gofmt the last outstanding files in src/pkg

- added a list of issues to printer/nodes.go

R=rsc
http://go/go-review/1024002

src/pkg/exp/datafmt/datafmt.go

@@ -232,7 +232,7 @@ type Formatter func(state *State, value interface{}, ruleName string) bool
 // A FormatterMap is a set of custom formatters.
 // It maps a rule name to a formatter function.
 //
-type FormatterMap map [string] Formatter;
+type FormatterMap map[string]Formatter
 
 
 // A parsed format expression is built from the following nodes.
@@ -265,7 +265,7 @@ type (
 
 	custom	struct {
 		ruleName	string;
-		fun Formatter
+		fun		Formatter;
 	};
 )
 
@@ -273,7 +273,7 @@ type (
 // A Format is the result of parsing a format specification.
 // The format may be applied repeatedly to format values.
 //
-type Format map [string] expr;
+type Format map[string]expr
 
 
 // ----------------------------------------------------------------------------
@@ -290,7 +290,7 @@ type Format map [string] expr;
 // the receiver, and thus can be very light-weight.
 //
 type Environment interface {
-	Copy() Environment
+	Copy() Environment;
 }
 
 
@@ -580,7 +580,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 		ruleName := t.ruleName;
 		if ruleName == "" {
 			// no alternate rule name, value type determines rule
-			ruleName = typename(value.Type())
+			ruleName = typename(value.Type());
 		}
 		fexpr = s.getFormat(ruleName);
 

src/pkg/exp/datafmt/datafmt_test.go

@@ -29,8 +29,7 @@ func verify(t *testing.T, f Format, expected string, args ...) {
 	if result != expected {
 		t.Errorf(
 			"result  : `%s`\nexpected: `%s`\n\n",
-			result, expected
+			result, expected);
-		)
 	}
 }
 
@@ -103,8 +102,7 @@ func check(t *testing.T, form, expected string, args ...) {
 	if result != expected {
 		t.Errorf(
 			"format  : %s\nresult  : `%s`\nexpected: `%s`\n\n",
-			form, result, expected
+			form, result, expected);
-		)
 	}
 }
 
