1) Change default gofmt default settings for

                  parsing and printing to new syntax.

                  Use -oldparser to parse the old syntax,
                  use -oldprinter to print the old syntax.

               2) Change default gofmt formatting settings
                  to use tabs for indentation only and to use
                  spaces for alignment. This will make the code
                  alignment insensitive to an editor's tabwidth.

                  Use -spaces=false to use tabs for alignment.

               3) Manually changed src/exp/parser/parser_test.go
                  so that it doesn't try to parse the parser's
                  source files using the old syntax (they have
                  new syntax now).

               4) gofmt -w src misc test/bench

	       2nd set of files.

R=rsc
CC=golang-dev
http://codereview.appspot.com/179067

1 files changed, 545 insertions, 545 deletions

diff --git a/src/pkg/exp/parser/parser.go b/src/pkg/exp/parser/parser.go
index 32360b5d6..199334b1b 100644
--- a/src/pkg/exp/parser/parser.go
+++ b/src/pkg/exp/parser/parser.go
@@ -15,11 +15,11 @@
 package oldParser
 
 import (
-	"container/vector";
-	"fmt";
-	"go/ast";
-	"go/scanner";
-	"go/token";
+	"container/vector"
+	"fmt"
+	"go/ast"
+	"go/scanner"
+	"go/token"
 )
 
 
@@ -32,42 +32,42 @@ var noPos token.Position
 // parser functionality.
 //
 const (
-	PackageClauseOnly	uint	= 1 << iota;	// parsing stops after package clause
-	ImportsOnly;			// parsing stops after import declarations
-	ParseComments;			// parse comments and add them to AST
-	Trace;				// print a trace of parsed productions
+	PackageClauseOnly uint = 1 << iota // parsing stops after package clause
+	ImportsOnly            // parsing stops after import declarations
+	ParseComments          // parse comments and add them to AST
+	Trace                  // print a trace of parsed productions
 )
 
 
 // The parser structure holds the parser's internal state.
 type parser struct {
-	scanner.ErrorVector;
-	scanner	scanner.Scanner;
+	scanner.ErrorVector
+	scanner scanner.Scanner
 
 	// Tracing/debugging
-	mode	uint;	// parsing mode
-	trace	bool;	// == (mode & Trace != 0)
-	indent	uint;	// indentation used for tracing output
+	mode   uint // parsing mode
+	trace  bool // == (mode & Trace != 0)
+	indent uint // indentation used for tracing output
 
 	// Comments
-	comments	*ast.CommentGroup;	// list of collected comments
-	lastComment	*ast.CommentGroup;	// last comment in the comments list
-	leadComment	*ast.CommentGroup;	// the last lead comment
-	lineComment	*ast.CommentGroup;	// the last line comment
+	comments    *ast.CommentGroup // list of collected comments
+	lastComment *ast.CommentGroup // last comment in the comments list
+	leadComment *ast.CommentGroup // the last lead comment
+	lineComment *ast.CommentGroup // the last line comment
 
 	// Next token
-	pos	token.Position;	// token position
-	tok	token.Token;	// one token look-ahead
-	lit	[]byte;		// token literal
+	pos token.Position // token position
+	tok token.Token    // one token look-ahead
+	lit []byte         // token literal
 
 	// Non-syntactic parser control
-	optSemi	bool;	// true if semicolon separator is optional in statement list
-	exprLev	int;	// < 0: in control clause, >= 0: in expression
+	optSemi bool // true if semicolon separator is optional in statement list
+	exprLev int  // < 0: in control clause, >= 0: in expression
 
 	// Scopes
-	pkgScope	*ast.Scope;
-	fileScope	*ast.Scope;
-	topScope	*ast.Scope;
+	pkgScope  *ast.Scope
+	fileScope *ast.Scope
+	topScope  *ast.Scope
 }
 
 
@@ -76,15 +76,15 @@ func scannerMode(mode uint) uint {
 	if mode&ParseComments != 0 {
 		return scanner.ScanComments
 	}
-	return 0;
+	return 0
 }
 
 
 func (p *parser) init(filename string, src []byte, mode uint) {
-	p.scanner.Init(filename, src, p, scannerMode(mode));
-	p.mode = mode;
-	p.trace = mode&Trace != 0;	// for convenience (p.trace is used frequently)
-	p.next();
+	p.scanner.Init(filename, src, p, scannerMode(mode))
+	p.mode = mode
+	p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
+	p.next()
 }
 
 
@@ -93,29 +93,29 @@ func (p *parser) init(filename string, src []byte, mode uint) {
 
 func (p *parser) printTrace(a ...) {
 	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
-		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ";
-	const n = uint(len(dots));
-	fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column);
-	i := 2 * p.indent;
+		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
+	const n = uint(len(dots))
+	fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column)
+	i := 2 * p.indent
 	for ; i > n; i -= n {
 		fmt.Print(dots)
 	}
-	fmt.Print(dots[0:i]);
-	fmt.Println(a);
+	fmt.Print(dots[0:i])
+	fmt.Println(a)
 }
 
 
 func trace(p *parser, msg string) *parser {
-	p.printTrace(msg, "(");
-	p.indent++;
-	return p;
+	p.printTrace(msg, "(")
+	p.indent++
+	return p
 }
 
 
 // Usage pattern: defer un(trace(p, "..."));
 func un(p *parser) {
-	p.indent--;
-	p.printTrace(")");
+	p.indent--
+	p.printTrace(")")
 }
 
 
@@ -126,7 +126,7 @@ func (p *parser) next0() {
 	// very first token (p.pos.Line == 0) is not initialized (it
 	// is token.ILLEGAL), so don't print it .
 	if p.trace && p.pos.Line > 0 {
-		s := p.tok.String();
+		s := p.tok.String()
 		switch {
 		case p.tok.IsLiteral():
 			p.printTrace(s, string(p.lit))
@@ -137,8 +137,8 @@ func (p *parser) next0() {
 		}
 	}
 
-	p.pos, p.tok, p.lit = p.scanner.Scan();
-	p.optSemi = false;
+	p.pos, p.tok, p.lit = p.scanner.Scan()
+	p.optSemi = false
 }
 
 
@@ -146,7 +146,7 @@ func (p *parser) next0() {
 func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
 	// /*-style comments may end on a different line than where they start.
 	// Scan the comment for '\n' chars and adjust endline accordingly.
-	endline = p.pos.Line;
+	endline = p.pos.Line
 	if p.lit[1] == '*' {
 		for _, b := range p.lit {
 			if b == '\n' {
@@ -155,10 +155,10 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
 		}
 	}
 
-	comment = &ast.Comment{p.pos, p.lit};
-	p.next0();
+	comment = &ast.Comment{p.pos, p.lit}
+	p.next0()
 
-	return;
+	return
 }
 
 
@@ -168,30 +168,30 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
 // a comment group.
 //
 func (p *parser) consumeCommentGroup() int {
-	list := new(vector.Vector);
-	endline := p.pos.Line;
+	list := new(vector.Vector)
+	endline := p.pos.Line
 	for p.tok == token.COMMENT && endline+1 >= p.pos.Line {
-		var comment *ast.Comment;
-		comment, endline = p.consumeComment();
-		list.Push(comment);
+		var comment *ast.Comment
+		comment, endline = p.consumeComment()
+		list.Push(comment)
 	}
 
 	// convert list
-	group := make([]*ast.Comment, list.Len());
+	group := make([]*ast.Comment, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		group[i] = list.At(i).(*ast.Comment)
 	}
 
 	// add comment group to the comments list
-	g := &ast.CommentGroup{group, nil};
+	g := &ast.CommentGroup{group, nil}
 	if p.lastComment != nil {
 		p.lastComment.Next = g
 	} else {
 		p.comments = g
 	}
-	p.lastComment = g;
+	p.lastComment = g
 
-	return endline;
+	return endline
 }
 
 
@@ -211,16 +211,16 @@ func (p *parser) consumeCommentGroup() int {
 // stored in the AST.
 //
 func (p *parser) next() {
-	p.leadComment = nil;
-	p.lineComment = nil;
-	line := p.pos.Line;	// current line
-	p.next0();
+	p.leadComment = nil
+	p.lineComment = nil
+	line := p.pos.Line // current line
+	p.next0()
 
 	if p.tok == token.COMMENT {
 		if p.pos.Line == line {
 			// The comment is on same line as previous token; it
 			// cannot be a lead comment but may be a line comment.
-			endline := p.consumeCommentGroup();
+			endline := p.consumeCommentGroup()
 			if p.pos.Line != endline {
 				// The next token is on a different line, thus
 				// the last comment group is a line comment.
@@ -229,7 +229,7 @@ func (p *parser) next() {
 		}
 
 		// consume successor comments, if any
-		endline := -1;
+		endline := -1
 		for p.tok == token.COMMENT {
 			endline = p.consumeCommentGroup()
 		}
@@ -244,26 +244,26 @@ func (p *parser) next() {
 
 
 func (p *parser) errorExpected(pos token.Position, msg string) {
-	msg = "expected " + msg;
+	msg = "expected " + msg
 	if pos.Offset == p.pos.Offset {
 		// the error happened at the current position;
 		// make the error message more specific
-		msg += ", found '" + p.tok.String() + "'";
+		msg += ", found '" + p.tok.String() + "'"
 		if p.tok.IsLiteral() {
 			msg += " " + string(p.lit)
 		}
 	}
-	p.Error(pos, msg);
+	p.Error(pos, msg)
 }
 
 
 func (p *parser) expect(tok token.Token) token.Position {
-	pos := p.pos;
+	pos := p.pos
 	if p.tok != tok {
 		p.errorExpected(pos, "'"+tok.String()+"'")
 	}
-	p.next();	// make progress in any case
-	return pos;
+	p.next() // make progress in any case
+	return pos
 }
 
 
@@ -271,13 +271,13 @@ func (p *parser) expect(tok token.Token) token.Position {
 // Scope support
 
 func openScope(p *parser) *parser {
-	p.topScope = ast.NewScope(p.topScope);
-	return p;
+	p.topScope = ast.NewScope(p.topScope)
+	return p
 }
 
 
 // Usage pattern: defer close(openScope(p));
-func close(p *parser)	{ p.topScope = p.topScope.Outer }
+func close(p *parser) { p.topScope = p.topScope.Outer }
 
 
 func (p *parser) declare(ident *ast.Ident) {
@@ -299,12 +299,12 @@ func (p *parser) declareList(idents []*ast.Ident) {
 
 func (p *parser) parseIdent() *ast.Ident {
 	if p.tok == token.IDENT {
-		x := &ast.Ident{p.pos, string(p.lit)};
-		p.next();
-		return x;
+		x := &ast.Ident{p.pos, string(p.lit)}
+		p.next()
+		return x
 	}
-	p.expect(token.IDENT);	// use expect() error handling
-	return &ast.Ident{p.pos, ""};
+	p.expect(token.IDENT) // use expect() error handling
+	return &ast.Ident{p.pos, ""}
 }
 
 
@@ -313,20 +313,20 @@ func (p *parser) parseIdentList() []*ast.Ident {
 		defer un(trace(p, "IdentList"))
 	}
 
-	list := new(vector.Vector);
-	list.Push(p.parseIdent());
+	list := new(vector.Vector)
+	list.Push(p.parseIdent())
 	for p.tok == token.COMMA {
-		p.next();
-		list.Push(p.parseIdent());
+		p.next()
+		list.Push(p.parseIdent())
 	}
 
 	// convert vector
-	idents := make([]*ast.Ident, list.Len());
+	idents := make([]*ast.Ident, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		idents[i] = list.At(i).(*ast.Ident)
 	}
 
-	return idents;
+	return idents
 }
 
 
@@ -335,20 +335,20 @@ func (p *parser) parseExprList() []ast.Expr {
 		defer un(trace(p, "ExpressionList"))
 	}
 
-	list := new(vector.Vector);
-	list.Push(p.parseExpr());
+	list := new(vector.Vector)
+	list.Push(p.parseExpr())
 	for p.tok == token.COMMA {
-		p.next();
-		list.Push(p.parseExpr());
+		p.next()
+		list.Push(p.parseExpr())
 	}
 
 	// convert list
-	exprs := make([]ast.Expr, list.Len());
+	exprs := make([]ast.Expr, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		exprs[i] = list.At(i).(ast.Expr)
 	}
 
-	return exprs;
+	return exprs
 }
 
 
@@ -360,15 +360,15 @@ func (p *parser) parseType() ast.Expr {
 		defer un(trace(p, "Type"))
 	}
 
-	typ := p.tryType();
+	typ := p.tryType()
 
 	if typ == nil {
-		p.errorExpected(p.pos, "type");
-		p.next();	// make progress
-		return &ast.BadExpr{p.pos};
+		p.errorExpected(p.pos, "type")
+		p.next() // make progress
+		return &ast.BadExpr{p.pos}
 	}
 
-	return typ;
+	return typ
 }
 
 
@@ -377,14 +377,14 @@ func (p *parser) parseQualifiedIdent() ast.Expr {
 		defer un(trace(p, "QualifiedIdent"))
 	}
 
-	var x ast.Expr = p.parseIdent();
+	var x ast.Expr = p.parseIdent()
 	if p.tok == token.PERIOD {
 		// first identifier is a package identifier
-		p.next();
-		sel := p.parseIdent();
-		x = &ast.SelectorExpr{x, sel};
+		p.next()
+		sel := p.parseIdent()
+		x = &ast.SelectorExpr{x, sel}
 	}
-	return x;
+	return x
 }
 
 
@@ -393,7 +393,7 @@ func (p *parser) parseTypeName() ast.Expr {
 		defer un(trace(p, "TypeName"))
 	}
 
-	return p.parseQualifiedIdent();
+	return p.parseQualifiedIdent()
 }
 
 
@@ -402,33 +402,33 @@ func (p *parser) parseArrayType(ellipsisOk bool) ast.Expr {
 		defer un(trace(p, "ArrayType"))
 	}
 
-	lbrack := p.expect(token.LBRACK);
-	var len ast.Expr;
+	lbrack := p.expect(token.LBRACK)
+	var len ast.Expr
 	if ellipsisOk && p.tok == token.ELLIPSIS {
-		len = &ast.Ellipsis{p.pos};
-		p.next();
+		len = &ast.Ellipsis{p.pos}
+		p.next()
 	} else if p.tok != token.RBRACK {
 		len = p.parseExpr()
 	}
-	p.expect(token.RBRACK);
-	elt := p.parseType();
+	p.expect(token.RBRACK)
+	elt := p.parseType()
 
-	return &ast.ArrayType{lbrack, len, elt};
+	return &ast.ArrayType{lbrack, len, elt}
 }
 
 
 func (p *parser) makeIdentList(list *vector.Vector) []*ast.Ident {
-	idents := make([]*ast.Ident, list.Len());
+	idents := make([]*ast.Ident, list.Len())
 	for i := 0; i < list.Len(); i++ {
-		ident, isIdent := list.At(i).(*ast.Ident);
+		ident, isIdent := list.At(i).(*ast.Ident)
 		if !isIdent {
-			pos := list.At(i).(ast.Expr).Pos();
-			p.errorExpected(pos, "identifier");
-			idents[i] = &ast.Ident{pos, ""};
+			pos := list.At(i).(ast.Expr).Pos()
+			p.errorExpected(pos, "identifier")
+			idents[i] = &ast.Ident{pos, ""}
 		}
-		idents[i] = ident;
+		idents[i] = ident
 	}
-	return idents;
+	return idents
 }
 
 
@@ -437,13 +437,13 @@ func (p *parser) parseFieldDecl() *ast.Field {
 		defer un(trace(p, "FieldDecl"))
 	}
 
-	doc := p.leadComment;
+	doc := p.leadComment
 
 	// a list of identifiers looks like a list of type names
-	list := new(vector.Vector);
+	list := new(vector.Vector)
 	for {
 		// TODO(gri): do not allow ()'s here
-		list.Push(p.parseType());
+		list.Push(p.parseType())
 		if p.tok == token.COMMA {
 			p.next()
 		} else {
@@ -452,16 +452,16 @@ func (p *parser) parseFieldDecl() *ast.Field {
 	}
 
 	// if we had a list of identifiers, it must be followed by a type
-	typ := p.tryType();
+	typ := p.tryType()
 
 	// optional tag
-	var tag []*ast.BasicLit;
+	var tag []*ast.BasicLit
 	if p.tok == token.STRING {
 		tag = p.parseStringList(nil)
 	}
 
 	// analyze case
-	var idents []*ast.Ident;
+	var idents []*ast.Ident
 	if typ != nil {
 		// IdentifierList Type
 		idents = p.makeIdentList(list)
@@ -471,12 +471,12 @@ func (p *parser) parseFieldDecl() *ast.Field {
 			// TODO(gri): check that this looks like a type
 			typ = list.At(0).(ast.Expr)
 		} else {
-			p.errorExpected(p.pos, "anonymous field");
-			typ = &ast.BadExpr{p.pos};
+			p.errorExpected(p.pos, "anonymous field")
+			typ = &ast.BadExpr{p.pos}
 		}
 	}
 
-	return &ast.Field{doc, idents, typ, tag, nil};
+	return &ast.Field{doc, idents, typ, tag, nil}
 }
 
 
@@ -485,27 +485,27 @@ func (p *parser) parseStructType() *ast.StructType {
 		defer un(trace(p, "StructType"))
 	}
 
-	pos := p.expect(token.STRUCT);
-	lbrace := p.expect(token.LBRACE);
-	list := new(vector.Vector);
+	pos := p.expect(token.STRUCT)
+	lbrace := p.expect(token.LBRACE)
+	list := new(vector.Vector)
 	for p.tok == token.IDENT || p.tok == token.MUL {
-		f := p.parseFieldDecl();
+		f := p.parseFieldDecl()
 		if p.tok != token.RBRACE {
 			p.expect(token.SEMICOLON)
 		}
-		f.Comment = p.lineComment;
-		list.Push(f);
+		f.Comment = p.lineComment
+		list.Push(f)
 	}
-	rbrace := p.expect(token.RBRACE);
-	p.optSemi = true;
+	rbrace := p.expect(token.RBRACE)
+	p.optSemi = true
 
 	// convert vector
-	fields := make([]*ast.Field, list.Len());
+	fields := make([]*ast.Field, list.Len())
 	for i := list.Len() - 1; i >= 0; i-- {
 		fields[i] = list.At(i).(*ast.Field)
 	}
 
-	return &ast.StructType{pos, lbrace, fields, rbrace, false};
+	return &ast.StructType{pos, lbrace, fields, rbrace, false}
 }
 
 
@@ -514,35 +514,35 @@ func (p *parser) parsePointerType() *ast.StarExpr {
 		defer un(trace(p, "PointerType"))
 	}
 
-	star := p.expect(token.MUL);
-	base := p.parseType();
+	star := p.expect(token.MUL)
+	base := p.parseType()
 
-	return &ast.StarExpr{star, base};
+	return &ast.StarExpr{star, base}
 }
 
 
 func (p *parser) tryParameterType(ellipsisOk bool) ast.Expr {
 	if ellipsisOk && p.tok == token.ELLIPSIS {
-		pos := p.pos;
-		p.next();
+		pos := p.pos
+		p.next()
 		if p.tok != token.RPAREN {
 			// "..." always must be at the very end of a parameter list
 			p.Error(pos, "expected type, found '...'")
 		}
-		return &ast.Ellipsis{pos};
+		return &ast.Ellipsis{pos}
 	}
-	return p.tryType();
+	return p.tryType()
 }
 
 
 func (p *parser) parseParameterType(ellipsisOk bool) ast.Expr {
-	typ := p.tryParameterType(ellipsisOk);
+	typ := p.tryParameterType(ellipsisOk)
 	if typ == nil {
-		p.errorExpected(p.pos, "type");
-		p.next();	// make progress
-		typ = &ast.BadExpr{p.pos};
+		p.errorExpected(p.pos, "type")
+		p.next() // make progress
+		typ = &ast.BadExpr{p.pos}
 	}
-	return typ;
+	return typ
 }
 
 
@@ -552,10 +552,10 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr)
 	}
 
 	// a list of identifiers looks like a list of type names
-	list := new(vector.Vector);
+	list := new(vector.Vector)
 	for {
 		// TODO(gri): do not allow ()'s here
-		list.Push(p.parseParameterType(ellipsisOk));
+		list.Push(p.parseParameterType(ellipsisOk))
 		if p.tok == token.COMMA {
 			p.next()
 		} else {
@@ -564,9 +564,9 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr)
 	}
 
 	// if we had a list of identifiers, it must be followed by a type
-	typ := p.tryParameterType(ellipsisOk);
+	typ := p.tryParameterType(ellipsisOk)
 
-	return list, typ;
+	return list, typ
 }
 
 
@@ -575,18 +575,18 @@ func (p *parser) parseParameterList(ellipsisOk bool) []*ast.Field {
 		defer un(trace(p, "ParameterList"))
 	}
 
-	list, typ := p.parseParameterDecl(ellipsisOk);
+	list, typ := p.parseParameterDecl(ellipsisOk)
 	if typ != nil {
 		// IdentifierList Type
-		idents := p.makeIdentList(list);
-		list.Resize(0, 0);
-		list.Push(&ast.Field{nil, idents, typ, nil, nil});
+		idents := p.makeIdentList(list)
+		list.Resize(0, 0)
+		list.Push(&ast.Field{nil, idents, typ, nil, nil})
 
 		for p.tok == token.COMMA {
-			p.next();
-			idents := p.parseIdentList();
-			typ := p.parseParameterType(ellipsisOk);
-			list.Push(&ast.Field{nil, idents, typ, nil, nil});
+			p.next()
+			idents := p.parseIdentList()
+			typ := p.parseParameterType(ellipsisOk)
+			list.Push(&ast.Field{nil, idents, typ, nil, nil})
 		}
 
 	} else {
@@ -598,12 +598,12 @@ func (p *parser) parseParameterList(ellipsisOk bool) []*ast.Field {
 	}
 
 	// convert list
-	params := make([]*ast.Field, list.Len());
+	params := make([]*ast.Field, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		params[i] = list.At(i).(*ast.Field)
 	}
 
-	return params;
+	return params
 }
 
 
@@ -612,14 +612,14 @@ func (p *parser) parseParameters(ellipsisOk bool) []*ast.Field {
 		defer un(trace(p, "Parameters"))
 	}
 
-	var params []*ast.Field;
-	p.expect(token.LPAREN);
+	var params []*ast.Field
+	p.expect(token.LPAREN)
 	if p.tok != token.RPAREN {
 		params = p.parseParameterList(ellipsisOk)
 	}
-	p.expect(token.RPAREN);
+	p.expect(token.RPAREN)
 
-	return params;
+	return params
 }
 
 
