gofmt: test rewrite of (x.(type)) -> x.(type)

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

diff --git a/src/cmd/gofmt/gofmt_test.go b/src/cmd/gofmt/gofmt_test.go
index 1f19d64eeef0122ccf61f0a66049ef3a4038a289..ee943989b62c092eb38e35c6477f9c8500ffc85a 100644 (file)
--- a/src/cmd/gofmt/gofmt_test.go
+++ b/src/cmd/gofmt/gofmt_test.go
@@ -83,7 +83,8 @@ var tests = []struct {
        {"testdata/stdin*.input", "-stdin"},
        {"testdata/comments.input", ""},
        {"testdata/import.input", ""},
-       {"testdata/crlf.input", ""}, // test case for issue 3961; see also TestCRLF
+       {"testdata/crlf.input", ""},       // test case for issue 3961; see also TestCRLF
+       {"testdata/typeswitch.input", ""}, // test case for issue 4470
 }
 
 func TestRewrite(t *testing.T) {

diff --git a/src/cmd/gofmt/testdata/typeswitch.golden b/src/cmd/gofmt/testdata/typeswitch.golden
new file mode 100644 (file)
index 0000000..87e9161
--- /dev/null
+++ b/src/cmd/gofmt/testdata/typeswitch.golden
@@ -0,0 +1,60 @@
+/*
+       Parenthesized type switch expressions originally
+       accepted by gofmt must continue to be rewritten
+       into the correct unparenthesized form.
+
+       Only type-switches that didn't declare a variable
+       in the the type switch type assertion and which
+       contained only "expression-like" (named) types in their
+       cases were permitted to have their type assertion parenthesized
+       by go/parser (due to a weak predicate in the parser). All others
+       were rejected always, either with a syntax error in the
+       type switch header or in the case.
+
+       See also issue 4470.
+*/
+package p
+
+func f() {
+       var x interface{}
+       switch x.(type) { // should remain the same
+       }
+       switch x.(type) { // should become: switch x.(type) {
+       }
+
+       switch x.(type) { // should remain the same
+       case int:
+       }
+       switch x.(type) { // should become: switch x.(type) {
+       case int:
+       }
+
+       switch x.(type) { // should remain the same
+       case []int:
+       }
+
+       // Parenthesized (x.(type)) in type switches containing cases
+       // with unnamed (literal) types were never permitted by gofmt;
+       // thus there won't be any code in the wild using this style if
+       // the code was gofmt-ed.
+       /*
+               switch (x.(type)) {
+               case []int:
+               }
+       */
+
+       switch t := x.(type) { // should remain the same
+       default:
+               _ = t
+       }
+
+       // Parenthesized (x.(type)) in type switches declaring a variable
+       // were never permitted by gofmt; thus there won't be any code in
+       // the wild using this style if the code was gofmt-ed.
+       /*
+               switch t := (x.(type)) {
+               default:
+                       _ = t
+               }
+       */
+}

diff --git a/src/cmd/gofmt/testdata/typeswitch.input b/src/cmd/gofmt/testdata/typeswitch.input
new file mode 100644 (file)
index 0000000..f90f289
--- /dev/null
+++ b/src/cmd/gofmt/testdata/typeswitch.input
@@ -0,0 +1,60 @@
+/*
+       Parenthesized type switch expressions originally
+       accepted by gofmt must continue to be rewritten
+       into the correct unparenthesized form.
+
+       Only type-switches that didn't declare a variable
+       in the the type switch type assertion and which
+       contained only "expression-like" (named) types in their
+       cases were permitted to have their type assertion parenthesized
+       by go/parser (due to a weak predicate in the parser). All others
+       were rejected always, either with a syntax error in the
+       type switch header or in the case.
+
+       See also issue 4470.
+*/
+package p
+
+func f() {
+       var x interface{}
+       switch x.(type) { // should remain the same
+       }
+       switch (x.(type)) { // should become: switch x.(type) {
+       }
+
+       switch x.(type) { // should remain the same
+       case int:
+       }
+       switch (x.(type)) { // should become: switch x.(type) {
+       case int:
+       }
+
+       switch x.(type) { // should remain the same
+       case []int:
+       }
+
+       // Parenthesized (x.(type)) in type switches containing cases
+       // with unnamed (literal) types were never permitted by gofmt;
+       // thus there won't be any code in the wild using this style if
+       // the code was gofmt-ed.
+       /*
+       switch (x.(type)) {
+       case []int:
+       }
+       */
+
+       switch t := x.(type) { // should remain the same
+       default:
+               _ = t
+       }
+
+       // Parenthesized (x.(type)) in type switches declaring a variable
+       // were never permitted by gofmt; thus there won't be any code in
+       // the wild using this style if the code was gofmt-ed.
+       /*
+       switch t := (x.(type)) {
+       default:
+               _ = t
+       }
+       */
+}