@@ -174,14 +172,14 @@ func TestFuncTypes(t *testing.T) {
 	var f0 func() int;
 	check(t, `func="func"`, `func`, f0);
 
-	f1 := func() int { return 42; };
+	f1 := func() int { return 42 };
 	check(t, `func="func"`, `func`, f1);
 	// check(t, `func=*`, `42`, f1);  // reflection support for funcs incomplete
 }
 
 
 func TestInterfaceTypes(t *testing.T) {
-	var i0 interface{};
+	var i0 interface{}
 	check(t, `interface="interface"`, `interface`, i0);
 
 	i0 = "foo";
@@ -234,8 +232,7 @@ type T1 struct {
 	a int;
 }
 
-const F1 =
+const F1 = `datafmt "datafmt";`
-	`datafmt "datafmt";`
 	`int = "%d";`
 	`datafmt.T1 = "<" a ">";`
 
@@ -252,17 +249,15 @@ type T2 struct {
 	p	*T1;
 }
 
-const F2a =
+const F2a = F1 +
-	F1 +
 	`string = "%s";`
 		`ptr = *;`
 		`datafmt.T2 = s ["-" p "-"];`
 
-const F2b =
+const F2b = F1 +
-	F1 +
 	`string = "%s";`
 		`ptr = *;`
-	`datafmt.T2 = s ("-" p "-" | "empty");`;
+		`datafmt.T2 = s ("-" p "-" | "empty");`
 
 func TestStruct2(t *testing.T) {
 	check(t, F2a, "foo", T2{"foo", nil});
@@ -279,14 +274,12 @@ type T3 struct {
 	a	[]int;
 }
 
-const F3a =
+const F3a = `datafmt "datafmt";`
-	`datafmt "datafmt";`
 	`default = "%v";`
 	`array = *;`
 	`datafmt.T3 = s  {" " a a / ","};`
 
-const F3b =
+const F3b = `datafmt "datafmt";`
-	`datafmt "datafmt";`
 	`int = "%d";`
 	`string = "%s";`
 	`array = *;`
@@ -310,8 +303,7 @@ type T4 struct {
 	a	[]int;
 }
 
-const F4a =
+const F4a = `datafmt "datafmt";`
-	`datafmt "datafmt";`
 	`int = "%d";`
 	`ptr = *;`
 	`array = *;`
@@ -319,8 +311,7 @@ const F4a =
 	`empty = *:nil;`
 	`datafmt.T4 = "<" (x:empty x | "-") ">" `
 
-const F4b =
+const F4b = `datafmt "datafmt";`
-	`datafmt "datafmt";`
 	`int = "%d";`
 	`ptr = *;`
 	`array = *;`
@@ -345,8 +336,7 @@ type Point struct {
 	x, y	int;
 }
 
-const FPoint =
+const FPoint = `datafmt "datafmt";`
-	`datafmt "datafmt";`
 	`int = "%d";`
 	`hexInt = "0x%x";`
 	`string = "---%s---";`
@@ -361,8 +351,7 @@ func TestStructPoint(t *testing.T) {
 // ----------------------------------------------------------------------------
 // Formatting a slice (documentation example)
 
-const FSlice =
+const FSlice = `int = "%b";`
-	`int = "%b";`
 	`array = { * / ", " }`
 
 func TestSlice(t *testing.T) {

src/pkg/go/parser/parser.go

@@ -19,7 +19,7 @@ import (
 
 
 // noPos is used when there is no corresponding source position for a token.
-var noPos token.Position;
+var noPos token.Position
 
 
 // The mode parameter to the Parse* functions is a set of flags (or 0).
@@ -63,7 +63,7 @@ type parser struct {
 	pkgScope	*ast.Scope;
 	fileScope	*ast.Scope;
 	topScope	*ast.Scope;
-};
+}
 
 
 // scannerMode returns the scanner mode bits given the parser's mode bits.
@@ -88,8 +88,7 @@ func (p *parser) init(filename string, src []byte, mode uint) {
 // Parsing support
 
 func (p *parser) printTrace(a ...) {
-	const dots =
+	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
-		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
 		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ";
 	const n = uint(len(dots));
 	fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column);
@@ -109,7 +108,8 @@ func trace(p *parser, msg string) *parser {
 }
 
 
-func un/*trace*/(p *parser) {
+// Usage pattern: defer un(trace(p, "..."));
+func un(p *parser) {
 	p.indent--;
 	p.printTrace(")");
 }
@@ -272,7 +272,8 @@ func openScope(p *parser) *parser {
 }
 
 
-func close/*Scope*/(p *parser) {
+// Usage pattern: defer close(openScope(p));
+func close(p *parser) {
 	p.topScope = p.topScope.Outer;
 }
 
@@ -757,14 +758,22 @@ func (p *parser) parseChanType() *ast.ChanType {
 
 func (p *parser) tryRawType(ellipsisOk bool) ast.Expr {
 	switch p.tok {
-	case token.IDENT: return p.parseTypeName();
+	case token.IDENT:
-	case token.LBRACK: return p.parseArrayType(ellipsisOk);
+		return p.parseTypeName();
-	case token.STRUCT: return p.parseStructType();
+	case token.LBRACK:
-	case token.MUL: return p.parsePointerType();
+		return p.parseArrayType(ellipsisOk);
-	case token.FUNC: return p.parseFuncType();
+	case token.STRUCT:
-	case token.INTERFACE: return p.parseInterfaceType();
+		return p.parseStructType();
-	case token.MAP: return p.parseMapType();
+	case token.MUL:
-	case token.CHAN, token.ARROW: return p.parseChanType();
+		return p.parsePointerType();
+	case token.FUNC:
+		return p.parseFuncType();
+	case token.INTERFACE:
+		return p.parseInterfaceType();
+	case token.MAP:
+		return p.parseMapType();
+	case token.CHAN, token.ARROW:
+		return p.parseChanType();
 	case token.LPAREN:
 		lparen := p.pos;
 		p.next();
@@ -1097,9 +1106,12 @@ func isTypeName(x ast.Expr) bool {
 	switch t := x.(type) {
 	case *ast.BadExpr:
 	case *ast.Ident:
-	case *ast.ParenExpr: return isTypeName(t.X);  // TODO(gri): should (TypeName) be illegal?
+	case *ast.ParenExpr:
-	case *ast.SelectorExpr: return isTypeName(t.X);
+		return isTypeName(t.X);	// TODO(gri): should (TypeName) be illegal?
-	default: return false;  // all other nodes are not type names
+	case *ast.SelectorExpr:
+		return isTypeName(t.X);
+	default:
+		return false;	// all other nodes are not type names
 	}
 	return true;
 }
@@ -1111,12 +1123,15 @@ func isCompositeLitType(x ast.Expr) bool {
 	switch t := x.(type) {
 	case *ast.BadExpr:
 	case *ast.Ident:
-	case *ast.ParenExpr: return isCompositeLitType(t.X);
+	case *ast.ParenExpr:
-	case *ast.SelectorExpr: return isTypeName(t.X);
+		return isCompositeLitType(t.X);
+	case *ast.SelectorExpr:
+		return isTypeName(t.X);
 	case *ast.ArrayType:
 	case *ast.StructType:
 	case *ast.MapType:
-	default: return false;  // all other nodes are not legal composite literal types
+	default:
+		return false;	// all other nodes are not legal composite literal types
 	}
 	return true;
 }
@@ -1154,9 +1169,12 @@ func (p *parser) parsePrimaryExpr() ast.Expr {
 	x := p.parseOperand();
 L:	for {
 		switch p.tok {
-		case token.PERIOD: x = p.parseSelectorOrTypeAssertion(p.checkExpr(x));
+		case token.PERIOD:
-		case token.LBRACK: x = p.parseIndex(p.checkExpr(x));
+			x = p.parseSelectorOrTypeAssertion(p.checkExpr(x));
-		case token.LPAREN: x = p.parseCallOrConversion(p.checkExprOrType(x));
+		case token.LBRACK:
+			x = p.parseIndex(p.checkExpr(x));
+		case token.LPAREN:
+			x = p.parseCallOrConversion(p.checkExprOrType(x));
 		case token.LBRACE:
 			if isCompositeLitType(x) && (p.exprLev >= 0 || !isTypeName(x)) {
 				x = p.parseCompositeLit(x);
@@ -1637,7 +1655,7 @@ func (p *parser) parseForStmt() ast.Stmt {
 		}
 		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}
+			return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body};
 		} else {
 			p.errorExpected(s2.Pos(), "range clause");
 			return &ast.BadStmt{pos};

src/pkg/go/printer/nodes.go

@@ -24,6 +24,15 @@ const (
 )
 
 
+// Other outstanding formatting issues:
+// - replacement of expression spacing algorithm with rsc's algorithm
+// - support for one-line composite types (e.g. structs) as composite literals types
+// - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)
+//   when the comment spans multiple lines
+// - formatting of expression lists; especially for string lists (stringListMode)
+// - blank after { and before } in one-line composite literals probably looks better
+
+
 // ----------------------------------------------------------------------------
 // Common AST nodes.
 

src/pkg/go/scanner/scanner_test.go

@@ -22,9 +22,12 @@ const /* class */ (
 
 func tokenclass(tok token.Token) int {
 	switch {
-	case tok.IsLiteral(): return literal;
+	case tok.IsLiteral():
-	case tok.IsOperator(): return operator;
+		return literal;
-	case tok.IsKeyword(): return keyword;
+	case tok.IsOperator():
+		return operator;
+	case tok.IsKeyword():
+		return keyword;
 	}
 	return special;
 }
@@ -64,7 +67,10 @@ var tokens = [...]elt{
 	elt{token.CHAR, "'\\U0000ff16'", literal},
 	elt{token.STRING, "`foobar`", literal},
 	elt{token.STRING, "`" `foo
-	                        bar` "`", literal },
+	                        bar`
+		"`",
+		literal,
+	},
 
 	// Operators and delimitors
 	elt{token.ADD, "+", operator},
@@ -156,10 +162,10 @@ var tokens = [...]elt{
 }
 
 
-const whitespace = "  \t  \n\n\n";  // to separate tokens
+const whitespace = "  \t  \n\n\n"	// to separate tokens
 
 type TestErrorHandler struct {
-	t *testing.T
+	t *testing.T;
 }
 
 func (h *TestErrorHandler) Error(pos token.Position, msg string) {
@@ -236,8 +242,7 @@ func TestScan(t *testing.T) {
 			}
 			index++;
 			return tok != token.EOF;
-		}
+		});
-	);
 	if nerrors != 0 {
 		t.Errorf("found %d errors", nerrors);
 	}
@@ -340,23 +345,19 @@ func TestIllegalChars(t *testing.T) {
 
 
 func TestStdErrorHander(t *testing.T) {
-	const src =
+	const src = "@\n"	// illegal character, cause an error
-		"@\n"  // illegal character, cause an error
 		"@ @\n"	// two errors on the same line
 		"//line File2:20\n"
 		"@\n"	// different file, but same line
 		"//line File2:1\n"
 		"@ @\n"	// same file, decreasing line number
 		"//line File1:1\n"
-		"@ @ @"  // original file, line 1 again
+		"@ @ @";	// original file, line 1 again
-	;
+
 
 	v := NewErrorVector();
 	nerrors := Tokenize("File1", strings.Bytes(src), v, 0,
-		func (pos token.Position, tok token.Token, litb []byte) bool {
+		func(pos token.Position, tok token.Token, litb []byte) bool { return tok != token.EOF });
-			return tok != token.EOF;
-		}
-	);
 
 	list := v.GetErrorList(Raw);
 	if len(list) != 9 {

src/pkg/xml/xml_test.go

@@ -16,7 +16,8 @@ const testInput = `
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" ` "\r\n\t" `  >
+<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" `
+	"\r\n\t" `  >
   <hello lang="en">World &lt;&gt;&apos;&quot; &#x767d;&#40300;翔</hello>
   <goodbye />
   <outer foo:attr="value" xmlns:tag="ns4">
@@ -116,7 +117,7 @@ func (r *stringReader) ReadByte() (b byte, err os.Error) {
 }
 
 func StringReader(s string) io.Reader {
-	return &stringReader{s, 0}
+	return &stringReader{s, 0};
 }
 
 func TestRawToken(t *testing.T) {
@@ -146,4 +147,3 @@ func TestToken(t *testing.T) {
 		}
 	}
 }
-