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

3rd set of files.

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

1 files changed, 525 insertions, 525 deletions

diff --git a/src/pkg/go/parser/parser.go b/src/pkg/go/parser/parser.go
index fa6fb545e..bd7ca158e 100644
--- a/src/pkg/go/parser/parser.go
+++ b/src/pkg/go/parser/parser.go
@@ -10,11 +10,11 @@
 package parser
 
 import (
-	"container/vector";
-	"fmt";
-	"go/ast";
-	"go/scanner";
-	"go/token";
+	"container/vector"
+	"fmt"
+	"go/ast"
+	"go/scanner"
+	"go/token"
 )
 
 
@@ -27,59 +27,59 @@ 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
-	exprLev	int;	// < 0: in control clause, >= 0: in expression
+	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
 }
 
 
 // scannerMode returns the scanner mode bits given the parser's mode bits.
 func scannerMode(mode uint) uint {
-	var m uint = scanner.InsertSemis;
+	var m uint = scanner.InsertSemis
 	if mode&ParseComments != 0 {
 		m |= scanner.ScanComments
 	}
-	return m;
+	return m
 }
 
 
 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()
 }
 
 
@@ -88,29 +88,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(")")
 }
 
 
@@ -121,7 +121,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))
@@ -132,14 +132,14 @@ func (p *parser) next0() {
 		}
 	}
 
-	p.pos, p.tok, p.lit = p.scanner.Scan();
+	p.pos, p.tok, p.lit = p.scanner.Scan()
 }
 
 // Consume a comment and return it and the line on which it ends.
 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' {
@@ -148,10 +148,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
 }
 
 
@@ -161,30 +161,30 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
 // a comment group.
 //
 func (p *parser) consumeCommentGroup() int {
-	var list vector.Vector;
-	endline := p.pos.Line;
+	var list 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
 }
 
 
@@ -204,16 +204,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.
@@ -222,7 +222,7 @@ func (p *parser) next() {
 		}
 
 		// consume successor comments, if any
-		endline := -1;
+		endline := -1
 		for p.tok == token.COMMENT {
 			endline = p.consumeCommentGroup()
 		}
@@ -237,26 +237,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) expectSemi() {
 // 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,29 +313,29 @@ func (p *parser) parseIdentList() []*ast.Ident {
 		defer un(trace(p, "IdentList"))
 	}
 
-	var list vector.Vector;
-	list.Push(p.parseIdent());
+	var list 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
 }
 
 
 func makeExprList(list *vector.Vector) []ast.Expr {
-	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
 }
 
 
@@ -344,14 +344,14 @@ func (p *parser) parseExprList() []ast.Expr {
 		defer un(trace(p, "ExpressionList"))
 	}
 
-	var list vector.Vector;
-	list.Push(p.parseExpr());
+	var list vector.Vector
+	list.Push(p.parseExpr())
 	for p.tok == token.COMMA {
-		p.next();
-		list.Push(p.parseExpr());
+		p.next()
+		list.Push(p.parseExpr())
 	}
 
-	return makeExprList(&list);
+	return makeExprList(&list)
 }
 
 
@@ -363,15 +363,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
 }
 
 
@@ -380,14 +380,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
 }
 
 
@@ -396,7 +396,7 @@ func (p *parser) parseTypeName() ast.Expr {
 		defer un(trace(p, "TypeName"))
 	}
 
-	return p.parseQualifiedIdent();
+	return p.parseQualifiedIdent()
 }
 
 
@@ -405,33 +405,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
 }
 
 
@@ -440,32 +440,32 @@ 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
-	var list vector.Vector;
+	var list vector.Vector
 	for {
 		// TODO(gri): do not allow ()'s here
-		list.Push(p.parseType());
+		list.Push(p.parseType())
 		if p.tok != token.COMMA {
 			break
 		}
-		p.next();
+		p.next()
 	}
 
 	// 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 {
-		x := &ast.BasicLit{p.pos, p.tok, p.lit};
-		p.next();
-		tag = []*ast.BasicLit{x};
+		x := &ast.BasicLit{p.pos, p.tok, p.lit}
+		p.next()
+		tag = []*ast.BasicLit{x}
 	}
 
 	// analyze case
-	var idents []*ast.Ident;
+	var idents []*ast.Ident
 	if typ != nil {
 		// IdentifierList Type
 		idents = p.makeIdentList(&list)
@@ -475,14 +475,14 @@ 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}
 		}
 	}
 
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.Field{doc, idents, typ, tag, p.lineComment};
+	return &ast.Field{doc, idents, typ, tag, p.lineComment}
 }
 
 