@@ -628,18 +628,18 @@ func (p *parser) parseResult() []*ast.Field {
 		defer un(trace(p, "Result"))
 	}
 
-	var results []*ast.Field;
+	var results []*ast.Field
 	if p.tok == token.LPAREN {
 		results = p.parseParameters(false)
 	} else if p.tok != token.FUNC {
-		typ := p.tryType();
+		typ := p.tryType()
 		if typ != nil {
-			results = make([]*ast.Field, 1);
-			results[0] = &ast.Field{Type: typ};
+			results = make([]*ast.Field, 1)
+			results[0] = &ast.Field{Type: typ}
 		}
 	}
 
-	return results;
+	return results
 }
 
 
@@ -648,10 +648,10 @@ func (p *parser) parseSignature() (params []*ast.Field, results []*ast.Field) {
 		defer un(trace(p, "Signature"))
 	}
 
-	params = p.parseParameters(true);
-	results = p.parseResult();
+	params = p.parseParameters(true)
+	results = p.parseResult()
 
-	return;
+	return
 }
 
 
@@ -660,10 +660,10 @@ func (p *parser) parseFuncType() *ast.FuncType {
 		defer un(trace(p, "FuncType"))
 	}
 
-	pos := p.expect(token.FUNC);
-	params, results := p.parseSignature();
+	pos := p.expect(token.FUNC)
+	params, results := p.parseSignature()
 
-	return &ast.FuncType{pos, params, results};
+	return &ast.FuncType{pos, params, results}
 }
 
 
@@ -672,21 +672,21 @@ func (p *parser) parseMethodSpec() *ast.Field {
 		defer un(trace(p, "MethodSpec"))
 	}
 
-	doc := p.leadComment;
-	var idents []*ast.Ident;
-	var typ ast.Expr;
-	x := p.parseQualifiedIdent();
+	doc := p.leadComment
+	var idents []*ast.Ident
+	var typ ast.Expr
+	x := p.parseQualifiedIdent()
 	if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
 		// method
-		idents = []*ast.Ident{ident};
-		params, results := p.parseSignature();
-		typ = &ast.FuncType{noPos, params, results};
+		idents = []*ast.Ident{ident}
+		params, results := p.parseSignature()
+		typ = &ast.FuncType{noPos, params, results}
 	} else {
 		// embedded interface
 		typ = x
 	}
 
-	return &ast.Field{doc, idents, typ, nil, nil};
+	return &ast.Field{doc, idents, typ, nil, nil}
 }
 
 
@@ -695,27 +695,27 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 		defer un(trace(p, "InterfaceType"))
 	}
 
-	pos := p.expect(token.INTERFACE);
-	lbrace := p.expect(token.LBRACE);
-	list := new(vector.Vector);
+	pos := p.expect(token.INTERFACE)
+	lbrace := p.expect(token.LBRACE)
+	list := new(vector.Vector)
 	for p.tok == token.IDENT {
-		m := p.parseMethodSpec();
+		m := p.parseMethodSpec()
 		if p.tok != token.RBRACE {
 			p.expect(token.SEMICOLON)
 		}
-		m.Comment = p.lineComment;
-		list.Push(m);
+		m.Comment = p.lineComment
+		list.Push(m)
 	}
-	rbrace := p.expect(token.RBRACE);
-	p.optSemi = true;
+	rbrace := p.expect(token.RBRACE)
+	p.optSemi = true
 
 	// convert vector
-	methods := make([]*ast.Field, list.Len());
+	methods := make([]*ast.Field, list.Len())
 	for i := list.Len() - 1; i >= 0; i-- {
 		methods[i] = list.At(i).(*ast.Field)
 	}
 
-	return &ast.InterfaceType{pos, lbrace, methods, rbrace, false};
+	return &ast.InterfaceType{pos, lbrace, methods, rbrace, false}
 }
 
 
@@ -724,13 +724,13 @@ func (p *parser) parseMapType() *ast.MapType {
 		defer un(trace(p, "MapType"))
 	}
 
-	pos := p.expect(token.MAP);
-	p.expect(token.LBRACK);
-	key := p.parseType();
-	p.expect(token.RBRACK);
-	value := p.parseType();
+	pos := p.expect(token.MAP)
+	p.expect(token.LBRACK)
+	key := p.parseType()
+	p.expect(token.RBRACK)
+	value := p.parseType()
 
