@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/go/types/gotype.go

@@ -120,6 +120,7 @@ var (
 )
 
 func initParserMode() {
+	parserMode = parser.SkipObjectResolution
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}

package/bin/go/src/go/types/hash.go

@@ -0,0 +1,309 @@
+// 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
+
+// This file defines a hash function for Types.
+
+import (
+	"fmt"
+	"hash/maphash"
+)
+
+type (
+	// Hasher defines a hash function and equivalence relation
+	// for [Types] that is consistent with [Identical].
+	// Hashers are stateless.
+	Hasher struct{}
+
+	// HasherIgnoreTags is a variant of [Hasher] that is
+	// consistent with [IdenticalIgnoreTags].
+	HasherIgnoreTags struct{}
+)
+
+var (
+	_ maphash.Hasher[Type] = Hasher{}
+	_ maphash.Hasher[Type] = HasherIgnoreTags{}
+)
+
+func (Hasher) Hash(h *maphash.Hash, t Type) {
+	// The two hashers use essentially the same hash function,
+	// which ignores tags; only the Equal methods vary.
+	// But for future-proofing we gratuitously force them
+	// to differ by one byte.
+	h.WriteByte(0)
+	hasher{inGenericSig: false}.hash(h, t)
+}
+func (HasherIgnoreTags) Hash(h *maphash.Hash, t Type) {
+	h.WriteByte(1)
+	hasher{inGenericSig: false}.hash(h, t)
+}
+
+func (Hasher) Equal(x, y Type) bool           { return Identical(x, y) }
+func (HasherIgnoreTags) Equal(x, y Type) bool { return IdenticalIgnoreTags(x, y) }
+
+// hasher holds the state of a single hash traversal, namely,
+// whether we are inside the signature of a generic function.
+// This is used to optimize [hasher.hashTypeParam].
+type hasher struct{ inGenericSig bool }
+
+func (hr hasher) hash(h *maphash.Hash, t Type) {
+	// See [Identical] for rationale.
+	switch t := t.(type) {
+	case *Alias:
+		hr.hash(h, Unalias(t))
+
+	case *Array:
+		h.WriteByte('A')
+		maphash.WriteComparable(h, t.Len())
+		hr.hash(h, t.Elem())
+
+	case *Basic:
+		h.WriteByte('B')
+		h.WriteByte(byte(t.Kind()))
+
+	case *Chan:
+		h.WriteByte('C')
+		h.WriteByte(byte(t.Dir()))
+		hr.hash(h, t.Elem())
+
+	case *Interface:
+		h.WriteByte('I')
+		h.WriteByte(byte(t.NumMethods()))
+
+		// Interfaces are identical if they have the same set of methods, with
+		// identical names and types, and they have the same set of type
+		// restrictions. See [Identical] for more details.
+
+		// Hash the methods.
+		//
+		// Because [Identical] treats Methods as an unordered set,
+		// we must either:
+		// (a) sort the methods into some canonical order; or
+		// (b) hash them each in parallel, combine them with a
+		//     commutative operation such as + or ^, and then
+		//     write this value into the primary hasher.
+		// Since (a) requires allocation, we choose (b).
+		var hash uint64
+		for m := range t.Methods() {
+			var subh maphash.Hash
+			subh.SetSeed(h.Seed())
+			// Ignore m.Pkg().
+			// Use shallow hash on method signature to
+			// avoid anonymous interface cycles.
+			subh.WriteString(m.Name())
+			hr.shallowHash(&subh, m.Type())
+			hash ^= subh.Sum64()
+		}
+		maphash.WriteComparable(h, hash)
+
+		// Hash type restrictions.
+		// TODO(adonovan): call (fork of) InterfaceTermSet from
+		// golang.org/x/tools/internal/typeparams/normalize.go.
+		// hr.hashTermSet(h, terms)
+
+	case *Map:
+		h.WriteByte('M')
+		hr.hash(h, t.Key())
+		hr.hash(h, t.Elem())
+
+	case *Named:
+		h.WriteByte('N')
+		hr.hashTypeName(h, t.Obj())
+		for targ := range t.TypeArgs().Types() {
+			hr.hash(h, targ)
+		}
+
+	case *Pointer:
+		h.WriteByte('P')
+		hr.hash(h, t.Elem())
+
+	case *Signature:
+		h.WriteByte('F')
+		maphash.WriteComparable(h, t.Variadic())
+		tparams := t.TypeParams()
+		if n := tparams.Len(); n > 0 {
+			hr.inGenericSig = true // affects constraints, params, and results
+
+			maphash.WriteComparable(h, n)
+			for tparam := range tparams.TypeParams() {
+				hr.hash(h, tparam.Constraint())
+			}
+		}
+		hr.hashTuple(h, t.Params())
+		hr.hashTuple(h, t.Results())
+
+	case *Slice:
+		h.WriteByte('S')
+		hr.hash(h, t.Elem())
+
+	case *Struct:
+		h.WriteByte('R') // mnemonic: a struct is a record type
+		n := t.NumFields()
+		h.WriteByte(byte(n))
+		for i := range n {
+			f := t.Field(i)
+			maphash.WriteComparable(h, f.Anonymous())
+			// Ignore t.Tag(i), so that a single hash function
+			// can be used with both [Identical] and [IdenticalIgnoreTags].
+			h.WriteString(f.Name()) // (ignore f.Pkg)
+			hr.hash(h, f.Type())
+		}
+
+	case *Tuple:
+		hr.hashTuple(h, t)
+
+	case *TypeParam:
+		hr.hashTypeParam(h, t)
+
+	case *Union:
+		h.WriteByte('U')
+		// TODO(adonovan): opt: call (fork of) UnionTermSet from
+		// golang.org/x/tools/internal/typeparams/normalize.go.
+		// hr.hashTermSet(h, terms)
+
+	default:
+		panic(fmt.Sprintf("%T: %v", t, t))
+	}
+}
+
+func (hr hasher) hashTuple(h *maphash.Hash, t *Tuple) {
+	h.WriteByte('T')
+	h.WriteByte(byte(t.Len()))
+	for v := range t.Variables() {
+		hr.hash(h, v.Type())
+	}
+}
+
+// func (hr hasher) hashTermSet(h *maphash.Hash, terms []*Term) {
+// 	h.WriteByte(byte(len(terms)))
+// 	for _, term := range terms {
+// 		// term order is not significant.
+// 		h.WriteByte(byte(btoi(term.Tilde())))
+// 		hr.hash(h, term.Type())
+// 	}
+// }
+
+// hashTypeParam encodes a type parameter into hasher h.
+func (hr hasher) hashTypeParam(h *maphash.Hash, t *TypeParam) {
+	h.WriteByte('P')
+	// Within the signature of a generic function, TypeParams are
+	// identical if they have the same index and constraint, so we
+	// hash them based on index.
+	//
+	// When we are outside a generic function, free TypeParams are
+	// identical iff they are the same object, so we can use a
+	// more discriminating hash consistent with object identity.
+	// This optimization saves [Map] about 4% when hashing all the
+	// Info.Types in the forward closure of net/http.
+	if !hr.inGenericSig {
+		// Optimization: outside a generic function signature,
+		// use a more discrimating hash consistent with object identity.
+		hr.hashTypeName(h, t.Obj())
+	} else {
+		h.WriteByte(byte(t.Index()))
+	}
+}
+
+// hashTypeName hashes the pointer of tname.
+func (hasher) hashTypeName(h *maphash.Hash, tname *TypeName) {
+	h.WriteByte('N')
+	// Since Identical uses == to compare TypeNames,
+	// the hash function uses maphash.Comparable.
+	maphash.WriteComparable(h, tname)
+}
+
+// shallowHash computes a hash of t without looking at any of its
+// element Types, to avoid potential anonymous cycles in the types of
+// interface methods.
+//
+// When an unnamed non-empty interface type appears anywhere among the
+// arguments or results of an interface method, there is a potential
+// for endless recursion. Consider:
+//
+//	type X interface { m() []*interface { X } }
+//
+// The problem is that the Methods of the interface in m's result type
+// include m itself; there is no mention of the named type X that
+// might help us break the cycle.
+// (See comment in [Identical], case *Interface, for more.)
+func (hr hasher) shallowHash(h *maphash.Hash, t Type) {
+	// t is the type of an interface method (Signature),
+	// its params or results (Tuples), or their immediate
+	// elements (mostly Slice, Pointer, Basic, Named),
+	// so there's no need to optimize anything else.
+	switch t := t.(type) {
+	case *Alias:
+		hr.shallowHash(h, Unalias(t))
+
+	case *Array:
+		h.WriteByte('A')
+		maphash.WriteComparable(h, t.Len())
+		// ignore t.Elem()
+
+	case *Basic:
+		h.WriteByte('B')
+		h.WriteByte(byte(t.Kind()))
+
+	case *Chan:
+		h.WriteByte('C')
+		// ignore Dir(), Elem()
+
+	case *Interface:
+		h.WriteByte('I')
+		// no recursion here
+
+	case *Map:
+		h.WriteByte('M')
+		// ignore Key(), Elem()
+
+	case *Named:
+		hr.hashTypeName(h, t.Obj())
+
+	case *Pointer:
+		h.WriteByte('P')
+		// ignore t.Elem()
+
+	case *Signature:
+		h.WriteByte(byte(btoi(t.Variadic())))
+		// The Signature/Tuple recursion is always
+		// finite and invariably shallow.
+		hr.shallowHash(h, t.Params())
+		hr.shallowHash(h, t.Results())
+
+	case *Slice:
+		h.WriteByte('S')
+		// ignore t.Elem()
+
+	case *Struct:
+		h.WriteByte('R') // mnemonic: a struct is a record type
+		h.WriteByte(byte(t.NumFields()))
+		// ignore t.Fields()
+
+	case *Tuple:
+		h.WriteByte('T')
+		h.WriteByte(byte(t.Len()))
+		for v := range t.Variables() {
+			hr.shallowHash(h, v.Type())
+		}
+
+	case *TypeParam:
+		hr.hashTypeParam(h, t)
+
+	case *Union:
+		h.WriteByte('U')
+		// ignore term set
+
+	default:
+		panic(fmt.Sprintf("shallowHash: %T: %v", t, t))
+	}
+}
+
+func btoi(b bool) int {
+	if b {
+		return 1
+	} else {
+		return 0
+	}
+}