@@ -491,21 +491,21 @@ func (p *parser) parseStructType() *ast.StructType {
 		defer un(trace(p, "StructType"))
 	}
 
-	pos := p.expect(token.STRUCT);
-	lbrace := p.expect(token.LBRACE);
-	var list vector.Vector;
+	pos := p.expect(token.STRUCT)
+	lbrace := p.expect(token.LBRACE)
+	var list vector.Vector
 	for p.tok == token.IDENT || p.tok == token.MUL {
 		list.Push(p.parseFieldDecl())
 	}
-	rbrace := p.expect(token.RBRACE);
+	rbrace := p.expect(token.RBRACE)
 
 	// 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,20 +552,20 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr)
 	}
 
 	// a list of identifiers looks like a list of type names
-	var list vector.Vector;
+	var list 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 {
 			break
 		}
-		p.next();
+		p.next()
 	}
 
 	// 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
 }
 
 
@@ -574,24 +574,24 @@ 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})
 		if p.tok == token.COMMA {
 			p.next()
 		}
 
 		for p.tok != token.RPAREN && p.tok != token.EOF {
-			idents := p.parseIdentList();
-			typ := p.parseParameterType(ellipsisOk);
-			list.Push(&ast.Field{nil, idents, typ, nil, nil});
+			idents := p.parseIdentList()
+			typ := p.parseParameterType(ellipsisOk)
+			list.Push(&ast.Field{nil, idents, typ, nil, nil})
 			if p.tok != token.COMMA {
 				break
 			}
-			p.next();
+			p.next()
 		}
 
 	} else {
@@ -603,12 +603,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
 }
 
 
@@ -617,14 +617,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
 }
 
 
@@ -633,18 +633,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
 }
 
 
@@ -653,10 +653,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
 }
 
 
@@ -665,10 +665,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}
 }
 
 
@@ -677,22 +677,22 @@ 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
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.Field{doc, idents, typ, nil, p.lineComment};
+	return &ast.Field{doc, idents, typ, nil, p.lineComment}
 }
 
 
@@ -701,21 +701,21 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 		defer un(trace(p, "InterfaceType"))
 	}
 
-	pos := p.expect(token.INTERFACE);
-	lbrace := p.expect(token.LBRACE);
-	var list vector.Vector;
+	pos := p.expect(token.INTERFACE)
+	lbrace := p.expect(token.LBRACE)
+	var list vector.Vector
 	for p.tok == token.IDENT {
 		list.Push(p.parseMethodSpec())
 	}
-	rbrace := p.expect(token.RBRACE);
+	rbrace := p.expect(token.RBRACE)
 
 	// 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,12 +809,12 @@ func (p *parser) parseStmtList() []ast.Stmt {
 		defer un(trace(p, "StatementList"))
 	}
 
-	var list vector.Vector;
+	var list vector.Vector
 	for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
 		list.Push(p.parseStmt())
 	}
 
-	return makeStmtList(&list);
+	return makeStmtList(&list)
 }
 
 
@@ -823,13 +823,13 @@ func (p *parser) parseBlockStmt() *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);
+	lbrace := p.expect(token.LBRACE)
+	list := p.parseStmtList()
+	rbrace := p.expect(token.RBRACE)
 
-	return &ast.BlockStmt{lbrace, list, rbrace};
+	return &ast.BlockStmt{lbrace, list, rbrace}
 }
 
 
@@ -841,17 +841,17 @@ 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();
-	p.exprLev--;
+	p.exprLev++
+	body := p.parseBlockStmt()
+	p.exprLev--
 
-	return &ast.FuncLit{typ, body};
+	return &ast.FuncLit{typ, body}
 }
 
 
@@ -868,32 +868,32 @@ 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();
-		return x;
+		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();
-		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}
 }
 
 
@@ -902,25 +902,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}
 }
 
 
@@ -929,23 +929,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
 }
 
 
@@ -954,20 +954,20 @@ func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
 		defer un(trace(p, "CallOrConversion"))
 	}
 
-	lparen := p.expect(token.LPAREN);
-	p.exprLev++;
-	var list vector.Vector;
+	lparen := p.expect(token.LPAREN)
+	p.exprLev++
+	var list vector.Vector
 	for p.tok != token.RPAREN && p.tok != token.EOF {
-		list.Push(p.parseExpr());
+		list.Push(p.parseExpr())
 		if p.tok != token.COMMA {
 			break
 		}
-		p.next();
+		p.next()
 	}
-	p.exprLev--;
-	rparen := p.expect(token.RPAREN);
+	p.exprLev--
+	rparen := p.expect(token.RPAREN)
 