-	return &ast.MapType{pos, key, value};
+	return &ast.MapType{pos, key, value}
 }
 
 
@@ -739,22 +739,22 @@ func (p *parser) parseChanType() *ast.ChanType {
 		defer un(trace(p, "ChanType"))
 	}
 
-	pos := p.pos;
-	dir := ast.SEND | ast.RECV;
+	pos := p.pos
+	dir := ast.SEND | ast.RECV
 	if p.tok == token.CHAN {
-		p.next();
+		p.next()
 		if p.tok == token.ARROW {
-			p.next();
-			dir = ast.SEND;
+			p.next()
+			dir = ast.SEND
 		}
 	} else {
-		p.expect(token.ARROW);
-		p.expect(token.CHAN);
-		dir = ast.RECV;
+		p.expect(token.ARROW)
+		p.expect(token.CHAN)
+		dir = ast.RECV
 	}
-	value := p.parseType();
+	value := p.parseType()
 
-	return &ast.ChanType{pos, dir, value};
+	return &ast.ChanType{pos, dir, value}
 }
 
 
@@ -777,30 +777,30 @@ func (p *parser) tryRawType(ellipsisOk bool) ast.Expr {
 	case token.CHAN, token.ARROW:
 		return p.parseChanType()
 	case token.LPAREN:
-		lparen := p.pos;
-		p.next();
-		typ := p.parseType();
-		rparen := p.expect(token.RPAREN);
-		return &ast.ParenExpr{lparen, typ, rparen};
+		lparen := p.pos
+		p.next()
+		typ := p.parseType()
+		rparen := p.expect(token.RPAREN)
+		return &ast.ParenExpr{lparen, typ, rparen}
 	}
 
 	// no type found
-	return nil;
+	return nil
 }
 
 
-func (p *parser) tryType() ast.Expr	{ return p.tryRawType(false) }
+func (p *parser) tryType() ast.Expr { return p.tryRawType(false) }
 
 
 // ----------------------------------------------------------------------------
 // Blocks
 
 func makeStmtList(list *vector.Vector) []ast.Stmt {
-	stats := make([]ast.Stmt, list.Len());
+	stats := make([]ast.Stmt, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		stats[i] = list.At(i).(ast.Stmt)
 	}
-	return stats;
+	return stats
 }
 
 
@@ -809,24 +809,24 @@ func (p *parser) parseStmtList() []ast.Stmt {
 		defer un(trace(p, "StatementList"))
 	}
 
-	list := new(vector.Vector);
-	expectSemi := false;
+	list := new(vector.Vector)
+	expectSemi := false
 	for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
 		if expectSemi {
-			p.expect(token.SEMICOLON);
-			expectSemi = false;
+			p.expect(token.SEMICOLON)
+			expectSemi = false
 		}
-		list.Push(p.parseStmt());
+		list.Push(p.parseStmt())
 		if p.tok == token.SEMICOLON {
 			p.next()
 		} else if p.optSemi {
-			p.optSemi = false	// "consume" optional semicolon
+			p.optSemi = false // "consume" optional semicolon
 		} else {
 			expectSemi = true
 		}
 	}
 
-	return makeStmtList(list);
+	return makeStmtList(list)
 }
 
 
@@ -835,14 +835,14 @@ func (p *parser) parseBlockStmt(idents []*ast.Ident) *ast.BlockStmt {
 		defer un(trace(p, "BlockStmt"))
 	}
 
-	defer close(openScope(p));
+	defer close(openScope(p))
 
-	lbrace := p.expect(token.LBRACE);
-	list := p.parseStmtList();
-	rbrace := p.expect(token.RBRACE);
-	p.optSemi = true;
+	lbrace := p.expect(token.LBRACE)
+	list := p.parseStmtList()
+	rbrace := p.expect(token.RBRACE)
+	p.optSemi = true
 
-	return &ast.BlockStmt{lbrace, list, rbrace};
+	return &ast.BlockStmt{lbrace, list, rbrace}
 }
 
 
@@ -854,23 +854,23 @@ func (p *parser) parseStringList(x *ast.BasicLit) []*ast.BasicLit {
 		defer un(trace(p, "StringList"))
 	}
 
-	list := new(vector.Vector);
+	list := new(vector.Vector)
 	if x != nil {
 		list.Push(x)
 	}
 
 	for p.tok == token.STRING {
-		list.Push(&ast.BasicLit{p.pos, token.STRING, p.lit});
-		p.next();
+		list.Push(&ast.BasicLit{p.pos, token.STRING, p.lit})
+		p.next()
 	}
 
 	// convert list
-	strings := make([]*ast.BasicLit, list.Len());
+	strings := make([]*ast.BasicLit, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		strings[i] = list.At(i).(*ast.BasicLit)
 	}
 
-	return strings;
+	return strings
 }
 
 
@@ -879,18 +879,18 @@ func (p *parser) parseFuncTypeOrLit() ast.Expr {
 		defer un(trace(p, "FuncTypeOrLit"))
 	}
 
-	typ := p.parseFuncType();
+	typ := p.parseFuncType()
 	if p.tok != token.LBRACE {
 		// function type only
 		return typ
 	}
 
-	p.exprLev++;
-	body := p.parseBlockStmt(nil);
-	p.optSemi = false;	// function body requires separating ";"
-	p.exprLev--;
+	p.exprLev++
+	body := p.parseBlockStmt(nil)
+	p.optSemi = false // function body requires separating ";"
+	p.exprLev--
 
-	return &ast.FuncLit{typ, body};
+	return &ast.FuncLit{typ, body}
 }
 
 
@@ -907,35 +907,35 @@ func (p *parser) parseOperand() ast.Expr {
 		return p.parseIdent()
 
 	case token.INT, token.FLOAT, token.CHAR, token.STRING:
-		x := &ast.BasicLit{p.pos, p.tok, p.lit};
-		p.next();
+		x := &ast.BasicLit{p.pos, p.tok, p.lit}
+		p.next()
 		if p.tok == token.STRING && p.tok == token.STRING {
 			return &ast.StringList{p.parseStringList(x)}
 		}
-		return x;
+		return x
 
 	case token.LPAREN:
-		lparen := p.pos;
-		p.next();
-		p.exprLev++;
-		x := p.parseExpr();
-		p.exprLev--;
-		rparen := p.expect(token.RPAREN);
-		return &ast.ParenExpr{lparen, x, rparen};
+		lparen := p.pos
+		p.next()
+		p.exprLev++
+		x := p.parseExpr()
+		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
+		t := p.tryRawType(true) // could be type for composite literal or conversion
 		if t != nil {
 			return t
 		}
 	}
 
-	p.errorExpected(p.pos, "operand");
-	p.next();	// make progress
-	return &ast.BadExpr{p.pos};
+	p.errorExpected(p.pos, "operand")
+	p.next() // make progress
+	return &ast.BadExpr{p.pos}
 }
 
 
@@ -944,25 +944,25 @@ func (p *parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr {
 		defer un(trace(p, "SelectorOrTypeAssertion"))
 	}
 
-	p.expect(token.PERIOD);
+	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}
 	}
 
 	// type assertion
-	p.expect(token.LPAREN);
-	var typ ast.Expr;
+	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);
+	p.expect(token.RPAREN)
 
-	return &ast.TypeAssertExpr{x, typ};
+	return &ast.TypeAssertExpr{x, typ}
 }
 
 
@@ -971,23 +971,23 @@ func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
 		defer un(trace(p, "IndexOrSlice"))
 	}
 
-	p.expect(token.LBRACK);
-	p.exprLev++;
-	index := p.parseExpr();
+	p.expect(token.LBRACK)
+	p.exprLev++
+	index := p.parseExpr()
 	if p.tok == token.COLON {
-		p.next();
-		var end ast.Expr;
+		p.next()
+		var end ast.Expr
 		if p.tok != token.RBRACK {
 			end = p.parseExpr()
 		}
-		x = &ast.SliceExpr{x, index, end};
+		x = &ast.SliceExpr{x, index, end}
 	} else {
 		x = &ast.IndexExpr{x, index}
 	}
-	p.exprLev--;
-	p.expect(token.RBRACK);
+	p.exprLev--
+	p.expect(token.RBRACK)
 
-	return x;
+	return x
 }
 
 
@@ -996,16 +996,16 @@ func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
 		defer un(trace(p, "CallOrConversion"))
 	}
 
-	lparen := p.expect(token.LPAREN);
-	p.exprLev++;
-	var args []ast.Expr;
+	lparen := p.expect(token.LPAREN)
+	p.exprLev++
+	var args []ast.Expr
 	if p.tok != token.RPAREN {
 		args = p.parseExprList()
 	}
-	p.exprLev--;
-	rparen := p.expect(token.RPAREN);
+	p.exprLev--
+	rparen := p.expect(token.RPAREN)
 
-	return &ast.CallExpr{fun, lparen, args, rparen};
+	return &ast.CallExpr{fun, lparen, args, rparen}
 }
 
 
