qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-20 05:44:44 -07:00
Code Releases Activity

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

Browse Source 
This reverts commit 57ae83307f.

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>
This commit is contained in:
Robert Griesemer 2016-11-04 16:04:11 -07:00
parent c350c5cfdc
commit 2808f1f415
5 changed files with 32 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/go/ast/ast.go
View File

@ -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

4
src/go/ast/filter.go
View File

@ -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 {

10
src/go/ast/walk.go
View File

@ -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)

84
src/go/parser/parser.go
View File

@ -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)

2
src/go/parser/short_test.go
View File

@ -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) {