Revert "go/ast, go/parser: parse alias declarations"

This reverts commit 57ae83307fc4cb90338b39dcc6fe3c61ee8ce0b7.

Reason: Decision to back out current alias implementation.

For #16339.

Change-Id: I7bcc04ac87ea3590999e58ff65a7f2e1e6c6bc77
Reviewed-on: https://go-review.googlesource.com/32823
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

5 files changed, 32 insertions, 96 deletions

diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index 8ffbaf9869..b6dc2a6c16 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -818,7 +818,7 @@ func (*RangeStmt) stmtNode()      {}
 // constant, type, or variable declaration.
 //
 type (
-	// The Spec type stands for any of *ImportSpec, *AliasSpec, *ValueSpec, or *TypeSpec.
+	// The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.
 	Spec interface {
 		Node
 		specNode()
@@ -833,14 +833,6 @@ type (
 		EndPos  token.Pos     // end of spec (overrides Path.Pos if nonzero)
 	}
 
-	// An AliasSpec node represents a constant, type, variable, or function alias.
-	AliasSpec struct {
-		Doc     *CommentGroup // associated documentation; or nil
-		Name    *Ident        // alias name
-		Orig    Expr          // original (possibly qualified) name
-		Comment *CommentGroup // line comments; or nil
-	}
-
 	// A ValueSpec node represents a constant or variable declaration
 	// (ConstSpec or VarSpec production).
 	//
@@ -869,7 +861,6 @@ func (s *ImportSpec) Pos() token.Pos {
 	}
 	return s.Path.Pos()
 }
-func (s *AliasSpec) Pos() token.Pos { return s.Name.Pos() }
 func (s *ValueSpec) Pos() token.Pos { return s.Names[0].Pos() }
 func (s *TypeSpec) Pos() token.Pos  { return s.Name.Pos() }
 
@@ -879,7 +870,7 @@ func (s *ImportSpec) End() token.Pos {
 	}
 	return s.Path.End()
 }