@@ -1014,14 +1014,14 @@ func (p *parser) parseElement() ast.Expr {
 		defer un(trace(p, "Element"))
 	}
 
-	x := p.parseExpr();
+	x := p.parseExpr()
 	if p.tok == token.COLON {
-		colon := p.pos;
-		p.next();
-		x = &ast.KeyValueExpr{x, colon, p.parseExpr()};
+		colon := p.pos
+		p.next()
+		x = &ast.KeyValueExpr{x, colon, p.parseExpr()}
 	}
 
-	return x;
+	return x
 }
 
 
@@ -1030,9 +1030,9 @@ func (p *parser) parseElementList() []ast.Expr {
 		defer un(trace(p, "ElementList"))
 	}
 
-	list := new(vector.Vector);
+	list := new(vector.Vector)
 	for p.tok != token.RBRACE && p.tok != token.EOF {
-		list.Push(p.parseElement());
+		list.Push(p.parseElement())
 		if p.tok == token.COMMA {
 			p.next()
 		} else {
@@ -1041,12 +1041,12 @@ func (p *parser) parseElementList() []ast.Expr {
 	}
 
 	// convert list
-	elts := make([]ast.Expr, list.Len());
+	elts := make([]ast.Expr, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		elts[i] = list.At(i).(ast.Expr)
 	}
 
-	return elts;
+	return elts
 }
 
 
@@ -1055,13 +1055,13 @@ func (p *parser) parseCompositeLit(typ ast.Expr) ast.Expr {
 		defer un(trace(p, "CompositeLit"))
 	}
 
-	lbrace := p.expect(token.LBRACE);
-	var elts []ast.Expr;
+	lbrace := p.expect(token.LBRACE)
+	var elts []ast.Expr
 	if p.tok != token.RBRACE {
 		elts = p.parseElementList()
 	}
-	rbrace := p.expect(token.RBRACE);
-	return &ast.CompositeLit{typ, lbrace, elts, rbrace};
+	rbrace := p.expect(token.RBRACE)
+	return &ast.CompositeLit{typ, lbrace, elts, rbrace}
 }
 
 
@@ -1087,24 +1087,24 @@ func (p *parser) checkExpr(x ast.Expr) ast.Expr {
 	case *ast.TypeAssertExpr:
 		if t.Type == nil {
 			// the form X.(type) is only allowed in type switch expressions
-			p.errorExpected(x.Pos(), "expression");
-			x = &ast.BadExpr{x.Pos()};
+			p.errorExpected(x.Pos(), "expression")
+			x = &ast.BadExpr{x.Pos()}
 		}
 	case *ast.CallExpr:
 	case *ast.StarExpr:
 	case *ast.UnaryExpr:
 		if t.Op == token.RANGE {
 			// the range operator is only allowed at the top of a for statement
-			p.errorExpected(x.Pos(), "expression");
-			x = &ast.BadExpr{x.Pos()};
+			p.errorExpected(x.Pos(), "expression")
+			x = &ast.BadExpr{x.Pos()}
 		}
 	case *ast.BinaryExpr:
 	default:
 		// all other nodes are not proper expressions
-		p.errorExpected(x.Pos(), "expression");
-		x = &ast.BadExpr{x.Pos()};
+		p.errorExpected(x.Pos(), "expression")
+		x = &ast.BadExpr{x.Pos()}
 	}
-	return x;
+	return x
 }
 
 
@@ -1115,13 +1115,13 @@ func isTypeName(x ast.Expr) bool {
 	case *ast.BadExpr:
 	case *ast.Ident:
 	case *ast.ParenExpr:
-		return isTypeName(t.X)	// TODO(gri): should (TypeName) be illegal?
+		return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal?
 	case *ast.SelectorExpr:
 		return isTypeName(t.X)
 	default:
-		return false	// all other nodes are not type names
+		return false // all other nodes are not type names
 	}
-	return true;
+	return true
 }
 
 
@@ -1139,9 +1139,9 @@ func isCompositeLitType(x ast.Expr) bool {
 	case *ast.StructType:
 	case *ast.MapType:
 	default:
-		return false	// all other nodes are not legal composite literal types
+		return false // all other nodes are not legal composite literal types
 	}
-	return true;
+	return true
 }
 
 
@@ -1154,18 +1154,18 @@ func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
 	case *ast.UnaryExpr:
 		if t.Op == token.RANGE {
 			// the range operator is only allowed at the top of a for statement
-			p.errorExpected(x.Pos(), "expression");
-			x = &ast.BadExpr{x.Pos()};
+			p.errorExpected(x.Pos(), "expression")
+			x = &ast.BadExpr{x.Pos()}
 		}
 	case *ast.ArrayType:
 		if len, isEllipsis := t.Len.(*ast.Ellipsis); isEllipsis {
-			p.Error(len.Pos(), "expected array length, found '...'");
-			x = &ast.BadExpr{x.Pos()};
+			p.Error(len.Pos(), "expected array length, found '...'")
+			x = &ast.BadExpr{x.Pos()}
 		}
 	}
 
 	// all other nodes are expressions or types
-	return x;
+	return x
 }
 
 
@@ -1174,8 +1174,8 @@ func (p *parser) parsePrimaryExpr() ast.Expr {
 		defer un(trace(p, "PrimaryExpr"))
 	}
 
-	x := p.parseOperand();
-L:	for {
+	x := p.parseOperand()
+L: for {
 		switch p.tok {
 		case token.PERIOD:
 			x = p.parseSelectorOrTypeAssertion(p.checkExpr(x))
@@ -1194,7 +1194,7 @@ L:	for {
 		}
 	}
 
-	return x;
+	return x
 }
 
 
@@ -1205,20 +1205,20 @@ func (p *parser) parseUnaryExpr() ast.Expr {
 
 	switch p.tok {
 	case token.ADD, token.SUB, token.NOT, token.XOR, token.ARROW, token.AND, token.RANGE:
-		pos, op := p.pos, p.tok;
-		p.next();
-		x := p.parseUnaryExpr();
-		return &ast.UnaryExpr{pos, op, p.checkExpr(x)};
+		pos, op := p.pos, p.tok
+		p.next()
+		x := p.parseUnaryExpr()
+		return &ast.UnaryExpr{pos, op, p.checkExpr(x)}
 
 	case token.MUL:
 		// unary "*" expression or pointer type
-		pos := p.pos;
-		p.next();
-		x := p.parseUnaryExpr();
-		return &ast.StarExpr{pos, p.checkExprOrType(x)};
+		pos := p.pos
+		p.next()
+		x := p.parseUnaryExpr()
+		return &ast.StarExpr{pos, p.checkExprOrType(x)}
 	}
 
-	return p.parsePrimaryExpr();
+	return p.parsePrimaryExpr()
 }
 
 
@@ -1227,17 +1227,17 @@ func (p *parser) parseBinaryExpr(prec1 int) ast.Expr {
 		defer un(trace(p, "BinaryExpr"))
 	}
 
-	x := p.parseUnaryExpr();
+	x := p.parseUnaryExpr()
 	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);
-			x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)};
+			pos, op := p.pos, p.tok
+			p.next()
+			y := p.parseBinaryExpr(prec + 1)
+			x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)}
 		}
 	}
 
-	return x;
+	return x
 }
 
 
@@ -1248,7 +1248,7 @@ func (p *parser) parseExpr() ast.Expr {
 		defer un(trace(p, "Expression"))
 	}
 
-	return p.parseBinaryExpr(token.LowestPrec + 1);
+	return p.parseBinaryExpr(token.LowestPrec + 1)
 }
 
 
@@ -1261,19 +1261,19 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
 		defer un(trace(p, "SimpleStmt"))
 	}
 
-	x := p.parseExprList();
+	x := p.parseExprList()
 
 	switch p.tok {
 	case token.COLON:
 		// labeled statement
-		p.next();
+		p.next()
 		if labelOk && len(x) == 1 {
 			if label, isIdent := x[0].(*ast.Ident); isIdent {
 				return &ast.LabeledStmt{label, p.parseStmt()}
 			}
 		}
-		p.Error(x[0].Pos(), "illegal label declaration");
-		return &ast.BadStmt{x[0].Pos()};
+		p.Error(x[0].Pos(), "illegal label declaration")
+		return &ast.BadStmt{x[0].Pos()}
 
 	case
 		token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
@@ -1281,13 +1281,13 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
 		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();
+		pos, tok := p.pos, p.tok
+		p.next()
+		y := p.parseExprList()
 		if len(x) > 1 && len(y) > 1 && len(x) != len(y) {
 			p.Error(x[0].Pos(), "arity of lhs doesn't match rhs")
 		}
-		return &ast.AssignStmt{x, pos, tok, y};
+		return &ast.AssignStmt{x, pos, tok, y}
 	}
 
 	if len(x) > 1 {
@@ -1297,23 +1297,23 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
 
 	if p.tok == token.INC || p.tok == token.DEC {
 		// increment or decrement
-		s := &ast.IncDecStmt{x[0], p.tok};
-		p.next();	// consume "++" or "--"
-		return s;
+		s := &ast.IncDecStmt{x[0], p.tok}
+		p.next() // consume "++" or "--"
+		return s
 	}
 
 	// expression
-	return &ast.ExprStmt{x[0]};
+	return &ast.ExprStmt{x[0]}
 }
 
 
 func (p *parser) parseCallExpr() *ast.CallExpr {
-	x := p.parseExpr();
+	x := p.parseExpr()
 	if call, isCall := x.(*ast.CallExpr); isCall {
 		return call
 	}
-	p.errorExpected(x.Pos(), "function/method call");
-	return nil;
+	p.errorExpected(x.Pos(), "function/method call")
+	return nil
 }
 
 
