diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index b331ad9..7407426 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -345,18 +345,18 @@
 		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
-		{genericPkg + `p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[generic_p0.T₁ interface{}](generic_p0.T₁)`},
+		{genericPkg + `p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[generic_p0.T interface{}](generic_p0.T)`},
 		{genericPkg + `p1; func f[T any](T) {}; var _ = f[int]`, `f[int]`, `func(int)`},
 		{genericPkg + `p2; func f[T any](T) {}; func _() { f(42) }`, `f`, `func(int)`},
 		{genericPkg + `p3; func f[T any](T) {}; func _() { f[int](42) }`, `f[int]`, `func(int)`},
-		{genericPkg + `p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[generic_p4.T₁ interface{}](generic_p4.T₁)`},
+		{genericPkg + `p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[generic_p4.T interface{}](generic_p4.T)`},
 		{genericPkg + `p5; func f[T any](T) {}; func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
 		{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[generic_t1.P₁ interface{}]`},
-		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[generic_t2.P₁ interface{}]`},
-		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[generic_t3.P₁, generic_t3.Q₂ interface{}]`},
+		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[generic_t1.P interface{}]`},
+		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[generic_t2.P interface{}]`},
+		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[generic_t3.P, generic_t3.Q interface{}]`},
 
 		// TODO (rFindley): compare with types2, which resolves the type broken_t4.t[P₁, Q₂ interface{m()}] here
 		{broken + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t`},
@@ -365,7 +365,7 @@
 		{genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`},
 
 		// issue 45096
-		{genericPkg + `issue45096; func _[T interface{ ~int8 | ~int16 | ~int32  }](x T) { _ = x < 0 }`, `0`, `generic_issue45096.T₁`},
+		{genericPkg + `issue45096; func _[T interface{ ~int8 | ~int16 | ~int32  }](x T) { _ = x < 0 }`, `0`, `generic_issue45096.T`},
 
 		// issue 47895
 		{`package p; import "unsafe"; type S struct { f int }; var s S; var _ = unsafe.Offsetof(s.f)`, `s.f`, `int`},
diff --git a/src/go/types/builtins_test.go b/src/go/types/builtins_test.go
index cee3d31..db56aea 100644
--- a/src/go/types/builtins_test.go
+++ b/src/go/types/builtins_test.go
@@ -113,15 +113,15 @@
 
 	{"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`},                 // constant
 	{"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant
-	{"Alignof", `var x P; _ = unsafe.Alignof(x)`, `func(p.P₁) uintptr`},
+	{"Alignof", `var x P; _ = unsafe.Alignof(x)`, `func(p.P) uintptr`},
 
 	{"Offsetof", `var x struct{f bool}; _ = unsafe.Offsetof(x.f)`, `invalid type`},           // constant
 	{"Offsetof", `var x struct{_ int; f bool}; _ = unsafe.Offsetof((&x).f)`, `invalid type`}, // constant
-	{"Offsetof", `var x struct{_ int; f P}; _ = unsafe.Offsetof((&x).f)`, `func(p.P₁) uintptr`},
+	{"Offsetof", `var x struct{_ int; f P}; _ = unsafe.Offsetof((&x).f)`, `func(p.P) uintptr`},
 
 	{"Sizeof", `_ = unsafe.Sizeof(0)`, `invalid type`},                 // constant
 	{"Sizeof", `var x struct{}; _ = unsafe.Sizeof(x)`, `invalid type`}, // constant
-	{"Sizeof", `var x P; _ = unsafe.Sizeof(x)`, `func(p.P₁) uintptr`},
+	{"Sizeof", `var x P; _ = unsafe.Sizeof(x)`, `func(p.P) uintptr`},
 
 	{"Slice", `var p *int; _ = unsafe.Slice(p, 1)`, `func(*int, int) []int`},
 	{"Slice", `var p *byte; var n uintptr; _ = unsafe.Slice(p, n)`, `func(*byte, uintptr) []byte`},
diff --git a/src/go/types/errors.go b/src/go/types/errors.go
index 2d48fe1..92002ad 100644
--- a/src/go/types/errors.go
+++ b/src/go/types/errors.go
@@ -63,10 +63,10 @@
 }
 
 func (check *Checker) sprintf(format string, args ...interface{}) string {
-	return sprintf(check.fset, check.qualifier, format, args...)
+	return sprintf(check.fset, check.qualifier, false, format, args...)
 }
 