-	return &ast.CallExpr{fun, lparen, makeExprList(&list), rparen};
+	return &ast.CallExpr{fun, lparen, makeExprList(&list), rparen}
 }
 
 
@@ -976,14 +976,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
 }
 
 
@@ -992,16 +992,16 @@ func (p *parser) parseElementList() []ast.Expr {
 		defer un(trace(p, "ElementList"))
 	}
 
-	var list vector.Vector;
+	var list vector.Vector
 	for p.tok != token.RBRACE && p.tok != token.EOF {
-		list.Push(p.parseElement());
+		list.Push(p.parseElement())
 		if p.tok != token.COMMA {
 			break
 		}
-		p.next();
+		p.next()
 	}
 
-	return makeExprList(&list);
+	return makeExprList(&list)
 }
 
 
@@ -1010,13 +1010,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}
 }
 
 
@@ -1042,24 +1042,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
 }
 
 
@@ -1070,13 +1070,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
 }
 
 
@@ -1094,9 +1094,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
 }
 
 
@@ -1109,18 +1109,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
 }
 
 
@@ -1129,8 +1129,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))
@@ -1149,7 +1149,7 @@ L:	for {
 		}
 	}
 
-	return x;
+	return x
 }
 
 
@@ -1160,20 +1160,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()
 }
 
 
@@ -1182,17 +1182,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
 }
 
 
@@ -1203,7 +1203,7 @@ func (p *parser) parseExpr() ast.Expr {
 		defer un(trace(p, "Expression"))
 	}
 
-	return p.parseBinaryExpr(token.LowestPrec + 1);
+	return p.parseBinaryExpr(token.LowestPrec + 1)
 }
 
 
@@ -1215,19 +1215,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,
@@ -1235,13 +1235,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 {
@@ -1251,23 +1251,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
 }
 
 
@@ -1276,14 +1276,14 @@ func (p *parser) parseGoStmt() ast.Stmt {
 		defer un(trace(p, "GoStmt"))
 	}
 
-	pos := p.expect(token.GO);
-	call := p.parseCallExpr();
-	p.expectSemi();
+	pos := p.expect(token.GO)
+	call := p.parseCallExpr()
+	p.expectSemi()
 	if call == nil {
 		return &ast.BadStmt{pos}
 	}
 
-	return &ast.GoStmt{pos, call};
+	return &ast.GoStmt{pos, call}
 }
 
 
@@ -1292,14 +1292,14 @@ func (p *parser) parseDeferStmt() ast.Stmt {
 		defer un(trace(p, "DeferStmt"))
 	}
 
-	pos := p.expect(token.DEFER);
-	call := p.parseCallExpr();
-	p.expectSemi();
+	pos := p.expect(token.DEFER)
+	call := p.parseCallExpr()
+	p.expectSemi()
 	if call == nil {
 		return &ast.BadStmt{pos}
 	}
 
-	return &ast.DeferStmt{pos, call};
+	return &ast.DeferStmt{pos, call}
 }
 
 
@@ -1308,15 +1308,15 @@ 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.RBRACE {
 		x = p.parseExprList()
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.ReturnStmt{pos, x};
+	return &ast.ReturnStmt{pos, x}
 }
 
 
@@ -1325,14 +1325,14 @@ 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()
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return s;
+	return s
 }
 
 
@@ -1343,27 +1343,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.expectSemi();
+				p.expectSemi()
 				if p.tok != token.LBRACE {
 					s3 = p.parseSimpleStmt(false)
 				}
@@ -1372,10 +1372,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
 }
 
 
@@ -1385,20 +1385,20 @@ 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();
-	var else_ ast.Stmt;
+	pos := p.expect(token.IF)
+	s1, s2, _ := p.parseControlClause(false)
+	body := p.parseBlockStmt()
+	var else_ ast.Stmt
 	if p.tok == token.ELSE {
-		p.next();
-		else_ = p.parseStmt();
+		p.next()
+		else_ = p.parseStmt()
 	} else {
 		p.expectSemi()
 	}
 
-	return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_};
+	return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_}
 }
 
 
@@ -1408,22 +1408,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}
 }
 
 
@@ -1432,14 +1432,14 @@ func (p *parser) parseTypeList() []ast.Expr {
 		defer un(trace(p, "TypeList"))
 	}
 
-	var list vector.Vector;
-	list.Push(p.parseType());
+	var list vector.Vector
+	list.Push(p.parseType())
 	for p.tok == token.COMMA {
-		p.next();
-		list.Push(p.parseType());
+		p.next()
+		list.Push(p.parseType())
 	}
 