@@ -1322,12 +1322,12 @@ func (p *parser) parseGoStmt() ast.Stmt {
 		defer un(trace(p, "GoStmt"))
 	}
 
-	pos := p.expect(token.GO);
-	call := p.parseCallExpr();
+	pos := p.expect(token.GO)
+	call := p.parseCallExpr()
 	if call != nil {
 		return &ast.GoStmt{pos, call}
 	}
-	return &ast.BadStmt{pos};
+	return &ast.BadStmt{pos}
 }
 
 
@@ -1336,12 +1336,12 @@ func (p *parser) parseDeferStmt() ast.Stmt {
 		defer un(trace(p, "DeferStmt"))
 	}
 
-	pos := p.expect(token.DEFER);
-	call := p.parseCallExpr();
+	pos := p.expect(token.DEFER)
+	call := p.parseCallExpr()
 	if call != nil {
 		return &ast.DeferStmt{pos, call}
 	}
-	return &ast.BadStmt{pos};
+	return &ast.BadStmt{pos}
 }
 
 
@@ -1350,14 +1350,14 @@ func (p *parser) parseReturnStmt() *ast.ReturnStmt {
 		defer un(trace(p, "ReturnStmt"))
 	}
 
-	pos := p.pos;
-	p.expect(token.RETURN);
-	var x []ast.Expr;
+	pos := p.pos
+	p.expect(token.RETURN)
+	var x []ast.Expr
 	if p.tok != token.SEMICOLON && p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE {
 		x = p.parseExprList()
 	}
 
-	return &ast.ReturnStmt{pos, x};
+	return &ast.ReturnStmt{pos, x}
 }
 
 
@@ -1366,13 +1366,13 @@ func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
 		defer un(trace(p, "BranchStmt"))
 	}
 
-	s := &ast.BranchStmt{p.pos, tok, nil};
-	p.expect(tok);
+	s := &ast.BranchStmt{p.pos, tok, nil}
+	p.expect(tok)
 	if tok != token.FALLTHROUGH && p.tok == token.IDENT {
 		s.Label = p.parseIdent()
 	}
 
-	return s;
+	return s
 }
 
 
@@ -1383,27 +1383,27 @@ func (p *parser) makeExpr(s ast.Stmt) ast.Expr {
 	if es, isExpr := s.(*ast.ExprStmt); isExpr {
 		return p.checkExpr(es.X)
 	}
-	p.Error(s.Pos(), "expected condition, found simple statement");
-	return &ast.BadExpr{s.Pos()};
+	p.Error(s.Pos(), "expected condition, found simple statement")
+	return &ast.BadExpr{s.Pos()}
 }
 
 
 func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
 	if p.tok != token.LBRACE {
-		prevLev := p.exprLev;
-		p.exprLev = -1;
+		prevLev := p.exprLev
+		p.exprLev = -1
 
 		if p.tok != token.SEMICOLON {
 			s1 = p.parseSimpleStmt(false)
 		}
 		if p.tok == token.SEMICOLON {
-			p.next();
+			p.next()
 			if p.tok != token.LBRACE && p.tok != token.SEMICOLON {
 				s2 = p.parseSimpleStmt(false)
 			}
 			if isForStmt {
 				// for statements have a 3rd section
-				p.expect(token.SEMICOLON);
+				p.expect(token.SEMICOLON)
 				if p.tok != token.LBRACE {
 					s3 = p.parseSimpleStmt(false)
 				}
@@ -1412,10 +1412,10 @@ func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
 			s1, s2 = nil, s1
 		}
 
-		p.exprLev = prevLev;
+		p.exprLev = prevLev
 	}
 
-	return s1, s2, s3;
+	return s1, s2, s3
 }
 
 
@@ -1425,18 +1425,18 @@ func (p *parser) parseIfStmt() *ast.IfStmt {
 	}
 
 	// IfStmt block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
-	pos := p.expect(token.IF);
-	s1, s2, _ := p.parseControlClause(false);
-	body := p.parseBlockStmt(nil);
-	var else_ ast.Stmt;
+	pos := p.expect(token.IF)
+	s1, s2, _ := p.parseControlClause(false)
+	body := p.parseBlockStmt(nil)
+	var else_ ast.Stmt
 	if p.tok == token.ELSE {
-		p.next();
-		else_ = p.parseStmt();
+		p.next()
+		else_ = p.parseStmt()
 	}
 
-	return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_};
+	return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_}
 }
 
 
@@ -1446,22 +1446,22 @@ func (p *parser) parseCaseClause() *ast.CaseClause {
 	}
 
 	// CaseClause block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
 	// SwitchCase
-	pos := p.pos;
-	var x []ast.Expr;
+	pos := p.pos
+	var x []ast.Expr
 	if p.tok == token.CASE {
-		p.next();
-		x = p.parseExprList();
+		p.next()
+		x = p.parseExprList()
 	} else {
 		p.expect(token.DEFAULT)
 	}
 
-	colon := p.expect(token.COLON);
-	body := p.parseStmtList();
+	colon := p.expect(token.COLON)
+	body := p.parseStmtList()
 
-	return &ast.CaseClause{pos, x, colon, body};
+	return &ast.CaseClause{pos, x, colon, body}
 }
 
 
@@ -1470,20 +1470,20 @@ func (p *parser) parseTypeList() []ast.Expr {
 		defer un(trace(p, "TypeList"))
 	}
 
-	list := new(vector.Vector);
-	list.Push(p.parseType());
+	list := new(vector.Vector)
+	list.Push(p.parseType())
 	for p.tok == token.COMMA {
-		p.next();
-		list.Push(p.parseType());
+		p.next()
+		list.Push(p.parseType())
 	}
 
 	// convert list
-	exprs := make([]ast.Expr, list.Len());
+	exprs := make([]ast.Expr, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		exprs[i] = list.At(i).(ast.Expr)
 	}
 
-	return exprs;
+	return exprs
 }
 
 
@@ -1493,22 +1493,22 @@ func (p *parser) parseTypeCaseClause() *ast.TypeCaseClause {
 	}
 
 	// TypeCaseClause block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
 	// TypeSwitchCase
-	pos := p.pos;
-	var types []ast.Expr;
+	pos := p.pos
+	var types []ast.Expr
 	if p.tok == token.CASE {
-		p.next();
-		types = p.parseTypeList();
+		p.next()
+		types = p.parseTypeList()
 	} else {
 		p.expect(token.DEFAULT)
 	}
 
-	colon := p.expect(token.COLON);
-	body := p.parseStmtList();
+	colon := p.expect(token.COLON)
+	body := p.parseStmtList()
 
-	return &ast.TypeCaseClause{pos, types, colon, body};
+	return &ast.TypeCaseClause{pos, types, colon, body}
 }
 
 
@@ -1518,11 +1518,11 @@ func isExprSwitch(s ast.Stmt) bool {
 	}
 	if e, ok := s.(*ast.ExprStmt); ok {
 		if a, ok := e.X.(*ast.TypeAssertExpr); ok {
-			return a.Type != nil	// regular type assertion
+			return a.Type != nil // regular type assertion
 		}
-		return true;
+		return true
 	}
-	return false;
+	return false
 }
 
 
@@ -1532,34 +1532,34 @@ func (p *parser) parseSwitchStmt() ast.Stmt {
 	}
 
 	// SwitchStmt block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
-	pos := p.expect(token.SWITCH);
-	s1, s2, _ := p.parseControlClause(false);
+	pos := p.expect(token.SWITCH)
+	s1, s2, _ := p.parseControlClause(false)
 
 	if isExprSwitch(s2) {
-		lbrace := p.expect(token.LBRACE);
-		cases := new(vector.Vector);
+		lbrace := p.expect(token.LBRACE)
+		cases := new(vector.Vector)
 		for p.tok == token.CASE || p.tok == token.DEFAULT {
 			cases.Push(p.parseCaseClause())
 		}
-		rbrace := p.expect(token.RBRACE);
-		p.optSemi = true;
-		body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace};
-		return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body};
+		rbrace := p.expect(token.RBRACE)
+		p.optSemi = true
+		body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}
+		return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body}
 	}
 
 	// type switch
 	// TODO(gri): do all the checks!
-	lbrace := p.expect(token.LBRACE);
-	cases := new(vector.Vector);
+	lbrace := p.expect(token.LBRACE)
+	cases := new(vector.Vector)
 	for p.tok == token.CASE || p.tok == token.DEFAULT {
 		cases.Push(p.parseTypeCaseClause())
 	}
