rename

Author: wzshiming

parser_types.go

@@ -106,7 +106,7 @@ func (r *parser) EvalType(expr ast.Expr) Type {
 			if v.Names == nil {
 				t := &typeStructField{
 					name: ty.Name(),
-					typ:  ty,
+					elem: ty,
 					tag:  tag,
 				}
 				s.anonymo.Add(t)
@@ -115,7 +115,7 @@ func (r *parser) EvalType(expr ast.Expr) Type {
 			for _, name := range v.Names {
 				t := &typeStructField{
 					name: name.Name,
-					typ:  ty,
+					elem: ty,
 					tag:  tag,
 				}
 				s.fields.Add(t)

types_array.go

@@ -4,27 +4,27 @@ import "fmt"
 
 func newTypeArray(v Type, l int) Type {
 	return &typeArray{
-		val: v,
-		le:  l,
+		elem: v,
+		le:   l,
 	}
 }
 
 type typeArray struct {
 	typeBase
-	le  int
-	val Type
+	le   int
+	elem Type
 }
 
 func (t *typeArray) String() string {
-	return fmt.Sprintf("[%v]%v", t.le, t.val)
+	return fmt.Sprintf("[%v]%v", t.le, t.elem)
 }
 
 func (t *typeArray) Kind() Kind {
 	return Array
 }
 
 func (t *typeArray) Elem() Type {
-	return t.val
+	return t.elem
 }
 
 func (t *typeArray) Len() int {

types_chan.go

@@ -4,34 +4,34 @@ import "fmt"
 
 func newTypeChan(v Type, dir ChanDir) Type {
 	return &typeChan{
-		val: v,
-		dir: dir,
+		elem: v,
+		dir:  dir,
 	}
 }
 
 type typeChan struct {
 	typeBase
-	dir ChanDir
-	val Type
+	dir  ChanDir
+	elem Type
 }
 
 func (t *typeChan) String() string {
 	switch t.dir {
 	case RecvDir:
-		return fmt.Sprintf("<-chan %v", t.val)
+		return fmt.Sprintf("<-chan %v", t.elem)
 	case SendDir:
-		return fmt.Sprintf("chan<- %v", t.val)
+		return fmt.Sprintf("chan<- %v", t.elem)
 	case BothDir:
 	}
-	return fmt.Sprintf("chan %v", t.val)
+	return fmt.Sprintf("chan %v", t.elem)
 }
 
 func (t *typeChan) Kind() Kind {
 	return Chan
 }
 
 func (t *typeChan) Elem() Type {
-	return t.val
+	return t.elem
 }
 
 func (t *typeChan) ChanDir() ChanDir {

types_func.go

@@ -18,10 +18,10 @@ func (t *typeFunc) String() string {
 		}
 		if t.variadic && i+1 == len(t.results) {
 			if d, ok := v.(*typeVar); ok {
-				if d0, ok := d.typ.(*typeSlice); ok {
+				if d0, ok := d.elem.(*typeSlice); ok {
 					buf.WriteString(d.name)
 					buf.WriteString(" ...")
-					buf.WriteString(d0.val.String())
+					buf.WriteString(d0.elem.String())
 					continue
 				}
 			}

types_map.go

@@ -4,18 +4,18 @@ import "fmt"
 
 func newTypeMap(k, v Type) Type {
 	return &typeMap{
-		key: k,
-		val: v,
+		key:  k,
+		elem: v,
 	}
 }
 
 type typeMap struct {
 	typeBase
-	key, val Type
+	key, elem Type
 }
 
 func (t *typeMap) String() string {
-	return fmt.Sprintf("map[%v]%v", t.key, t.val)
+	return fmt.Sprintf("map[%v]%v", t.key, t.elem)
 }
 
 func (t *typeMap) Kind() Kind {
@@ -27,5 +27,5 @@ func (t *typeMap) Key() Type {
 }
 
 func (t *typeMap) Elem() Type {
-	return t.val
+	return t.elem
 }

types_ptr.go

@@ -4,23 +4,23 @@ import "fmt"
 
 func newTypePtr(elem Type) Type {
 	return &typePtr{
-		typ: elem,
+		elem: elem,
 	}
 }
 
 type typePtr struct {
 	typeBase
-	typ Type
+	elem Type
 }
 
 func (t *typePtr) String() string {
-	return fmt.Sprintf("*%v", t.typ)
+	return fmt.Sprintf("*%v", t.elem)
 }
 
 func (y *typePtr) Kind() Kind {
 	return Ptr
 }
 
 func (t *typePtr) Elem() Type {
-	return t.typ
+	return t.elem
 }

types_slice.go

@@ -6,23 +6,23 @@ import (
 
 func newTypeSlice(v Type) Type {
 	return &typeSlice{
-		val: v,
+		elem: v,
 	}
 }
 
 type typeSlice struct {
 	typeBase
-	val Type
+	elem Type
 }
 
 func (t *typeSlice) String() string {
-	return fmt.Sprintf("[]%v", t.val.String())
+	return fmt.Sprintf("[]%v", t.elem.String())
 }
 
 func (t *typeSlice) Kind() Kind {
 	return Slice
 }
 
 func (t *typeSlice) Elem() Type {
-	return t.val
+	return t.elem
 }

types_struct_field.go

@@ -8,20 +8,20 @@ import (
 type typeStructField struct {
 	typeBase
 	name string
-	typ  Type              // 字段类型
+	elem Type              // 字段类型
 	tag  reflect.StructTag // 字段标签
 }
 
 func (t *typeStructField) String() string {
-	return fmt.Sprintf("%v %v %v", t.name, t.typ, t.tag)
+	return fmt.Sprintf("%v %v %v", t.name, t.elem, t.tag)
 }
 
 func (t *typeStructField) Name() string {
 	return t.name
 }
 
 func (t *typeStructField) Elem() Type {
-	return t.typ
+	return t.elem
 }
 
 func (t *typeStructField) Kind() Kind {

types_var.go

@@ -5,18 +5,18 @@ func newTypeVar(name string, typ Type) *typeVar {
 	if ok {
 		return &typeVar{
 			name: name,
-			typ:  v.typ,
+			elem: v.elem,
 		}
 	}
 	return &typeVar{
 		name: name,
-		typ:  typ,
+		elem: typ,
 	}
 }
 
 type typeVar struct {
 	typeBase
-	typ  Type
+	elem Type
 	name string
 }
 
@@ -33,5 +33,5 @@ func (t *typeVar) Kind() Kind {
 }
 
 func (t *typeVar) Elem() Type {
-	return t.typ
+	return t.elem
 }