diff --git a/api/except.txt b/api/except.txt
index 79ffd91..ccfdf06 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -1,5 +1,4 @@
 pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
-pkg go/types, type Type interface { String, Underlying }
 pkg math/big, const MaxBase = 36
 pkg math/big, type Word uintptr
 pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
diff --git a/api/go1.15.txt b/api/go1.15.txt
index b51837c..dd90506 100644
--- a/api/go1.15.txt
+++ b/api/go1.15.txt
@@ -112,8 +112,6 @@
 pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_GUI ideal-int
 pkg debug/pe, const IMAGE_SUBSYSTEM_XBOX = 14
 pkg debug/pe, const IMAGE_SUBSYSTEM_XBOX ideal-int
-pkg go/printer, const StdFormat = 16
-pkg go/printer, const StdFormat Mode
 pkg math/big, method (*Int) FillBytes([]uint8) []uint8
 pkg net, method (*Resolver) LookupIP(context.Context, string, string) ([]IP, error)
 pkg net/url, method (*URL) EscapedFragment() string
diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index 92bfd46..8a6f4cc 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -40,7 +40,13 @@
 // Keep these in sync with go/format/format.go.
 const (
 	tabWidth    = 8
-	printerMode = printer.UseSpaces | printer.TabIndent | printer.StdFormat | printer.UseBrackets
+	printerMode = printer.UseSpaces | printer.TabIndent | printerNormalizeNumbers
+
+	// printerNormalizeNumbers means to canonicalize number literal prefixes
+	// and exponents while printing. See https://golang.org/doc/go1.13#gofmt.
+	//
+	// This value is defined in go/printer specifically for go/format and cmd/gofmt.
+	printerNormalizeNumbers = 1 << 30
 )
 
 var (
@@ -62,7 +68,7 @@
 
 func initParserMode() {
 	// Keep this in sync with go/format/format.go.
-	parserMode = parser.ParseComments | parser.UnifiedParamLists
+	parserMode = parser.ParseComments | parser.ParseTypeParams
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}
diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index d6e691c..2456020 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -57,6 +57,11 @@
 // Comments
 
 // A Comment node represents a single //-style or /*-style comment.
+//
+// The Text field contains the comment text without carriage returns (\r) that
+// may have been present in the source. Because a comment's end position is
+// computed using len(Text), the position reported by End() does not match the
+// true source end position for comments containing carriage returns.
 type Comment struct {
 	Slash token.Pos // position of "/" starting the comment
 	Text  string    // comment text (excluding '\n' for //-style comments)
@@ -367,7 +372,9 @@
 		Args     []Expr    // function arguments; or nil
 		Ellipsis token.Pos // position of "..." (token.NoPos if there is no "...")
 		Rparen   token.Pos // position of ")"
-		Brackets bool      // if set, "[" and "]" are used instead of "(" and ")"
+		// TODO(rFindley) use a new ListExpr type rather than overloading CallExpr
+		//                via Brackets, as is done in the syntax package
+		Brackets bool // if set, "[" and "]" are used instead of "(" and ")"
 	}
 
 	// A StarExpr node represents an expression of the form "*" Expression.
@@ -982,6 +989,8 @@
 		Name *Ident        // function/method name
 		Type *FuncType     // function signature: type and value parameters, results, and position of "func" keyword
 		Body *BlockStmt    // function body; or nil for external (non-Go) function
+		// TODO(rFindley) consider storing TParams here, rather than FuncType, as
+		//                they are only valid for declared functions
 	}
 )
 
@@ -1039,15 +1048,14 @@
 // are "free-floating" (see also issues #18593, #20744).
 //
 type File struct {
-	Doc         *CommentGroup   // associated documentation; or nil
-	Package     token.Pos       // position of "package" keyword
-	Name        *Ident          // package name
-	Decls       []Decl          // top-level declarations; or nil
-	Scope       *Scope          // package scope (this file only)
-	Imports     []*ImportSpec   // imports in this file
-	Unresolved  []*Ident        // unresolved identifiers in this file
-	Comments    []*CommentGroup // list of all comments in the source file
-	UseBrackets bool            // indicates that type parameters use []'s
+	Doc        *CommentGroup   // associated documentation; or nil
+	Package    token.Pos       // position of "package" keyword
+	Name       *Ident          // package name
+	Decls      []Decl          // top-level declarations; or nil
+	Scope      *Scope          // package scope (this file only)
+	Imports    []*ImportSpec   // imports in this file
+	Unresolved []*Ident        // unresolved identifiers in this file
+	Comments   []*CommentGroup // list of all comments in the source file
 }
 
 func (f *File) Pos() token.Pos { return f.Package }
diff --git a/src/go/ast/commentmap_test.go b/src/go/ast/commentmap_test.go
index e372eab..38c62b0 100644
--- a/src/go/ast/commentmap_test.go
+++ b/src/go/ast/commentmap_test.go
@@ -140,4 +140,31 @@
 	}
 }
 
-// TODO(gri): add tests for Filter.
+func TestFilter(t *testing.T) {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cmap := NewCommentMap(fset, f, f.Comments)
+
+	// delete variable declaration
+	for i, decl := range f.Decls {
+		if gen, ok := decl.(*GenDecl); ok && gen.Tok == token.VAR {
+			copy(f.Decls[i:], f.Decls[i+1:])
+			f.Decls = f.Decls[:len(f.Decls)-1]
+			break
+		}
+	}
+
+	// check if comments are filtered correctly
+	cc := cmap.Filter(f)
+	for n, list := range cc {
+		key := fmt.Sprintf("%2d: %T", fset.Position(n.Pos()).Line, n)
+		got := ctext(list)
+		want := res[key]
+		if key == "25: *ast.GenDecl" || got != want {
+			t.Errorf("%s: got %q; want %q", key, got, want)
+		}
+	}
+}
diff --git a/src/go/ast/example_test.go b/src/go/ast/example_test.go
index 6e8d2ee..c2b3520 100644
--- a/src/go/ast/example_test.go
+++ b/src/go/ast/example_test.go
@@ -135,8 +135,7 @@
 	//     56  .  Unresolved: []*ast.Ident (len = 1) {
 	//     57  .  .  0: *(obj @ 29)
 	//     58  .  }
-	//     59  .  UseBrackets: false
-	//     60  }
+	//     59  }
 }
 
 // This example illustrates how to remove a variable declaration
diff --git a/src/go/ast/filter.go b/src/go/ast/filter.go
index 90a997b..c398e6e 100644
--- a/src/go/ast/filter.go
+++ b/src/go/ast/filter.go
@@ -493,5 +493,5 @@
 	}
 
 	// TODO(gri) need to compute unresolved identifiers!
-	return &File{doc, pos, NewIdent(pkg.Name), decls, pkg.Scope, imports, nil, comments, false}
+	return &File{doc, pos, NewIdent(pkg.Name), decls, pkg.Scope, imports, nil, comments}
 }
diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 08bcb3b..78cb3f8 100644
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -17,6 +17,7 @@
 	"go/token"
 	"math"
 	"math/big"
+	"math/bits"
 	"strconv"
 	"strings"
 	"sync"
@@ -66,6 +67,22 @@
 // The spec requires at least 256 bits; typical implementations use 512 bits.
 const prec = 512
 
+// TODO(gri) Consider storing "error" information in an unknownVal so clients
+//           can provide better error messages. For instance, if a number is
+//           too large (incl. infinity), that could be recorded in unknownVal.
+//           See also #20583 and #42695 for use cases.
+
+// Representation of values:
+//
+// Values of Int and Float Kind have two different representations each: int64Val
+// and intVal, and ratVal and floatVal. When possible, the "smaller", respectively
+// more precise (for Floats) representation is chosen. However, once a Float value
+// is represented as a floatVal, any subsequent results remain floatVals (unless
+// explicitly converted); i.e., no attempt is made to convert a floatVal back into
+// a ratVal. The reasoning is that all representations but floatVal are mathematically
+// exact, but once that precision is lost (by moving to floatVal), moving back to
+// a different representation implies a precision that's not actually there.
+
 type (
 	unknownVal struct{}
 	boolVal    bool
@@ -257,14 +274,8 @@
 func i64tof(x int64Val) floatVal { return floatVal{newFloat().SetInt64(int64(x))} }
 func itor(x intVal) ratVal       { return ratVal{newRat().SetInt(x.val)} }
 func itof(x intVal) floatVal     { return floatVal{newFloat().SetInt(x.val)} }
-
-func rtof(x ratVal) floatVal {
-	a := newFloat().SetInt(x.val.Num())
-	b := newFloat().SetInt(x.val.Denom())
-	return floatVal{a.Quo(a, b)}
-}
-
-func vtoc(x Value) complexVal { return complexVal{x, int64Val(0)} }
+func rtof(x ratVal) floatVal     { return floatVal{newFloat().SetRat(x.val)} }
+func vtoc(x Value) complexVal    { return complexVal{x, int64Val(0)} }
 
 func makeInt(x *big.Int) Value {
 	if x.IsInt64() {
@@ -273,21 +284,15 @@
 	return intVal{x}
 }
 
-// Permit fractions with component sizes up to maxExp
-// before switching to using floating-point numbers.
-const maxExp = 4 << 10
-
 func makeRat(x *big.Rat) Value {
 	a := x.Num()
 	b := x.Denom()
-	if a.BitLen() < maxExp && b.BitLen() < maxExp {
+	if smallInt(a) && smallInt(b) {
 		// ok to remain fraction
 		return ratVal{x}
 	}
 	// components too large => switch to float
-	fa := newFloat().SetInt(a)
-	fb := newFloat().SetInt(b)
-	return floatVal{fa.Quo(fa, fb)}
+	return floatVal{newFloat().SetRat(x)}
 }
 
 var floatVal0 = floatVal{newFloat()}
@@ -297,16 +302,25 @@
 	if x.Sign() == 0 {
 		return floatVal0
 	}
+	if x.IsInf() {
+		return unknownVal{}
+	}
+	// No attempt is made to "go back" to ratVal, even if possible,
+	// to avoid providing the illusion of a mathematically exact
+	// representation.
 	return floatVal{x}
 }
 
 func makeComplex(re, im Value) Value {
+	if re.Kind() == Unknown || im.Kind() == Unknown {
+		return unknownVal{}
+	}
 	return complexVal{re, im}
 }
 
 func makeFloatFromLiteral(lit string) Value {
 	if f, ok := newFloat().SetString(lit); ok {
-		if smallRat(f) {
+		if smallFloat(f) {
 			// ok to use rationals
 			if f.Sign() == 0 {
 				// Issue 20228: If the float underflowed to zero, parse just "0".
@@ -325,14 +339,34 @@
 	return nil
 }
 
-// smallRat reports whether x would lead to "reasonably"-sized fraction
+// Permit fractions with component sizes up to maxExp
+// before switching to using floating-point numbers.
+const maxExp = 4 << 10
+
+// smallInt reports whether x would lead to "reasonably"-sized fraction
 // if converted to a *big.Rat.
-func smallRat(x *big.Float) bool {
-	if !x.IsInf() {
-		e := x.MantExp(nil)
-		return -maxExp < e && e < maxExp
+func smallInt(x *big.Int) bool {
+	return x.BitLen() < maxExp
+}
+
+// smallFloat64 reports whether x would lead to "reasonably"-sized fraction
+// if converted to a *big.Rat.
+func smallFloat64(x float64) bool {
+	if math.IsInf(x, 0) {
+		return false
 	}
-	return false
+	_, e := math.Frexp(x)
+	return -maxExp < e && e < maxExp
+}
+
+// smallFloat reports whether x would lead to "reasonably"-sized fraction
+// if converted to a *big.Rat.
+func smallFloat(x *big.Float) bool {
+	if x.IsInf() {
+		return false
+	}
+	e := x.MantExp(nil)
+	return -maxExp < e && e < maxExp
 }
 
 // ----------------------------------------------------------------------------
@@ -359,16 +393,16 @@
 }
 
 // MakeFloat64 returns the Float value for x.
+// If x is -0.0, the result is 0.0.
 // If x is not finite, the result is an Unknown.
 func MakeFloat64(x float64) Value {
 	if math.IsInf(x, 0) || math.IsNaN(x) {
 		return unknownVal{}
 	}
-	// convert -0 to 0
-	if x == 0 {
-		return int64Val(0)
+	if smallFloat64(x) {
+		return ratVal{newRat().SetFloat64(x + 0)} // convert -0 to 0
 	}
-	return ratVal{newRat().SetFloat64(x)}
+	return floatVal{newFloat().SetFloat64(x + 0)}
 }
 
 // MakeFromLiteral returns the corresponding integer, floating-point,
@@ -583,11 +617,11 @@
 	case int64:
 		return int64Val(x)
 	case *big.Int:
-		return intVal{x}
+		return makeInt(x)
 	case *big.Rat:
-		return ratVal{x}
+		return makeRat(x)
 	case *big.Float:
-		return floatVal{x}
+		return makeFloat(x)
 	default:
 		return unknownVal{}
 	}
@@ -599,7 +633,11 @@
 func BitLen(x Value) int {
 	switch x := x.(type) {
 	case int64Val:
-		return i64toi(x).val.BitLen()
+		u := uint64(x)
+		if x < 0 {
+			u = uint64(-x)
+		}
+		return 64 - bits.LeadingZeros64(u)
 	case intVal:
 		return x.val.BitLen()
 	case unknownVal:
@@ -720,7 +758,7 @@
 	case ratVal:
 		return makeInt(x.val.Num())
 	case floatVal:
-		if smallRat(x.val) {
+		if smallFloat(x.val) {
 			r, _ := x.val.Rat(nil)
 			return makeInt(r.Num())
 		}
@@ -742,7 +780,7 @@
 	case ratVal:
 		return makeInt(x.val.Denom())
 	case floatVal:
-		if smallRat(x.val) {
+		if smallFloat(x.val) {
 			r, _ := x.val.Rat(nil)
 			return makeInt(r.Denom())
 		}
@@ -815,7 +853,7 @@
 		// avoid creation of huge integers
 		// (Existing tests require permitting exponents of at least 1024;
 		// allow any value that would also be permissible as a fraction.)
-		if smallRat(x.val) {
+		if smallFloat(x.val) {
 			i := newInt()
 			if _, acc := x.val.Int(i); acc == big.Exact {
 				return makeInt(i)
@@ -858,14 +896,16 @@
 func ToFloat(x Value) Value {
 	switch x := x.(type) {
 	case int64Val:
-		return i64tof(x)
+		return i64tor(x) // x is always a small int
 	case intVal:
+		if smallInt(x.val) {
+			return itor(x)
+		}
 		return itof(x)
 	case ratVal, floatVal:
 		return x
 	case complexVal:
-		if im := ToInt(x.im); im.Kind() == Int && Sign(im) == 0 {
-			// imaginary component is 0
+		if Sign(x.im) == 0 {
 			return ToFloat(x.re)
 		}
 	}
@@ -876,13 +916,7 @@
 // Otherwise it returns an Unknown.
 func ToComplex(x Value) Value {
 	switch x := x.(type) {
-	case int64Val:
-		return vtoc(i64tof(x))
-	case intVal:
-		return vtoc(itof(x))
-	case ratVal:
-		return vtoc(x)
-	case floatVal:
+	case int64Val, intVal, ratVal, floatVal:
 		return vtoc(x)
 	case complexVal:
 		return x
@@ -1001,59 +1035,45 @@
 // or invalid (say, nil) both results are that value.
 //
 func match(x, y Value) (_, _ Value) {
-	if ord(x) > ord(y) {
-		y, x = match(y, x)
-		return x, y
+	switch ox, oy := ord(x), ord(y); {
+	case ox < oy:
+		x, y = match0(x, y)
+	case ox > oy:
+		y, x = match0(y, x)
 	}
-	// ord(x) <= ord(y)
+	return x, y
+}
 
-	switch x := x.(type) {
-	case boolVal, *stringVal, complexVal:
-		return x, y
+// match0 must only be called by match.
+// Invariant: ord(x) < ord(y)
+func match0(x, y Value) (_, _ Value) {
+	// Prefer to return the original x and y arguments when possible,
+	// to avoid unnecessary heap allocations.
 
-	case int64Val:
-		switch y := y.(type) {
-		case int64Val:
-			return x, y
-		case intVal:
-			return i64toi(x), y
-		case ratVal:
-			return i64tor(x), y
-		case floatVal:
-			return i64tof(x), y
-		case complexVal:
-			return vtoc(x), y
-		}
-
+	switch y.(type) {
 	case intVal:
-		switch y := y.(type) {
-		case intVal:
-			return x, y
-		case ratVal:
-			return itor(x), y
-		case floatVal:
-			return itof(x), y
-		case complexVal:
-			return vtoc(x), y
+		switch x1 := x.(type) {
+		case int64Val:
+			return i64toi(x1), y
 		}
-
 	case ratVal:
-		switch y := y.(type) {
-		case ratVal:
-			return x, y
-		case floatVal:
-			return rtof(x), y
-		case complexVal:
-			return vtoc(x), y
+		switch x1 := x.(type) {
+		case int64Val:
+			return i64tor(x1), y
+		case intVal:
+			return itor(x1), y
 		}
-
 	case floatVal:
-		switch y := y.(type) {
-		case floatVal:
-			return x, y
-		case complexVal:
-			return vtoc(x), y
+		switch x1 := x.(type) {
+		case int64Val:
+			return i64tof(x1), y
+		case intVal:
+			return itof(x1), y
+		case ratVal:
+			return rtof(x1), y
 		}
+	case complexVal:
+		return vtoc(x), y
 	}
 
 	// force unknown and invalid values into "x position" in callers of match
diff --git a/src/go/constant/value_test.go b/src/go/constant/value_test.go
index a319039f..91ad0b0 100644
--- a/src/go/constant/value_test.go
+++ b/src/go/constant/value_test.go
@@ -7,6 +7,7 @@
 import (
 	"fmt"
 	"go/token"
+	"math"
 	"math/big"
 	"strings"
 	"testing"
@@ -82,6 +83,11 @@
 	`1_2_3.123 = 123.123`,
 	`0123.01_23 = 123.0123`,
 
+	`1e-1000000000 = 0`,
+	`1e+1000000000 = ?`,
+	`6e5518446744 = ?`,
+	`-6e5518446744 = ?`,
+
 	// hexadecimal floats
 	`0x0.p+0 = 0.`,
 	`0Xdeadcafe.p-10 = 0xdeadcafe/1024`,
@@ -117,6 +123,11 @@
 	`0.e+1i = 0i`,
 	`123.E-1_0i = 123e-10i`,
 	`01_23.e123i = 123e123i`,
+
+	`1e-1000000000i = 0i`,
+	`1e+1000000000i = ?`,
+	`6e5518446744i = ?`,
+	`-6e5518446744i = ?`,
 }
 
 func testNumbers(t *testing.T, kind token.Token, tests []string) {
@@ -129,21 +140,32 @@
 
 		x := MakeFromLiteral(a[0], kind, 0)
 		var y Value
-		if i := strings.Index(a[1], "/"); i >= 0 && kind == token.FLOAT {
-			n := MakeFromLiteral(a[1][:i], token.INT, 0)
-			d := MakeFromLiteral(a[1][i+1:], token.INT, 0)
-			y = BinaryOp(n, token.QUO, d)
+		if a[1] == "?" {
+			y = MakeUnknown()
 		} else {
-			y = MakeFromLiteral(a[1], kind, 0)
+			if i := strings.Index(a[1], "/"); i >= 0 && kind == token.FLOAT {
+				n := MakeFromLiteral(a[1][:i], token.INT, 0)
+				d := MakeFromLiteral(a[1][i+1:], token.INT, 0)
+				y = BinaryOp(n, token.QUO, d)
+			} else {
+				y = MakeFromLiteral(a[1], kind, 0)
+			}
+			if y.Kind() == Unknown {
+				panic(fmt.Sprintf("invalid test case: %s %d", test, y.Kind()))
+			}
 		}
 
 		xk := x.Kind()
 		yk := y.Kind()
-		if xk != yk || xk == Unknown {
+		if xk != yk {
 			t.Errorf("%s: got kind %d != %d", test, xk, yk)
 			continue
 		}
 
+		if yk == Unknown {
+			continue
+		}
+
 		if !Compare(x, token.EQL, y) {
 			t.Errorf("%s: %s != %s", test, x, y)
 		}
@@ -200,6 +222,7 @@
 	`1i * 1i = -1`,
 	`? * 0 = ?`,
 	`0 * ? = ?`,
+	`0 * 1e+1000000000 = ?`,
 
 	`0 / 0 = "division_by_zero"`,
 	`10 / 2 = 5`,
@@ -207,6 +230,7 @@
 	`5i / 3i = 5/3`,
 	`? / 0 = ?`,
 	`0 / ? = ?`,
+	`0 * 1e+1000000000i = ?`,
 
 	`0 % 0 = "runtime_error:_integer_divide_by_zero"`, // TODO(gri) should be the same as for /
 	`10 % 3 = 1`,
@@ -597,18 +621,68 @@
 	}
 }
 
-func TestMake(t *testing.T) {
-	for _, want := range []interface{}{
-		false,
-		"hello",
-		int64(1),
-		big.NewInt(10),
-		big.NewFloat(2.0),
-		big.NewRat(1, 3),
+func TestMakeFloat64(t *testing.T) {
+	var zero float64
+	for _, arg := range []float64{
+		-math.MaxFloat32,
+		-10,
+		-0.5,
+		-zero,
+		zero,
+		1,
+		10,
+		123456789.87654321e-23,
+		1e10,
+		math.MaxFloat64,
 	} {
-		got := Val(Make(want))
-		if got != want {
-			t.Errorf("got %v; want %v", got, want)
+		val := MakeFloat64(arg)
+		if val.Kind() != Float {
+			t.Errorf("%v: got kind = %d; want %d", arg, val.Kind(), Float)
+		}
+
+		// -0.0 is mapped to 0.0
+		got, exact := Float64Val(val)
+		if !exact || math.Float64bits(got) != math.Float64bits(arg+0) {
+			t.Errorf("%v: got %v (exact = %v)", arg, got, exact)
+		}
+	}
+
+	// infinity
+	for sign := range []int{-1, 1} {
+		arg := math.Inf(sign)
+		val := MakeFloat64(arg)
+		if val.Kind() != Unknown {
+			t.Errorf("%v: got kind = %d; want %d", arg, val.Kind(), Unknown)
+		}
+	}
+}
+
+type makeTestCase struct {
+	kind      Kind
+	arg, want interface{}
+}
+
+func dup(k Kind, x interface{}) makeTestCase { return makeTestCase{k, x, x} }
+
+func TestMake(t *testing.T) {
+	for _, test := range []makeTestCase{
+		{Bool, false, false},
+		{String, "hello", "hello"},
+
+		{Int, int64(1), int64(1)},
+		{Int, big.NewInt(10), int64(10)},
+		{Int, new(big.Int).Lsh(big.NewInt(1), 62), int64(1 << 62)},
+		dup(Int, new(big.Int).Lsh(big.NewInt(1), 63)),
+
+		{Float, big.NewFloat(0), floatVal0.val},
+		dup(Float, big.NewFloat(2.0)),
+		dup(Float, big.NewRat(1, 3)),
+	} {
+		val := Make(test.arg)
+		got := Val(val)
+		if val.Kind() != test.kind || got != test.want {
+			t.Errorf("got %v (%T, kind = %d); want %v (%T, kind = %d)",
+				got, got, val.Kind(), test.want, test.want, test.kind)
 		}
 	}
 }
@@ -632,3 +706,24 @@
 		})
 	}
 }
+
+var bitLenTests = []struct {
+	val  int64
+	want int
+}{
+	{0, 0},
+	{1, 1},
+	{-16, 5},
+	{1 << 61, 62},
+	{1 << 62, 63},
+	{-1 << 62, 63},
+	{-1 << 63, 64},
+}
+
+func TestBitLen(t *testing.T) {
+	for _, test := range bitLenTests {
+		if got := BitLen(MakeInt64(test.val)); got != test.want {
+			t.Errorf("%v: got %v, want %v", test.val, got, test.want)
+		}
+	}
+}
diff --git a/src/go/format/format.go b/src/go/format/format.go
index 3613702..279fc2e 100644
--- a/src/go/format/format.go
+++ b/src/go/format/format.go
@@ -27,12 +27,18 @@
 // Keep these in sync with cmd/gofmt/gofmt.go.
 const (
 	tabWidth    = 8
-	printerMode = printer.UseSpaces | printer.TabIndent | printer.StdFormat | printer.UseBrackets
+	printerMode = printer.UseSpaces | printer.TabIndent | printerNormalizeNumbers
+
+	// printerNormalizeNumbers means to canonicalize number literal prefixes
+	// and exponents while printing. See https://golang.org/doc/go1.13#gofmt.
+	//
+	// This value is defined in go/printer specifically for go/format and cmd/gofmt.
+	printerNormalizeNumbers = 1 << 30
 )
 
 var config = printer.Config{Mode: printerMode, Tabwidth: tabWidth}
 
-const parserMode = parser.ParseComments | parser.UnifiedParamLists
+const parserMode = parser.ParseComments | parser.ParseTypeParams
 
 // Node formats node in canonical gofmt style and writes the result to dst.
 //
diff --git a/src/go/format/format_test.go b/src/go/format/format_test.go
index aee51e2..58e088e 100644
--- a/src/go/format/format_test.go
+++ b/src/go/format/format_test.go
@@ -58,8 +58,8 @@
 	diff(t, buf.Bytes(), src)
 }
 
-// Node is documented to not modify the AST. Test that it is so, even when
-// formatting changes are applied due to printer.StdFormat mode being used.
+// Node is documented to not modify the AST.
+// Test that it is so even when numbers are normalized.
 func TestNodeNoModify(t *testing.T) {
 	const (
 		src    = "package p\n\nconst _ = 0000000123i\n"
diff --git a/src/go/go2go/go2go.go b/src/go/go2go/go2go.go
index a2265f1..b0c4873 100644
--- a/src/go/go2go/go2go.go
+++ b/src/go/go2go/go2go.go
@@ -83,9 +83,8 @@
 
 		var merr multiErr
 		conf := types.Config{
-			InferFromConstraints: true,
-			Importer:             importer,
-			Error:                merr.add,
+			Importer: importer,
+			Error:    merr.add,
 		}
 		path := importPath
 		if path == "" {
@@ -126,15 +125,14 @@
 // for error messages.
 func RewriteBuffer(importer *Importer, filename string, file []byte) ([]byte, error) {
 	fset := token.NewFileSet()
-	pf, err := parser.ParseFile(fset, filename, file, parser.UnifiedParamLists)
+	pf, err := parser.ParseFile(fset, filename, file, parser.ParseTypeParams)
 	if err != nil {
 		return nil, err
 	}
 	var merr multiErr
 	conf := types.Config{
-		InferFromConstraints: true,
-		Importer:             importer,
-		Error:                merr.add,
+		Importer: importer,
+		Error:    merr.add,
 	}
 	tpkg, err := conf.Check(pf.Name.Name, fset, []*ast.File{pf}, importer.info)
 	if err != nil {
@@ -222,7 +220,7 @@
 func parseFiles(importer *Importer, dir string, go2files []string, fset *token.FileSet) ([]*ast.Package, error) {
 	pkgs := make(map[string]*ast.Package)
 	for _, go2f := range go2files {
-		mode := parser.UnifiedParamLists // overrides UseBrackets
+		mode := parser.ParseTypeParams
 
 		filename := filepath.Join(dir, go2f)
 		pf, err := parser.ParseFile(fset, filename, nil, mode)
diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go
index c7f93c9a..15c1b50 100644
--- a/src/go/parser/error_test.go
+++ b/src/go/parser/error_test.go
@@ -114,6 +114,7 @@
 // of found errors and reports discrepancies.
 //
 func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]string, found scanner.ErrorList) {
+	t.Helper()
 	for _, error := range found {
 		// error.Pos is a token.Position, but we want
 		// a token.Pos so we can do a map lookup
@@ -149,7 +150,8 @@
 	}
 }
 
-func checkErrors(t *testing.T, filename string, input interface{}) {
+func checkErrors(t *testing.T, filename string, input interface{}, mode Mode, expectErrors bool) {
+	t.Helper()
 	src, err := readSource(filename, input)
 	if err != nil {
 		t.Error(err)
@@ -157,7 +159,7 @@
 	}
 
 	fset := token.NewFileSet()
-	_, err = ParseFile(fset, filename, src, DeclarationErrors|AllErrors)
+	_, err = ParseFile(fset, filename, src, mode)
 	found, ok := err.(scanner.ErrorList)
 	if err != nil && !ok {
 		t.Error(err)
@@ -165,9 +167,12 @@
 	}
 	found.RemoveMultiples()
 
-	// we are expecting the following errors
-	// (collect these after parsing a file so that it is found in the file set)
-	expected := expectedErrors(fset, filename, src)
+	expected := map[token.Pos]string{}
+	if expectErrors {
+		// we are expecting the following errors
+		// (collect these after parsing a file so that it is found in the file set)
+		expected = expectedErrors(fset, filename, src)
+	}
 
 	// verify errors returned by the parser
 	compareErrors(t, fset, expected, found)
@@ -178,10 +183,14 @@
 	if err != nil {
 		t.Fatal(err)
 	}
-	for _, fi := range list {
-		name := fi.Name()
-		if !fi.IsDir() && !strings.HasPrefix(name, ".") && (strings.HasSuffix(name, ".src") || strings.HasSuffix(name, ".go2")) {
-			checkErrors(t, filepath.Join(testdata, name), nil)
+	for _, d := range list {
+		name := d.Name()
+		if !d.IsDir() && !strings.HasPrefix(name, ".") && (strings.HasSuffix(name, ".src") || strings.HasSuffix(name, ".go2")) {
+			mode := DeclarationErrors | AllErrors
+			if strings.HasSuffix(name, ".go2") {
+				mode |= ParseTypeParams
+			}
+			checkErrors(t, filepath.Join(testdata, name), nil, mode, true)
 		}
 	}
 }
diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go
index e8d218e..58c57a1 100644
--- a/src/go/parser/interface.go
+++ b/src/go/parser/interface.go
@@ -55,8 +55,7 @@
 	Trace                                          // print a trace of parsed productions
 	DeclarationErrors                              // report declaration errors
 	SpuriousErrors                                 // same as AllErrors, for backward-compatibility
-	UseBrackets                                    // use square brackets with type parameters
-	UnifiedParamLists                              // use same syntax for type and ordinary parameter lists (implies UseBrackets)
+	ParseTypeParams                                // Placeholder. Will control the parsing of type parameters.
 	AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
 )
 
@@ -142,23 +141,29 @@
 
 	pkgs = make(map[string]*ast.Package)
 	for _, d := range list {
-		if strings.HasSuffix(d.Name(), ".go") && (filter == nil || filter(d)) {
-			filename := filepath.Join(path, d.Name())
-			if src, err := ParseFile(fset, filename, nil, mode); err == nil {
-				name := src.Name.Name
-				pkg, found := pkgs[name]
-				if !found {
-					pkg = &ast.Package{
-						Name:  name,
-						Files: make(map[string]*ast.File),
-					}
-					pkgs[name] = pkg
-				}
-				pkg.Files[filename] = src
-			} else if first == nil {
-				first = err
+		if d.IsDir() || !strings.HasSuffix(d.Name(), ".go") {
+			continue
+		}
+		if filter != nil {
+			if !filter(d) {
+				continue
 			}
 		}
+		filename := filepath.Join(path, d.Name())
+		if src, err := ParseFile(fset, filename, nil, mode); err == nil {
+			name := src.Name.Name
+			pkg, found := pkgs[name]
+			if !found {
+				pkg = &ast.Package{
+					Name:  name,
+					Files: make(map[string]*ast.File),
+				}
+				pkgs[name] = pkg
+			}
+			pkg.Files[filename] = src
+		} else if first == nil {
+			first = err
+		}
 	}
 
 	return
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 797ef25..ccbcef8 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -35,7 +35,6 @@
 	// Tracing/debugging
 	mode   Mode // parsing mode
 	trace  bool // == (mode&Trace != 0)
-	brack  bool // use square brackets to enclose type parameters
 	indent int  // indentation used for tracing output
 
 	// Comments
@@ -82,7 +81,6 @@
 
 	p.mode = mode
 	p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
-	p.brack = mode&UseBrackets != 0 || mode&UnifiedParamLists != 0
 
 	p.next()
 }
@@ -630,12 +628,12 @@
 // ----------------------------------------------------------------------------
 // Types
 
-func (p *parser) parseType(typeContext bool) ast.Expr {
+func (p *parser) parseType() ast.Expr {
 	if p.trace {
 		defer un(trace(p, "Type"))
 	}
 
-	typ := p.tryType(typeContext)
+	typ := p.tryType()
 
 	if typ == nil {
 		pos := p.pos
@@ -647,6 +645,19 @@
 	return typ
 }
 
+func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
+	if p.trace {
+		defer un(trace(p, "QualifiedIdent"))
+	}
+
+	typ := p.parseTypeName(ident)
+	if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
+		typ = p.parseTypeInstance(typ)
+	}
+
+	return typ
+}
+
 // If the result is an identifier, it is not resolved.
 func (p *parser) parseTypeName(ident *ast.Ident) ast.Expr {
 	if p.trace {
@@ -697,12 +708,22 @@
 	//           list such as T[P,]? (We do in parseTypeInstance).
 	lbrack := p.expect(token.LBRACK)
 	var args []ast.Expr
+	var firstComma token.Pos
+	// TODO(rfindley): consider changing parseRhsOrType so that this function variable
+	// is not needed.
+	argparser := p.parseRhsOrType
+	if p.mode&ParseTypeParams == 0 {
+		argparser = p.parseRhs
+	}
 	if p.tok != token.RBRACK {
 		p.exprLev++
-		args = append(args, p.parseRhsOrType())
+		args = append(args, argparser())
 		for p.tok == token.COMMA {
+			if !firstComma.IsValid() {
+				firstComma = p.pos
+			}
 			p.next()
-			args = append(args, p.parseRhsOrType())
+			args = append(args, argparser())
 		}
 		p.exprLev--
 	}
@@ -710,36 +731,32 @@
 
 	if len(args) == 0 {
 		// x []E
-		elt := p.parseType(true)
+		elt := p.parseType()
 		return x, &ast.ArrayType{Lbrack: lbrack, Elt: elt}
 	}
 
 	// x [P]E or x[P]
 	if len(args) == 1 {
-		elt := p.tryType(true)
+		elt := p.tryType()
 		if elt != nil {
 			// x [P]E
 			return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
 		}
+		if p.mode&ParseTypeParams == 0 {
+			p.error(rbrack, "missing element type in array type expression")
+			return nil, &ast.BadExpr{From: args[0].Pos(), To: args[0].End()}
+		}
+	}
+
+	if p.mode&ParseTypeParams == 0 {
+		p.error(firstComma, "expected ']', found ','")
+		return x, &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
 	}
 
 	// x[P], x[P1, P2], ...
 	return nil, &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
 }
 
-type lookAhead struct {
-	pos token.Pos
-	tok token.Token
-}
-
-func (l *lookAhead) consume(p *parser) {
-	if l.tok == 0 {
-		l.pos = p.pos
-		l.tok = p.tok
-		p.next()
-	}
-}
-
 func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
 	if p.trace {
 		defer un(trace(p, "FieldDecl"))
@@ -755,11 +772,7 @@
 			// embedded type
 			typ = name
 			if p.tok == token.PERIOD {
-				typ = p.parseTypeName(name)
-				// A [ or ( indicates a type parameter (or a syntax error).
-				if p.brack && p.tok == token.LBRACK || !p.brack && p.tok == token.LPAREN {
-					typ = p.parseTypeInstance(typ, lookAhead{})
-				}
+				typ = p.parseQualifiedIdent(name)
 			} else {
 				p.resolve(typ)
 			}
@@ -772,21 +785,21 @@
 			}
 			// Careful dance: We don't know if we have an embedded instantiated
 			// type T[P1, P2, ...] or a field T of array type []E or [P]E.
-			if len(names) == 1 && p.brack && p.tok == token.LBRACK {
+			if len(names) == 1 && p.tok == token.LBRACK {
 				name, typ = p.parseArrayFieldOrTypeInstance(name)
 				if name == nil {
 					names = nil
 				}
 			} else {
 				// T P
-				typ = p.parseType(true)
+				typ = p.parseType()
 			}
 		}
 	} else {
 		// embedded, possibly generic type
 		// (using the enclosing parentheses to distinguish it from a named field declaration)
-		// TODO(gri) if p.brack is set, don't allow parenthesized embedded type
-		typ = p.parseType(true)
+		// TODO(rFindley) confirm that this doesn't allow parenthesized embedded type
+		typ = p.parseType()
 	}
 
 	var tag *ast.BasicLit
@@ -795,7 +808,7 @@
 		p.next()
 	}
 
-	p.expectSemi()
+	p.expectSemi() // call before accessing p.linecomment
 
 	field := &ast.Field{Doc: doc, Names: names, Type: typ, Tag: tag, Comment: p.lineComment}
 	p.declare(field, nil, scope, ast.Var, names...)
@@ -812,6 +825,9 @@
 	scope := ast.NewScope(nil) // struct scope
 	var list []*ast.Field
 	for p.tok == token.IDENT || p.tok == token.MUL || p.tok == token.LPAREN {
+		// a field declaration cannot start with a '(' but we accept
+		// it here for more robust parsing and better error messages
+		// (parseFieldDecl will check and complain if necessary)
 		list = append(list, p.parseFieldDecl(scope))
 	}
 	rbrace := p.expect(token.RBRACE)
@@ -826,13 +842,13 @@
 	}
 }
 
-func (p *parser) parsePointerType(typeContext bool) *ast.StarExpr {
+func (p *parser) parsePointerType() *ast.StarExpr {
 	if p.trace {
 		defer un(trace(p, "PointerType"))
 	}
 
 	star := p.expect(token.MUL)
-	base := p.parseType(typeContext)
+	base := p.parseType()
 
 	return &ast.StarExpr{Star: star, X: base}
 }
@@ -843,7 +859,7 @@
 	}
 
 	pos := p.expect(token.ELLIPSIS)
-	elt := p.parseType(true)
+	elt := p.parseType()
 
 	return &ast.Ellipsis{Ellipsis: pos, Elt: elt}
 }
@@ -854,6 +870,7 @@
 }
 
 func (p *parser) parseParamDecl(name *ast.Ident) (f field) {
+	// TODO(rFindley) compare with parser.paramDeclOrNil in the syntax package
 	if p.trace {
 		defer un(trace(p, "ParamDeclOrNil"))
 	}
@@ -874,15 +891,11 @@
 		switch p.tok {
 		case token.IDENT, token.MUL, token.ARROW, token.FUNC, token.CHAN, token.MAP, token.STRUCT, token.INTERFACE, token.LPAREN:
 			// name type
-			f.typ = p.parseType(true)
+			f.typ = p.parseType()
 
 		case token.LBRACK:
-			if p.brack {
-				// name[type1, type2, ...] or name []type or name [len]type
-				f.name, f.typ = p.parseArrayFieldOrTypeInstance(f.name)
-			} else {
-				f.typ = p.parseType(true)
-			}
+			// name[type1, type2, ...] or name []type or name [len]type
+			f.name, f.typ = p.parseArrayFieldOrTypeInstance(f.name)
 
 		case token.ELLIPSIS:
 			// name ...type
@@ -890,16 +903,13 @@
 
 		case token.PERIOD:
 			// qualified.typename
-			f.typ = p.parseTypeName(f.name)
-			if p.brack && p.tok == token.LBRACK || !p.brack && p.tok == token.LPAREN {
-				f.typ = p.parseTypeInstance(f.typ, lookAhead{})
-			}
+			f.typ = p.parseQualifiedIdent(f.name)
 			f.name = nil
 		}
 
 	case token.MUL, token.ARROW, token.FUNC, token.LBRACK, token.CHAN, token.MAP, token.STRUCT, token.INTERFACE, token.LPAREN:
 		// type
-		f.typ = p.parseType(true)
+		f.typ = p.parseType()
 
 	case token.ELLIPSIS:
 		// ...type
@@ -914,35 +924,6 @@
 	return
 }
 
-func (p *parser) parseTParamDecl(name *ast.Ident) (f field) {
-	if p.trace {
-		defer un(trace(p, "TParamDeclOrNil"))
-	}
-
-	ptr := false
-	if name == nil && p.tok == token.MUL {
-		ptr = true
-		p.next()
-	}
-
-	if name == nil {
-		name = p.parseIdent()
-	}
-	f.name = name
-	if ptr {
-		// encode pointer designation in the name
-		f.name.Name = "*" + f.name.Name
-	}
-
-	switch p.tok {
-	case token.IDENT, token.INTERFACE, token.LPAREN:
-		// type bound
-		f.typ = p.parseType(true)
-	}
-
-	return
-}
-
 func (p *parser) parseParameterList(scope *ast.Scope, name0 *ast.Ident, closing token.Token, parseParamDecl func(*ast.Ident) field, tparams bool) (params []*ast.Field) {
 	if p.trace {
 		defer un(trace(p, "ParameterList"))
@@ -1059,96 +1040,49 @@
 	return
 }
 
-func (p *parser) parseTypeParams(scope *ast.Scope, name0 *ast.Ident, closing token.Token) []*ast.Field {
-	if p.trace {
-		defer un(trace(p, "TypeParams"))
-	}
-
-	params := p.parseParameterList(scope, name0, closing, p.parseTParamDecl, false)
-
-	// determine which form we have (list of type parameters with optional
-	// type bound, or type parameters, all with interfaces as type bounds)
-	for _, f := range params {
-		if len(f.Names) == 0 {
-			assert(f.Type != nil, "expected non-nil type")
-			f.Names = []*ast.Ident{f.Type.(*ast.Ident)}
-			f.Type = nil
-		}
-	}
-
-	return params
-}
-
-func (p *parser) parseParameters(scope *ast.Scope, opening lookAhead, acceptTParams bool) (tparams, params *ast.FieldList) {
+func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams, params *ast.FieldList) {
 	if p.trace {
 		defer un(trace(p, "Parameters"))
 	}
 
-	opening.consume(p)
-	lparen := opening.pos
-	if acceptTParams {
-		if opening.tok == token.LBRACK {
-			var list []*ast.Field
-			if p.mode&UnifiedParamLists != 0 {
-				// assume [T any](params) syntax
-				list = p.parseParameterList(scope, nil, token.RBRACK, p.parseParamDecl, true)
-			} else {
-				// assume [type T](params) syntax
-				p.brack = true
-				if p.tok == token.TYPE {
-					p.next()
-				}
-				list = p.parseTypeParams(scope, nil, token.RBRACK)
-			}
-			rbrack := p.expect(token.RBRACK)
-			tparams = &ast.FieldList{Opening: lparen, List: list, Closing: rbrack}
-			lparen = p.expect(token.LPAREN)
-		} else {
-			// assume (type T)(params) syntax
-			if opening.tok != token.LPAREN {
-				p.errorExpected(opening.pos, "'('")
-			}
-			if !p.brack && p.tok == token.TYPE {
-				p.next()
-				list := p.parseTypeParams(scope, nil, token.RPAREN)
-				rparen := p.expect(token.RPAREN)
-				tparams = &ast.FieldList{Opening: lparen, List: list, Closing: rparen}
-				lparen = p.expect(token.LPAREN)
-			}
-		}
-		// type parameter lists must not be empty when we have unified parameter lists
-		if p.mode&UnifiedParamLists != 0 && tparams != nil && tparams.NumFields() == 0 {
+	if p.mode&ParseTypeParams != 0 && acceptTParams && p.tok == token.LBRACK {
+		opening := p.pos
+		p.next()
+		// [T any](params) syntax
+		list := p.parseParameterList(scope, nil, token.RBRACK, p.parseParamDecl, true)
+		rbrack := p.expect(token.RBRACK)
+		tparams = &ast.FieldList{Opening: opening, List: list, Closing: rbrack}
+		// Type parameter lists must not be empty.
+		if tparams != nil && tparams.NumFields() == 0 {
 			p.error(tparams.Closing, "empty type parameter list")
 			tparams = nil // avoid follow-on errors
 		}
-	} else {
-		if opening.tok != token.LPAREN {
-			p.errorExpected(lparen, "'('")
-		}
 	}
 
+	opening := p.expect(token.LPAREN)
+
 	var fields []*ast.Field
 	if p.tok != token.RPAREN {
 		fields = p.parseParameterList(scope, nil, token.RPAREN, p.parseParamDecl, false)
 	}
 
 	rparen := p.expect(token.RPAREN)
-	params = &ast.FieldList{Opening: lparen, List: fields, Closing: rparen}
+	params = &ast.FieldList{Opening: opening, List: fields, Closing: rparen}
 
 	return
 }
 
-func (p *parser) parseResult(scope *ast.Scope, typeContext bool) *ast.FieldList {
+func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
 	if p.trace {
 		defer un(trace(p, "Result"))
 	}
 
 	if p.tok == token.LPAREN {
-		_, results := p.parseParameters(scope, lookAhead{}, false)
+		_, results := p.parseParameters(scope, false)
 		return results
 	}
 
-	typ := p.tryType(typeContext)
+	typ := p.tryType()
 	if typ != nil {
 		list := make([]*ast.Field, 1)
 		list[0] = &ast.Field{Type: typ}
@@ -1158,18 +1092,18 @@
 	return nil
 }
 
-func (p *parser) parseFuncType(typeContext bool) (*ast.FuncType, *ast.Scope) {
+func (p *parser) parseFuncType() (*ast.FuncType, *ast.Scope) {
 	if p.trace {
 		defer un(trace(p, "FuncType"))
 	}
 
 	pos := p.expect(token.FUNC)
 	scope := ast.NewScope(p.topScope) // function scope
-	tparams, params := p.parseParameters(scope, lookAhead{}, true)
+	tparams, params := p.parseParameters(scope, true)
 	if tparams != nil {
 		p.error(tparams.Pos(), "function type cannot have type parameters")
 	}
-	results := p.parseResult(scope, typeContext)
+	results := p.parseResult(scope)
 
 	return &ast.FuncType{Func: pos, Params: params, Results: results}, scope
 }
@@ -1182,99 +1116,64 @@
 	doc := p.leadComment
 	var idents []*ast.Ident
 	var typ ast.Expr
-	if p.mode&UnifiedParamLists != 0 {
-		x := p.parseTypeName(nil)
-		if ident, _ := x.(*ast.Ident); ident != nil {
-			switch p.tok {
-			case token.LBRACK:
-				// generic method or embedded instantiated type
-				lbrack := p.pos
-				p.next()
-				p.exprLev++
-				x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
-				p.exprLev--
-				if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.COMMA && p.tok != token.RBRACK {
-					// generic method m[T any]
-					scope := ast.NewScope(nil) // method scope
-					list := p.parseParameterList(scope, name0, token.RBRACK, p.parseParamDecl, true)
-					rbrack := p.expect(token.RBRACK)
-					tparams := &ast.FieldList{Opening: lbrack, List: list, Closing: rbrack}
-					_, params := p.parseParameters(scope, lookAhead{}, false)
-					results := p.parseResult(scope, true)
-					idents = []*ast.Ident{ident}
-					typ = &ast.FuncType{Func: token.NoPos, TParams: tparams, Params: params, Results: results}
-				} else {
-					// embedded instantiated type
-					// TODO(gri) should resolve all identifiers in x (doesn't matter for this prototype)
-					list := []ast.Expr{x}
-					if p.atComma("type argument list", token.RBRACK) {
-						p.exprLev++
-						for p.tok != token.RBRACK && p.tok != token.EOF {
-							list = append(list, p.parseType(true))
-							if !p.atComma("type argument list", token.RBRACK) {
-								break
-							}
-							p.next()
-						}
-						p.exprLev--
-					}
-					rbrack := p.expectClosing(token.RBRACK, "type argument list")
-					typ = &ast.CallExpr{Fun: ident, Lparen: lbrack, Args: list, Rparen: rbrack, Brackets: true}
-				}
-			case token.LPAREN:
-				// ordinary method
+	x := p.parseTypeName(nil)
+	if ident, _ := x.(*ast.Ident); ident != nil {
+		switch {
+		case p.tok == token.LBRACK && p.mode&ParseTypeParams != 0:
+			// generic method or embedded instantiated type
+			lbrack := p.pos
+			p.next()
+			p.exprLev++
+			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
+			p.exprLev--
+			if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.COMMA && p.tok != token.RBRACK {
+				// generic method m[T any]
 				scope := ast.NewScope(nil) // method scope
-				_, params := p.parseParameters(scope, lookAhead{}, false)
-				results := p.parseResult(scope, true)
+				list := p.parseParameterList(scope, name0, token.RBRACK, p.parseParamDecl, true)
+				rbrack := p.expect(token.RBRACK)
+				tparams := &ast.FieldList{Opening: lbrack, List: list, Closing: rbrack}
+				// TODO(rfindley) refactor to share code with parseFuncType.
+				_, params := p.parseParameters(scope, false)
+				results := p.parseResult(scope)
 				idents = []*ast.Ident{ident}
-				typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
-			default:
-				// embedded type
-				typ = x
-				p.resolve(typ)
+				typ = &ast.FuncType{Func: token.NoPos, TParams: tparams, Params: params, Results: results}
+			} else {
+				// embedded instantiated type
+				// TODO(rfindley) should resolve all identifiers in x.
+				list := []ast.Expr{x}
+				if p.atComma("type argument list", token.RBRACK) {
+					p.exprLev++
+					for p.tok != token.RBRACK && p.tok != token.EOF {
+						list = append(list, p.parseType())
+						if !p.atComma("type argument list", token.RBRACK) {
+							break
+						}
+						p.next()
+					}
+					p.exprLev--
+				}
+				rbrack := p.expectClosing(token.RBRACK, "type argument list")
+				typ = &ast.CallExpr{Fun: ident, Lparen: lbrack, Args: list, Rparen: rbrack, Brackets: true}
 			}
-		} else {
-			// embedded, possibly instantiated type
+		case p.tok == token.LPAREN:
+			// ordinary method
+			// TODO(rfindley) refactor to share code with parseFuncType.
+			scope := ast.NewScope(nil) // method scope
+			_, params := p.parseParameters(scope, false)
+			results := p.parseResult(scope)
+			idents = []*ast.Ident{ident}
+			typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
+		default:
+			// embedded type
 			typ = x
-			if p.tok == token.LBRACK {
-				// embedded instantiated interface
-				typ = p.parseTypeInstance(typ, lookAhead{})
-			}
+			p.resolve(typ)
 		}
 	} else {
-		if p.tok == token.IDENT {
-			x := p.parseTypeName(nil)
-			if ident, _ := x.(*ast.Ident); ident != nil && (p.tok == token.LPAREN || p.brack && p.tok == token.LBRACK) {
-				// method or embedded instantiated type
-				opening := lookAhead{p.pos, p.tok}
-				p.next()
-				if opening.tok == token.LBRACK && p.tok != token.TYPE {
-					// embedded instantiated type
-					typ = x
-					p.resolve(typ)
-					typ = p.parseTypeInstance(typ, opening)
-				} else {
-					// method
-					idents = []*ast.Ident{ident}
-					scope := ast.NewScope(nil) // method scope
-					tparams, params := p.parseParameters(scope, opening, true)
-					results := p.parseResult(scope, true)
-					typ = &ast.FuncType{Func: token.NoPos, TParams: tparams, Params: params, Results: results}
-				}
-			} else {
-				// embedded, possibly instantiated type
-				typ = x
-				p.resolve(typ)
-				if p.brack && p.tok == token.LBRACK {
-					// embedded instantiated interface
-					typ = p.parseTypeInstance(typ, lookAhead{})
-				}
-			}
-		} else {
-			// embedded, possibly instantiated type
-			// (using enclosing parentheses to distinguish it from a method declaration)
-			// TODO(gri) if p.brack is set, don't allow parenthesized embedded type
-			typ = p.parseType(true)
+		// embedded, possibly instantiated type
+		typ = x
+		if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
+			// embedded instantiated interface
+			typ = p.parseTypeInstance(typ)
 		}
 	}
 	p.expectSemi() // call before accessing p.linecomment
@@ -1294,12 +1193,10 @@
 	lbrace := p.expect(token.LBRACE)
 	scope := ast.NewScope(nil) // interface scope
 	var list []*ast.Field
-L:
-	for {
-		switch p.tok {
-		case token.IDENT, token.LPAREN:
+	for p.tok == token.IDENT || p.mode&ParseTypeParams != 0 && p.tok == token.TYPE {
+		if p.tok == token.IDENT {
 			list = append(list, p.parseMethodSpec(scope))
-		case token.TYPE:
+		} else {
 			// all types in a type list share the same field name "type"
 			// (since type is a keyword, a Go program cannot have that field name)
 			name := []*ast.Ident{{NamePos: p.pos, Name: "type"}}
@@ -1309,10 +1206,10 @@
 				list = append(list, &ast.Field{Names: name, Type: typ})
 			}
 			p.expectSemi()
-		default:
-			break L
 		}
 	}
+	// TODO(rfindley): the error produced here could be improved, since we could
+	// accept a identifier, 'type', or a '}' at this point.
 	rbrace := p.expect(token.RBRACE)
 
 	return &ast.InterfaceType{
@@ -1325,21 +1222,21 @@
 	}
 }
 
-func (p *parser) parseMapType(typeContext bool) *ast.MapType {
+func (p *parser) parseMapType() *ast.MapType {
 	if p.trace {
 		defer un(trace(p, "MapType"))
 	}
 
 	pos := p.expect(token.MAP)
 	p.expect(token.LBRACK)
-	key := p.parseType(true)
+	key := p.parseType()
 	p.expect(token.RBRACK)
-	value := p.parseType(typeContext)
+	value := p.parseType()
 
 	return &ast.MapType{Map: pos, Key: key, Value: value}
 }
 
-func (p *parser) parseChanType(typeContext bool) *ast.ChanType {
+func (p *parser) parseChanType() *ast.ChanType {
 	if p.trace {
 		defer un(trace(p, "ChanType"))
 	}
@@ -1359,90 +1256,66 @@
 		p.expect(token.CHAN)
 		dir = ast.RECV
 	}
-	value := p.parseType(typeContext)
+	value := p.parseType()
 
 	return &ast.ChanType{Begin: pos, Arrow: arrow, Dir: dir, Value: value}
 }
 
-func (p *parser) parseTypeInstance(typ ast.Expr, opening lookAhead) ast.Expr {
+func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
 	if p.trace {
-		defer un(trace(p, "TypeInstantiation"))
+		defer un(trace(p, "TypeInstance"))
 	}
 
-	opening.consume(p)
-
-	closingTok := token.RBRACK
-	if !p.brack || opening.tok != token.LBRACK {
-		if opening.tok != token.LPAREN {
-			p.errorExpected(opening.pos, "'('")
-		}
-		closingTok = token.RPAREN
-	}
+	opening := p.expect(token.LBRACK)
 
 	p.exprLev++
 	var list []ast.Expr
-	for p.tok != closingTok && p.tok != token.EOF {
-		list = append(list, p.parseType(true))
-		if !p.atComma("type argument list", closingTok) {
+	for p.tok != token.RBRACK && p.tok != token.EOF {
+		list = append(list, p.parseType())
+		if !p.atComma("type argument list", token.RBRACK) {
 			break
 		}
 		p.next()
 	}
 	p.exprLev--
 
-	closing := p.expectClosing(closingTok, "type argument list")
+	closing := p.expectClosing(token.RBRACK, "type argument list")
 
-	return &ast.CallExpr{Fun: typ, Lparen: opening.pos, Args: list, Rparen: closing, Brackets: opening.tok == token.LBRACK}
+	return &ast.CallExpr{Fun: typ, Lparen: opening, Args: list, Rparen: closing, Brackets: true}
 }
 
 // If the result is an identifier, it is not resolved.
-// typeContext controls whether a trailing type parameter list (opening "(")
-// following a type is consumed. We need this to disambiguate an expression
-// such as []T(x) between the slice type [](T(x)) and the conversion ([]T)(x).
-// In typeContext, []T(x) is parsed as a slice type; otherwise it is parsed
-// as a conversion.
-// If we use [] for instantiation, when need this to disambiguate an expression
-// such as T[x] between the instantiated type (T[x]) and the index expression (T)(x).
-// But because an index expression requires a value and not a type before the index,
-// we can be more aggressive: whenever we are in a literal type ending in an element
-// type, we know for sure that we are in type context.
-func (p *parser) tryIdentOrType(typeContext bool) ast.Expr {
-	// When []'s are used for type instantiation, there
-	// are no ambiguities that prevent us from moving
-	// forward with instantiation when seeing a "[".
-	if p.brack {
-		typeContext = true
-	}
+func (p *parser) tryIdentOrType() ast.Expr {
 	switch p.tok {
 	case token.IDENT:
 		typ := p.parseTypeName(nil)
-		if typeContext && (p.brack && p.tok == token.LBRACK || !p.brack && p.tok == token.LPAREN) {
-			typ = p.parseTypeInstance(typ, lookAhead{})
+		if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
+			typ = p.parseTypeInstance(typ)
 		}
 		return typ
 	case token.LBRACK:
 		lbrack := p.expect(token.LBRACK)
 		alen := p.parseArrayLen()
 		p.expect(token.RBRACK)
-		elt := p.parseType(typeContext)
+		elt := p.parseType()
 		return &ast.ArrayType{Lbrack: lbrack, Len: alen, Elt: elt}
 	case token.STRUCT:
 		return p.parseStructType()
 	case token.MUL:
-		return p.parsePointerType(typeContext)
+		return p.parsePointerType()
 	case token.FUNC:
-		typ, _ := p.parseFuncType(typeContext)
+		typ, _ := p.parseFuncType()
 		return typ
 	case token.INTERFACE:
 		return p.parseInterfaceType()
 	case token.MAP:
-		return p.parseMapType(typeContext)
+		return p.parseMapType()
 	case token.CHAN, token.ARROW:
-		return p.parseChanType(typeContext)
+		return p.parseChanType()
 	case token.LPAREN:
 		lparen := p.pos
 		p.next()
-		typ := p.parseType(true)
+		typ := p.parseType()
 		rparen := p.expect(token.RPAREN)
 		return &ast.ParenExpr{Lparen: lparen, X: typ, Rparen: rparen}
 	}
@@ -1451,8 +1324,8 @@
 	return nil
 }
 
-func (p *parser) tryType(typeContext bool) ast.Expr {
-	typ := p.tryIdentOrType(typeContext)
+func (p *parser) tryType() ast.Expr {
+	typ := p.tryIdentOrType()
 	if typ != nil {
 		p.resolve(typ)
 	}
@@ -1512,7 +1385,7 @@
 		defer un(trace(p, "FuncTypeOrLit"))
 	}
 
-	typ, scope := p.parseFuncType(false)
+	typ, scope := p.parseFuncType()
 	if p.tok != token.LBRACE {
 		// function type only
 		return typ
@@ -1560,7 +1433,7 @@
 		return p.parseFuncTypeOrLit()
 	}
 
-	if typ := p.tryIdentOrType(false); typ != nil { // do not consume trailing type parameters
+	if typ := p.tryIdentOrType(); typ != nil { // do not consume trailing type parameters
 		// could be type for composite literal or conversion
 		_, isIdent := typ.(*ast.Ident)
 		assert(!isIdent, "type cannot be identifier")
@@ -1595,7 +1468,7 @@
 		// type switch: typ == nil
 		p.next()
 	} else {
-		typ = p.parseType(true)
+		typ = p.parseType()
 	}
 	rparen := p.expect(token.RPAREN)
 
@@ -1608,7 +1481,7 @@
 	}
 
 	lbrack := p.expect(token.LBRACK)
-	if p.brack && p.tok == token.RBRACK {
+	if p.tok == token.RBRACK {
 		// empty index, slice or index expressions are not permitted;
 		// accept them for parsing tolerance, but complain
 		p.errorExpected(p.pos, "operand")
@@ -1621,6 +1494,7 @@
 	var args []ast.Expr
 	var index [N]ast.Expr
 	var colons [N - 1]token.Pos
+	var firstComma token.Pos
 	if p.tok != token.COLON {
 		// We can't know if we have an index expression or a type instantiation;
 		// so even if we see a (named) type we are not going to be in type context.
@@ -1639,12 +1513,13 @@
 			}
 		}
 	case token.COMMA:
+		firstComma = p.pos
 		// instance expression
 		args = append(args, index[0])
 		for p.tok == token.COMMA {
 			p.next()
 			if p.tok != token.RBRACK && p.tok != token.EOF {
-				args = append(args, p.parseType(true))
+				args = append(args, p.parseType())
 			}
 		}
 	}
@@ -1676,57 +1551,15 @@
 		return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
 	}
 
+	if p.mode&ParseTypeParams == 0 {
+		p.error(firstComma, "expected ']' or ':', found ','")
+		return &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
+	}
+
 	// instance expression
 	return &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
 }
 
-func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "IndexOrSlice"))
-	}
-
-	const N = 3 // change the 3 to 2 to disable 3-index slices
-	lbrack := p.expect(token.LBRACK)
-	p.exprLev++
-	var index [N]ast.Expr
-	var colons [N - 1]token.Pos
-	if p.tok != token.COLON {
-		index[0] = p.parseRhs()
-	}
-	ncolons := 0
-	for p.tok == token.COLON && ncolons < len(colons) {
-		colons[ncolons] = p.pos
-		ncolons++
-		p.next()
-		if p.tok != token.COLON && p.tok != token.RBRACK && p.tok != token.EOF {
-			index[ncolons] = p.parseRhs()
-		}
-	}
-	p.exprLev--
-	rbrack := p.expect(token.RBRACK)
-
-	if ncolons > 0 {
-		// slice expression
-		slice3 := false
-		if ncolons == 2 {
-			slice3 = true
-			// Check presence of 2nd and 3rd index here rather than during type-checking
-			// to prevent erroneous programs from passing through gofmt (was issue 7305).
-			if index[1] == nil {
-				p.error(colons[0], "2nd index required in 3-index slice")
-				index[1] = &ast.BadExpr{From: colons[0] + 1, To: colons[1]}
-			}
-			if index[2] == nil {
-				p.error(colons[1], "3rd index required in 3-index slice")
-				index[2] = &ast.BadExpr{From: colons[1] + 1, To: rbrack}
-			}
-		}
-		return &ast.SliceExpr{X: x, Lbrack: lbrack, Low: index[0], High: index[1], Max: index[2], Slice3: slice3, Rbrack: rbrack}
-	}
-
-	return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
-}
-
 func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
 	if p.trace {
 		defer un(trace(p, "CallOrConversion"))
@@ -1873,28 +1706,6 @@
 	return x
 }
 
-// isTypeName reports whether x is a (qualified) TypeName.
-func isTypeName(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	default:
-		return false // all other nodes are not type names
-	}
-	return true
-}
-
-// If x is of the form *T, deref returns T, otherwise it returns x.
-func deref(x ast.Expr) ast.Expr {
-	if p, isPtr := x.(*ast.StarExpr); isPtr {
-		x = p.X
-	}
-	return x
-}
-
 // If x is of the form (T), unparen returns unparen(T), otherwise it returns x.
 func unparen(x ast.Expr) ast.Expr {
 	if p, isParen := x.(*ast.ParenExpr); isParen {
@@ -1951,11 +1762,7 @@
 			if lhs {
 				p.resolve(x)
 			}
-			if p.brack {
-				x = p.parseIndexOrSliceOrInstance(p.checkExpr(x))
-			} else {
-				x = p.parseIndexOrSlice(p.checkExpr(x))
-			}
+			x = p.parseIndexOrSliceOrInstance(p.checkExpr(x))
 		case token.LPAREN:
 			if lhs {
 				p.resolve(x)
@@ -1973,12 +1780,12 @@
 				}
 				// x is possibly a composite literal type
 			case *ast.CallExpr:
-				if p.brack != t.Brackets || p.exprLev < 0 {
+				if !t.Brackets || p.exprLev < 0 {
 					return
 				}
 				// x is possibly a composite literal type
 			case *ast.IndexExpr:
-				if !p.brack || p.exprLev < 0 {
+				if p.exprLev < 0 {
 					return
 				}
 				// x is possibly a composite literal type
@@ -2328,7 +2135,7 @@
 		// accept potential variable declaration but complain
 		if p.tok == token.VAR {
 			p.next()
-			p.error(p.pos, fmt.Sprintf("var declaration not allowed in 'IF' initializer"))
+			p.error(p.pos, "var declaration not allowed in 'IF' initializer")
 		}
 		init, _ = p.parseSimpleStmt(basic)
 	}
@@ -2410,10 +2217,10 @@
 		defer un(trace(p, "TypeList"))
 	}
 
-	list = append(list, p.parseType(true))
+	list = append(list, p.parseType())
 	for p.tok == token.COMMA {
 		p.next()
-		list = append(list, p.parseType(true))
+		list = append(list, p.parseType())
 	}
 
 	return
@@ -2809,7 +2616,7 @@
 
 	pos := p.pos
 	idents := p.parseIdentList()
-	typ := p.tryType(true)
+	typ := p.tryType()
 	var values []ast.Expr
 	// always permit optional initialization for more tolerant parsing
 	if p.tok == token.ASSIGN {
@@ -2850,16 +2657,8 @@
 }
 
 func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, closeTok token.Token) {
-	if closeTok == token.RBRACK {
-		p.brack = true // switch to using []'s instead of ()'s from now on
-	}
 	p.openScope()
-	var list []*ast.Field
-	if p.mode&UnifiedParamLists != 0 {
-		list = p.parseParameterList(p.topScope, name0, closeTok, p.parseParamDecl, true)
-	} else {
-		list = p.parseTypeParams(p.topScope, name0, closeTok)
-	}
+	list := p.parseParameterList(p.topScope, name0, closeTok, p.parseParamDecl, true)
 	closePos := p.expect(closeTok)
 	spec.TParams = &ast.FieldList{Opening: openPos, List: list, Closing: closePos}
 	// Type alias cannot have type parameters. Accept them for robustness but complain.
@@ -2867,7 +2666,7 @@
 		p.error(p.pos, "generic type cannot be alias")
 		p.next()
 	}
-	spec.Type = p.parseType(true)
+	spec.Type = p.parseType()
 	p.closeScope()
 }
 
@@ -2889,80 +2688,27 @@
 	case token.LBRACK:
 		lbrack := p.pos
 		p.next()
-		if p.mode&UnifiedParamLists != 0 {
-			if p.tok == token.IDENT {
-				// array type or generic type [T any]
-				p.exprLev++
-				x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
-				p.exprLev--
-				if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.RBRACK {
-					// generic type [T any];
-					p.parseGenericType(spec, lbrack, name0, token.RBRACK)
-				} else {
-					// array type
-					// TODO(gri) should resolve all identifiers in x (doesn't matter for this prototype)
-					p.expect(token.RBRACK)
-					elt := p.parseType(true)
-					spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: x, Elt: elt}
-				}
+		if p.tok == token.IDENT {
+			// array type or generic type [T any]
+			p.exprLev++
+			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
+			p.exprLev--
+			if name0, _ := x.(*ast.Ident); p.mode&ParseTypeParams != 0 && name0 != nil && p.tok != token.RBRACK {
+				// generic type [T any];
+				p.parseGenericType(spec, lbrack, name0, token.RBRACK)
 			} else {
 				// array type
-				alen := p.parseArrayLen()
+				// TODO(rfindley) should resolve all identifiers in x.
 				p.expect(token.RBRACK)
-				elt := p.parseType(true)
-				spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: alen, Elt: elt}
+				elt := p.parseType()
+				spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: x, Elt: elt}
 			}
 		} else {
-			switch p.tok {
-			case token.TYPE:
-				// generic type
-				p.next()
-				p.parseGenericType(spec, lbrack, nil, token.RBRACK)
-			case token.IDENT:
-				// array type or generic type without "type" keyword
-				p.exprLev++
-				x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
-				p.exprLev--
-				if name0, _ := x.(*ast.Ident); name0 != nil {
-					// array type or generic type without "type" keyword;
-					// assume a generic type and then decide based on next token and use of name0
-					next := p.tok
-					pbrack := p.brack // changed by parseGenericType; restore if we have an array type
-					p.parseGenericType(spec, lbrack, name0, token.RBRACK)
-					if next == token.RBRACK && !usesName(spec.Type, name0.Name) {
-						// assume array type
-						p.brack = pbrack
-						spec.TParams = nil
-						spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: x, Elt: spec.Type}
-					}
-				} else {
-					// array type
-					// TODO(gri) should resolve all identifiers in x (doesn't matter for this prototype)
-					p.expect(token.RBRACK)
-					elt := p.parseType(true)
-					spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: x, Elt: elt}
-				}
-			default:
-				// array type
-				alen := p.parseArrayLen()
-				p.expect(token.RBRACK)
-				elt := p.parseType(true)
-				spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: alen, Elt: elt}
-			}
-		}
-
-	case token.LPAREN:
-		lparen := p.pos
-		p.next()
-		if !p.brack && p.tok == token.TYPE {
-			// generic type
-			p.next()
-			p.parseGenericType(spec, lparen, nil, token.RPAREN)
-		} else {
-			// parenthesized type
-			typ := p.parseType(true)
-			rparen := p.expect(token.RPAREN)
-			spec.Type = &ast.ParenExpr{Lparen: lparen, X: typ, Rparen: rparen}
+			// array type
+			alen := p.parseArrayLen()
+			p.expect(token.RBRACK)
+			elt := p.parseType()
+			spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: alen, Elt: elt}
 		}
 
 	default:
@@ -2972,7 +2718,7 @@
 			spec.Assign = p.pos
 			p.next()
 		}
-		spec.Type = p.parseType(true)
+		spec.Type = p.parseType()
 	}
 
 	p.expectSemi() // call before accessing p.linecomment
@@ -2981,27 +2727,6 @@
 	return spec
 }
 
-// uses reports whether name appears anywhere in x except as array length.
-func usesName(x ast.Expr, name string) (used bool) {
-	ast.Inspect(x, func(n ast.Node) bool {
-		switch n := n.(type) {
-		case *ast.Ident:
-			if n.Name == name {
-				used = true
-			}
-			return false
-		case *ast.ArrayType:
-			// ignore n.Len (and for slices, n.Len == nil)
-			if usesName(n.Elt, name) {
-				used = true
-			}
-			return false
-		}
-		return true
-	})
-	return
-}
-
 func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.GenDecl {
 	if p.trace {
 		defer un(trace(p, "GenDecl("+keyword.String()+")"))
@@ -3044,13 +2769,13 @@
 
 	var recv *ast.FieldList
 	if p.tok == token.LPAREN {
-		_, recv = p.parseParameters(scope, lookAhead{}, false)
+		_, recv = p.parseParameters(scope, false)
 	}
 
 	ident := p.parseIdent()
 
-	tparams, params := p.parseParameters(scope, lookAhead{}, true)
-	results := p.parseResult(scope, true)
+	tparams, params := p.parseParameters(scope, true)
+	results := p.parseResult(scope)
 
 	var body *ast.BlockStmt
 	if p.tok == token.LBRACE {
@@ -3185,14 +2910,13 @@
 	}
 
 	return &ast.File{
-		Doc:         doc,
-		Package:     pos,
-		Name:        ident,
-		Decls:       decls,
-		Scope:       p.pkgScope,
-		Imports:     p.imports,
-		Unresolved:  p.unresolved[0:i],
-		Comments:    p.comments,
-		UseBrackets: p.brack,
+		Doc:        doc,
+		Package:    pos,
+		Name:       ident,
+		Decls:      decls,
+		Scope:      p.pkgScope,
+		Imports:    p.imports,
+		Unresolved: p.unresolved[0:i],
+		Comments:   p.comments,
 	}
 }
diff --git a/src/go/parser/parser_test.go b/src/go/parser/parser_test.go
index 25a374e..e204854 100644
--- a/src/go/parser/parser_test.go
+++ b/src/go/parser/parser_test.go
@@ -82,6 +82,14 @@
 	}
 }
 
+func TestIssue42951(t *testing.T) {
+	path := "./testdata/issue42951"
+	_, err := ParseDir(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Errorf("ParseDir(%s): %v", path, err)
+	}
+}
+
 func TestParseExpr(t *testing.T) {
 	// just kicking the tires:
 	// a valid arithmetic expression
diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go
index bc7caa2..3676c27 100644
--- a/src/go/parser/short_test.go
+++ b/src/go/parser/short_test.go
@@ -49,168 +49,100 @@
 	`package p; type T = int`,
 	`package p; type (T = p.T; _ = struct{}; x = *T)`,
 	`package p; type T (*int)`,
-
-	// structs with parameterized embedded fields (for symmetry with interfaces)
 	`package p; type _ struct{ ((int)) }`,
 	`package p; type _ struct{ (*(int)) }`,
 	`package p; type _ struct{ ([]byte) }`, // disallowed by type-checker
-
-	// type parameters
-	`package p; type T(type P) struct { P }`,
-	`package p; type T(type P comparable) struct { P }`,
-	`package p; type T(type P comparable(P)) struct { P }`,
-	`package p; type T(type P1, P2) struct { P1; f []P2 }`,
-	`package p; type _ []T(int)`,
-
-	`package p; type T[type P] struct { P }`,
-	`package p; type T[type P comparable] struct { P }`,
-	`package p; type T[type P comparable[P]] struct { P }`,
-	`package p; type T[type P1, P2] struct { P1; f []P2 }`,
-	`package p; type _[type] int; type _ []T[int]`,
-
 	`package p; var _ = func()T(nil)`,
-	`package p; func _(type)()`,
-	`package p; func _(type)()()`,
 	`package p; func _(T (P))`,
 	`package p; func _(T []E)`,
 	`package p; func _(T [P]E)`,
-	`package p; func _(x T(P1, P2, P3))`,
-	`package p; func _(x p.T(Q))`,
-	`package p; func _(p.T(Q))`,
-
-	`package p; var _ = func()T(nil)`,
-	`package p; func _[type]()`,
-	`package p; func _[type]()()`,
-	`package p; func _(T (P))`,
-	`package p; func _[type](); func _(T []E)`,
-	`package p; func _[type](); func _(T [P]E)`,
-	`package p; func _[type](); func _(x T[P1, P2, P3])`,
-	`package p; func _[type](); func _(x p.T[Q])`,
-	`package p; func _[type](); func _(p.T[Q])`,
-
-	`package p; type _[type] int; var _ T[chan int]`,
-	`package p; func f[A, B](); func _() { _ = f[int, int] }`,
-
-	// optional "type" keyword for generic types using square brackets
-	`package p; type _[A interface{},] struct{}`,
-	`package p; type _[A interface{}] struct{}`,
-	`package p; type _[A, B,] struct{}`,
-	`package p; type _[A, B] struct{}`,
-	`package p; type _[A,] struct{}`,
-	`package p; type _ [A+B]struct{}`, // this is an array!
-
-	`package p; type _[A]struct{}`,     // this is an array
-	`package p; type _[A] struct{ A }`, // this is not an array!
-
-	// optional "type" keyword for generic functions using square brackets
-	`package p; func _[]()`,
-	`package p; func _[T]()`,
-	`package p; func _[T](x T)`,
-	`package p; func _[T1, T2](x T)`,
-
-	`package p; func _[](); func (R) _[]()`,
-	`package p; func _[](); func (R[P]) _[T]()`,
-	`package p; func _[](); func (_ R[P]) _[T](x T)`,
-	`package p; func _[](); func (_ R[P, Q]) _[T1, T2](x T)`,
-
-	// need for parentheses to disambiguate
-	`package p; var _ = [](T(int)){}`,
-	`package p; var _ = [10](T(int)){}`,
-	`package p; var _ = func()(T(int)){}`,
-	`package p; var _ = map[T(int)](T(int)){}`,
-	`package p; var _ = chan (T(int))(x)`,
-	`package p; func _((T(P)))`,
-	`package p; func _((T(P1, P2, P3)))`,
-
-	`package p; func _(type *P)()`,
-	`package p; func _(type *P B)()`,
-	`package p; func _(type P, *Q interface{})()`,
-
-	`package p; func _((T(P))) T(P)`,
-	`package p; func _(_ T(P), T (P)) T(P)`,
-
-	// no need for parentheses to disambiguate
-	`package p; type _[type] int; var _ = []T[int]{}`,
-	`package p; type _[type] int; var _ = [10]T[int]{}`,
-	`package p; type _[type] int; var _ = func()T[int]{}`,
-	`package p; type _[type] int; var _ = map[T[int]]T[int]{}`,
-	`package p; type _[type] int; var _ = chan T[int](x)`,
-	`package p; type _[type] int; func _(T[P])`,
-	`package p; type _[type] int; func _(T[P1, P2, P3])`,
-
-	`package p; type _[type] int; func _[type *P]()`,
-	`package p; type _[type] int; func _[type *P B]()`,
-	`package p; type _[type] int; func _[type P, *Q interface{}]()`,
-
-	`package p; type _[type] int; func _(T[P]) T[P]`,
-	`package p; type _[type] int; func _(_ T[P], T (P)) T[P]`,
-
-	// method type parameters (if methodTypeParamsOk)
-	`package p; func _(type A, B)(a A) B`,
-	`package p; func _(type A, B C)(a A) B`,
-	`package p; func _(type A, B C(A, B))(a A) B`,
-	`package p; func (T) _(type A, B)(a A) B`,
-	`package p; func (T) _(type A, B C)(a A) B`,
-	`package p; func (T) _(type A, B C(A, B))(a A) B`,
-	`package p; type _ interface { _(type A, B)(a A) B }`,
-	`package p; type _ interface { _(type A, B C)(a A) B }`,
-	`package p; type _ interface { _(type A, B C(A, B))(a A) B }`,
-
-	`package p; type _[type] int; func _[type A, B](a A) B`,
-	`package p; type _[type] int; func _[type A, B C](a A) B`,
-	`package p; type _[type] int; func _[type A, B C[A, B]](a A) B`,
-	`package p; type _[type] int; func (T) _[type A, B](a A) B`,
-	`package p; type _[type] int; func (T) _[type A, B C](a A) B`,
-	`package p; type _[type] int; func (T) _[type A, B C[A, B]](a A) B`,
-	`package p; type _[type] int; type _ interface { _[type A, B](a A) B }`,
-	`package p; type _[type] int; type _ interface { _[type A, B C](a A) B }`,
-	`package p; type _[type] int; type _ interface { _[type A, B C[A, B]](a A) B }`,
-
-	// type bounds
-	`package p; func _(type T1, T2 interface{})(x T1) T2`,
-	`package p; func _(type T1 interface{ m() }, T2, T3 interface{})(x T1, y T3) T2`,
-
-	`package p; type _[type] int; func _[type T1, T2 interface{}](x T1) T2`,
-	`package p; type _[type] int; func _[type T1 interface{ m() }, T2, T3 interface{}](x T1, y T3) T2`,
-
-	// embedded types
-	`package p; type _ struct{ (T(P)) }`,
-	`package p; type _ struct{ (T(struct{a, b, c int})) }`,
+	`package p; type _ [A+B]struct{}`,
+	`package p; func (R) _()`,
 	`package p; type _ struct{ f [n]E }`,
 	`package p; type _ struct{ f [a+b+c+d]E }`,
+	`package p; type I1 interface{}; type I2 interface{ I1 }`,
+}
 
-	`package p; type _[type] int; type _ struct{ T[P] }`,
-	`package p; type _[type] int; type _ struct{ T[struct{a, b, c int}] }`,
-	`package p; type _[type] int; type _ struct{ f [n]E }`,
-	`package p; type _[type] int; type _ struct{ f [a+b+c+d]E }`,
+// validWithTParamsOnly holds source code examples that are valid if
+// ParseTypeParams is set, but invalid if not. When checking with the
+// ParseTypeParams set, errors are ignored.
+var validWithTParamsOnly = []string{
+	`package p; type _ []T[ /* ERROR "expected ';', found '\['" */ int]`,
+	`package p; type T[P any /* ERROR "expected ']', found any" */ ] struct { P }`,
+	`package p; type T[P comparable /* ERROR "expected ']', found comparable" */ ] struct { P }`,
+	`package p; type T[P comparable /* ERROR "expected ']', found comparable" */ [P]] struct { P }`,
+	`package p; type T[P1, /* ERROR "expected ']', found ','" */ P2 any] struct { P1; f []P2 }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T any]()()`,
+	`package p; func _(T (P))`,
+	`package p; func f[ /* ERROR "expected '\(', found '\['" */ A, B any](); func _() { _ = f[int, int] }`,
+	`package p; func _(x /* ERROR "mixed named and unnamed parameters" */ T[P1, P2, P3])`,
+	`package p; func _(x /* ERROR "mixed named and unnamed parameters" */ p.T[Q])`,
+	`package p; func _(p.T[ /* ERROR "missing ',' in parameter list" */ Q])`,
+	`package p; type _[A interface /* ERROR "expected ']', found 'interface'" */ {},] struct{}`,
+	`package p; type _[A interface /* ERROR "expected ']', found 'interface'" */ {}] struct{}`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */  B any,] struct{}`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */ B any] struct{}`,
+	`package p; type _[A any /* ERROR "expected ']', found any" */,] struct{}`,
+	`package p; type _[A any /* ERROR "expected ']', found any" */ ]struct{}`,
+	`package p; type _[A any /* ERROR "expected ']', found any" */ ] struct{ A }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T any]()`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T any](x T)`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T1, T2 any](x T)`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ A, B any](a A) B`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ A, B C](a A) B`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ A, B C[A, B]](a A) B`,
+	`package p; func (T) _[ /* ERROR "expected '\(', found '\['" */ A, B any](a A) B`,
+	`package p; func (T) _[ /* ERROR "expected '\(', found '\['" */ A, B C](a A) B`,
+	`package p; func (T) _[ /* ERROR "expected '\(', found '\['" */ A, B C[A, B]](a A) B`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */ B any] interface { _(a A) B }`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */ B C[A, B]] interface { _(a A) B }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T1, T2 interface{}](x T1) T2`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T1 interface{ m() }, T2, T3 interface{}](x T1, y T3) T2`,
+	`package p; var _ = [ /* ERROR "expected expression" */ ]T[int]{}`,
+	`package p; var _ = [ /* ERROR "expected expression" */ 10]T[int]{}`,
+	`package p; var _ = func /* ERROR "expected expression" */ ()T[int]{}`,
+	`package p; var _ = map /* ERROR "expected expression" */ [T[int]]T[int]{}`,
+	`package p; var _ = chan /* ERROR "expected expression" */ T[int](x)`,
+	`package p; func _(_ T[ /* ERROR "missing ',' in parameter list" */ P], T P) T[P]`,
+	`package p; var _ T[ /* ERROR "expected ';', found '\['" */ chan int]`,
 
-	// interfaces with type lists
-	`package p; type _ interface{type int}`,
-	`package p; type _ interface{type int, float32; type bool; m(); type string;}`,
+	// TODO(rfindley) this error message could be improved.
+	`package p; func (_ /* ERROR "mixed named and unnamed parameters" */ R[P]) _[T any](x T)`,
+	`package p; func (_ /* ERROR "mixed named and unnamed parameters" */ R[ P, Q]) _[T1, T2 any](x T)`,
 
-	`package p; type _[type] int; type _ interface{type int}`,
-	`package p; type _[type] int; type _ interface{type int, float32; type bool; m(); type string;}`,
-
-	// interfaces with parenthesized embedded and possibly parameterized interfaces
-	`package p; type I1 interface{}; type I2 interface{ (I1) }`,
-	`package p; type I1(type T) interface{}; type I2 interface{ (I1(int)) }`,
-	`package p; type I1(type T) interface{}; type I2(type T) interface{ (I1(T)) }`,
-
-	`package p; type _[type] int; type I1 interface{}; type I2 interface{ (I1) }`,
-	`package p; type I1[type T] interface{}; type I2 interface{ I1[int] }`,
-	`package p; type I1[type T] interface{}; type I2[type T] interface{ I1[T] }`,
+	`package p; func (R[P] /* ERROR "missing element type" */ ) _[T any]()`,
+	`package p; func _(T[P] /* ERROR "missing element type" */ )`,
+	`package p; func _(T[P1, /* ERROR "expected ']', found ','" */ P2, P3 ])`,
+	`package p; func _(T[P] /* ERROR "missing element type" */ ) T[P]`,
+	`package p; type _ struct{ T[P] /* ERROR "missing element type" */ }`,
+	`package p; type _ struct{ T[struct /* ERROR "expected expression" */ {a, b, c int}] }`,
+	`package p; type _ interface{type /* ERROR "expected '}', found 'type'" */ int}`,
+	`package p; type _ interface{type /* ERROR "expected '}', found 'type'" */ int, float32; type bool; m(); type string;}`,
+	`package p; type I1[T any /* ERROR "expected ']', found any" */ ] interface{}; type I2 interface{ I1[int] }`,
+	`package p; type I1[T any /* ERROR "expected ']', found any" */ ] interface{}; type I2[T any] interface{ I1[T] }`,
+	`package p; type _ interface { f[ /* ERROR "expected ';', found '\['" */ T any]() }`,
 }
 
 func TestValid(t *testing.T) {
-	for _, src := range valids {
-		checkErrors(t, src, src)
-	}
+	t.Run("no tparams", func(t *testing.T) {
+		for _, src := range valids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, false)
+		}
+	})
+	t.Run("tparams", func(t *testing.T) {
+		for _, src := range valids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, false)
+		}
+		for _, src := range validWithTParamsOnly {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, false)
+		}
+	})
 }
 
 // TestSingle is useful to track down a problem with a single short test program.
 func TestSingle(t *testing.T) {
-	const src = `package p; var _ = T(P){}`
-	checkErrors(t, src, src)
+	const src = `package p; var _ = T[P]{}`
+	checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
 }
 
 var invalids = []string{
@@ -236,7 +168,6 @@
 	`package p; var a = chan /* ERROR "expected expression" */ int;`,
 	`package p; var a = []int{[ /* ERROR "expected expression" */ ]int};`,
 	`package p; var a = ( /* ERROR "expected expression" */ []int);`,
-	`package p; var a = a[[ /* ERROR "expected expression" */ ]int:[]int];`,
 	`package p; var a = <- /* ERROR "expected expression" */ chan int;`,
 	`package p; func f() { select { case _ <- chan /* ERROR "expected expression" */ int: } };`,
 	`package p; func f() { _ = (<-<- /* ERROR "expected 'chan'" */ chan int)(nil) };`,
@@ -259,15 +190,14 @@
 	`package p; func f() { go f /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { defer func() {} /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { go func() { func() { f(x func /* ERROR "missing ','" */ (){}) } } }`,
-	//`package p; func f(x func(), u v func /* ERROR "missing ','" */ ()){}`,
-
-	// type parameters
-	`package p; var _ func( /* ERROR "cannot have type parameters" */ type T)(T)`,
 	`package p; func _() (type /* ERROR "found 'type'" */ T)(T)`,
 	`package p; func (type /* ERROR "found 'type'" */ T)(T) _()`,
 	`package p; type _[A+B, /* ERROR "expected ']'" */ ] int`,
-	`package p; type _[type _] int; var _ = T[] /* ERROR "expected operand" */ {}`,
-	`package p; type T[P any] = /* ERROR "cannot be alias" */ T0`,
+
+	// TODO: this error should be positioned on the ':'
+	`package p; var a = a[[]int:[ /* ERROR "expected expression" */ ]int];`,
+	// TODO: the compiler error is better here: "cannot parenthesize embedded type"
+	`package p; type I1 interface{}; type I2 interface{ (/* ERROR "expected '}', found '\('" */ I1) }`,
 
 	// issue 8656
 	`package p; func f() (a b string /* ERROR "missing ','" */ , ok bool)`,
@@ -285,17 +215,56 @@
 	// issue 11611
 	`package p; type _ struct { int, } /* ERROR "expected 'IDENT', found '}'" */ ;`,
 	`package p; type _ struct { int, float } /* ERROR "expected type, found '}'" */ ;`,
-	//`package p; type _ struct { ( /* ERROR "cannot parenthesize embedded type" */ int) };`,
-	//`package p; func _()(x, y, z ... /* ERROR "expected '\)', found '...'" */ int){}`,
-	//`package p; func _()(... /* ERROR "expected type, found '...'" */ int){}`,
 
 	// issue 13475
 	`package p; func f() { if true {} else ; /* ERROR "expected if statement or block" */ }`,
 	`package p; func f() { if true {} else defer /* ERROR "expected if statement or block" */ f() }`,
 }
 
+// invalidNoTParamErrs holds invalid source code examples annotated with the
+// error messages produced when ParseTypeParams is not set.
+var invalidNoTParamErrs = []string{
+	`package p; type _[_ any /* ERROR "expected ']', found any" */ ] int; var _ = T[]{}`,
+	`package p; type T[P any /* ERROR "expected ']', found any" */ ] = T0`,
+	`package p; var _ func[ /* ERROR "expected '\(', found '\['" */ T any](T)`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ ]()`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */] struct{ A }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ type P, *Q interface{}]()`,
+}
+
+// invalidTParamErrs holds invalid source code examples annotated with the
+// error messages produced when ParseTypeParams is set.
+var invalidTParamErrs = []string{
+	`package p; type _[_ any] int; var _ = T[] /* ERROR "expected operand" */ {}`,
+	`package p; type T[P any] = /* ERROR "cannot be alias" */ T0`,
+	`package p; var _ func[ /* ERROR "cannot have type parameters" */ T any](T)`,
+	`package p; func _[]/* ERROR "empty type parameter list" */()`,
+
+	// TODO(rfindley) a better location would be after the ']'
+	`package p; type _[A/* ERROR "all type parameters must be named" */,] struct{ A }`,
+
+	// TODO(rfindley) this error is confusing.
+	`package p; func _[type /* ERROR "all type parameters must be named" */P, *Q interface{}]()`,
+}
+
 func TestInvalid(t *testing.T) {
-	for _, src := range invalids {
-		checkErrors(t, src, src)
-	}
+	t.Run("no tparams", func(t *testing.T) {
+		for _, src := range invalids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+		}
+		for _, src := range validWithTParamsOnly {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+		}
+		for _, src := range invalidNoTParamErrs {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+		}
+	})
+	t.Run("tparams", func(t *testing.T) {
+		for _, src := range invalids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+		}
+		for _, src := range invalidTParamErrs {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+		}
+	})
 }
diff --git a/src/go/parser/testdata/chans.go2 b/src/go/parser/testdata/chans.go2
index d6ca4df..fad2bce 100644
--- a/src/go/parser/testdata/chans.go2
+++ b/src/go/parser/testdata/chans.go2
@@ -10,24 +10,24 @@
 //
 // This is a convenient way to exit a goroutine sending values when
 // the receiver stops reading them.
-func Ranger(type T)() (*Sender(T), *Receiver(T)) {
+func Ranger[T any]() (*Sender[T], *Receiver[T]) {
 	c := make(chan T)
 	d := make(chan bool)
-	s := &Sender(T){values: c, done: d}
-	r := &Receiver(T){values: c, done: d}
+	s := &Sender[T]{values: c, done: d}
+	r := &Receiver[T]{values: c, done: d}
 	runtime.SetFinalizer(r, r.finalize)
 	return s, r
 }
 
 // A sender is used to send values to a Receiver.
-type Sender(type T) struct {
+type Sender[T any] struct {
 	values chan<- T
 	done <-chan bool
 }
 
 // Send sends a value to the receiver. It returns whether any more
 // values may be sent; if it returns false the value was not sent.
-func (s *Sender(T)) Send(v T) bool {
+func (s *Sender[T]) Send(v T) bool {
 	select {
 	case s.values <- v:
 		return true
@@ -38,12 +38,12 @@
 
 // Close tells the receiver that no more values will arrive.
 // After Close is called, the Sender may no longer be used.
-func (s *Sender(T)) Close() {
+func (s *Sender[T]) Close() {
 	close(s.values)
 }
 
 // A Receiver receives values from a Sender.
-type Receiver(type T) struct {
+type Receiver[T any] struct {
 	values <-chan T
 	done chan<- bool
 }
@@ -51,12 +51,12 @@
 // Next returns the next value from the channel. The bool result
 // indicates whether the value is valid, or whether the Sender has
 // been closed and no more values will be received.
-func (r *Receiver(T)) Next() (T, bool) {
+func (r *Receiver[T]) Next() (T, bool) {
 	v, ok := <-r.values
 	return v, ok
 }
 
 // finalize is a finalizer for the receiver.
-func (r *Receiver(T)) finalize() {
+func (r *Receiver[T]) finalize() {
 	close(r.done)
 }
diff --git a/src/go/parser/testdata/chansB.go2 b/src/go/parser/testdata/chansB.go2
deleted file mode 100644
index d2ee3a3..0000000
--- a/src/go/parser/testdata/chansB.go2
+++ /dev/null
@@ -1,62 +0,0 @@
-package chans
-
-import "runtime"
-
-// Ranger returns a Sender and a Receiver. The Receiver provides a
-// Next method to retrieve values. The Sender provides a Send method
-// to send values and a Close method to stop sending values. The Next
-// method indicates when the Sender has been closed, and the Send
-// method indicates when the Receiver has been freed.
-//
-// This is a convenient way to exit a goroutine sending values when
-// the receiver stops reading them.
-func Ranger[type T]() (*Sender[T], *Receiver[T]) {
-	c := make(chan T)
-	d := make(chan bool)
-	s := &Sender[T]{values: c, done: d}
-	r := &Receiver[T]{values: c, done: d}
-	runtime.SetFinalizer(r, r.finalize)
-	return s, r
-}
-
-// A sender is used to send values to a Receiver.
-type Sender[type T] struct {
-	values chan<- T
-	done <-chan bool
-}
-
-// Send sends a value to the receiver. It returns whether any more
-// values may be sent; if it returns false the value was not sent.
-func (s *Sender[T]) Send(v T) bool {
-	select {
-	case s.values <- v:
-		return true
-	case <-s.done:
-		return false
-	}
-}
-
-// Close tells the receiver that no more values will arrive.
-// After Close is called, the Sender may no longer be used.
-func (s *Sender[T]) Close() {
-	close(s.values)
-}
-
-// A Receiver receives values from a Sender.
-type Receiver[type T] struct {
-	values <-chan T
-	done chan<- bool
-}
-
-// Next returns the next value from the channel. The bool result
-// indicates whether the value is valid, or whether the Sender has
-// been closed and no more values will be received.
-func (r *Receiver[T]) Next() (T, bool) {
-	v, ok := <-r.values
-	return v, ok
-}
-
-// finalize is a finalizer for the receiver.
-func (r *Receiver[T]) finalize() {
-	close(r.done)
-}
diff --git a/src/go/parser/testdata/issue42951/not_a_file.go/invalid.go b/src/go/parser/testdata/issue42951/not_a_file.go/invalid.go
new file mode 100644
index 0000000..bb698be
--- /dev/null
+++ b/src/go/parser/testdata/issue42951/not_a_file.go/invalid.go
@@ -0,0 +1 @@
+This file should not be parsed by ParseDir.
diff --git a/src/go/parser/testdata/linalg.go2 b/src/go/parser/testdata/linalg.go2
index 5fbd22f..fba0d02 100644
--- a/src/go/parser/testdata/linalg.go2
+++ b/src/go/parser/testdata/linalg.go2
@@ -15,7 +15,7 @@
 		complex64, complex128
 }
 
-func DotProduct(type T Numeric)(s1, s2 []T) T {
+func DotProduct[T Numeric](s1, s2 []T) T {
 	if len(s1) != len(s2) {
 		panic("DotProduct: slices of unequal length")
 	}
@@ -27,7 +27,7 @@
 }
 
 // NumericAbs matches numeric types with an Abs method.
-type NumericAbs(type T) interface {
+type NumericAbs[T any] interface {
 	Numeric
 
 	Abs() T
@@ -35,7 +35,7 @@
 
 // AbsDifference computes the absolute value of the difference of
 // a and b, where the absolute value is determined by the Abs method.
-func AbsDifference(type T NumericAbs)(a, b T) T {
+func AbsDifference[T NumericAbs](a, b T) T {
 	d := a - b
 	return d.Abs()
 }
@@ -54,9 +54,9 @@
 
 // OrderedAbs is a helper type that defines an Abs method for
 // ordered numeric types.
-type OrderedAbs(type T OrderedNumeric) T
+type OrderedAbs[T OrderedNumeric] T
 
-func (a OrderedAbs(T)) Abs() OrderedAbs(T) {
+func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
 	if a < 0 {
 		return -a
 	}
@@ -65,19 +65,19 @@
 
 // ComplexAbs is a helper type that defines an Abs method for
 // complex types.
-type ComplexAbs(type T Complex) T
+type ComplexAbs[T Complex] T
 
-func (a ComplexAbs(T)) Abs() ComplexAbs(T) {
+func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
 	r := float64(real(a))
 	i := float64(imag(a))
 	d := math.Sqrt(r * r + i * i)
-	return ComplexAbs(T)(complex(d, 0))
+	return ComplexAbs[T](complex(d, 0))
 }
 
-func OrderedAbsDifference(type T OrderedNumeric)(a, b T) T {
-	return T(AbsDifference(OrderedAbs(T)(a), OrderedAbs(T)(b)))
+func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
 }
 
-func ComplexAbsDifference(type T Complex)(a, b T) T {
-	return T(AbsDifference(ComplexAbs(T)(a), ComplexAbs(T)(b)))
+func ComplexAbsDifference[T Complex](a, b T) T {
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
 }
diff --git a/src/go/parser/testdata/linalgB.go2 b/src/go/parser/testdata/linalgB.go2
deleted file mode 100644
index a72f7be..0000000
--- a/src/go/parser/testdata/linalgB.go2
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package linalg
-
-import "math"
-
-// Numeric is type bound that matches any numeric type.
-// It would likely be in a constraints package in the standard library.
-type Numeric interface {
-	type int, int8, int16, int32, int64,
-		uint, uint8, uint16, uint32, uint64, uintptr,
-		float32, float64,
-		complex64, complex128
-}
-
-func DotProduct[type T Numeric](s1, s2 []T) T {
-	if len(s1) != len(s2) {
-		panic("DotProduct: slices of unequal length")
-	}
-	var r T
-	for i := range s1 {
-		r += s1[i] * s2[i]
-	}
-	return r
-}
-
-// NumericAbs matches numeric types with an Abs method.
-type NumericAbs[type T] interface {
-	Numeric
-
-	Abs() T
-}
-
-// AbsDifference computes the absolute value of the difference of
-// a and b, where the absolute value is determined by the Abs method.
-func AbsDifference[type T NumericAbs](a, b T) T {
-	d := a - b
-	return d.Abs()
-}
-
-// OrderedNumeric is a type bound that matches numeric types that support the < operator.
-type OrderedNumeric interface {
-	type int, int8, int16, int32, int64,
-		uint, uint8, uint16, uint32, uint64, uintptr,
-		float32, float64
-}
-
-// Complex is a type bound that matches the two complex types, which do not have a < operator.
-type Complex interface {
-	type complex64, complex128
-}
-
-// OrderedAbs is a helper type that defines an Abs method for
-// ordered numeric types.
-type OrderedAbs[type T OrderedNumeric] T
-
-func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
-	if a < 0 {
-		return -a
-	}
-	return a
-}
-
-// ComplexAbs is a helper type that defines an Abs method for
-// complex types.
-type ComplexAbs[type T Complex] T
-
-func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
-	r := float64(real(a))
-	i := float64(imag(a))
-	d := math.Sqrt(r * r + i * i)
-	return ComplexAbs[T](complex(d, 0))
-}
-
-func OrderedAbsDifference[type T OrderedNumeric](a, b T) T {
-	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
-}
-
-func ComplexAbsDifference[type T Complex](a, b T) T {
-	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
-}
diff --git a/src/go/parser/testdata/map.go2 b/src/go/parser/testdata/map.go2
index 8b0cdaa..74c79ae 100644
--- a/src/go/parser/testdata/map.go2
+++ b/src/go/parser/testdata/map.go2
@@ -4,27 +4,27 @@
 import "chans"
 
 // Map is an ordered map.
-type Map(type K, V) struct {
-	root    *node(K, V)
+type Map[K, V any] struct {
+	root    *node[K, V]
 	compare func(K, K) int
 }
 
 // node is the type of a node in the binary tree.
-type node(type K, V) struct {
+type node[K, V any] struct {
 	key         K
 	val         V
-	left, right *node(K, V)
+	left, right *node[K, V]
 }
 
 // New returns a new map.
-func New(type K, V)(compare func(K, K) int) *Map(K, V) {
-        return &Map(K, V){compare: compare}
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
 }
 
 // find looks up key in the map, and returns either a pointer
 // to the node holding key, or a pointer to the location where
 // such a node would go.
-func (m *Map(K, V)) find(key K) **node(K, V) {
+func (m *Map[K, V]) find(key K) **node[K, V] {
 	pn := &m.root
 	for *pn != nil {
 		switch cmp := m.compare(key, (*pn).key); {
@@ -42,19 +42,19 @@
 // Insert inserts a new key/value into the map.
 // If the key is already present, the value is replaced.
 // Returns true if this is a new key, false if already present.
-func (m *Map(K, V)) Insert(key K, val V) bool {
+func (m *Map[K, V]) Insert(key K, val V) bool {
 	pn := m.find(key)
 	if *pn != nil {
 		(*pn).val = val
 		return false
 	}
-        *pn = &node(K, V){key: key, val: val}
+        *pn = &node[K, V]{key: key, val: val}
 	return true
 }
 
 // Find returns the value associated with a key, or zero if not present.
 // The found result reports whether the key was found.
-func (m *Map(K, V)) Find(key K) (V, bool) {
+func (m *Map[K, V]) Find(key K) (V, bool) {
 	pn := m.find(key)
 	if *pn == nil {
 		var zero V // see the discussion of zero values, above
@@ -64,16 +64,16 @@
 }
 
 // keyValue is a pair of key and value used when iterating.
-type keyValue(type K, V) struct {
+type keyValue[K, V any] struct {
 	key K
 	val V
 }
 
 // InOrder returns an iterator that does an in-order traversal of the map.
-func (m *Map(K, V)) InOrder() *Iterator(K, V) {
-	sender, receiver := chans.Ranger(keyValue(K, V))()
-	var f func(*node(K, V)) bool
-	f = func(n *node(K, V)) bool {
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans.Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
 		if n == nil {
 			return true
 		}
@@ -81,7 +81,7 @@
 		// meaning that nothing is listening at the receiver end.
 		return f(n.left) &&
                         // TODO
-			// sender.Send(keyValue(K, V){n.key, n.val}) &&
+			// sender.Send(keyValue[K, V]{n.key, n.val}) &&
 			f(n.right)
 	}
 	go func() {
@@ -92,13 +92,13 @@
 }
 
 // Iterator is used to iterate over the map.
-type Iterator(type K, V) struct {
-	r *chans.Receiver(keyValue(K, V))
+type Iterator[K, V any] struct {
+	r *chans.Receiver[keyValue[K, V]]
 }
 
 // Next returns the next key and value pair, and a boolean indicating
 // whether they are valid or whether we have reached the end.
-func (it *Iterator(K, V)) Next() (K, V, bool) {
+func (it *Iterator[K, V]) Next() (K, V, bool) {
 	keyval, ok := it.r.Next()
 	if !ok {
 		var zerok K
diff --git a/src/go/parser/testdata/mapB.go2 b/src/go/parser/testdata/mapB.go2
deleted file mode 100644
index 0be5b28..0000000
--- a/src/go/parser/testdata/mapB.go2
+++ /dev/null
@@ -1,109 +0,0 @@
-// Package orderedmap provides an ordered map, implemented as a binary tree.
-package orderedmap
-
-import "chans"
-
-// Map is an ordered map.
-type Map[type K, V] struct {
-	root    *node[K, V]
-	compare func(K, K) int
-}
-
-// node is the type of a node in the binary tree.
-type node[type K, V] struct {
-	key         K
-	val         V
-	left, right *node[K, V]
-}
-
-// New returns a new map.
-func New[type K, V](compare func(K, K) int) *Map[K, V] {
-        return &Map[K, V]{compare: compare}
-}
-
-// find looks up key in the map, and returns either a pointer
-// to the node holding key, or a pointer to the location where
-// such a node would go.
-func (m *Map[K, V]) find(key K) **node[K, V] {
-	pn := &m.root
-	for *pn != nil {
-		switch cmp := m.compare(key, (*pn).key); {
-		case cmp < 0:
-			pn = &(*pn).left
-		case cmp > 0:
-			pn = &(*pn).right
-		default:
-			return pn
-		}
-	}
-	return pn
-}
-
-// Insert inserts a new key/value into the map.
-// If the key is already present, the value is replaced.
-// Returns true if this is a new key, false if already present.
-func (m *Map[K, V]) Insert(key K, val V) bool {
-	pn := m.find(key)
-	if *pn != nil {
-		(*pn).val = val
-		return false
-	}
-        *pn = &node[K, V]{key: key, val: val}
-	return true
-}
-
-// Find returns the value associated with a key, or zero if not present.
-// The found result reports whether the key was found.
-func (m *Map[K, V]) Find(key K) (V, bool) {
-	pn := m.find(key)
-	if *pn == nil {
-		var zero V // see the discussion of zero values, above
-		return zero, false
-	}
-	return (*pn).val, true
-}
-
-// keyValue is a pair of key and value used when iterating.
-type keyValue[type K, V] struct {
-	key K
-	val V
-}
-
-// InOrder returns an iterator that does an in-order traversal of the map.
-func (m *Map[K, V]) InOrder() *Iterator[K, V] {
-	sender, receiver := chans.Ranger(keyValue[K, V])()
-	var f func(*node[K, V]) bool
-	f = func(n *node[K, V]) bool {
-		if n == nil {
-			return true
-		}
-		// Stop sending values if sender.Send returns false,
-		// meaning that nothing is listening at the receiver end.
-		return f(n.left) &&
-                        // TODO
-			// sender.Send(keyValue[K, V]{n.key, n.val}) &&
-			f(n.right)
-	}
-	go func() {
-		f(m.root)
-		sender.Close()
-	}()
-	return &Iterator{receiver}
-}
-
-// Iterator is used to iterate over the map.
-type Iterator[type K, V] struct {
-	r *chans.Receiver[keyValue[K, V]]
-}
-
-// Next returns the next key and value pair, and a boolean indicating
-// whether they are valid or whether we have reached the end.
-func (it *Iterator[K, V]) Next() (K, V, bool) {
-	keyval, ok := it.r.Next()
-	if !ok {
-		var zerok K
-		var zerov V
-		return zerok, zerov, false
-	}
-	return keyval.key, keyval.val, true
-}
diff --git a/src/go/parser/testdata/metrics.go2 b/src/go/parser/testdata/metrics.go2
index bd43747..ef1c66b 100644
--- a/src/go/parser/testdata/metrics.go2
+++ b/src/go/parser/testdata/metrics.go2
@@ -2,12 +2,12 @@
 
 import "sync"
 
-type Metric1(type T comparable) struct {
+type Metric1[T comparable] struct {
 	mu sync.Mutex
 	m  map[T]int
 }
 
-func (m *Metric1(T)) Add(v T) {
+func (m *Metric1[T]) Add(v T) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.m == nil {
@@ -16,43 +16,43 @@
 	m[v]++
 }
 
-type key2(type T1, T2 comparable) struct {
+type key2[T1, T2 comparable] struct {
 	f1 T1
 	f2 T2
 }
 
-type Metric2(type T1, T2 cmp2) struct {
+type Metric2[T1, T2 cmp2] struct {
 	mu sync.Mutex
-	m  map[key2(T1, T2)]int
+	m  map[key2[T1, T2]]int
 }
 
-func (m *Metric2(T1, T2)) Add(v1 T1, v2 T2) {
+func (m *Metric2[T1, T2]) Add(v1 T1, v2 T2) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.m == nil {
-		m.m = make(map[key2(T1, T2)]int)
+		m.m = make(map[key2[T1, T2]]int)
 	}
-	m[key(T1, T2){v1, v2}]++
+	m[key[T1, T2]{v1, v2}]++
 }
 
-type key3(type T1, T2, T3 comparable) struct {
+type key3[T1, T2, T3 comparable] struct {
 	f1 T1
 	f2 T2
 	f3 T3
 }
 
-type Metric3(type T1, T2, T3 comparable) struct {
+type Metric3[T1, T2, T3 comparable] struct {
 	mu sync.Mutex
-	m  map[key3(T1, T2, T3)]int
+	m  map[key3[T1, T2, T3]]int
 }
 
-func (m *Metric3(T1, T2, T3)) Add(v1 T1, v2 T2, v3 T3) {
+func (m *Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.m == nil {
 		m.m = make(map[key3]int)
 	}
-	m[key(T1, T2, T3){v1, v2, v3}]++
+	m[key[T1, T2, T3]{v1, v2, v3}]++
 }
 
 // Repeat for the maximum number of permitted arguments.
diff --git a/src/go/parser/testdata/metricsB.go2 b/src/go/parser/testdata/metricsB.go2
deleted file mode 100644
index 1ca0ab5..0000000
--- a/src/go/parser/testdata/metricsB.go2
+++ /dev/null
@@ -1,58 +0,0 @@
-package metrics
-
-import "sync"
-
-type Metric1[type T comparable] struct {
-	mu sync.Mutex
-	m  map[T]int
-}
-
-func (m *Metric1[T]) Add(v T) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.m == nil {
-		m.m = make(map[T]int)
-	}
-	m[v]++
-}
-
-type key2[type T1, T2 comparable] struct {
-	f1 T1
-	f2 T2
-}
-
-type Metric2[type T1, T2 cmp2] struct {
-	mu sync.Mutex
-	m  map[key2[T1, T2]]int
-}
-
-func (m *Metric2[T1, T2]) Add(v1 T1, v2 T2) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.m == nil {
-		m.m = make(map[key2[T1, T2]]int)
-	}
-	m[key[T1, T2]{v1, v2}]++
-}
-
-type key3[type T1, T2, T3 comparable] struct {
-	f1 T1
-	f2 T2
-	f3 T3
-}
-
-type Metric3[type T1, T2, T3 comparable] struct {
-	mu sync.Mutex
-	m  map[key3[T1, T2, T3]]int
-}
-
-func (m *Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.m == nil {
-		m.m = make(map[key3]int)
-	}
-	m[key[T1, T2, T3]{v1, v2, v3}]++
-}
-
-// Repeat for the maximum number of permitted arguments.
diff --git a/src/go/parser/testdata/set.go2 b/src/go/parser/testdata/set.go2
index bc18550..0da6377 100644
--- a/src/go/parser/testdata/set.go2
+++ b/src/go/parser/testdata/set.go2
@@ -1,30 +1,30 @@
 // Package set implements sets of any type.
 package set
 
-type Set(type Elem comparable) map[Elem]struct{}
+type Set[Elem comparable] map[Elem]struct{}
 
-func Make(type Elem comparable)() Set(Elem) {
+func Make[Elem comparable]() Set[Elem] {
 	return make(Set(Elem))
 }
 
-func (s Set(Elem)) Add(v Elem) {
+func (s Set[Elem]) Add(v Elem) {
 	s[v] = struct{}{}
 }
 
-func (s Set(Elem)) Delete(v Elem) {
+func (s Set[Elem]) Delete(v Elem) {
 	delete(s, v)
 }
 
-func (s Set(Elem)) Contains(v Elem) bool {
+func (s Set[Elem]) Contains(v Elem) bool {
 	_, ok := s[v]
 	return ok
 }
 
-func (s Set(Elem)) Len() int {
+func (s Set[Elem]) Len() int {
 	return len(s)
 }
 
-func (s Set(Elem)) Iterate(f func(Elem)) {
+func (s Set[Elem]) Iterate(f func(Elem)) {
 	for v := range s {
 		f(v)
 	}
diff --git a/src/go/parser/testdata/setB.go2 b/src/go/parser/testdata/setB.go2
deleted file mode 100644
index 7a0c56d..0000000
--- a/src/go/parser/testdata/setB.go2
+++ /dev/null
@@ -1,31 +0,0 @@
-// Package set implements sets of any type.
-package set
-
-type Set[type Elem comparable] map[Elem]struct{}
-
-func Make[type Elem comparable]() Set[Elem] {
-	return make(Set[Elem])
-}
-
-func (s Set[Elem]) Add(v Elem) {
-	s[v] = struct{}{}
-}
-
-func (s Set[Elem]) Delete(v Elem) {
-	delete(s, v)
-}
-
-func (s Set[Elem]) Contains(v Elem) bool {
-	_, ok := s[v]
-	return ok
-}
-
-func (s Set[Elem]) Len() int {
-	return len(s)
-}
-
-func (s Set[Elem]) Iterate(f func(Elem)) {
-	for v := range s {
-		f(v)
-	}
-}
diff --git a/src/go/parser/testdata/slices.go2 b/src/go/parser/testdata/slices.go2
index fe90f7c..e060212 100644
--- a/src/go/parser/testdata/slices.go2
+++ b/src/go/parser/testdata/slices.go2
@@ -2,7 +2,7 @@
 package slices
 
 // Map turns a []T1 to a []T2 using a mapping function.
-func Map(type T1, T2)(s []T1, f func(T1) T2) []T2 {
+func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
 	r := make([]T2, len(s))
 	for i, v := range s {
 		r[i] = f(v)
@@ -11,7 +11,7 @@
 }
 
 // Reduce reduces a []T1 to a single value using a reduction function.
-func Reduce(type T1, T2)(s []T1, initializer T2, f func(T2, T1) T2) T2 {
+func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
 	r := initializer
 	for _, v := range s {
 		r = f(r, v)
@@ -20,7 +20,7 @@
 }
 
 // Filter filters values from a slice using a filter function.
-func Filter(type T)(s []T, f func(T) bool) []T {
+func Filter[T any](s []T, f func(T) bool) []T {
 	var r []T
 	for _, v := range s {
 		if f(v) {
diff --git a/src/go/parser/testdata/slicesB.go2 b/src/go/parser/testdata/slicesB.go2
deleted file mode 100644
index 5e83f6e..0000000
--- a/src/go/parser/testdata/slicesB.go2
+++ /dev/null
@@ -1,31 +0,0 @@
-// Package slices implements various slice algorithms.
-package slices
-
-// Map turns a []T1 to a []T2 using a mapping function.
-func Map[type T1, T2](s []T1, f func(T1) T2) []T2 {
-	r := make([]T2, len(s))
-	for i, v := range s {
-		r[i] = f(v)
-	}
-	return r
-}
-
-// Reduce reduces a []T1 to a single value using a reduction function.
-func Reduce[type T1, T2](s []T1, initializer T2, f func(T2, T1) T2) T2 {
-	r := initializer
-	for _, v := range s {
-		r = f(r, v)
-	}
-	return r
-}
-
-// Filter filters values from a slice using a filter function.
-func Filter[type T](s []T, f func(T) bool) []T {
-	var r []T
-	for _, v := range s {
-		if f(v) {
-			r = append(r, v)
-		}
-	}
-	return r
-}
diff --git a/src/go/parser/testdata/sort.go2 b/src/go/parser/testdata/sort.go2
index 241b8fb..88be79f 100644
--- a/src/go/parser/testdata/sort.go2
+++ b/src/go/parser/testdata/sort.go2
@@ -1,27 +1,27 @@
 package sort
 
-type orderedSlice(type Elem comparable) []Elem
+type orderedSlice[Elem comparable] []Elem
 
-func (s orderedSlice(Elem)) Len() int           { return len(s) }
-func (s orderedSlice(Elem)) Less(i, j int) bool { return s[i] < s[j] }
-func (s orderedSlice(Elem)) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s orderedSlice[Elem]) Len() int           { return len(s) }
+func (s orderedSlice[Elem]) Less(i, j int) bool { return s[i] < s[j] }
+func (s orderedSlice[Elem]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 // OrderedSlice sorts the slice s in ascending order.
 // The elements of s must be ordered using the < operator.
-func OrderedSlice(type Elem comparable)(s []Elem) {
-	sort.Sort(orderedSlice(Elem)(s))
+func OrderedSlice[Elem comparable](s []Elem) {
+	sort.Sort(orderedSlice[Elem](s))
 }
 
-type sliceFn(type Elem) struct {
+type sliceFn[Elem any] struct {
 	s []Elem
 	f func(Elem, Elem) bool
 }
 
-func (s sliceFn(Elem)) Len() int           { return len(s.s) }
-func (s sliceFn(Elem)) Less(i, j int) bool { return s.f(s.s[i], s.s[j]) }
-func (s sliceFn(Elem)) Swap(i, j int)      { s.s[i], s.s[j] = s.s[j], s.s[i] }
+func (s sliceFn[Elem]) Len() int           { return len(s.s) }
+func (s sliceFn[Elem]) Less(i, j int) bool { return s.f(s.s[i], s.s[j]) }
+func (s sliceFn[Elem]) Swap(i, j int)      { s.s[i], s.s[j] = s.s[j], s.s[i] }
 
 // SliceFn sorts the slice s according to the function f.
-func SliceFn(type Elem)(s []Elem, f func(Elem, Elem) bool) {
-	Sort(sliceFn(Elem){s, f})
+func SliceFn[Elem any](s []Elem, f func(Elem, Elem) bool) {
+	Sort(sliceFn[Elem]{s, f})
 }
diff --git a/src/go/parser/testdata/sortB.go2 b/src/go/parser/testdata/sortB.go2
deleted file mode 100644
index 39363ae..0000000
--- a/src/go/parser/testdata/sortB.go2
+++ /dev/null
@@ -1,27 +0,0 @@
-package sort
-
-type orderedSlice[type Elem comparable] []Elem
-
-func (s orderedSlice[Elem]) Len() int           { return len(s) }
-func (s orderedSlice[Elem]) Less(i, j int) bool { return s[i] < s[j] }
-func (s orderedSlice[Elem]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-// OrderedSlice sorts the slice s in ascending order.
-// The elements of s must be ordered using the < operator.
-func OrderedSlice[type Elem comparable](s []Elem) {
-	sort.Sort(orderedSlice[Elem](s))
-}
-
-type sliceFn[type Elem] struct {
-	s []Elem
-	f func(Elem, Elem) bool
-}
-
-func (s sliceFn[Elem]) Len() int           { return len(s.s) }
-func (s sliceFn[Elem]) Less(i, j int) bool { return s.f(s.s[i], s.s[j]) }
-func (s sliceFn[Elem]) Swap(i, j int)      { s.s[i], s.s[j] = s.s[j], s.s[i] }
-
-// SliceFn sorts the slice s according to the function f.
-func SliceFn[type Elem](s []Elem, f func(Elem, Elem) bool) {
-	Sort(sliceFn[Elem]{s, f})
-}
diff --git a/src/go/parser/testdata/typeparams.src b/src/go/parser/testdata/typeparams.src
new file mode 100644
index 0000000..1fea23f
--- /dev/null
+++ b/src/go/parser/testdata/typeparams.src
@@ -0,0 +1,17 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test cases for error messages produced while parsing code that uses type
+// parameters, without ParseTypeParams being enabled.
+
+package p
+
+type List[E any /* ERROR "expected ']', found any" */ ] []E
+
+type Pair[L, /* ERROR "expected ']', found ','" */ R any] struct {
+	Left L
+	Right R
+}
+
+var _ = Pair[int, /* ERROR "expected ']' or ':', found ','" */ string]{}
diff --git a/src/go/printer/nodes.go b/src/go/printer/nodes.go
index fbf3d14..cc79553 100644
--- a/src/go/printer/nodes.go
+++ b/src/go/printer/nodes.go
@@ -319,15 +319,12 @@
 	}
 }
 
-func (p *printer) parameters(isTypeParam bool, fields *ast.FieldList) {
+func (p *printer) parameters(fields *ast.FieldList, isTypeParam bool) {
 	openTok, closeTok := token.LPAREN, token.RPAREN
-	if isTypeParam && p.Mode&UseBrackets != 0 {
+	if isTypeParam {
 		openTok, closeTok = token.LBRACK, token.RBRACK
 	}
 	p.print(fields.Opening, openTok)
-	if isTypeParam && p.Mode&UseBrackets == 0 {
-		p.print(token.TYPE)
-	}
 	if len(fields.List) > 0 {
 		prevLine := p.lineFor(fields.Opening)
 		ws := indent
@@ -352,7 +349,7 @@
 			if needsLinebreak && p.linebreak(parLineBeg, 0, ws, true) > 0 {
 				// break line if the opening "(" or previous parameter ended on a different line
 				ws = ignore
-			} else if isTypeParam && len(par.Names) > 0 && p.Mode&UseBrackets == 0 || i > 0 {
+			} else if i > 0 {
 				p.print(blank)
 			}
 			// parameter names
@@ -364,25 +361,10 @@
 				// by a linebreak call after a type, or in the next multi-line identList
 				// will do the right thing.
 				p.identList(par.Names, ws == indent)
-				if par.Type != nil {
-					p.print(blank)
-				}
+				p.print(blank)
 			}
 			// parameter type
-			if par.Type != nil {
-				typ := stripParensAlways(par.Type)
-				// If we don't have a parameter name and the parameter type is an
-				// instantiated type using parentheses, then we need to parenthesize
-				// the type otherwise it is interpreted as a parameter name followed
-				// by a parenthesized type name.
-				if call, _ := typ.(*ast.CallExpr); call != nil && !call.Brackets && len(par.Names) == 0 {
-					p.print(token.LPAREN)
-					p.expr(typ)
-					p.print(token.RPAREN)
-				} else {
-					p.expr(typ)
-				}
-			}
+			p.expr(stripParensAlways(par.Type))
 			prevLine = parLineEnd
 		}
 		// if the closing ")" is on a separate line from the last parameter,
@@ -401,10 +383,10 @@
 
 func (p *printer) signature(sig *ast.FuncType) {
 	if sig.TParams != nil {
-		p.parameters(true, sig.TParams)
+		p.parameters(sig.TParams, true)
 	}
 	if sig.Params != nil {
-		p.parameters(false, sig.Params)
+		p.parameters(sig.Params, false)
 	} else {
 		p.print(token.LPAREN, token.RPAREN)
 	}
@@ -418,7 +400,7 @@
 			p.expr(stripParensAlways(res.List[0].Type))
 			return
 		}
-		p.parameters(false, res)
+		p.parameters(res, false)
 	}
 }
 
@@ -848,8 +830,8 @@
 		}
 
 	case *ast.BasicLit:
-		if p.Config.Mode&StdFormat != 0 {
-			x = normalizeNumbers(x)
+		if p.Config.Mode&normalizeNumbers != 0 {
+			x = normalizedNumber(x)
 		}
 		p.print(x)
 
@@ -1038,11 +1020,15 @@
 	}
 }
 
-// normalizeNumbers rewrites base prefixes and exponents to
-// use lower-case letters, and removes leading 0's from
-// integer imaginary literals. It leaves hexadecimal digits
-// alone.
-func normalizeNumbers(lit *ast.BasicLit) *ast.BasicLit {
+// normalizedNumber rewrites base prefixes and exponents
+// of numbers to use lower-case letters (0X123 to 0x123 and 1.2E3 to 1.2e3),
+// and removes leading 0's from integer imaginary literals (0765i to 765i).
+// It leaves hexadecimal digits alone.
+//
+// normalizedNumber doesn't modify the ast.BasicLit value lit points to.
+// If lit is not a number or a number in canonical format already,
+// lit is returned as is. Otherwise a new ast.BasicLit is created.
+func normalizedNumber(lit *ast.BasicLit) *ast.BasicLit {
 	if lit.Kind != token.INT && lit.Kind != token.FLOAT && lit.Kind != token.IMAG {
 		return lit // not a number - nothing to do
 	}
@@ -1646,7 +1632,7 @@
 		p.setComment(s.Doc)
 		p.expr(s.Name)
 		if s.TParams != nil {
-			p.parameters(true, s.TParams)
+			p.parameters(s.TParams, true)
 		}
 		if n == 1 {
 			p.print(blank)
@@ -1836,7 +1822,7 @@
 	// FUNC is emitted).
 	startCol := p.out.Column - len("func ")
 	if d.Recv != nil {
-		p.parameters(false, d.Recv) // method: print receiver
+		p.parameters(d.Recv, false) // method: print receiver
 		p.print(blank)
 	}
 	p.expr(d.Name)
diff --git a/src/go/printer/performance_test.go b/src/go/printer/performance_test.go
index 3f34bfc..2e67154 100644
--- a/src/go/printer/performance_test.go
+++ b/src/go/printer/performance_test.go
@@ -20,7 +20,7 @@
 var testfile *ast.File
 
 func testprint(out io.Writer, file *ast.File) {
-	if err := (&Config{TabIndent | UseSpaces | StdFormat, 8, 0}).Fprint(out, fset, file); err != nil {
+	if err := (&Config{TabIndent | UseSpaces | normalizeNumbers, 8, 0}).Fprint(out, fset, file); err != nil {
 		log.Fatalf("print error: %s", err)
 	}
 }
diff --git a/src/go/printer/printer.go b/src/go/printer/printer.go
index b3eba6c..0077afe 100644
--- a/src/go/printer/printer.go
+++ b/src/go/printer/printer.go
@@ -1272,12 +1272,26 @@
 type Mode uint
 
 const (
-	RawFormat   Mode = 1 << iota // do not use a tabwriter; if set, UseSpaces is ignored
-	TabIndent                    // use tabs for indentation independent of UseSpaces
-	UseSpaces                    // use spaces instead of tabs for alignment
-	SourcePos                    // emit //line directives to preserve original source positions
-	StdFormat                    // apply standard formatting changes (exact byte output may change between versions of Go)
-	UseBrackets                  // use square brackets instead of parentheses for type parameters (implies unified parameter syntax)
+	RawFormat Mode = 1 << iota // do not use a tabwriter; if set, UseSpaces is ignored
+	TabIndent                  // use tabs for indentation independent of UseSpaces
+	UseSpaces                  // use spaces instead of tabs for alignment
+	SourcePos                  // emit //line directives to preserve original source positions
+)
+
+// The mode below is not included in printer's public API because
+// editing code text is deemed out of scope. Because this mode is
+// unexported, it's also possible to modify or remove it based on
+// the evolving needs of go/format and cmd/gofmt without breaking
+// users. See discussion in CL 240683.
+const (
+	// normalizeNumbers means to canonicalize number
+	// literal prefixes and exponents while printing.
+	//
+	// This value is known in and used by go/format and cmd/gofmt.
+	// It is currently more convenient and performant for those
+	// packages to apply number normalization during printing,
+	// rather than by modifying the AST in advance.
+	normalizeNumbers Mode = 1 << 30
 )
 
 // A Config node controls the output of Fprint.
@@ -1350,13 +1364,6 @@
 // or assignment-compatible to ast.Expr, ast.Decl, ast.Spec, or ast.Stmt.
 //
 func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node interface{}) error {
-	// Ensure that our formatting of type parameters is consistent with the file.
-	if file, _ := node.(*ast.File); file != nil && file.UseBrackets && cfg.Mode&UseBrackets == 0 {
-		// Copy to avoid data races.
-		cfg2 := *cfg
-		cfg2.Mode |= UseBrackets
-		cfg = &cfg2
-	}
 	return cfg.fprint(output, fset, node, make(map[ast.Node]int))
 }
 
diff --git a/src/go/printer/printer_test.go b/src/go/printer/printer_test.go
index bc8c43e..3efa468 100644
--- a/src/go/printer/printer_test.go
+++ b/src/go/printer/printer_test.go
@@ -33,7 +33,7 @@
 const (
 	export checkMode = 1 << iota
 	rawFormat
-	stdFormat
+	normNumber
 	idempotent
 )
 
@@ -42,7 +42,7 @@
 // if any.
 func format(src []byte, mode checkMode) ([]byte, error) {
 	// parse src
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.ParseTypeParams)
 	if err != nil {
 		return nil, fmt.Errorf("parse: %s\n%s", err, src)
 	}
@@ -58,8 +58,8 @@
 	if mode&rawFormat != 0 {
 		cfg.Mode |= RawFormat
 	}
-	if mode&stdFormat != 0 {
-		cfg.Mode |= StdFormat
+	if mode&normNumber != 0 {
+		cfg.Mode |= normalizeNumbers
 	}
 
 	// print AST
@@ -70,7 +70,7 @@
 
 	// make sure formatted output is syntactically correct
 	res := buf.Bytes()
-	if _, err := parser.ParseFile(fset, "", res, 0); err != nil {
+	if _, err := parser.ParseFile(fset, "", res, parser.ParseTypeParams); err != nil {
 		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
 	}
 
@@ -205,9 +205,8 @@
 	{"slow.input", "slow.golden", idempotent},
 	{"complit.input", "complit.x", export},
 	{"go2numbers.input", "go2numbers.golden", idempotent},
-	{"go2numbers.input", "go2numbers.stdfmt", stdFormat | idempotent},
+	{"go2numbers.input", "go2numbers.norm", normNumber | idempotent},
 	{"generics.input", "generics.golden", idempotent},
-	{"genericsB.input", "genericsB.golden", idempotent},
 }
 
 func TestFiles(t *testing.T) {
diff --git a/src/go/printer/testdata/declarations.golden b/src/go/printer/testdata/declarations.golden
index 058baa8..74ffce7 100644
--- a/src/go/printer/testdata/declarations.golden
+++ b/src/go/printer/testdata/declarations.golden
@@ -942,6 +942,13 @@
 		x ...int)
 }
 
+// properly format one-line type lists
+type _ interface{ type a }
+
+type _ interface {
+	type a, b, c
+}
+
 // omit superfluous parentheses in parameter lists
 func _(int)
 func _(int)
@@ -993,9 +1000,8 @@
 })	// no extra comma between } and )
 
 // type parameters
-func _(type)()
-func _(type A, B)(a A, b B) int	{}
-func _(type T)(x, y T) T
+func _[A, B any](a A, b B) int	{}
+func _[T any](x, y T) T
 
 // alias declarations
 
diff --git a/src/go/printer/testdata/declarations.input b/src/go/printer/testdata/declarations.input
index 8787f49..ab20221 100644
--- a/src/go/printer/testdata/declarations.input
+++ b/src/go/printer/testdata/declarations.input
@@ -955,6 +955,11 @@
 		x ...int)
 }
 
+// properly format one-line type lists
+type _ interface { type a }
+
+type _ interface { type a,b,c }
+
 // omit superfluous parentheses in parameter lists
 func _((int))
 func _((((((int))))))
@@ -1006,9 +1011,8 @@
 }) // no extra comma between } and )
 
 // type parameters
-func _(type)()
-func _(type A, B)(a A, b B) int {}
-func _(type T)(x, y T) T
+func _[A, B any](a A, b B) int {}
+func _[T any](x, y T) T
 
 // alias declarations
 
@@ -1023,4 +1027,4 @@
 	c = foo
 	d = interface{}
 	ddd = p.Foo
-)
\ No newline at end of file
+)
diff --git a/src/go/printer/testdata/generics.golden b/src/go/printer/testdata/generics.golden
index 751ba68..88c4616 100644
--- a/src/go/printer/testdata/generics.golden
+++ b/src/go/printer/testdata/generics.golden
@@ -4,33 +4,30 @@
 
 package generics
 
-type T(type) struct{}
-type T(type P) struct{}
-type T(type P1, P2, P3) struct{}
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
 
-type T(type P C) struct{}
-type T(type P1, P2, P3, C) struct{}
+type T[P C] struct{}
+type T[P1, P2, P3 C] struct{}
 
-type T(type P C(P)) struct{}
-type T(type P1, P2, P3 C(P1, P2, P3)) struct{}
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
 
-func f(type)()
-func f(type P)(x P)
-func f(type P1, P2, P3)(x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
 
-func f(type)()
-func f(type P interface{})(x P)
-func f(type P1, P2, P3 interface {
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface {
 	m1(P1)
 	type P2, P3
-})(x1 P1, x2 P2, x3 P3) struct{}
-func f(type P)((T1(P)), (T2(P))) T3(P)
+}](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
 
-func (x T(P)) m()
-func ((T(P))) m(x T(P)) P
+func (x T[P]) m()
+func (T[P]) m(x T[P]) P
 
 func _() {
-	type _ [](T(P))
-	var _ []T(P)
-	_ = [](T(P)){}
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
 }
diff --git a/src/go/printer/testdata/generics.input b/src/go/printer/testdata/generics.input
index 9fe5cec..5fdf8cd 100644
--- a/src/go/printer/testdata/generics.input
+++ b/src/go/printer/testdata/generics.input
@@ -4,30 +4,27 @@
 
 package generics
 
-type T(type) struct{}
-type T(type P) struct{}
-type T(type P1, P2, P3) struct{}
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
 
-type T(type P C) struct{}
-type T(type P1, P2, P3, C) struct{}
+type T[P C] struct{}
+type T[P1, P2, P3 C] struct{}
 
-type T(type P C(P)) struct{}
-type T(type P1, P2, P3 C(P1, P2, P3)) struct{}
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
 
-func f(type)()
-func f(type P)(x P)
-func f(type P1, P2, P3)(x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
 
-func f(type)()
-func f(type P interface{})(x P)
-func f(type P1, P2, P3 interface{ m1(P1); type P2, P3 })(x1 P1, x2 P2, x3 P3) struct{}
-func f(type P)((T1(P)), (T2(P))) T3(P)
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface{ m1(P1); type P2, P3 }](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
 
-func (x T(P)) m()
-func ((T(P))) m(x T(P)) P
+func (x T[P]) m()
+func ((T[P])) m(x T[P]) P
 
 func _() {
-	type _ [](T(P))
-	var _ []T(P)
-	_ = [](T(P)){}
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
 }
diff --git a/src/go/printer/testdata/go2numbers.norm b/src/go/printer/testdata/go2numbers.norm
new file mode 100644
index 0000000..855f0fc
--- /dev/null
+++ b/src/go/printer/testdata/go2numbers.norm
@@ -0,0 +1,186 @@
+package p
+
+const (
+	// 0-octals
+	_	= 0
+	_	= 0123
+	_	= 0123456
+
+	_	= 0_123
+	_	= 0123_456
+
+	// decimals
+	_	= 1
+	_	= 1234
+	_	= 1234567
+
+	_	= 1_234
+	_	= 1_234_567
+
+	// hexadecimals
+	_	= 0x0
+	_	= 0x1234
+	_	= 0xcafef00d
+
+	_	= 0x0
+	_	= 0x1234
+	_	= 0xCAFEf00d
+
+	_	= 0x_0
+	_	= 0x_1234
+	_	= 0x_CAFE_f00d
+
+	// octals
+	_	= 0o0
+	_	= 0o1234
+	_	= 0o01234567
+
+	_	= 0o0
+	_	= 0o1234
+	_	= 0o01234567
+
+	_	= 0o_0
+	_	= 0o_1234
+	_	= 0o0123_4567
+
+	_	= 0o_0
+	_	= 0o_1234
+	_	= 0o0123_4567
+
+	// binaries
+	_	= 0b0
+	_	= 0b1011
+	_	= 0b00101101
+
+	_	= 0b0
+	_	= 0b1011
+	_	= 0b00101101
+
+	_	= 0b_0
+	_	= 0b10_11
+	_	= 0b_0010_1101
+
+	// decimal floats
+	_	= 0.
+	_	= 123.
+	_	= 0123.
+
+	_	= .0
+	_	= .123
+	_	= .0123
+
+	_	= 0e0
+	_	= 123e+0
+	_	= 0123e-1
+
+	_	= 0e-0
+	_	= 123e+0
+	_	= 0123e123
+
+	_	= 0.e+1
+	_	= 123.e-10
+	_	= 0123.e123
+
+	_	= .0e-1
+	_	= .123e+10
+	_	= .0123e123
+
+	_	= 0.0
+	_	= 123.123
+	_	= 0123.0123
+
+	_	= 0.0e1
+	_	= 123.123e-10
+	_	= 0123.0123e+456
+
+	_	= 1_2_3.
+	_	= 0_123.
+
+	_	= 0_0e0
+	_	= 1_2_3e0
+	_	= 0_123e0
+
+	_	= 0e-0_0
+	_	= 1_2_3e+0
+	_	= 0123e1_2_3
+
+	_	= 0.e+1
+	_	= 123.e-1_0
+	_	= 01_23.e123
+
+	_	= .0e-1
+	_	= .123e+10
+	_	= .0123e123
+
+	_	= 1_2_3.123
+	_	= 0123.01_23
+
+	// hexadecimal floats
+	_	= 0x0.p+0
+	_	= 0xdeadcafe.p-10
+	_	= 0x1234.p123
+
+	_	= 0x.1p-0
+	_	= 0x.deadcafep2
+	_	= 0x.1234p+10
+
+	_	= 0x0p0
+	_	= 0xdeadcafep+1
+	_	= 0x1234p-10
+
+	_	= 0x0.0p0
+	_	= 0xdead.cafep+1
+	_	= 0x12.34p-10
+
+	_	= 0xdead_cafep+1
+	_	= 0x_1234p-10
+
+	_	= 0x_dead_cafe.p-10
+	_	= 0x12_34.p1_2_3
+	_	= 0x1_2_3_4.p-1_2_3
+
+	// imaginaries
+	_	= 0i
+	_	= 0i
+	_	= 8i
+	_	= 0i
+	_	= 123i
+	_	= 123i
+	_	= 56789i
+	_	= 1234i
+	_	= 1234567i
+
+	_	= 0i
+	_	= 0i
+	_	= 8i
+	_	= 0i
+	_	= 123i
+	_	= 123i
+	_	= 56_789i
+	_	= 1_234i
+	_	= 1_234_567i
+
+	_	= 0.i
+	_	= 123.i
+	_	= 0123.i
+	_	= 000123.i
+
+	_	= 0e0i
+	_	= 123e0i
+	_	= 0123e0i
+	_	= 000123e0i
+
+	_	= 0.e+1i
+	_	= 123.e-1_0i
+	_	= 01_23.e123i
+	_	= 00_01_23.e123i
+
+	_	= 0b1010i
+	_	= 0b1010i
+	_	= 0o660i
+	_	= 0o660i
+	_	= 0xabcDEFi
+	_	= 0xabcDEFi
+	_	= 0xabcDEFp0i
+	_	= 0xabcDEFp0i
+)
diff --git a/src/go/token/position.go b/src/go/token/position.go
index 3f5a390..a21f5fd 100644
--- a/src/go/token/position.go
+++ b/src/go/token/position.go
@@ -58,8 +58,11 @@
 // larger, representation.
 //
 // The Pos value for a given file is a number in the range [base, base+size],
-// where base and size are specified when adding the file to the file set via
-// AddFile.
+// where base and size are specified when a file is added to the file set.
+// The difference between a Pos value and the corresponding file base
+// corresponds to the byte offset of that position (represented by the Pos value)
+// from the beginning of the file. Thus, the file base offset is the Pos value
+// representing the first byte in the file.
 //
 // To create the Pos value for a specific source offset (measured in bytes),
 // first add the respective file to the current file set using FileSet.AddFile
@@ -147,12 +150,12 @@
 //
 func (f *File) MergeLine(line int) {
 	if line < 1 {
-		panic("illegal line number (line numbering starts at 1)")
+		panic(fmt.Sprintf("invalid line number %d (should be >= 1)", line))
 	}
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
 	if line >= len(f.lines) {
-		panic("illegal line number")
+		panic(fmt.Sprintf("invalid line number %d (should be < %d)", line, len(f.lines)))
 	}
 	// To merge the line numbered <line> with the line numbered <line+1>,
 	// we need to remove the entry in lines corresponding to the line
@@ -214,12 +217,12 @@
 // LineStart panics if the 1-based line number is invalid.
 func (f *File) LineStart(line int) Pos {
 	if line < 1 {
-		panic("illegal line number (line numbering starts at 1)")
+		panic(fmt.Sprintf("invalid line number %d (should be >= 1)", line))
 	}
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
 	if line > len(f.lines) {
-		panic("illegal line number")
+		panic(fmt.Sprintf("invalid line number %d (should be < %d)", line, len(f.lines)))
 	}
 	return Pos(f.base + f.lines[line-1])
 }
@@ -264,7 +267,7 @@
 //
 func (f *File) Pos(offset int) Pos {
 	if offset > f.size {
-		panic("illegal file offset")
+		panic(fmt.Sprintf("invalid file offset %d (should be <= %d)", offset, f.size))
 	}
 	return Pos(f.base + offset)
 }
@@ -275,7 +278,7 @@
 //
 func (f *File) Offset(p Pos) int {
 	if int(p) < f.base || int(p) > f.base+f.size {
-		panic("illegal Pos value")
+		panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d[)", p, f.base, f.base+f.size))
 	}
 	return int(p) - f.base
 }
@@ -343,7 +346,7 @@
 func (f *File) PositionFor(p Pos, adjusted bool) (pos Position) {
 	if p != NoPos {
 		if int(p) < f.base || int(p) > f.base+f.size {
-			panic("illegal Pos value")
+			panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d[)", p, f.base, f.base+f.size))
 		}
 		pos = f.position(p, adjusted)
 	}
@@ -364,6 +367,22 @@
 // Methods of file sets are synchronized; multiple goroutines
 // may invoke them concurrently.
 //
+// The byte offsets for each file in a file set are mapped into
+// distinct (integer) intervals, one interval [base, base+size]
+// per file. Base represents the first byte in the file, and size
+// is the corresponding file size. A Pos value is a value in such
+// an interval. By determining the interval a Pos value belongs
+// to, the file, its file base, and thus the byte offset (position)
+// the Pos value is representing can be computed.
+//
+// When adding a new file, a file base must be provided. That can
+// be any integer value that is past the end of any interval of any
+// file already in the file set. For convenience, FileSet.Base provides
+// such a value, which is simply the end of the Pos interval of the most
+// recently added file, plus one. Unless there is a need to extend an
+// interval later, using the FileSet.Base should be used as argument
+// for FileSet.AddFile.
+//
 type FileSet struct {
 	mutex sync.RWMutex // protects the file set
 	base  int          // base offset for the next file
@@ -411,8 +430,11 @@
 	if base < 0 {
 		base = s.base
 	}
-	if base < s.base || size < 0 {
-		panic("illegal base or size")
+	if base < s.base {
+		panic(fmt.Sprintf("invalid base %d (should be >= %d)", base, s.base))
+	}
+	if size < 0 {
+		panic(fmt.Sprintf("invalid size %d (should be >= 0)", size))
 	}
 	// base >= s.base && size >= 0
 	f := &File{set: s, name: filename, base: base, size: size, lines: []int{0}}
diff --git a/src/go/types/api.go b/src/go/types/api.go
index 3b43047..ec12fcf 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -41,9 +41,17 @@
 type Error struct {
 	Fset *token.FileSet // file set for interpretation of Pos
 	Pos  token.Pos      // error position
-	Msg  string         // default error message, user-friendly
-	Full string         // full error message, for debugging (may contain internal details)
+	Msg  string         // error message
 	Soft bool           // if set, error is "soft"
+
+	// go116code is a future API, unexported as the set of error codes is large
+	// and likely to change significantly during experimentation. Tools wishing
+	// to preview this feature may read go116code using reflection (see
+	// errorcodes_test.go), but beware that there is no guarantee of future
+	// compatibility.
+	go116code  errorCode
+	go116start token.Pos
+	go116end   token.Pos
 }
 
 // Error returns an error string formatted as follows:
@@ -52,13 +60,6 @@
 	return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Msg)
 }
 
-// FullError returns an error string like Error, buy it may contain
-// type-checker internal details such as subscript indices for type
-// parameters and more. Useful for debugging.
-func (err Error) FullError() string {
-	return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Full)
-}
-
 // An Importer resolves import paths to Packages.
 //
 // CAUTION: This interface does not support the import of locally
@@ -104,13 +105,6 @@
 	// type-checked.
 	IgnoreFuncBodies bool
 
-	// If AcceptMethodTypeParams is set, methods may have type parameters.
-	AcceptMethodTypeParams bool
-
-	// If InferFromConstraints is set, constraint type inference is used
-	// if some function type arguments are missing.
-	InferFromConstraints bool
-
 	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
 	// declares an empty "C" package and errors are omitted for qualified
 	// identifiers referring to package C (which won't find an object).
@@ -129,9 +123,6 @@
 	// It is an error to set both FakeImportC and go115UsesCgo.
 	go115UsesCgo bool
 
-	// If Trace is set, a debug trace is printed to stdout.
-	Trace bool
-
 	// If Error != nil, it is called with each error found
 	// during type checking; err has dynamic type Error.
 	// Secondary errors (for instance, to enumerate all types
@@ -394,14 +385,15 @@
 
 // AssertableTo reports whether a value of type V can be asserted to have type T.
 func AssertableTo(V *Interface, T Type) bool {
-	m, _ := (*Checker)(nil).assertableTo(V, T, false)
+	m, _ := (*Checker)(nil).assertableTo(V, T)
 	return m == nil
 }
 
 // AssignableTo reports whether a value of type V is assignable to a variable of type T.
 func AssignableTo(V, T Type) bool {
 	x := operand{mode: value, typ: V}
-	return x.assignableTo(nil, T, nil) // check not needed for non-constant x
+	ok, _ := x.assignableTo(nil, T, nil) // check not needed for non-constant x
+	return ok
 }
 
 // ConvertibleTo reports whether a value of type V is convertible to a value of type T.
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 3344939..014cd52 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -22,7 +22,8 @@
 
 func pkgFor(path, source string, info *Info) (*Package, error) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, path, source, 0)
+	mode := modeForSource(source)
+	f, err := parser.ParseFile(fset, path, source, mode)
 	if err != nil {
 		return nil, err
 	}
@@ -42,17 +43,27 @@
 	return pkg.Name()
 }
 
+// genericPkg is a prefix for packages that should be type checked with
+// generics.
+const genericPkg = "package generic_"
+
+func modeForSource(src string) parser.Mode {
+	if strings.HasPrefix(src, genericPkg) {
+		return parser.ParseTypeParams
+	}
+	return 0
+}
+
 func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, path, source, 0)
+	mode := modeForSource(source)
+	f, err := parser.ParseFile(fset, path, source, mode)
 	if f == nil { // ignore errors unless f is nil
 		t.Fatalf("%s: unable to parse: %s", path, err)
 	}
 	conf := Config{
-		AcceptMethodTypeParams: true,
-		InferFromConstraints:   true,
-		Error:                  func(err error) {},
-		Importer:               importer.Default(),
+		Error:    func(err error) {},
+		Importer: importer.Default(),
 	}
 	pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
 	return pkg.Name(), err
@@ -278,20 +289,20 @@
 		{`package x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
-		{`package p0; func f[T any](T); var _ = f(int)`, `f`, `func[T₁ any](T₁)`},
-		{`package p1; func f[T any](T); var _ = f(int)`, `f(int)`, `func(int)`},
-		{`package p2; func f[T any](T); var _ = f(42)`, `f`, `func[T₁ any](T₁)`},
-		{`package p2; func f[T any](T); var _ = f(42)`, `f(42)`, `()`},
+		{genericPkg + `p0; func f[T any](T); var _ = f(int)`, `f`, `func[T₁ any](T₁)`},
+		{genericPkg + `p1; func f[T any](T); var _ = f(int)`, `f(int)`, `func(int)`},
+		{genericPkg + `p2; func f[T any](T); var _ = f(42)`, `f`, `func[T₁ any](T₁)`},
+		{genericPkg + `p2; func f[T any](T); var _ = f(42)`, `f(42)`, `()`},
 
 		// type parameters
-		{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
-		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ any]`},
-		{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P₁ interface{}]`},
-		{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P₁, Q₂ interface{}]`},
-		{`package t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `t4.t[P₁, Q₂ interface{m()}]`},
+		{genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
+		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P₁ any]`},
+		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P₁ interface{}]`},
+		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P₁, Q₂ interface{}]`},
+		{genericPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `generic_t4.t[P₁, Q₂ interface{m()}]`},
 
 		// instantiated types must be sanitized
-		{`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`},
+		{genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`},
 	}
 
 	for _, test := range tests {
@@ -325,103 +336,64 @@
 		targs []string
 		sig   string
 	}{
-		{`package p0; func f[T any](T); func _() { f(42) }`,
+		{genericPkg + `p0; func f[T any](T); func _() { f(42) }`,
 			`f`,
 			[]string{`int`},
 			`func(int)`,
 		},
-		{`package p1; func f[T any](T) T; func _() { f('@') }`,
+		{genericPkg + `p1; func f[T any](T) T; func _() { f('@') }`,
 			`f`,
 			[]string{`rune`},
 			`func(rune) rune`,
 		},
-		{`package p2; func f[T any](...T) T; func _() { f(0i) }`,
+		{genericPkg + `p2; func f[T any](...T) T; func _() { f(0i) }`,
 			`f`,
 			[]string{`complex128`},
 			`func(...complex128) complex128`,
 		},
-		{`package p3; func f(type A, B, C)(A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
+		{genericPkg + `p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
 			`f`,
 			[]string{`float64`, `string`, `byte`},
 			`func(float64, *string, []byte)`,
 		},
-		{`package p4; func f(type A, B)(A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
+		{genericPkg + `p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
 			`f`,
 			[]string{`float64`, `byte`},
 			`func(float64, *byte, ...[]byte)`,
 		},
 
-		// we don't know how to translate these but we can type-check them
-		{`package q0; type T struct{}; func (T) m[P any](P); func _(x T) { x.m(42) }`,
-			`x.m`,
-			[]string{`int`},
-			`func(int)`,
-		},
-		{`package q1; type T struct{}; func (T) m[P any](P) P; func _(x T) { x.m(42) }`,
-			`x.m`,
-			[]string{`int`},
-			`func(int) int`,
-		},
-		{`package q2; type T struct{}; func (T) m[P any](...P) P; func _(x T) { x.m(42) }`,
-			`x.m`,
-			[]string{`int`},
-			`func(...int) int`,
-		},
-		{`package q3; type T struct{}; func (T) m(type A, B, C)(A, *B, []C); func _(x T) { x.m(1.2, new(string), []byte{}) }`,
-			`x.m`,
-			[]string{`float64`, `string`, `byte`},
-			`func(float64, *string, []byte)`,
-		},
-		{`package q4; type T struct{}; func (T) m(type A, B)(A, *B, ...[]B); func _(x T) { x.m(1.2, new(byte)) }`,
-			`x.m`,
-			[]string{`float64`, `byte`},
-			`func(float64, *byte, ...[]byte)`,
-		},
-
-		{`package r0; type T[P any] struct{}; func (_ T[P]) m[type Q](Q); func _[P any](x T[P]) { x.m(42) }`,
-			`x.m`,
-			[]string{`int`},
-			`func(int)`,
-		},
-		// TODO(gri) fix method type parameter syntax below
-		{`package r1; type T interface{ m(type P any)(P) }; func _(x T) { x.m(4.2) }`,
-			`x.m`,
-			[]string{`float64`},
-			`func(float64)`,
-		},
-
-		{`package s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
+		{genericPkg + `s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
 			`f`,
 			[]string{`string`, `*string`},
 			`func(x string)`,
 		},
-		{`package s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
+		{genericPkg + `s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
 			`f`,
 			[]string{`int`, `*int`},
 			`func(x []int)`,
 		},
-		{`package s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
+		{genericPkg + `s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
 			`f`,
 			[]string{`int`, `chan<- int`},
 			`func(x []int)`,
 		},
-		{`package s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
+		{genericPkg + `s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
 			`f`,
 			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
 			`func(x []int)`,
 		},
 
-		{`package t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
+		{genericPkg + `t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
 			`f`,
 			[]string{`string`, `*string`},
 			`func() string`,
 		},
-		{`package t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
+		{genericPkg + `t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
 			`f`,
 			[]string{`int`, `chan<- int`},
 			`func() []int`,
 		},
-		{`package t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
+		{genericPkg + `t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
 			`f`,
 			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
 			`func() []int`,
@@ -493,10 +465,10 @@
 
 		// generic types must be sanitized
 		// (need to use sufficiently nested types to provoke unexpanded types)
-		{`package g0; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`},
-		{`package g1; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`},
-		{`package g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`},
-		{`package g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var g3.g func(x struct{f g3.t[string]})`},
+		{genericPkg + `g0; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
+		{genericPkg + `g1; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
+		{genericPkg + `g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
+		{genericPkg + `g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var generic_g3.g func(x struct{f generic_g3.t[string]})`},
 	}
 
 	for _, test := range tests {
@@ -538,10 +510,10 @@
 
 		// generic types must be sanitized
 		// (need to use sufficiently nested types to provoke unexpanded types)
-		{`package g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`},
-		{`package g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`},
-		{`package g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`},
-		{`package g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func g3.f(x struct{f g3.t[string]})`},
+		{genericPkg + `g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
+		{genericPkg + `g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
+		{genericPkg + `g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
+		{genericPkg + `g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func generic_g3.f(x struct{f generic_g3.t[string]})`},
 	}
 
 	for _, test := range tests {
@@ -1501,6 +1473,50 @@
 	}
 }
 
+func TestConvertibleTo(t *testing.T) {
+	for _, test := range []struct {
+		v, t Type
+		want bool
+	}{
+		{Typ[Int], Typ[Int], true},
+		{Typ[Int], Typ[Float32], true},
+		{newDefined(Typ[Int]), Typ[Int], true},
+		{newDefined(new(Struct)), new(Struct), true},
+		{newDefined(Typ[Int]), new(Struct), false},
+		{Typ[UntypedInt], Typ[Int], true},
+		// Untyped string values are not permitted by the spec, so the below
+		// behavior is undefined.
+		{Typ[UntypedString], Typ[String], true},
+	} {
+		if got := ConvertibleTo(test.v, test.t); got != test.want {
+			t.Errorf("ConvertibleTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want)
+		}
+	}
+}
+
+func TestAssignableTo(t *testing.T) {
+	for _, test := range []struct {
+		v, t Type
+		want bool
+	}{
+		{Typ[Int], Typ[Int], true},
+		{Typ[Int], Typ[Float32], false},
+		{newDefined(Typ[Int]), Typ[Int], false},
+		{newDefined(new(Struct)), new(Struct), true},
+		{Typ[UntypedBool], Typ[Bool], true},
+		{Typ[UntypedString], Typ[Bool], false},
+		// Neither untyped string nor untyped numeric assignments arise during
+		// normal type checking, so the below behavior is technically undefined by
+		// the spec.
+		{Typ[UntypedString], Typ[String], true},
+		{Typ[UntypedInt], Typ[Int], true},
+	} {
+		if got := AssignableTo(test.v, test.t); got != test.want {
+			t.Errorf("AssignableTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want)
+		}
+	}
+}
+
 func TestIdentical_issue15173(t *testing.T) {
 	// Identical should allow nil arguments and be symmetric.
 	for _, test := range []struct {
diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index e9a1224..3aa06e8 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -26,7 +26,7 @@
 		// ok
 	default:
 		// we may get here because of other problems (issue #39634, crash 12)
-		check.errorf(x.pos(), "cannot assign %s to %s in %s", x, T, context)
+		check.errorf(x, 0, "cannot assign %s to %s in %s", x, T, context)
 		return
 	}
 
@@ -35,26 +35,44 @@
 		// spec: "If an untyped constant is assigned to a variable of interface
 		// type or the blank identifier, the constant is first converted to type
 		// bool, rune, int, float64, complex128 or string respectively, depending
-		// on whether the value is a boolean, rune, integer, floating-point, complex,
-		// or string constant."
+		// on whether the value is a boolean, rune, integer, floating-point,
+		// complex, or string constant."
 		if T == nil || IsInterface(T) {
 			if T == nil && x.typ == Typ[UntypedNil] {
-				check.errorf(x.pos(), "use of untyped nil in %s", context)
+				check.errorf(x, _UntypedNil, "use of untyped nil in %s", context)
 				x.mode = invalid
 				return
 			}
 			target = Default(x.typ)
 		}
-		check.convertUntyped(x, target)
-		if x.mode == invalid {
+		newType, val, code := check.implicitTypeAndValue(x, target)
+		if code != 0 {
+			msg := check.sprintf("cannot use %s as %s value in %s", x, target, context)
+			switch code {
+			case _TruncatedFloat:
+				msg += " (truncated)"
+			case _NumericOverflow:
+				msg += " (overflows)"
+			default:
+				code = _IncompatibleAssign
+			}
+			check.error(x, code, msg)
+			x.mode = invalid
 			return
 		}
+		if val != nil {
+			x.val = val
+			check.updateExprVal(x.expr, val)
+		}
+		if newType != x.typ {
+			x.typ = newType
+			check.updateExprType(x.expr, newType, false)
+		}
 	}
-	// x.typ is typed
 
 	// A generic (non-instantiated) function value cannot be assigned to a variable.
 	if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
-		check.errorf(x.pos(), "cannot use generic function %s without instantiation in %s", x, context)
+		check.errorf(x, _Todo, "cannot use generic function %s without instantiation in %s", x, context)
 	}
 
 	// spec: "If a left-hand side is the blank identifier, any typed or
@@ -64,11 +82,12 @@
 		return
 	}
 
-	if reason := ""; !x.assignableTo(check, T, &reason) {
+	reason := ""
+	if ok, code := x.assignableTo(check, T, &reason); !ok {
 		if reason != "" {
-			check.errorf(x.pos(), "cannot use %s as %s value in %s: %s", x, T, context, reason)
+			check.errorf(x, code, "cannot use %s as %s value in %s: %s", x, T, context, reason)
 		} else {
-			check.errorf(x.pos(), "cannot use %s as %s value in %s", x, T, context)
+			check.errorf(x, code, "cannot use %s as %s value in %s", x, T, context)
 		}
 		x.mode = invalid
 	}
@@ -84,7 +103,7 @@
 
 	// rhs must be a constant
 	if x.mode != constant_ {
-		check.errorf(x.pos(), "%s is not constant", x)
+		check.errorf(x, _InvalidConstInit, "%s is not constant", x)
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
@@ -119,7 +138,7 @@
 		if isUntyped(typ) {
 			// convert untyped types to default types
 			if typ == Typ[UntypedNil] {
-				check.errorf(x.pos(), "use of untyped nil in %s", context)
+				check.errorf(x, _UntypedNil, "use of untyped nil in %s", context)
 				lhs.typ = Typ[Invalid]
 				return nil
 			}
@@ -194,11 +213,11 @@
 			var op operand
 			check.expr(&op, sel.X)
 			if op.mode == mapindex {
-				check.errorf(z.pos(), "cannot assign to struct field %s in map", ExprString(z.expr))
+				check.errorf(&z, _UnaddressableFieldAssign, "cannot assign to struct field %s in map", ExprString(z.expr))
 				return nil
 			}
 		}
-		check.errorf(z.pos(), "cannot assign to %s", &z)
+		check.errorf(&z, _UnassignableOperand, "cannot assign to %s", &z)
 		return nil
 	}
 
@@ -212,8 +231,8 @@
 
 // If returnPos is valid, initVars is called to type-check the assignment of
 // return expressions, and returnPos is the position of the return statement.
-func (check *Checker) initVars(lhs []*Var, orig_rhs []ast.Expr, returnPos token.Pos) {
-	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2 && !returnPos.IsValid())
+func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.Pos) {
+	rhs, commaOk := check.exprList(origRHS, len(lhs) == 2 && !returnPos.IsValid())
 
 	if len(lhs) != len(rhs) {
 		// invalidate lhs
@@ -229,10 +248,10 @@
 			}
 		}
 		if returnPos.IsValid() {
-			check.errorf(returnPos, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
+			check.errorf(atPos(returnPos), _WrongResultCount, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
 			return
 		}
-		check.errorf(rhs[0].pos(), "cannot initialize %d variables with %d values", len(lhs), len(rhs))
+		check.errorf(rhs[0], _WrongAssignCount, "cannot initialize %d variables with %d values", len(lhs), len(rhs))
 		return
 	}
 
@@ -246,7 +265,7 @@
 		for i := range a {
 			a[i] = check.initVar(lhs[i], rhs[i], context)
 		}
-		check.recordCommaOkTypes(orig_rhs[0], a)
+		check.recordCommaOkTypes(origRHS[0], a)
 		return
 	}
 
@@ -255,8 +274,8 @@
 	}
 }
 
-func (check *Checker) assignVars(lhs, orig_rhs []ast.Expr) {
-	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2)
+func (check *Checker) assignVars(lhs, origRHS []ast.Expr) {
+	rhs, commaOk := check.exprList(origRHS, len(lhs) == 2)
 
 	if len(lhs) != len(rhs) {
 		check.useLHS(lhs...)
@@ -266,7 +285,7 @@
 				return
 			}
 		}
-		check.errorf(rhs[0].pos(), "cannot assign %d values to %d variables", len(rhs), len(lhs))
+		check.errorf(rhs[0], _WrongAssignCount, "cannot assign %d values to %d variables", len(rhs), len(lhs))
 		return
 	}
 
@@ -275,7 +294,7 @@
 		for i := range a {
 			a[i] = check.assignVar(lhs[i], rhs[i])
 		}
-		check.recordCommaOkTypes(orig_rhs[0], a)
+		check.recordCommaOkTypes(origRHS[0], a)
 		return
 	}
 
@@ -284,7 +303,7 @@
 	}
 }
 
-func (check *Checker) shortVarDecl(pos token.Pos, lhs, rhs []ast.Expr) {
+func (check *Checker) shortVarDecl(pos positioner, lhs, rhs []ast.Expr) {
 	top := len(check.delayed)
 	scope := check.scope
 
@@ -304,7 +323,7 @@
 				if alt, _ := alt.(*Var); alt != nil {
 					obj = alt
 				} else {
-					check.errorf(lhs.Pos(), "cannot assign to %s", lhs)
+					check.errorf(lhs, _UnassignableOperand, "cannot assign to %s", lhs)
 				}
 				check.recordUse(ident, alt)
 			} else {
@@ -317,7 +336,7 @@
 			}
 		} else {
 			check.useLHS(lhs)
-			check.errorf(lhs.Pos(), "cannot declare %s", lhs)
+			check.invalidAST(lhs, "cannot declare %s", lhs)
 		}
 		if obj == nil {
 			obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
@@ -341,6 +360,6 @@
 			check.declare(scope, nil, obj, scopePos) // recordObject already called
 		}
 	} else {
-		check.softErrorf(pos, "no new variables on left side of :=")
+		check.softErrorf(pos, _NoNewVar, "no new variables on left side of :=")
 	}
 }
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index d53a424..28697d9 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -21,7 +21,9 @@
 	// append is the only built-in that permits the use of ... for the last argument
 	bin := predeclaredFuncs[id]
 	if call.Ellipsis.IsValid() && id != _Append {
-		check.invalidOp(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)
+		check.invalidOp(atPos(call.Ellipsis),
+			_InvalidDotDotDot,
+			"invalid use of ... with built-in %s", bin.name)
 		check.use(call.Args...)
 		return
 	}
@@ -67,7 +69,7 @@
 			msg = "too many"
 		}
 		if msg != "" {
-			check.invalidOp(call.Rparen, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
+			check.invalidOp(inNode(call, call.Rparen), _WrongArgCount, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
 			return
 		}
 	}
@@ -84,7 +86,7 @@
 		if s := asSlice(S); s != nil {
 			T = s.elem
 		} else {
-			check.invalidArg(x.pos(), "%s is not a slice", x)
+			check.invalidArg(x, _InvalidAppend, "%s is not a slice", x)
 			return
 		}
 
@@ -94,23 +96,25 @@
 		// spec: "As a special case, append also accepts a first argument assignable
 		// to type []byte with a second argument of string type followed by ... .
 		// This form appends the bytes of the string.
-		if nargs == 2 && call.Ellipsis.IsValid() && x.assignableTo(check, NewSlice(universeByte), nil) {
-			arg(x, 1)
-			if x.mode == invalid {
-				return
-			}
-			if isString(x.typ) {
-				if check.Types != nil {
-					sig := makeSig(S, S, x.typ)
-					sig.variadic = true
-					check.recordBuiltinType(call.Fun, sig)
+		if nargs == 2 && call.Ellipsis.IsValid() {
+			if ok, _ := x.assignableTo(check, NewSlice(universeByte), nil); ok {
+				arg(x, 1)
+				if x.mode == invalid {
+					return
 				}
-				x.mode = value
-				x.typ = S
-				break
+				if isString(x.typ) {
+					if check.Types != nil {
+						sig := makeSig(S, S, x.typ)
+						sig.variadic = true
+						check.recordBuiltinType(call.Fun, sig)
+					}
+					x.mode = value
+					x.typ = S
+					break
+				}
+				alist = append(alist, *x)
+				// fallthrough
 			}
-			alist = append(alist, *x)
-			// fallthrough
 		}
 
 		// check general case by creating custom signature
@@ -196,7 +200,11 @@
 		}
 
 		if mode == invalid && typ != Typ[Invalid] {
-			check.invalidArg(x.pos(), "%s for %s", x, bin.name)
+			code := _InvalidCap
+			if id == _Len {
+				code = _InvalidLen
+			}
+			check.invalidArg(x, code, "%s for %s", x, bin.name)
 			return
 		}
 
@@ -211,11 +219,11 @@
 		// close(c)
 		c := asChan(x.typ)
 		if c == nil {
-			check.invalidArg(x.pos(), "%s is not a channel", x)
+			check.invalidArg(x, _InvalidClose, "%s is not a channel", x)
 			return
 		}
 		if c.dir == RecvOnly {
-			check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
+			check.invalidArg(x, _InvalidClose, "%s must not be a receive-only channel", x)
 			return
 		}
 
@@ -279,7 +287,7 @@
 
 		// both argument types must be identical
 		if !check.identical(x.typ, y.typ) {
-			check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
+			check.invalidArg(x, _InvalidComplex, "mismatched types %s and %s", x.typ, y.typ)
 			return
 		}
 
@@ -299,7 +307,7 @@
 		}
 		resTyp := check.applyTypeFunc(f, x.typ)
 		if resTyp == nil {
-			check.invalidArg(x.pos(), "arguments have type %s, expected floating-point", x.typ)
+			check.invalidArg(x, _InvalidComplex, "arguments have type %s, expected floating-point", x.typ)
 			return
 		}
 
@@ -339,12 +347,12 @@
 		}
 
 		if dst == nil || src == nil {
-			check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
+			check.invalidArg(x, _InvalidCopy, "copy expects slice arguments; found %s and %s", x, &y)
 			return
 		}
 
 		if !check.identical(dst, src) {
-			check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
+			check.invalidArg(x, _InvalidCopy, "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
 			return
 		}
 
@@ -358,7 +366,7 @@
 		// delete(m, k)
 		m := asMap(x.typ)
 		if m == nil {
-			check.invalidArg(x.pos(), "%s is not a map", x)
+			check.invalidArg(x, _InvalidDelete, "%s is not a map", x)
 			return
 		}
 		arg(x, 1) // k
@@ -366,8 +374,8 @@
 			return
 		}
 
-		if !x.assignableTo(check, m.key, nil) {
-			check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key)
+		if ok, code := x.assignableTo(check, m.key, nil); !ok {
+			check.invalidArg(x, code, "%s is not assignable to %s", x, m.key)
 			return
 		}
 
@@ -417,7 +425,11 @@
 		}
 		resTyp := check.applyTypeFunc(f, x.typ)
 		if resTyp == nil {
-			check.invalidArg(x.pos(), "argument has type %s, expected complex type", x.typ)
+			code := _InvalidImag
+			if id == _Real {
+				code = _InvalidReal
+			}
+			check.invalidArg(x, code, "argument has type %s, expected complex type", x.typ)
 			return
 		}
 
@@ -472,14 +484,14 @@
 		}
 
 		if !valid(T) {
-			check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0)
+			check.invalidArg(arg0, _InvalidMake, "cannot make %s; type must be slice, map, or channel", arg0)
 			return
 		}
 		if nargs < min || max < nargs {
 			if min == max {
-				check.errorf(call.Pos(), "%v expects %d arguments; found %d", call, min, nargs)
+				check.errorf(call, _WrongArgCount, "%v expects %d arguments; found %d", call, min, nargs)
 			} else {
-				check.errorf(call.Pos(), "%v expects %d or %d arguments; found %d", call, min, max, nargs)
+				check.errorf(call, _WrongArgCount, "%v expects %d or %d arguments; found %d", call, min, max, nargs)
 			}
 			return
 		}
@@ -494,7 +506,7 @@
 			}
 		}
 		if len(sizes) == 2 && sizes[0] > sizes[1] {
-			check.invalidArg(call.Args[1].Pos(), "length and capacity swapped")
+			check.invalidArg(call.Args[1], _SwappedMakeArgs, "length and capacity swapped")
 			// safe to continue
 		}
 		x.mode = value
@@ -577,7 +589,7 @@
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
-			check.invalidOp(call.Pos(), "unsafe.Alignof undefined for %s", x)
+			check.invalidOp(call, _Todo, "unsafe.Alignof undefined for %s", x)
 			return
 		}
 		check.assignment(x, nil, "argument to unsafe.Alignof")
@@ -596,7 +608,7 @@
 		arg0 := call.Args[0]
 		selx, _ := unparen(arg0).(*ast.SelectorExpr)
 		if selx == nil {
-			check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0)
+			check.invalidArg(arg0, _BadOffsetofSyntax, "%s is not a selector expression", arg0)
 			check.use(arg0)
 			return
 		}
@@ -611,18 +623,18 @@
 		obj, index, indirect := check.lookupFieldOrMethod(base, false, check.pkg, sel)
 		switch obj.(type) {
 		case nil:
-			check.invalidArg(x.pos(), "%s has no single field %s", base, sel)
+			check.invalidArg(x, _MissingFieldOrMethod, "%s has no single field %s", base, sel)
 			return
 		case *Func:
 			// TODO(gri) Using derefStructPtr may result in methods being found
 			// that don't actually exist. An error either way, but the error
 			// message is confusing. See: https://play.golang.org/p/al75v23kUy ,
 			// but go/types reports: "invalid argument: x.m is a method value".
-			check.invalidArg(arg0.Pos(), "%s is a method value", arg0)
+			check.invalidArg(arg0, _InvalidOffsetof, "%s is a method value", arg0)
 			return
 		}
 		if indirect {
-			check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base)
+			check.invalidArg(x, _InvalidOffsetof, "field %s is embedded via a pointer in %s", sel, base)
 			return
 		}
 
@@ -638,7 +650,7 @@
 	case _Sizeof:
 		// unsafe.Sizeof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
-			check.invalidOp(call.Pos(), "unsafe.Sizeof undefined for %s", x)
+			check.invalidOp(call, _Todo, "unsafe.Sizeof undefined for %s", x)
 			return
 		}
 		check.assignment(x, nil, "argument to unsafe.Sizeof")
@@ -656,15 +668,15 @@
 		// The result of assert is the value of pred if there is no error.
 		// Note: assert is only available in self-test mode.
 		if x.mode != constant_ || !isBoolean(x.typ) {
-			check.invalidArg(x.pos(), "%s is not a boolean constant", x)
+			check.invalidArg(x, _Test, "%s is not a boolean constant", x)
 			return
 		}
 		if x.val.Kind() != constant.Bool {
-			check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
+			check.errorf(x, _Test, "internal error: value of %s should be a boolean constant", x)
 			return
 		}
 		if !constant.BoolVal(x.val) {
-			check.errorf(call.Pos(), "%v failed", call)
+			check.errorf(call, _Test, "%v failed", call)
 			// compile-time assertion failure - safe to continue
 		}
 		// result is constant - no need to record signature
@@ -684,7 +696,7 @@
 		x1 := x
 		for _, arg := range call.Args {
 			check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
-			check.dump("%v: %s", x1.pos(), x1)
+			check.dump("%v: %s", x1.Pos(), x1)
 			x1 = &t // use incoming x only for first argument
 		}
 		// trace is only available in test mode - no need to record signature
@@ -720,7 +732,7 @@
 
 		// construct a suitable new type parameter
 		tpar := NewTypeName(token.NoPos, nil /* = Universe pkg */, "<type parameter>", nil)
-		ptyp := check.NewTypeParam(tp.ptr, tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
+		ptyp := check.NewTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
 		tsum := NewSum(rtypes)
 		ptyp.bound = &Interface{types: tsum, allMethods: markComplete, allTypes: tsum}
 
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 267c463..d9a7b44 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -1,3 +1,4 @@
+// REVIEW INCOMPLETE
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
@@ -13,6 +14,7 @@
 	"unicode"
 )
 
+// TODO(rFindley) this has diverged a bit from types2. Bring it up to date.
 // If call == nil, the "call" was an index expression, and orig is of type *ast.IndexExpr.
 func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKind {
 	assert(orig != nil)
@@ -49,14 +51,18 @@
 		// conversion
 		switch n := len(call.Args); n {
 		case 0:
-			check.errorf(call.Rparen, "missing argument in conversion to %s", T)
+			check.errorf(inNode(call, call.Rparen), _WrongArgCount, "missing argument in conversion to %s", T)
 		case 1:
 			check.expr(x, call.Args[0])
 			if x.mode != invalid {
+				if call.Ellipsis.IsValid() {
+					check.errorf(call.Args[0], _BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T)
+					break
+				}
 				if t := asInterface(T); t != nil {
 					check.completeInterface(token.NoPos, t)
 					if t.IsConstraint() {
-						check.errorf(call.Pos(), "cannot use interface %s in conversion (contains type list or is comparable)", T)
+						check.errorf(call, _Todo, "cannot use interface %s in conversion (contains type list or is comparable)", T)
 						break
 					}
 				}
@@ -64,7 +70,7 @@
 			}
 		default:
 			check.use(call.Args...)
-			check.errorf(call.Args[n-1].Pos(), "too many arguments in conversion to %s", T)
+			check.errorf(call.Args[n-1], _WrongArgCount, "too many arguments in conversion to %s", T)
 		}
 		x.expr = orig
 		return conversion
@@ -87,7 +93,7 @@
 
 		sig := asSignature(x.typ)
 		if sig == nil {
-			check.invalidOp(x.pos(), "cannot call non-function %s", x)
+			check.invalidOp(x, _InvalidCall, "cannot call non-function %s", x)
 			x.mode = invalid
 			x.expr = orig
 			return statement
@@ -96,7 +102,7 @@
 		// evaluate arguments
 		args, ok := check.exprOrTypeList(call.Args)
 		if ok && call.Brackets && len(args) > 0 && args[0].mode != typexpr {
-			check.errorf(args[0].pos(), "%s is not a type", args[0])
+			check.errorf(args[0], _NotAType, "%s is not a type", args[0])
 			ok = false
 		}
 		if !ok {
@@ -110,8 +116,8 @@
 			// If the first argument is a type, assume we have explicit type arguments.
 
 			// check number of type arguments
-			if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
-				check.errorf(args[n-1].pos(), "got %d type arguments but want %d", n, len(sig.tparams))
+			if n > len(sig.tparams) {
+				check.errorf(args[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
 				x.mode = invalid
 				x.expr = orig
 				return expression
@@ -119,6 +125,8 @@
 
 			// collect types
 			targs := make([]Type, n)
+			// TODO(rFindley) use a positioner here? instantiate would need to be
+			//                updated accordingly.
 			poslist := make([]token.Pos, n)
 			for i, a := range args {
 				if a.mode != typexpr {
@@ -128,7 +136,7 @@
 					return expression
 				}
 				targs[i] = a.typ
-				poslist[i] = a.pos()
+				poslist[i] = a.Pos()
 			}
 
 			// if we don't have enough type arguments, use constraint type inference
@@ -147,7 +155,7 @@
 					assert(targs[failed] == nil)
 					tpar := sig.tparams[failed]
 					ppos := check.fset.Position(tpar.pos).String()
-					check.errorf(call.Rparen, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
+					check.errorf(inNode(call, call.Rparen), 0, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
 					x.mode = invalid
 					x.expr = orig
 					return expression
@@ -158,7 +166,6 @@
 						assert(targ != nil)
 					}
 				}
-				//check.dump("### inferred targs = %s", targs)
 				n = len(targs)
 				inferred = true
 			}
@@ -171,9 +178,9 @@
 				if i < len(poslist) {
 					pos = poslist[i]
 				}
-				check.ordinaryType(pos, typ)
+				check.ordinaryType(atPos(pos), typ)
 			}
-			res := check.instantiate(x.pos(), sig, targs, poslist).(*Signature)
+			res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
 			assert(res.tparams == nil) // signature is not generic anymore
 			if inferred {
 				check.recordInferred(orig, targs, res)
@@ -184,7 +191,11 @@
 			return expression
 		}
 
-		// If we reach here, orig must have been a regular call, not an index expression.
+		// If we reach here, orig must have been a regular call, not an index
+		// expression.
+		// TODO(rFindley) with a manually constructed AST it is possible to reach
+		//                this assertion. We should return an invalidAST error here
+		//                rather than panicking.
 		assert(!call.Brackets)
 
 		sig = check.arguments(call, sig, args)
@@ -262,7 +273,7 @@
 			}
 		}
 		if 0 < ntypes && ntypes < len(xlist) {
-			check.errorf(xlist[0].pos(), "mix of value and type expressions")
+			check.errorf(xlist[0], 0, "mix of value and type expressions")
 			ok = false
 		}
 	}
@@ -293,7 +304,11 @@
 		xlist = []*operand{&x}
 		if allowCommaOk && (x.mode == mapindex || x.mode == commaok || x.mode == commaerr) {
 			x.mode = value
-			xlist = append(xlist, &operand{mode: value, expr: e, typ: Typ[UntypedBool]})
+			x2 := &operand{mode: value, expr: e, typ: Typ[UntypedBool]}
+			if x.mode == commaerr {
+				x2.typ = universeError
+			}
+			xlist = append(xlist, x2)
 			commaOk = true
 		}
 
@@ -317,7 +332,7 @@
 	for _, a := range args {
 		switch a.mode {
 		case typexpr:
-			check.errorf(a.pos(), "%s used as value", a)
+			check.errorf(a, 0, "%s used as value", a)
 			return
 		case invalid:
 			return
@@ -338,14 +353,14 @@
 	ddd := call.Ellipsis.IsValid()
 
 	// set up parameters
-	sig_params := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)
-	adjusted := false        // indicates if sig_params is different from t.params
+	sigParams := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)
+	adjusted := false       // indicates if sigParams is different from t.params
 	if sig.variadic {
 		if ddd {
 			// variadic_func(a, b, c...)
 			if len(call.Args) == 1 && nargs > 1 {
 				// f()... is not permitted if f() is multi-valued
-				check.errorf(call.Ellipsis, "cannot use ... with %d-valued %s", nargs, call.Args[0])
+				check.errorf(inNode(call, call.Ellipsis), _InvalidDotDotDot, "cannot use ... with %d-valued %s", nargs, call.Args[0])
 				return
 			}
 		} else {
@@ -361,7 +376,7 @@
 				for len(vars) < nargs {
 					vars = append(vars, NewParam(last.pos, last.pkg, last.name, typ))
 				}
-				sig_params = NewTuple(vars...) // possibly nil!
+				sigParams = NewTuple(vars...) // possibly nil!
 				adjusted = true
 				npars = nargs
 			} else {
@@ -372,7 +387,7 @@
 	} else {
 		if ddd {
 			// standard_func(a, b, c...)
-			check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", call.Fun)
+			check.errorf(inNode(call, call.Ellipsis), _NonVariadicDotDotDot, "cannot use ... in call to non-variadic %s", call.Fun)
 			return
 		}
 		// standard_func(a, b, c)
@@ -381,10 +396,10 @@
 	// check argument count
 	switch {
 	case nargs < npars:
-		check.errorf(call.Rparen, "not enough arguments in call to %s", call.Fun)
+		check.errorf(inNode(call, call.Rparen), _WrongArgCount, "not enough arguments in call to %s", call.Fun)
 		return
 	case nargs > npars:
-		check.errorf(args[npars].pos(), "too many arguments in call to %s", call.Fun) // report at first extra argument
+		check.errorf(args[npars], _WrongArgCount, "too many arguments in call to %s", call.Fun) // report at first extra argument
 		return
 	}
 
@@ -392,25 +407,23 @@
 	if len(sig.tparams) > 0 {
 		// TODO(gri) provide position information for targs so we can feed
 		//           it to the instantiate call for better error reporting
-		targs, failed := check.infer(sig.tparams, sig_params, args)
+		targs, failed := check.infer(sig.tparams, sigParams, args)
 		if targs == nil {
 			return // error already reported
 		}
 		if failed >= 0 {
 			// Some type arguments couldn't be inferred. Use
 			// bounds type inference to try to make progress.
-			if check.conf.InferFromConstraints {
-				targs, failed = check.inferB(sig.tparams, targs)
-				if targs == nil {
-					return // error already reported
-				}
+			targs, failed = check.inferB(sig.tparams, targs)
+			if targs == nil {
+				return // error already reported
 			}
 			if failed >= 0 {
 				// at least one type argument couldn't be inferred
 				assert(targs[failed] == nil)
 				tpar := sig.tparams[failed]
 				ppos := check.fset.Position(tpar.pos).String()
-				check.errorf(call.Rparen, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
+				check.errorf(inNode(call, call.Rparen), _Todo, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
 				return
 			}
 		}
@@ -420,7 +433,6 @@
 				assert(targ != nil)
 			}
 		}
-		//check.dump("### inferred targs = %s", targs)
 
 		// compute result signature
 		rsig = check.instantiate(call.Pos(), sig, targs, nil).(*Signature)
@@ -431,9 +443,9 @@
 		// need to compute it from the adjusted list; otherwise we can
 		// simply use the result signature's parameter list.
 		if adjusted {
-			sig_params = check.subst(call.Pos(), sig_params, makeSubstMap(sig.tparams, targs)).(*Tuple)
+			sigParams = check.subst(call.Pos(), sigParams, makeSubstMap(sig.tparams, targs)).(*Tuple)
 		} else {
-			sig_params = rsig.params
+			sigParams = rsig.params
 		}
 	}
 
@@ -441,7 +453,7 @@
 	// TODO(gri) Possible optimization (may be tricky): We could avoid
 	//           checking arguments from which we inferred type arguments.
 	for i, a := range args {
-		check.assignment(a, sig_params.vars[i].typ, "argument")
+		check.assignment(a, sigParams.vars[i].typ, check.sprintf("argument to %s", call.Fun))
 	}
 
 	return
@@ -499,7 +511,7 @@
 					}
 				}
 				if exp == nil {
-					check.errorf(e.Sel.Pos(), "%s not declared by package C", sel)
+					check.errorf(e.Sel, _UndeclaredImportedName, "%s not declared by package C", sel)
 					goto Error
 				}
 				check.objDecl(exp, nil)
@@ -507,12 +519,12 @@
 				exp = pkg.scope.Lookup(sel)
 				if exp == nil {
 					if !pkg.fake {
-						check.errorf(e.Sel.Pos(), "%s not declared by package %s", sel, pkg.name)
+						check.errorf(e.Sel, _UndeclaredImportedName, "%s not declared by package %s", sel, pkg.name)
 					}
 					goto Error
 				}
 				if !exp.Exported() {
-					check.errorf(e.Sel.Pos(), "%s not exported by package %s", sel, pkg.name)
+					check.errorf(e.Sel, _UnexportedName, "%s not exported by package %s", sel, pkg.name)
 					// ok to continue
 				}
 			}
@@ -567,9 +579,9 @@
 		switch {
 		case index != nil:
 			// TODO(gri) should provide actual type where the conflict happens
-			check.errorf(e.Sel.Pos(), "ambiguous selector %s.%s", x.expr, sel)
+			check.errorf(e.Sel, _AmbiguousSelector, "ambiguous selector %s.%s", x.expr, sel)
 		case indirect:
-			check.errorf(e.Sel.Pos(), "cannot call pointer method %s on %s", sel, x.typ)
+			check.errorf(e.Sel, _InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ)
 		default:
 			var why string
 			if tpar := asTypeParam(x.typ); tpar != nil {
@@ -597,15 +609,13 @@
 				}
 			}
 
-			check.errorf(e.Sel.Pos(), "%s.%s undefined (%s)", x.expr, sel, why)
-
+			check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why)
 		}
 		goto Error
 	}
 
 	// methods may not have a fully set up signature yet
 	if m, _ := obj.(*Func); m != nil {
-		// check.dump("### found method %s", m)
 		check.objDecl(m, nil)
 		// If m has a parameterized receiver type, infer the type parameter
 		// values from the actual receiver provided and then substitute the
@@ -613,8 +623,6 @@
 		// TODO(gri) factor this code out
 		sig := m.typ.(*Signature)
 		if len(sig.rparams) > 0 {
-			//check.dump("### recv typ = %s", x.typ)
-			//check.dump("### method = %s rparams = %s tparams = %s", m, sig.rparams, sig.tparams)
 			// The method may have a pointer receiver, but the actually provided receiver
 			// may be a (hopefully addressable) non-pointer value, or vice versa. Here we
 			// only care about inferring receiver type parameters; to make the inference
@@ -630,7 +638,6 @@
 				arg = &copy
 			}
 			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{arg})
-			//check.dump("### inferred targs = %s", targs)
 			if failed >= 0 {
 				// We may reach here if there were other errors (see issue #40056).
 				// check.infer will report a follow-up error.
@@ -654,7 +661,7 @@
 		m, _ := obj.(*Func)
 		if m == nil {
 			// TODO(gri) should check if capitalization of sel matters and provide better error message in that case
-			check.errorf(e.Sel.Pos(), "%s.%s undefined (type %s has no method %s)", x.expr, sel, x.typ, sel)
+			check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (type %s has no method %s)", x.expr, sel, x.typ, sel)
 			goto Error
 		}
 
@@ -814,7 +821,7 @@
 // instantiatedOperand reports an error of x is an uninstantiated (generic) type and sets x.typ to Typ[Invalid].
 func (check *Checker) instantiatedOperand(x *operand) {
 	if x.mode == typexpr && isGeneric(x.typ) {
-		check.errorf(x.pos(), "cannot use generic type %s without instantiation", x.typ)
+		check.errorf(x, _Todo, "cannot use generic type %s without instantiation", x.typ)
 		x.typ = Typ[Invalid]
 	}
 }
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 5238e5a..d167283 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -8,14 +8,16 @@
 
 import (
 	"errors"
-	"fmt"
 	"go/ast"
 	"go/constant"
 	"go/token"
 )
 
 // debugging/development support
-const debug = true // leave on during development
+const (
+	debug = false // leave on during development
+	trace = false // turn on for detailed type resolution traces
+)
 
 // If forceStrict is set, the type-checker enforces additional
 // rules not specified by the Go 1 spec, but which will
@@ -30,11 +32,6 @@
 //
 const forceStrict = false
 
-// If methodTypeParamsOk is set, type parameters are
-// permitted in method declarations (in interfaces, too).
-// Generalization and experimental feature.
-const methodTypeParamsOk = true
-
 // exprInfo stores information about an untyped expression.
 type exprInfo struct {
 	isLhs bool // expression is lhs operand of a shift with delayed type-check
@@ -49,6 +46,7 @@
 	scope         *Scope                 // top-most scope for lookups
 	pos           token.Pos              // if valid, identifiers are looked up as if at position pos (used by Eval)
 	iota          constant.Value         // value of iota in a constant declaration; nil otherwise
+	errpos        positioner             // if set, identifier position of a constant with inherited initializer
 	sig           *Signature             // function signature if inside a function; nil otherwise
 	isPanic       map[*ast.CallExpr]bool // set of panic call expressions (used for termination check)
 	hasLabel      bool                   // set if a function makes use of labels (only ~1% of functions); unused outside functions
@@ -90,9 +88,8 @@
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
 	// maps and lists are allocated on demand)
-	files            []*ast.File                       // package files
-	unusedDotImports map[*Scope]map[*Package]token.Pos // positions of unused dot-imported packages for each file scope
-	useBrackets      bool                              // if set, [] are used instead of () for type parameters
+	files            []*ast.File                             // package files
+	unusedDotImports map[*Scope]map[*Package]*ast.ImportSpec // unused dot-imported packages
 
 	firstErr error                 // first error encountered
 	methods  map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
@@ -111,18 +108,18 @@
 
 // addUnusedImport adds the position of a dot-imported package
 // pkg to the map of dot imports for the given file scope.
-func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, pos token.Pos) {
+func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, spec *ast.ImportSpec) {
 	mm := check.unusedDotImports
 	if mm == nil {
-		mm = make(map[*Scope]map[*Package]token.Pos)
+		mm = make(map[*Scope]map[*Package]*ast.ImportSpec)
 		check.unusedDotImports = mm
 	}
 	m := mm[scope]
 	if m == nil {
-		m = make(map[*Package]token.Pos)
+		m = make(map[*Package]*ast.ImportSpec)
 		mm[scope] = m
 	}
-	m[pkg] = pos
+	m[pkg] = spec
 }
 
 // addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
@@ -225,7 +222,7 @@
 			if name != "_" {
 				pkg.name = name
 			} else {
-				check.errorf(file.Name.Pos(), "invalid package name _")
+				check.errorf(file.Name, _BlankPkgName, "invalid package name _")
 			}
 			fallthrough
 
@@ -233,7 +230,7 @@
 			check.files = append(check.files, file)
 
 		default:
-			check.errorf(file.Package, "package %s; expected %s", name, pkg.name)
+			check.errorf(atPos(file.Package), _MismatchedPkgName, "package %s; expected %s", name, pkg.name)
 			// ignore this file
 		}
 	}
@@ -265,49 +262,24 @@
 
 	defer check.handleBailout(&err)
 
-	print := func(msg string) {
-		if check.conf.Trace {
-			fmt.Println(msg)
-		}
-	}
-
-	print("=== check consistent use of () or [] for type parameters ===")
-	if len(files) > 0 {
-		check.useBrackets = files[0].UseBrackets
-		for _, file := range files[1:] {
-			if check.useBrackets != file.UseBrackets {
-				check.errorf(file.Package, "inconsistent use of () or [] for type parameters")
-				return // cannot type-check properly
-			}
-		}
-	}
-
-	print("== initFiles ==")
 	check.initFiles(files)
 
-	print("== collectObjects ==")
 	check.collectObjects()
 
-	print("== packageObjects ==")
 	check.packageObjects()
 
-	print("== processDelayed ==")
 	check.processDelayed(0) // incl. all functions
 	check.processFinals()
 
-	print("== initOrder ==")
 	check.initOrder()
 
 	if !check.conf.DisableUnusedImportCheck {
-		print("== unusedImports ==")
 		check.unusedImports()
 	}
 
-	print("== recordUntyped ==")
 	check.recordUntyped()
 
 	if check.Info != nil {
-		print("== sanitizeInfo ==")
 		sanitizeInfo(check.Info)
 	}
 
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 08fc784..c6a8c3b 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -67,11 +67,11 @@
 	return
 }
 
-func parseFiles(t *testing.T, filenames []string) ([]*ast.File, []error) {
+func parseFiles(t *testing.T, filenames []string, mode parser.Mode) ([]*ast.File, []error) {
 	var files []*ast.File
 	var errlist []error
 	for _, filename := range filenames {
-		file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors|parser.UnifiedParamLists)
+		file, err := parser.ParseFile(fset, filename, nil, mode)
 		if file == nil {
 			t.Fatalf("%s: %s", filename, err)
 		}
@@ -189,9 +189,18 @@
 	}
 }
 
-func checkFiles(t *testing.T, sources []string, trace bool) {
+func checkFiles(t *testing.T, sources []string) {
+	if len(sources) == 0 {
+		t.Fatal("no source files")
+	}
+
+	mode := parser.AllErrors
+	if strings.HasSuffix(sources[0], ".go2") {
+		mode |= parser.ParseTypeParams
+	}
+
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, sources)
+	files, errlist := parseFiles(t, sources, mode)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
@@ -207,16 +216,14 @@
 
 	// typecheck and collect typechecker errors
 	var conf Config
-	conf.AcceptMethodTypeParams = true
-	conf.InferFromConstraints = true
+
 	// special case for importC.src
 	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
 		conf.FakeImportC = true
 	}
-	conf.Trace = trace
-	// We don't use importer.Default() below so we can eventually
-	// get testdata/map.go2 to import chans (still to be fixed).
-	conf.Importer = importer.ForCompiler(fset, "source", nil)
+	// TODO(rFindley) we may need to use the source importer when adding generics
+	// tests.
+	conf.Importer = importer.Default()
 	conf.Error = func(err error) {
 		if *haltOnError {
 			defer panic(err)
@@ -237,6 +244,17 @@
 		return
 	}
 
+	for _, err := range errlist {
+		err, ok := err.(Error)
+		if !ok {
+			continue
+		}
+		code := readCode(err)
+		if code == 0 {
+			t.Errorf("missing error code: %v", err)
+		}
+	}
+
 	// match and eliminate errors;
 	// we are expecting the following errors
 	errmap := errMap(t, pkgName, files)
@@ -260,7 +278,7 @@
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	checkFiles(t, strings.Split(*testFiles, " "), testing.Verbose())
+	checkFiles(t, strings.Split(*testFiles, " "))
 }
 
 func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
@@ -276,20 +294,18 @@
 		return
 	}
 
-	for count, fi := range fis {
+	for _, fi := range fis {
 		path := filepath.Join(dir, fi.Name())
 
 		// if fi is a directory, its files make up a single package
+		var files []string
 		if fi.IsDir() {
-			if testing.Verbose() {
-				fmt.Printf("%3d %s\n", count, path)
-			}
 			fis, err := ioutil.ReadDir(path)
 			if err != nil {
 				t.Error(err)
 				continue
 			}
-			files := make([]string, len(fis))
+			files = make([]string, len(fis))
 			for i, fi := range fis {
 				// if fi is a directory, checkFiles below will complain
 				files[i] = filepath.Join(path, fi.Name())
@@ -297,14 +313,11 @@
 					fmt.Printf("\t%s\n", files[i])
 				}
 			}
-			checkFiles(t, files, false)
-			continue
+		} else {
+			files = []string{path}
 		}
-
-		// otherwise, fi is a stand-alone file
-		if testing.Verbose() {
-			fmt.Printf("%3d %s\n", count, path)
-		}
-		checkFiles(t, []string{path}, false)
+		t.Run(filepath.Base(path), func(t *testing.T) {
+			checkFiles(t, files)
+		})
 	}
 }
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 9d9e9d7..0756b57 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -38,7 +38,7 @@
 	}
 
 	if !ok {
-		check.errorf(x.pos(), "cannot convert %s to %s", x, T)
+		check.errorf(x, _InvalidConversion, "cannot convert %s to %s", x, T)
 		x.mode = invalid
 		return
 	}
@@ -81,7 +81,7 @@
 // exported API call, i.e., when all methods have been type-checked.
 func (x *operand) convertibleTo(check *Checker, T Type) bool {
 	// "x is assignable to T"
-	if x.assignableTo(check, T, nil) {
+	if ok, _ := x.assignableTo(check, T, nil); ok {
 		return true
 	}
 
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 1292ee2..bd2c546 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -16,7 +16,7 @@
 		// We use "other" rather than "previous" here because
 		// the first declaration seen may not be textually
 		// earlier in the source.
-		check.errorf(pos, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
+		check.errorf(obj, _DuplicateDecl, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
 	}
 }
 
@@ -27,7 +27,7 @@
 	// binding."
 	if obj.Name() != "_" {
 		if alt := scope.Insert(obj); alt != nil {
-			check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
+			check.errorf(obj, _DuplicateDecl, "%s redeclared in this block", obj.Name())
 			check.reportAltDecl(alt)
 			return
 		}
@@ -53,7 +53,7 @@
 // objDecl type-checks the declaration of obj in its respective (file) context.
 // For the meaning of def, see Checker.definedType, in typexpr.go.
 func (check *Checker) objDecl(obj Object, def *Named) {
-	if check.conf.Trace && obj.Type() == nil {
+	if trace && obj.Type() == nil {
 		if check.indent == 0 {
 			fmt.Println() // empty line between top-level objects for readability
 		}
@@ -187,7 +187,7 @@
 	switch obj := obj.(type) {
 	case *Const:
 		check.decl = d // new package-level const decl
-		check.constDecl(obj, d.vtyp, d.init)
+		check.constDecl(obj, d.vtyp, d.init, d.inherited)
 	case *Var:
 		check.decl = d // new package-level var decl
 		check.varDecl(obj, d.lhs, d.vtyp, d.init)
@@ -253,7 +253,7 @@
 		}
 	}
 
-	if check.conf.Trace {
+	if trace {
 		check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle))
 		check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef)
 		defer func() {
@@ -323,7 +323,7 @@
 		}
 
 		// don't report a 2nd error if we already know the type is invalid
-		// (e.g., if a cycle was detected earlier, via Checker.underlying).
+		// (e.g., if a cycle was detected earlier, via under).
 		if t.underlying == Typ[Invalid] {
 			t.info = invalid
 			return invalid
@@ -364,16 +364,16 @@
 	//           cycle? That would be more consistent with other error messages.
 	i := firstInSrc(cycle)
 	obj := cycle[i]
-	check.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name())
+	check.errorf(obj, _InvalidDeclCycle, "illegal cycle in declaration of %s", obj.Name())
 	for range cycle {
-		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
+		check.errorf(obj, _InvalidDeclCycle, "\t%s refers to", obj.Name()) // secondary error, \t indented
 		i++
 		if i >= len(cycle) {
 			i = 0
 		}
 		obj = cycle[i]
 	}
-	check.errorf(obj.Pos(), "\t%s", obj.Name())
+	check.errorf(obj, _InvalidDeclCycle, "\t%s", obj.Name())
 }
 
 // firstInSrc reports the index of the object with the "smallest"
@@ -388,12 +388,90 @@
 	return fst
 }
 
-func (check *Checker) constDecl(obj *Const, typ, init ast.Expr) {
+type (
+	decl interface {
+		node() ast.Node
+	}
+
+	importDecl struct{ spec *ast.ImportSpec }
+	constDecl  struct {
+		spec      *ast.ValueSpec
+		iota      int
+		typ       ast.Expr
+		init      []ast.Expr
+		inherited bool
+	}
+	varDecl  struct{ spec *ast.ValueSpec }
+	typeDecl struct{ spec *ast.TypeSpec }
+	funcDecl struct{ decl *ast.FuncDecl }
+)
+
+func (d importDecl) node() ast.Node { return d.spec }
+func (d constDecl) node() ast.Node  { return d.spec }
+func (d varDecl) node() ast.Node    { return d.spec }
+func (d typeDecl) node() ast.Node   { return d.spec }
+func (d funcDecl) node() ast.Node   { return d.decl }
+
+func (check *Checker) walkDecls(decls []ast.Decl, f func(decl)) {
+	for _, d := range decls {
+		check.walkDecl(d, f)
+	}
+}
+
+func (check *Checker) walkDecl(d ast.Decl, f func(decl)) {
+	switch d := d.(type) {
+	case *ast.BadDecl:
+		// ignore
+	case *ast.GenDecl:
+		var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
+		for iota, s := range d.Specs {
+			switch s := s.(type) {
+			case *ast.ImportSpec:
+				f(importDecl{s})
+			case *ast.ValueSpec:
+				switch d.Tok {
+				case token.CONST:
+					// determine which initialization expressions to use
+					inherited := true
+					switch {
+					case s.Type != nil || len(s.Values) > 0:
+						last = s
+						inherited = false
+					case last == nil:
+						last = new(ast.ValueSpec) // make sure last exists
+						inherited = false
+					}
+					check.arityMatch(s, last)
+					f(constDecl{spec: s, iota: iota, typ: last.Type, init: last.Values, inherited: inherited})
+				case token.VAR:
+					check.arityMatch(s, nil)
+					f(varDecl{s})
+				default:
+					check.invalidAST(s, "invalid token %s", d.Tok)
+				}
+			case *ast.TypeSpec:
+				f(typeDecl{s})
+			default:
+				check.invalidAST(s, "unknown ast.Spec node %T", s)
+			}
+		}
+	case *ast.FuncDecl:
+		f(funcDecl{d})
+	default:
+		check.invalidAST(d, "unknown ast.Decl node %T", d)
+	}
+}
+
+func (check *Checker) constDecl(obj *Const, typ, init ast.Expr, inherited bool) {
 	assert(obj.typ == nil)
 
 	// use the correct value of iota
-	defer func(iota constant.Value) { check.iota = iota }(check.iota)
+	defer func(iota constant.Value, errpos positioner) {
+		check.iota = iota
+		check.errpos = errpos
+	}(check.iota, check.errpos)
 	check.iota = obj.val
+	check.errpos = nil
 
 	// provide valid constant value under all circumstances
 	obj.val = constant.MakeUnknown()
@@ -405,7 +483,7 @@
 			// don't report an error if the type is an invalid C (defined) type
 			// (issue #22090)
 			if under(t) != Typ[Invalid] {
-				check.errorf(typ.Pos(), "invalid constant type %s", t)
+				check.errorf(typ, _InvalidConstType, "invalid constant type %s", t)
 			}
 			obj.typ = Typ[Invalid]
 			return
@@ -416,6 +494,15 @@
 	// check initialization
 	var x operand
 	if init != nil {
+		if inherited {
+			// The initialization expression is inherited from a previous
+			// constant declaration, and (error) positions refer to that
+			// expression and not the current constant declaration. Use
+			// the constant identifier position for any errors during
+			// init expression evaluation since that is all we have
+			// (see issues #42991, #42992).
+			check.errpos = atPos(obj.pos)
+		}
 		check.expr(&x, init)
 	}
 	check.initConst(obj, &x)
@@ -520,6 +607,8 @@
 
 		if i, ok := seen[n]; ok {
 			// cycle
+			// TODO(rFindley) revert this to a method on Checker. Having a possibly
+			// nil Checker on Named and TypeParam is too subtle.
 			if n0.check != nil {
 				n0.check.cycleError(path[i:])
 			}
@@ -559,7 +648,7 @@
 	if alias && tdecl.TParams != nil {
 		// The parser will ensure this but we may still get an invalid AST.
 		// Complain and continue as regular type definition.
-		check.errorf(tdecl.Assign, "generic type cannot be alias")
+		check.error(atPos(tdecl.Assign), 0, "generic type cannot be alias")
 		alias = false
 	}
 
@@ -631,19 +720,11 @@
 			goto next
 		}
 
-		// If the type bound expects exactly one type argument, permit leaving
-		// it away and use the corresponding type parameter as implicit argument.
-		// This allows us to write (type p b(p), q b(q), r b(r)) as (type p, q, r b).
-		// Enabled if enableImplicitTParam is set.
-		const enableImplicitTParam = false
-
 		// The predeclared identifier "any" is visible only as a constraint
 		// in a type parameter list. Look for it before general constraint
 		// resolution.
 		if tident, _ := f.Type.(*ast.Ident); tident != nil && tident.Name == "any" && check.lookup("any") == nil {
 			bound = universeAny
-		} else if enableImplicitTParam {
-			bound = check.anyType(f.Type)
 		} else {
 			bound = check.typ(f.Type)
 		}
@@ -654,47 +735,12 @@
 		//           type C(type T C) interface {}
 		//           (issue #39724).
 		if _, ok := under(bound).(*Interface); ok {
-			if enableImplicitTParam && isGeneric(bound) {
-				base := bound.(*Named) // only a *Named type can be generic
-				if len(base.tparams) != 1 {
-					check.errorf(f.Type.Pos(), "cannot use generic type %s without instantiation (more than one type parameter)", bound)
-					goto next
-				}
-				// We have exactly one type parameter.
-				// "Manually" instantiate the bound with each type
-				// parameter the bound applies to.
-				// TODO(gri) this code (in more general form) is also in
-				// checker.typInternal for the *ast.CallExpr case. Factor?
-				for i, name := range f.Names {
-					typ := new(instance)
-					typ.check = check
-					typ.pos = f.Type.Pos()
-					typ.base = base
-					typ.targs = []Type{tparams[index+i].typ}
-					typ.poslist = []token.Pos{name.Pos()}
-					// Make sure we check instantiation works at least once
-					// and that the resulting type is valid.
-					check.atEnd(func() {
-						check.validType(typ.expand(), nil)
-					})
-					// Set bound for each type parameter and record type.
-					setBoundAt(index+i, typ)
-					// We don't have a mechanism to record multiple different types
-					// for a single type bound expression. Just do it for the first
-					// type parameter for now.
-					// TODO(gri) investigate what we need to do here
-					if i == 0 {
-						check.recordTypeAndValue(f.Type, typexpr, typ, nil)
-					}
-				}
-				goto next
-			}
 			// Otherwise, set the bound for each type parameter.
-			for i, _ := range f.Names {
+			for i := range f.Names {
 				setBoundAt(index+i, bound)
 			}
 		} else if bound != Typ[Invalid] {
-			check.errorf(f.Type.Pos(), "%s is not an interface", bound)
+			check.errorf(f.Type, _Todo, "%s is not an interface", bound)
 		}
 
 	next:
@@ -706,19 +752,13 @@
 
 func (check *Checker) declareTypeParams(tparams []*TypeName, names []*ast.Ident) []*TypeName {
 	for _, name := range names {
-		var ptr bool
-		nstr := name.Name
-		if len(nstr) > 0 && nstr[0] == '*' {
-			ptr = true
-			nstr = nstr[1:]
-		}
-		tpar := NewTypeName(name.Pos(), check.pkg, nstr, nil)
-		check.NewTypeParam(ptr, tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
-		check.declare(check.scope, name, tpar, check.scope.pos)      // TODO(gri) check scope position
+		tpar := NewTypeName(name.Pos(), check.pkg, name.Name, nil)
+		check.NewTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
+		check.declare(check.scope, name, tpar, check.scope.pos) // TODO(gri) check scope position
 		tparams = append(tparams, tpar)
 	}
 
-	if check.conf.Trace && len(names) > 0 {
+	if trace && len(names) > 0 {
 		check.trace(names[0].Pos(), "type params = %v", tparams[len(tparams)-len(names):])
 	}
 
@@ -769,9 +809,9 @@
 		if alt := mset.insert(m); alt != nil {
 			switch alt.(type) {
 			case *Var:
-				check.errorf(m.pos, "field and method with the same name %s", m.name)
+				check.errorf(m, _DuplicateFieldAndMethod, "field and method with the same name %s", m.name)
 			case *Func:
-				check.errorf(m.pos, "method %s already declared for %s", m.name, obj)
+				check.errorf(m, _DuplicateMethod, "method %s already declared for %s", m.name, obj)
 			default:
 				unreachable()
 			}
@@ -815,133 +855,105 @@
 	}
 }
 
-func (check *Checker) declStmt(decl ast.Decl) {
+func (check *Checker) declStmt(d ast.Decl) {
 	pkg := check.pkg
 
-	switch d := decl.(type) {
-	case *ast.BadDecl:
-		// ignore
+	check.walkDecl(d, func(d decl) {
+		switch d := d.(type) {
+		case constDecl:
+			top := len(check.delayed)
 
-	case *ast.GenDecl:
-		var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
-		for iota, spec := range d.Specs {
-			switch s := spec.(type) {
-			case *ast.ValueSpec:
-				switch d.Tok {
-				case token.CONST:
-					top := len(check.delayed)
+			// declare all constants
+			lhs := make([]*Const, len(d.spec.Names))
+			for i, name := range d.spec.Names {
+				obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(d.iota)))
+				lhs[i] = obj
 
-					// determine which init exprs to use
-					switch {
-					case s.Type != nil || len(s.Values) > 0:
-						last = s
-					case last == nil:
-						last = new(ast.ValueSpec) // make sure last exists
-					}
-
-					// declare all constants
-					lhs := make([]*Const, len(s.Names))
-					for i, name := range s.Names {
-						obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(iota)))
-						lhs[i] = obj
-
-						var init ast.Expr
-						if i < len(last.Values) {
-							init = last.Values[i]
-						}
-
-						check.constDecl(obj, last.Type, init)
-					}
-
-					check.arityMatch(s, last)
-
-					// process function literals in init expressions before scope changes
-					check.processDelayed(top)
-
-					// spec: "The scope of a constant or variable identifier declared
-					// inside a function begins at the end of the ConstSpec or VarSpec
-					// (ShortVarDecl for short variable declarations) and ends at the
-					// end of the innermost containing block."
-					scopePos := s.End()
-					for i, name := range s.Names {
-						check.declare(check.scope, name, lhs[i], scopePos)
-					}
-
-				case token.VAR:
-					top := len(check.delayed)
-
-					lhs0 := make([]*Var, len(s.Names))
-					for i, name := range s.Names {
-						lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil)
-					}
-
-					// initialize all variables
-					for i, obj := range lhs0 {
-						var lhs []*Var
-						var init ast.Expr
-						switch len(s.Values) {
-						case len(s.Names):
-							// lhs and rhs match
-							init = s.Values[i]
-						case 1:
-							// rhs is expected to be a multi-valued expression
-							lhs = lhs0
-							init = s.Values[0]
-						default:
-							if i < len(s.Values) {
-								init = s.Values[i]
-							}
-						}
-						check.varDecl(obj, lhs, s.Type, init)
-						if len(s.Values) == 1 {
-							// If we have a single lhs variable we are done either way.
-							// If we have a single rhs expression, it must be a multi-
-							// valued expression, in which case handling the first lhs
-							// variable will cause all lhs variables to have a type
-							// assigned, and we are done as well.
-							if debug {
-								for _, obj := range lhs0 {
-									assert(obj.typ != nil)
-								}
-							}
-							break
-						}
-					}
-
-					check.arityMatch(s, nil)
-
-					// process function literals in init expressions before scope changes
-					check.processDelayed(top)
-
-					// declare all variables
-					// (only at this point are the variable scopes (parents) set)
-					scopePos := s.End() // see constant declarations
-					for i, name := range s.Names {
-						// see constant declarations
-						check.declare(check.scope, name, lhs0[i], scopePos)
-					}
-
-				default:
-					check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
+				var init ast.Expr
+				if i < len(d.init) {
+					init = d.init[i]
 				}
 
-			case *ast.TypeSpec:
-				obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
-				// spec: "The scope of a type identifier declared inside a function
-				// begins at the identifier in the TypeSpec and ends at the end of
-				// the innermost containing block."
-				scopePos := s.Name.Pos()
-				check.declare(check.scope, s.Name, obj, scopePos)
-				// mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
-				obj.setColor(grey + color(check.push(obj)))
-				check.typeDecl(obj, s, nil)
-				check.pop().setColor(black)
-			default:
-				check.invalidAST(s.Pos(), "const, type, or var declaration expected")
+				check.constDecl(obj, d.typ, init, d.inherited)
 			}
-		}
 
-	default:
-		check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
-	}
+			// process function literals in init expressions before scope changes
+			check.processDelayed(top)
+
+			// spec: "The scope of a constant or variable identifier declared
+			// inside a function begins at the end of the ConstSpec or VarSpec
+			// (ShortVarDecl for short variable declarations) and ends at the
+			// end of the innermost containing block."
+			scopePos := d.spec.End()
+			for i, name := range d.spec.Names {
+				check.declare(check.scope, name, lhs[i], scopePos)
+			}
+
+		case varDecl:
+			top := len(check.delayed)
+
+			lhs0 := make([]*Var, len(d.spec.Names))
+			for i, name := range d.spec.Names {
+				lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil)
+			}
+
+			// initialize all variables
+			for i, obj := range lhs0 {
+				var lhs []*Var
+				var init ast.Expr
+				switch len(d.spec.Values) {
+				case len(d.spec.Names):
+					// lhs and rhs match
+					init = d.spec.Values[i]
+				case 1:
+					// rhs is expected to be a multi-valued expression
+					lhs = lhs0
+					init = d.spec.Values[0]
+				default:
+					if i < len(d.spec.Values) {
+						init = d.spec.Values[i]
+					}
+				}
+				check.varDecl(obj, lhs, d.spec.Type, init)
+				if len(d.spec.Values) == 1 {
+					// If we have a single lhs variable we are done either way.
+					// If we have a single rhs expression, it must be a multi-
+					// valued expression, in which case handling the first lhs
+					// variable will cause all lhs variables to have a type
+					// assigned, and we are done as well.
+					if debug {
+						for _, obj := range lhs0 {
+							assert(obj.typ != nil)
+						}
+					}
+					break
+				}
+			}
+
+			// process function literals in init expressions before scope changes
+			check.processDelayed(top)
+
+			// declare all variables
+			// (only at this point are the variable scopes (parents) set)
+			scopePos := d.spec.End() // see constant declarations
+			for i, name := range d.spec.Names {
+				// see constant declarations
+				check.declare(check.scope, name, lhs0[i], scopePos)
+			}
+
+		case typeDecl:
+			obj := NewTypeName(d.spec.Name.Pos(), pkg, d.spec.Name.Name, nil)
+			// spec: "The scope of a type identifier declared inside a function
+			// begins at the identifier in the TypeSpec and ends at the end of
+			// the innermost containing block."
+			scopePos := d.spec.Name.Pos()
+			check.declare(check.scope, d.spec.Name, obj, scopePos)
+			// mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
+			obj.setColor(grey + color(check.push(obj)))
+			check.typeDecl(obj, d.spec, nil)
+			check.pop().setColor(black)
+		default:
+			check.invalidAST(d.node(), "unknown ast.Decl node %T", d.node())
+		}
+	})
 }
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index e4c8311..7e62091 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -753,52 +753,12 @@
 	_NonVariadicDotDotDot
 
 	// _MisplacedDotDotDot occurs when a "..." is used somewhere other than the
-	// final argument to a function call.
+	// final argument in a function declaration.
 	//
 	// Example:
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	a := []int{1,2,3}
-	//  	printArgs(0, a...)
-	//  }
+	// 	func f(...int, int)
 	_MisplacedDotDotDot
 
-	// _InvalidDotDotDotOperand occurs when a "..." operator is applied to a
-	// single-valued operand.
-	//
-	// Example:
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	a := 1
-	//  	printArgs(a...)
-	//  }
-	//
-	// Example:
-	//  func args() (int, int) {
-	//  	return 1, 2
-	//  }
-	//
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func g() {
-	//  	printArgs(args()...)
-	//  }
-	_InvalidDotDotDotOperand
-
 	// _InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
 	// function.
 	//
@@ -1078,18 +1038,6 @@
 	//  }
 	_InvalidPostDecl
 
-	// _InvalidChanRange occurs when a send-only channel used in a range
-	// expression.
-	//
-	// Example:
-	//  func sum(c chan<- int) {
-	//  	s := 0
-	//  	for i := range c {
-	//  		s += i
-	//  	}
-	//  }
-	_InvalidChanRange
-
 	// _InvalidIterVar occurs when two iteration variables are used while ranging
 	// over a channel.
 	//
@@ -1207,6 +1155,16 @@
 	//  }
 	_InvalidTypeSwitch
 
+	// _InvalidExprSwitch occurs when a switch expression is not comparable.
+	//
+	// Example:
+	//  func _() {
+	//  	var a struct{ _ func() }
+	//  	switch a /* ERROR cannot switch on a */ {
+	//  	}
+	//  }
+	_InvalidExprSwitch
+
 	/* control flow > select */
 
 	// _InvalidSelectCase occurs when a select case is not a channel send or
@@ -1353,4 +1311,8 @@
 	//  	return i
 	//  }
 	_InvalidGo
+
+	// _Todo is a placeholder for error codes that have not been decided.
+	// TODO(rFindley) remove this error code after deciding on errors for generics code.
+	_Todo
 )
diff --git a/src/go/types/errorcodes_test.go b/src/go/types/errorcodes_test.go
new file mode 100644
index 0000000..5da1cda
--- /dev/null
+++ b/src/go/types/errorcodes_test.go
@@ -0,0 +1,197 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strings"
+	"testing"
+
+	. "go/types"
+)
+
+func TestErrorCodeExamples(t *testing.T) {
+	walkCodes(t, func(name string, value int, spec *ast.ValueSpec) {
+		t.Run(name, func(t *testing.T) {
+			doc := spec.Doc.Text()
+			examples := strings.Split(doc, "Example:")
+			for i := 1; i < len(examples); i++ {
+				example := examples[i]
+				err := checkExample(t, example)
+				if err == nil {
+					t.Fatalf("no error in example #%d", i)
+				}
+				typerr, ok := err.(Error)
+				if !ok {
+					t.Fatalf("not a types.Error: %v", err)
+				}
+				if got := readCode(typerr); got != value {
+					t.Errorf("%s: example #%d returned code %d (%s), want %d", name, i, got, err, value)
+				}
+			}
+		})
+	})
+}
+
+func walkCodes(t *testing.T, f func(string, int, *ast.ValueSpec)) {
+	t.Helper()
+	fset := token.NewFileSet()
+	files, err := pkgFiles(fset, ".", parser.ParseComments) // from self_test.go
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := Config{Importer: importer.Default()}
+	info := &Info{
+		Types: make(map[ast.Expr]TypeAndValue),
+		Defs:  make(map[*ast.Ident]Object),
+		Uses:  make(map[*ast.Ident]Object),
+	}
+	_, err = conf.Check("types", fset, files, info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, file := range files {
+		for _, decl := range file.Decls {
+			decl, ok := decl.(*ast.GenDecl)
+			if !ok || decl.Tok != token.CONST {
+				continue
+			}
+			for _, spec := range decl.Specs {
+				spec, ok := spec.(*ast.ValueSpec)
+				if !ok || len(spec.Names) == 0 {
+					continue
+				}
+				obj := info.ObjectOf(spec.Names[0])
+				if named, ok := obj.Type().(*Named); ok && named.Obj().Name() == "errorCode" {
+					if len(spec.Names) != 1 {
+						t.Fatalf("bad Code declaration for %q: got %d names, want exactly 1", spec.Names[0].Name, len(spec.Names))
+					}
+					codename := spec.Names[0].Name
+					value := int(constant.Val(obj.(*Const).Val()).(int64))
+					f(codename, value, spec)
+				}
+			}
+		}
+	}
+}
+
+func readCode(err Error) int {
+	v := reflect.ValueOf(err)
+	return int(v.FieldByName("go116code").Int())
+}
+
+func checkExample(t *testing.T, example string) error {
+	t.Helper()
+	fset := token.NewFileSet()
+	src := fmt.Sprintf("package p\n\n%s", example)
+	file, err := parser.ParseFile(fset, "example.go", src, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := Config{
+		FakeImportC: true,
+		Importer:    importer.Default(),
+	}
+	_, err = conf.Check("example", fset, []*ast.File{file}, nil)
+	return err
+}
+
+func TestErrorCodeStyle(t *testing.T) {
+	// The set of error codes is large and intended to be self-documenting, so
+	// this test enforces some style conventions.
+	forbiddenInIdent := []string{
+		// use invalid instead
+		"illegal",
+		// words with a common short-form
+		"argument",
+		"assertion",
+		"assignment",
+		"boolean",
+		"channel",
+		"condition",
+		"declaration",
+		"expression",
+		"function",
+		"initial", // use init for initializer, initialization, etc.
+		"integer",
+		"interface",
+		"iterat", // use iter for iterator, iteration, etc.
+		"literal",
+		"operation",
+		"package",
+		"pointer",
+		"receiver",
+		"signature",
+		"statement",
+		"variable",
+	}
+	forbiddenInComment := []string{
+		// lhs and rhs should be spelled-out.
+		"lhs", "rhs",
+		// builtin should be hyphenated.
+		"builtin",
+		// Use dot-dot-dot.
+		"ellipsis",
+	}
+	nameHist := make(map[int]int)
+	longestName := ""
+	maxValue := 0
+
+	walkCodes(t, func(name string, value int, spec *ast.ValueSpec) {
+		if name == "_" {
+			return
+		}
+		nameHist[len(name)]++
+		if value > maxValue {
+			maxValue = value
+		}
+		if len(name) > len(longestName) {
+			longestName = name
+		}
+		if token.IsExported(name) {
+			// This is an experimental API, and errorCode values should not be
+			// exported.
+			t.Errorf("%q is exported", name)
+		}
+		if name[0] != '_' || !token.IsExported(name[1:]) {
+			t.Errorf("%q should start with _, followed by an exported identifier", name)
+		}
+		lower := strings.ToLower(name)
+		for _, bad := range forbiddenInIdent {
+			if strings.Contains(lower, bad) {
+				t.Errorf("%q contains forbidden word %q", name, bad)
+			}
+		}
+		doc := spec.Doc.Text()
+		if !strings.HasPrefix(doc, name) {
+			t.Errorf("doc for %q does not start with identifier", name)
+		}
+		lowerComment := strings.ToLower(strings.TrimPrefix(doc, name))
+		for _, bad := range forbiddenInComment {
+			if strings.Contains(lowerComment, bad) {
+				t.Errorf("doc for %q contains forbidden word %q", name, bad)
+			}
+		}
+	})
+
+	if testing.Verbose() {
+		var totChars, totCount int
+		for chars, count := range nameHist {
+			totChars += chars * count
+			totCount += count
+		}
+		avg := float64(totChars) / float64(totCount)
+		fmt.Println()
+		fmt.Printf("%d error codes\n", totCount)
+		fmt.Printf("average length: %.2f chars\n", avg)
+		fmt.Printf("max length: %d (%s)\n", len(longestName), longestName)
+	}
+}
diff --git a/src/go/types/errors.go b/src/go/types/errors.go
index 92ba8de..a956256 100644
--- a/src/go/types/errors.go
+++ b/src/go/types/errors.go
@@ -7,6 +7,7 @@
 package types
 
 import (
+	"errors"
 	"fmt"
 	"go/ast"
 	"go/token"
@@ -72,22 +73,48 @@
 	fmt.Println(check.sprintf(format, args...))
 }
 
-func (check *Checker) err(pos token.Pos, msg string, soft bool) {
+func (check *Checker) err(err error) {
+	if err == nil {
+		return
+	}
+	var e Error
+	isInternal := errors.As(err, &e)
 	// Cheap trick: Don't report errors with messages containing
 	// "invalid operand" or "invalid type" as those tend to be
 	// follow-on errors which don't add useful information. Only
 	// exclude them if these strings are not at the beginning,
 	// and only if we have at least one error already reported.
-	if check.firstErr != nil && (strings.Index(msg, "invalid operand") > 0 || strings.Index(msg, "invalid type") > 0) {
+	isInvalidErr := isInternal && (strings.Index(e.Msg, "invalid operand") > 0 || strings.Index(e.Msg, "invalid type") > 0)
+	if check.firstErr != nil && isInvalidErr {
 		return
 	}
 
-	err := Error{check.fset, pos, stripAnnotations(msg), msg, soft}
+	if isInternal {
+		e.Msg = stripAnnotations(e.Msg)
+		if check.errpos != nil {
+			// If we have an internal error and the errpos override is set, use it to
+			// augment our error positioning.
+			// TODO(rFindley) we may also want to augment the error message and refer
+			// to the position (pos) in the original expression.
+			span := spanOf(check.errpos)
+			e.Pos = span.pos
+			e.go116start = span.start
+			e.go116end = span.end
+		}
+		err = e
+	}
+
 	if check.firstErr == nil {
 		check.firstErr = err
 	}
 
-	if check.conf.Trace {
+	if trace {
+		pos := e.Pos
+		msg := e.Msg
+		if !isInternal {
+			msg = err.Error()
+			pos = token.NoPos
+		}
 		check.trace(pos, "ERROR: %s", msg)
 	}
 
@@ -98,28 +125,108 @@
 	f(err)
 }
 
-func (check *Checker) error(pos token.Pos, msg string) {
-	check.err(pos, msg, false)
+func (check *Checker) newError(at positioner, code errorCode, soft bool, msg string) error {
+	span := spanOf(at)
+	return Error{
+		Fset:       check.fset,
+		Pos:        span.pos,
+		Msg:        msg,
+		Soft:       soft,
+		go116code:  code,
+		go116start: span.start,
+		go116end:   span.end,
+	}
 }
 
-func (check *Checker) errorf(pos token.Pos, format string, args ...interface{}) {
-	check.err(pos, check.sprintf(format, args...), false)
+// newErrorf creates a new Error, but does not handle it.
+func (check *Checker) newErrorf(at positioner, code errorCode, soft bool, format string, args ...interface{}) error {
+	msg := check.sprintf(format, args...)
+	return check.newError(at, code, soft, msg)
 }
 
-func (check *Checker) softErrorf(pos token.Pos, format string, args ...interface{}) {
-	check.err(pos, check.sprintf(format, args...), true)
+func (check *Checker) error(at positioner, code errorCode, msg string) {
+	check.err(check.newError(at, code, false, msg))
 }
 
-func (check *Checker) invalidAST(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid AST: "+format, args...)
+func (check *Checker) errorf(at positioner, code errorCode, format string, args ...interface{}) {
+	check.error(at, code, check.sprintf(format, args...))
 }
 
-func (check *Checker) invalidArg(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid argument: "+format, args...)
+func (check *Checker) softErrorf(at positioner, code errorCode, format string, args ...interface{}) {
+	check.err(check.newErrorf(at, code, true, format, args...))
 }
 
-func (check *Checker) invalidOp(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid operation: "+format, args...)
+func (check *Checker) invalidAST(at positioner, format string, args ...interface{}) {
+	check.errorf(at, 0, "invalid AST: "+format, args...)
+}
+
+func (check *Checker) invalidArg(at positioner, code errorCode, format string, args ...interface{}) {
+	check.errorf(at, code, "invalid argument: "+format, args...)
+}
+
+func (check *Checker) invalidOp(at positioner, code errorCode, format string, args ...interface{}) {
+	check.errorf(at, code, "invalid operation: "+format, args...)
+}
+
+// The positioner interface is used to extract the position of type-checker
+// errors.
+type positioner interface {
+	Pos() token.Pos
+}
+
+// posSpan holds a position range along with a highlighted position within that
+// range. This is used for positioning errors, with pos by convention being the
+// first position in the source where the error is known to exist, and start
+// and end defining the full span of syntax being considered when the error was
+// detected. Invariant: start <= pos < end || start == pos == end.
+type posSpan struct {
+	start, pos, end token.Pos
+}
+
+func (e posSpan) Pos() token.Pos {
+	return e.pos
+}
+
+// inNode creates a posSpan for the given node.
+// Invariant: node.Pos() <= pos < node.End() (node.End() is the position of the
+// first byte after node within the source).
+func inNode(node ast.Node, pos token.Pos) posSpan {
+	start, end := node.Pos(), node.End()
+	if debug {
+		assert(start <= pos && pos < end)
+	}
+	return posSpan{start, pos, end}
+}
+
+// atPos wraps a token.Pos to implement the positioner interface.
+type atPos token.Pos
+
+func (s atPos) Pos() token.Pos {
+	return token.Pos(s)
+}
+
+// spanOf extracts an error span from the given positioner. By default this is
+// the trivial span starting and ending at pos, but this span is expanded when
+// the argument naturally corresponds to a span of source code.
+func spanOf(at positioner) posSpan {
+	switch x := at.(type) {
+	case nil:
+		panic("internal error: nil")
+	case posSpan:
+		return x
+	case ast.Node:
+		pos := x.Pos()
+		return posSpan{pos, pos, x.End()}
+	case *operand:
+		if x.expr != nil {
+			pos := x.Pos()
+			return posSpan{pos, pos, x.expr.End()}
+		}
+		return posSpan{token.NoPos, token.NoPos, token.NoPos}
+	default:
+		pos := at.Pos()
+		return posSpan{pos, pos, pos}
+	}
 }
 
 // stripAnnotations removes internal (type) annotations from s.
diff --git a/src/go/types/examples/methods.go2 b/src/go/types/examples/methods.go2
index 95ff872..c294627 100644
--- a/src/go/types/examples/methods.go2
+++ b/src/go/types/examples/methods.go2
@@ -39,7 +39,7 @@
 // and usually should be avoided. There are some notable exceptions; e.g.,
 // sometimes it makes sense to use the identifier "copy" which happens to
 // also be the name of a predeclared built-in function.
-func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot convert 42 .* to int */ }
+func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot use 42 .* as int */ }
 
 // The names of the type parameters used in a parameterized receiver
 // type don't have to match the type parameter names in the the declaration
diff --git a/src/go/types/examples/types.go2 b/src/go/types/examples/types.go2
index 9808f9c..5aa624c 100644
--- a/src/go/types/examples/types.go2
+++ b/src/go/types/examples/types.go2
@@ -150,24 +150,12 @@
 // (7/14/2020: See comment above. We probably will revert this generalized ability
 // if we go with [] for type parameters.)
 type _ struct {
-	(int8)
-	(*int16)
-	*(int32)
-	(*(int64))
-	(((*(int))))
-	(*(List[int]))
+	int8
+	*int16
+	*List[int]
 
 	int8 /* ERROR int8 redeclared */
-	int /* ERROR int redeclared */
 	* /* ERROR List redeclared */ List[int]
-
-	( /* ERROR invalid embedded field type */ [10]int)
-	( /* ERROR invalid embedded field type */ []int)
-	( /* ERROR invalid embedded field type */ struct{})
-	( /* ERROR invalid embedded field type */ map[int]string)
-	( /* ERROR invalid embedded field type */ chan<- int)
-	( /* ERROR invalid embedded field type */ interface{})
-	( /* ERROR invalid embedded field type */ func())
 }
 
 // It's possible to declare local types whose underlying types
@@ -275,4 +263,4 @@
 func _() {
 	var _ comparable /* ERROR comparable */
 	var _ C /* ERROR comparable */
-}
\ No newline at end of file
+}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 62e24da..1deda99 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1,3 +1,4 @@
+// REVIEW INCOMPLETE
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
@@ -73,11 +74,11 @@
 func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
 	if pred := m[op]; pred != nil {
 		if !pred(x.typ) {
-			check.invalidOp(x.pos(), "operator %s not defined for %s", op, x)
+			check.invalidOp(x, _UndefinedOp, "operator %s not defined for %s", op, x)
 			return false
 		}
 	} else {
-		check.invalidAST(x.pos(), "unknown operator %s", op)
+		check.invalidAST(x, "unknown operator %s", op)
 		return false
 	}
 	return true
@@ -90,7 +91,7 @@
 		// spec: "As an exception to the addressability
 		// requirement x may also be a composite literal."
 		if _, ok := unparen(x.expr).(*ast.CompositeLit); !ok && x.mode != variable {
-			check.invalidOp(x.pos(), "cannot take address of %s", x)
+			check.invalidOp(x, _UnaddressableOperand, "cannot take address of %s", x)
 			x.mode = invalid
 			return
 		}
@@ -101,12 +102,12 @@
 	case token.ARROW:
 		typ := asChan(x.typ)
 		if typ == nil {
-			check.invalidOp(x.pos(), "cannot receive from non-channel %s", x)
+			check.invalidOp(x, _InvalidReceive, "cannot receive from non-channel %s", x)
 			x.mode = invalid
 			return
 		}
 		if typ.dir == SendOnly {
-			check.invalidOp(x.pos(), "cannot receive from send-only channel %s", x)
+			check.invalidOp(x, _InvalidReceive, "cannot receive from send-only channel %s", x)
 			x.mode = invalid
 			return
 		}
@@ -334,11 +335,21 @@
 	return false
 }
 
-// representable checks that a constant operand is representable in the given basic type.
+// representable checks that a constant operand is representable in the given
+// basic type.
 func (check *Checker) representable(x *operand, typ *Basic) {
+	if v, code := check.representation(x, typ); code != 0 {
+		check.invalidConversion(code, x, typ)
+		x.mode = invalid
+	} else if v != nil {
+		x.val = v
+	}
+}
+
+func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, errorCode) {
 	assert(x.mode == constant_)
-	if !representableConst(x.val, check, typ, &x.val) {
-		var msg string
+	v := x.val
+	if !representableConst(x.val, check, typ, &v) {
 		if isNumeric(x.typ) && isNumeric(typ) {
 			// numeric conversion : error msg
 			//
@@ -348,16 +359,25 @@
 			// float   -> float   : overflows
 			//
 			if !isInteger(x.typ) && isInteger(typ) {
-				msg = "%s truncated to %s"
+				return nil, _TruncatedFloat
 			} else {
-				msg = "%s overflows %s"
+				return nil, _NumericOverflow
 			}
-		} else {
-			msg = "cannot convert %s to %s"
 		}
-		check.errorf(x.pos(), msg, x, typ)
-		x.mode = invalid
+		return nil, _InvalidConstVal
 	}
+	return v, 0
+}
+
+func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) {
+	msg := "cannot convert %s to %s"
+	switch code {
+	case _TruncatedFloat:
+		msg = "%s truncated to %s"
+	case _NumericOverflow:
+		msg = "%s overflows %s"
+	}
+	check.errorf(x, code, msg, x, target)
 }
 
 // updateExprType updates the type of x to typ and invokes itself
@@ -463,7 +483,7 @@
 		// We already know from the shift check that it is representable
 		// as an integer if it is a constant.
 		if !isInteger(typ) {
-			check.invalidOp(x.Pos(), "shifted operand %s (type %s) must be integer", x, typ)
+			check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ)
 			return
 		}
 		// Even if we have an integer, if the value is a constant we
@@ -493,13 +513,30 @@
 
 // convertUntyped attempts to set the type of an untyped value to the target type.
 func (check *Checker) convertUntyped(x *operand, target Type) {
-	target = expand(target)
-	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
+	newType, val, code := check.implicitTypeAndValue(x, target)
+	if code != 0 {
+		check.invalidConversion(code, x, target.Underlying())
+		x.mode = invalid
 		return
 	}
+	if val != nil {
+		x.val = val
+		check.updateExprVal(x.expr, val)
+	}
+	if newType != x.typ {
+		x.typ = newType
+		check.updateExprType(x.expr, newType, false)
+	}
+}
 
-	// TODO(gri) Sloppy code - clean up. This function is central
-	//           to assignment and expression checking.
+// implicitTypeAndValue returns the implicit type of x when used in a context
+// where the target type is expected. If no such implicit conversion is
+// possible, it returns a nil Type.
+func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, errorCode) {
+	target = expand(target)
+	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
+		return x.typ, nil, 0
+	}
 
 	if isUntyped(target) {
 		// both x and target are untyped
@@ -507,138 +544,98 @@
 		tkind := target.(*Basic).kind
 		if isNumeric(x.typ) && isNumeric(target) {
 			if xkind < tkind {
-				x.typ = target
-				check.updateExprType(x.expr, target, false)
+				return target, nil, 0
 			}
 		} else if xkind != tkind {
-			goto Error
+			return nil, nil, _InvalidUntypedConversion
 		}
-		return
+		return x.typ, nil, 0
 	}
 
-	// In case of a type parameter, conversion must succeed against
-	// all types enumerated by the type parameter bound.
-	// TODO(gri) We should not need this because we have the code
-	// for Sum types in convertUntypedInternal. But at least one
-	// test fails. Investigate.
-	if t := asTypeParam(target); t != nil {
-		types := t.Bound().allTypes
-		if types == nil {
-			goto Error
-		}
-
-		for _, t := range unpack(types) {
-			check.convertUntypedInternal(x, t)
-			if x.mode == invalid {
-				goto Error
-			}
-		}
-
-		// keep nil untyped (was bug #39755)
-		if x.isNil() {
-			target = Typ[UntypedNil]
-		}
-		x.typ = target
-		check.updateExprType(x.expr, target, true) // UntypedNils are final
-		return
-	}
-
-	check.convertUntypedInternal(x, target)
-	return
-
-Error:
-	// TODO(gri) better error message (explain cause)
-	check.errorf(x.pos(), "cannot convert %s to %s", x, target)
-	x.mode = invalid
-}
-
-// convertUntypedInternal should only be called by convertUntyped.
-func (check *Checker) convertUntypedInternal(x *operand, target Type) {
-	assert(isTyped(target))
-
-	// typed target
 	switch t := optype(target).(type) {
 	case *Basic:
 		if x.mode == constant_ {
-			check.representable(x, t)
-			if x.mode == invalid {
-				return
+			v, code := check.representation(x, t)
+			if code != 0 {
+				return nil, nil, code
 			}
-			// expression value may have been rounded - update if needed
-			check.updateExprVal(x.expr, x.val)
-		} else {
-			// Non-constant untyped values may appear as the
-			// result of comparisons (untyped bool), intermediate
-			// (delayed-checked) rhs operands of shifts, and as
-			// the value nil.
-			switch x.typ.(*Basic).kind {
-			case UntypedBool:
-				if !isBoolean(target) {
-					goto Error
-				}
-			case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
-				if !isNumeric(target) {
-					goto Error
-				}
-			case UntypedString:
-				// Non-constant untyped string values are not
-				// permitted by the spec and should not occur.
-				unreachable()
-			case UntypedNil:
-				// Unsafe.Pointer is a basic type that includes nil.
-				if !hasNil(target) {
-					goto Error
-				}
-			default:
-				goto Error
+			return target, v, code
+		}
+		// Non-constant untyped values may appear as the
+		// result of comparisons (untyped bool), intermediate
+		// (delayed-checked) rhs operands of shifts, and as
+		// the value nil.
+		switch x.typ.(*Basic).kind {
+		case UntypedBool:
+			if !isBoolean(target) {
+				return nil, nil, _InvalidUntypedConversion
 			}
+		case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
+			if !isNumeric(target) {
+				return nil, nil, _InvalidUntypedConversion
+			}
+		case UntypedString:
+			// Non-constant untyped string values are not permitted by the spec and
+			// should not occur during normal typechecking passes, but this path is
+			// reachable via the AssignableTo API.
+			if !isString(target) {
+				return nil, nil, _InvalidUntypedConversion
+			}
+		case UntypedNil:
+			// Unsafe.Pointer is a basic type that includes nil.
+			if !hasNil(target) {
+				return nil, nil, _InvalidUntypedConversion
+			}
+			// TODO(rFindley) return UntypedNil here (golang.org/issues/13061).
+		default:
+			return nil, nil, _InvalidUntypedConversion
 		}
 	case *Sum:
-		t.is(func(t Type) bool {
-			check.convertUntypedInternal(x, t)
-			return x.mode != invalid
+		ok := t.is(func(t Type) bool {
+			target, _, _ := check.implicitTypeAndValue(x, t)
+			return target != nil
 		})
+		if !ok {
+			return nil, nil, _InvalidUntypedConversion
+		}
+		// keep nil untyped (was bug #39755)
+		if x.isNil() {
+			return Typ[UntypedNil], nil, 0
+		}
 	case *Interface:
-		// Update operand types to the default type rather then
-		// the target (interface) type: values must have concrete
-		// dynamic types. If the value is nil, keep it untyped
-		// (this is important for tools such as go vet which need
-		// the dynamic type for argument checking of say, print
+		// Values must have concrete dynamic types. If the value is nil,
+		// keep it untyped (this is important for tools such as go vet which
+		// need the dynamic type for argument checking of say, print
 		// functions)
 		if x.isNil() {
-			target = Typ[UntypedNil]
-		} else {
-			// cannot assign untyped values to non-empty interfaces
-			check.completeInterface(token.NoPos, t)
-			if !t.Empty() {
-				goto Error
-			}
-			target = Default(x.typ)
+			return Typ[UntypedNil], nil, 0
 		}
+		// cannot assign untyped values to non-empty interfaces
+		check.completeInterface(token.NoPos, t)
+		if !t.Empty() {
+			return nil, nil, _InvalidUntypedConversion
+		}
+		return Default(x.typ), nil, 0
 	case *Pointer, *Signature, *Slice, *Map, *Chan:
 		if !x.isNil() {
-			goto Error
+			return nil, nil, _InvalidUntypedConversion
 		}
-		// keep nil untyped - see comment for interfaces, above
-		target = Typ[UntypedNil]
+		// Keep nil untyped - see comment for interfaces, above.
+		return Typ[UntypedNil], nil, 0
 	default:
-		goto Error
+		return nil, nil, _InvalidUntypedConversion
 	}
-
-	x.typ = target
-	check.updateExprType(x.expr, target, true) // UntypedNils are final
-	return
-
-Error:
-	check.errorf(x.pos(), "cannot convert %s to %s", x, target)
-	x.mode = invalid
+	return target, nil, 0
 }
 
 func (check *Checker) comparison(x, y *operand, op token.Token) {
 	// spec: "In any comparison, the first operand must be assignable
 	// to the type of the second operand, or vice versa."
 	err := ""
-	if x.assignableTo(check, y.typ, nil) || y.assignableTo(check, x.typ, nil) {
+	var code errorCode
+	xok, _ := x.assignableTo(check, y.typ, nil)
+	yok, _ := y.assignableTo(check, x.typ, nil)
+	if xok || yok {
 		defined := false
 		switch op {
 		case token.EQL, token.NEQ:
@@ -656,13 +653,15 @@
 				typ = y.typ
 			}
 			err = check.sprintf("operator %s not defined for %s", op, typ)
+			code = _UndefinedOp
 		}
 	} else {
 		err = check.sprintf("mismatched types %s and %s", x.typ, y.typ)
+		code = _MismatchedTypes
 	}
 
 	if err != "" {
-		check.errorf(x.pos(), "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
+		check.errorf(x, code, "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
 		x.mode = invalid
 		return
 	}
@@ -699,7 +698,7 @@
 		// as an integer. Nothing to do.
 	} else {
 		// shift has no chance
-		check.invalidOp(x.pos(), "shifted operand %s must be integer", x)
+		check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s must be integer", x)
 		x.mode = invalid
 		return
 	}
@@ -716,7 +715,7 @@
 			return
 		}
 	default:
-		check.invalidOp(y.pos(), "shift count %s must be integer", y)
+		check.invalidOp(y, _InvalidShiftCount, "shift count %s must be integer", y)
 		x.mode = invalid
 		return
 	}
@@ -729,7 +728,7 @@
 		yval = constant.ToInt(y.val)
 		assert(yval.Kind() == constant.Int)
 		if constant.Sign(yval) < 0 {
-			check.invalidOp(y.pos(), "negative shift count %s", y)
+			check.invalidOp(y, _InvalidShiftCount, "negative shift count %s", y)
 			x.mode = invalid
 			return
 		}
@@ -741,7 +740,7 @@
 			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64
 			s, ok := constant.Uint64Val(yval)
 			if !ok || s > shiftBound {
-				check.invalidOp(y.pos(), "invalid shift count %s", y)
+				check.invalidOp(y, _InvalidShiftCount, "invalid shift count %s", y)
 				x.mode = invalid
 				return
 			}
@@ -798,7 +797,7 @@
 
 	// non-constant shift - lhs must be an integer
 	if !isInteger(x.typ) {
-		check.invalidOp(x.pos(), "shifted operand %s must be integer", x)
+		check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s must be integer", x)
 		x.mode = invalid
 		return
 	}
@@ -828,7 +827,7 @@
 }
 
 // The binary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, op token.Token) {
+func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
 	var y operand
 
 	check.expr(x, lhs)
@@ -867,7 +866,11 @@
 		// only report an error if we have valid types
 		// (otherwise we had an error reported elsewhere already)
 		if x.typ != Typ[Invalid] && y.typ != Typ[Invalid] {
-			check.invalidOp(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
+			var posn positioner = x
+			if e != nil {
+				posn = e
+			}
+			check.invalidOp(posn, _MismatchedTypes, "mismatched types %s and %s", x.typ, y.typ)
 		}
 		x.mode = invalid
 		return
@@ -881,7 +884,7 @@
 	if op == token.QUO || op == token.REM {
 		// check for zero divisor
 		if (x.mode == constant_ || isInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 {
-			check.invalidOp(y.pos(), "division by zero")
+			check.invalidOp(&y, _DivByZero, "division by zero")
 			x.mode = invalid
 			return
 		}
@@ -891,7 +894,7 @@
 			re, im := constant.Real(y.val), constant.Imag(y.val)
 			re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im)
 			if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 {
-				check.invalidOp(y.pos(), "division by zero")
+				check.invalidOp(&y, _DivByZero, "division by zero")
 				x.mode = invalid
 				return
 			}
@@ -907,6 +910,14 @@
 			op = token.QUO_ASSIGN
 		}
 		x.val = constant.BinaryOp(xval, op, yval)
+		// report error if valid operands lead to an invalid result
+		if xval.Kind() != constant.Unknown && yval.Kind() != constant.Unknown && x.val.Kind() == constant.Unknown {
+			// TODO(gri) We should report exactly what went wrong. At the
+			//           moment we don't have the (go/constant) API for that.
+			//           See also TODO in go/constant/value.go.
+			check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
+			// TODO(gri) Should we mark operands with unknown values as invalid?
+		}
 		// Typed constants must be representable in
 		// their type after each constant operation.
 		if isTyped(typ) {
@@ -944,7 +955,7 @@
 
 	// the index must be of integer type
 	if !isInteger(x.typ) {
-		check.invalidArg(x.pos(), "index %s must be integer", &x)
+		check.invalidArg(&x, _InvalidIndex, "index %s must be integer", &x)
 		return
 	}
 
@@ -954,13 +965,13 @@
 
 	// a constant index i must be in bounds
 	if constant.Sign(x.val) < 0 {
-		check.invalidArg(x.pos(), "index %s must not be negative", &x)
+		check.invalidArg(&x, _InvalidIndex, "index %s must not be negative", &x)
 		return
 	}
 
 	v, valid := constant.Int64Val(constant.ToInt(x.val))
 	if !valid || max >= 0 && v >= max {
-		check.errorf(x.pos(), "index %s is out of bounds", &x)
+		check.errorf(&x, _InvalidIndex, "index %s is out of bounds", &x)
 		return
 	}
 
@@ -986,12 +997,12 @@
 					index = i
 					validIndex = true
 				} else {
-					check.errorf(e.Pos(), "index %s must be integer constant", kv.Key)
+					check.errorf(e, _InvalidLitIndex, "index %s must be integer constant", kv.Key)
 				}
 			}
 			eval = kv.Value
 		} else if length >= 0 && index >= length {
-			check.errorf(e.Pos(), "index %d is out of bounds (>= %d)", index, length)
+			check.errorf(e, _OversizeArrayLit, "index %d is out of bounds (>= %d)", index, length)
 		} else {
 			validIndex = true
 		}
@@ -999,7 +1010,7 @@
 		// if we have a valid index, check for duplicate entries
 		if validIndex {
 			if visited[index] {
-				check.errorf(e.Pos(), "duplicate index %d in array or slice literal", index)
+				check.errorf(e, _DuplicateLitKey, "duplicate index %d in array or slice literal", index)
 			}
 			visited[index] = true
 		}
@@ -1031,7 +1042,7 @@
 // If hint != nil, it is the type of a composite literal element.
 //
 func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type) exprKind {
-	if check.conf.Trace {
+	if trace {
 		check.trace(e.Pos(), "expr %s", e)
 		check.indent++
 		defer func() {
@@ -1089,13 +1100,17 @@
 	case *ast.Ellipsis:
 		// ellipses are handled explicitly where they are legal
 		// (array composite literals and parameter lists)
-		check.error(e.Pos(), "invalid use of '...'")
+		check.error(e, _BadDotDotDotSyntax, "invalid use of '...'")
 		goto Error
 
 	case *ast.BasicLit:
 		x.setConst(e.Kind, e.Value)
 		if x.mode == invalid {
-			check.invalidAST(e.Pos(), "invalid literal %v", e.Value)
+			// The parser already establishes syntactic correctness.
+			// If we reach here it's because of number under-/overflow.
+			// TODO(gri) setConst (and in turn the go/constant package)
+			// should return an error describing the issue.
+			check.errorf(e, _InvalidConstVal, "malformed constant: %s", e.Value)
 			goto Error
 		}
 
@@ -1116,7 +1131,7 @@
 			x.mode = value
 			x.typ = sig
 		} else {
-			check.invalidAST(e.Pos(), "invalid function literal %s", e)
+			check.invalidAST(e, "invalid function literal %s", e)
 			goto Error
 		}
 
@@ -1148,7 +1163,7 @@
 
 		default:
 			// TODO(gri) provide better error messages depending on context
-			check.error(e.Pos(), "missing type in composite literal")
+			check.error(e, _UntypedLit, "missing type in composite literal")
 			goto Error
 		}
 
@@ -1164,7 +1179,7 @@
 				for _, e := range e.Elts {
 					kv, _ := e.(*ast.KeyValueExpr)
 					if kv == nil {
-						check.error(e.Pos(), "mixture of field:value and value elements in struct literal")
+						check.error(e, _MixedStructLit, "mixture of field:value and value elements in struct literal")
 						continue
 					}
 					key, _ := kv.Key.(*ast.Ident)
@@ -1172,12 +1187,12 @@
 					// so we don't drop information on the floor
 					check.expr(x, kv.Value)
 					if key == nil {
-						check.errorf(kv.Pos(), "invalid field name %s in struct literal", kv.Key)
+						check.errorf(kv, _InvalidLitField, "invalid field name %s in struct literal", kv.Key)
 						continue
 					}
 					i := fieldIndex(utyp.fields, check.pkg, key.Name)
 					if i < 0 {
-						check.errorf(kv.Pos(), "unknown field %s in struct literal", key.Name)
+						check.errorf(kv, _MissingLitField, "unknown field %s in struct literal", key.Name)
 						continue
 					}
 					fld := fields[i]
@@ -1186,7 +1201,7 @@
 					check.assignment(x, etyp, "struct literal")
 					// 0 <= i < len(fields)
 					if visited[i] {
-						check.errorf(kv.Pos(), "duplicate field name %s in struct literal", key.Name)
+						check.errorf(kv, _DuplicateLitField, "duplicate field name %s in struct literal", key.Name)
 						continue
 					}
 					visited[i] = true
@@ -1195,25 +1210,27 @@
 				// no element must have a key
 				for i, e := range e.Elts {
 					if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
-						check.error(kv.Pos(), "mixture of field:value and value elements in struct literal")
+						check.error(kv, _MixedStructLit, "mixture of field:value and value elements in struct literal")
 						continue
 					}
 					check.expr(x, e)
 					if i >= len(fields) {
-						check.error(x.pos(), "too many values in struct literal")
+						check.error(x, _InvalidStructLit, "too many values in struct literal")
 						break // cannot continue
 					}
 					// i < len(fields)
 					fld := fields[i]
 					if !fld.Exported() && fld.pkg != check.pkg {
-						check.errorf(x.pos(), "implicit assignment to unexported field %s in %s literal", fld.name, typ)
+						check.errorf(x,
+							_UnexportedLitField,
+							"implicit assignment to unexported field %s in %s literal", fld.name, typ)
 						continue
 					}
 					etyp := fld.typ
 					check.assignment(x, etyp, "struct literal")
 				}
 				if len(e.Elts) < len(fields) {
-					check.error(e.Rbrace, "too few values in struct literal")
+					check.error(inNode(e, e.Rbrace), _InvalidStructLit, "too few values in struct literal")
 					// ok to continue
 				}
 			}
@@ -1223,7 +1240,7 @@
 			// This is a stop-gap solution. Should use Checker.objPath to report entire
 			// path starting with earliest declaration in the source. TODO(gri) fix this.
 			if utyp.elem == nil {
-				check.error(e.Pos(), "illegal cycle in type declaration")
+				check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration")
 				goto Error
 			}
 			n := check.indexedElts(e.Elts, utyp.elem, utyp.len)
@@ -1250,7 +1267,7 @@
 			// Prevent crash if the slice referred to is not yet set up.
 			// See analogous comment for *Array.
 			if utyp.elem == nil {
-				check.error(e.Pos(), "illegal cycle in type declaration")
+				check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration")
 				goto Error
 			}
 			check.indexedElts(e.Elts, utyp.elem, -1)
@@ -1259,14 +1276,14 @@
 			// Prevent crash if the map referred to is not yet set up.
 			// See analogous comment for *Array.
 			if utyp.key == nil || utyp.elem == nil {
-				check.error(e.Pos(), "illegal cycle in type declaration")
+				check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration")
 				goto Error
 			}
 			visited := make(map[interface{}][]Type, len(e.Elts))
 			for _, e := range e.Elts {
 				kv, _ := e.(*ast.KeyValueExpr)
 				if kv == nil {
-					check.error(e.Pos(), "missing key in map literal")
+					check.error(e, _MissingLitKey, "missing key in map literal")
 					continue
 				}
 				check.exprWithHint(x, kv.Key, utyp.key)
@@ -1291,7 +1308,7 @@
 						visited[xkey] = nil
 					}
 					if duplicate {
-						check.errorf(x.pos(), "duplicate key %s in map literal", x.val)
+						check.errorf(x, _DuplicateLitKey, "duplicate key %s in map literal", x.val)
 						continue
 					}
 				}
@@ -1313,7 +1330,7 @@
 			}
 			// if utyp is invalid, an error was reported before
 			if utyp != Typ[Invalid] {
-				check.errorf(e.Pos(), "invalid composite literal type %s", typ)
+				check.errorf(e, _InvalidLit, "invalid composite literal type %s", typ)
 				goto Error
 			}
 		}
@@ -1330,32 +1347,24 @@
 		check.selector(x, e)
 
 	case *ast.IndexExpr:
-		if check.useBrackets {
-			check.exprOrType(x, e.X)
-		} else {
-			check.expr(x, e.X)
-		}
+		check.exprOrType(x, e.X)
 		if x.mode == invalid {
 			check.use(e.Index)
 			goto Error
 		}
 
-		if check.useBrackets {
-			if x.mode == typexpr {
-				if isGeneric(x.typ) {
-					// type instantiation
-					x.mode = invalid
-					x.typ = check.varType(e)
-					if x.typ != Typ[Invalid] {
-						x.mode = typexpr
-					}
-					return expression
-				}
-				check.errorf(x.pos(), "%s is not a generic type", x.typ)
-				goto Error
+		if x.mode == typexpr {
+			// type instantiation
+			x.mode = invalid
+			x.typ = check.varType(e)
+			if x.typ != Typ[Invalid] {
+				x.mode = typexpr
 			}
+			return expression
+		}
 
-			if sig := asSignature(x.typ); sig != nil {
+		if x.mode == value {
+			if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
 				return check.call(x, nil, e)
 			}
 		}
@@ -1440,7 +1449,7 @@
 					e = t.elem
 					nmaps++
 				case *TypeParam:
-					check.errorf(x.pos(), "type of %s contains a type parameter - cannot index (implementation restriction)", x)
+					check.errorf(x, 0, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
 				case *instance:
 					panic("unimplemented")
 				}
@@ -1485,12 +1494,12 @@
 		}
 
 		if !valid {
-			check.invalidOp(x.pos(), "cannot index %s", x)
+			check.invalidOp(x, _NonIndexableOperand, "cannot index %s", x)
 			goto Error
 		}
 
 		if e.Index == nil {
-			check.invalidAST(e.Pos(), "missing index for %s", x)
+			check.invalidAST(e, "missing index for %s", x)
 			goto Error
 		}
 
@@ -1517,7 +1526,7 @@
 		case *Basic:
 			if isString(typ) {
 				if e.Slice3 {
-					check.invalidOp(x.pos(), "3-index slice of string")
+					check.invalidOp(x, _InvalidSliceExpr, "3-index slice of string")
 					goto Error
 				}
 				valid = true
@@ -1535,7 +1544,7 @@
 			valid = true
 			length = typ.len
 			if x.mode != variable {
-				check.invalidOp(x.pos(), "cannot slice %s (value not addressable)", x)
+				check.invalidOp(x, _NonSliceableOperand, "cannot slice %s (value not addressable)", x)
 				goto Error
 			}
 			x.typ = &Slice{elem: typ.elem}
@@ -1552,12 +1561,12 @@
 			// x.typ doesn't change
 
 		case *Sum, *TypeParam:
-			check.errorf(x.pos(), "generic slice expressions not yet implemented")
+			check.errorf(x, 0, "generic slice expressions not yet implemented")
 			goto Error
 		}
 
 		if !valid {
-			check.invalidOp(x.pos(), "cannot slice %s", x)
+			check.invalidOp(x, _NonSliceableOperand, "cannot slice %s", x)
 			goto Error
 		}
 
@@ -1565,7 +1574,7 @@
 
 		// spec: "Only the first index may be omitted; it defaults to 0."
 		if e.Slice3 && (e.High == nil || e.Max == nil) {
-			check.error(e.Rbrack, "2nd and 3rd index required in 3-index slice")
+			check.invalidAST(inNode(e, e.Rbrack), "2nd and 3rd index required in 3-index slice")
 			goto Error
 		}
 
@@ -1602,7 +1611,7 @@
 			if x > 0 {
 				for _, y := range ind[i+1:] {
 					if y >= 0 && x > y {
-						check.errorf(e.Rbrack, "invalid slice indices: %d > %d", x, y)
+						check.errorf(inNode(e, e.Rbrack), _SwappedSliceIndices, "swapped slice indices: %d > %d", x, y)
 						break L // only report one error, ok to continue
 					}
 				}
@@ -1616,20 +1625,22 @@
 		}
 		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
-			check.errorf(x.pos(), "%s is not an interface type", x)
+			check.invalidOp(x, _InvalidAssert, "%s is not an interface", x)
 			goto Error
 		}
-		check.ordinaryType(x.pos(), xtyp)
+		check.ordinaryType(x, xtyp)
 		// x.(type) expressions are handled explicitly in type switches
 		if e.Type == nil {
-			check.invalidAST(e.Pos(), "use of .(type) outside type switch")
+			// Don't use invalidAST because this can occur in the AST produced by
+			// go/parser.
+			check.error(e, _BadTypeKeyword, "use of .(type) outside type switch")
 			goto Error
 		}
 		T := check.varType(e.Type)
 		if T == Typ[Invalid] {
 			goto Error
 		}
-		check.typeAssertion(x.pos(), x, xtyp, T, false)
+		check.typeAssertion(x, x, xtyp, T)
 		x.mode = commaok
 		x.typ = T
 
@@ -1648,7 +1659,7 @@
 				x.mode = variable
 				x.typ = typ.base
 			} else {
-				check.invalidOp(x.pos(), "cannot indirect %s", x)
+				check.invalidOp(x, _InvalidIndirection, "cannot indirect %s", x)
 				goto Error
 			}
 		}
@@ -1668,14 +1679,14 @@
 		}
 
 	case *ast.BinaryExpr:
-		check.binary(x, e, e.X, e.Y, e.Op)
+		check.binary(x, e, e.X, e.Y, e.Op, e.OpPos)
 		if x.mode == invalid {
 			goto Error
 		}
 
 	case *ast.KeyValueExpr:
 		// key:value expressions are handled in composite literals
-		check.invalidAST(e.Pos(), "no key:value expected")
+		check.invalidAST(e, "no key:value expected")
 		goto Error
 
 	case *ast.ArrayType, *ast.StructType, *ast.FuncType,
@@ -1727,8 +1738,8 @@
 }
 
 // typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
-func (check *Checker) typeAssertion(pos token.Pos, x *operand, xtyp *Interface, T Type, strict bool) {
-	method, wrongType := check.assertableTo(xtyp, T, strict)
+func (check *Checker) typeAssertion(at positioner, x *operand, xtyp *Interface, T Type) {
+	method, wrongType := check.assertableTo(xtyp, T)
 	if method == nil {
 		return
 	}
@@ -1742,7 +1753,7 @@
 	} else {
 		msg = "missing method " + method.name
 	}
-	check.errorf(pos, "%s cannot have dynamic type %s (%s)", x, T, msg)
+	check.errorf(at, _ImpossibleAssert, "%s cannot have dynamic type %s (%s)", x, T, msg)
 }
 
 // expr typechecks expression e and initializes x with the expression value.
@@ -1792,6 +1803,7 @@
 func (check *Checker) exclude(x *operand, modeset uint) {
 	if modeset&(1<<x.mode) != 0 {
 		var msg string
+		var code errorCode
 		switch x.mode {
 		case novalue:
 			if modeset&(1<<typexpr) != 0 {
@@ -1799,14 +1811,17 @@
 			} else {
 				msg = "%s used as value or type"
 			}
+			code = _TooManyValues
 		case builtin:
 			msg = "%s must be called"
+			code = _UncalledBuiltin
 		case typexpr:
 			msg = "%s is not an expression"
+			code = _NotAnExpr
 		default:
 			unreachable()
 		}
-		check.errorf(x.pos(), msg, x)
+		check.errorf(x, code, msg, x)
 		x.mode = invalid
 	}
 }
@@ -1817,7 +1832,7 @@
 		// tuple types are never named - no need for underlying type below
 		if t, ok := x.typ.(*Tuple); ok {
 			assert(t.Len() != 1)
-			check.errorf(x.pos(), "%d-valued %s where single value is expected", t.Len(), x)
+			check.errorf(x, _TooManyValues, "%d-valued %s where single value is expected", t.Len(), x)
 			x.mode = invalid
 		}
 	}
diff --git a/src/go/types/fixedbugs/issue20583.src b/src/go/types/fixedbugs/issue20583.src
new file mode 100644
index 0000000..d26dbad
--- /dev/null
+++ b/src/go/types/fixedbugs/issue20583.src
@@ -0,0 +1,14 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package issue20583
+
+const (
+	_ = 6e886451608 /* ERROR malformed constant */ /2
+	_ = 6e886451608i /* ERROR malformed constant */ /2
+	_ = 0 * 1e+1000000000 // ERROR malformed constant
+
+	x = 1e100000000
+	_ = x*x*x*x*x*x* /* ERROR not representable */ x
+)
diff --git a/src/go/types/fixedbugs/issue23203a.src b/src/go/types/fixedbugs/issue23203a.src
new file mode 100644
index 0000000..48cb588
--- /dev/null
+++ b/src/go/types/fixedbugs/issue23203a.src
@@ -0,0 +1,14 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "unsafe"
+
+type T struct{}
+
+func (T) m1()                         {}
+func (T) m2([unsafe.Sizeof(T.m1)]int) {}
+
+func main() {}
diff --git a/src/go/types/fixedbugs/issue23203b.src b/src/go/types/fixedbugs/issue23203b.src
new file mode 100644
index 0000000..638ec6c
--- /dev/null
+++ b/src/go/types/fixedbugs/issue23203b.src
@@ -0,0 +1,14 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "unsafe"
+
+type T struct{}
+
+func (T) m2([unsafe.Sizeof(T.m1)]int) {}
+func (T) m1()                         {}
+
+func main() {}
diff --git a/src/go/types/fixedbugs/issue26390.src b/src/go/types/fixedbugs/issue26390.src
new file mode 100644
index 0000000..9e0101f5
--- /dev/null
+++ b/src/go/types/fixedbugs/issue26390.src
@@ -0,0 +1,13 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// stand-alone test to ensure case is triggered
+
+package issue26390
+
+type A = T
+
+func (t *T) m() *A { return t }
+
+type T struct{}
diff --git a/src/go/types/fixedbugs/issue28251.src b/src/go/types/fixedbugs/issue28251.src
new file mode 100644
index 0000000..cd79e0e
--- /dev/null
+++ b/src/go/types/fixedbugs/issue28251.src
@@ -0,0 +1,65 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains test cases for various forms of
+// method receiver declarations, per the spec clarification
+// https://golang.org/cl/142757.
+
+package issue28251
+
+// test case from issue28251
+type T struct{}
+
+type T0 = *T
+
+func (T0) m() {}
+
+func _() { (&T{}).m() }
+
+// various alternative forms
+type (
+        T1 = (((T)))
+)
+
+func ((*(T1))) m1() {}
+func _() { (T{}).m2() }
+func _() { (&T{}).m2() }
+
+type (
+        T2 = (((T3)))
+        T3 = T
+)
+
+func (T2) m2() {}
+func _() { (T{}).m2() }
+func _() { (&T{}).m2() }
+
+type (
+        T4 = ((*(T5)))
+        T5 = T
+)
+
+func (T4) m4() {}
+func _() { (T{}).m4 /* ERROR "cannot call pointer method m4 on T" */ () }
+func _() { (&T{}).m4() }
+
+type (
+        T6 = (((T7)))
+        T7 = (*(T8))
+        T8 = T
+)
+
+func (T6) m6() {}
+func _() { (T{}).m6 /* ERROR "cannot call pointer method m6 on T" */ () }
+func _() { (&T{}).m6() }
+
+type (
+        T9 = *T10
+        T10 = *T11
+        T11 = T
+)
+
+func (T9 /* ERROR invalid receiver \*\*T */ ) m9() {}
+func _() { (T{}).m9 /* ERROR has no field or method m9 */ () }
+func _() { (&T{}).m9 /* ERROR has no field or method m9 */ () }
diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/fixedbugs/issue39634.go2
index e19343e..249542d 100644
--- a/src/go/types/fixedbugs/issue39634.go2
+++ b/src/go/types/fixedbugs/issue39634.go2
@@ -83,9 +83,9 @@
 var x T25 /* ERROR without instantiation */ .m1
 
 // crash 26
-type T26 = interface{ F26[Z any]() }
+type T26 = interface{ F26[ /* ERROR methods cannot have type parameters */ Z any]() }
 func F26[Z any]() T26 { return F26 /* ERROR without instantiation */ /* ERROR missing method */ [] /* ERROR operand */ }
 
 // crash 27
 func e27[T any]() interface{ x27 /* ERROR not a type */ }
-func x27() { e27() /* ERROR cannot infer T */ }
\ No newline at end of file
+func x27() { e27() /* ERROR cannot infer T */ }
diff --git a/src/go/types/fixedbugs/issue39754.go2 b/src/go/types/fixedbugs/issue39754.go2
index 0de777a..2ed84dc 100644
--- a/src/go/types/fixedbugs/issue39754.go2
+++ b/src/go/types/fixedbugs/issue39754.go2
@@ -16,5 +16,5 @@
 
 func _() {
 	f[int, Optional[int], Optional[int]]()
-	f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]()
+	// f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]()
 }
diff --git a/src/go/types/fixedbugs/issue42695.src b/src/go/types/fixedbugs/issue42695.src
new file mode 100644
index 0000000..d0d6200
--- /dev/null
+++ b/src/go/types/fixedbugs/issue42695.src
@@ -0,0 +1,17 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package issue42695
+
+const _ = 6e5518446744 // ERROR malformed constant
+const _ uint8 = 6e5518446744 // ERROR malformed constant
+
+var _ = 6e5518446744 // ERROR malformed constant
+var _ uint8 = 6e5518446744 // ERROR malformed constant
+
+func f(x int) int {
+        return x + 6e5518446744 // ERROR malformed constant
+}
+
+var _ = f(6e5518446744 /* ERROR malformed constant */ )
diff --git a/src/go/types/fixedbugs/issue43110.src b/src/go/types/fixedbugs/issue43110.src
new file mode 100644
index 0000000..4a46945
--- /dev/null
+++ b/src/go/types/fixedbugs/issue43110.src
@@ -0,0 +1,43 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+type P *struct{}
+
+func _() {
+	// want an error even if the switch is empty
+	var a struct{ _ func() }
+	switch a /* ERROR cannot switch on a */ {
+	}
+
+	switch a /* ERROR cannot switch on a */ {
+	case a: // no follow-on error here
+	}
+
+	// this is ok because f can be compared to nil
+	var f func()
+	switch f {
+	}
+
+	switch f {
+	case nil:
+	}
+
+	switch (func())(nil) {
+	case nil:
+	}
+
+	switch (func())(nil) {
+	case f /* ERROR cannot compare */ :
+	}
+
+	switch nil /* ERROR use of untyped nil in switch expression */ {
+	}
+
+	// this is ok
+	switch P(nil) {
+	case P(nil):
+	}
+}
diff --git a/src/go/types/fixedbugs/issue43124.src b/src/go/types/fixedbugs/issue43124.src
new file mode 100644
index 0000000..f429f74
--- /dev/null
+++ b/src/go/types/fixedbugs/issue43124.src
@@ -0,0 +1,16 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+var _ = int(0 /* ERROR invalid use of \.\.\. in conversion to int */ ...)
+
+// test case from issue
+
+type M []string
+
+var (
+	x = []string{"a", "b"}
+	_ = M(x /* ERROR invalid use of \.\.\. in conversion to M */ ...)
+)
diff --git a/src/go/types/fixedbugs/issue6977.src b/src/go/types/fixedbugs/issue6977.src
new file mode 100644
index 0000000..8f4e9ba
--- /dev/null
+++ b/src/go/types/fixedbugs/issue6977.src
@@ -0,0 +1,82 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import "io"
+
+// Alan's initial report.
+
+type I interface { f(); String() string }
+type J interface { g(); String() string }
+
+type IJ1 = interface { I; J }
+type IJ2 = interface { f(); g(); String() string }
+
+var _ = (*IJ1)(nil) == (*IJ2)(nil) // static assert that IJ1 and IJ2 are identical types
+
+// The canonical example.
+
+type ReadWriteCloser interface { io.ReadCloser; io.WriteCloser }
+
+// Some more cases.
+
+type M interface { m() }
+type M32 interface { m() int32 }
+type M64 interface { m() int64 }
+
+type U1 interface { m() }
+type U2 interface { m(); M }
+type U3 interface { M; m() }
+type U4 interface { M; M; M }
+type U5 interface { U1; U2; U3; U4 }
+
+type U6 interface { m(); m /* ERROR duplicate method */ () }
+type U7 interface { M32 /* ERROR duplicate method */ ; m() }
+type U8 interface { m(); M32 /* ERROR duplicate method */ }
+type U9 interface { M32; M64 /* ERROR duplicate method */ }
+
+// Verify that repeated embedding of the same interface(s)
+// eliminates duplicate methods early (rather than at the
+// end) to prevent exponential memory and time use.
+// Without early elimination, computing T29 may take dozens
+// of minutes.
+type (
+        T0 interface { m() }
+        T1 interface { T0; T0 }
+        T2 interface { T1; T1 }
+        T3 interface { T2; T2 }
+        T4 interface { T3; T3 }
+        T5 interface { T4; T4 }
+        T6 interface { T5; T5 }
+        T7 interface { T6; T6 }
+        T8 interface { T7; T7 }
+        T9 interface { T8; T8 }
+
+        T10 interface { T9; T9 }
+        T11 interface { T10; T10 }
+        T12 interface { T11; T11 }
+        T13 interface { T12; T12 }
+        T14 interface { T13; T13 }
+        T15 interface { T14; T14 }
+        T16 interface { T15; T15 }
+        T17 interface { T16; T16 }
+        T18 interface { T17; T17 }
+        T19 interface { T18; T18 }
+
+        T20 interface { T19; T19 }
+        T21 interface { T20; T20 }
+        T22 interface { T21; T21 }
+        T23 interface { T22; T22 }
+        T24 interface { T23; T23 }
+        T25 interface { T24; T24 }
+        T26 interface { T25; T25 }
+        T27 interface { T26; T26 }
+        T28 interface { T27; T27 }
+        T29 interface { T28; T28 }
+)
+
+// Verify that m is present.
+var x T29
+var _ = x.m
diff --git a/src/go/types/gotype.go b/src/go/types/gotype.go
index 258ad3b..eacf68f 100644
--- a/src/go/types/gotype.go
+++ b/src/go/types/gotype.go
@@ -48,9 +48,9 @@
 
 Flags controlling additional output:
 	-ast
-		print AST (forces -seq)
+		print AST
 	-trace
-		print parse trace (forces -seq)
+		print parse trace
 	-comments
 		parse comments (ignored unless -ast or -trace is provided)
 	-panic
@@ -104,8 +104,8 @@
 	compiler   = flag.String("c", "source", "compiler used for installed packages (gc, gccgo, or source)")
 
 	// additional output control
-	printAST      = flag.Bool("ast", false, "print AST (forces -seq)")
-	printTrace    = flag.Bool("trace", false, "print parse trace (forces -seq)")
+	printAST      = flag.Bool("ast", false, "print AST")
+	printTrace    = flag.Bool("trace", false, "print parse trace")
 	parseComments = flag.Bool("comments", false, "parse comments (ignored unless -ast or -trace is provided)")
 	panicOnError  = flag.Bool("panic", false, "panic on first error")
 )
@@ -118,7 +118,6 @@
 )
 
 func initParserMode() {
-	parserMode = parser.UnifiedParamLists
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}
@@ -291,8 +290,7 @@
 
 	// if checkPkgFiles is called multiple times, set up conf only once
 	conf := types.Config{
-		InferFromConstraints: true,
-		FakeImportC:          true,
+		FakeImportC: true,
 		Error: func(err error) {
 			if !*allErrors && errorCount >= 10 {
 				panic(bailout{})
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 2c7e548..95bd3cb 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -17,7 +17,7 @@
 // is impossible because unification fails, an error is reported and the resulting types list is
 // nil, and index is 0. Otherwise, types is the list of inferred type arguments, and index is
 // the index of the first type argument in that list that couldn't be inferred (and thus is nil).
-// If all type arguments where inferred successfully, index is < 0.
+// If all type arguments were inferred successfully, index is < 0.
 func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand) (types []Type, index int) {
 	assert(params.Len() == len(args))
 
@@ -39,16 +39,17 @@
 				}
 			}
 			if allFailed {
-				check.errorf(arg.pos(), "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
+				check.errorf(arg, _Todo, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
 				return
 			}
 		}
 		smap := makeSubstMap(tparams, targs)
-		inferred := check.subst(arg.pos(), tpar, smap)
+		// TODO(rFindley): pass a positioner here, rather than arg.Pos().
+		inferred := check.subst(arg.Pos(), tpar, smap)
 		if inferred != tpar {
-			check.errorf(arg.pos(), "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
+			check.errorf(arg, _Todo, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
 		} else {
-			check.errorf(arg.pos(), "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
+			check.errorf(arg, 0, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
 		}
 	}
 
@@ -72,7 +73,7 @@
 			if targ := arg.typ; isTyped(targ) {
 				// If we permit bidirectional unification, and targ is
 				// a generic function, we need to initialize u.y with
-				// the respectice type parameters of targ.
+				// the respective type parameters of targ.
 				if !u.unify(par.typ, targ) {
 					errorf("type", par.typ, targ, arg)
 					return nil, 0
@@ -215,13 +216,13 @@
 
 	case *Interface:
 		if t.allMethods != nil {
-			// interface is complete - quick test
+			// TODO(rFindley) at some point we should enforce completeness here
 			for _, m := range t.allMethods {
 				if w.isParameterized(m.typ) {
 					return true
 				}
 			}
-			return w.isParameterizedList(unpack(t.allTypes))
+			return w.isParameterizedList(unpackType(t.allTypes))
 		}
 
 		return t.iterate(func(t *Interface) bool {
@@ -230,7 +231,7 @@
 					return true
 				}
 			}
-			return w.isParameterizedList(unpack(t.types))
+			return w.isParameterizedList(unpackType(t.types))
 		}, nil)
 
 	case *Map:
@@ -291,21 +292,19 @@
 	// Unify type parameters with their structural constraints, if any.
 	for _, tpar := range tparams {
 		typ := tpar.typ.(*TypeParam)
-		sbound := check.structuralType(under(typ.bound))
+		sbound := check.structuralType(typ.bound)
 		if sbound != nil {
-			//check.dump(">>> unify(%s, %s)", tpar, sbound)
 			if !u.unify(typ, sbound) {
-				check.errorf(tpar.pos, "%s does not match %s", tpar, sbound)
+				check.errorf(tpar, 0, "%s does not match %s", tpar, sbound)
 				return nil, 0
 			}
-			//check.dump(">>> => indices = %v, types = %s", u.x.indices, u.types)
 		}
 	}
 
 	// u.x.types() now contains the incoming type arguments plus any additional type
 	// arguments for which there were structural constraints. The newly inferred non-
 	// nil entries may still contain references to other type parameters. For instance,
-	// for [type A interface{}, B interface{type []C}, C interface{type *A}], if A == int
+	// for [A any, B interface{type []C}, C interface{type *A}], if A == int
 	// was given, unification produced the type list [int, []C, *A]. We eliminate the
 	// remaining type parameters by substituting the type parameters in this type list
 	// until nothing changes anymore.
@@ -317,7 +316,7 @@
 	}
 
 	// dirty tracks the indices of all types that may still contain type parameters.
-	// We know that nil types entries and entries corresponding to provided (non-nil)
+	// We know that nil type entries and entries corresponding to provided (non-nil)
 	// type arguments are clean, so exclude them from the start.
 	var dirty []int
 	for i, typ := range types {
@@ -327,8 +326,8 @@
 	}
 
 	for len(dirty) > 0 {
-		// TODO(gri) Instead of creating a new smap for each iteration,
-		// provide an update operation for smaps and only change when
+		// TODO(gri) Instead of creating a new substMap for each iteration,
+		// provide an update operation for substMaps and only change when
 		// needed. Optimization.
 		smap := makeSubstMap(tparams, types)
 		n := 0
@@ -342,16 +341,15 @@
 		}
 		dirty = dirty[:n]
 	}
-	//check.dump(">>> inferred types = %s", types)
 
 	return
 }
 
 // structuralType returns the structural type of a constraint, if any.
 func (check *Checker) structuralType(constraint Type) Type {
-	if iface, _ := constraint.(*Interface); iface != nil {
+	if iface, _ := under(constraint).(*Interface); iface != nil {
 		check.completeInterface(token.NoPos, iface)
-		types := unpack(iface.allTypes)
+		types := unpackType(iface.allTypes)
 		if len(types) == 1 {
 			return types[0]
 		}
diff --git a/src/go/types/initorder.go b/src/go/types/initorder.go
index 9d5e916..77a739c 100644
--- a/src/go/types/initorder.go
+++ b/src/go/types/initorder.go
@@ -151,14 +151,14 @@
 // reportCycle reports an error for the given cycle.
 func (check *Checker) reportCycle(cycle []Object) {
 	obj := cycle[0]
-	check.errorf(obj.Pos(), "initialization cycle for %s", obj.Name())
+	check.errorf(obj, _InvalidInitCycle, "initialization cycle for %s", obj.Name())
 	// subtle loop: print cycle[i] for i = 0, n-1, n-2, ... 1 for len(cycle) = n
 	for i := len(cycle) - 1; i >= 0; i-- {
-		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
+		check.errorf(obj, _InvalidInitCycle, "\t%s refers to", obj.Name()) // secondary error, \t indented
 		obj = cycle[i]
 	}
 	// print cycle[0] again to close the cycle
-	check.errorf(obj.Pos(), "\t%s", obj.Name())
+	check.errorf(obj, _InvalidInitCycle, "\t%s", obj.Name())
 }
 
 // ----------------------------------------------------------------------------
diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go
index 318427d..34850eb 100644
--- a/src/go/types/issues_test.go
+++ b/src/go/types/issues_test.go
@@ -12,6 +12,7 @@
 	"go/ast"
 	"go/importer"
 	"go/parser"
+	"go/token"
 	"internal/testenv"
 	"sort"
 	"strings"
@@ -384,12 +385,9 @@
 			}
 		}
 		if obj == nil {
-			t.Fatal("object X not found")
+			t.Fatal("interface not found")
 		}
-		iface, _ := obj.Type().Underlying().(*Interface) // object X must be an interface
-		if iface == nil {
-			t.Fatalf("%s is not an interface", obj)
-		}
+		iface := obj.Type().Underlying().(*Interface) // I must be an interface
 
 		// Each iface method m is embedded; and m's receiver base type name
 		// must match the method's name per the choice in the source file.
@@ -526,3 +524,28 @@
 		pkg = res // res is imported by the next package in this test
 	}
 }
+
+func TestIssue43088(t *testing.T) {
+	// type T1 struct {
+	//         _ T2
+	// }
+	//
+	// type T2 struct {
+	//         _ struct {
+	//                 _ T2
+	//         }
+	// }
+	n1 := NewTypeName(token.NoPos, nil, "T1", nil)
+	T1 := NewNamed(n1, nil, nil)
+	n2 := NewTypeName(token.NoPos, nil, "T2", nil)
+	T2 := NewNamed(n2, nil, nil)
+	s1 := NewStruct([]*Var{NewField(token.NoPos, nil, "_", T2, false)}, nil)
+	T1.SetUnderlying(s1)
+	s2 := NewStruct([]*Var{NewField(token.NoPos, nil, "_", T2, false)}, nil)
+	s3 := NewStruct([]*Var{NewField(token.NoPos, nil, "_", s2, false)}, nil)
+	T2.SetUnderlying(s3)
+
+	// These calls must terminate (no endless recursion).
+	Comparable(T1)
+	Comparable(T2)
+}
diff --git a/src/go/types/labels.go b/src/go/types/labels.go
index 3b43b4b..8cf6e63 100644
--- a/src/go/types/labels.go
+++ b/src/go/types/labels.go
@@ -22,20 +22,23 @@
 	// for the respective gotos.
 	for _, jmp := range fwdJumps {
 		var msg string
+		var code errorCode
 		name := jmp.Label.Name
 		if alt := all.Lookup(name); alt != nil {
 			msg = "goto %s jumps into block"
 			alt.(*Label).used = true // avoid another error
+			code = _JumpIntoBlock
 		} else {
 			msg = "label %s not declared"
+			code = _UndeclaredLabel
 		}
-		check.errorf(jmp.Label.Pos(), msg, name)
+		check.errorf(jmp.Label, code, msg, name)
 	}
 
 	// spec: "It is illegal to define a label that is never used."
 	for _, obj := range all.elems {
 		if lbl := obj.(*Label); !lbl.used {
-			check.softErrorf(lbl.pos, "label %s declared but not used", lbl.name)
+			check.softErrorf(lbl, _UnusedLabel, "label %s declared but not used", lbl.name)
 		}
 	}
 }
@@ -133,7 +136,7 @@
 			if name := s.Label.Name; name != "_" {
 				lbl := NewLabel(s.Label.Pos(), check.pkg, name)
 				if alt := all.Insert(lbl); alt != nil {
-					check.softErrorf(lbl.pos, "label %s already declared", name)
+					check.softErrorf(lbl, _DuplicateLabel, "label %s already declared", name)
 					check.reportAltDecl(alt)
 					// ok to continue
 				} else {
@@ -149,7 +152,8 @@
 						check.recordUse(jmp.Label, lbl)
 						if jumpsOverVarDecl(jmp) {
 							check.softErrorf(
-								jmp.Label.Pos(),
+								jmp.Label,
+								_JumpOverDecl,
 								"goto %s jumps over variable declaration at line %d",
 								name,
 								check.fset.Position(varDeclPos).Line,
@@ -187,7 +191,7 @@
 					}
 				}
 				if !valid {
-					check.errorf(s.Label.Pos(), "invalid break label %s", name)
+					check.errorf(s.Label, _MisplacedLabel, "invalid break label %s", name)
 					return
 				}
 
@@ -202,7 +206,7 @@
 					}
 				}
 				if !valid {
-					check.errorf(s.Label.Pos(), "invalid continue label %s", name)
+					check.errorf(s.Label, _MisplacedLabel, "invalid continue label %s", name)
 					return
 				}
 
@@ -214,7 +218,7 @@
 				}
 
 			default:
-				check.invalidAST(s.Pos(), "branch statement: %s %s", s.Tok, name)
+				check.invalidAST(s, "branch statement: %s %s", s.Tok, name)
 				return
 			}
 
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 0514819..a0e7f3c 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -196,6 +196,8 @@
 				}
 
 			case *TypeParam:
+				// only consider explicit methods in the type parameter bound, not
+				// methods that may be common to all types in the type list.
 				if i, m := lookupMethod(t.Bound().allMethods, pkg, name); m != nil {
 					assert(m.typ != nil)
 					index = concat(e.index, i)
@@ -206,12 +208,6 @@
 					obj = m
 					indirect = e.indirect
 				}
-				if obj == nil {
-					// At this point we're not (yet) looking into methods
-					// that any underlyng type of the types in the type list
-					// migth have.
-					// TODO(gri) Do we want to specify the language that way?
-				}
 			}
 		}
 
@@ -223,7 +219,7 @@
 			//        is shorthand for (&x).m()".
 			if f, _ := obj.(*Func); f != nil {
 				// determine if method has a pointer receiver
-				hasPtrRecv := tpar == nil && ptrRecv(f) || tpar != nil && tpar.ptr
+				hasPtrRecv := tpar == nil && ptrRecv(f)
 				if hasPtrRecv && !indirect && !addressable {
 					return nil, nil, true // pointer/addressable receiver required
 				}
@@ -329,7 +325,6 @@
 				return m, f
 			}
 
-			// both methods must have the same number of type parameters
 			ftyp := f.typ.(*Signature)
 			mtyp := m.typ.(*Signature)
 			if len(ftyp.tparams) != len(mtyp.tparams) {
@@ -429,13 +424,13 @@
 // method required by V and whether it is missing or just has the wrong type.
 // The receiver may be nil if assertableTo is invoked through an exported API call
 // (such as AssertableTo), i.e., when all methods have been type-checked.
-// If strict (or the global constant forceStrict) is set, assertions that
-// are known to fail are not permitted.
-func (check *Checker) assertableTo(V *Interface, T Type, strict bool) (method, wrongType *Func) {
+// If the global constant forceStrict is set, assertions that are known to fail
+// are not permitted.
+func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Func) {
 	// no static check is required if T is an interface
 	// spec: "If T is an interface type, x.(T) asserts that the
 	//        dynamic type of x implements the interface T."
-	if asInterface(T) != nil && !(strict || forceStrict) {
+	if asInterface(T) != nil && !forceStrict {
 		return
 	}
 	return check.missingMethod(T, V, false)
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index cd66db67..8f9c9d0 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -59,10 +59,10 @@
 	id   builtinId
 }
 
-// pos returns the position of the expression corresponding to x.
+// Pos returns the position of the expression corresponding to x.
 // If x is invalid the position is token.NoPos.
 //
-func (x *operand) pos() token.Pos {
+func (x *operand) Pos() token.Pos {
 	// x.expr may not be set if x is invalid
 	if x.expr == nil {
 		return token.NoPos
@@ -204,9 +204,15 @@
 		unreachable()
 	}
 
+	val := constant.MakeFromLiteral(lit, tok, 0)
+	if val.Kind() == constant.Unknown {
+		x.mode = invalid
+		x.typ = Typ[Invalid]
+		return
+	}
 	x.mode = constant_
 	x.typ = Typ[kind]
-	x.val = constant.MakeFromLiteral(lit, tok, 0)
+	x.val = val
 }
 
 // isNil reports whether x is the nil value.
@@ -214,65 +220,44 @@
 	return x.mode == value && x.typ == Typ[UntypedNil]
 }
 
-// TODO(gri) The functions operand.assignableTo, checker.convertUntyped,
-//           checker.representable, and checker.assignment are
-//           overlapping in functionality. Need to simplify and clean up.
-
-// assignableTo reports whether x is assignable to a variable of type T.
-// If the result is false and a non-nil reason is provided, it may be set
-// to a more detailed explanation of the failure (result != "").
-// The check parameter may be nil if assignableTo is invoked through
-// an exported API call, i.e., when all methods have been type-checked.
-func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
+// assignableTo reports whether x is assignable to a variable of type T. If the
+// result is false and a non-nil reason is provided, it may be set to a more
+// detailed explanation of the failure (result != ""). The check parameter may
+// be nil if assignableTo is invoked through an exported API call, i.e., when
+// all methods have been type-checked.
+func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, errorCode) {
 	if x.mode == invalid || T == Typ[Invalid] {
-		return true // avoid spurious errors
+		return true, 0 // avoid spurious errors
 	}
 
 	V := x.typ
 
 	// x's type is identical to T
 	if check.identical(V, T) {
-		return true
+		return true, 0
 	}
 
 	Vu := optype(V)
 	Tu := optype(T)
 
-	// x is an untyped value representable by a value of type T
-	// TODO(gri) This is borrowing from checker.convertUntyped and
-	//           checker.representable. Need to clean up.
+	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
-		switch t := Tu.(type) {
-		case *Basic:
-			if x.isNil() && t.kind == UnsafePointer {
-				return true
-			}
-			if x.mode == constant_ {
-				return representableConst(x.val, check, t, nil)
-			}
-			// The result of a comparison is an untyped boolean,
-			// but may not be a constant.
-			if Vb, _ := Vu.(*Basic); Vb != nil {
-				return Vb.kind == UntypedBool && isBoolean(Tu)
-			}
-		case *Sum:
+		if t, ok := Tu.(*Sum); ok {
 			return t.is(func(t Type) bool {
 				// TODO(gri) this could probably be more efficient
-				return x.assignableTo(check, t, reason)
-			})
-		case *Interface:
-			check.completeInterface(token.NoPos, t)
-			return x.isNil() || t.Empty()
-		case *Pointer, *Signature, *Slice, *Map, *Chan:
-			return x.isNil()
+				ok, _ := x.assignableTo(check, t, reason)
+				return ok
+			}), _IncompatibleAssign
 		}
+		newType, _, _ := check.implicitTypeAndValue(x, Tu)
+		return newType != nil, _IncompatibleAssign
 	}
 	// Vu is typed
 
 	// x's type V and T have identical underlying types
 	// and at least one of V or T is not a named type
 	if check.identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
-		return true
+		return true, 0
 	}
 
 	// T is an interface type and x implements T
@@ -290,9 +275,9 @@
 					*reason = "missing method " + m.Name()
 				}
 			}
-			return false
+			return false, _InvalidIfaceAssign
 		}
-		return true
+		return true, 0
 	}
 
 	// x is a bidirectional channel value, T is a channel
@@ -300,9 +285,13 @@
 	// and at least one of V or T is not a named type
 	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
 		if Tc, ok := Tu.(*Chan); ok && check.identical(Vc.elem, Tc.elem) {
-			return !isNamed(V) || !isNamed(T)
+			if !isNamed(V) || !isNamed(T) {
+				return true, 0
+			} else {
+				return false, _InvalidChanAssign
+			}
 		}
 	}
 
-	return false
+	return false, _IncompatibleAssign
 }
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 7f76df6..0233274 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -21,7 +21,8 @@
 	return false
 }
 
-// isGeneric reports whether a type is a generic, uninstantiated type (generic signatures are not included).
+// isGeneric reports whether a type is a generic, uninstantiated type (generic
+// signatures are not included).
 func isGeneric(typ Type) bool {
 	// A parameterized type is only instantiated if it doesn't have an instantiation already.
 	named, _ := typ.(*Named)
@@ -73,12 +74,8 @@
 	return !isTyped(typ)
 }
 
-func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
-
-func isConstType(typ Type) bool {
-	t := asBasic(typ)
-	return t != nil && t.info&IsConstType != 0
-}
+func isOrdered(typ Type) bool   { return is(typ, IsOrdered) }
+func isConstType(typ Type) bool { return is(typ, IsConstType) }
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
@@ -87,7 +84,19 @@
 
 // Comparable reports whether values of type T are comparable.
 func Comparable(T Type) bool {
-	// If T is a type parameter not constraint by any type
+	return comparable(T, nil)
+}
+
+func comparable(T Type, seen map[Type]bool) bool {
+	if seen[T] {
+		return true
+	}
+	if seen == nil {
+		seen = make(map[Type]bool)
+	}
+	seen[T] = true
+
+	// If T is a type parameter not constrained by any type
 	// list (i.e., it's underlying type is the top type),
 	// T is comparable if it has the == method. Otherwise,
 	// the underlying type "wins". For instance
@@ -108,15 +117,18 @@
 		return true
 	case *Struct:
 		for _, f := range t.fields {
-			if !Comparable(f.typ) {
+			if !comparable(f.typ, seen) {
 				return false
 			}
 		}
 		return true
 	case *Array:
-		return Comparable(t.elem)
+		return comparable(t.elem, seen)
 	case *Sum:
-		return t.is(Comparable)
+		pred := func(t Type) bool {
+			return comparable(t, seen)
+		}
+		return t.is(pred)
 	case *TypeParam:
 		return t.Bound().IsComparable()
 	}
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 165b842..639ed12 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -17,12 +17,13 @@
 
 // A declInfo describes a package-level const, type, var, or func declaration.
 type declInfo struct {
-	file  *Scope        // scope of file containing this declaration
-	lhs   []*Var        // lhs of n:1 variable declarations, or nil
-	vtyp  ast.Expr      // type, or nil (for const and var declarations only)
-	init  ast.Expr      // init/orig expression, or nil (for const and var declarations only)
-	tdecl *ast.TypeSpec // type declaration, or nil
-	fdecl *ast.FuncDecl // func declaration, or nil
+	file      *Scope        // scope of file containing this declaration
+	lhs       []*Var        // lhs of n:1 variable declarations, or nil
+	vtyp      ast.Expr      // type, or nil (for const and var declarations only)
+	init      ast.Expr      // init/orig expression, or nil (for const and var declarations only)
+	inherited bool          // if set, the init expression is inherited from a previous constant declaration
+	tdecl     *ast.TypeSpec // type declaration, or nil
+	fdecl     *ast.FuncDecl // func declaration, or nil
 
 	// The deps field tracks initialization expression dependencies.
 	deps map[Object]bool // lazily initialized
@@ -55,26 +56,27 @@
 		r = len(init.Values)
 	}
 
+	const code = _WrongAssignCount
 	switch {
 	case init == nil && r == 0:
 		// var decl w/o init expr
 		if s.Type == nil {
-			check.errorf(s.Pos(), "missing type or init expr")
+			check.errorf(s, code, "missing type or init expr")
 		}
 	case l < r:
 		if l < len(s.Values) {
 			// init exprs from s
 			n := s.Values[l]
-			check.errorf(n.Pos(), "extra init expr %s", n)
+			check.errorf(n, code, "extra init expr %s", n)
 			// TODO(gri) avoid declared but not used error here
 		} else {
 			// init exprs "inherited"
-			check.errorf(s.Pos(), "extra init expr at %s", check.fset.Position(init.Pos()))
+			check.errorf(s, code, "extra init expr at %s", check.fset.Position(init.Pos()))
 			// TODO(gri) avoid declared but not used error here
 		}
 	case l > r && (init != nil || r != 1):
 		n := s.Names[r]
-		check.errorf(n.Pos(), "missing init expr for %s", n)
+		check.errorf(n, code, "missing init expr for %s", n)
 	}
 }
 
@@ -103,14 +105,14 @@
 	// spec: "A package-scope or file-scope identifier with name init
 	// may only be declared to be a function with this (func()) signature."
 	if ident.Name == "init" {
-		check.errorf(ident.Pos(), "cannot declare init - must be func")
+		check.errorf(ident, _InvalidInitDecl, "cannot declare init - must be func")
 		return
 	}
 
 	// spec: "The main package must have package name main and declare
 	// a function main that takes no arguments and returns no value."
 	if ident.Name == "main" && check.pkg.name == "main" {
-		check.errorf(ident.Pos(), "cannot declare main - must be func")
+		check.errorf(ident, _InvalidMainDecl, "cannot declare main - must be func")
 		return
 	}
 
@@ -168,7 +170,7 @@
 			imp = nil // create fake package below
 		}
 		if err != nil {
-			check.errorf(pos, "could not import %s (%s)", path, err)
+			check.errorf(atPos(pos), _BrokenImport, "could not import %s (%s)", path, err)
 			if imp == nil {
 				// create a new fake package
 				// come up with a sensible package name (heuristic)
@@ -242,218 +244,185 @@
 		// we get "." as the directory which is what we would want.
 		fileDir := dir(check.fset.Position(file.Name.Pos()).Filename)
 
-		for _, decl := range file.Decls {
-			switch d := decl.(type) {
-			case *ast.BadDecl:
-				// ignore
+		check.walkDecls(file.Decls, func(d decl) {
+			switch d := d.(type) {
+			case importDecl:
+				// import package
+				path, err := validatedImportPath(d.spec.Path.Value)
+				if err != nil {
+					check.errorf(d.spec.Path, _BadImportPath, "invalid import path (%s)", err)
+					return
+				}
 
-			case *ast.GenDecl:
-				var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
-				for iota, spec := range d.Specs {
-					switch s := spec.(type) {
-					case *ast.ImportSpec:
-						// import package
-						path, err := validatedImportPath(s.Path.Value)
-						if err != nil {
-							check.errorf(s.Path.Pos(), "invalid import path (%s)", err)
-							continue
-						}
+				imp := check.importPackage(d.spec.Path.Pos(), path, fileDir)
+				if imp == nil {
+					return
+				}
 
-						imp := check.importPackage(s.Path.Pos(), path, fileDir)
-						if imp == nil {
-							continue
-						}
+				// add package to list of explicit imports
+				// (this functionality is provided as a convenience
+				// for clients; it is not needed for type-checking)
+				if !pkgImports[imp] {
+					pkgImports[imp] = true
+					pkg.imports = append(pkg.imports, imp)
+				}
 
-						// add package to list of explicit imports
-						// (this functionality is provided as a convenience
-						// for clients; it is not needed for type-checking)
-						if !pkgImports[imp] {
-							pkgImports[imp] = true
-							pkg.imports = append(pkg.imports, imp)
-						}
-
-						// local name overrides imported package name
-						name := imp.name
-						if s.Name != nil {
-							name = s.Name.Name
-							if path == "C" {
-								// match cmd/compile (not prescribed by spec)
-								check.errorf(s.Name.Pos(), `cannot rename import "C"`)
-								continue
-							}
-							if name == "init" {
-								check.errorf(s.Name.Pos(), "cannot declare init - must be func")
-								continue
-							}
-						}
-
-						obj := NewPkgName(s.Pos(), pkg, name, imp)
-						if s.Name != nil {
-							// in a dot-import, the dot represents the package
-							check.recordDef(s.Name, obj)
-						} else {
-							check.recordImplicit(s, obj)
-						}
-
-						if path == "C" {
-							// match cmd/compile (not prescribed by spec)
-							obj.used = true
-						}
-
-						// add import to file scope
-						if name == "." {
-							// merge imported scope with file scope
-							for _, obj := range imp.scope.elems {
-								// A package scope may contain non-exported objects,
-								// do not import them!
-								if obj.Exported() {
-									// declare dot-imported object
-									// (Do not use check.declare because it modifies the object
-									// via Object.setScopePos, which leads to a race condition;
-									// the object may be imported into more than one file scope
-									// concurrently. See issue #32154.)
-									if alt := fileScope.Insert(obj); alt != nil {
-										check.errorf(s.Name.Pos(), "%s redeclared in this block", obj.Name())
-										check.reportAltDecl(alt)
-									}
-								}
-							}
-							// add position to set of dot-import positions for this file
-							// (this is only needed for "imported but not used" errors)
-							check.addUnusedDotImport(fileScope, imp, s.Pos())
-						} else {
-							// declare imported package object in file scope
-							// (no need to provide s.Name since we called check.recordDef earlier)
-							check.declare(fileScope, nil, obj, token.NoPos)
-						}
-
-					case *ast.ValueSpec:
-						switch d.Tok {
-						case token.CONST:
-							// determine which initialization expressions to use
-							switch {
-							case s.Type != nil || len(s.Values) > 0:
-								last = s
-							case last == nil:
-								last = new(ast.ValueSpec) // make sure last exists
-							}
-
-							// declare all constants
-							for i, name := range s.Names {
-								obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(iota)))
-
-								var init ast.Expr
-								if i < len(last.Values) {
-									init = last.Values[i]
-								}
-
-								d := &declInfo{file: fileScope, vtyp: last.Type, init: init}
-								check.declarePkgObj(name, obj, d)
-							}
-
-							check.arityMatch(s, last)
-
-						case token.VAR:
-							lhs := make([]*Var, len(s.Names))
-							// If there's exactly one rhs initializer, use
-							// the same declInfo d1 for all lhs variables
-							// so that each lhs variable depends on the same
-							// rhs initializer (n:1 var declaration).
-							var d1 *declInfo
-							if len(s.Values) == 1 {
-								// The lhs elements are only set up after the for loop below,
-								// but that's ok because declareVar only collects the declInfo
-								// for a later phase.
-								d1 = &declInfo{file: fileScope, lhs: lhs, vtyp: s.Type, init: s.Values[0]}
-							}
-
-							// declare all variables
-							for i, name := range s.Names {
-								obj := NewVar(name.Pos(), pkg, name.Name, nil)
-								lhs[i] = obj
-
-								d := d1
-								if d == nil {
-									// individual assignments
-									var init ast.Expr
-									if i < len(s.Values) {
-										init = s.Values[i]
-									}
-									d = &declInfo{file: fileScope, vtyp: s.Type, init: init}
-								}
-
-								check.declarePkgObj(name, obj, d)
-							}
-
-							check.arityMatch(s, nil)
-
-						default:
-							check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
-						}
-
-					case *ast.TypeSpec:
-						obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
-						check.declarePkgObj(s.Name, obj, &declInfo{file: fileScope, tdecl: s})
-
-					default:
-						check.invalidAST(s.Pos(), "unknown ast.Spec node %T", s)
+				// local name overrides imported package name
+				name := imp.name
+				if d.spec.Name != nil {
+					name = d.spec.Name.Name
+					if path == "C" {
+						// match cmd/compile (not prescribed by spec)
+						check.errorf(d.spec.Name, _ImportCRenamed, `cannot rename import "C"`)
+						return
+					}
+					if name == "init" {
+						check.errorf(d.spec.Name, _InvalidInitDecl, "cannot declare init - must be func")
+						return
 					}
 				}
 
-			case *ast.FuncDecl:
-				name := d.Name.Name
-				obj := NewFunc(d.Name.Pos(), pkg, name, nil)
-				if !d.IsMethod() {
+				obj := NewPkgName(d.spec.Pos(), pkg, name, imp)
+				if d.spec.Name != nil {
+					// in a dot-import, the dot represents the package
+					check.recordDef(d.spec.Name, obj)
+				} else {
+					check.recordImplicit(d.spec, obj)
+				}
+
+				if path == "C" {
+					// match cmd/compile (not prescribed by spec)
+					obj.used = true
+				}
+
+				// add import to file scope
+				if name == "." {
+					// merge imported scope with file scope
+					for _, obj := range imp.scope.elems {
+						// A package scope may contain non-exported objects,
+						// do not import them!
+						if obj.Exported() {
+							// declare dot-imported object
+							// (Do not use check.declare because it modifies the object
+							// via Object.setScopePos, which leads to a race condition;
+							// the object may be imported into more than one file scope
+							// concurrently. See issue #32154.)
+							if alt := fileScope.Insert(obj); alt != nil {
+								check.errorf(d.spec.Name, _DuplicateDecl, "%s redeclared in this block", obj.Name())
+								check.reportAltDecl(alt)
+							}
+						}
+					}
+					// add position to set of dot-import positions for this file
+					// (this is only needed for "imported but not used" errors)
+					check.addUnusedDotImport(fileScope, imp, d.spec)
+				} else {
+					// declare imported package object in file scope
+					// (no need to provide s.Name since we called check.recordDef earlier)
+					check.declare(fileScope, nil, obj, token.NoPos)
+				}
+			case constDecl:
+				// declare all constants
+				for i, name := range d.spec.Names {
+					obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(d.iota)))
+
+					var init ast.Expr
+					if i < len(d.init) {
+						init = d.init[i]
+					}
+
+					d := &declInfo{file: fileScope, vtyp: d.typ, init: init, inherited: d.inherited}
+					check.declarePkgObj(name, obj, d)
+				}
+
+			case varDecl:
+				lhs := make([]*Var, len(d.spec.Names))
+				// If there's exactly one rhs initializer, use
+				// the same declInfo d1 for all lhs variables
+				// so that each lhs variable depends on the same
+				// rhs initializer (n:1 var declaration).
+				var d1 *declInfo
+				if len(d.spec.Values) == 1 {
+					// The lhs elements are only set up after the for loop below,
+					// but that's ok because declareVar only collects the declInfo
+					// for a later phase.
+					d1 = &declInfo{file: fileScope, lhs: lhs, vtyp: d.spec.Type, init: d.spec.Values[0]}
+				}
+
+				// declare all variables
+				for i, name := range d.spec.Names {
+					obj := NewVar(name.Pos(), pkg, name.Name, nil)
+					lhs[i] = obj
+
+					di := d1
+					if di == nil {
+						// individual assignments
+						var init ast.Expr
+						if i < len(d.spec.Values) {
+							init = d.spec.Values[i]
+						}
+						di = &declInfo{file: fileScope, vtyp: d.spec.Type, init: init}
+					}
+
+					check.declarePkgObj(name, obj, di)
+				}
+			case typeDecl:
+				obj := NewTypeName(d.spec.Name.Pos(), pkg, d.spec.Name.Name, nil)
+				check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, tdecl: d.spec})
+			case funcDecl:
+				info := &declInfo{file: fileScope, fdecl: d.decl}
+				name := d.decl.Name.Name
+				obj := NewFunc(d.decl.Name.Pos(), pkg, name, nil)
+				if !d.decl.IsMethod() {
 					// regular function
-					if d.Recv != nil {
-						check.errorf(d.Recv.Pos(), "method is missing receiver")
+					if d.decl.Recv != nil {
+						check.error(d.decl.Recv, _BadRecv, "method is missing receiver")
 						// treat as function
 					}
 					if name == "init" {
-						if d.Type.TParams != nil {
-							check.softErrorf(d.Type.TParams.Pos(), "func init must have no type parameters")
+						if d.decl.Type.TParams != nil {
+							check.softErrorf(d.decl.Type.TParams, _InvalidInitSig, "func init must have no type parameters")
 						}
-						if t := d.Type; t.Params.NumFields() != 0 || t.Results != nil {
-							check.softErrorf(d.Pos(), "func init must have no arguments and no return values")
+						if t := d.decl.Type; t.Params.NumFields() != 0 || t.Results != nil {
+							// TODO(rFindley) Should this be a hard error?
+							check.softErrorf(d.decl, _InvalidInitSig, "func init must have no arguments and no return values")
 						}
 						// don't declare init functions in the package scope - they are invisible
 						obj.parent = pkg.scope
-						check.recordDef(d.Name, obj)
+						check.recordDef(d.decl.Name, obj)
 						// init functions must have a body
-						if d.Body == nil {
+						if d.decl.Body == nil {
 							// TODO(gri) make this error message consistent with the others above
-							check.softErrorf(obj.pos, "missing function body")
+							check.softErrorf(obj, _MissingInitBody, "missing function body")
 						}
 					} else {
-						check.declare(pkg.scope, d.Name, obj, token.NoPos)
+						check.declare(pkg.scope, d.decl.Name, obj, token.NoPos)
 					}
 				} else {
 					// method
-					// d.Recv != nil && len(d.Recv.List) > 0
-					if !methodTypeParamsOk && d.Type.TParams != nil {
-						check.invalidAST(d.Type.TParams.Pos(), "method must have no type parameters")
-					}
-					ptr, recv, _ := check.unpackRecv(d.Recv.List[0].Type, false)
+
+					// TODO(rFindley) earlier versions of this code checked that methods
+					//                have no type parameters, but this is checked later
+					//                when type checking the function type. Confirm that
+					//                we don't need to check tparams here.
+
+					ptr, recv, _ := check.unpackRecv(d.decl.Recv.List[0].Type, false)
 					// (Methods with invalid receiver cannot be associated to a type, and
 					// methods with blank _ names are never found; no need to collect any
 					// of them. They will still be type-checked with all the other functions.)
 					if recv != nil && name != "_" {
 						methods = append(methods, methodInfo{obj, ptr, recv})
 					}
-					check.recordDef(d.Name, obj)
+					check.recordDef(d.decl.Name, obj)
 				}
-				info := &declInfo{file: fileScope, fdecl: d}
 				// Methods are not package-level objects but we still track them in the
 				// object map so that we can handle them like regular functions (if the
 				// receiver is invalid); also we need their fdecl info when associating
 				// them with their receiver base type, below.
 				check.objMap[obj] = info
 				obj.setOrder(uint32(len(check.objMap)))
-
-			default:
-				check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
 			}
-		}
+		})
 	}
 
 	// verify that objects in package and file scopes have different names
@@ -461,10 +430,10 @@
 		for _, obj := range scope.elems {
 			if alt := pkg.scope.Lookup(obj.Name()); alt != nil {
 				if pkg, ok := obj.(*PkgName); ok {
-					check.errorf(alt.Pos(), "%s already declared through import of %s", alt.Name(), pkg.Imported())
+					check.errorf(alt, _DuplicateDecl, "%s already declared through import of %s", alt.Name(), pkg.Imported())
 					check.reportAltDecl(pkg)
 				} else {
-					check.errorf(alt.Pos(), "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
+					check.errorf(alt, _DuplicateDecl, "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
 					// TODO(gri) dot-imported objects don't have a position; reportAltDecl won't print anything
 					check.reportAltDecl(obj)
 				}
@@ -476,16 +445,17 @@
 	// associate methods with receiver base type name where possible.
 	// Ignore methods that have an invalid receiver. They will be
 	// type-checked later, with regular functions.
-	if methods != nil {
-		check.methods = make(map[*TypeName][]*Func)
-		for i := range methods {
-			m := &methods[i]
-			// Determine the receiver base type and associate m with it.
-			ptr, base := check.resolveBaseTypeName(m.ptr, m.recv)
-			if base != nil {
-				m.obj.hasPtrRecv = ptr
-				check.methods[base] = append(check.methods[base], m.obj)
-			}
+	if methods == nil {
+		return // nothing to do
+	}
+	check.methods = make(map[*TypeName][]*Func)
+	for i := range methods {
+		m := &methods[i]
+		// Determine the receiver base type and associate m with it.
+		ptr, base := check.resolveBaseTypeName(m.ptr, m.recv)
+		if base != nil {
+			m.obj.hasPtrRecv = ptr
+			check.methods[base] = append(check.methods[base], m.obj)
 		}
 	}
 }
@@ -505,6 +475,7 @@
 		case *ast.ParenExpr:
 			rtyp = t.X
 		case *ast.StarExpr:
+			ptr = true
 			rtyp = t.X
 		default:
 			break L
@@ -526,9 +497,9 @@
 				case *ast.BadExpr:
 					// ignore - error already reported by parser
 				case nil:
-					check.invalidAST(ptyp.Pos(), "parameterized receiver contains nil parameters")
+					check.invalidAST(ptyp, "parameterized receiver contains nil parameters")
 				default:
-					check.errorf(arg.Pos(), "receiver type parameter %s must be an identifier", arg)
+					check.errorf(arg, _Todo, "receiver type parameter %s must be an identifier", arg)
 				}
 				if par == nil {
 					par = &ast.Ident{NamePos: arg.Pos(), Name: "_"}
@@ -550,7 +521,7 @@
 // there was a pointer indirection to get to it. The base type name must be declared
 // in package scope, and there can be at most one pointer indirection. If no such type
 // name exists, the returned base is nil.
-func (check *Checker) resolveBaseTypeName(seenPtr bool, typ ast.Expr) (ptr bool, base *TypeName) {
+func (check *Checker) resolveBaseTypeName(seenPtr bool, name *ast.Ident) (ptr bool, base *TypeName) {
 	// Algorithm: Starting from a type expression, which may be a name,
 	// we follow that type through alias declarations until we reach a
 	// non-alias type name. If we encounter anything but pointer types or
@@ -558,6 +529,7 @@
 	// we're done.
 	ptr = seenPtr
 	var seen map[*TypeName]bool
+	var typ ast.Expr = name
 	for {
 		typ = unparen(typ)
 
@@ -686,9 +658,9 @@
 					path := obj.imported.path
 					base := pkgName(path)
 					if obj.name == base {
-						check.softErrorf(obj.pos, "%q imported but not used", path)
+						check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
 					} else {
-						check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
+						check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
 					}
 				}
 			}
@@ -698,7 +670,7 @@
 	// check use of dot-imported packages
 	for _, unusedDotImports := range check.unusedDotImports {
 		for pkg, pos := range unusedDotImports {
-			check.softErrorf(pos, "%q imported but not used", pkg.path)
+			check.softErrorf(pos, _UnusedImport, "%q imported but not used", pkg.path)
 		}
 	}
 }
diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
index 1408937..c4e729e 100644
--- a/src/go/types/sanitize.go
+++ b/src/go/types/sanitize.go
@@ -4,6 +4,8 @@
 
 package types
 
+// sanitizeInfo walks the types contained in info to ensure that all instances
+// are expanded.
 func sanitizeInfo(info *Info) {
 	var s sanitizer = make(map[Type]Type)
 
diff --git a/src/go/types/self_test.go b/src/go/types/self_test.go
index 10ad06f..262dc7b 100644
--- a/src/go/types/self_test.go
+++ b/src/go/types/self_test.go
@@ -5,12 +5,11 @@
 package types_test
 
 import (
-	"flag"
-	"fmt"
 	"go/ast"
 	"go/importer"
 	"go/parser"
 	"go/token"
+	"path"
 	"path/filepath"
 	"testing"
 	"time"
@@ -18,11 +17,9 @@
 	. "go/types"
 )
 
-var benchmark = flag.Bool("b", false, "run benchmarks")
-
 func TestSelf(t *testing.T) {
 	fset := token.NewFileSet()
-	files, err := pkgFiles(fset, ".")
+	files, err := pkgFiles(fset, ".", 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -39,36 +36,39 @@
 	}
 }
 
-func TestBenchmark(t *testing.T) {
-	if !*benchmark {
-		return
-	}
-
-	// We're not using testing's benchmarking mechanism directly
-	// because we want custom output.
-
-	for _, p := range []string{"types", "constant", filepath.Join("internal", "gcimporter")} {
-		path := filepath.Join("..", p)
-		runbench(t, path, false)
-		runbench(t, path, true)
-		fmt.Println()
+func BenchmarkCheck(b *testing.B) {
+	for _, p := range []string{
+		"net/http",
+		"go/parser",
+		"go/constant",
+		filepath.Join("go", "internal", "gcimporter"),
+	} {
+		b.Run(path.Base(p), func(b *testing.B) {
+			path := filepath.Join("..", "..", p)
+			for _, ignoreFuncBodies := range []bool{false, true} {
+				name := "funcbodies"
+				if ignoreFuncBodies {
+					name = "nofuncbodies"
+				}
+				b.Run(name, func(b *testing.B) {
+					b.Run("info", func(b *testing.B) {
+						runbench(b, path, ignoreFuncBodies, true)
+					})
+					b.Run("noinfo", func(b *testing.B) {
+						runbench(b, path, ignoreFuncBodies, false)
+					})
+				})
+			}
+		})
 	}
 }
 
-func runbench(t *testing.T, path string, ignoreFuncBodies bool) {
+func runbench(b *testing.B, path string, ignoreFuncBodies, writeInfo bool) {
 	fset := token.NewFileSet()
-	files, err := pkgFiles(fset, path)
+	files, err := pkgFiles(fset, path, 0)
 	if err != nil {
-		t.Fatal(err)
+		b.Fatal(err)
 	}
-
-	b := testing.Benchmark(func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			conf := Config{IgnoreFuncBodies: ignoreFuncBodies}
-			conf.Check(path, fset, files, nil)
-		}
-	})
-
 	// determine line count
 	lines := 0
 	fset.Iterate(func(f *token.File) bool {
@@ -76,14 +76,33 @@
 		return true
 	})
 
-	d := time.Duration(b.NsPerOp())
-	fmt.Printf(
-		"%s: %s for %d lines (%d lines/s), ignoreFuncBodies = %v\n",
-		filepath.Base(path), d, lines, int64(float64(lines)/d.Seconds()), ignoreFuncBodies,
-	)
+	b.ResetTimer()
+	start := time.Now()
+	for i := 0; i < b.N; i++ {
+		conf := Config{
+			IgnoreFuncBodies: ignoreFuncBodies,
+			Importer:         importer.Default(),
+		}
+		var info *Info
+		if writeInfo {
+			info = &Info{
+				Types:      make(map[ast.Expr]TypeAndValue),
+				Defs:       make(map[*ast.Ident]Object),
+				Uses:       make(map[*ast.Ident]Object),
+				Implicits:  make(map[ast.Node]Object),
+				Selections: make(map[*ast.SelectorExpr]*Selection),
+				Scopes:     make(map[ast.Node]*Scope),
+			}
+		}
+		if _, err := conf.Check(path, fset, files, info); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+	b.ReportMetric(float64(lines)*float64(b.N)/time.Since(start).Seconds(), "lines/s")
 }
 
-func pkgFiles(fset *token.FileSet, path string) ([]*ast.File, error) {
+func pkgFiles(fset *token.FileSet, path string, mode parser.Mode) ([]*ast.File, error) {
 	filenames, err := pkgFilenames(path) // from stdlib_test.go
 	if err != nil {
 		return nil, err
@@ -91,7 +110,7 @@
 
 	var files []*ast.File
 	for _, filename := range filenames {
-		file, err := parser.ParseFile(fset, filename, nil, 0)
+		file, err := parser.ParseFile(fset, filename, nil, mode)
 		if err != nil {
 			return nil, err
 		}
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 049d546..7a4a0ea 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -156,6 +156,9 @@
 	testTestDir(t, filepath.Join(runtime.GOROOT(), "test"),
 		"cmplxdivide.go", // also needs file cmplxdivide1.go - ignore
 		"directive.go",   // tests compiler rejection of bad directive placement - ignore
+		"embedfunc.go",   // tests //go:embed
+		"embedvers.go",   // tests //go:embed
+		"linkname2.go",   // go/types doesn't check validity of //go:xxx directives
 	)
 }
 
@@ -183,7 +186,8 @@
 		"issue31747.go",  // go/types does not have constraints on language level (-lang=go1.12) (see #31793)
 		"issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
 		"bug251.go",      // issue #34333 which was exposed with fix for #34151
-		"bug299.go",      // go/types permits parenthesized embedded fields (TODO(gri) remove once we disallow this again because we switched to []'s)
+		"issue42058a.go", // go/types does not have constraints on channel element size
+		"issue42058b.go", // go/types does not have constraints on channel element size
 	)
 }
 
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 1102fb6..82c21c2 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -14,7 +14,7 @@
 )
 
 func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt, iota constant.Value) {
-	if check.conf.Trace {
+	if trace {
 		check.trace(body.Pos(), "--- %s: %s", name, sig)
 		defer func() {
 			check.trace(body.End(), "--- <end>")
@@ -46,7 +46,7 @@
 	}
 
 	if sig.results.Len() > 0 && !check.isTerminating(body, "") {
-		check.error(body.Rbrace, "missing return")
+		check.error(atPos(body.Rbrace), _MissingReturn, "missing return")
 	}
 
 	// TODO(gri) Should we make it an error to declare generic functions
@@ -70,7 +70,7 @@
 		return unused[i].pos < unused[j].pos
 	})
 	for _, v := range unused {
-		check.softErrorf(v.pos, "%s declared but not used", v.name)
+		check.softErrorf(v, _UnusedVar, "%s declared but not used", v.name)
 	}
 
 	for _, scope := range scope.children {
@@ -140,11 +140,11 @@
 				d = s
 			}
 		default:
-			check.invalidAST(s.Pos(), "case/communication clause expected")
+			check.invalidAST(s, "case/communication clause expected")
 		}
 		if d != nil {
 			if first != nil {
-				check.errorf(d.Pos(), "multiple defaults (first at %s)", check.fset.Position(first.Pos()))
+				check.errorf(d, _DuplicateDefault, "multiple defaults (first at %s)", check.fset.Position(first.Pos()))
 			} else {
 				first = d
 			}
@@ -173,17 +173,23 @@
 func (check *Checker) suspendedCall(keyword string, call *ast.CallExpr) {
 	var x operand
 	var msg string
+	var code errorCode
 	switch check.rawExpr(&x, call, nil) {
 	case conversion:
 		msg = "requires function call, not conversion"
+		code = _InvalidDefer
+		if keyword == "go" {
+			code = _InvalidGo
+		}
 	case expression:
 		msg = "discards result of"
+		code = _UnusedResults
 	case statement:
 		return
 	default:
 		unreachable()
 	}
-	check.errorf(x.pos(), "%s %s %s", keyword, msg, &x)
+	check.errorf(&x, code, "%s %s %s", keyword, msg, &x)
 }
 
 // goVal returns the Go value for val, or nil.
@@ -255,17 +261,17 @@
 			// (quadratic algorithm, but these lists tend to be very short)
 			for _, vt := range seen[val] {
 				if check.identical(v.typ, vt.typ) {
-					check.errorf(v.pos(), "duplicate case %s in expression switch", &v)
-					check.error(vt.pos, "\tprevious case") // secondary error, \t indented
+					check.errorf(&v, _DuplicateCase, "duplicate case %s in expression switch", &v)
+					check.error(atPos(vt.pos), _DuplicateCase, "\tprevious case") // secondary error, \t indented
 					continue L
 				}
 			}
-			seen[val] = append(seen[val], valueType{v.pos(), v.typ})
+			seen[val] = append(seen[val], valueType{v.Pos(), v.typ})
 		}
 	}
 }
 
-func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []ast.Expr, seen map[Type]token.Pos, strict bool) (T Type) {
+func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []ast.Expr, seen map[Type]ast.Expr) (T Type) {
 L:
 	for _, e := range types {
 		T = check.typeOrNil(e)
@@ -273,25 +279,25 @@
 			continue L
 		}
 		if T != nil {
-			check.ordinaryType(e.Pos(), T)
+			check.ordinaryType(e, T)
 		}
 		// look for duplicate types
 		// (quadratic algorithm, but type switches tend to be reasonably small)
-		for t, pos := range seen {
+		for t, other := range seen {
 			if T == nil && t == nil || T != nil && t != nil && check.identical(T, t) {
 				// talk about "case" rather than "type" because of nil case
 				Ts := "nil"
 				if T != nil {
 					Ts = T.String()
 				}
-				check.errorf(e.Pos(), "duplicate case %s in type switch", Ts)
-				check.error(pos, "\tprevious case") // secondary error, \t indented
+				check.errorf(e, _DuplicateCase, "duplicate case %s in type switch", Ts)
+				check.error(other, _DuplicateCase, "\tprevious case") // secondary error, \t indented
 				continue L
 			}
 		}
-		seen[T] = e.Pos()
+		seen[T] = e
 		if T != nil {
-			check.typeAssertion(e.Pos(), x, xtyp, T, strict)
+			check.typeAssertion(e, x, xtyp, T)
 		}
 	}
 	return
@@ -332,18 +338,22 @@
 		var x operand
 		kind := check.rawExpr(&x, s.X, nil)
 		var msg string
+		var code errorCode
 		switch x.mode {
 		default:
 			if kind == statement {
 				return
 			}
 			msg = "is not used"
+			code = _UnusedExpr
 		case builtin:
 			msg = "must be called"
+			code = _UncalledBuiltin
 		case typexpr:
 			msg = "is not an expression"
+			code = _NotAnExpr
 		}
-		check.errorf(x.pos(), "%s %s", &x, msg)
+		check.errorf(&x, code, "%s %s", &x, msg)
 
 	case *ast.SendStmt:
 		var ch, x operand
@@ -355,12 +365,12 @@
 
 		tch := asChan(ch.typ)
 		if tch == nil {
-			check.invalidOp(s.Arrow, "cannot send to non-chan type %s", ch.typ)
+			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to non-chan type %s", ch.typ)
 			return
 		}
 
 		if tch.dir == RecvOnly {
-			check.invalidOp(s.Arrow, "cannot send to receive-only type %s", tch)
+			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to receive-only type %s", tch)
 			return
 		}
 
@@ -374,7 +384,7 @@
 		case token.DEC:
 			op = token.SUB
 		default:
-			check.invalidAST(s.TokPos, "unknown inc/dec operation %s", s.Tok)
+			check.invalidAST(inNode(s, s.TokPos), "unknown inc/dec operation %s", s.Tok)
 			return
 		}
 
@@ -384,12 +394,12 @@
 			return
 		}
 		if !isNumeric(x.typ) {
-			check.invalidOp(s.X.Pos(), "%s%s (non-numeric type %s)", s.X, s.Tok, x.typ)
+			check.invalidOp(s.X, _NonNumericIncDec, "%s%s (non-numeric type %s)", s.X, s.Tok, x.typ)
 			return
 		}
 
 		Y := &ast.BasicLit{ValuePos: s.X.Pos(), Kind: token.INT, Value: "1"} // use x's position
-		check.binary(&x, nil, s.X, Y, op)
+		check.binary(&x, nil, s.X, Y, op, s.TokPos)
 		if x.mode == invalid {
 			return
 		}
@@ -399,11 +409,11 @@
 		switch s.Tok {
 		case token.ASSIGN, token.DEFINE:
 			if len(s.Lhs) == 0 {
-				check.invalidAST(s.Pos(), "missing lhs in assignment")
+				check.invalidAST(s, "missing lhs in assignment")
 				return
 			}
 			if s.Tok == token.DEFINE {
-				check.shortVarDecl(s.TokPos, s.Lhs, s.Rhs)
+				check.shortVarDecl(inNode(s, s.TokPos), s.Lhs, s.Rhs)
 			} else {
 				// regular assignment
 				check.assignVars(s.Lhs, s.Rhs)
@@ -412,16 +422,16 @@
 		default:
 			// assignment operations
 			if len(s.Lhs) != 1 || len(s.Rhs) != 1 {
-				check.errorf(s.TokPos, "assignment operation %s requires single-valued expressions", s.Tok)
+				check.errorf(inNode(s, s.TokPos), _MultiValAssignOp, "assignment operation %s requires single-valued expressions", s.Tok)
 				return
 			}
 			op := assignOp(s.Tok)
 			if op == token.ILLEGAL {
-				check.invalidAST(s.TokPos, "unknown assignment operation %s", s.Tok)
+				check.invalidAST(atPos(s.TokPos), "unknown assignment operation %s", s.Tok)
 				return
 			}
 			var x operand
-			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op)
+			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op, s.TokPos)
 			if x.mode == invalid {
 				return
 			}
@@ -445,8 +455,8 @@
 				// with the same name as a result parameter is in scope at the place of the return."
 				for _, obj := range res.vars {
 					if alt := check.lookup(obj.name); alt != nil && alt != obj {
-						check.errorf(s.Pos(), "result parameter %s not in scope at return", obj.name)
-						check.errorf(alt.Pos(), "\tinner declaration of %s", obj)
+						check.errorf(s, _OutOfScopeResult, "result parameter %s not in scope at return", obj.name)
+						check.errorf(alt, _OutOfScopeResult, "\tinner declaration of %s", obj)
 						// ok to continue
 					}
 				}
@@ -455,7 +465,7 @@
 				check.initVars(res.vars, s.Results, s.Return)
 			}
 		} else if len(s.Results) > 0 {
-			check.error(s.Results[0].Pos(), "no result values expected")
+			check.error(s.Results[0], _WrongResultCount, "no result values expected")
 			check.use(s.Results...)
 		}
 
@@ -467,22 +477,23 @@
 		switch s.Tok {
 		case token.BREAK:
 			if ctxt&breakOk == 0 {
-				check.error(s.Pos(), "break not in for, switch, or select statement")
+				check.error(s, _MisplacedBreak, "break not in for, switch, or select statement")
 			}
 		case token.CONTINUE:
 			if ctxt&continueOk == 0 {
-				check.error(s.Pos(), "continue not in for statement")
+				check.error(s, _MisplacedContinue, "continue not in for statement")
 			}
 		case token.FALLTHROUGH:
 			if ctxt&fallthroughOk == 0 {
 				msg := "fallthrough statement out of place"
+				code := _MisplacedFallthrough
 				if ctxt&finalSwitchCase != 0 {
 					msg = "cannot fallthrough final case in switch"
 				}
-				check.error(s.Pos(), msg)
+				check.error(s, code, msg)
 			}
 		default:
-			check.invalidAST(s.Pos(), "branch statement: %s", s.Tok)
+			check.invalidAST(s, "branch statement: %s", s.Tok)
 		}
 
 	case *ast.BlockStmt:
@@ -499,7 +510,7 @@
 		var x operand
 		check.expr(&x, s.Cond)
 		if x.mode != invalid && !isBoolean(x.typ) {
-			check.error(s.Cond.Pos(), "non-boolean condition in if statement")
+			check.error(s.Cond, _InvalidCond, "non-boolean condition in if statement")
 		}
 		check.stmt(inner, s.Body)
 		// The parser produces a correct AST but if it was modified
@@ -510,7 +521,7 @@
 		case *ast.IfStmt, *ast.BlockStmt:
 			check.stmt(inner, s.Else)
 		default:
-			check.error(s.Else.Pos(), "invalid else branch in if statement")
+			check.invalidAST(s.Else, "invalid else branch in if statement")
 		}
 
 	case *ast.SwitchStmt:
@@ -525,6 +536,10 @@
 			// By checking assignment of x to an invisible temporary
 			// (as a compiler would), we get all the relevant checks.
 			check.assignment(&x, nil, "switch expression")
+			if x.mode != invalid && !Comparable(x.typ) && !hasNil(x.typ) {
+				check.errorf(&x, _InvalidExprSwitch, "cannot switch on %s (%s is not comparable)", &x, x.typ)
+				x.mode = invalid
+			}
 		} else {
 			// spec: "A missing switch expression is
 			// equivalent to the boolean value true."
@@ -540,7 +555,7 @@
 		for i, c := range s.Body.List {
 			clause, _ := c.(*ast.CaseClause)
 			if clause == nil {
-				check.invalidAST(c.Pos(), "incorrect expression switch case")
+				check.invalidAST(c, "incorrect expression switch case")
 				continue
 			}
 			check.caseValues(&x, clause.List, seen)
@@ -577,19 +592,19 @@
 			rhs = guard.X
 		case *ast.AssignStmt:
 			if len(guard.Lhs) != 1 || guard.Tok != token.DEFINE || len(guard.Rhs) != 1 {
-				check.invalidAST(s.Pos(), "incorrect form of type switch guard")
+				check.invalidAST(s, "incorrect form of type switch guard")
 				return
 			}
 
 			lhs, _ = guard.Lhs[0].(*ast.Ident)
 			if lhs == nil {
-				check.invalidAST(s.Pos(), "incorrect form of type switch guard")
+				check.invalidAST(s, "incorrect form of type switch guard")
 				return
 			}
 
 			if lhs.Name == "_" {
 				// _ := x.(type) is an invalid short variable declaration
-				check.softErrorf(lhs.Pos(), "no new variable on left side of :=")
+				check.softErrorf(lhs, _NoNewVar, "no new variable on left side of :=")
 				lhs = nil // avoid declared but not used error below
 			} else {
 				check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
@@ -598,14 +613,14 @@
 			rhs = guard.Rhs[0]
 
 		default:
-			check.invalidAST(s.Pos(), "incorrect form of type switch guard")
+			check.invalidAST(s, "incorrect form of type switch guard")
 			return
 		}
 
 		// rhs must be of the form: expr.(type) and expr must be an ordinary interface
 		expr, _ := rhs.(*ast.TypeAssertExpr)
 		if expr == nil || expr.Type != nil {
-			check.invalidAST(s.Pos(), "incorrect form of type switch guard")
+			check.invalidAST(s, "incorrect form of type switch guard")
 			return
 		}
 		var x operand
@@ -615,23 +630,23 @@
 		}
 		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
-			check.errorf(x.pos(), "%s is not an interface type", &x)
+			check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x)
 			return
 		}
-		check.ordinaryType(x.pos(), xtyp)
+		check.ordinaryType(&x, xtyp)
 
 		check.multipleDefaults(s.Body.List)
 
-		var lhsVars []*Var               // list of implicitly declared lhs variables
-		seen := make(map[Type]token.Pos) // map of seen types to positions
+		var lhsVars []*Var              // list of implicitly declared lhs variables
+		seen := make(map[Type]ast.Expr) // map of seen types to positions
 		for _, s := range s.Body.List {
 			clause, _ := s.(*ast.CaseClause)
 			if clause == nil {
-				check.invalidAST(s.Pos(), "incorrect type switch case")
+				check.invalidAST(s, "incorrect type switch case")
 				continue
 			}
 			// Check each type in this type switch case.
-			T := check.caseTypes(&x, xtyp, clause.List, seen, false)
+			T := check.caseTypes(&x, xtyp, clause.List, seen)
 			check.openScope(clause, "case")
 			// If lhs exists, declare a corresponding variable in the case-local scope.
 			if lhs != nil {
@@ -669,7 +684,7 @@
 				v.used = true // avoid usage error when checking entire function
 			}
 			if !used {
-				check.softErrorf(lhs.Pos(), "%s declared but not used", lhs.Name)
+				check.softErrorf(lhs, _UnusedVar, "%s declared but not used", lhs.Name)
 			}
 		}
 
@@ -706,7 +721,7 @@
 			}
 
 			if !valid {
-				check.error(clause.Comm.Pos(), "select case must be send or receive (possibly with assignment)")
+				check.error(clause.Comm, _InvalidSelectCase, "select case must be send or receive (possibly with assignment)")
 				continue
 			}
 
@@ -728,14 +743,14 @@
 			var x operand
 			check.expr(&x, s.Cond)
 			if x.mode != invalid && !isBoolean(x.typ) {
-				check.error(s.Cond.Pos(), "non-boolean condition in for statement")
+				check.error(s.Cond, _InvalidCond, "non-boolean condition in for statement")
 			}
 		}
 		check.simpleStmt(s.Post)
 		// spec: "The init statement may be a short variable
 		// declaration, but the post statement must not."
 		if s, _ := s.Post.(*ast.AssignStmt); s != nil && s.Tok == token.DEFINE {
-			check.softErrorf(s.Pos(), "cannot declare in post statement")
+			check.softErrorf(s, _InvalidPostDecl, "cannot declare in post statement")
 			// Don't call useLHS here because we want to use the lhs in
 			// this erroneous statement so that we don't get errors about
 			// these lhs variables being declared but not used.
@@ -758,16 +773,17 @@
 			typ := optype(x.typ)
 			if _, ok := typ.(*Chan); ok && s.Value != nil {
 				// TODO(gri) this also needs to happen for channels in generic variables
-				check.softErrorf(s.Value.Pos(), "range over %s permits only one iteration variable", &x)
+				check.softErrorf(atPos(s.Value.Pos()), _InvalidIterVar, "range over %s permits only one iteration variable", &x)
 				// ok to continue
 			}
 			var msg string
 			key, val, msg = rangeKeyVal(typ, isVarName(s.Key), isVarName(s.Value))
 			if key == nil || msg != "" {
 				if msg != "" {
+					// TODO(rFindley) should this be parenthesized, to be consistent with other qualifiers?
 					msg = ": " + msg
 				}
-				check.softErrorf(x.pos(), "cannot range over %s%s", &x, msg)
+				check.softErrorf(&x, _InvalidRangeExpr, "cannot range over %s%s", &x, msg)
 				// ok to continue
 			}
 		}
@@ -801,7 +817,7 @@
 						vars = append(vars, obj)
 					}
 				} else {
-					check.errorf(lhs.Pos(), "cannot declare %s", lhs)
+					check.invalidAST(lhs, "cannot declare %s", lhs)
 					obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
 				}
 
@@ -828,7 +844,7 @@
 					check.declare(check.scope, nil /* recordDef already called */, obj, scopePos)
 				}
 			} else {
-				check.error(s.TokPos, "no new variables on left side of :=")
+				check.error(inNode(s, s.TokPos), _NoNewVar, "no new variables on left side of :=")
 			}
 		} else {
 			// ordinary assignment
@@ -848,7 +864,7 @@
 		check.stmt(inner, s.Body)
 
 	default:
-		check.error(s.Pos(), "invalid statement")
+		check.invalidAST(s, "invalid statement")
 	}
 }
 
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index 00f60dc..ed27488 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -14,6 +14,9 @@
 	"go/token"
 )
 
+// TODO(rFindley) decide error codes for the errors in this file, and check
+//                if error spans can be improved
+
 type substMap struct {
 	// The targs field is currently needed for *Named type substitution.
 	// TODO(gri) rewrite that code, get rid of this field, and make this
@@ -28,7 +31,7 @@
 	assert(len(tpars) == len(targs))
 	proj := make(map[*TypeParam]Type, len(tpars))
 	for i, tpar := range tpars {
-		// We must expand type arguments otherwise *Instance
+		// We must expand type arguments otherwise *instance
 		// types end up as components in composite types.
 		// TODO(gri) explain why this causes problems, if it does
 		targ := expand(targs[i]) // possibly nil
@@ -54,7 +57,7 @@
 }
 
 func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist []token.Pos) (res Type) {
-	if check.conf.Trace {
+	if trace {
 		check.trace(pos, "-- instantiating %s with %s", typ, typeListString(targs))
 		check.indent++
 		defer func() {
@@ -70,7 +73,7 @@
 		}()
 	}
 
-	assert(poslist == nil || len(poslist) <= len(targs))
+	assert(len(poslist) <= len(targs))
 
 	// TODO(gri) What is better here: work with TypeParams, or work with TypeNames?
 	var tparams []*TypeName
@@ -80,9 +83,10 @@
 	case *Signature:
 		tparams = t.tparams
 		defer func() {
-			// If we had an unexpected failure somewhere don't
-			// panic below when asserting res.(*Signature).
-			if res == nil {
+			// If we had an unexpected failure somewhere don't panic below when
+			// asserting res.(*Signature). Check for *Signature in case Typ[Invalid]
+			// is returned.
+			if _, ok := res.(*Signature); !ok {
 				return
 			}
 			// If the signature doesn't use its type parameters, subst
@@ -100,13 +104,12 @@
 	default:
 		check.dump("%v: cannot instantiate %v", pos, typ)
 		unreachable() // only defined types and (defined) functions can be generic
-
 	}
 
 	// the number of supplied types must match the number of type parameters
 	if len(targs) != len(tparams) {
 		// TODO(gri) provide better error message
-		check.errorf(pos, "got %d arguments but %d type parameters", len(targs), len(tparams))
+		check.errorf(atPos(pos), _Todo, "got %d arguments but %d type parameters", len(targs), len(tparams))
 		return Typ[Invalid]
 	}
 
@@ -142,42 +145,31 @@
 		// - check only if we have methods
 		check.completeInterface(token.NoPos, iface)
 		if len(iface.allMethods) > 0 {
-			// If the type argument is a type parameter itself, its pointer designation
-			// must match the pointer designation of the callee's type parameter.
 			// If the type argument is a pointer to a type parameter, the type argument's
 			// method set is empty.
 			// TODO(gri) is this what we want? (spec question)
-			if tparg := asTypeParam(targ); tparg != nil {
-				if tparg.ptr != tpar.ptr {
-					check.errorf(pos, "pointer designation mismatch")
-					break
-				}
-			} else if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
-				check.errorf(pos, "%s has no methods", targ)
+			if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
+				check.errorf(atPos(pos), 0, "%s has no methods", targ)
 				break
 			}
-			// If a type parameter is marked as a pointer type, the type bound applies
-			// to a pointer of the type argument.
-			actual := targ
-			if tpar.ptr {
-				actual = NewPointer(targ)
-			}
-			if m, wrong := check.missingMethod(actual, iface, true); m != nil {
+			if m, wrong := check.missingMethod(targ, iface, true); m != nil {
 				// TODO(gri) needs to print updated name to avoid major confusion in error message!
 				//           (print warning for now)
+				// Old warning:
 				// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
 				if m.name == "==" {
 					// We don't want to report "missing method ==".
-					check.softErrorf(pos, "%s does not satisfy comparable", targ)
+					check.softErrorf(atPos(pos), 0, "%s does not satisfy comparable", targ)
 				} else if wrong != nil {
 					// TODO(gri) This can still report uninstantiated types which makes the error message
 					//           more difficult to read then necessary.
-					check.softErrorf(pos,
+					// TODO(rFindley) should this use parentheses rather than ':' for qualification?
+					check.softErrorf(atPos(pos), _Todo,
 						"%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
 						targ, tpar.bound, wrong, m,
 					)
 				} else {
-					check.softErrorf(pos, "%s does not satisfy %s (missing method %s)", targ, tpar.bound, m.name)
+					check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (missing method %s)", targ, tpar.bound, m.name)
 				}
 				break
 			}
@@ -187,20 +179,19 @@
 		if iface.allTypes == nil {
 			continue // nothing to do
 		}
-		// iface.allTypes != nil
 
 		// If targ is itself a type parameter, each of its possible types, but at least one, must be in the
 		// list of iface types (i.e., the targ type list must be a non-empty subset of the iface types).
 		if targ := asTypeParam(targ); targ != nil {
 			targBound := targ.Bound()
 			if targBound.allTypes == nil {
-				check.softErrorf(pos, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
+				check.softErrorf(atPos(pos), _Todo, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
 				break
 			}
-			for _, t := range unpack(targBound.allTypes) {
+			for _, t := range unpackType(targBound.allTypes) {
 				if !iface.isSatisfiedBy(t) {
 					// TODO(gri) match this error message with the one below (or vice versa)
-					check.softErrorf(pos, "%s does not satisfy %s (%s type constraint %s not found in %s)", targ, tpar.bound, targ, t, iface.allTypes)
+					check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (%s type constraint %s not found in %s)", targ, tpar.bound, targ, t, iface.allTypes)
 					break
 				}
 			}
@@ -209,7 +200,7 @@
 
 		// Otherwise, targ's type or underlying type must also be one of the interface types listed, if any.
 		if !iface.isSatisfiedBy(targ) {
-			check.softErrorf(pos, "%s does not satisfy %s (%s or %s not found in %s)", targ, tpar.bound, targ, under(targ), iface.allTypes)
+			check.softErrorf(atPos(pos), _Todo, "%s does not satisfy %s (%s or %s not found in %s)", targ, tpar.bound, targ, under(targ), iface.allTypes)
 			break
 		}
 	}
@@ -290,7 +281,9 @@
 		results := subst.tuple(t.results)
 		if recv != t.recv || params != t.params || results != t.results {
 			return &Signature{
-				rparams:  t.rparams,
+				rparams: t.rparams,
+				// TODO(rFindley) why can't we nil out tparams here, rather than in
+				//                instantiate above?
 				tparams:  t.tparams,
 				scope:    t.scope,
 				recv:     recv,
@@ -342,7 +335,7 @@
 			subst.check.indent--
 		}()
 		dump := func(format string, args ...interface{}) {
-			if subst.check.conf.Trace {
+			if trace {
 				subst.check.trace(subst.pos, format, args...)
 			}
 		}
@@ -352,10 +345,9 @@
 			return t // type is not parameterized
 		}
 
-		var new_targs []Type
+		var newTargs []Type
 
 		if len(t.targs) > 0 {
-
 			// already instantiated
 			dump(">>> %s already instantiated", t)
 			assert(len(t.targs) == len(t.tparams))
@@ -364,32 +356,30 @@
 			// that has a type argument for it.
 			for i, targ := range t.targs {
 				dump(">>> %d targ = %s", i, targ)
-				new_targ := subst.typ(targ)
-				if new_targ != targ {
-					dump(">>> substituted %d targ %s => %s", i, targ, new_targ)
-					if new_targs == nil {
-						new_targs = make([]Type, len(t.tparams))
-						copy(new_targs, t.targs)
+				newTarg := subst.typ(targ)
+				if newTarg != targ {
+					dump(">>> substituted %d targ %s => %s", i, targ, newTarg)
+					if newTargs == nil {
+						newTargs = make([]Type, len(t.tparams))
+						copy(newTargs, t.targs)
 					}
-					new_targs[i] = new_targ
+					newTargs[i] = newTarg
 				}
 			}
 
-			if new_targs == nil {
+			if newTargs == nil {
 				dump(">>> nothing to substitute in %s", t)
 				return t // nothing to substitute
 			}
-
 		} else {
-
 			// not yet instantiated
 			dump(">>> first instantiation of %s", t)
-			new_targs = subst.smap.targs
-
+			// TODO(rFindley) can we instead subst the tparam types here?
+			newTargs = subst.smap.targs
 		}
 
 		// before creating a new named type, check if we have this one already
-		h := instantiatedHash(t, new_targs)
+		h := instantiatedHash(t, newTargs)
 		dump(">>> new type hash: %s", h)
 		if named, found := subst.check.typMap[h]; found {
 			dump(">>> found %s", named)
@@ -401,12 +391,12 @@
 		tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil)
 		named := subst.check.NewNamed(tname, t.underlying, t.methods) // method signatures are updated lazily
 		named.tparams = t.tparams                                     // new type is still parameterized
-		named.targs = new_targs
+		named.targs = newTargs
 		subst.check.typMap[h] = named
 		subst.cache[t] = named
 
 		// do the substitution
-		dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, new_targs)
+		dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, newTargs)
 		named.underlying = subst.typOrNil(t.underlying)
 		named.orig = named.underlying // for cycle detection (Checker.validType)
 
@@ -431,9 +421,9 @@
 func instantiatedHash(typ *Named, targs []Type) string {
 	var buf bytes.Buffer
 	writeTypeName(&buf, typ.obj, nil)
-	buf.WriteByte('(')
+	buf.WriteByte('[')
 	writeTypeList(&buf, targs, nil, nil)
-	buf.WriteByte(')')
+	buf.WriteByte(']')
 
 	// With respect to the represented type, whether a
 	// type is fully expanded or stored as instance
diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/builtins.src
index 69cc487..3c273b0 100644
--- a/src/go/types/testdata/builtins.src
+++ b/src/go/types/testdata/builtins.src
@@ -25,19 +25,19 @@
 	_ = append(s, b)
 	_ = append(s, x /* ERROR cannot use x */ )
 	_ = append(s, s /* ERROR cannot use s */ )
-	_ = append(s... ) /* ERROR not enough arguments */
-	_ = append(s, b, s /* ERROR too many arguments */ ... )
+	_ = append(s...) /* ERROR not enough arguments */
+	_ = append(s, b, s /* ERROR too many arguments */ ...)
 	_ = append(s, 1, 2, 3)
 	_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
-	_ = append(s, 1, 2 /* ERROR too many arguments */ , s... )
+	_ = append(s, 1, 2 /* ERROR too many arguments */, s...)
 	_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
 
 	type S []byte
 	type T string
 	var t T
-	_ = append(s, "foo" /* ERROR cannot convert */ )
+	_ = append(s, "foo" /* ERROR cannot use .* in argument to append */ )
 	_ = append(s, "foo"...)
-	_ = append(S(s), "foo" /* ERROR cannot convert */ )
+	_ = append(S(s), "foo" /* ERROR cannot use .* in argument to append */ )
 	_ = append(S(s), "foo"...)
 	_ = append(s, t /* ERROR cannot use t */ )
 	_ = append(s, t...)
@@ -482,7 +482,7 @@
 }
 
 func make2() {
-	f1 := func() (x []int) { return }
+	f1 /* ERROR not used */ := func() (x []int) { return }
 	_ = make(f0 /* ERROR not a type */ ())
 	_ = make(f1 /* ERROR not a type */ ())
 }
@@ -502,7 +502,7 @@
 }
 
 func new2() {
-	f1 := func() (x []int) { return }
+	f1 /* ERROR not used */ := func() (x []int) { return }
 	_ = new(f0 /* ERROR not a type */ ())
 	_ = new(f1 /* ERROR not a type */ ())
 }
diff --git a/src/go/types/testdata/constdecl.src b/src/go/types/testdata/constdecl.src
index c2f40ed..680c85a 100644
--- a/src/go/types/testdata/constdecl.src
+++ b/src/go/types/testdata/constdecl.src
@@ -107,4 +107,35 @@
 	const x, y, z = 0, 1, unsafe.Sizeof(func() { _ = x /* ERROR "undeclared name" */ + y /* ERROR "undeclared name" */ + z /* ERROR "undeclared name" */ })
 }
 
+// Test cases for errors in inherited constant initialization expressions.
+// Errors related to inherited initialization expressions must appear at
+// the constant identifier being declared, not at the original expression
+// (issues #42991, #42992).
+const (
+	_ byte = 255 + iota
+	/* some gap */
+	_ // ERROR overflows
+	/* some gap */
+	/* some gap */ _ /* ERROR overflows */; _ /* ERROR overflows */
+	/* some gap */
+	_ = 255 + iota
+	_ = byte /* ERROR overflows */ (255) + iota
+	_ /* ERROR overflows */
+)
+
+// Test cases from issue.
+const (
+	ok = byte(iota + 253)
+	bad
+	barn
+	bard // ERROR cannot convert
+)
+
+const (
+	c = len([1 - iota]int{})
+	d
+	e // ERROR invalid array length
+	f // ERROR invalid array length
+)
+
 // TODO(gri) move extra tests from testdata/const0.src into here
diff --git a/src/go/types/testdata/cycles.src b/src/go/types/testdata/cycles.src
index b2ee8ec..218b4ca 100644
--- a/src/go/types/testdata/cycles.src
+++ b/src/go/types/testdata/cycles.src
@@ -65,7 +65,7 @@
 	I6 interface{ I5 }
 
 	// maps
-	M0 map[M0 /* ERROR invalid map key */ ]M0
+	M0 map[M0 /* ERROR incomparable map key */ ]M0
 
 	// channels
 	C0 chan C0
@@ -114,7 +114,7 @@
 		i0 /* ERROR cycle */ interface{ i0 }
 
 		// maps
-		m0 map[m0 /* ERROR invalid map key */ ]m0
+		m0 map[m0 /* ERROR incomparable map key */ ]m0
 
 		// channels
 		c0 chan c0
@@ -123,10 +123,10 @@
 
 // test cases for issue 6667
 
-type A [10]map[A /* ERROR invalid map key */ ]bool
+type A [10]map[A /* ERROR incomparable map key */ ]bool
 
 type S struct {
-	m map[S /* ERROR invalid map key */ ]bool
+	m map[S /* ERROR incomparable map key */ ]bool
 }
 
 // test cases for issue 7236
diff --git a/src/go/types/testdata/cycles2.src b/src/go/types/testdata/cycles2.src
index 5fd9e83..1a7f40a 100644
--- a/src/go/types/testdata/cycles2.src
+++ b/src/go/types/testdata/cycles2.src
@@ -37,7 +37,7 @@
 }
 
 type B interface {
-	a() interface {
+	b() interface {
 		AB
 	}
 }
@@ -59,8 +59,7 @@
 	B
 }
 
-// TODO(gri) This should be a valid compare. See #33656.
-var _ = x /* ERROR cannot compare */ == y
+var _ = x == y
 
 
 // Test case for issue 6638.
diff --git a/src/go/types/testdata/decls0.src b/src/go/types/testdata/decls0.src
index 917cc78..5ad8f53 100644
--- a/src/go/types/testdata/decls0.src
+++ b/src/go/types/testdata/decls0.src
@@ -184,11 +184,13 @@
 func f2(x *f2 /* ERROR "not a type" */ ) {}
 func f3() (x f3 /* ERROR "not a type" */ ) { return }
 func f4() (x *f4 /* ERROR "not a type" */ ) { return }
+// TODO(#43215) this should be detected as a cycle error
+func f5([unsafe.Sizeof(f5)]int) {}
 
-func (S0) m1(x S0 /* ERROR value .* is not a type */ .m1) {}
-func (S0) m2(x *S0 /* ERROR value .* is not a type */ .m2) {}
-func (S0) m3() (x S0 /* ERROR value .* is not a type */ .m3) { return }
-func (S0) m4() (x *S0 /* ERROR value .* is not a type */ .m4) { return }
+func (S0) m1 (x S0 /* ERROR value .* is not a type */ .m1) {}
+func (S0) m2 (x *S0 /* ERROR value .* is not a type */ .m2) {}
+func (S0) m3 () (x S0 /* ERROR value .* is not a type */ .m3) { return }
+func (S0) m4 () (x *S0 /* ERROR value .* is not a type */ .m4) { return }
 
 // interfaces may not have any blank methods
 type BlankI interface {
diff --git a/src/go/types/testdata/decls1.src b/src/go/types/testdata/decls1.src
index e6beb78..f4d2eab 100644
--- a/src/go/types/testdata/decls1.src
+++ b/src/go/types/testdata/decls1.src
@@ -96,6 +96,8 @@
 	v11 = xx/yy*yy - xx
 	v12 = true && false
 	v13 = nil /* ERROR "use of untyped nil" */
+	v14 string = 257 // ERROR cannot use 257 .* as string value in variable declaration$
+	v15 int8 = 257 // ERROR cannot use 257 .* as int8 value in variable declaration .*overflows
 )
 
 // Multiple assignment expressions
diff --git a/src/go/types/testdata/decls2/decls2b.src b/src/go/types/testdata/decls2/decls2b.src
index 8e82c6d..5c55750 100644
--- a/src/go/types/testdata/decls2/decls2b.src
+++ b/src/go/types/testdata/decls2/decls2b.src
@@ -40,17 +40,17 @@
 // Verify by checking that errors are reported.
 func (T /* ERROR "undeclared" */ ) _() {}
 func (T1) _(undeclared /* ERROR "undeclared" */ ) {}
-func (T1) _() int { return "foo" /* ERROR "cannot convert" */ }
+func (T1) _() int { return "foo" /* ERROR "cannot use .* in return statement" */ }
 
 // Methods with undeclared receiver type can still be checked.
 // Verify by checking that errors are reported.
 func (Foo /* ERROR "undeclared" */ ) m() {}
 func (Foo /* ERROR "undeclared" */ ) m(undeclared /* ERROR "undeclared" */ ) {}
-func (Foo /* ERROR "undeclared" */ ) m() int { return "foo" /* ERROR "cannot convert" */ }
+func (Foo /* ERROR "undeclared" */ ) m() int { return "foo" /* ERROR "cannot use .* in return statement" */ }
 
 func (Foo /* ERROR "undeclared" */ ) _() {}
 func (Foo /* ERROR "undeclared" */ ) _(undeclared /* ERROR "undeclared" */ ) {}
-func (Foo /* ERROR "undeclared" */ ) _() int { return "foo" /* ERROR "cannot convert" */ }
+func (Foo /* ERROR "undeclared" */ ) _() int { return "foo" /* ERROR "cannot use .* in return statement" */ }
 
 // Receiver declarations are regular parameter lists;
 // receiver types may use parentheses, and the list
@@ -72,4 +72,4 @@
 	_ = (*T7).m4
 	_ = (*T7).m5
 	_ = (*T7).m6
-)
\ No newline at end of file
+)
diff --git a/src/go/types/testdata/expr3.src b/src/go/types/testdata/expr3.src
index 1aa21b6..c3158e6 100644
--- a/src/go/types/testdata/expr3.src
+++ b/src/go/types/testdata/expr3.src
@@ -7,9 +7,8 @@
 import "time"
 
 func indexes() {
-	var x int
 	_ = 1 /* ERROR "cannot index" */ [0]
-	_ = x /* ERROR "cannot index" */ [0]
+	_ = indexes /* ERROR "cannot index" */ [0]
 	_ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]
 
 	var a [10]int
@@ -44,9 +43,9 @@
 	_ = a[:10:10]
 	_ = a[:11 /* ERROR "index .* out of bounds" */ :10]
 	_ = a[:10:11 /* ERROR "index .* out of bounds" */ ]
-	_ = a[10:0:10] /* ERROR "invalid slice indices" */
-	_ = a[0:10:0] /* ERROR "invalid slice indices" */
-	_ = a[10:0:0] /* ERROR "invalid slice indices" */
+	_ = a[10:0:10] /* ERROR swapped slice indices" */
+	_ = a[0:10:0] /* ERROR "swapped slice indices" */
+	_ = a[10:0:0] /* ERROR "swapped slice indices" */
 	_ = &a /* ERROR "cannot take address" */ [:10]
 
 	pa := &a
@@ -62,9 +61,9 @@
 	_ = pa[:10:10]
 	_ = pa[:11 /* ERROR "index .* out of bounds" */ :10]
 	_ = pa[:10:11 /* ERROR "index .* out of bounds" */ ]
-	_ = pa[10:0:10] /* ERROR "invalid slice indices" */
-	_ = pa[0:10:0] /* ERROR "invalid slice indices" */
-	_ = pa[10:0:0] /* ERROR "invalid slice indices" */
+	_ = pa[10:0:10] /* ERROR "swapped slice indices" */
+	_ = pa[0:10:0] /* ERROR "swapped slice indices" */
+	_ = pa[10:0:0] /* ERROR "swapped slice indices" */
 	_ = &pa /* ERROR "cannot take address" */ [:10]
 
 	var b [0]int
@@ -82,20 +81,20 @@
 	_ = s[: - /* ERROR "negative" */ 1]
 	_ = s[0]
 	_ = s[1:2]
-	_ = s[2:1] /* ERROR "invalid slice indices" */
+	_ = s[2:1] /* ERROR "swapped slice indices" */
 	_ = s[2:]
 	_ = s[: 1 /* ERROR "overflows" */ <<100]
 	_ = s[1 /* ERROR "overflows" */ <<100 :]
 	_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
 	_ = s[: /* ERROR "2nd index required" */ :  /* ERROR "3rd index required" */ ]
 	_ = s[:10:10]
-	_ = s[10:0:10] /* ERROR "invalid slice indices" */
-	_ = s[0:10:0] /* ERROR "invalid slice indices" */
-	_ = s[10:0:0] /* ERROR "invalid slice indices" */
+	_ = s[10:0:10] /* ERROR "swapped slice indices" */
+	_ = s[0:10:0] /* ERROR "swapped slice indices" */
+	_ = s[10:0:0] /* ERROR "swapped slice indices" */
 	_ = &s /* ERROR "cannot take address" */ [:10]
 
 	var m map[string]int
-	_ = m[0 /* ERROR "cannot convert" */ ]
+	_ = m[0 /* ERROR "cannot use .* in map index" */ ]
 	_ = m /* ERROR "cannot slice" */ ["foo" : "bar"]
 	_ = m["foo"]
 	// ok is of type bool
@@ -103,7 +102,7 @@
 	var ok mybool
 	_, ok = m["bar"]
 	_ = ok
-	_ = m[0 /* ERROR "cannot convert 0" */ ] + "foo" // ERROR "cannot convert"
+	_ = m[0 /* ERROR "cannot use 0" */ ] + "foo" // ERROR "cannot convert"
 
 	var t string
 	_ = t[- /* ERROR "negative" */ 1]
@@ -186,7 +185,7 @@
 	_ = T1{aa /* ERROR "unknown field" */ : 0}
 	_ = T1{1 /* ERROR "invalid field name" */ : 0}
 	_ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
-	_ = T1{a: "foo" /* ERROR "cannot convert" */ }
+	_ = T1{a: "foo" /* ERROR "cannot use .* in struct literal" */ }
 	_ = T1{c /* ERROR "unknown field" */ : 0}
 	_ = T1{T0: { /* ERROR "missing type" */ }} // struct literal element type may not be elided
 	_ = T1{T0: T0{}}
@@ -197,7 +196,7 @@
 	_ = T0{1, b /* ERROR "mixture" */ : 2, 3}
 	_ = T0{1, 2} /* ERROR "too few values" */
 	_ = T0{1, 2, 3, 4  /* ERROR "too many values" */ }
-	_ = T0{1, "foo" /* ERROR "cannot convert" */, 3.4  /* ERROR "truncated" */}
+	_ = T0{1, "foo" /* ERROR "cannot use .* in struct literal" */, 3.4  /* ERROR "cannot use .*\(truncated\)" */}
 
 	// invalid type
 	type P *struct{
@@ -237,7 +236,7 @@
 	_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
 	_ = A1{2.0}
 	_ = A1{2.1 /* ERROR "truncated" */ }
-	_ = A1{"foo" /* ERROR "cannot convert" */ }
+	_ = A1{"foo" /* ERROR "cannot use .* in array or slice literal" */ }
 
 	// indices must be integer constants
 	i := 1
@@ -303,7 +302,7 @@
 	_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
 	_ = S0{2.0}
 	_ = S0{2.1 /* ERROR "truncated" */ }
-	_ = S0{"foo" /* ERROR "cannot convert" */ }
+	_ = S0{"foo" /* ERROR "cannot use .* in array or slice literal" */ }
 
 	// indices must be resolved correctly
 	const index1 = 1
@@ -356,8 +355,8 @@
 
 	_ = M0{}
 	_ = M0{1 /* ERROR "missing key" */ }
-	_ = M0{1 /* ERROR "cannot convert" */ : 2}
-	_ = M0{"foo": "bar" /* ERROR "cannot convert" */ }
+	_ = M0{1 /* ERROR "cannot use .* in map literal" */ : 2}
+	_ = M0{"foo": "bar" /* ERROR "cannot use .* in map literal" */ }
 	_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }
 
 	_ = map[interface{}]int{2: 1, 2 /* ERROR "duplicate key" */ : 1}
@@ -520,7 +519,7 @@
 	fv(s /* ERROR "cannot use .* in argument" */ )
 	fv(s...)
 	fv(x /* ERROR "cannot use" */ ...)
-	fv(1, s /* ERROR "too many arguments" */ ... )
+	fv(1, s /* ERROR "too many arguments" */ ...)
 	fv(gs /* ERROR "cannot use .* in argument" */ ())
 	fv(gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -529,7 +528,7 @@
 	t.fm(1, 2.0, x)
 	t.fm(s /* ERROR "cannot use .* in argument" */ )
 	t.fm(g1())
-	t.fm(1, s /* ERROR "too many arguments" */ ... )
+	t.fm(1, s /* ERROR "too many arguments" */ ...)
 	t.fm(gs /* ERROR "cannot use .* in argument" */ ())
 	t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -537,7 +536,7 @@
 	T.fm(t, 1, 2.0, x)
 	T.fm(t, s /* ERROR "cannot use .* in argument" */ )
 	T.fm(t, g1())
-	T.fm(t, 1, s /* ERROR "too many arguments" */ ... )
+	T.fm(t, 1, s /* ERROR "too many arguments" */ ...)
 	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
 	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -546,7 +545,7 @@
 	i.fm(1, 2.0, x)
 	i.fm(s /* ERROR "cannot use .* in argument" */ )
 	i.fm(g1())
-	i.fm(1, s /* ERROR "too many arguments" */ ... )
+	i.fm(1, s /* ERROR "too many arguments" */ ...)
 	i.fm(gs /* ERROR "cannot use .* in argument" */ ())
 	i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
 
diff --git a/src/go/types/testdata/issues.go2 b/src/go/types/testdata/issues.go2
index c77599f..ac2dee3 100644
--- a/src/go/types/testdata/issues.go2
+++ b/src/go/types/testdata/issues.go2
@@ -154,7 +154,7 @@
 
 // Infinite generic type declarations must lead to an error.
 type inf1[T any] struct{ _ inf1 /* ERROR illegal cycle */ [T] }
-type inf2[T any] struct{ (inf2 /* ERROR illegal cycle */ [T]) }
+type inf2[T any] struct{ inf2 /* ERROR illegal cycle */ [T] }
 
 // The implementation of conversions T(x) between integers and floating-point
 // numbers checks that both T and x have either integer or floating-point
diff --git a/src/go/types/testdata/issues.src b/src/go/types/testdata/issues.src
index 1bfc7fe..db415ea 100644
--- a/src/go/types/testdata/issues.src
+++ b/src/go/types/testdata/issues.src
@@ -325,8 +325,8 @@
 func issue28281d(... /* ERROR can only use ... with final parameter */ int, int)
 func issue28281e(a, b, c  ... /* ERROR can only use ... with final parameter */ int, d int)
 func issue28281f(... /* ERROR can only use ... with final parameter */ int, ... /* ERROR can only use ... with final parameter */ int, int)
-func (... /* ERROR can only use ... with final parameter in list */ TT) f()
-func issue28281g() (... /* ERROR can only use ... with final parameter in list */ TT)
+func (... /* ERROR can only use ... with final parameter */ TT) f()
+func issue28281g() (... /* ERROR can only use ... with final parameter */ TT)
 
 // Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
 func issue26234a(f *syn.File) {
@@ -354,10 +354,10 @@
 
 func issue35895() {
 	// T is defined in this package, don't qualify its name with the package name.
-	var _ T = 0 // ERROR cannot convert 0 \(untyped int constant\) to T
+	var _ T = 0 // ERROR cannot use 0 \(untyped int constant\) as T
 
 	// There is only one package with name syntax imported, only use the (global) package name in error messages.
-	var _ *syn.File = 0 // ERROR cannot convert 0 \(untyped int constant\) to \*syntax.File
+	var _ *syn.File = 0 // ERROR cannot use 0 \(untyped int constant\) as \*syntax.File
 
 	// Because both t1 and t2 have the same global package name (template),
 	// qualify packages with full path name in this case.
diff --git a/src/go/types/testdata/mtypeparams.go2 b/src/go/types/testdata/mtypeparams.go2
deleted file mode 100644
index 1d12406..0000000
--- a/src/go/types/testdata/mtypeparams.go2
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// If types.Config.AcceptMethodTypeParams is set,
-// the type checker accepts methods that have their
-// own type parameter list.
-
-package p
-
-type S struct{}
-
-func (S) m[T any](v T)
-
-type I interface {
-   m[T any](v T)
-}
-
-type J interface {
-   m[T any](v T)
-}
-
-var _ I = S{}
-var _ I = J(nil)
-
-type C interface{ n() }
-
-type Sc struct{}
-
-func (Sc) m[T C](v T)
-
-type Ic interface {
-   m[T C](v T)
-}
-
-type Jc interface {
-   m[T C](v T)
-}
-
-var _ Ic = Sc{}
-var _ Ic = Jc(nil)
-
-// TODO(gri) These should fail because the constraints don't match.
-var _ I = Sc{}
-var _ I = Jc(nil)
-
-var _ Ic = S{}
-var _ Ic = J(nil)
diff --git a/src/go/types/testdata/shifts.src b/src/go/types/testdata/shifts.src
index ebc95ba..c9a38ae 100644
--- a/src/go/types/testdata/shifts.src
+++ b/src/go/types/testdata/shifts.src
@@ -193,14 +193,27 @@
 	_ = float32(1.0 /* ERROR "must be integer" */ <<s)
 	_ = float32(1.1 /* ERROR "must be integer" */ <<s)
 
+	_ = int32(0x80000000 /* ERROR "overflows int32" */ << s)
+	// TODO(rfindley) Eliminate the redundant error here.
+	_ = int32(( /* ERROR "truncated to int32" */ 0x80000000 /* ERROR "truncated to int32" */ + 0i) << s)
+
+	_ = int(1+0i<<0)
+	_ = int((1+0i)<<s)
+	_ = int(1.0<<s)
+	_ = int(complex(1, 0)<<s)
+	_ = int(float32/* ERROR "must be integer" */(1.0) <<s)
+	_ = int(1.1 /* ERROR must be integer */ <<s)
+	_ = int(( /* ERROR "must be integer" */ 1+1i)  <<s)
+
+	_ = complex(1 /* ERROR "must be integer" */ <<s, 0)
+
 	var b []int
 	_ = append(b, 1<<s)
 	_ = append(b, 1.0<<s)
+	_ = append(b, (1+0i)<<s)
 	_ = append(b, 1.1 /* ERROR "must be integer" */ <<s)
-
-	_ = append(b, 1<<s)
-	_ = append(b, 1.0<<s) // should fail - see TODO in append code
-	_ = append(b, 1.1 /* ERROR "must be integer" */ <<s)
+	_ = append(b, (1 + 0i) <<s)
+	_ = append(b, ( /* ERROR "must be integer" */ 1 + 1i)  <<s)
 
 	_ = complex(1.0 /* ERROR "must be integer" */ <<s, 0)
 	_ = complex(1.1 /* ERROR "must be integer" */ <<s, 0)
@@ -379,4 +392,4 @@
 	var _ int8 = 0xff /* ERROR "overflows int8" */ << s
 	var _ int16 = 0xffff /* ERROR "overflows int16" */ << s
 	var _ int32 = 0x80000000 /* ERROR "overflows int32" */ << s
-}
\ No newline at end of file
+}
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index c89ff7f..297e34b 100644
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -182,7 +182,7 @@
 	var x int
 	x <- /* ERROR "cannot send" */ x
 	rch <- /* ERROR "cannot send" */ x
-	ch <- "foo" /* ERROR "cannot convert" */
+	ch <- "foo" /* ERROR "cannot use .* in send" */
 	ch <- x
 }
 
@@ -381,13 +381,13 @@
 func returns1(x float64) (int, *float64) {
 	return 0, &x
 	return /* ERROR wrong number of return values */
-	return "foo" /* ERROR "cannot convert" */, x /* ERROR "cannot use .* in return statement" */
+	return "foo" /* ERROR "cannot .* in return statement" */, x /* ERROR "cannot use .* in return statement" */
 	return /* ERROR wrong number of return values */ 0, &x, 1
 }
 
 func returns2() (a, b int) {
 	return
-	return 1, "foo" /* ERROR cannot convert */
+	return 1, "foo" /* ERROR cannot use .* in return statement */
 	return /* ERROR wrong number of return values */ 1, 2, 3
 	{
 		type a int
@@ -609,7 +609,7 @@
 	// untyped constants are converted to default types
 	switch 1<<63-1 {
 	}
-	switch 1 /* ERROR "overflows int" */ << 63 {
+	switch 1 /* ERROR "cannot use .* as int value.*\(overflows\)" */ << 63 {
 	}
 	var x int
 	switch 1.0 {
@@ -631,9 +631,9 @@
 }
 
 func issue11667() {
-	switch 9223372036854775808 /* ERROR "overflows int" */ {
+	switch 9223372036854775808 /* ERROR "cannot use .* as int value.*\(overflows\)" */ {
 	}
-	switch 9223372036854775808 /* ERROR "overflows int" */ {
+	switch 9223372036854775808 /* ERROR "cannot use .* as int value.*\(overflows\)" */ {
 	case 9223372036854775808:
 	}
 	var x int
@@ -886,7 +886,7 @@
 		ee = e
 		_ = ee
 	}
-	for _ = range sc /* ERROR "send-only channel" */ {}
+	for _ = range sc /* ERROR "cannot range over" */ {}
 	for _ = range rc {}
 
 	// constant strings
diff --git a/src/go/types/testdata/tinference.go2 b/src/go/types/testdata/tinference.go2
index a53fde0..31338b3 100644
--- a/src/go/types/testdata/tinference.go2
+++ b/src/go/types/testdata/tinference.go2
@@ -8,6 +8,9 @@
 
 type any interface{}
 
+// TODO(rFindley) the below partially applied function types should probably
+//                not be permitted (spec question).
+
 func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](A, B, C, D)
 func _() {
 	f := f0[string]
diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/typeparams.go2
index 3e2568d..bdf6d56 100644
--- a/src/go/types/testdata/typeparams.go2
+++ b/src/go/types/testdata/typeparams.go2
@@ -33,7 +33,7 @@
 var _ = reverse[int, float32 /* ERROR got 2 type arguments */ ] ([]int{1, 2, 3})
 var _ = reverse[int]([ /* ERROR cannot use */ ]float32{1, 2, 3})
 var f = reverse[chan int]
-var _ = f(0 /* ERROR cannot convert 0 .* to \[\]chan int */ )
+var _ = f(0 /* ERROR cannot use 0 .* as \[\]chan int */ )
 
 func swap[A, B any](a A, b B) (B, A) { return b, a }
 
@@ -73,7 +73,7 @@
 var _ = new /* ERROR cannot use generic function new */
 var _ *int = new[int]()
 
-func _[T any](map[T /* ERROR invalid map key type T \(missing comparable constraint\) */]int) // w/o constraint we don't know if T is comparable
+func _[T any](map[T /* ERROR incomparable map key type T \(missing comparable constraint\) */]int) // w/o constraint we don't know if T is comparable
 
 func f1[T1 any](struct{T1}) int
 var _ = f1(int)(struct{T1}{})
@@ -229,9 +229,8 @@
 type T struct {}
 
 func (T) m1() {}
-// The type checker accepts method type parameters if configured accordingly.
-func (T) m2[_ any]() {}
-func (T) m3[P any]() {}
+func (T) m2[ /* ERROR methods cannot have type parameters */ _ any]() {}
+func (T) m3[ /* ERROR methods cannot have type parameters */ P any]() {}
 
 // type inference across parameterized types
 
@@ -293,20 +292,20 @@
 
 type R0 struct{}
 
-func (R0) _[T any](x T)
-func (R0 /* ERROR invalid receiver */ ) _[R0 any]() // scope of type parameters starts at "func"
+func (R0) _[ /* ERROR methods cannot have type parameters */ T any](x T)
+func (R0 /* ERROR invalid receiver */ ) _[ /* ERROR methods cannot have type parameters */ R0 any]() // scope of type parameters starts at "func"
 
 type R1[A, B any] struct{}
 
 func (_ R1[A, B]) m0(A, B)
-func (_ R1[A, B]) m1[T any](A, B, T) T
+func (_ R1[A, B]) m1[ /* ERROR methods cannot have type parameters */ T any](A, B, T) T
 func (_ R1 /* ERROR not a generic type */ [R1, _]) _()
-func (_ R1[A, B]) _[A /* ERROR redeclared */ any](B)
+func (_ R1[A, B]) _[ /* ERROR methods cannot have type parameters */ A /* ERROR redeclared */ any](B)
 
 func _() {
         var r R1[int, string]
         r.m1[rune](42, "foo", 'a')
-        r.m1[rune](42, "foo", 1.2 /* ERROR truncated to rune */)
+        r.m1[rune](42, "foo", 1.2 /* ERROR cannot use .* as rune .* \(truncated\) */)
         r.m1(42, "foo", 1.2) // using type inference
         var _ float64 = r.m1(42, "foo", 1.2)
 }
@@ -456,4 +455,4 @@
 
 type T3[P] func(P)
 var _ T3[int]
-*/
\ No newline at end of file
+*/
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 7eeccc5..0fcefef 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -207,8 +207,8 @@
 	// and store it in the Func Object) because when type-checking a function
 	// literal we call the general type checker which returns a general Type.
 	// We then unpack the *Signature and use the scope for the literal body.
-	rparams  []*TypeName // reveiver type parameters from left to right; or nil
-	tparams  []*TypeName // type parameters from left to right; or nil
+	rparams  []*TypeName // receiver type parameters from left to right, or nil
+	tparams  []*TypeName // type parameters from left to right, or nil
 	scope    *Scope      // function scope, present for package-local signatures
 	recv     *Var        // nil if not a method
 	params   *Tuple      // (incoming) parameters from left to right; or nil
@@ -317,7 +317,7 @@
 
 // unpack unpacks a type into a list of types.
 // TODO(gri) Try to eliminate the need for this function.
-func unpack(typ Type) []Type {
+func unpackType(typ Type) []Type {
 	if typ == nil {
 		return nil
 	}
@@ -332,7 +332,7 @@
 	if t.allTypes == nil {
 		return false // we must have at least one type! (was bug)
 	}
-	for _, t := range unpack(t.allTypes) {
+	for _, t := range unpackType(t.allTypes) {
 		if !pred(t) {
 			return false
 		}
@@ -443,10 +443,7 @@
 		return len(t.allMethods) == 0 && t.allTypes == nil
 	}
 	return !t.iterate(func(t *Interface) bool {
-		if len(t.methods) > 0 || t.types != nil {
-			return true
-		}
-		return false
+		return len(t.methods) > 0 || t.types != nil
 	}, nil)
 }
 
@@ -458,10 +455,7 @@
 	}
 
 	return t.iterate(func(t *Interface) bool {
-		if t.types != nil {
-			return true
-		}
-		return false
+		return t.types != nil
 	}, nil)
 }
 
@@ -534,7 +528,7 @@
 	if t.allTypes == nil {
 		return true
 	}
-	types := unpack(t.allTypes)
+	types := unpackType(t.allTypes)
 	return includes(types, typ) || includes(types, under(typ))
 }
 
@@ -726,16 +720,15 @@
 type TypeParam struct {
 	check *Checker  // for lazy type bound completion
 	id    uint64    // unique id
-	ptr   bool      // pointer designation
 	obj   *TypeName // corresponding type name
 	index int       // parameter index
 	bound Type      // *Named or *Interface; underlying type is always *Interface
 }
 
 // NewTypeParam returns a new TypeParam.
-func (check *Checker) NewTypeParam(ptr bool, obj *TypeName, index int, bound Type) *TypeParam {
+func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
 	assert(bound != nil)
-	typ := &TypeParam{check: check, id: check.nextId, ptr: ptr, obj: obj, index: index, bound: bound}
+	typ := &TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
 	check.nextId++
 	if obj.typ == nil {
 		obj.typ = typ
@@ -750,6 +743,7 @@
 	if n, _ := t.bound.(*Named); n != nil {
 		pos = n.obj.pos
 	}
+	// TODO(rFindley) switch this to an unexported method on Checker.
 	t.check.completeInterface(pos, iface)
 	return iface
 }
@@ -765,7 +759,7 @@
 	if t := asTypeParam(typ); t != nil {
 		// If the optype is typ, return the top type as we have
 		// no information. It also prevents infinite recursion
-		// via the TypeParam converter methods. This can happen
+		// via the asTypeParam converter function. This can happen
 		// for a type parameter list of the form:
 		// (type T interface { type T }).
 		// See also issue #39680.
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index 1582f70..64bbb33 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -313,33 +313,17 @@
 }
 
 func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited []Type) {
-	// bound returns the type bound for tname. The result is never nil.
-	bound := func(tname *TypeName) Type {
-		// be careful to avoid crashes in case of inconsistencies
-		if t, _ := tname.typ.(*TypeParam); t != nil && t.bound != nil {
-			return t.bound
-		}
-		return &emptyInterface
-	}
-
-	// If a single type bound is not the empty interface, we have to write them all.
-	var writeBounds bool
-	for _, p := range list {
-		// bound(p) should be an interface but be careful (it may be invalid)
-		b := asInterface(bound(p))
-		if b != nil && !b.Empty() {
-			writeBounds = true
-			break
-		}
-	}
-	writeBounds = true // always write the bounds for new type parameter list syntax
-
+	// TODO(rFindley) compare this with the corresponding implementation in types2
 	buf.WriteString("[")
 	var prev Type
 	for i, p := range list {
-		b := bound(p)
+		// TODO(rFindley) support 'any' sugar here.
+		var b Type = &emptyInterface
+		if t, _ := p.typ.(*TypeParam); t != nil && t.bound != nil {
+			b = t.bound
+		}
 		if i > 0 {
-			if writeBounds && b != prev {
+			if b != prev {
 				// type bound changed - write previous one before advancing
 				buf.WriteByte(' ')
 				writeType(buf, prev, qf, visited)
@@ -349,15 +333,12 @@
 		prev = b
 
 		if t, _ := p.typ.(*TypeParam); t != nil {
-			if t.ptr {
-				buf.WriteByte('*')
-			}
 			writeType(buf, t, qf, visited)
 		} else {
 			buf.WriteString(p.name)
 		}
 	}
-	if writeBounds && prev != nil {
+	if prev != nil {
 		buf.WriteByte(' ')
 		writeType(buf, prev, qf, visited)
 	}
diff --git a/src/go/types/typestring_test.go b/src/go/types/typestring_test.go
index 13d4162..b16529d 100644
--- a/src/go/types/typestring_test.go
+++ b/src/go/types/typestring_test.go
@@ -95,7 +95,10 @@
 	dup("interface{}"),
 	dup("interface{m()}"),
 	dup(`interface{String() string; m(int) float32}`),
-	dup(`interface{type int, float32, complex128}`),
+
+	// TODO(rFindley) uncomment this once this AST is accepted, and add more test
+	// cases.
+	// dup(`interface{type int, float32, complex128}`),
 
 	// maps
 	dup("map[string]int"),
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 89a4085..a6b7314 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -30,9 +30,9 @@
 	scope, obj := check.scope.LookupParent(e.Name, check.pos)
 	if obj == nil {
 		if e.Name == "_" {
-			check.errorf(e.Pos(), "cannot use _ as value or type")
+			check.errorf(e, _InvalidBlank, "cannot use _ as value or type")
 		} else {
-			check.errorf(e.Pos(), "undeclared name: %s", e.Name)
+			check.errorf(e, _UndeclaredName, "undeclared name: %s", e.Name)
 		}
 		return
 	}
@@ -63,7 +63,7 @@
 
 	switch obj := obj.(type) {
 	case *PkgName:
-		check.errorf(e.Pos(), "use of package %s not in selector", obj.name)
+		check.errorf(e, _InvalidPkgUse, "use of package %s not in selector", obj.name)
 		return
 
 	case *Const:
@@ -73,7 +73,7 @@
 		}
 		if obj == universeIota {
 			if check.iota == nil {
-				check.errorf(e.Pos(), "cannot use iota outside constant declaration")
+				check.errorf(e, _InvalidIota, "cannot use iota outside constant declaration")
 				return
 			}
 			x.val = check.iota
@@ -128,26 +128,26 @@
 // (see ordinaryType).
 func (check *Checker) varType(e ast.Expr) Type {
 	typ := check.definedType(e, nil)
-	check.ordinaryType(e.Pos(), typ)
+	check.ordinaryType(e, typ)
 	return typ
 }
 
 // ordinaryType reports an error if typ is an interface type containing
 // type lists or is (or embeds) the predeclared type comparable.
-func (check *Checker) ordinaryType(pos token.Pos, typ Type) {
+func (check *Checker) ordinaryType(pos positioner, typ Type) {
 	// We don't want to call under() (via asInterface) or complete interfaces
 	// while we are in the middle of type-checking parameter declarations that
 	// might belong to interface methods. Delay this check to the end of
 	// type-checking.
 	check.atEnd(func() {
 		if t := asInterface(typ); t != nil {
-			check.completeInterface(pos, t) // TODO(gri) is this the correct position?
+			check.completeInterface(pos.Pos(), t) // TODO(gri) is this the correct position?
 			if t.allTypes != nil {
-				check.softErrorf(pos, "interface contains type constraints (%s)", t.allTypes)
+				check.softErrorf(pos, _Todo, "interface contains type constraints (%s)", t.allTypes)
 				return
 			}
 			if t.IsComparable() {
-				check.softErrorf(pos, "interface is (or embeds) comparable")
+				check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
 			}
 		}
 	})
@@ -171,7 +171,7 @@
 	typ := check.typInternal(e, def)
 	assert(isTyped(typ))
 	if isGeneric(typ) {
-		check.errorf(e.Pos(), "cannot use generic type %s without instantiation", typ)
+		check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
 		typ = Typ[Invalid]
 	}
 	check.recordTypeAndValue(e, typexpr, typ, nil)
@@ -184,7 +184,7 @@
 	assert(isTyped(typ))
 	if typ != Typ[Invalid] && !isGeneric(typ) {
 		if reportErr {
-			check.errorf(e.Pos(), "%s is not a generic type", typ)
+			check.errorf(e, _Todo, "%s is not a generic type", typ)
 		}
 		typ = Typ[Invalid]
 	}
@@ -211,13 +211,13 @@
 	case *ast.CallExpr:
 		var args []ast.Expr
 		for i, arg := range n.Args {
-			Arg := isubst(arg, smap)
-			if Arg != arg {
+			new := isubst(arg, smap)
+			if new != arg {
 				if args == nil {
 					args = make([]ast.Expr, len(n.Args))
 					copy(args, n.Args)
 				}
-				args[i] = Arg
+				args[i] = new
 			}
 		}
 		if args != nil {
@@ -288,14 +288,11 @@
 			// - only do this if we have the right number (otherwise an error is reported elsewhere)
 			if len(sig.rparams) == len(recvTParams) {
 				// We have a list of *TypeNames but we need a list of Types.
-				// While creating this list, also update type parameter pointer designation
-				// for each (*TypeParam) list entry, by copying the information from the
-				// receiver base type's type parameters.
 				list := make([]Type, len(sig.rparams))
 				for i, t := range sig.rparams {
-					t.typ.(*TypeParam).ptr = recvTParams[i].typ.(*TypeParam).ptr
 					list[i] = t.typ
 				}
+				smap := makeSubstMap(recvTParams, list)
 				for i, tname := range sig.rparams {
 					bound := recvTParams[i].typ.(*TypeParam).bound
 					// bound is (possibly) parameterized in the context of the
@@ -304,7 +301,7 @@
 					// TODO(gri) should we assume now that bounds always exist?
 					//           (no bound == empty interface)
 					if bound != nil {
-						bound = check.subst(tname.pos, bound, makeSubstMap(recvTParams, list))
+						bound = check.subst(tname.pos, bound, smap)
 						tname.typ.(*TypeParam).bound = bound
 					}
 				}
@@ -314,11 +311,11 @@
 
 	if ftyp.TParams != nil {
 		sig.tparams = check.collectTypeParams(ftyp.TParams)
-		// Always type-check method type parameters but complain if they are not enabled.
+		// Always type-check method type parameters but complain that they are not allowed.
 		// (A separate check is needed when type-checking interface method signatures because
 		// they don't have a receiver specification.)
-		if recvPar != nil && !check.conf.AcceptMethodTypeParams {
-			check.errorf(ftyp.TParams.Pos(), "methods cannot have type parameters")
+		if recvPar != nil {
+			check.errorf(ftyp.TParams, _Todo, "methods cannot have type parameters")
 		}
 	}
 
@@ -330,7 +327,7 @@
 	params, variadic := check.collectParams(scope, ftyp.Params, nil, true)
 	results, _ := check.collectParams(scope, ftyp.Results, nil, false)
 	scope.Squash(func(obj, alt Object) {
-		check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
+		check.errorf(obj, _DuplicateDecl, "%s redeclared in this block", obj.Name())
 		check.reportAltDecl(alt)
 	})
 
@@ -345,7 +342,7 @@
 			recv = NewParam(0, nil, "", Typ[Invalid]) // ignore recv below
 		default:
 			// more than one receiver
-			check.error(recvList[len(recvList)-1].Pos(), "method must have exactly one receiver")
+			check.error(recvList[len(recvList)-1], _BadRecv, "method must have exactly one receiver")
 			fallthrough // continue with first receiver
 		case 1:
 			recv = recvList[0]
@@ -381,7 +378,7 @@
 				err = "basic or unnamed type"
 			}
 			if err != "" {
-				check.errorf(recv.pos, "invalid receiver %s (%s)", recv.typ, err)
+				check.errorf(recv, _InvalidRecv, "invalid receiver %s (%s)", recv.typ, err)
 				// ok to continue
 			}
 		}
@@ -403,7 +400,7 @@
 // Must only be called by definedType or genericType.
 //
 func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
-	if check.conf.Trace {
+	if trace {
 		check.trace(e0.Pos(), "type %s", e0)
 		check.indent++
 		defer func() {
@@ -440,9 +437,9 @@
 		case invalid:
 			// ignore - error reported before
 		case novalue:
-			check.errorf(x.pos(), "%s used as type", &x)
+			check.errorf(&x, _NotAType, "%s used as type", &x)
 		default:
-			check.errorf(x.pos(), "%s is not a type", &x)
+			check.errorf(&x, _NotAType, "%s is not a type", &x)
 		}
 
 	case *ast.SelectorExpr:
@@ -457,19 +454,20 @@
 		case invalid:
 			// ignore - error reported before
 		case novalue:
-			check.errorf(x.pos(), "%s used as type", &x)
+			check.errorf(&x, _NotAType, "%s used as type", &x)
 		default:
-			check.errorf(x.pos(), "%s is not a type", &x)
+			check.errorf(&x, _NotAType, "%s is not a type", &x)
 		}
 
 	case *ast.IndexExpr:
-		if check.useBrackets {
-			return check.instantiatedType(e.X, []ast.Expr{e.Index}, def)
-		}
-		check.errorf(e0.Pos(), "%s is not a type", e0)
+		return check.instantiatedType(e.X, []ast.Expr{e.Index}, def)
 
 	case *ast.CallExpr:
-		return check.instantiatedType(e.Fun, e.Args, def)
+		if e.Brackets {
+			return check.instantiatedType(e.Fun, e.Args, def)
+		} else {
+			check.errorf(e0, _NotAType, "%s is not a type", e0)
+		}
 
 	case *ast.ParenExpr:
 		// Generic types must be instantiated before they can be used in any form.
@@ -536,7 +534,7 @@
 				if asTypeParam(typ.key) != nil {
 					why = " (missing comparable constraint)"
 				}
-				check.errorf(e.Key.Pos(), "invalid map key type %s%s", typ.key, why)
+				check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
 			}
 		})
 
@@ -555,7 +553,7 @@
 		case ast.RECV:
 			dir = RecvOnly
 		default:
-			check.invalidAST(e.Pos(), "unknown channel direction %d", e.Dir)
+			check.invalidAST(e, "unknown channel direction %d", e.Dir)
 			// ok to continue
 		}
 
@@ -564,7 +562,7 @@
 		return typ
 
 	default:
-		check.errorf(e0.Pos(), "%s is not a type", e0)
+		check.errorf(e0, _NotAType, "%s is not a type", e0)
 	}
 
 	typ := Typ[Invalid]
@@ -584,7 +582,7 @@
 	case invalid:
 		// ignore - error reported before
 	case novalue:
-		check.errorf(x.pos(), "%s used as type", &x)
+		check.errorf(&x, _NotAType, "%s used as type", &x)
 	case typexpr:
 		check.instantiatedOperand(&x)
 		return x.typ
@@ -594,7 +592,7 @@
 		}
 		fallthrough
 	default:
-		check.errorf(x.pos(), "%s is not a type", &x)
+		check.errorf(&x, _NotAType, "%s is not a type", &x)
 	}
 	return Typ[Invalid]
 }
@@ -609,9 +607,9 @@
 		unreachable() // should have been caught by genericType
 	}
 
-	// create a new type Instance rather than instantiate the type
+	// create a new type instance rather than instantiate the type
 	// TODO(gri) should do argument number check here rather than
-	// when instantiating the type?
+	//           when instantiating the type?
 	typ := new(instance)
 	def.setUnderlying(typ)
 
@@ -650,7 +648,7 @@
 	check.expr(&x, e)
 	if x.mode != constant_ {
 		if x.mode != invalid {
-			check.errorf(x.pos(), "array length %s must be constant", &x)
+			check.errorf(&x, _InvalidArrayLen, "array length %s must be constant", &x)
 		}
 		return -1
 	}
@@ -660,12 +658,12 @@
 				if n, ok := constant.Int64Val(val); ok && n >= 0 {
 					return n
 				}
-				check.errorf(x.pos(), "invalid array length %s", &x)
+				check.errorf(&x, _InvalidArrayLen, "invalid array length %s", &x)
 				return -1
 			}
 		}
 	}
-	check.errorf(x.pos(), "array length %s must be integer", &x)
+	check.errorf(&x, _InvalidArrayLen, "array length %s must be integer", &x)
 	return -1
 }
 
@@ -703,7 +701,7 @@
 			if variadicOk && i == len(list.List)-1 && len(field.Names) <= 1 {
 				variadic = true
 			} else {
-				check.softErrorf(t.Pos(), "can only use ... with final parameter in list")
+				check.softErrorf(t, _MisplacedDotDotDot, "can only use ... with final parameter in list")
 				// ignore ... and continue
 			}
 		}
@@ -714,7 +712,7 @@
 			// named parameter
 			for _, name := range field.Names {
 				if name.Name == "" {
-					check.invalidAST(name.Pos(), "anonymous parameter")
+					check.invalidAST(name, "anonymous parameter")
 					// ok to continue
 				}
 				par := NewParam(name.Pos(), check.pkg, name.Name, typ)
@@ -732,7 +730,7 @@
 	}
 
 	if named && anonymous {
-		check.invalidAST(list.Pos(), "list contains both named and anonymous parameters")
+		check.invalidAST(list, "list contains both named and anonymous parameters")
 		// ok to continue
 	}
 
@@ -750,7 +748,7 @@
 
 func (check *Checker) declareInSet(oset *objset, pos token.Pos, obj Object) bool {
 	if alt := oset.insert(obj); alt != nil {
-		check.errorf(pos, "%s redeclared", obj.Name())
+		check.errorf(atPos(pos), _DuplicateDecl, "%s redeclared", obj.Name())
 		check.reportAltDecl(alt)
 		return false
 	}
@@ -768,7 +766,7 @@
 			// and we don't care if a constructed AST has more.)
 			name := f.Names[0]
 			if name.Name == "_" {
-				check.errorf(name.Pos(), "invalid method name _")
+				check.errorf(name, _BlankIfaceMethod, "invalid method name _")
 				continue // ignore
 			}
 
@@ -778,7 +776,7 @@
 				// the author intended to include all types.
 				types = append(types, f.Type)
 				if tlist != nil && tlist != name {
-					check.errorf(name.Pos(), "cannot have multiple type lists in an interface")
+					check.errorf(name, _Todo, "cannot have multiple type lists in an interface")
 				}
 				tlist = name
 				continue
@@ -788,7 +786,7 @@
 			sig, _ := typ.(*Signature)
 			if sig == nil {
 				if typ != Typ[Invalid] {
-					check.invalidAST(f.Type.Pos(), "%s is not a method signature", typ)
+					check.invalidAST(f.Type, "%s is not a method signature", typ)
 				}
 				continue // ignore
 			}
@@ -796,8 +794,8 @@
 			// Always type-check method type parameters but complain if they are not enabled.
 			// (This extra check is needed here because interface method signatures don't have
 			// a receiver specification.)
-			if sig.tparams != nil && !check.conf.AcceptMethodTypeParams {
-				check.errorf(f.Type.(*ast.FuncType).TParams.Pos(), "methods cannot have type parameters")
+			if sig.tparams != nil {
+				check.errorf(f.Type.(*ast.FuncType).TParams, _Todo, "methods cannot have type parameters")
 			}
 
 			// use named receiver type if available (for better error messages)
@@ -847,7 +845,7 @@
 		panic("internal error: incomplete interface")
 	}
 
-	if check.conf.Trace {
+	if trace {
 		// Types don't generally have position information.
 		// If we don't have a valid pos provided, try to use
 		// one close enough.
@@ -892,14 +890,14 @@
 			methods = append(methods, m)
 			mpos[m] = pos
 		case explicit:
-			check.errorf(pos, "duplicate method %s", m.name)
-			check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
+			check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
+			check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
 		default:
 			// check method signatures after all types are computed (issue #33656)
 			check.atEnd(func() {
 				if !check.identical(m.typ, other.Type()) {
-					check.errorf(pos, "duplicate method %s", m.name)
-					check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
+					check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
+					check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
 				}
 			})
 		}
@@ -925,7 +923,8 @@
 				} else {
 					format = "%s is not an interface"
 				}
-				check.errorf(pos, format, typ)
+				// TODO: correct error code.
+				check.errorf(atPos(pos), _InvalidIfaceEmbed, format, typ)
 			}
 			continue
 		}
@@ -962,8 +961,8 @@
 		return x
 	}
 
-	xtypes := unpack(x)
-	ytypes := unpack(y)
+	xtypes := unpackType(x)
+	ytypes := unpackType(y)
 	// Compute the list rtypes which includes only
 	// types that are in both xtypes and ytypes.
 	// Quadratic algorithm, but good enough for now.
@@ -1009,7 +1008,7 @@
 				return val
 			}
 		}
-		check.invalidAST(t.Pos(), "incorrect tag syntax: %q", t.Value)
+		check.invalidAST(t, "incorrect tag syntax: %q", t.Value)
 	}
 	return ""
 }
@@ -1067,24 +1066,31 @@
 			}
 		} else {
 			// embedded field
-			// spec: "An embedded type must be specified as a (possibly parenthesized) type name T or
-			// as a pointer to a non-interface type name *T, and T itself may not be a pointer type."
+			// spec: "An embedded type must be specified as a type name T or as a
+			// pointer to a non-interface type name *T, and T itself may not be a
+			// pointer type."
 			pos := f.Type.Pos()
 			name := embeddedFieldIdent(f.Type)
 			if name == nil {
-				check.errorf(pos, "invalid embedded field type %s", f.Type)
+				// TODO(rFindley): using invalidAST here causes test failures (all
+				//                 errors should have codes). Clean this up.
+				check.errorf(f.Type, _Todo, "invalid AST: embedded field type %s has no name", f.Type)
 				name = ast.NewIdent("_")
 				name.NamePos = pos
 				addInvalid(name, pos)
 				continue
 			}
 			add(name, true, pos)
+
 			// Because we have a name, typ must be of the form T or *T, where T is the name
 			// of a (named or alias) type, and t (= deref(typ)) must be the type of T.
 			// We must delay this check to the end because we don't want to instantiate
 			// (via under(t)) a possibly incomplete type.
-			embeddedTyp := typ // for closure below
-			embeddedPos := pos
+
+			// for use in the closure below
+			embeddedTyp := typ
+			embeddedPos := f.Type
+
 			check.atEnd(func() {
 				t, isPtr := deref(embeddedTyp)
 				switch t := optype(t).(type) {
@@ -1095,13 +1101,13 @@
 					}
 					// unsafe.Pointer is treated like a regular pointer
 					if t.kind == UnsafePointer {
-						check.errorf(embeddedPos, "embedded field type cannot be unsafe.Pointer")
+						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer")
 					}
 				case *Pointer:
-					check.errorf(embeddedPos, "embedded field type cannot be a pointer")
+					check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
 				case *Interface:
 					if isPtr {
-						check.errorf(embeddedPos, "embedded field type cannot be a pointer to an interface")
+						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
 					}
 				}
 			})
@@ -1123,10 +1129,12 @@
 		}
 	case *ast.SelectorExpr:
 		return e.Sel
-	case *ast.CallExpr:
-		return embeddedFieldIdent(e.Fun)
-	case *ast.ParenExpr:
+	case *ast.IndexExpr:
 		return embeddedFieldIdent(e.X)
+	case *ast.CallExpr:
+		if e.Brackets {
+			return embeddedFieldIdent(e.Fun)
+		}
 	}
 	return nil // invalid embedded field
 }
@@ -1135,37 +1143,24 @@
 	list := make([]Type, 0, len(types)) // assume all types are correct
 	for _, texpr := range types {
 		if texpr == nil {
-			check.invalidAST(pos, "missing type constraint")
+			check.invalidAST(atPos(pos), "missing type constraint")
 			continue
 		}
-		typ := check.varType(texpr)
-		// A type constraint may be a predeclared type or a
-		// composite type composed of only predeclared types.
-		// TODO(gri) If we enable this again it also must run
-		// at the end.
-		const restricted = false
-		var why string
-		if restricted && !check.typeConstraint(typ, &why) {
-			check.errorf(texpr.Pos(), "invalid type constraint %s (%s)", typ, why)
-			continue
-		}
-		list = append(list, typ)
+		list = append(list, check.varType(texpr))
 	}
 
-	// Ensure that each type is only present once in the type list.
-	// Types may be interfaces, which may not be complete yet. It's
-	// ok to do this check at the end because it's not a requirement
-	// for correctness of the code.
+	// Ensure that each type is only present once in the type list.  Types may be
+	// interfaces, which may not be complete yet. It's ok to do this check at the
+	// end because it's not a requirement for correctness of the code.
+	// Note: This is a quadratic algorithm, but type lists tend to be short.
 	check.atEnd(func() {
-		uniques := make([]Type, 0, len(list)) // assume all types are unique
 		for i, t := range list {
 			if t := asInterface(t); t != nil {
 				check.completeInterface(types[i].Pos(), t)
 			}
-			if includes(uniques, t) {
-				check.softErrorf(types[i].Pos(), "duplicate type %s in type list", t)
+			if includes(list[:i], t) {
+				check.softErrorf(types[i], _Todo, "duplicate type %s in type list", t)
 			}
-			uniques = append(uniques, t)
 		}
 	})
 
@@ -1181,59 +1176,3 @@
 	}
 	return false
 }
-
-// typeConstraint checks that typ may be used in a type list.
-// For now this just checks for the absence of defined (*Named) types.
-func (check *Checker) typeConstraint(typ Type, why *string) bool {
-	switch t := typ.(type) {
-	case *Basic:
-		// ok
-	case *Array:
-		return check.typeConstraint(t.elem, why)
-	case *Slice:
-		return check.typeConstraint(t.elem, why)
-	case *Struct:
-		for _, f := range t.fields {
-			if !check.typeConstraint(f.typ, why) {
-				return false
-			}
-		}
-	case *Pointer:
-		return check.typeConstraint(t.base, why)
-	case *Tuple:
-		if t == nil {
-			return true
-		}
-		for _, v := range t.vars {
-			if !check.typeConstraint(v.typ, why) {
-				return false
-			}
-		}
-	case *Signature:
-		if len(t.tparams) != 0 {
-			panic("type parameter in function type")
-		}
-		return (t.recv == nil || check.typeConstraint(t.recv.typ, why)) &&
-			check.typeConstraint(t.params, why) &&
-			check.typeConstraint(t.results, why)
-	case *Interface:
-		t.assertCompleteness()
-		for _, m := range t.allMethods {
-			if !check.typeConstraint(m.typ, why) {
-				return false
-			}
-		}
-	case *Map:
-		return check.typeConstraint(t.key, why) && check.typeConstraint(t.elem, why)
-	case *Chan:
-		return check.typeConstraint(t.elem, why)
-	case *Named:
-		*why = check.sprintf("contains defined type %s", t)
-		return false
-	case *TypeParam:
-		// ok, e.g.: func f (type T interface { type T }) ()
-	default:
-		unreachable()
-	}
-	return true
-}
diff --git a/src/go/types/unify.go b/src/go/types/unify.go
index 2bd2068..ab18feb 100644
--- a/src/go/types/unify.go
+++ b/src/go/types/unify.go
@@ -65,9 +65,9 @@
 	unifier *unifier
 	tparams []*TypeName
 	// For each tparams element, there is a corresponding type slot index in indices.
-	// index  < 0: unifier.types[-index] == nil
+	// index  < 0: unifier.types[-index-1] == nil
 	// index == 0: no type slot allocated yet
-	// index  > 0: unifier.types[index] == typ
+	// index  > 0: unifier.types[index-1] == typ
 	// Joined tparams elements share the same type slot and thus have the same index.
 	// By using a negative index for nil types we don't need to check unifier.types
 	// to see if we have a type or not.
@@ -120,13 +120,9 @@
 	case ti > 0:
 		// Only the type parameter for x has an inferred type. Use x slot for y.
 		u.y.setIndex(j, ti)
-	// This case is handled like the default case.
-	// case tj > 0:
-	// 	// Only the type parameter for y has an inferred type. Use y slot for x.
-	// 	u.x.setIndex(i, tj)
 	default:
-		// Neither type parameter has an inferred type. Use y slot for x
-		// (or x slot for y, it doesn't matter).
+		// Either the type parameter for y has an inferred type, or neither type
+		// parameter has an inferred type. In either case, use y slot for x.
 		u.x.setIndex(i, tj)
 	}
 	return true
diff --git a/test/gen/g012.go2 b/test/gen/g012.go2
index 539e069..46d7d61 100644
--- a/test/gen/g012.go2
+++ b/test/gen/g012.go2
@@ -59,19 +59,19 @@
 	r := float64(real(a))
 	i := float64(imag(a))
 	d := math.Sqrt(r * r + i * i)
-	return ComplexAbs(T)(complex(d, 0))
+	return ComplexAbs[T](complex(d, 0))
 }
 
 // OrderedAbsDifference returns the absolute value of the difference
 // between a and b, where a and b are of an ordered type.
 func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
-	return T(AbsDifference(OrderedAbs(T)(a), OrderedAbs(T)(b)))
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
 }
 
 // ComplexAbsDifference returns the absolute value of the difference
 // between a and b, where a and b are of a complex type.
 func ComplexAbsDifference[T Complex](a, b T) T {
-	return T(AbsDifference(ComplexAbs(T)(a), ComplexAbs(T)(b)))
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
 }
 
 func main() {