-	rbrace := p.expect(token.RBRACE);
-	p.optSemi = true;
-	body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace};
-	return &ast.TypeSwitchStmt{pos, s1, s2, body};
+	rbrace := p.expect(token.RBRACE)
+	p.optSemi = true
+	body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}
+	return &ast.TypeSwitchStmt{pos, s1, s2, body}
 }
 
 
@@ -1569,29 +1569,29 @@ func (p *parser) parseCommClause() *ast.CommClause {
 	}
 
 	// CommClause block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
 	// CommCase
-	pos := p.pos;
-	var tok token.Token;
-	var lhs, rhs ast.Expr;
+	pos := p.pos
+	var tok token.Token
+	var lhs, rhs ast.Expr
 	if p.tok == token.CASE {
-		p.next();
+		p.next()
 		if p.tok == token.ARROW {
 			// RecvExpr without assignment
 			rhs = p.parseExpr()
 		} else {
 			// SendExpr or RecvExpr
-			rhs = p.parseExpr();
+			rhs = p.parseExpr()
 			if p.tok == token.ASSIGN || p.tok == token.DEFINE {
 				// RecvExpr with assignment
-				tok = p.tok;
-				p.next();
-				lhs = rhs;
+				tok = p.tok
+				p.next()
+				lhs = rhs
 				if p.tok == token.ARROW {
 					rhs = p.parseExpr()
 				} else {
-					p.expect(token.ARROW)	// use expect() error handling
+					p.expect(token.ARROW) // use expect() error handling
 				}
 			}
 			// else SendExpr
@@ -1600,10 +1600,10 @@ func (p *parser) parseCommClause() *ast.CommClause {
 		p.expect(token.DEFAULT)
 	}
 
-	colon := p.expect(token.COLON);
-	body := p.parseStmtList();
+	colon := p.expect(token.COLON)
+	body := p.parseStmtList()
 
-	return &ast.CommClause{pos, tok, lhs, rhs, colon, body};
+	return &ast.CommClause{pos, tok, lhs, rhs, colon, body}
 }
 
 
@@ -1612,17 +1612,17 @@ func (p *parser) parseSelectStmt() *ast.SelectStmt {
 		defer un(trace(p, "SelectStmt"))
 	}
 
-	pos := p.expect(token.SELECT);
-	lbrace := p.expect(token.LBRACE);
-	cases := new(vector.Vector);
+	pos := p.expect(token.SELECT)
+	lbrace := p.expect(token.LBRACE)
+	cases := new(vector.Vector)
 	for p.tok == token.CASE || p.tok == token.DEFAULT {
 		cases.Push(p.parseCommClause())
 	}
-	rbrace := p.expect(token.RBRACE);
-	p.optSemi = true;
-	body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace};
+	rbrace := p.expect(token.RBRACE)
+	p.optSemi = true
+	body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}
 
-	return &ast.SelectStmt{pos, body};
+	return &ast.SelectStmt{pos, body}
 }
 
 
@@ -1632,49 +1632,49 @@ func (p *parser) parseForStmt() ast.Stmt {
 	}
 
 	// ForStmt block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
-	pos := p.expect(token.FOR);
-	s1, s2, s3 := p.parseControlClause(true);
-	body := p.parseBlockStmt(nil);
+	pos := p.expect(token.FOR)
+	s1, s2, s3 := p.parseControlClause(true)
+	body := p.parseBlockStmt(nil)
 
 	if as, isAssign := s2.(*ast.AssignStmt); isAssign {
 		// possibly a for statement with a range clause; check assignment operator
 		if as.Tok != token.ASSIGN && as.Tok != token.DEFINE {
-			p.errorExpected(as.TokPos, "'=' or ':='");
-			return &ast.BadStmt{pos};
+			p.errorExpected(as.TokPos, "'=' or ':='")
+			return &ast.BadStmt{pos}
 		}
 		// check lhs
-		var key, value ast.Expr;
+		var key, value ast.Expr
 		switch len(as.Lhs) {
 		case 2:
-			value = as.Lhs[1];
-			fallthrough;
+			value = as.Lhs[1]
+			fallthrough
 		case 1:
 			key = as.Lhs[0]
 		default:
-			p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions");
-			return &ast.BadStmt{pos};
+			p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions")
+			return &ast.BadStmt{pos}
 		}
 		// check rhs
 		if len(as.Rhs) != 1 {
-			p.errorExpected(as.Rhs[0].Pos(), "1 expressions");
-			return &ast.BadStmt{pos};
+			p.errorExpected(as.Rhs[0].Pos(), "1 expressions")
+			return &ast.BadStmt{pos}
 		}
 		if rhs, isUnary := as.Rhs[0].(*ast.UnaryExpr); isUnary && rhs.Op == token.RANGE {
 			// rhs is range expression; check lhs
 			return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body}
 		} else {
-			p.errorExpected(s2.Pos(), "range clause");
-			return &ast.BadStmt{pos};
+			p.errorExpected(s2.Pos(), "range clause")
+			return &ast.BadStmt{pos}
 		}
 	} else {
 		// regular for statement
 		return &ast.ForStmt{pos, s1, p.makeExpr(s2), s3, body}
 	}
 
-	panic();	// unreachable
-	return nil;
+	panic() // unreachable
+	return nil
 }
 
 
@@ -1685,13 +1685,13 @@ func (p *parser) parseStmt() ast.Stmt {
 
 	switch p.tok {
 	case token.CONST, token.TYPE, token.VAR:
-		decl, _ := p.parseDecl(false);	// do not consume trailing semicolon
-		return &ast.DeclStmt{decl};
+		decl, _ := p.parseDecl(false) // do not consume trailing semicolon
+		return &ast.DeclStmt{decl}
 	case
 		// tokens that may start a top-level expression
-		token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN,	// operand
-		token.LBRACK, token.STRUCT,	// composite type
-		token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR:	// unary operators
+		token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand
+		token.LBRACK, token.STRUCT, // composite type
+		token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators
 		return p.parseSimpleStmt(true)
 	case token.GO:
 		return p.parseGoStmt()
@@ -1717,9 +1717,9 @@ func (p *parser) parseStmt() ast.Stmt {
 	}
 
 	// no statement found
-	p.errorExpected(p.pos, "statement");
-	p.next();	// make progress
-	return &ast.BadStmt{p.pos};
+	p.errorExpected(p.pos, "statement")
+	p.next() // make progress
+	return &ast.BadStmt{p.pos}
 }
 
 
@@ -1734,10 +1734,10 @@ type parseSpecFunction func(p *parser, doc *ast.CommentGroup, getSemi bool) (spe
 //
 func (p *parser) parseComment(getSemi bool) (comment *ast.CommentGroup, gotSemi bool) {
 	if getSemi && p.tok == token.SEMICOLON {
-		p.next();
-		gotSemi = true;
+		p.next()
+		gotSemi = true
 	}
-	return p.lineComment, gotSemi;
+	return p.lineComment, gotSemi
 }
 
 
@@ -1746,24 +1746,24 @@ func parseImportSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.S
 		defer un(trace(p, "ImportSpec"))
 	}
 
-	var ident *ast.Ident;
+	var ident *ast.Ident
 	if p.tok == token.PERIOD {
-		ident = &ast.Ident{p.pos, "."};
-		p.next();
+		ident = &ast.Ident{p.pos, "."}
+		p.next()
 	} else if p.tok == token.IDENT {
 		ident = p.parseIdent()
 	}
 
-	var path []*ast.BasicLit;
+	var path []*ast.BasicLit
 	if p.tok == token.STRING {
 		path = p.parseStringList(nil)
 	} else {
-		p.expect(token.STRING)	// use expect() error handling
+		p.expect(token.STRING) // use expect() error handling
 	}
 
-	comment, gotSemi := p.parseComment(getSemi);
+	comment, gotSemi := p.parseComment(getSemi)
 
-	return &ast.ImportSpec{doc, ident, path, comment}, gotSemi;
+	return &ast.ImportSpec{doc, ident, path, comment}, gotSemi
 }
 
 
@@ -1772,16 +1772,16 @@ func parseConstSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Sp
 		defer un(trace(p, "ConstSpec"))
 	}
 
-	idents := p.parseIdentList();
-	typ := p.tryType();
-	var values []ast.Expr;
+	idents := p.parseIdentList()
+	typ := p.tryType()
+	var values []ast.Expr
 	if typ != nil || p.tok == token.ASSIGN {
-		p.expect(token.ASSIGN);
-		values = p.parseExprList();
+		p.expect(token.ASSIGN)
+		values = p.parseExprList()
 	}
-	comment, gotSemi := p.parseComment(getSemi);
+	comment, gotSemi := p.parseComment(getSemi)
 
-	return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi;
+	return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi
 }
 
 
@@ -1790,11 +1790,11 @@ func parseTypeSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Spe
 		defer un(trace(p, "TypeSpec"))
 	}
 
-	ident := p.parseIdent();
-	typ := p.parseType();
-	comment, gotSemi := p.parseComment(getSemi);
+	ident := p.parseIdent()
+	typ := p.parseType()
+	comment, gotSemi := p.parseComment(getSemi)
 
-	return &ast.TypeSpec{doc, ident, typ, comment}, gotSemi;
+	return &ast.TypeSpec{doc, ident, typ, comment}, gotSemi
 }
 
 
@@ -1803,16 +1803,16 @@ func parseVarSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Spec
 		defer un(trace(p, "VarSpec"))
 	}
 
-	idents := p.parseIdentList();
-	typ := p.tryType();
-	var values []ast.Expr;
+	idents := p.parseIdentList()
+	typ := p.tryType()
+	var values []ast.Expr
 	if typ == nil || p.tok == token.ASSIGN {
-		p.expect(token.ASSIGN);
-		values = p.parseExprList();
+		p.expect(token.ASSIGN)
+		values = p.parseExprList()
 	}
-	comment, gotSemi := p.parseComment(getSemi);
+	comment, gotSemi := p.parseComment(getSemi)
 
-	return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi;
+	return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi
 }
 
 
@@ -1821,42 +1821,42 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction, getSemi
 		defer un(trace(p, keyword.String()+"Decl"))
 	}
 
-	doc := p.leadComment;
-	pos := p.expect(keyword);
-	var lparen, rparen token.Position;
-	list := new(vector.Vector);
+	doc := p.leadComment
+	pos := p.expect(keyword)
+	var lparen, rparen token.Position
+	list := new(vector.Vector)
 	if p.tok == token.LPAREN {
-		lparen = p.pos;
-		p.next();
+		lparen = p.pos
+		p.next()
 		for p.tok != token.RPAREN && p.tok != token.EOF {
-			doc := p.leadComment;
-			spec, semi := f(p, doc, true);	// consume semicolon if any
-			list.Push(spec);
+			doc := p.leadComment
+			spec, semi := f(p, doc, true) // consume semicolon if any
+			list.Push(spec)
 			if !semi {
 				break
 			}
 		}
-		rparen = p.expect(token.RPAREN);
+		rparen = p.expect(token.RPAREN)
 
 		if getSemi && p.tok == token.SEMICOLON {
-			p.next();
-			gotSemi = true;
+			p.next()
+			gotSemi = true
 		} else {
 			p.optSemi = true
 		}
 	} else {
-		spec, semi := f(p, nil, getSemi);
-		list.Push(spec);
-		gotSemi = semi;
+		spec, semi := f(p, nil, getSemi)
+		list.Push(spec)
+		gotSemi = semi
 	}
 
 	// convert vector
-	specs := make([]ast.Spec, list.Len());
+	specs := make([]ast.Spec, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		specs[i] = list.At(i).(ast.Spec)
 	}
 
-	return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}, gotSemi;
+	return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}, gotSemi
 }
 
 
@@ -1865,19 +1865,19 @@ func (p *parser) parseReceiver() *ast.Field {
 		defer un(trace(p, "Receiver"))
 	}
 
-	pos := p.pos;
-	par := p.parseParameters(false);
+	pos := p.pos
+	par := p.parseParameters(false)
 
 	// must have exactly one receiver
 	if len(par) != 1 || len(par) == 1 && len(par[0].Names) > 1 {
-		p.errorExpected(pos, "exactly one receiver");
-		return &ast.Field{Type: &ast.BadExpr{noPos}};
+		p.errorExpected(pos, "exactly one receiver")
+		return &ast.Field{Type: &ast.BadExpr{noPos}}
 	}
 
-	recv := par[0];
+	recv := par[0]
 
 	// recv type must be TypeName or *TypeName
-	base := recv.Type;
+	base := recv.Type
 	if ptr, isPtr := base.(*ast.StarExpr); isPtr {
 		base = ptr.X
 	}
@@ -1885,7 +1885,7 @@ func (p *parser) parseReceiver() *ast.Field {
 		p.errorExpected(base.Pos(), "type name")
 	}
 
-	return recv;
+	return recv
 }
 
 
@@ -1894,23 +1894,23 @@ func (p *parser) parseFunctionDecl() *ast.FuncDecl {
 		defer un(trace(p, "FunctionDecl"))
 	}
 
-	doc := p.leadComment;
-	pos := p.expect(token.FUNC);
+	doc := p.leadComment
+	pos := p.expect(token.FUNC)
 
-	var recv *ast.Field;
+	var recv *ast.Field
 	if p.tok == token.LPAREN {
 		recv = p.parseReceiver()
 	}
 
-	ident := p.parseIdent();
-	params, results := p.parseSignature();
+	ident := p.parseIdent()
+	params, results := p.parseSignature()
 
-	var body *ast.BlockStmt;
+	var body *ast.BlockStmt
 	if p.tok == token.LBRACE {
 		body = p.parseBlockStmt(nil)
 	}
 
-	return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body};
+	return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body}
 }
 
 
@@ -1919,7 +1919,7 @@ func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) {
 		defer un(trace(p, "Declaration"))
 	}
 
-	var f parseSpecFunction;
+	var f parseSpecFunction
 	switch p.tok {
 	case token.CONST:
 		f = parseConstSpec
@@ -1931,20 +1931,20 @@ func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) {
 		f = parseVarSpec
 
 	case token.FUNC:
-		decl = p.parseFunctionDecl();
-		_, gotSemi := p.parseComment(getSemi);
-		return decl, gotSemi;
+		decl = p.parseFunctionDecl()
+		_, gotSemi := p.parseComment(getSemi)
+		return decl, gotSemi
 
 	default:
-		pos := p.pos;
-		p.errorExpected(pos, "declaration");
-		decl = &ast.BadDecl{pos};
-		gotSemi = getSemi && p.tok == token.SEMICOLON;
-		p.next();	// make progress in any case
-		return decl, gotSemi;
+		pos := p.pos
+		p.errorExpected(pos, "declaration")
+		decl = &ast.BadDecl{pos}
+		gotSemi = getSemi && p.tok == token.SEMICOLON
+		p.next() // make progress in any case
+		return decl, gotSemi
 	}
 
-	return p.parseGenDecl(p.tok, f, getSemi);
+	return p.parseGenDecl(p.tok, f, getSemi)
 }
 
 
@@ -1953,19 +1953,19 @@ func (p *parser) parseDeclList() []ast.Decl {
 		defer un(trace(p, "DeclList"))
 	}
 
-	list := new(vector.Vector);
+	list := new(vector.Vector)
 	for p.tok != token.EOF {
-		decl, _ := p.parseDecl(true);	// consume optional semicolon
-		list.Push(decl);
+		decl, _ := p.parseDecl(true) // consume optional semicolon
+		list.Push(decl)
 	}
 
 	// convert vector
-	decls := make([]ast.Decl, list.Len());
+	decls := make([]ast.Decl, list.Len())
 	for i := 0; i < list.Len(); i++ {
 		decls[i] = list.At(i).(ast.Decl)
 	}
 
-	return decls;
+	return decls
 }
 
 
@@ -1978,47 +1978,47 @@ func (p *parser) parseFile() *ast.File {
 	}
 
 	// file block
-	defer close(openScope(p));
+	defer close(openScope(p))
 
 	// package clause
-	doc := p.leadComment;
-	pos := p.expect(token.PACKAGE);
-	ident := p.parseIdent();
+	doc := p.leadComment
+	pos := p.expect(token.PACKAGE)
+	ident := p.parseIdent()
 
 	// Common error: semicolon after package clause.
 	// Accept and report it for better error synchronization.
 	if p.tok == token.SEMICOLON {
-		p.Error(p.pos, "expected declaration, found ';'");
-		p.next();
+		p.Error(p.pos, "expected declaration, found ';'")
+		p.next()
 	}
 
-	var decls []ast.Decl;
+	var decls []ast.Decl
 
 	// Don't bother parsing the rest if we had errors already.
 	// Likely not a Go source file at all.
 
 	if p.ErrorCount() == 0 && p.mode&PackageClauseOnly == 0 {
 		// import decls
-		list := new(vector.Vector);
+		list := new(vector.Vector)
 		for p.tok == token.IMPORT {
-			decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true);	// consume optional semicolon
-			list.Push(decl);
+			decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true) // consume optional semicolon
+			list.Push(decl)
 		}
 
 		if p.mode&ImportsOnly == 0 {
 			// rest of package body
 			for p.tok != token.EOF {
-				decl, _ := p.parseDecl(true);	// consume optional semicolon
-				list.Push(decl);
+				decl, _ := p.parseDecl(true) // consume optional semicolon
+				list.Push(decl)
 			}
 		}
 
 		// convert declaration list
-		decls = make([]ast.Decl, list.Len());
+		decls = make([]ast.Decl, list.Len())
 		for i := 0; i < list.Len(); i++ {
 			decls[i] = list.At(i).(ast.Decl)
 		}
 	}
 
-	return &ast.File{doc, pos, ident, decls, p.comments};
+	return &ast.File{doc, pos, ident, decls, p.comments}
 }