code review 217056: - removed exp/parser (support for old semicolon syntax)

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 508 matching lines @@
                 if p.tok != token.COMMA {
                         break
                 }
                 p.next()
         }
 
         // if we had a list of identifiers, it must be followed by a type
         typ := p.tryType()
 
         // optional tag
-        var tag []*ast.BasicLit
+        var tag *ast.BasicLit
         if p.tok == token.STRING {
-                x := &ast.BasicLit{p.pos, p.tok, p.lit}
+                tag = &ast.BasicLit{p.pos, p.tok, p.lit}
                 p.next()
-                tag = []*ast.BasicLit{x}
         }
 
         // analyze case
         var idents []*ast.Ident
         if typ != nil {
                 // IdentifierList Type
                 idents = p.makeIdentList(&list)
         } else {
                 // Type (anonymous field)
                 if len(list) == 1 {
@@ skipping 578 matching lines @@
 //            restricting what they are supposed to accept depending
 //            on context.
 
 // checkExpr checks that x is an expression (and not a type).
 func (p *parser) checkExpr(x ast.Expr) ast.Expr {
         // TODO(gri): should provide predicate in AST nodes
         switch t := x.(type) {
         case *ast.BadExpr:
         case *ast.Ident:
         case *ast.BasicLit:
-        case *ast.StringList:
         case *ast.FuncLit:
         case *ast.CompositeLit:
         case *ast.ParenExpr:
         case *ast.SelectorExpr:
         case *ast.IndexExpr:
         case *ast.SliceExpr:
         case *ast.TypeAssertExpr:
                 if t.Type == nil {
                         // the form X.(type) is only allowed in type switch expressions
                         p.errorExpected(x.Pos(), "expression")
@@ skipping 677 matching lines @@
                 ident = &ast.Ident{p.pos, ast.NewObj(ast.Pkg, p.pos, ".")}
                 p.next()
         } else if p.tok == token.IDENT {
                 ident = p.parseIdent(ast.Pkg)
                 // TODO(gri) Make sure the ident is not already declared in the
                 //           package scope. Also, cannot add the same name to
                 //           the package scope later.
                 p.declIdent(p.fileScope, ident)
         }
 
-        var path []*ast.BasicLit
+        var path *ast.BasicLit
         if p.tok == token.STRING {
-                x := &ast.BasicLit{p.pos, p.tok, p.lit}
+                path = &ast.BasicLit{p.pos, p.tok, p.lit}
                 p.next()
-                path = []*ast.BasicLit{x}
         } else {
                 p.expect(token.STRING) // use expect() error handling
         }
         p.expectSemi()
 
         return &ast.ImportSpec{doc, ident, path, p.lineComment}
 }
 
 
 func parseConstSpec(p *parser, doc *ast.CommentGroup) ast.Spec {
@@ skipping 248 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}
 }