code review 4271061: go/parser: resolve identifiers properly

src/pkg/go/parser/parser.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // A parser for Go source files. Input may be provided in a variety of
 // forms (see the various Parse* functions); the output is an abstract
 // syntax tree (AST) representing the Go source. The parser is invoked
 // through one of the Parse* functions.
 //
 package parser
@@ skipping 37 matching lines @@
 
         // Next token
         pos  token.Pos   // token position
         tok  token.Token // one token look-ahead
         lit_ []byte      // token literal (slice into original source, don't hold on to it)
 
         // Non-syntactic parser control
         exprLev int // < 0: in control clause, >= 0: in expression
 
         // Ordinary identifer scopes
-        pkgScope   *ast.Scope   // pkgScope.Outer == nil
-        topScope   *ast.Scope   // top-most scope; may be pkgScope
-        unresolved []*ast.Ident // unresolved global identifiers
+        pkgScope   *ast.Scope        // pkgScope.Outer == nil
+        topScope   *ast.Scope        // top-most scope; may be pkgScope
+        unresolved []*ast.Ident      // unresolved identifiers
+        imports    []*ast.ImportSpec // list of imports
 
         // Label scope
         // (maintained by open/close LabelScope)
         labelScope  *ast.Scope     // label scope for current function
         targetStack [][]*ast.Ident // stack of unresolved labels
 }
 
 
 // scannerMode returns the scanner mode bits given the parser's mode bits.
 func scannerMode(mode uint) uint {
@@ skipping 63 matching lines @@
                 }
         }
         // pop label scope
         p.targetStack = p.targetStack[0:n]
         p.labelScope = p.labelScope.Outer
 }
 
 
 func (p *parser) declare(decl interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) {
         for _, ident := range idents {
+                assert(ident.Obj == nil, "identifier already declared or resolved")
                 if ident.Name != "_" {
                         obj := ast.NewObj(kind, ident.Name)
                         // remember the corresponding declaration for redeclaration
                         // errors and global variable resolution/typechecking phase
                         obj.Decl = decl
                         alt := scope.Insert(obj)
                         if alt != obj && p.mode&DeclarationErrors != 0 {
                                 prevDecl := ""
                                 if pos := alt.Pos(); pos.IsValid() {
                                         prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.file.Position(pos))
                                 }
                                 p.error(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
                         }
                         ident.Obj = obj
                 }
         }
 }
 
 
 func (p *parser) shortVarDecl(idents []*ast.Ident) {
         // Go spec: A short variable declaration may redeclare variables
         // provided they were originally declared in the same block with
         // the same type, and at least one of the non-blank variables is new.
         n := 0 // number of new variables
         for _, ident := range idents {
+                assert(ident.Obj == nil, "identifier already declared or resolved")
                 if ident.Name != "_" {
                         obj := ast.NewObj(ast.Var, ident.Name)
                         // short var declarations cannot have redeclaration errors
                         // and are not global => no need to remember the respective
                         // declaration
                         alt := p.topScope.Insert(obj)
                         if alt == obj {
                                 n++ // new declaration
                         }
                         ident.Obj = alt
                 }
         }
         if n == 0 && p.mode&DeclarationErrors != 0 {
                 p.error(idents[0].Pos(), "no new variables on left side of :=")
         }
 }
 
 