-	return makeExprList(&list);
+	return makeExprList(&list)
 }
 
 
@@ -1449,22 +1449,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}
 }
 
 
@@ -1474,11 +1474,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
 }
 
 
@@ -1488,34 +1488,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);
-		var cases vector.Vector;
+		lbrace := p.expect(token.LBRACE)
+		var cases vector.Vector
 		for p.tok == token.CASE || p.tok == token.DEFAULT {
 			cases.Push(p.parseCaseClause())
 		}
-		rbrace := p.expect(token.RBRACE);
-		body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace};
-		p.expectSemi();
-		return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body};
+		rbrace := p.expect(token.RBRACE)
+		body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace}
+		p.expectSemi()
+		return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body}
 	}
 
 	// type switch
 	// TODO(gri): do all the checks!
-	lbrace := p.expect(token.LBRACE);
-	var cases vector.Vector;
+	lbrace := p.expect(token.LBRACE)
+	var cases vector.Vector
 	for p.tok == token.CASE || p.tok == token.DEFAULT {
 		cases.Push(p.parseTypeCaseClause())
 	}
-	rbrace := p.expect(token.RBRACE);
-	p.expectSemi();
-	body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace};
-	return &ast.TypeSwitchStmt{pos, s1, s2, body};
+	rbrace := p.expect(token.RBRACE)
+	p.expectSemi()
+	body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace}
+	return &ast.TypeSwitchStmt{pos, s1, s2, body}
 }
 
 
@@ -1525,29 +1525,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
@@ -1556,10 +1556,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}
 }
 
 
@@ -1568,17 +1568,17 @@ func (p *parser) parseSelectStmt() *ast.SelectStmt {
 		defer un(trace(p, "SelectStmt"))
 	}
 
-	pos := p.expect(token.SELECT);
-	lbrace := p.expect(token.LBRACE);
-	var cases vector.Vector;
+	pos := p.expect(token.SELECT)
+	lbrace := p.expect(token.LBRACE)
+	var cases vector.Vector
 	for p.tok == token.CASE || p.tok == token.DEFAULT {
 		cases.Push(p.parseCommClause())
 	}
-	rbrace := p.expect(token.RBRACE);
-	p.expectSemi();
-	body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace};
+	rbrace := p.expect(token.RBRACE)
+	p.expectSemi()
+	body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace}
 
-	return &ast.SelectStmt{pos, body};
+	return &ast.SelectStmt{pos, body}
 }
 
 
@@ -1588,50 +1588,50 @@ 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();
-	p.expectSemi();
+	pos := p.expect(token.FOR)
+	s1, s2, s3 := p.parseControlClause(true)
+	body := p.parseBlockStmt()
+	p.expectSemi()
 
 	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
 }
 
 
@@ -1645,10 +1645,10 @@ func (p *parser) parseStmt() (s ast.Stmt) {
 		s = &ast.DeclStmt{p.parseDecl()}
 	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
-		s = p.parseSimpleStmt(true);
+		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
+		s = p.parseSimpleStmt(true)
 		// because of the required look-ahead, labeled statements are
 		// parsed by parseSimpleStmt - don't expect a semicolon after
 		// them
@@ -1664,8 +1664,8 @@ func (p *parser) parseStmt() (s ast.Stmt) {
 	case token.BREAK, token.CONTINUE, token.GOTO, token.FALLTHROUGH:
 		s = p.parseBranchStmt(p.tok)
 	case token.LBRACE:
-		s = p.parseBlockStmt();
-		p.expectSemi();
+		s = p.parseBlockStmt()
+		p.expectSemi()
 	case token.IF:
 		s = p.parseIfStmt()
 	case token.SWITCH:
@@ -1675,19 +1675,19 @@ func (p *parser) parseStmt() (s ast.Stmt) {
 	case token.FOR:
 		s = p.parseForStmt()
 	case token.SEMICOLON:
-		p.next();
-		fallthrough;
+		p.next()
+		fallthrough
 	case token.RBRACE:
 		// a semicolon may be omitted before a closing "}"
 		s = &ast.EmptyStmt{p.pos}
 	default:
 		// no statement found
-		p.errorExpected(p.pos, "statement");
-		p.next();	// make progress
-		s = &ast.BadStmt{p.pos};
+		p.errorExpected(p.pos, "statement")
+		p.next() // make progress
+		s = &ast.BadStmt{p.pos}
 	}
 
-	return;
+	return
 }
 
 
@@ -1702,25 +1702,25 @@ func parseImportSpec(p *parser, doc *ast.CommentGroup) ast.Spec {
 		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 {
-		x := &ast.BasicLit{p.pos, p.tok, p.lit};
-		p.next();
-		path = []*ast.BasicLit{x};
+		x := &ast.BasicLit{p.pos, p.tok, p.lit}
+		p.next()
+		path = []*ast.BasicLit{x}
 	} else {
-		p.expect(token.STRING)	// use expect() error handling
+		p.expect(token.STRING) // use expect() error handling
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.ImportSpec{doc, ident, path, p.lineComment};
+	return &ast.ImportSpec{doc, ident, path, p.lineComment}
 }
 
 
@@ -1729,16 +1729,16 @@ func parseConstSpec(p *parser, doc *ast.CommentGroup) ast.Spec {
 		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()
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.ValueSpec{doc, idents, typ, values, p.lineComment};
+	return &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
 }
 
 
@@ -1747,11 +1747,11 @@ func parseTypeSpec(p *parser, doc *ast.CommentGroup) ast.Spec {
 		defer un(trace(p, "TypeSpec"))
 	}
 
-	ident := p.parseIdent();
-	typ := p.parseType();
-	p.expectSemi();
+	ident := p.parseIdent()
+	typ := p.parseType()
+	p.expectSemi()
 
-	return &ast.TypeSpec{doc, ident, typ, p.lineComment};
+	return &ast.TypeSpec{doc, ident, typ, p.lineComment}
 }
 
 
@@ -1760,16 +1760,16 @@ func parseVarSpec(p *parser, doc *ast.CommentGroup) 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()
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.ValueSpec{doc, idents, typ, values, p.lineComment};
+	return &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
 }
 
 