package/bin/go/src/go/types/index.go

@@ -20,23 +20,23 @@ func (check *Checker) indexExpr(x *operand, e *indexedExpr) (isFuncInst bool) {
 	check.exprOrType(x, e.x, true)
 	// x may be generic
 
-	switch x.mode {
+	switch x.mode() {
 	case invalid:
 		check.use(e.indices...)
 		return false
 
 	case typexpr:
 		// type instantiation
-		x.mode = invalid
+		x.invalidate()
 		// TODO(gri) here we re-evaluate e.X - try to avoid this
-		x.typ = check.varType(e.orig)
-		if isValid(x.typ) {
-			x.mode = typexpr
+		x.typ_ = check.varType(e.orig)
+		if isValid(x.typ()) {
+			x.mode_ = typexpr
 		}
 		return false
 
 	case value:
-		if sig, _ := x.typ.Underlying().(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
+		if sig, _ := x.typ().Underlying().(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
 			// function instantiation
 			return true
 		}
@@ -44,72 +44,94 @@ func (check *Checker) indexExpr(x *operand, e *indexedExpr) (isFuncInst bool) {
 
 	// x should not be generic at this point, but be safe and check
 	check.nonGeneric(nil, x)
-	if x.mode == invalid {
+	if !x.isValid() {
 		return false
 	}
 
+	// We cannot index on an incomplete type; make sure it's complete.
+	if !check.isComplete(x.typ()) {
+		x.invalidate()
+		return false
+	}
+	switch typ := x.typ().Underlying().(type) {
+	case *Pointer:
+		// Additionally, if x.typ is a pointer to an array type, indexing implicitly dereferences the value, meaning
+		// its base type must also be complete.
+		if !check.isComplete(typ.base) {
+			x.invalidate()
+			return false
+		}
+	case *Map:
+		// Lastly, if x.typ is a map type, indexing must produce a value of a complete type, meaning
+		// its element type must also be complete.
+		if !check.isComplete(typ.elem) {
+			x.invalidate()
+			return false
+		}
+	}
+
 	// ordinary index expression
 	valid := false
 	length := int64(-1) // valid if >= 0
-	switch typ := x.typ.Underlying().(type) {
+	switch typ := x.typ().Underlying().(type) {
 	case *Basic:
 		if isString(typ) {
 			valid = true
-			if x.mode == constant_ {
-				length = int64(len(constant.StringVal(x.val)))
+			if x.mode() == constant_ {
+				length = constant.StringLen(x.val)
 			}
 			// an indexed string always yields a byte value
 			// (not a constant) even if the string and the
 			// index are constant
-			x.mode = value
-			x.typ = universeByte // use 'byte' name
+			x.mode_ = value
+			x.typ_ = universeByte // use 'byte' name
 		}
 
 	case *Array:
 		valid = true
 		length = typ.len
-		if x.mode != variable {
-			x.mode = value
+		if x.mode() != variable {
+			x.mode_ = value
 		}
-		x.typ = typ.elem
+		x.typ_ = typ.elem
 
 	case *Pointer:
 		if typ, _ := typ.base.Underlying().(*Array); typ != nil {
 			valid = true
 			length = typ.len
-			x.mode = variable
-			x.typ = typ.elem
+			x.mode_ = variable
+			x.typ_ = typ.elem
 		}
 
 	case *Slice:
 		valid = true
-		x.mode = variable
-		x.typ = typ.elem
+		x.mode_ = variable
+		x.typ_ = typ.elem
 
 	case *Map:
 		index := check.singleIndex(e)
 		if index == nil {
-			x.mode = invalid
+			x.invalidate()
 			return false
 		}
 		var key operand
-		check.expr(nil, &key, index)
+		check.genericExpr(&key, index, nil)
 		check.assignment(&key, typ.key, "map index")
 		// ok to continue even if indexing failed - map element type is known
-		x.mode = mapindex
-		x.typ = typ.elem
+		x.mode_ = mapindex
+		x.typ_ = typ.elem
 		x.expr = e.orig
 		return false
 
 	case *Interface:
-		if !isTypeParam(x.typ) {
+		if !isTypeParam(x.typ()) {
 			break
 		}
 		// TODO(gri) report detailed failure cause for better error messages
 		var key, elem Type // key != nil: we must have all maps
 		mode := variable   // non-maps result mode
 		// TODO(gri) factor out closure and use it for non-typeparam cases as well
-		if underIs(x.typ, func(u Type) bool {
+		if underIs(x.typ(), func(u Type) bool {
 			l := int64(-1) // valid if >= 0
 			var k, e Type  // k is only set for maps
 			switch t := u.(type) {
@@ -121,7 +143,7 @@ func (check *Checker) indexExpr(x *operand, e *indexedExpr) (isFuncInst bool) {
 			case *Array:
 				l = t.len
 				e = t.elem
-				if x.mode != variable {
+				if x.mode() != variable {
 					mode = value
 				}
 			case *Pointer:
@@ -163,23 +185,23 @@ func (check *Checker) indexExpr(x *operand, e *indexedExpr) (isFuncInst bool) {
 			if key != nil {
 				index := check.singleIndex(e)
 				if index == nil {
-					x.mode = invalid
+					x.invalidate()
 					return false
 				}
 				var k operand
-				check.expr(nil, &k, index)
+				check.genericExpr(&k, index, nil)
 				check.assignment(&k, key, "map index")
 				// ok to continue even if indexing failed - map element type is known
-				x.mode = mapindex
-				x.typ = elem
+				x.mode_ = mapindex
+				x.typ_ = elem
 				x.expr = e.orig
 				return false
 			}
 
 			// no maps
 			valid = true
-			x.mode = mode
-			x.typ = elem
+			x.mode_ = mode
+			x.typ_ = elem
 		}
 	}
 
@@ -187,21 +209,21 @@ func (check *Checker) indexExpr(x *operand, e *indexedExpr) (isFuncInst bool) {
 		// types2 uses the position of '[' for the error
 		check.errorf(x, NonIndexableOperand, "cannot index %s", x)
 		check.use(e.indices...)
-		x.mode = invalid
+		x.invalidate()
 		return false
 	}
 
 	index := check.singleIndex(e)
 	if index == nil {
-		x.mode = invalid
+		x.invalidate()
 		return false
 	}
 
 	// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
 	// the element type may be accessed before it's set. Make sure we have
 	// a valid type.
-	if x.typ == nil {
-		x.typ = Typ[Invalid]
+	if x.typ() == nil {
+		x.typ_ = Typ[Invalid]
 	}
 
 	check.index(index, length)
@@ -210,7 +232,7 @@ func (check *Checker) indexExpr(x *operand, e *indexedExpr) (isFuncInst bool) {
 
 func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 	check.expr(nil, x, e.X)
-	if x.mode == invalid {
+	if !x.isValid() {
 		check.use(e.Low, e.High, e.Max)
 		return
 	}
@@ -219,9 +241,9 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 	var ct, cu Type // type and respective common underlying type
 	var hasString bool
 	// TODO(adonovan): use go1.23 "range typeset()".
-	typeset(x.typ)(func(t, u Type) bool {
+	typeset(x.typ())(func(t, u Type) bool {
 		if u == nil {
-			check.errorf(x, NonSliceableOperand, "cannot slice %s: no specific type in %s", x, x.typ)
+			check.errorf(x, NonSliceableOperand, "cannot slice %s: no specific type in %s", x, x.typ())
 			cu = nil
 			return false
 		}
@@ -251,17 +273,25 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 		// If we saw a string, proceed with string type,
 		// but don't go from untyped string to string.
 		cu = Typ[String]
-		if !isTypeParam(x.typ) {
-			cu = x.typ.Underlying() // untyped string remains untyped
+		if !isTypeParam(x.typ()) {
+			cu = x.typ().Underlying() // untyped string remains untyped
 		}
 	}
 
+	// Note that we don't permit slice expressions where x is a type expression, so we don't check for that here.
+	// However, if x.typ is a pointer to an array type, slicing implicitly dereferences the value, meaning
+	// its base type must also be complete.
+	if p, ok := x.typ().Underlying().(*Pointer); ok && !check.isComplete(p.base) {
+		x.invalidate()
+		return
+	}
+
 	valid := false
 	length := int64(-1) // valid if >= 0
 	switch u := cu.(type) {
 	case nil:
 		// error reported above
-		x.mode = invalid
+		x.invalidate()
 		return
 
 	case *Basic:
@@ -272,35 +302,35 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 					at = e // e.Index[2] should be present but be careful
 				}
 				check.error(at, InvalidSliceExpr, invalidOp+"3-index slice of string")
-				x.mode = invalid
+				x.invalidate()
 				return
 			}
 			valid = true
-			if x.mode == constant_ {
-				length = int64(len(constant.StringVal(x.val)))
+			if x.mode() == constant_ {
+				length = constant.StringLen(x.val)
 			}
 			// spec: "For untyped string operands the result
 			// is a non-constant value of type string."
-			if isUntyped(x.typ) {
-				x.typ = Typ[String]
+			if isUntyped(x.typ()) {
+				x.typ_ = Typ[String]
 			}
 		}
 
 	case *Array:
 		valid = true
 		length = u.len
-		if x.mode != variable {
+		if x.mode() != variable {
 			check.errorf(x, NonSliceableOperand, "cannot slice unaddressable value %s", x)
-			x.mode = invalid
+			x.invalidate()
 			return
 		}
-		x.typ = &Slice{elem: u.elem}
+		x.typ_ = &Slice{elem: u.elem}
 
 	case *Pointer:
 		if u, _ := u.base.Underlying().(*Array); u != nil {
 			valid = true
 			length = u.len
-			x.typ = &Slice{elem: u.elem}
+			x.typ_ = &Slice{elem: u.elem}
 		}
 
 	case *Slice:
@@ -310,16 +340,16 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 
 	if !valid {
 		check.errorf(x, NonSliceableOperand, "cannot slice %s", x)
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 
-	x.mode = value
+	x.mode_ = value
 
 	// spec: "Only the first index may be omitted; it defaults to 0."
 	if e.Slice3 && (e.High == nil || e.Max == nil) {
 		check.error(inNode(e, e.Rbrack), InvalidSyntaxTree, "2nd and 3rd index required in 3-index slice")
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 
@@ -397,8 +427,8 @@ func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
 		return
 	}
 
-	if x.mode != constant_ {
-		return x.typ, -1
+	if x.mode() != constant_ {
+		return x.typ(), -1
 	}
 
 	if x.val.Kind() == constant.Unknown {
@@ -413,27 +443,27 @@ func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
 	}
 
 	// 0 <= v [ && v < max ]
-	return x.typ, v
+	return x.typ(), v
 }
 
 func (check *Checker) isValidIndex(x *operand, code Code, what string, allowNegative bool) bool {
-	if x.mode == invalid {
+	if !x.isValid() {
 		return false
 	}
 
 	// spec: "a constant index that is untyped is given type int"
 	check.convertUntyped(x, Typ[Int])
-	if x.mode == invalid {
+	if !x.isValid() {
 		return false
 	}
 
 	// spec: "the index x must be of integer type or an untyped constant"
-	if !allInteger(x.typ) {
+	if !allInteger(x.typ()) {
 		check.errorf(x, code, invalidArg+"%s %s must be integer", what, x)
 		return false
 	}
 
-	if x.mode == constant_ {
+	if x.mode() == constant_ {
 		// spec: "a constant index must be non-negative ..."
 		if !allowNegative && constant.Sign(x.val) < 0 {
 			check.errorf(x, code, invalidArg+"%s %s must not be negative", what, x)