-func (p *parser) resolve(ident *ast.Ident) {
+// The unresolved object is a sentinel to mark identifiers that have been added
+// to the list of unresolved identifiers. The sentinel is only used for verifying
+// internal consistency.
+var unresolved = new(ast.Object)
+
+
+func (p *parser) resolve(x ast.Expr) {
+        // nothing to do if x is not an identifier or the blank identifier
+        ident, _ := x.(*ast.Ident)
+        if ident == nil {
+                return
+        }
+        assert(ident.Obj == nil, "identifier already declared or resolved")
         if ident.Name == "_" {
                 return
         }
         // try to resolve the identifier
         for s := p.topScope; s != nil; s = s.Outer {
                 if obj := s.Lookup(ident.Name); obj != nil {
                         ident.Obj = obj
                         return
                 }
         }
-        // collect unresolved global identifiers; ignore the others
-        if p.topScope == p.pkgScope {
-                p.unresolved = append(p.unresolved, ident)
-        }
+        // all local scopes are known, so any unresolved identifier
+        // must be found either in the file scope, package scope
+        // (perhaps in another file), or universe scope --- collect
+        // them so that they can be resolved later
+        ident.Obj = unresolved
+        p.unresolved = append(p.unresolved, ident)
 }
 
 
 // ----------------------------------------------------------------------------
 // Parsing support
 
 func (p *parser) printTrace(a ...interface{}) {
         const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
                 ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
         const n = uint(len(dots))
@@ skipping 169 matching lines @@
 }
 
 
 func (p *parser) expectSemi() {
         if p.tok != token.RPAREN && p.tok != token.RBRACE {
                 p.expect(token.SEMICOLON)
         }
 }
 
 
+func assert(cond bool, msg string) {
+        if !cond {
+                panic("go/parser internal error: " + msg)
+        }
+}
+
+
 // ----------------------------------------------------------------------------
 // Identifiers
 
 func (p *parser) parseIdent() *ast.Ident {
         pos := p.pos
         name := "_"
         if p.tok == token.IDENT {
                 name = string(p.lit_)
                 p.next()
         } else {
@@ skipping 14 matching lines @@
                 list = append(list, p.parseIdent())
         }
 
         return
 }
 
 
 // ----------------------------------------------------------------------------
 // Common productions
 
-func (p *parser) parseExprList() (list []ast.Expr) {
+// If lhs is set, result list elements which are identifiers are not resolved.
+func (p *parser) parseExprList(lhs bool) (list []ast.Expr) {
         if p.trace {
                 defer un(trace(p, "ExpressionList"))
         }
 
-        list = append(list, p.parseExpr())
+        list = append(list, p.parseExpr(lhs))
         for p.tok == token.COMMA {
                 p.next()
-                list = append(list, p.parseExpr())
+                list = append(list, p.parseExpr(lhs))
         }
 
         return
 }
 
 
+func (p *parser) parseLhsList() []ast.Expr {
+        list := p.parseExprList(true)
+        switch p.tok {
+        case token.DEFINE:
+                // lhs of a short variable declaration
+                p.shortVarDecl(p.makeIdentList(list))
+        case token.COLON:
+                // lhs of a label declaration or a communication clause of a select
+                // statement (parseLhsList is not called when parsing the case clause
+                // of a switch statement):
+                // - labels are declared by the caller of parseLhsList
+                // - for communication clauses, if there is a stand-alone identifier
+                //   followed by a colon, we have a syntax error; there is no need
+                //   to resolve the identifier in that case
+        default:
+                // identifiers must be declared elsewhere
+                for _, x := range list {
+                        p.resolve(x)
+                }
+        }
+        return list
+}
+
+
+func (p *parser) parseRhsList() []ast.Expr {
+        return p.parseExprList(false)
+}
+
+
 // ----------------------------------------------------------------------------
 // Types
 
 func (p *parser) parseType() ast.Expr {
         if p.trace {
                 defer un(trace(p, "Type"))
         }
 
         typ := p.tryType()
 
         if typ == nil {
                 pos := p.pos
                 p.errorExpected(pos, "type")
                 p.next() // make progress
                 return &ast.BadExpr{pos, p.pos}
         }
 
         return typ
 }
 
 
-func (p *parser) parseQualifiedIdent() ast.Expr {
-        if p.trace {
-                defer un(trace(p, "QualifiedIdent"))
-        }
-
-        ident := p.parseIdent()
-        p.resolve(ident)
-        var x ast.Expr = ident
-        if p.tok == token.PERIOD {
-                // first identifier is a package identifier
-                p.next()
-                sel := p.parseIdent()
-                x = &ast.SelectorExpr{x, sel}
-        }
-
-        return x
-}
-
-
+// If the result is an identifier, it is not resolved.
 func (p *parser) parseTypeName() ast.Expr {
         if p.trace {
                 defer un(trace(p, "TypeName"))
         }
 
-        return p.parseQualifiedIdent()
+        ident := p.parseIdent()
+        // don't resolve ident yet - it may be a parameter or field name
+
+        if p.tok == token.PERIOD {
+                // ident is a package name
+                p.next()
+                p.resolve(ident)
+                sel := p.parseIdent()
+                return &ast.SelectorExpr{ident, sel}
+        }
+
+        return ident
 }
 
 
 func (p *parser) parseArrayType(ellipsisOk bool) ast.Expr {
         if p.trace {
                 defer un(trace(p, "ArrayType"))
         }
 
         lbrack := p.expect(token.LBRACK)
         var len ast.Expr
         if ellipsisOk && p.tok == token.ELLIPSIS {
                 len = &ast.Ellipsis{p.pos, nil}
                 p.next()
         } else if p.tok != token.RBRACK {
-                len = p.parseExpr()
+                len = p.parseRhs()
         }
         p.expect(token.RBRACK)
         elt := p.parseType()
 
         return &ast.ArrayType{lbrack, len, elt}
 }
 
 
 func (p *parser) makeIdentList(list []ast.Expr) []*ast.Ident {
         idents := make([]*ast.Ident, len(list))
         for i, x := range list {
                 ident, isIdent := x.(*ast.Ident)
                 if !isIdent {
                         pos := x.(ast.Expr).Pos()
                         p.errorExpected(pos, "identifier")
                         ident = &ast.Ident{pos, "_", nil}
                 }
                 idents[i] = ident
         }
         return idents
 }
 
 
-func (p *parser) parseFieldDecl() *ast.Field {
+func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
         if p.trace {
                 defer un(trace(p, "FieldDecl"))
         }
 
         doc := p.leadComment
 
         // fields
         list, typ := p.parseVarList(false)
 
         // optional tag
         var tag *ast.BasicLit
         if p.tok == token.STRING {
                 tag = &ast.BasicLit{p.pos, p.tok, p.lit()}
                 p.next()
         }
 
         // analyze case
         var idents []*ast.Ident
         if typ != nil {
                 // IdentifierList Type
                 idents = p.makeIdentList(list)
         } else {
                 // ["*"] TypeName (AnonymousField)
                 typ = list[0] // we always have at least one element
+                p.resolve(typ)
                 if n := len(list); n > 1 || !isTypeName(deref(typ)) {
                         pos := typ.Pos()
                         p.errorExpected(pos, "anonymous field")
                         typ = &ast.BadExpr{pos, list[n-1].End()}
                 }
         }
 
         p.expectSemi() // call before accessing p.linecomment
 
-        return &ast.Field{doc, idents, typ, tag, p.lineComment}
+        field := &ast.Field{doc, idents, typ, tag, p.lineComment}
+        p.declare(field, scope, ast.Var, idents...)
+
+        return field
 }
 
 
 func (p *parser) parseStructType() *ast.StructType {
         if p.trace {
                 defer un(trace(p, "StructType"))
         }
 
         pos := p.expect(token.STRUCT)
         lbrace := p.expect(token.LBRACE)
+        scope := ast.NewScope(nil) // struct scope
         var list []*ast.Field
         for p.tok == token.IDENT || p.tok == token.MUL || p.tok == token.LPAREN {
                 // a field declaration cannot start with a '(' but we accept
                 // it here for more robust parsing and better error messages
                 // (parseFieldDecl will check and complain if necessary)
-                list = append(list, p.parseFieldDecl())
+                list = append(list, p.parseFieldDecl(scope))
         }
         rbrace := p.expect(token.RBRACE)
 
+        // TODO(gri): store struct scope in AST
         return &ast.StructType{pos, &ast.FieldList{lbrace, list, rbrace}, false}
 }
 
 
 func (p *parser) parsePointerType() *ast.StarExpr {
         if p.trace {
                 defer un(trace(p, "PointerType"))
         }
 
         star := p.expect(token.MUL)
         base := p.parseType()
 
         return &ast.StarExpr{star, base}
 }
 
 
 func (p *parser) tryVarType(isParam bool) ast.Expr {
         if isParam && p.tok == token.ELLIPSIS {
                 pos := p.pos
                 p.next()
-                typ := p.tryType() // don't use parseType so we can provide better error message
+                typ := p.tryIdentOrType(isParam) // don't use parseType so we can provide better error message
                 if typ == nil {
                         p.error(pos, "'...' parameter is missing type")
                         typ = &ast.BadExpr{pos, p.pos}
                 }
                 if p.tok != token.RPAREN {
                         p.error(pos, "can use '...' with last parameter type only")
                 }
                 return &ast.Ellipsis{pos, typ}
         }
-        return p.tryType()
+        return p.tryIdentOrType(false)
 }
 
 
 func (p *parser) parseVarType(isParam bool) ast.Expr {
         typ := p.tryVarType(isParam)
         if typ == nil {
                 pos := p.pos
                 p.errorExpected(pos, "type")
                 p.next() // make progress
                 typ = &ast.BadExpr{pos, p.pos}
@@ skipping 15 matching lines @@
                 // afterwards
                 list = append(list, p.parseVarType(isParam))
                 if p.tok != token.COMMA {
                         break
                 }
                 p.next()
         }
 
         // if we had a list of identifiers, it must be followed by a type
         typ = p.tryVarType(isParam)
+        if typ != nil {
+                p.resolve(typ)
+        }
 
         return
 }
 
 
 func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params []*ast.Field) {
         if p.trace {
                 defer un(trace(p, "ParameterList"))
         }
 
@@ skipping 21 matching lines @@
                         if p.tok != token.COMMA {
                                 break
                         }
                         p.next()
                 }
 
         } else {
                 // Type { "," Type } (anonymous parameters)
                 params = make([]*ast.Field, len(list))
                 for i, x := range list {
+                        p.resolve(x)
                         params[i] = &ast.Field{Type: x}
                 }
         }
 
         return
 }
 
 
 func (p *parser) parseParameters(scope *ast.Scope, ellipsisOk bool) *ast.FieldList {
         if p.trace {
@@ skipping 49 matching lines @@
         }
 
         pos := p.expect(token.FUNC)
         scope := ast.NewScope(p.topScope) // function scope
         params, results := p.parseSignature(scope)
 
         return &ast.FuncType{pos, params, results}, scope
 }
 
 
