From 2808f1f41583ef9943b1d7426d7affa6cfc998ba Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 4 Nov 2016 16:04:11 -0700 Subject: [PATCH] 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 --- src/go/ast/ast.go | 28 ++++--------- src/go/ast/filter.go | 4 -- src/go/ast/walk.go | 10 ----- src/go/parser/parser.go | 84 +++++++++++-------------------------- src/go/parser/short_test.go | 2 - 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) {