@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/go/types/resolver.go

@@ -400,7 +400,10 @@ func (check *Checker) collectObjects() {
 			case funcDecl:
 				name := d.decl.Name.Name
 				obj := NewFunc(d.decl.Name.Pos(), pkg, name, nil) // signature set later
-				hasTParamError := false                           // avoid duplicate type parameter errors
+				var tparam0 *ast.Field
+				if d.decl.Type.TypeParams.NumFields() > 0 {
+					tparam0 = d.decl.Type.TypeParams.List[0]
+				}
 				if d.decl.Recv.NumFields() == 0 {
 					// regular function
 					if d.decl.Recv != nil {
@@ -408,18 +411,20 @@ func (check *Checker) collectObjects() {
 						// treat as function
 					}
 					if name == "init" || (name == "main" && check.pkg.name == "main") {
+						// init and main functions must not declare type and ordinary parameters or results
 						code := InvalidInitDecl
 						if name == "main" {
 							code = InvalidMainDecl
 						}
-						if d.decl.Type.TypeParams.NumFields() != 0 {
-							check.softErrorf(d.decl.Type.TypeParams.List[0], code, "func %s must have no type parameters", name)
-							hasTParamError = true
+						if tparam0 != nil {
+							check.softErrorf(tparam0, code, "func %s must have no type parameters", name)
 						}
 						if t := d.decl.Type; t.Params.NumFields() != 0 || t.Results != nil {
 							// TODO(rFindley) Should this be a hard error?
 							check.softErrorf(d.decl.Name, code, "func %s must have no arguments and no return values", name)
 						}
+					} else {
+						_ = tparam0 != nil && check.verifyVersionf(tparam0, go1_18, "type parameter")
 					}
 					if name == "init" {
 						// don't declare init functions in the package scope - they are invisible
@@ -433,12 +438,6 @@ func (check *Checker) collectObjects() {
 					}
 				} else {
 					// method
-
-					// 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, base, _ := 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
@@ -446,9 +445,9 @@ func (check *Checker) collectObjects() {
 					if recv, _ := base.(*ast.Ident); recv != nil && name != "_" {
 						methods = append(methods, methodInfo{obj, ptr, recv})
 					}
+					_ = tparam0 != nil && check.verifyVersionf(tparam0, go1_27, "generic method")
 					check.recordDef(d.decl.Name, obj)
 				}
-				_ = d.decl.Type.TypeParams.NumFields() != 0 && !hasTParamError && check.verifyVersionf(d.decl.Type.TypeParams.List[0], go1_18, "type parameter")
 				info := &declInfo{file: fileScope, version: check.version, fdecl: d.decl}
 				// 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
@@ -641,13 +640,12 @@ func (check *Checker) packageObjects() {
 		}
 	}
 
-	if false && check.conf._EnableAlias {
-		// With Alias nodes we can process declarations in any order.
+	if false {
+		// TODO: determine if we can enable this code now or
+		//       if there are still problems with cycles and
+		//       aliases.
 		//
-		// TODO(adonovan): unfortunately, Alias nodes
-		// (GODEBUG=gotypesalias=1) don't entirely resolve
-		// problems with cycles. For example, in
-		// GOROOT/test/typeparam/issue50259.go,
+		// For example, in GOROOT/test/typeparam/issue50259.go,
 		//
 		// 	type T[_ any] struct{}
 		// 	type A T[B]
@@ -662,7 +660,7 @@ func (check *Checker) packageObjects() {
 			check.objDecl(obj)
 		}
 	} else {
-		// Without Alias nodes, we process non-alias type declarations first, followed by
+		// To avoid problems with cycles, we process non-alias type declarations first, followed by
 		// alias declarations, and then everything else. This appears to avoid most situations
 		// where the type of an alias is needed before it is available.
 		// There may still be cases where this is not good enough (see also go.dev/issue/25838).

package/bin/go/src/go/types/scope.go

@@ -70,21 +70,7 @@ func (s *Scope) Child(i int) *Scope { return s.children[i] }
 
 // Lookup returns the object in scope s with the given name if such an
 // object exists; otherwise the result is nil.
-func (s *Scope) Lookup(name string) Object {
-	obj := resolve(name, s.elems[name])
-	// Hijack Lookup for "any": with gotypesalias=1, we want the Universe to
-	// return an Alias for "any", and with gotypesalias=0 we want to return
-	// the legacy representation of aliases.
-	//
-	// This is rather tricky, but works out after auditing of the usage of
-	// s.elems. The only external API to access scope elements is Lookup.
-	//
-	// TODO: remove this once gotypesalias=0 is no longer supported.
-	if obj == universeAnyAlias && !aliasAny() {
-		return universeAnyNoAlias
-	}
-	return obj
-}
+func (s *Scope) Lookup(name string) Object { return resolve(name, s.elems[name]) }
 
 // lookupIgnoringCase returns the objects in scope s whose names match
 // the given name ignoring case. If exported is set, only exported names

package/bin/go/src/go/types/selection.go

@@ -95,6 +95,7 @@ func (s *Selection) Obj() Object { return s.obj }
 func (s *Selection) Type() Type {
 	switch s.kind {
 	case MethodVal:
+		// TODO(mark) Align this with call.go if possible.
 		// The type of x.f is a method with its receiver type set
 		// to the type of x.
 		sig := *s.obj.(*Func).typ.(*Signature)
@@ -110,6 +111,7 @@ func (s *Selection) Type() Type {
 		// TODO(gri) Compute this eagerly to avoid allocations.
 		sig := *s.obj.(*Func).typ.(*Signature)
 		arg0 := *sig.recv
+		sig.recvold = sig.recv // stash receiver (for consistency with call.go)
 		sig.recv = nil
 		arg0.typ = s.recv
 		var params []*Var
@@ -120,7 +122,7 @@ func (s *Selection) Type() Type {
 		return &sig
 	}
 
-	// In all other cases, the type of x.f is the type of x.
+	// In all other cases, the type of x.f is the type of f.
 	return s.obj.Type()
 }
 

package/bin/go/src/go/types/signature.go

@@ -27,10 +27,16 @@ type Signature struct {
 	tparams  *TypeParamList // type parameters from left to right, or nil
 	scope    *Scope         // function scope for package-local and non-instantiated signatures; nil otherwise
 	recv     *Var           // nil if not a method
+	recvold  *Var           // receiver dropped via method selection; or nil
 	params   *Tuple         // (incoming) parameters from left to right; or nil
 	results  *Tuple         // (outgoing) results from left to right; or nil
 	variadic bool           // true if the last parameter's type is of the form ...T
 
+	// If recvold is the sentinel value [methExpr], then recvold should
+	// instead be sourced from params[0]. Otherwise, recvold points to
+	// the receiver of the original method signature from which this
+	// function signature was cloned via a selector expression.
+
 	// If variadic, the last element of params ordinarily has an
 	// unnamed Slice type. As a special case, in a call to append,
 	// it may be string, or a TypeParam T whose typeset ⊇ {string, []byte}.
@@ -38,6 +44,9 @@ type Signature struct {
 	// T at such a type.
 }
 
+// sentinel value for detecting method expressions
+var methodExprSentinel = &Var{}
+
 // NewSignature returns a new function type for the given receiver, parameters,
 // and results, either of which may be nil. If variadic is set, the function
 // is variadic, it must have at least one parameter, and the last parameter
@@ -63,8 +72,7 @@ func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
 // type set. It may even be a named []byte slice type resulting from
 // instantiation of such a type parameter.
 //
-// If recv is non-nil, typeParams must be empty. If recvTypeParams is
-// non-empty, recv must be non-nil.
+// If recvTypeParams is non-empty, recv must be non-nil.
 func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature {
 	if variadic {
 		n := params.Len()
@@ -114,9 +122,6 @@ func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params
 		sig.rparams = bindTParams(recvTypeParams)
 	}
 	if len(typeParams) != 0 {
-		if recv != nil {
-			panic("function with type parameters cannot have a receiver")
-		}
 		sig.tparams = bindTParams(typeParams)
 	}
 	return sig
@@ -176,12 +181,6 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 
 	// collect and declare function type parameters
 	if ftyp.TypeParams != nil {
-		// 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.error(ftyp.TypeParams, InvalidMethodTypeParams, "methods cannot have type parameters")
-		}
 		check.collectTypeParams(&sig.tparams, ftyp.TypeParams)
 	}
 

package/bin/go/src/go/types/stmt.go

@@ -239,20 +239,20 @@ L:
 	for _, e := range values {
 		var v operand
 		check.expr(nil, &v, e)
-		if x.mode == invalid || v.mode == invalid {
+		if !x.isValid() || !v.isValid() {
 			continue L
 		}
-		check.convertUntyped(&v, x.typ)
-		if v.mode == invalid {
+		check.convertUntyped(&v, x.typ())
+		if !v.isValid() {
 			continue L
 		}
 		// Order matters: By comparing v against x, error positions are at the case values.
 		res := v // keep original v unchanged
 		check.comparison(&res, x, token.EQL, true)
-		if res.mode == invalid {
+		if !res.isValid() {
 			continue L
 		}
-		if v.mode != constant_ {
+		if v.mode() != constant_ {
 			continue L // we're done
 		}
 		// look for duplicate values
@@ -260,7 +260,7 @@ L:
 			// look for duplicate types for a given value
 			// (quadratic algorithm, but these lists tend to be very short)
 			for _, vt := range seen[val] {
-				if Identical(v.typ, vt.typ) {
+				if Identical(v.typ(), vt.typ) {
 					err := check.newError(DuplicateCase)
 					err.addf(&v, "duplicate case %s in expression switch", &v)
 					err.addf(atPos(vt.pos), "previous case")
@@ -268,7 +268,7 @@ L:
 					continue L
 				}
 			}
-			seen[val] = append(seen[val], valueType{v.Pos(), v.typ})
+			seen[val] = append(seen[val], valueType{v.Pos(), v.typ()})
 		}
 	}
 }
@@ -346,7 +346,7 @@ L:
 	if len(types) != 1 || T == nil {
 		T = Typ[Invalid]
 		if x != nil {
-			T = x.typ
+			T = x.typ()
 		}
 	}
 
@@ -399,7 +399,7 @@ L:
 	if len(types) != 1 || T == nil {
 		T = Typ[Invalid]
 		if x != nil {
-			T = x.typ
+			T = x.typ()
 		}
 	}
 
@@ -445,7 +445,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		kind := check.rawExpr(nil, &x, s.X, nil, false)
 		var msg string
 		var code Code
-		switch x.mode {
+		switch x.mode() {
 		default:
 			if kind == statement {
 				return
@@ -464,8 +464,8 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 	case *ast.SendStmt:
 		var ch, val operand
 		check.expr(nil, &ch, s.Chan)
-		check.expr(nil, &val, s.Value)
-		if ch.mode == invalid || val.mode == invalid {
+		check.genericExpr(&val, s.Value, nil)
+		if !ch.isValid() || !val.isValid() {
 			return
 		}
 		if elem := check.chanElem(inNode(s, s.Arrow), &ch, false); elem != nil {
@@ -486,17 +486,17 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 
 		var x operand
 		check.expr(nil, &x, s.X)
-		if x.mode == invalid {
+		if !x.isValid() {
 			return
 		}
-		if !allNumeric(x.typ) {
-			check.errorf(s.X, NonNumericIncDec, invalidOp+"%s%s (non-numeric type %s)", s.X, s.Tok, x.typ)
+		if !allNumeric(x.typ()) {
+			check.errorf(s.X, NonNumericIncDec, invalidOp+"%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, s.TokPos)
-		if x.mode == invalid {
+		if !x.isValid() {
 			return
 		}
 		check.assignVar(s.X, nil, &x, "assignment")
@@ -528,7 +528,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 			}
 			var x operand
 			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op, s.TokPos)
-			if x.mode == invalid {
+			if !x.isValid() {
 				return
 			}
 			check.assignVar(s.Lhs[0], nil, &x, "assignment")
@@ -609,7 +609,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		check.simpleStmt(s.Init)
 		var x operand
 		check.expr(nil, &x, s.Cond)
-		if x.mode != invalid && !allBoolean(x.typ) {
+		if x.isValid() && !allBoolean(x.typ()) {
 			check.error(s.Cond, InvalidCond, "non-boolean condition in if statement")
 		}
 		check.stmt(inner, s.Body)
@@ -636,15 +636,15 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 			// 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
+			if x.isValid() && !Comparable(x.typ()) && !hasNil(x.typ()) {
+				check.errorf(&x, InvalidExprSwitch, "cannot switch on %s (%s is not comparable)", &x, x.typ())
+				x.invalidate()
 			}
 		} else {
 			// spec: "A missing switch expression is
 			// equivalent to the boolean value true."
-			x.mode = constant_
-			x.typ = Typ[Bool]
+			x.mode_ = constant_
+			x.typ_ = Typ[Bool]
 			x.val = constant.MakeBool(true)
 			x.expr = &ast.Ident{NamePos: s.Body.Lbrace, Name: "true"}
 		}
@@ -728,10 +728,10 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		{
 			var x operand
 			check.expr(nil, &x, expr.X)
-			if x.mode != invalid {
-				if isTypeParam(x.typ) {
+			if x.isValid() {
+				if isTypeParam(x.typ()) {
 					check.errorf(&x, InvalidTypeSwitch, "cannot use type switch on type parameter value %s", &x)
-				} else if IsInterface(x.typ) {
+				} else if IsInterface(x.typ()) {
 					sx = &x
 				} else {
 					check.errorf(&x, InvalidTypeSwitch, "%s is not an interface", &x)
@@ -837,7 +837,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		if s.Cond != nil {
 			var x operand
 			check.expr(nil, &x, s.Cond)
-			if x.mode != invalid && !allBoolean(x.typ) {
+			if x.isValid() && !allBoolean(x.typ()) {
 				check.error(s.Cond, InvalidCond, "non-boolean condition in for statement")
 			}
 		}
@@ -855,7 +855,13 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 
 	case *ast.RangeStmt:
 		inner |= breakOk | continueOk
-		check.rangeStmt(inner, s, inNode(s, s.TokPos), s.Key, s.Value, nil, s.X, s.Tok == token.DEFINE)
+		// s.TokPos is invalid when there are no range variables (for range x {});
+		// noNewVarPos is unused in that case, but inNode asserts a valid pos.
+		tokPos := s.TokPos
+		if !tokPos.IsValid() {
+			tokPos = s.For
+		}
+		check.rangeStmt(inner, s, inNode(s, tokPos), s.Key, s.Value, nil, s.X, s.Tok == token.DEFINE)
 
 	default:
 		check.error(s, InvalidSyntaxTree, "invalid statement")

package/bin/go/src/go/types/subst.go

@@ -164,15 +164,92 @@ func (subst *subster) typ(typ Type) Type {
 		// recv->interface->recv->interface->...
 		recv := t.recv
 
-		params := subst.tuple(t.params)
-		results := subst.tuple(t.results)
-		if params != t.params || results != t.results {
+		// If t is a generic method signature whose own type parameters are not
+		// themselves the subject of this substitution, we are substituting the
+		// receiver type parameters (via Named.expandMethod). Because a method
+		// type parameter's bound may refer to a receiver type parameter
+		// (e.g. func (G[T]) M[P interface{ ~*T }]), we must create fresh type
+		// parameters with substituted bounds, and rename occurrences in params
+		// and results so they refer to the fresh parameters. Otherwise the
+		// resulting signature would retain a free reference to the original
+		// receiver type parameter.
+		//
+		// Fresh type parameters are always created, even when the bounds are
+		// unaffected by the substitution, so that the methods of distinct
+		// instances of the receiver type have distinct (method-specific) type
+		// parameters.
+		//
+		// When t's type parameters are the variables being substituted, we are
+		// instantiating t itself; the caller (Checker.instance for *Signature)
+		// sets tparams to nil afterward, so we leave them in place here.
+		tparams := t.tparams
+		s := subst
+		if n := tparams.Len(); n > 0 {
+			// If (any) one of the signature's type parameters is in the
+			// substitution map, this subst call is an instantiation of the
+			// signature.
+			_, instantiating := subst.smap[tparams.At(0)]
+			if debug {
+				// When calling subst on a signature, the substitution either
+				// applies to all of the type parameters (all are in the map)
+				// or none of them (none are in the map).
+				for _, tp := range tparams.list() {
+					_, ok := subst.smap[tp]
+					assert(ok == instantiating)
+				}
+			}
+			if !instantiating {
+				fresh := make([]*TypeParam, n)
+				// We're introducing a fresh set of method type parameters
+				// which appear elsewhere in the signature (parameter or
+				// result types, or the bounds of other type parameters).
+				// Create an updated substitution map containing the
+				// existing entries plus an entry for each fresh type
+				// parameter so that they are substituted simultaneously
+				// when we proceed with the outer substitution.
+				smap := make(substMap, len(subst.smap)+n)
+				for k, v := range subst.smap {
+					smap[k] = v
+				}
+				for i, tp := range tparams.list() {
+					tname := NewTypeName(tp.Obj().Pos(), tp.Obj().Pkg(), tp.Obj().Name(), nil)
+					ftp := subst.check.newTypeParam(tname, nil)
+					ftp.index = tp.index
+					fresh[i] = ftp
+					smap[tp] = ftp
+					// The fresh parameter stands in for tp in the mono graph,
+					// so that instantiations of (e.g.) G[int].M and G[A].M
+					// are tracked against the same vertex as the origin's tp.
+					if subst.check != nil {
+						subst.check.mono.recordCanon(ftp, tp)
+					}
+				}
+				// Now that we have the updated substitution map, use it to
+				// compute the constraints for the fresh type parameters.
+				for i, tp := range tparams.list() {
+					fresh[i].bound = subst.check.subst(subst.pos, tp.bound, smap, subst.expanding, subst.ctxt)
+				}
+				// Continue with the fresh type parameters and updated map.
+				tparams = &TypeParamList{tparams: fresh}
+				s = &subster{
+					pos:       subst.pos,
+					smap:      smap,
+					check:     subst.check,
+					expanding: subst.expanding,
+					ctxt:      subst.ctxt,
+				}
+			}
+		}
+
+		params := s.tuple(t.params)
+		results := s.tuple(t.results)
+		if params != t.params || results != t.results || tparams != t.tparams {
 			return &Signature{
 				rparams: t.rparams,
-				// TODO(gri) why can't we nil out tparams here, rather than in instantiate?
-				tparams: t.tparams,
+				tparams: tparams,
 				// instantiated signatures have a nil scope
 				recv:     recv,
+				recvold:  t.recvold,
 				params:   params,
 				results:  results,
 				variadic: t.variadic,

package/bin/go/src/go/types/trie.go

@@ -0,0 +1,93 @@
+// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
+// Source: ../../cmd/compile/internal/types2/trie.go
+
+// Copyright 2026 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
+
+import "sort"
+
+// A trie[V] maps keys to values V, similar to a map.
+// A key is a list of integers; two keys collide if one of them is a prefix of the other.
+// For instance, [1, 2] and [1, 2, 3] collide, but [1, 2, 3] and [1, 2, 4] do not.
+// If all keys have length 1, a trie degenerates into an ordinary map[int]V.
+type trie[V any] map[int]any // map value is either trie[V] (non-leaf node), or V (leaf node)
+
+// insert inserts a value with a key into the trie; key must not be empty.
+// If key doesn't collide with any other key in the trie, insert succeeds
+// and returns (val, 0). Otherwise, insert fails and returns (alt, n) where
+// alt is an unspecified but deterministically chosen value with a colliding
+// key and n is the length > 0 of the common key prefix. The trie is not
+// changed in this case.
+func (tr trie[V]) insert(key []int, val V) (V, int) {
+	// A key serves as the path from the trie root to its corresponding value.
+	for l, index := range key {
+		if v, exists := tr[index]; exists {
+			// An entry already exists for this index; check its type to determine collision.
+			switch v := v.(type) {
+			case trie[V]:
+				// Path continues.
+				// Must check this case first in case V is any which would act as catch-all.
+				tr = v
+			case V:
+				// Collision: An existing key ends here.
+				// This means the existing key is a prefix of (or exactly equal to) key.
+				return v, l + 1
+			case nil:
+				// Handle esoteric case where V is any and val is nil.
+				var zero V
+				return zero, l + 1
+			default:
+				panic("trie.insert: invalid entry")
+			}
+		} else {
+			// Path doesn't exist yet, we need to build it.
+			if l == len(key)-1 {
+				// No prefix collision detected; insert val as a new leaf node.
+				tr[index] = val
+				return val, 0
+			}
+			node := make(trie[V])
+			tr[index] = node
+			tr = node
+		}
+	}
+
+	if len(key) == 0 {
+		panic("trie.insert: key must not be empty")
+	}
+
+	// Collision: path ends here, but the trie continues.
+	// This means key is a prefix of an existing key.
+	// Return a value from the subtrie.
+	for len(tr) != 0 {
+		// see switch above
+		switch v := tr.pickValue().(type) {
+		case trie[V]:
+			tr = v
+		case V:
+			return v, len(key)
+		case nil:
+			var zero V
+			return zero, len(key)
+		default:
+			panic("trie.insert: invalid entry")
+		}
+	}
+
+	panic("trie.insert: unreachable")
+}
+
+// pickValue deterministically picks a value of the trie and returns it.
+// Only called in case of a collision.
+// The trie must not be empty.
+func (tr trie[V]) pickValue() any {
+	var keys []int
+	for k := range tr {
+		keys = append(keys, k)
+	}
+	sort.Ints(keys) // guarantee deterministic element pick
+	return tr[keys[0]]
+}

package/bin/go/src/go/types/typelists.go

@@ -7,6 +7,8 @@
 
 package types
 
+import "bytes"
+
 // TypeParamList holds a list of type parameters.
 type TypeParamList struct{ tparams []*TypeParam }
 
@@ -27,6 +29,19 @@ func (l *TypeParamList) list() []*TypeParam {
 	return l.tparams
 }
 
+func (l *TypeParamList) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	for i, tparam := range l.tparams {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		WriteType(&buf, tparam, nil)
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}
+
 // TypeList holds a list of types.
 type TypeList struct{ types []Type }
 
@@ -55,6 +70,19 @@ func (l *TypeList) list() []Type {
 	return l.types
 }
 
+func (l *TypeList) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	for i, t := range l.types {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		WriteType(&buf, t, nil)
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}
+
 // ----------------------------------------------------------------------------
 // Implementation
 

package/bin/go/src/go/types/typestring.go

@@ -214,14 +214,6 @@ func (w *typeWriter) typ(typ Type) {
 
 	case *Interface:
 		if w.ctxt == nil {
-			if t == universeAnyAlias.Type().Underlying() {
-				// When not hashing, we can try to improve type strings by writing "any"
-				// for a type that is pointer-identical to universeAny.
-				// TODO(rfindley): this logic should not be necessary with
-				// gotypesalias=1. Remove once that is always the case.
-				w.string("any")
-				break
-			}
 			if t == asNamed(universeComparable.Type()).underlying {
 				w.string("interface{comparable}")
 				break
@@ -347,7 +339,11 @@ func (w *typeWriter) typ(typ Type) {
 		}
 		if w.ctxt != nil {
 			// TODO(gri) do we need to print the alias type name, too?
-			w.typ(Unalias(t.obj.typ))
+			typ := Unalias(t.obj.typ)
+			if typ == nil {
+				panic("known implementation limitation: encountered an incomplete alias (see go.dev/issue/78296)")
+			}
+			w.typ(typ)
 		}
 
 	default: