[dev.typeparams] test: add scaffolding to run.go to check compiler with -G flag

Added a new flag -G to run. Setting -G (as in: go run run.go -G)
will run tests marked with "errorcheck" (and no other flags) also
with the compiler using the new typechecker.

Many tests don't pass yet (due to discrepancies in error messages).
The top-level tests in the test directory which don't pass yet have
been explicitly excluded, permitting to see the current status.
Future CLs will bring error messages in sync and eventually all
tests should pass.

Change-Id: I7caf5eff413e173f68d092af4bbe458434718d74
Reviewed-on: https://go-review.googlesource.com/c/go/+/274313
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

1 files changed, 28 insertions, 28 deletions

diff --git a/test/const1.go b/test/const1.go
index 3fd5b55522..1efe688cb9 100644
--- a/test/const1.go
+++ b/test/const1.go
@@ -30,43 +30,43 @@ const (
 )
 
 var (
-	a1 = Int8 * 100              // ERROR "overflow"
+	a1 = Int8 * 100              // ERROR "overflow|cannot convert"
 	a2 = Int8 * -1               // OK
-	a3 = Int8 * 1000             // ERROR "overflow"
-	a4 = Int8 * int8(1000)       // ERROR "overflow"
-	a5 = int8(Int8 * 1000)       // ERROR "overflow"
-	a6 = int8(Int8 * int8(1000)) // ERROR "overflow"
-	a7 = Int8 - 2*Int8 - 2*Int8  // ERROR "overflow"
-	a8 = Int8 * Const / 100      // ERROR "overflow"
+	a3 = Int8 * 1000             // ERROR "overflow|cannot convert"
+	a4 = Int8 * int8(1000)       // ERROR "overflow|cannot convert"
+	a5 = int8(Int8 * 1000)       // ERROR "overflow|cannot convert"
+	a6 = int8(Int8 * int8(1000)) // ERROR "overflow|cannot convert"
+	a7 = Int8 - 2*Int8 - 2*Int8  // ERROR "overflow|cannot convert"
+	a8 = Int8 * Const / 100      // ERROR "overflow|cannot convert"
 	a9 = Int8 * (Const / 100)    // OK
 
-	b1        = Uint8 * Uint8         // ERROR "overflow"
-	b2        = Uint8 * -1            // ERROR "overflow"
+	b1        = Uint8 * Uint8         // ERROR "overflow|cannot convert"
+	b2        = Uint8 * -1            // ERROR "overflow|cannot convert"
 	b3        = Uint8 - Uint8         // OK
-	b4        = Uint8 - Uint8 - Uint8 // ERROR "overflow"
-	b5        = uint8(^0)             // ERROR "overflow"
+	b4        = Uint8 - Uint8 - Uint8 // ERROR "overflow|cannot convert"
+	b5        = uint8(^0)             // ERROR "overflow|cannot convert"
 	b5a       = int64(^0)             // OK
 	b6        = ^uint8(0)             // OK
 	b6a       = ^int64(0)             // OK
-	b7        = uint8(Minus1)         // ERROR "overflow"
-	b8        = uint8(int8(-1))       // ERROR "overflow"
-	b8a       = uint8(-1)             // ERROR "overflow"
+	b7        = uint8(Minus1)         // ERROR "overflow|cannot convert"
+	b8        = uint8(int8(-1))       // ERROR "overflow|cannot convert"
+	b8a       = uint8(-1)             // ERROR "overflow|cannot convert"
 	b9   byte = (1 << 10) >> 8        // OK
-	b10  byte = (1 << 10)             // ERROR "overflow"
-	b11  byte = (byte(1) << 10) >> 8  // ERROR "overflow"
-	b12  byte = 1000                  // ERROR "overflow"
-	b13  byte = byte(1000)            // ERROR "overflow"
-	b14  byte = byte(100) * byte(100) // ERROR "overflow"
-	b15  byte = byte(100) * 100       // ERROR "overflow"
-	b16  byte = byte(0) * 1000        // ERROR "overflow"
+	b10  byte = (1 << 10)             // ERROR "overflow|cannot convert"
+	b11  byte = (byte(1) << 10) >> 8  // ERROR "overflow|cannot convert"
+	b12  byte = 1000                  // ERROR "overflow|cannot convert"
+	b13  byte = byte(1000)            // ERROR "overflow|cannot convert"
+	b14  byte = byte(100) * byte(100) // ERROR "overflow|cannot convert"
+	b15  byte = byte(100) * 100       // ERROR "overflow|cannot convert"
+	b16  byte = byte(0) * 1000        // ERROR "overflow|cannot convert"
 	b16a byte = 0 * 1000              // OK
-	b17  byte = byte(0) * byte(1000)  // ERROR "overflow"
+	b17  byte = byte(0) * byte(1000)  // ERROR "overflow|cannot convert"
 	b18  byte = Uint8 / 0             // ERROR "division by zero"
 
 	c1 float64 = Big
-	c2 float64 = Big * Big          // ERROR "overflow"
-	c3 float64 = float64(Big) * Big // ERROR "overflow"
-	c4         = Big * Big          // ERROR "overflow"
+	c2 float64 = Big * Big          // ERROR "overflow|cannot convert"
+	c3 float64 = float64(Big) * Big // ERROR "overflow|cannot convert"
+	c4         = Big * Big          // ERROR "overflow|cannot convert"
 	c5         = Big / 0            // ERROR "division by zero"
 	c6         = 1000 % 1e3         // ERROR "invalid operation|expected integer type"
 )
@@ -87,8 +87,8 @@ func main() {
 	f(Bool)             // ERROR "convert|wrong type|cannot|incompatible"
 }
 
-const ptr = nil // ERROR "const.*nil"
+const ptr = nil // ERROR "const.*nil|not constant"
 const _ = string([]byte(nil)) // ERROR "is not a? ?constant"
 const _ = uintptr(unsafe.Pointer((*int)(nil))) // ERROR "is not a? ?constant"
-const _ = unsafe.Pointer((*int)(nil)) // ERROR "cannot be nil|invalid constant type|is not a constant"
-const _ = (*int)(nil) // ERROR "cannot be nil|invalid constant type|is not a constant"
+const _ = unsafe.Pointer((*int)(nil)) // ERROR "cannot be nil|invalid constant type|is not a constant|not constant"
+const _ = (*int)(nil) // ERROR "cannot be nil|invalid constant type|is not a constant|not constant"