Reimplement type aliases. Add a few type alias tests.

Author: nsf

_testing/DESC

@@ -51,3 +51,5 @@ test.0050 - anonymous struct pointer type as a function argument
 test.0051 - go parser stops parsing after 10 errors without AllErrors flag
 test.0052 - implicit type of a struct within slice/array literal
 test.0053 - type redefinition should not inherit method sets
+test.0054 - type alias dealiasing
+test.0055 - type alias inference

_testing/test.0054/cursor.168

@@ -0,0 +1,5 @@
+Found 4 candidates:
+  func Foobarer() string
+  var A int
+  var B int
+  var C float64

_testing/test.0054/out.expected

@@ -0,0 +1,16 @@
+package main
+
+type FooBar struct {
+	A int
+	B int
+	C float64
+}
+
+func (b *FooBar) Foobarer() string { return "foobarer" }
+
+type Bar = FooBar
+
+func main() {
+	var b Bar
+	b.
+}

_testing/test.0054/test.go.in

@@ -0,0 +1,4 @@
+Found 3 candidates:
+  var Jim string
+  var John string
+  var Kim string

_testing/test.0055/cursor.229

@@ -0,0 +1,21 @@
+package main
+
+type Baz struct {
+	Jim string
+	John string
+	Kim string
+}
+
+type FooBar struct {
+	A int
+	B int
+	C float64
+}
+
+func (b *FooBar) Foobarer() Baz { return Baz{} }
+
+func main() {
+	type Bar = FooBar
+	var b Bar
+	b.Foobarer().
+}

_testing/test.0055/out.expected

@@ -201,7 +201,28 @@ func (c *auto_complete_context) get_candidates_from_set(set map[string]*decl, pa
 	}
 }
 
+func (c *auto_complete_context) get_candidates_from_decl_alias(cc cursor_context, class decl_class, b *out_buffers) {
+	if cc.decl.flags&decl_visited != 0 {
+		return
+	}
+
+	cc.decl = cc.decl.type_dealias()
+	if cc.decl == nil {
+		return
+	}
+	cc.decl.flags |= decl_visited
+	defer cc.decl.clear_visited()
+
+	c.get_candidates_from_decl(cc, class, b)
+	return
+}
+
 func (c *auto_complete_context) get_candidates_from_decl(cc cursor_context, class decl_class, b *out_buffers) {
+	if cc.decl.class == decl_type_alias {
+		c.get_candidates_from_decl_alias(cc, class, b)
+		return
+	}
+
 	// propose all children of a subject declaration and
 	for _, decl := range cc.decl.children {
 		if cc.decl.class == decl_package && !ast.IsExported(decl.name) {
@@ -595,6 +616,7 @@ var g_decl_class_to_color = [...]string{
 	decl_const:        color_white_bold,
 	decl_var:          color_magenta,
 	decl_type:         color_cyan,
+	decl_type_alias:   color_cyan,
 	decl_func:         color_green,
 	decl_package:      color_red,
 	decl_methods_stub: color_red,
@@ -604,6 +626,7 @@ var g_decl_class_to_string_status = [...]string{
 	decl_const:        "  const",
 	decl_var:          "    var",
 	decl_type:         "   type",
+	decl_type_alias:   "   type",
 	decl_func:         "   func",
 	decl_package:      "package",
 	decl_methods_stub: "   stub",

_testing/test.0055/test.go.in

@@ -135,7 +135,7 @@ func (f *auto_complete_file) process_decl(decl ast.Decl) {
 	prevscope := f.scope
 	foreach_decl(decl, func(data *foreach_decl_struct) {
 		class := ast_decl_class(data.decl)
-		if class != decl_type {
+		if class != decl_type && class != decl_type_alias {
 			f.scope, prevscope = advance_scope(f.scope)
 		}
 		for i, name := range data.names {

autocompletecontext.go

@@ -23,6 +23,7 @@ const (
 	decl_import
 	decl_package
 	decl_type
+	decl_type_alias
 	decl_var
 
 	// this one serves as a temporary type for those methods that were
@@ -44,6 +45,8 @@ func (this decl_class) String() string {
 		return "package"
 	case decl_type:
 		return "type"
+	case decl_type_alias:
+		return "type"
 	case decl_var:
 		return "var"
 	case decl_methods_stub:
@@ -127,7 +130,11 @@ func ast_decl_class(d ast.Decl) decl_class {
 		case token.CONST:
 			return decl_const
 		case token.TYPE:
-			return decl_type
+			if t.Specs[0].(*ast.TypeSpec).Assign != 0 {
+				return decl_type_alias
+			} else {
+				return decl_type
+			}
 		}
 	case *ast.FuncDecl:
 		return decl_func
@@ -726,7 +733,7 @@ func infer_type(v ast.Expr, scope *scope, index int) (ast.Expr, *scope, bool) {
 				return ast.NewIdent(t.Name), scope, false
 			}
 			typ, scope := d.infer_type()
-			return typ, scope, d.class == decl_type
+			return typ, scope, d.class == decl_type || d.class == decl_type_alias
 		}
 	case *ast.UnaryExpr:
 		switch t.Op {
@@ -878,7 +885,7 @@ func infer_type(v ast.Expr, scope *scope, index int) (ast.Expr, *scope, bool) {
 		if d := type_to_decl(it, s); d != nil {
 			c := d.find_child_and_in_embedded(t.Sel.Name)
 			if c != nil {
-				if c.class == decl_type {
+				if c.class == decl_type || c.class == decl_type_alias {
 					return t, scope, true
 				} else {
 					typ, s := c.infer_type()
@@ -927,7 +934,7 @@ func (d *decl) infer_type() (ast.Expr, *scope) {
 	case decl_package:
 		// package is handled specially in inferType
 		return nil, nil
-	case decl_type:
+	case decl_type, decl_type_alias:
 		return ast.NewIdent(d.name), d.scope
 	}
 
@@ -948,13 +955,31 @@ func (d *decl) infer_type() (ast.Expr, *scope) {
 	return d.typ, scope
 }
 
+func (d *decl) type_dealias() *decl {
+	dd := type_to_decl(d.typ, d.scope)
+	return dd
+}
+
 func (d *decl) find_child(name string) *decl {
 	if d.flags&decl_visited != 0 {
 		return nil
 	}
 	d.flags |= decl_visited
 	defer d.clear_visited()
 
+	// type aliases don't really have any children on their own, but they
+	// point to a different type, let's try to find one
+	if d.class == decl_type_alias {
+		dd := d.type_dealias()
+		if dd != nil {
+			return dd.find_child(name)
+		}
+
+		// note that type alias can also point to a type literal, something like
+		// type A = struct { A int }
+		// in this case we rely on "advance_to_struct_or_interface" below
+	}
+
 	if d.children != nil {
 		if c, ok := d.children[name]; ok {
 			return c
@@ -1301,11 +1326,6 @@ func (f *decl_pack) value_index(i int) (v ast.Expr, vi int) {
 
 func (f *decl_pack) type_value_index(i int) (ast.Expr, ast.Expr, int) {
 	if f.typ != nil {
-		// If there is a type and have f.values, it's type alias decl.
-		// Return the both of type and first value.
-		if len(f.values) == 1 {
-			return f.typ, f.values[0], -1
-		}
 		// If there is a type, we don't care about value, just return the type
 		// and zero value.
 		return f.typ, nil, -1

autocompletefile.go

@@ -121,18 +121,6 @@ func append_to_top_decls(decls map[string]*decl, decl ast.Decl, scope *scope) {
 		for i, name := range data.names {
 			typ, v, vi := data.type_value_index(i)
 
-			// If typ is *ast.Ident, it holds the underlying type of type alias.
-			// Replace the typ to underlying types ast.Expr.
-			if id, ok := typ.(*ast.Ident); ok && id.Obj != nil {
-				if t, ok := id.Obj.Decl.(*ast.TypeSpec); ok {
-					if d, ok := decls[t.Name.Name]; ok {
-						scope.typealias[name.Name] = d
-					}
-
-					typ = t.Type
-				}
-			}
-
 			d := new_decl_full(name.Name, class, 0, typ, v, vi, scope)
 			if d == nil {
 				return
@@ -142,11 +130,6 @@ func append_to_top_decls(decls map[string]*decl, decl ast.Decl, scope *scope) {
 			if methodof != "" {
 				decl, ok := decls[methodof]
 				if ok {
-					if d, ok := scope.typealias[methodof]; ok {
-						for _, d := range d.children {
-							decl.add_child(d)
-						}
-					}
 					decl.add_child(d)
 				} else {
 					decl = new_decl(methodof, decl_methods_stub, scope)

decl.go

@@ -216,8 +216,9 @@ func (p *gc_bin_parser) obj(tag int) {
 			Tok: token.TYPE,
 			Specs: []ast.Spec{
 				&ast.TypeSpec{
-					Name: ast.NewIdent(name),
-					Type: typ,
+					Name:   ast.NewIdent(name),
+					Assign: 1, // fake, but gocode only cares if it's there or not
+					Type:   typ,
 				},
 			},
 		})

declcache.go

@@ -5,16 +5,14 @@ package main
 //-------------------------------------------------------------------------
 
 type scope struct {
-	parent    *scope // nil for universe scope
-	entities  map[string]*decl
-	typealias map[string]*decl
+	parent   *scope // nil for universe scope
+	entities map[string]*decl
 }
 
 func new_scope(outer *scope) *scope {
 	s := new(scope)
 	s.parent = outer
 	s.entities = make(map[string]*decl)
-	s.typealias = make(map[string]*decl)
 	return s
 }