-func (s *AliasSpec) End() token.Pos { return s.Orig.End() }
+
 func (s *ValueSpec) End() token.Pos {
 	if n := len(s.Values); n > 0 {
 		return s.Values[n-1].End()
@@ -895,7 +886,6 @@ func (s *TypeSpec) End() token.Pos { return s.Type.End() }
 // assigned to a Spec.
 //
 func (*ImportSpec) specNode() {}
-func (*AliasSpec) specNode()  {}
 func (*ValueSpec) specNode()  {}
 func (*TypeSpec) specNode()   {}
 
@@ -911,22 +901,20 @@ type (
 	}
 
 	// A GenDecl node (generic declaration node) represents an import,
-	// constant, type, or variable declaration, or a function alias
-	// declaration. A valid Lparen position (Lparen.Line > 0) indicates
-	// a parenthesized declaration.
+	// constant, type or variable declaration. A valid Lparen position
+	// (Lparen.Line > 0) indicates a parenthesized declaration.
 	//
 	// Relationship between Tok value and Specs element type:
 	//
 	//	token.IMPORT  *ImportSpec
-	//	token.CONST   *ValueSpec or *AliasSpec
-	//	token.TYPE    *TypeSpec  or *AliasSpec
-	//	token.VAR     *ValueSpec or *AliasSpec
-	//	token.FUNC                  *AliasSpec
+	//	token.CONST   *ValueSpec
+	//	token.TYPE    *TypeSpec
+	//	token.VAR     *ValueSpec
 	//
 	GenDecl struct {
 		Doc    *CommentGroup // associated documentation; or nil
 		TokPos token.Pos     // position of Tok
-		Tok    token.Token   // IMPORT, CONST, TYPE, VAR, FUNC (alias decl only)
+		Tok    token.Token   // IMPORT, CONST, TYPE, VAR
 		Lparen token.Pos     // position of '(', if any
 		Specs  []Spec
 		Rparen token.Pos // position of ')', if any
diff --git a/src/go/ast/filter.go b/src/go/ast/filter.go
index bd0bf87f11..bb571166f4 100644
--- a/src/go/ast/filter.go
+++ b/src/go/ast/filter.go
@@ -156,10 +156,6 @@ func filterType(typ Expr, f Filter, export bool) bool {
 
 func filterSpec(spec Spec, f Filter, export bool) bool {
 	switch s := spec.(type) {
-	case *AliasSpec:
-		if f(s.Name.Name) {
-			return true
-		}
 	case *ValueSpec:
 		s.Names = filterIdentList(s.Names, f)
 		if len(s.Names) > 0 {
diff --git a/src/go/ast/walk.go b/src/go/ast/walk.go
index b474e1e29a..8ca21959b1 100644
--- a/src/go/ast/walk.go
+++ b/src/go/ast/walk.go
@@ -297,16 +297,6 @@ func Walk(v Visitor, node Node) {
 			Walk(v, n.Comment)
 		}
 
-	case *AliasSpec:
-		if n.Doc != nil {
-			Walk(v, n.Doc)
-		}
-		Walk(v, n.Name)
-		Walk(v, n.Orig)
-		if n.Comment != nil {
-			Walk(v, n.Comment)
-		}
-
 	case *ValueSpec:
 		if n.Doc != nil {
 			Walk(v, n.Doc)
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 375ae03e86..d3ef7db31e 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -542,18 +542,18 @@ func (p *parser) parseIdent() *ast.Ident {
 	return &ast.Ident{NamePos: pos, Name: name}
 }
 
-func (p *parser) parseIdentList(first *ast.Ident) []*ast.Ident {
+func (p *parser) parseIdentList() (list []*ast.Ident) {
 	if p.trace {
 		defer un(trace(p, "IdentList"))
 	}
 
-	list := []*ast.Ident{first}
+	list = append(list, p.parseIdent())
 	for p.tok == token.COMMA {
 		p.next()
 		list = append(list, p.parseIdent())
 	}
 
-	return list
+	return
 }
 
 // ----------------------------------------------------------------------------
@@ -640,10 +640,11 @@ func (p *parser) parseTypeName() ast.Expr {
 	// don't resolve ident yet - it may be a parameter or field name
 
 	if p.tok == token.PERIOD {
-		// ident must be a package name
+		// ident is a package name
 		p.next()
 		p.resolve(ident)
-		return &ast.SelectorExpr{X: ident, Sel: p.parseIdent()}
+		sel := p.parseIdent()
+		return &ast.SelectorExpr{X: ident, Sel: sel}
 	}
 
 	return ident
@@ -841,7 +842,7 @@ func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params [
 		}
 		p.next()
 		for p.tok != token.RPAREN && p.tok != token.EOF {
-			idents := p.parseIdentList(p.parseIdent())
+			idents := p.parseIdentList()
 			typ := p.parseVarType(ellipsisOk)
 			field := &ast.Field{Names: idents, Type: typ}
 			params = append(params, field)
@@ -1169,6 +1170,16 @@ func (p *parser) parseOperand(lhs bool) ast.Expr {
 	return &ast.BadExpr{From: pos, To: p.pos}
 }
 
+func (p *parser) parseSelector(x ast.Expr) ast.Expr {
+	if p.trace {
+		defer un(trace(p, "Selector"))
+	}
+
+	sel := p.parseIdent()
+
+	return &ast.SelectorExpr{X: x, Sel: sel}
+}
+
 func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
 	if p.trace {
 		defer un(trace(p, "TypeAssertion"))
@@ -1463,7 +1474,7 @@ L:
 			}
 			switch p.tok {
 			case token.IDENT:
-				x = &ast.SelectorExpr{X: p.checkExprOrType(x), Sel: p.parseIdent()}
+				x = p.parseSelector(p.checkExprOrType(x))
 			case token.LPAREN:
 				x = p.parseTypeAssertion(p.checkExpr(x))
 			default:
@@ -2256,51 +2267,13 @@ func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Token, _ int) as
 	return spec
 }
 
-// AliasSpec = identifier "=>" [ PackageName "." ] identifier .
-func (p *parser) parseAliasSpec(doc *ast.CommentGroup, kind ast.ObjKind, ident *ast.Ident) ast.Spec {
-	// no tracing since this is already called from a parse(Value/Type)Spec or parseFuncDecl
-
-	// lhs identifier and "=>" have been consumed already
-
-	var orig ast.Expr = p.parseIdent()
-	if p.tok == token.PERIOD {
-		// orig must be a package name
-		p.next()
-		p.resolve(orig)
-		orig = &ast.SelectorExpr{X: orig, Sel: p.parseIdent()}
-	}
-
-	p.expectSemi() // call before accessing p.linecomment
-
-	spec := &ast.AliasSpec{
-		Doc:     doc,
-		Name:    ident,
-		Orig:    orig,
-		Comment: p.lineComment,
-	}
-	p.declare(spec, nil, p.topScope, kind, ident)
-
-	return spec
-}
-
 func (p *parser) parseValueSpec(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec {
 	if p.trace {
 		defer un(trace(p, keyword.String()+"Spec"))
 	}
 
-	kind := ast.Con
-	if keyword == token.VAR {
-		kind = ast.Var
-	}
-
 	pos := p.pos
-	ident := p.parseIdent()
-	if p.tok == token.ALIAS {
-		p.next()
-		return p.parseAliasSpec(doc, kind, ident)
-	}
-
-	idents := p.parseIdentList(ident)
+	idents := p.parseIdentList()
 	typ := p.tryType()
 	var values []ast.Expr
 	// always permit optional initialization for more tolerant parsing
@@ -2332,6 +2305,10 @@ func (p *parser) parseValueSpec(doc *ast.CommentGroup, keyword token.Token, iota
 		Values:  values,
 		Comment: p.lineComment,
 	}
+	kind := ast.Con
+	if keyword == token.VAR {
+		kind = ast.Var
+	}
 	p.declare(spec, iota, p.topScope, kind, idents...)
 
 	return spec
@@ -2343,10 +2320,6 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.
 	}
 
 	ident := p.parseIdent()
-	if p.tok == token.ALIAS {
-		p.next()
-		return p.parseAliasSpec(doc, ast.Typ, ident)
-	}
 
 	// Go spec: The scope of a type identifier declared inside a function begins
 	// at the identifier in the TypeSpec and ends at the end of the innermost
@@ -2393,7 +2366,7 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.Gen
 	}
 }
 
-func (p *parser) parseFuncDecl() ast.Decl {
+func (p *parser) parseFuncDecl() *ast.FuncDecl {
 	if p.trace {
 		defer un(trace(p, "FunctionDecl"))
 	}
@@ -2408,15 +2381,6 @@ func (p *parser) parseFuncDecl() ast.Decl {
 	}
 
 	ident := p.parseIdent()
-	if recv == nil && p.tok == token.ALIAS {
-		p.next()
-		return &ast.GenDecl{
-			Doc:    doc,
-			TokPos: pos,
-			Tok:    token.FUNC,
-			Specs:  []ast.Spec{p.parseAliasSpec(nil, ast.Fun, ident)},
-		}
-	}
 
 	params, results := p.parseSignature(scope)
 
diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go
index 514dd4c90c..cdd343ea3c 100644
--- a/src/go/parser/short_test.go
+++ b/src/go/parser/short_test.go
@@ -46,8 +46,6 @@ var valids = []string{
 	`package p; const (x = 0; y; z)`, // issue 9639
 	`package p; var _ = map[P]int{P{}:0, {}:1}`,
 	`package p; var _ = map[*P]int{&P{}:0, {}:1}`,
-	`package p; const c => p.C; var x => X; type T => p.T; func F => p.F`,
-	`package p; var (_ int; x => p.X; y => Y); type (t => T; t1 => p.T1)`,
 }
 
 func TestValid(t *testing.T) {