-func (p *parser) parseMethodSpec() *ast.Field {
+func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
         if p.trace {
                 defer un(trace(p, "MethodSpec"))
         }
 
         doc := p.leadComment
         var idents []*ast.Ident
         var typ ast.Expr
-        x := p.parseQualifiedIdent()
+        x := p.parseTypeName()
         if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
                 // method
                 idents = []*ast.Ident{ident}
                 scope := ast.NewScope(nil) // method scope
                 params, results := p.parseSignature(scope)
                 typ = &ast.FuncType{token.NoPos, params, results}
         } else {
                 // embedded interface
                 typ = x
         }
         p.expectSemi() // call before accessing p.linecomment
 
-        return &ast.Field{doc, idents, typ, nil, p.lineComment}
+        spec := &ast.Field{doc, idents, typ, nil, p.lineComment}
+        p.declare(spec, scope, ast.Fun, idents...)
+
+        return spec
 }
 
 
 func (p *parser) parseInterfaceType() *ast.InterfaceType {
         if p.trace {
                 defer un(trace(p, "InterfaceType"))
         }
 
         pos := p.expect(token.INTERFACE)
         lbrace := p.expect(token.LBRACE)
+        scope := ast.NewScope(nil) // interface scope
         var list []*ast.Field
         for p.tok == token.IDENT {
-                list = append(list, p.parseMethodSpec())
+                list = append(list, p.parseMethodSpec(scope))
         }
         rbrace := p.expect(token.RBRACE)
 
+        // TODO(gri): store interface scope in AST
         return &ast.InterfaceType{pos, &ast.FieldList{lbrace, list, rbrace}, false}
 }
 
 
 func (p *parser) parseMapType() *ast.MapType {
         if p.trace {
                 defer un(trace(p, "MapType"))
         }
 
         pos := p.expect(token.MAP)
@@ skipping 23 matching lines @@
                 p.expect(token.ARROW)
                 p.expect(token.CHAN)
                 dir = ast.RECV
         }
         value := p.parseType()
 
         return &ast.ChanType{pos, dir, value}
 }
 
 