@@ -1778,29 +1778,29 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.Gen
 		defer un(trace(p, keyword.String()+"Decl"))
 	}
 
-	doc := p.leadComment;
-	pos := p.expect(keyword);
-	var lparen, rparen token.Position;
-	var list vector.Vector;
+	doc := p.leadComment
+	pos := p.expect(keyword)
+	var lparen, rparen token.Position
+	var list 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 {
 			list.Push(f(p, p.leadComment))
 		}
-		rparen = p.expect(token.RPAREN);
-		p.expectSemi();
+		rparen = p.expect(token.RPAREN)
+		p.expectSemi()
 	} else {
 		list.Push(f(p, nil))
 	}
 
 	// 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};
+	return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}
 }
 
 
@@ -1809,19 +1809,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
 	}
@@ -1829,7 +1829,7 @@ func (p *parser) parseReceiver() *ast.Field {
 		p.errorExpected(base.Pos(), "type name")
 	}
 
-	return recv;
+	return recv
 }
 
 
@@ -1838,24 +1838,24 @@ 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()
 	}
-	p.expectSemi();
+	p.expectSemi()
 
-	return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body};
+	return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body}
 }
 
 
@@ -1864,7 +1864,7 @@ func (p *parser) parseDecl() ast.Decl {
 		defer un(trace(p, "Declaration"))
 	}
 
-	var f parseSpecFunction;
+	var f parseSpecFunction
 	switch p.tok {
 	case token.CONST:
 		f = parseConstSpec
@@ -1879,14 +1879,14 @@ func (p *parser) parseDecl() ast.Decl {
 		return p.parseFunctionDecl()
 
 	default:
-		pos := p.pos;
-		p.errorExpected(pos, "declaration");
-		decl := &ast.BadDecl{pos};
-		p.next();	// make progress in any case
-		return decl;
+		pos := p.pos
+		p.errorExpected(pos, "declaration")
+		decl := &ast.BadDecl{pos}
+		p.next() // make progress in any case
+		return decl
 	}
 
-	return p.parseGenDecl(p.tok, f);
+	return p.parseGenDecl(p.tok, f)
 }
 
 
@@ -1895,18 +1895,18 @@ func (p *parser) parseDeclList() []ast.Decl {
 		defer un(trace(p, "DeclList"))
 	}
 
-	var list vector.Vector;
+	var list vector.Vector
 	for p.tok != token.EOF {
 		list.Push(p.parseDecl())
 	}
 
 	// 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
 }
 
 
@@ -1919,22 +1919,22 @@ 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();
-	p.expectSemi();
+	doc := p.leadComment
+	pos := p.expect(token.PACKAGE)
+	ident := p.parseIdent()
+	p.expectSemi()
 
-	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
-		var list vector.Vector;
+		var list vector.Vector
 		for p.tok == token.IMPORT {
 			list.Push(p.parseGenDecl(token.IMPORT, parseImportSpec))
 		}
@@ -1947,11 +1947,11 @@ func (p *parser) parseFile() *ast.File {
 		}
 
 		// 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}
 }