prog: rename {PtrType,ArrayType}.Type to Elem

Name "Type" is confusing when referring to pointer/array element type.
Frequently there are too many Type/typ/typ1/t and typ.Type is not very informative.
It _is_ a type, but what's usually more relevant is that it's an _element_ type.
Let's leave type checking to compiler and give it a more meaningful name.

16 files changed, 59 insertions, 60 deletions

diff --git a/pkg/compiler/gen.go b/pkg/compiler/gen.go
index 61dd85eae..07f35d71f 100644
--- a/pkg/compiler/gen.go
+++ b/pkg/compiler/gen.go
@@ -179,9 +179,9 @@ func (comp *compiler) collectTypes(proxies map[string]*typeProxy, tptr *prog.Typ
 	typ := *tptr
 	switch t := typ.(type) {
 	case *prog.PtrType:
-		comp.collectTypes(proxies, &t.Type)
+		comp.collectTypes(proxies, &t.Elem)
 	case *prog.ArrayType:
-		comp.collectTypes(proxies, &t.Type)
+		comp.collectTypes(proxies, &t.Elem)
 	case *prog.ResourceType, *prog.BufferType, *prog.VmaType, *prog.LenType,
 		*prog.FlagsType, *prog.ConstType, *prog.IntType, *prog.ProcType,
 		*prog.CsumType, *prog.StructType, *prog.UnionType:
@@ -277,7 +277,7 @@ func (ctx *structGen) check(key prog.StructKey, descp **prog.StructDesc) bool {
 func (ctx *structGen) walk(t0 prog.Type) {
 	switch t := t0.(type) {
 	case *prog.PtrType:
-		ctx.walk(t.Type)
+		ctx.walk(t.Elem)
 	case *prog.ArrayType:
 		ctx.walkArray(t)
 	case *prog.StructType:
@@ -291,16 +291,16 @@ func (ctx *structGen) walkArray(t *prog.ArrayType) {
 	if ctx.padded[t] {
 		return
 	}
-	ctx.walk(t.Type)
-	if !t.Type.Varlen() && t.Type.Size() == sizeUnassigned {
+	ctx.walk(t.Elem)
+	if !t.Elem.Varlen() && t.Elem.Size() == sizeUnassigned {
 		// An inner struct is not padded yet.
 		// Leave this array for next iteration.
 		return
 	}
 	ctx.padded[t] = true
 	t.TypeSize = 0
-	if t.Kind == prog.ArrayRangeLen && t.RangeBegin == t.RangeEnd && !t.Type.Varlen() {
-		t.TypeSize = t.RangeBegin * t.Type.Size()
+	if t.Kind == prog.ArrayRangeLen && t.RangeBegin == t.RangeEnd && !t.Elem.Varlen() {
+		t.TypeSize = t.RangeBegin * t.Elem.Size()
 	}
 }
 
@@ -535,7 +535,7 @@ func (comp *compiler) typeAlign(t0 prog.Type) uint64 {
 	case *prog.BufferType:
 		return 1
 	case *prog.ArrayType:
-		return comp.typeAlign(t.Type)
+		return comp.typeAlign(t.Elem)
 	case *prog.StructType:
 		n := comp.structNodes[t.StructDesc]
 		attrs := comp.parseAttrs(structAttrs, n, n.Attrs)
diff --git a/pkg/compiler/types.go b/pkg/compiler/types.go
index 6f2c26a6e..bf542c511 100644
--- a/pkg/compiler/types.go
+++ b/pkg/compiler/types.go
@@ -162,7 +162,7 @@ var typePtr = &typeDesc{
 		}
 		return &prog.PtrType{
 			TypeCommon: base.TypeCommon,
-			Type:       comp.genType(args[1], "", 0),
+			Elem:       comp.genType(args[1], "", 0),
 			ElemDir:    genDir(args[0]),
 		}
 	},
@@ -240,7 +240,7 @@ var typeArray = &typeDesc{
 		// TypeSize is assigned later in genStructDescs.
 		return &prog.ArrayType{
 			TypeCommon: base.TypeCommon,
-			Type:       elemType,
+			Elem:       elemType,
 			Kind:       kind,
 			RangeBegin: begin,
 			RangeEnd:   end,
diff --git a/pkg/host/syscalls_linux.go b/pkg/host/syscalls_linux.go
index dd89733c0..184bf6410 100644
--- a/pkg/host/syscalls_linux.go
+++ b/pkg/host/syscalls_linux.go
@@ -403,7 +403,7 @@ func extractStringConst(typ prog.Type) (string, bool) {
 	if !ok {
 		panic("first open arg is not a pointer to string const")
 	}
-	str, ok := ptr.Type.(*prog.BufferType)
+	str, ok := ptr.Elem.(*prog.BufferType)
 	if !ok || str.Kind != prog.BufferString || len(str.Values) == 0 {
 		return "", false
 	}
diff --git a/prog/any.go b/prog/any.go
index d1433b18d..6e90698b9 100644
--- a/prog/any.go
+++ b/prog/any.go
@@ -45,7 +45,7 @@ func initAnyTypes(target *Target) {
 			FldName:  "ANYARRAY",
 			IsVarlen: true,
 		},
-		Type: target.any.union,
+		Elem: target.any.union,
 	}
 	target.any.ptrPtr = &PtrType{
 		TypeCommon: TypeCommon{
@@ -54,7 +54,7 @@ func initAnyTypes(target *Target) {
 			TypeSize:   target.PtrSize,
 			IsOptional: true,
 		},
-		Type:    target.any.array,
+		Elem:    target.any.array,
 		ElemDir: DirIn,
 	}
 	target.any.ptr64 = &PtrType{
@@ -64,7 +64,7 @@ func initAnyTypes(target *Target) {
 			TypeSize:   8,
 			IsOptional: true,
 		},
-		Type:    target.any.array,
+		Elem:    target.any.array,
 		ElemDir: DirIn,
 	}
 	target.any.blob = &BufferType{
@@ -134,7 +134,7 @@ func (target *Target) makeAnyPtrType(size uint64, field string) *PtrType {
 
 func (target *Target) isAnyPtr(typ Type) bool {
 	ptr, ok := typ.(*PtrType)
-	return ok && ptr.Type == target.any.array
+	return ok && ptr.Elem == target.any.array
 }
 
 func (p *Prog) complexPtrs() (res []*PointerArg) {
@@ -217,7 +217,7 @@ func (target *Target) squashPtr(arg *PointerArg, preserveField bool) {
 		field = arg.Type().FieldName()
 	}
 	arg.typ = target.makeAnyPtrType(arg.Type().Size(), field)
-	arg.Res = MakeGroupArg(arg.typ.(*PtrType).Type, DirIn, elems)
+	arg.Res = MakeGroupArg(arg.typ.(*PtrType).Elem, DirIn, elems)
 	if size := arg.Res.Size(); size != size0 {
 		panic(fmt.Sprintf("squash changed size %v->%v for %v", size0, size, res0.Type()))
 	}
diff --git a/prog/encoding.go b/prog/encoding.go
index c7f8ba56a..38935b302 100644
--- a/prog/encoding.go
+++ b/prog/encoding.go
@@ -451,12 +451,11 @@ func (p *parser) parseArgRes(typ Type, dir Dir) (Arg, error) {
 }
 
 func (p *parser) parseArgAddr(typ Type, dir Dir) (Arg, error) {
-	var typ1 Type
+	var elem Type
 	elemDir := DirInOut
 	switch t1 := typ.(type) {
 	case *PtrType:
-		typ1 = t1.Type
-		elemDir = t1.ElemDir
+		elem, elemDir = t1.Elem, t1.ElemDir
 	case *VmaType:
 	default:
 		p.eatExcessive(true, "wrong addr arg")
@@ -470,7 +469,7 @@ func (p *parser) parseArgAddr(typ Type, dir Dir) (Arg, error) {
 		p.Parse('U')
 		p.Parse('T')
 		p.Parse('O')
-		if typ1 == nil {
+		if elem == nil {
 			return nil, fmt.Errorf("vma type can't be AUTO")
 		}
 		auto = true
@@ -490,15 +489,15 @@ func (p *parser) parseArgAddr(typ Type, dir Dir) (Arg, error) {
 			p.Parse('Y')
 			p.Parse('=')
 			anyPtr := p.target.makeAnyPtrType(typ.Size(), typ.FieldName())
-			typ, typ1, elemDir = anyPtr, anyPtr.Type, anyPtr.ElemDir
+			typ, elem, elemDir = anyPtr, anyPtr.Elem, anyPtr.ElemDir
 		}
 		var err error
-		inner, err = p.parseArg(typ1, elemDir)
+		inner, err = p.parseArg(elem, elemDir)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if typ1 == nil {
+	if elem == nil {
 		if addr%p.target.PageSize != 0 {
 			p.strictFailf("unaligned vma address 0x%x", addr)
 			addr &= ^(p.target.PageSize - 1)
@@ -506,7 +505,7 @@ func (p *parser) parseArgAddr(typ Type, dir Dir) (Arg, error) {
 		return MakeVmaPointerArg(typ, dir, addr, vmaSize), nil
 	}
 	if inner == nil {
-		inner = typ1.DefaultArg(elemDir)
+		inner = elem.DefaultArg(elemDir)
 	}
 	arg := MakePointerArg(typ, dir, addr, inner)
 	if auto {
@@ -618,7 +617,7 @@ func (p *parser) parseArgArray(typ Type, dir Dir) (Arg, error) {
 	}
 	var inner []Arg
 	for i := 0; p.Char() != ']'; i++ {
-		arg, err := p.parseArg(t1.Type, dir)
+		arg, err := p.parseArg(t1.Elem, dir)
 		if err != nil {
 			return nil, err
 		}
@@ -631,7 +630,7 @@ func (p *parser) parseArgArray(typ Type, dir Dir) (Arg, error) {
 	if t1.Kind == ArrayRangeLen && t1.RangeBegin == t1.RangeEnd {
 		for uint64(len(inner)) < t1.RangeBegin {
 			p.strictFailf("missing array elements")
-			inner = append(inner, t1.Type.DefaultArg(dir))
+			inner = append(inner, t1.Elem.DefaultArg(dir))
 		}
 		inner = inner[:t1.RangeBegin]
 	}
diff --git a/prog/mutation.go b/prog/mutation.go
index 7087b4d86..ada2febdb 100644
--- a/prog/mutation.go
+++ b/prog/mutation.go
@@ -412,7 +412,7 @@ func (t *ArrayType) mutate(r *randGen, s *state, arg Arg, ctx ArgCtx) (calls []*
 	}
 	if count > uint64(len(a.Inner)) {
 		for count > uint64(len(a.Inner)) {
-			newArg, newCalls := r.generateArg(s, t.Type, a.Dir())
+			newArg, newCalls := r.generateArg(s, t.Elem, a.Dir())
 			a.Inner = append(a.Inner, newArg)
 			calls = append(calls, newCalls...)
 			for _, c := range newCalls {
diff --git a/prog/prio.go b/prog/prio.go
index 2a9486570..43668d48d 100644
--- a/prog/prio.go
+++ b/prog/prio.go
@@ -82,14 +82,14 @@ func (target *Target) calcResourceUsage() map[string]map[int]weights {
 					}
 				}
 			case *PtrType:
-				if _, ok := a.Type.(*StructType); ok {
-					noteUsage(uses, c, 1.0, ctx.Dir, "ptrto-%v", a.Type.Name())
+				if _, ok := a.Elem.(*StructType); ok {
+					noteUsage(uses, c, 1.0, ctx.Dir, "ptrto-%v", a.Elem.Name())
 				}
-				if _, ok := a.Type.(*UnionType); ok {
-					noteUsage(uses, c, 1.0, ctx.Dir, "ptrto-%v", a.Type.Name())
+				if _, ok := a.Elem.(*UnionType); ok {
+					noteUsage(uses, c, 1.0, ctx.Dir, "ptrto-%v", a.Elem.Name())
 				}
-				if arr, ok := a.Type.(*ArrayType); ok {
-					noteUsage(uses, c, 1.0, ctx.Dir, "ptrto-%v", arr.Type.Name())
+				if arr, ok := a.Elem.(*ArrayType); ok {
+					noteUsage(uses, c, 1.0, ctx.Dir, "ptrto-%v", arr.Elem.Name())
 				}
 			case *BufferType:
 				switch a.Kind {
diff --git a/prog/rand.go b/prog/rand.go
index 5277a9814..603996114 100644
--- a/prog/rand.go
+++ b/prog/rand.go
@@ -644,9 +644,9 @@ func (r *randGen) generateArgImpl(s *state, typ Type, dir Dir, ignoreSpecial boo
 
 	// Allow infinite recursion for optional pointers.
 	if pt, ok := typ.(*PtrType); ok && typ.Optional() {
-		switch pt.Type.(type) {
+		switch pt.Elem.(type) {
 		case *StructType, *ArrayType, *UnionType:
-			name := pt.Type.Name()
+			name := pt.Elem.Name()
 			r.recDepth[name]++
 			defer func() {
 				r.recDepth[name]--
@@ -783,7 +783,7 @@ func (a *ArrayType) generate(r *randGen, s *state, dir Dir) (arg Arg, calls []*C
 	}
 	var inner []Arg
 	for i := uint64(0); i < count; i++ {
-		arg1, calls1 := r.generateArg(s, a.Type, dir)
+		arg1, calls1 := r.generateArg(s, a.Elem, dir)
 		inner = append(inner, arg1)
 		calls = append(calls, calls1...)
 	}
@@ -807,7 +807,7 @@ func (a *PtrType) generate(r *randGen, s *state, dir Dir) (arg Arg, calls []*Cal
 		index := r.rand(len(r.target.SpecialPointers))
 		return MakeSpecialPointerArg(a, dir, index), nil
 	}
-	inner, calls := r.generateArg(s, a.Type, a.ElemDir)
+	inner, calls := r.generateArg(s, a.Elem, a.ElemDir)
 	arg = r.allocAddr(s, a, dir, inner.Size(), inner)
 	return arg, calls
 }
diff --git a/prog/size.go b/prog/size.go
index 3b0bf0b0f..a7fdb093e 100644
--- a/prog/size.go
+++ b/prog/size.go
@@ -162,10 +162,10 @@ func (r *randGen) mutateSize(arg *ConstArg, parent []Arg) bool {
 					case *VmaType:
 						return false
 					case *ArrayType:
-						if targetType.Type.Varlen() {
+						if targetType.Elem.Varlen() {
 							return false
 						}
-						elemSize = targetType.Type.Size()
+						elemSize = targetType.Elem.Size()
 					}
 				}
 				break
diff --git a/prog/target.go b/prog/target.go
index 692d0b877..f71730b1b 100644
--- a/prog/target.go
+++ b/prog/target.go
@@ -200,9 +200,9 @@ func restoreLinks(syscalls []*Syscall, resources []*ResourceDesc, structs []*Key
 		foreachType(c, func(t0 Type, _ typeCtx) {
 			switch t := t0.(type) {
 			case *PtrType:
-				unref(&t.Type, types)
+				unref(&t.Elem, types)
 			case *ArrayType:
-				unref(&t.Type, types)
+				unref(&t.Elem, types)
 			case *ResourceType:
 				t.Desc = resourceMap[t.TypeName]
 				if t.Desc == nil {
diff --git a/prog/types.go b/prog/types.go
index a3b3c9709..2d9e8659c 100644
--- a/prog/types.go
+++ b/prog/types.go
@@ -521,21 +521,21 @@ const (
 
 type ArrayType struct {
 	TypeCommon
-	Type       Type
+	Elem       Type
 	Kind       ArrayKind
 	RangeBegin uint64
 	RangeEnd   uint64
 }
 
 func (t *ArrayType) String() string {
-	return fmt.Sprintf("array[%v]", t.Type.String())
+	return fmt.Sprintf("array[%v]", t.Elem.String())
 }
 
 func (t *ArrayType) DefaultArg(dir Dir) Arg {
 	var elems []Arg
 	if t.Kind == ArrayRangeLen && t.RangeBegin == t.RangeEnd {
 		for i := uint64(0); i < t.RangeBegin; i++ {
-			elems = append(elems, t.Type.DefaultArg(dir))
+			elems = append(elems, t.Elem.DefaultArg(dir))
 		}
 	}
 	return MakeGroupArg(t, dir, elems)
@@ -556,19 +556,19 @@ func (t *ArrayType) isDefaultArg(arg Arg) bool {
 
 type PtrType struct {
 	TypeCommon
-	Type    Type
+	Elem    Type
 	ElemDir Dir
 }
 
 func (t *PtrType) String() string {
-	return fmt.Sprintf("ptr[%v, %v]", t.ElemDir, t.Type.String())
+	return fmt.Sprintf("ptr[%v, %v]", t.ElemDir, t.Elem.String())
 }
 
 func (t *PtrType) DefaultArg(dir Dir) Arg {
 	if t.Optional() {
 		return MakeSpecialPointerArg(t, dir, 0)
 	}
-	return MakePointerArg(t, dir, 0, t.Type.DefaultArg(t.ElemDir))
+	return MakePointerArg(t, dir, 0, t.Elem.DefaultArg(t.ElemDir))
 }
 
 func (t *PtrType) isDefaultArg(arg Arg) bool {
@@ -678,9 +678,9 @@ func foreachType(meta *Syscall, f func(t Type, ctx typeCtx)) {
 		f(t, typeCtx{Dir: dir})
 		switch a := t.(type) {
 		case *PtrType:
-			rec(a.Type, a.ElemDir)
+			rec(a.Elem, a.ElemDir)
 		case *ArrayType:
-			rec(a.Type, dir)
+			rec(a.Elem, dir)
 		case *StructType:
 			recStruct(a.StructDesc, dir)
 		case *UnionType:
diff --git a/prog/validation.go b/prog/validation.go
index 8ec0615da..54b288905 100644
--- a/prog/validation.go
+++ b/prog/validation.go
@@ -203,7 +203,7 @@ func (arg *GroupArg) validate(ctx *validCtx) error {
 				typ.Name(), len(arg.Inner), typ.RangeBegin)
 		}
 		for _, elem := range arg.Inner {
-			if err := ctx.validateArg(elem, typ.Type, arg.Dir()); err != nil {
+			if err := ctx.validateArg(elem, typ.Elem, arg.Dir()); err != nil {
 				return err
 			}
 		}
@@ -239,7 +239,7 @@ func (arg *PointerArg) validate(ctx *validCtx) error {
 		}
 	case *PtrType:
 		if arg.Res != nil {
-			if err := ctx.validateArg(arg.Res, typ.Type, typ.ElemDir); err != nil {
+			if err := ctx.validateArg(arg.Res, typ.Elem, typ.ElemDir); err != nil {
 				return err
 			}
 		}
diff --git a/sys/linux/init.go b/sys/linux/init.go
index 9a6eaf62e..0ad4bfeee 100644
--- a/sys/linux/init.go
+++ b/sys/linux/init.go
@@ -321,7 +321,7 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, dir prog.Dir, ol
 		// Few ms ahead for absolute.
 		meta := arch.clockGettimeSyscall
 		ptrArgType := meta.Args[1].(*prog.PtrType)
-		argType := ptrArgType.Type.(*prog.StructType)
+		argType := ptrArgType.Elem.(*prog.StructType)
 		tp := prog.MakeGroupArg(argType, prog.DirOut, []prog.Arg{
 			prog.MakeResultArg(argType.Fields[0], prog.DirOut, nil, 0),
 			prog.MakeResultArg(argType.Fields[1], prog.DirOut, nil, 0),
diff --git a/tools/syz-check/check.go b/tools/syz-check/check.go
index 490a48c3f..45506261a 100644
--- a/tools/syz-check/check.go
+++ b/tools/syz-check/check.go
@@ -510,7 +510,7 @@ func isNetlinkPolicy(typ *prog.StructDesc) bool {
 			continue
 		}
 		if arr, ok := field.(*prog.ArrayType); ok {
-			field = arr.Type
+			field = arr.Elem
 		}
 		if field1, ok := field.(*prog.StructType); ok {
 			if isNetlinkPolicy(field1.StructDesc) {
@@ -629,8 +629,8 @@ func minTypeSize(typ prog.Type) int {
 		return size
 	}
 	if arr, ok := typ.(*prog.ArrayType); ok {
-		if arr.Kind == prog.ArrayRangeLen && !arr.Type.Varlen() {
-			return int(arr.RangeBegin * arr.Type.Size())
+		if arr.Kind == prog.ArrayRangeLen && !arr.Elem.Varlen() {
+			return int(arr.RangeBegin * arr.Elem.Size())
 		}
 	}
 	return -1
diff --git a/tools/syz-trace2syz/proggen/call_selector.go b/tools/syz-trace2syz/proggen/call_selector.go
index 886c82636..4808432a3 100644
--- a/tools/syz-trace2syz/proggen/call_selector.go
+++ b/tools/syz-trace2syz/proggen/call_selector.go
@@ -145,7 +145,7 @@ func (cs *openCallSelector) matchOpen(meta *prog.Syscall, call *parser.Syscall)
 	if _, ok := syzFileArg.(*prog.PtrType); !ok {
 		return false, -1
 	}
-	syzBuf := syzFileArg.(*prog.PtrType).Type.(*prog.BufferType)
+	syzBuf := syzFileArg.(*prog.PtrType).Elem.(*prog.BufferType)
 	if syzBuf.Kind != prog.BufferString {
 		return false, -1
 	}
@@ -228,7 +228,7 @@ func (cs *defaultCallSelector) matchCall(meta *prog.Syscall, call *parser.Syscal
 				return -1
 			}
 		case *prog.PtrType:
-			switch r := t.Type.(type) {
+			switch r := t.Elem.(type) {
 			case *prog.BufferType:
 				matched := false
 				buffer, ok := arg.(*parser.BufferType)
diff --git a/tools/syz-trace2syz/proggen/proggen.go b/tools/syz-trace2syz/proggen/proggen.go
index 1189fe2ac..371050c56 100644
--- a/tools/syz-trace2syz/proggen/proggen.go
+++ b/tools/syz-trace2syz/proggen/proggen.go
@@ -201,7 +201,7 @@ func (ctx *context) genArray(syzType *prog.ArrayType, dir prog.Dir, traceType pa
 	switch a := traceType.(type) {
 	case *parser.GroupType:
 		for i := 0; i < len(a.Elems); i++ {
-			args = append(args, ctx.genArg(syzType.Type, dir, a.Elems[i]))
+			args = append(args, ctx.genArg(syzType.Elem, dir, a.Elems[i]))
 		}
 	default:
 		log.Fatalf("unsupported type for array: %#v", traceType)
@@ -361,10 +361,10 @@ func (ctx *context) genPtr(syzType *prog.PtrType, dir prog.Dir, traceType parser
 			return prog.MakeSpecialPointerArg(syzType, dir, 0)
 		}
 		// Likely have a type of the form bind(3, 0xfffffffff, [3]);
-		res := syzType.Type.DefaultArg(syzType.ElemDir)
+		res := syzType.Elem.DefaultArg(syzType.ElemDir)
 		return ctx.addr(syzType, dir, res.Size(), res)
 	default:
-		res := ctx.genArg(syzType.Type, syzType.ElemDir, a)
+		res := ctx.genArg(syzType.Elem, syzType.ElemDir, a)
 		return ctx.addr(syzType, dir, res.Size(), res)
 	}
 }