-func (p *parser) tryRawType(ellipsisOk bool) ast.Expr {
+// If the result is an identifier, it is not resolved.
+func (p *parser) tryIdentOrType(ellipsisOk bool) ast.Expr {
         switch p.tok {
         case token.IDENT:
                 return p.parseTypeName()
         case token.LBRACK:
                 return p.parseArrayType(ellipsisOk)
         case token.STRUCT:
                 return p.parseStructType()
         case token.MUL:
                 return p.parsePointerType()
         case token.FUNC:
@@ skipping 11 matching lines @@
                 typ := p.parseType()
                 rparen := p.expect(token.RPAREN)
                 return &ast.ParenExpr{lparen, typ, rparen}
         }
 
         // no type found
         return nil
 }
 
 
-func (p *parser) tryType() ast.Expr { return p.tryRawType(false) }
+func (p *parser) tryType() ast.Expr {
+        typ := p.tryIdentOrType(false)
+        if typ != nil {
+                p.resolve(typ)
+        }
+        return typ
+}
 
 
 // ----------------------------------------------------------------------------
 // Blocks
 
 func (p *parser) parseStmtList() (list []ast.Stmt) {
         if p.trace {
                 defer un(trace(p, "StatementList"))
         }
 
@@ skipping 54 matching lines @@
         p.exprLev++
         body := p.parseBody(scope)
         p.exprLev--
 
         return &ast.FuncLit{typ, body}
 }
 
 
 // parseOperand may return an expression or a raw type (incl. array
 // types of the form [...]T. Callers must verify the result.
+// If lhs is set and the result is an identifier, it is not resolved.
 //
-func (p *parser) parseOperand() ast.Expr {
+func (p *parser) parseOperand(lhs bool) ast.Expr {
         if p.trace {
                 defer un(trace(p, "Operand"))
         }
 
         switch p.tok {
         case token.IDENT:
-                ident := p.parseIdent()
-                p.resolve(ident)
-                return ident
+                x := p.parseIdent()
+                if !lhs {
+                        p.resolve(x)
+                }
+                return x
 
         case token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING:
                 x := &ast.BasicLit{p.pos, p.tok, p.lit()}
                 p.next()
                 return x
 
         case token.LPAREN:
                 lparen := p.pos
                 p.next()
                 p.exprLev++
-                x := p.parseExpr()
+                x := p.parseRhs()
                 p.exprLev--
                 rparen := p.expect(token.RPAREN)
                 return &ast.ParenExpr{lparen, x, rparen}
 
         case token.FUNC:
                 return p.parseFuncTypeOrLit()
 
         default:
-                t := p.tryRawType(true) // could be type for composite literal or conversion
-                if t != nil {
-                        return t
+                if typ := p.tryIdentOrType(true); typ != nil {
+                        // could be type for composite literal or conversion
+                        _, isIdent := typ.(*ast.Ident)
+                        assert(!isIdent, "type cannot be identifier")
+                        return typ
                 }
         }
 
         pos := p.pos
         p.errorExpected(pos, "operand")
         p.next() // make progress
         return &ast.BadExpr{pos, p.pos}
 }
 
 
-func (p *parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr {
+func (p *parser) parseSelector(x ast.Expr) ast.Expr {
         if p.trace {
-                defer un(trace(p, "SelectorOrTypeAssertion"))
+                defer un(trace(p, "Selector"))
         }
 
-        p.expect(token.PERIOD)
-        if p.tok == token.IDENT {
-                // selector
-                sel := p.parseIdent()
-                return &ast.SelectorExpr{x, sel}
+        sel := p.parseIdent()
+
+        return &ast.SelectorExpr{x, sel}
+}
+
+
+func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
+        if p.trace {
+                defer un(trace(p, "TypeAssertion"))
         }
 
-        // type assertion
         p.expect(token.LPAREN)
         var typ ast.Expr
         if p.tok == token.TYPE {
                 // type switch: typ == nil
                 p.next()
         } else {
                 typ = p.parseType()
         }
         p.expect(token.RPAREN)
 
         return &ast.TypeAssertExpr{x, typ}
 }
 
 
 func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
         if p.trace {
                 defer un(trace(p, "IndexOrSlice"))
         }
 
         lbrack := p.expect(token.LBRACK)
         p.exprLev++
         var low, high ast.Expr
         isSlice := false
         if p.tok != token.COLON {
-                low = p.parseExpr()
+                low = p.parseRhs()
         }
         if p.tok == token.COLON {
                 isSlice = true
                 p.next()
                 if p.tok != token.RBRACK {
-                        high = p.parseExpr()
+                        high = p.parseRhs()
                 }
         }
         p.exprLev--
         rbrack := p.expect(token.RBRACK)
 
         if isSlice {
                 return &ast.SliceExpr{x, lbrack, low, high, rbrack}
         }
         return &ast.IndexExpr{x, lbrack, low, rbrack}
 }
 
 
 func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
         if p.trace {
                 defer un(trace(p, "CallOrConversion"))
         }
 
         lparen := p.expect(token.LPAREN)
         p.exprLev++
         var list []ast.Expr
         var ellipsis token.Pos
         for p.tok != token.RPAREN && p.tok != token.EOF && !ellipsis.IsValid() {
-                list = append(list, p.parseExpr())
+                list = append(list, p.parseRhs())
                 if p.tok == token.ELLIPSIS {
                         ellipsis = p.pos
                         p.next()
                 }
                 if p.tok != token.COMMA {
                         break
                 }
                 p.next()
         }
         p.exprLev--
         rparen := p.expect(token.RPAREN)
 
         return &ast.CallExpr{fun, lparen, list, ellipsis, rparen}
 }
 
 
 func (p *parser) parseElement(keyOk bool) ast.Expr {
         if p.trace {
                 defer un(trace(p, "Element"))
         }
 
         if p.tok == token.LBRACE {
                 return p.parseLiteralValue(nil)
         }
 
-        x := p.parseExpr()
+        x := p.parseRhs()
         if keyOk && p.tok == token.COLON {
                 colon := p.pos
                 p.next()
                 x = &ast.KeyValueExpr{x, colon, p.parseElement(false)}
         }
         return x
 }
 
 
 func (p *parser) parseElementList() (list []ast.Expr) {
@@ skipping 136 matching lines @@
                         p.error(len.Pos(), "expected array length, found '...'")
                         x = &ast.BadExpr{x.Pos(), x.End()}
                 }
         }
 
         // all other nodes are expressions or types
         return x
 }
 
 
-func (p *parser) parsePrimaryExpr() ast.Expr {
+// If lhs is set and the result is an identifier, it is not resolved.
+func (p *parser) parsePrimaryExpr(lhs bool) ast.Expr {
         if p.trace {
                 defer un(trace(p, "PrimaryExpr"))
         }
 
-        x := p.parseOperand()
+        x := p.parseOperand(lhs)
 L:
         for {
                 switch p.tok {
                 case token.PERIOD:
-                        x = p.parseSelectorOrTypeAssertion(p.checkExpr(x))
+                        p.next()
+                        if lhs {
+                                p.resolve(x)
+                        }
+                        switch p.tok {
+                        case token.IDENT:
+                                x = p.parseSelector(p.checkExpr(x))
+                        case token.LPAREN:
+                                x = p.parseTypeAssertion(p.checkExpr(x))
+                        default:
+                                pos := p.pos
+                                p.next() // make progress
+                                p.errorExpected(pos, "selector or type assertion")
+                                x = &ast.BadExpr{pos, p.pos}
+                        }
                 case token.LBRACK:
+                        if lhs {
+                                p.resolve(x)
+                        }
                         x = p.parseIndexOrSlice(p.checkExpr(x))
                 case token.LPAREN:
+                        if lhs {
+                                p.resolve(x)
+                        }
                         x = p.parseCallOrConversion(p.checkExprOrType(x))
                 case token.LBRACE:
                         if isLiteralType(x) && (p.exprLev >= 0 || !isTypeName(x)) {
+                                if lhs {
+                                        p.resolve(x)
+                                }
                                 x = p.parseLiteralValue(x)
                         } else {
                                 break L
                         }
                 default:
                         break L
                 }
+                lhs = false // no need to try to resolve again
         }
 
         return x
 }
 
 
-func (p *parser) parseUnaryExpr() ast.Expr {
+// If lhs is set and the result is an identifier, it is not resolved.
+func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
         if p.trace {
                 defer un(trace(p, "UnaryExpr"))
         }
 
         switch p.tok {
         case token.ADD, token.SUB, token.NOT, token.XOR, token.AND, token.RANGE:
                 pos, op := p.pos, p.tok
                 p.next()
-                x := p.parseUnaryExpr()
+                x := p.parseUnaryExpr(false)
                 return &ast.UnaryExpr{pos, op, p.checkExpr(x)}
 
         case token.ARROW:
                 // channel type or receive expression
                 pos := p.pos
                 p.next()
                 if p.tok == token.CHAN {
                         p.next()
                         value := p.parseType()
                         return &ast.ChanType{pos, ast.RECV, value}
                 }
 
-                x := p.parseUnaryExpr()
+                x := p.parseUnaryExpr(false)
                 return &ast.UnaryExpr{pos, token.ARROW, p.checkExpr(x)}
 
         case token.MUL:
                 // pointer type or unary "*" expression
                 pos := p.pos
                 p.next()
-                x := p.parseUnaryExpr()
+                x := p.parseUnaryExpr(false)
                 return &ast.StarExpr{pos, p.checkExprOrType(x)}
         }
 
-        return p.parsePrimaryExpr()
+        return p.parsePrimaryExpr(lhs)
 }
 
 
-func (p *parser) parseBinaryExpr(prec1 int) ast.Expr {
+// If lhs is set and the result is an identifier, it is not resolved.
+func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
         if p.trace {
                 defer un(trace(p, "BinaryExpr"))
         }
 
-        x := p.parseUnaryExpr()
+        x := p.parseUnaryExpr(lhs)
         for prec := p.tok.Precedence(); prec >= prec1; prec-- {
                 for p.tok.Precedence() == prec {
                         pos, op := p.pos, p.tok
                         p.next()
-                        y := p.parseBinaryExpr(prec + 1)
+                        if lhs {
+                                p.resolve(x)
+                                lhs = false
+                        }
+                        y := p.parseBinaryExpr(false, prec+1)
                         x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)}
                 }
         }
 
         return x
 }
 
 
