code review 189080: Steps towards tracking scopes for identifiers.

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 265 matching lines @@
 // Usage pattern: defer closeScope(openScope(p));
 func openScope(p *parser) *parser {
         p.topScope = ast.NewScope(p.topScope)
         return p
 }
 
 
 func closeScope(p *parser) { p.topScope = p.topScope.Outer }
 
 
-func (p *parser) parseIdent(kind ast.Kind) *ast.Ident {
+func (p *parser) parseIdent(kind ast.ObjKind) *ast.Ident {
         obj := ast.NewObj(ast.Err, p.pos, "")
         if p.tok == token.IDENT {
                 obj.Name = string(p.lit)
                 p.next()
         } else {
                 p.expect(token.IDENT) // use expect() error handling
         }
         return &ast.Ident{obj.Pos, obj}
 }
 
 
-func (p *parser) declIdent(kind ast.Kind) *ast.Ident {
+// TODO(gri) Separate parsing from declaration since an identifier's
+//           scope often starts only after the type has been seen.
+func (p *parser) declIdent(kind ast.ObjKind) *ast.Ident {
         obj := ast.NewObj(kind, p.pos, "")
         if p.tok == token.IDENT {
                 obj.Name = string(p.lit)
                 // TODO(gri) Consider reversing the conditionals below:
                 //           always do the declaration but only report
                 //           error if enabled (may be necessary to get
                 //           search functionality in the presence of
                 //           incorrect files).
                 if p.check && !p.topScope.Declare(obj) {
                         // TODO(gri) Declare could return already-declared
-                        //           object very good error message.
+                        //           object for a very good error message.
                         p.Error(obj.Pos, "'"+obj.Name+"' declared already")
                 }
                 p.next()
         } else {
                 p.expect(token.IDENT) // use expect() error handling
         }
         return &ast.Ident{obj.Pos, obj}
 }
 
 
-func (p *parser) declIdentList(kind ast.Kind) []*ast.Ident {
+// TODO(gri) Separate parsing from declaration since an identifier's
+//           scope often starts only after the type has been seen.
+func (p *parser) declIdentList(kind ast.ObjKind) []*ast.Ident {
         if p.trace {
                 defer un(trace(p, "IdentList"))
         }
 
         var list vector.Vector
         list.Push(p.declIdent(kind))
         for p.tok == token.COMMA {
                 p.next()
                 list.Push(p.declIdent(kind))
         }
@@ skipping 119 matching lines @@
 }
 
 
 func (p *parser) makeIdentList(list *vector.Vector) []*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")
-                        idents[i] = &ast.Ident{pos, &ast.Object{Pos: pos}}
+                        idents[i] = &ast.Ident{pos, ast.NewObj(ast.Err, pos, "")}
                 }
                 idents[i] = ident
         }
         return idents
 }
 
 
 func (p *parser) parseFieldDecl() *ast.Field {
         if p.trace {
                 defer un(trace(p, "FieldDecl"))
@@ skipping 1472 matching lines @@
 // Source files
 
 func (p *parser) parseFile() *ast.File {
         if p.trace {
                 defer un(trace(p, "File"))
         }
 
         // package clause
         doc := p.leadComment
         pos := p.expect(token.PACKAGE)
-        ident := p.parseIdent(ast.Pkg)  // package name is in no scope
+        ident := p.parseIdent(ast.Pkg) // package name is in no scope
         p.expectSemi()
 
         // file block
         defer closeScope(openScope(p))
 
         var decls []ast.Decl
 
         // Don't bother parsing the rest if we had errors already.
         // Likely not a Go source file at all.
 
@@ skipping 13 matching lines @@
 
                 // convert declaration list
                 decls = make([]ast.Decl, len(list))
                 for i, x := range list {
                         decls[i] = x.(ast.Decl)
                 }
         }
 
         return &ast.File{doc, pos, ident, decls, p.comments}
 }