-func sprintf(fset *token.FileSet, qf Qualifier, format string, args ...interface{}) string {
+func sprintf(fset *token.FileSet, qf Qualifier, debug bool, format string, args ...interface{}) string {
 	for i, arg := range args {
 		switch a := arg.(type) {
 		case nil:
@@ -84,7 +84,7 @@
 		case Object:
 			arg = ObjectString(a, qf)
 		case Type:
-			arg = TypeString(a, qf)
+			arg = typeString(a, qf, debug)
 		}
 		args[i] = arg
 	}
@@ -95,13 +95,13 @@
 	fmt.Printf("%s:\t%s%s\n",
 		check.fset.Position(pos),
 		strings.Repeat(".  ", check.indent),
-		check.sprintf(format, args...),
+		sprintf(check.fset, check.qualifier, true, format, args...),
 	)
 }
 
 // dump is only needed for debugging
 func (check *Checker) dump(format string, args ...interface{}) {
-	fmt.Println(check.sprintf(format, args...))
+	fmt.Println(sprintf(check.fset, check.qualifier, true, format, args...))
 }
 
 func (check *Checker) err(err error) {
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 65c935a..2bb31b1 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -146,7 +146,7 @@
 		qf = check.qualifier
 	}
 	errorf := func(format string, args ...interface{}) error {
-		return errors.New(sprintf(nil, qf, format, args...))
+		return errors.New(sprintf(nil, qf, false, format, args...))
 	}
 
 	// The type parameter bound is parameterized with the same type parameters
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index a0c78e8..2feaf62 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -44,8 +44,14 @@
 // The Qualifier controls the printing of
 // package-level objects, and may be nil.
 func TypeString(typ Type, qf Qualifier) string {
+	return typeString(typ, qf, false)
+}
+
+func typeString(typ Type, qf Qualifier, debug bool) string {
 	var buf bytes.Buffer
-	WriteType(&buf, typ, qf)
+	w := newTypeWriter(&buf, qf)
+	w.debug = debug
+	w.typ(typ)
 	return buf.String()
 }
 
@@ -65,19 +71,20 @@
 }
 
 type typeWriter struct {
-	buf  *bytes.Buffer
-	seen map[Type]bool
-	qf   Qualifier
-	ctxt *Context // if non-nil, we are type hashing
+	buf   *bytes.Buffer
+	seen  map[Type]bool
+	qf    Qualifier
+	ctxt  *Context // if non-nil, we are type hashing
+	debug bool     // if true, write debug annotations
 }
 
 func newTypeWriter(buf *bytes.Buffer, qf Qualifier) *typeWriter {
-	return &typeWriter{buf, make(map[Type]bool), qf, nil}
+	return &typeWriter{buf, make(map[Type]bool), qf, nil, false}
 }
 
 func newTypeHasher(buf *bytes.Buffer, ctxt *Context) *typeWriter {
 	assert(ctxt != nil)
-	return &typeWriter{buf, make(map[Type]bool), nil, ctxt}
+	return &typeWriter{buf, make(map[Type]bool), nil, ctxt, false}
 }
 
 func (w *typeWriter) byte(b byte) {
@@ -274,7 +281,10 @@
 		if t.obj.pkg != nil {
 			writePackage(w.buf, t.obj.pkg, w.qf)
 		}
-		w.string(t.obj.name + subscript(t.id))
+		w.string(t.obj.name)
+		if w.debug || w.ctxt != nil {
+			w.string(subscript(t.id))
+		}
 
 	case *top:
 		w.error("⊤")