+// If lhs is set and the result is an identifier, it is not resolved.
 // TODO(gri): parseExpr may return a type or even a raw type ([..]int) -
 //            should reject when a type/raw type is obviously not allowed
-func (p *parser) parseExpr() ast.Expr {
+func (p *parser) parseExpr(lhs bool) ast.Expr {
         if p.trace {
                 defer un(trace(p, "Expression"))
         }
 
-        return p.parseBinaryExpr(token.LowestPrec + 1)
+        return p.parseBinaryExpr(lhs, token.LowestPrec+1)
 }
 
 
+func (p *parser) parseRhs() ast.Expr {
+        return p.parseExpr(false)
+}
+
+
 // ----------------------------------------------------------------------------
 // Statements
 
 func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
         if p.trace {
                 defer un(trace(p, "SimpleStmt"))
         }
 
-        x := p.parseExprList()
+        x := p.parseLhsList()
 
         switch p.tok {
         case
                 token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
                 token.SUB_ASSIGN, token.MUL_ASSIGN, token.QUO_ASSIGN,
                 token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
                 token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN:
                 // assignment statement
                 pos, tok := p.pos, p.tok
                 p.next()
-                y := p.parseExprList()
-                if tok == token.DEFINE {
-                        p.shortVarDecl(p.makeIdentList(x))
-                }
+                y := p.parseRhsList()
                 return &ast.AssignStmt{x, pos, tok, y}
         }
 
         if len(x) > 1 {
                 p.errorExpected(x[0].Pos(), "1 expression")
                 // continue with first expression
         }
 
         switch p.tok {
         case token.COLON:
                 // labeled statement
                 colon := p.pos
                 p.next()
                 if label, isIdent := x[0].(*ast.Ident); labelOk && isIdent {
                         // Go spec: The scope of a label is the body of the function
                         // in which it is declared and excludes the body of any nested
                         // function.
                         stmt := &ast.LabeledStmt{label, colon, p.parseStmt()}
                         p.declare(stmt, p.labelScope, ast.Lbl, label)
                         return stmt
                 }
                 p.error(x[0].Pos(), "illegal label declaration")
                 return &ast.BadStmt{x[0].Pos(), colon + 1}
 
         case token.ARROW:
                 // send statement
                 arrow := p.pos
                 p.next() // consume "<-"
-                y := p.parseExpr()
+                y := p.parseRhs()
                 return &ast.SendStmt{x[0], arrow, y}
 
         case token.INC, token.DEC:
                 // increment or decrement
                 s := &ast.IncDecStmt{x[0], p.pos, p.tok}
                 p.next() // consume "++" or "--"
                 return s
         }
 
         // expression
         return &ast.ExprStmt{x[0]}
 }
 
 
 func (p *parser) parseCallExpr() *ast.CallExpr {
-        x := p.parseExpr()
+        x := p.parseRhs()
         if call, isCall := x.(*ast.CallExpr); isCall {
                 return call
         }
         p.errorExpected(x.Pos(), "function/method call")
         return nil
 }
 
 
 func (p *parser) parseGoStmt() ast.Stmt {
         if p.trace {
@@ skipping 29 matching lines @@
 
 func (p *parser) parseReturnStmt() *ast.ReturnStmt {
         if p.trace {
                 defer un(trace(p, "ReturnStmt"))
         }
 
         pos := p.pos
         p.expect(token.RETURN)
         var x []ast.Expr
         if p.tok != token.SEMICOLON && p.tok != token.RBRACE {
-                x = p.parseExprList()
+                x = p.parseRhsList()
         }
         p.expectSemi()
 
         return &ast.ReturnStmt{pos, x}
 }
 
 
 func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
         if p.trace {
                 defer un(trace(p, "BranchStmt"))
@@ skipping 34 matching lines @@
         p.openScope()
         defer p.closeScope()
 
         var s ast.Stmt
         var x ast.Expr
         {
                 prevLev := p.exprLev
                 p.exprLev = -1
                 if p.tok == token.SEMICOLON {
                         p.next()
-                        x = p.parseExpr()
+                        x = p.parseRhs()
                 } else {
                         s = p.parseSimpleStmt(false)
                         if p.tok == token.SEMICOLON {
                                 p.next()
-                                x = p.parseExpr()
+                                x = p.parseRhs()
                         } else {
                                 x = p.makeExpr(s)
                                 s = nil
                         }
                 }
                 p.exprLev = prevLev
         }
 
         body := p.parseBlockStmt()
         var else_ ast.Stmt
@@ skipping 26 matching lines @@
 func (p *parser) parseCaseClause(exprSwitch bool) *ast.CaseClause {
         if p.trace {
                 defer un(trace(p, "CaseClause"))
         }
 
         pos := p.pos
         var list []ast.Expr
         if p.tok == token.CASE {
                 p.next()
                 if exprSwitch {
-                        list = p.parseExprList()
+                        list = p.parseRhsList()
                 } else {
                         list = p.parseTypeList()
                 }
         } else {
                 p.expect(token.DEFAULT)
         }
 
         colon := p.expect(token.COLON)
         p.openScope()
         body := p.parseStmtList()
@@ skipping 66 matching lines @@
 func (p *parser) parseCommClause() *ast.CommClause {
         if p.trace {
                 defer un(trace(p, "CommClause"))
         }
 
         p.openScope()
         pos := p.pos
         var comm ast.Stmt
         if p.tok == token.CASE {
                 p.next()
-                lhs := p.parseExprList()
+                lhs := p.parseLhsList()
                 if p.tok == token.ARROW {
                         // SendStmt
                         if len(lhs) > 1 {
                                 p.errorExpected(lhs[0].Pos(), "1 expression")
                                 // continue with first expression
                         }
                         arrow := p.pos
                         p.next()
-                        rhs := p.parseExpr()
+                        rhs := p.parseRhs()
                         comm = &ast.SendStmt{lhs[0], arrow, rhs}
                 } else {
                         // RecvStmt
                         pos := p.pos
                         tok := p.tok
                         var rhs ast.Expr
                         if tok == token.ASSIGN || tok == token.DEFINE {
                                 // RecvStmt with assignment
                                 if len(lhs) > 2 {
                                         p.errorExpected(lhs[0].Pos(), "1 or 2 expressions")
                                         // continue with first two expressions
                                         lhs = lhs[0:2]
                                 }
                                 p.next()
-                                rhs = p.parseExpr()
-                                if tok == token.DEFINE {
-                                        p.shortVarDecl(p.makeIdentList(lhs))
-                                }
+                                rhs = p.parseRhs()
                         } else {
                                 // rhs must be single receive operation
                                 if len(lhs) > 1 {
                                         p.errorExpected(lhs[0].Pos(), "1 expression")
                                         // continue with first expression
                                 }
                                 rhs = lhs[0]
                                 lhs = nil // there is no lhs
                         }
                         if x, isUnary := rhs.(*ast.UnaryExpr); !isUnary || x.Op != token.ARROW {
@@ skipping 186 matching lines @@
 
         var path *ast.BasicLit
         if p.tok == token.STRING {
                 path = &ast.BasicLit{p.pos, p.tok, p.lit()}
                 p.next()
         } else {
                 p.expect(token.STRING) // use expect() error handling
         }
         p.expectSemi() // call before accessing p.linecomment
 
-        return &ast.ImportSpec{doc, ident, path, p.lineComment}
+        // collect imports
+        spec := &ast.ImportSpec{doc, ident, path, p.lineComment}
+        p.imports = append(p.imports, spec)
+
+        return spec
 }
 
 
 func parseConstSpec(p *parser, doc *ast.CommentGroup, iota int) ast.Spec {
         if p.trace {
                 defer un(trace(p, "ConstSpec"))
         }
 
         idents := p.parseIdentList()
         typ := p.tryType()
         var values []ast.Expr
         if typ != nil || p.tok == token.ASSIGN || iota == 0 {
                 p.expect(token.ASSIGN)
-                values = p.parseExprList()
+                values = p.parseRhsList()
         }
         p.expectSemi() // call before accessing p.linecomment
 
         // Go spec: The scope of a constant or variable identifier declared inside
         // a function begins at the end of the ConstSpec or VarSpec and ends at
         // the end of the innermost containing block.
         // (Global identifiers are resolved in a separate phase after parsing.)
         spec := &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
         p.declare(spec, p.topScope, ast.Con, idents...)
 
@@ skipping 24 matching lines @@
 func parseVarSpec(p *parser, doc *ast.CommentGroup, _ int) ast.Spec {
         if p.trace {
                 defer un(trace(p, "VarSpec"))
         }
 
         idents := p.parseIdentList()
         typ := p.tryType()
         var values []ast.Expr
         if typ == nil || p.tok == token.ASSIGN {
                 p.expect(token.ASSIGN)
-                values = p.parseExprList()
+                values = p.parseRhsList()
         }
         p.expectSemi() // call before accessing p.linecomment
 
         // Go spec: The scope of a constant or variable identifier declared inside
         // a function begins at the end of the ConstSpec or VarSpec and ends at
         // the end of the innermost containing block.
         // (Global identifiers are resolved in a separate phase after parsing.)
         spec := &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
         p.declare(spec, p.topScope, ast.Var, idents...)
 
@@ skipping 167 matching lines @@
                 }
 
                 if p.mode&ImportsOnly == 0 {
                         // rest of package body
                         for p.tok != token.EOF {
                                 decls = append(decls, p.parseDecl())
                         }
                 }
         }
 
-        if p.topScope != p.pkgScope {
-                panic("internal error: imbalanced scopes")
-        }
+        assert(p.topScope == p.pkgScope, "imbalanced scopes")
 
         // resolve global identifiers within the same file
         i := 0
         for _, ident := range p.unresolved {
                 // i <= index for current ident
-                ident.Obj = p.pkgScope.Lookup(ident.Name)
+                assert(ident.Obj == unresolved, "object already resolved")
+                ident.Obj = p.pkgScope.Lookup(ident.Name) // also removes unresolved sentinel
                 if ident.Obj == nil {
                         p.unresolved[i] = ident
                         i++
                 }
         }
 
+        // TODO(gri): store p.imports in AST
         return &ast.File{doc, pos, ident, decls, p.pkgScope, p.unresolved[0:i], p.comments}
 }