gofmt: fine-tune stripping of parentheses

       (composite literals in control clauses only need
       parentheses if the literals start with a type name)

R=rsc
CC=golang-dev
https://golang.org/cl/962045

Author: griesemer

src/pkg/go/printer/nodes.go

@@ -950,14 +950,25 @@ func (p *printer) block(s *ast.BlockStmt, indent int) {
 }
 
 
+func isTypeName(x ast.Expr) bool {
+	switch t := x.(type) {
+	case *ast.Ident:
+		return true
+	case *ast.SelectorExpr:
+		return isTypeName(t.X)
+	}
+	return false
+}
+
+
 // TODO(gri): Decide if this should be used more broadly. The printing code
 //            knows when to insert parentheses for precedence reasons, but
 //            need to be careful to keep them around type expressions.
 func stripParens(x ast.Expr, inControlClause bool) ast.Expr {
 	for px, hasParens := x.(*ast.ParenExpr); hasParens; px, hasParens = x.(*ast.ParenExpr) {
 		x = px.X
-		if _, isCompositeLit := x.(*ast.CompositeLit); isCompositeLit && inControlClause {
-			// composite literals inside control clauses need parens;
+		if cx, isCompositeLit := x.(*ast.CompositeLit); inControlClause && isCompositeLit && isTypeName(cx.Type) {
+			// composite literals inside control clauses need parens if they start with a type name;
 			// don't strip innermost layer
 			return px
 		}

src/pkg/go/printer/testdata/statements.golden

@@ -144,47 +144,71 @@ func _() {
 	for x := range []int{} {
 		use(x)
 	}
-	for x := range ([]int{}) {
+	for x := range []int{} {
 		use(x)
 	}	// no parens printed
 }
 
 
 // Don't remove mandatory parentheses around composite literals in control clauses.
 func _() {
+	// strip no parentheses - no composite literals or composite literals don't start with a type name
 	if x {
-	}	// no ()'s
+	}
 	if x {
-	}	// no ()'s
-	if ([]T{}) {
-	}	// ()
-	if ([]T{}) {
-	}	// ()
-	if ([]T{}) {
-	}	// ()
+	}
+	if []T{} {
+	}
+	if []T{} {
+	}
+	if []T{} {
+	}
 
 	for x {
-	}	// no ()'s
+	}
 	for x {
-	}	// no ()'s
-	for ([]T{}) {
-	}	// ()
-	for ([]T{}) {
-	}	// ()
-	for ([]T{}) {
-	}	// ()
+	}
+	for []T{} {
+	}
+	for []T{} {
+	}
+	for []T{} {
+	}
 
 	switch x {
-	}	// no ()'s
+	}
 	switch x {
-	}	// no ()'s
-	switch ([]T{}) {
-	}	// ()
-	switch ([]T{}) {
-	}	// ()
-
-	for _ = range ([]T{T{42}}) {
-	}	// ()
+	}
+	switch []T{} {
+	}
+	switch []T{} {
+	}
+
+	for _ = range []T{T{42}} {
+	}
+
+	// leave parentheses - composite literals start with a type name
+	if (T{}) {
+	}
+	if (T{}) {
+	}
+	if (T{}) {
+	}
+
+	for (T{}) {
+	}
+	for (T{}) {
+	}
+	for (T{}) {
+	}
+
+	switch (T{}) {
+	}
+	switch (T{}) {
+	}
+
+	for _ = range (T1{T{42}}) {
+	}
 }
 
 

src/pkg/go/printer/testdata/statements.input

@@ -113,24 +113,39 @@ func _() {
 
 // Don't remove mandatory parentheses around composite literals in control clauses.
 func _() {
-	if (x) {}                // no ()'s
-	if (((x))) {}            // no ()'s
-	if ([]T{}) {}            // ()
-	if (([]T{})) {}          // ()
-	if ; (((([]T{})))) {}    // ()
-
-	for (x) {}                // no ()'s
-	for (((x))) {}            // no ()'s
-	for ([]T{}) {}            // ()
-	for (([]T{})) {}          // ()
-	for ; (((([]T{})))) ; {}  // ()
-
-	switch (x) {}                // no ()'s
-	switch (((x))) {}            // no ()'s
-	switch ([]T{}) {}            // ()
-	switch (([]T{})) {}          // ()
-
-	for _ = range ((([]T{T{42}}))) {}  // ()
+	// strip parentheses - no composite literals or composite literals don't start with a type name
+	if (x) {}
+	if (((x))) {}
+	if ([]T{}) {}
+	if (([]T{})) {}
+	if ; (((([]T{})))) {}
+
+	for (x) {}
+	for (((x))) {}
+	for ([]T{}) {}
+	for (([]T{})) {}
+	for ; (((([]T{})))) ; {}
+
+	switch (x) {}
+	switch (((x))) {}
+	switch ([]T{}) {}
+	switch ; (((([]T{})))) {}
+
+	for _ = range ((([]T{T{42}}))) {}
+
+	// leave parentheses - composite literals start with a type name
+	if (T{}) {}
+	if ((T{})) {}
+	if ; ((((T{})))) {}
+
+	for (T{}) {}
+	for ((T{})) {}
+	for ; ((((T{})))) ; {}
+
+	switch (T{}) {}
+	switch ; ((((T{})))) {}
+
+	for _ = range (((T1{T{42}}))) {}
 }