return n.line
}
-// TODO(gri) clean up init/initFrom once we have a good file pos story
func (n *node) init(p *parser) {
n.pos = uint32(p.pos)
n.line = uint32(p.line)
}
-func (n *node) initFrom(a *node) {
- n.pos = a.pos
- n.line = a.line
-}
-
// ----------------------------------------------------------------------------
// Files
-// package PkgName; DeclList[0], DeclList[1], ...
type File struct {
PkgName *Name
DeclList []Decl
aDecl()
}
- // Path
- // LocalPkgName Path
ImportDecl struct {
LocalPkgName *Name // including "."; nil means no rename present
Path *BasicLit
decl
}
- // Name => Orig
- AliasDecl struct {
- Tok token // Const, Type, Var, or Func
- Name *Name
- Orig Expr
- Group *Group // nil means not part of a group
- decl
- }
-
- // NameList
- // NameList = Values
- // NameList Type = Values
ConstDecl struct {
NameList []*Name
Type Expr // nil means no type
decl
}
- // Name Type
TypeDecl struct {
Name *Name
Type Expr
decl
}
- // NameList Type
- // NameList Type = Values
- // NameList = Values
VarDecl struct {
NameList []*Name
Type Expr // nil means no type
decl
}
- // func Name Type { Body }
- // func Name Type
- // func Receiver Name Type { Body }
- // func Receiver Name Type
FuncDecl struct {
Attr map[string]bool // go:attr map
Recv *Field // nil means regular function
// ----------------------------------------------------------------------------
// Comments
-// TODO(gri) Consider renaming to CommentPos, CommentPlacement, etc.
-// Kind = Above doesn't make much sense.
type CommentKind uint
const (
return d
}
-// AliasSpec = identifier "=>" [ PackageName "." ] identifier .
-func (p *parser) aliasDecl(tok token, name *Name, group *Group) Decl {
- // no tracing since this is already called from a const/type/var/funcDecl
-
- d := new(AliasDecl)
- d.initFrom(&name.node)
-
- // lhs identifier and "=>" have been consumed already
-
- d.Tok = tok
- d.Name = name
- d.Orig = p.dotname(p.name())
- d.Group = group
-
- return d
-}
-
-// ConstSpec = IdentifierList [ [ Type ] "=" ExpressionList ] | AliasSpec .
+// ConstSpec = IdentifierList [ [ Type ] "=" ExpressionList ] .
func (p *parser) constDecl(group *Group) Decl {
if trace {
defer p.trace("constDecl")()
}
- name := p.name()
- if p.got(_Rarrow) {
- return p.aliasDecl(Const, name, group)
- }
-
d := new(ConstDecl)
- d.initFrom(&name.node)
+ d.init(p)
- d.NameList = p.nameList(name)
+ d.NameList = p.nameList(p.name())
if p.tok != _EOF && p.tok != _Semi && p.tok != _Rparen {
d.Type = p.tryType()
if p.got(_Assign) {
return d
}
-// TypeSpec = identifier Type | AliasSpec .
+// TypeSpec = identifier Type .
func (p *parser) typeDecl(group *Group) Decl {
if trace {
defer p.trace("typeDecl")()
}
- name := p.name()
- if p.got(_Rarrow) {
- return p.aliasDecl(Type, name, group)
- }
-
d := new(TypeDecl)
- d.initFrom(&name.node)
+ d.init(p)
- d.Name = name
+ d.Name = p.name()
d.Type = p.tryType()
if d.Type == nil {
p.syntax_error("in type declaration")
return d
}
-// VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) | AliasSpec .
+// VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
func (p *parser) varDecl(group *Group) Decl {
if trace {
defer p.trace("varDecl")()
}
- name := p.name()
- if p.got(_Rarrow) {
- return p.aliasDecl(Var, name, group)
- }
-
d := new(VarDecl)
- d.initFrom(&name.node)
+ d.init(p)
- d.NameList = p.nameList(name)
+ d.NameList = p.nameList(p.name())
if p.got(_Assign) {
d.Values = p.exprList()
} else {
return d
}
-var badRecv = new(Field) // to signal invalid receiver in funcDecl
-
-// FunctionDecl = "func" FunctionName ( Function | Signature ) | "func" AliasSpec .
+// FunctionDecl = "func" FunctionName ( Function | Signature ) .
// FunctionName = identifier .
// Function = Signature FunctionBody .
// MethodDecl = "func" Receiver MethodName ( Function | Signature ) .
// Receiver = Parameters .
-func (p *parser) funcDecl() Decl {
+func (p *parser) funcDecl() *FuncDecl {
if trace {
defer p.trace("funcDecl")()
}
- var recv *Field
+ f := new(FuncDecl)
+ f.init(p)
+
+ badRecv := false
if p.tok == _Lparen {
- recv = badRecv
- switch list := p.paramList(); len(list) {
+ rcvr := p.paramList()
+ switch len(rcvr) {
case 0:
p.error("method has no receiver")
+ badRecv = true
case 1:
- recv = list[0]
+ f.Recv = rcvr[0]
default:
p.error("method has multiple receivers")
+ badRecv = true
}
}
return nil
}
- name := p.name()
- if recv == nil && p.got(_Rarrow) {
- return p.aliasDecl(Func, name, nil)
- }
-
// TODO(gri) check for regular functions only
// if name.Sym.Name == "init" {
// name = renameinit()
// }
// }
- f := new(FuncDecl)
- f.initFrom(&name.node) // TODO(gri) is this the correct position for methods?
-
- f.Recv = recv
- f.Name = name
+ f.Name = p.name()
f.Type = p.funcType()
if gcCompat {
f.node = f.Type.node
// p.error("can only use //go:noescape with external func implementations")
// }
- if recv == badRecv {
+ if badRecv {
return nil // TODO(gri) better solution
}
return f
return x
}
- case _Larrow:
+ case _Arrow:
// receive op (<-x) or receive-only channel (<-chan E)
p.next()
p.next()
return indirect(p.type_())
- case _Larrow:
+ case _Arrow:
// recvchantype
p.next()
p.want(_Chan)
p.next()
t := new(ChanType)
t.init(p)
- if p.got(_Larrow) {
+ if p.got(_Arrow) {
t.Dir = SendOnly
}
t.Elem = p.chanElem()
case _Name:
f.Name = p.name()
switch p.tok {
- case _Name, _Star, _Larrow, _Func, _Lbrack, _Chan, _Map, _Struct, _Interface, _Lparen:
+ case _Name, _Star, _Arrow, _Func, _Lbrack, _Chan, _Map, _Struct, _Interface, _Lparen:
// sym name_or_type
f.Type = p.type_()
f.Name = nil
}
- case _Larrow, _Star, _Func, _Lbrack, _Chan, _Map, _Struct, _Interface, _Lparen:
+ case _Arrow, _Star, _Func, _Lbrack, _Chan, _Map, _Struct, _Interface, _Lparen:
// name_or_type
f.Type = p.type_()
p.next()
return p.newAssignStmt(op, lhs, ImplicitOne)
- case _Larrow:
+ case _Arrow:
// lhs <- rhs
p.next()
s := new(SendStmt)
p.next()
lhs := p.exprList()
- if _, ok := lhs.(*ListExpr); !ok && p.tok == _Larrow {
+ if _, ok := lhs.(*ListExpr); !ok && p.tok == _Arrow {
// lhs <- x
} else {
// lhs
case _Literal, _Func, _Lparen, // operands
_Lbrack, _Struct, _Map, _Chan, _Interface, // composite types
- _Larrow: // receive operator
+ _Arrow: // receive operator
return p.simpleStmt(nil, false)
case _For: