@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/go/types/typexpr.go

@@ -18,7 +18,7 @@ import (
 // If an error occurred, x.mode is set to invalid.
 // If wantType is set, the identifier e is expected to denote a type.
 func (check *Checker) ident(x *operand, e *ast.Ident, wantType bool) {
-	x.mode = invalid
+	x.invalidate()
 	x.expr = e
 
 	scope, obj := check.lookupScope(e.Name)
@@ -30,14 +30,7 @@ func (check *Checker) ident(x *operand, e *ast.Ident, wantType bool) {
 			check.errorf(e, UndeclaredName, "undefined: %s", e.Name)
 		}
 		return
-	case universeComparable:
-		if !check.verifyVersionf(e, go1_18, "predeclared %s", e.Name) {
-			return // avoid follow-on errors
-		}
-	}
-	// Because the representation of any depends on gotypesalias, we don't check
-	// pointer identity here.
-	if obj.Name() == "any" && obj.Parent() == Universe {
+	case universeAny, universeComparable:
 		if !check.verifyVersionf(e, go1_18, "predeclared %s", e.Name) {
 			return // avoid follow-on errors
 		}
@@ -105,14 +98,10 @@ func (check *Checker) ident(x *operand, e *ast.Ident, wantType bool) {
 			x.val = obj.val
 		}
 		assert(x.val != nil)
-		x.mode = constant_
+		x.mode_ = constant_
 
 	case *TypeName:
-		if !check.conf._EnableAlias && check.isBrokenAlias(obj) {
-			check.errorf(e, InvalidDeclCycle, "invalid use of type alias %s in recursive type (see go.dev/issue/50729)", obj.name)
-			return
-		}
-		x.mode = typexpr
+		x.mode_ = typexpr
 
 	case *Var:
 		// It's ok to mark non-local variables, but ignore variables
@@ -125,24 +114,24 @@ func (check *Checker) ident(x *operand, e *ast.Ident, wantType bool) {
 		if !isValid(typ) {
 			return
 		}
-		x.mode = variable
+		x.mode_ = variable
 
 	case *Func:
 		check.addDeclDep(obj)
-		x.mode = value
+		x.mode_ = value
 
 	case *Builtin:
 		x.id = obj.id
-		x.mode = builtin
+		x.mode_ = builtin
 
 	case *Nil:
-		x.mode = value
+		x.mode_ = value
 
 	default:
 		panic("unreachable")
 	}
 
-	x.typ = typ
+	x.typ_ = typ
 }
 
 // typ type-checks the type expression e and returns its type, or Typ[Invalid].
@@ -257,9 +246,9 @@ func (check *Checker) typInternal(e0 ast.Expr, def *TypeName) (T Type) {
 		var x operand
 		check.ident(&x, e, true)
 
-		switch x.mode {
+		switch x.mode() {
 		case typexpr:
-			return x.typ
+			return x.typ()
 		case invalid:
 			// ignore - error reported before
 		case novalue:
@@ -272,9 +261,9 @@ func (check *Checker) typInternal(e0 ast.Expr, def *TypeName) (T Type) {
 		var x operand
 		check.selector(&x, e, true)
 
-		switch x.mode {
+		switch x.mode() {
 		case typexpr:
-			return x.typ
+			return x.typ()
 		case invalid:
 			// ignore - error reported before
 		case novalue:
@@ -489,14 +478,14 @@ func (check *Checker) arrayLength(e ast.Expr) int64 {
 
 	var x operand
 	check.expr(nil, &x, e)
-	if x.mode != constant_ {
-		if x.mode != invalid {
+	if x.mode() != constant_ {
+		if x.isValid() {
 			check.errorf(&x, InvalidArrayLen, "array length %s must be constant", &x)
 		}
 		return -1
 	}
 
-	if isUntyped(x.typ) || isInteger(x.typ) {
+	if isUntyped(x.typ()) || isInteger(x.typ()) {
 		if val := constant.ToInt(x.val); val.Kind() == constant.Int {
 			if representableConst(val, check, Typ[Int], nil) {
 				if n, ok := constant.Int64Val(val); ok && n >= 0 {
@@ -507,7 +496,7 @@ func (check *Checker) arrayLength(e ast.Expr) int64 {
 	}
 
 	var msg string
-	if isInteger(x.typ) {
+	if isInteger(x.typ()) {
 		msg = "invalid array length %s"
 	} else {
 		msg = "array length %s must be integer"

package/bin/go/src/go/types/unify.go

@@ -70,6 +70,7 @@ const (
 // corresponding types inferred for each type parameter.
 // A unifier is created by calling newUnifier.
 type unifier struct {
+	check *Checker
 	// handles maps each type parameter to its inferred type through
 	// an indirection *Type called (inferred type) "handle".
 	// Initially, each type parameter has its own, separate handle,
@@ -88,7 +89,7 @@ type unifier struct {
 // and corresponding type argument lists. The type argument list may be shorter
 // than the type parameter list, and it may contain nil types. Matching type
 // parameters and arguments must have the same index.
-func newUnifier(tparams []*TypeParam, targs []Type, enableInterfaceInference bool) *unifier {
+func newUnifier(check *Checker, tparams []*TypeParam, targs []Type, enableInterfaceInference bool) *unifier {
 	assert(len(tparams) >= len(targs))
 	handles := make(map[*TypeParam]*Type, len(tparams))
 	// Allocate all handles up-front: in a correct program, all type parameters
@@ -102,7 +103,7 @@ func newUnifier(tparams []*TypeParam, targs []Type, enableInterfaceInference boo
 		}
 		handles[x] = &t
 	}
-	return &unifier{handles, 0, enableInterfaceInference}
+	return &unifier{check, handles, 0, enableInterfaceInference}
 }
 
 // unifyMode controls the behavior of the unifier.
@@ -145,6 +146,7 @@ func (u *unifier) unify(x, y Type, mode unifyMode) bool {
 }
 
 func (u *unifier) tracef(format string, args ...any) {
+	// TODO(gri) consider adjusting this to use Checker.trace
 	fmt.Println(strings.Repeat(".  ", u.depth) + sprintf(nil, nil, true, format, args...))
 }
 
@@ -537,10 +539,17 @@ func (u *unifier) nify(x, y Type, mode unifyMode, p *ifacePair) (result bool) {
 		// the non-interface type, otherwise unification fails.
 		if xi != nil {
 			// All xi methods must exist in y and corresponding signatures must unify.
+			// A generic method never satisfies an interface method, so fail rather
+			// than unify ym's own type parameter into an inference variable.
 			xmethods := xi.typeSet().methods
 			for _, xm := range xmethods {
 				obj, _, _ := LookupFieldOrMethod(y, false, xm.pkg, xm.name)
-				if ym, _ := obj.(*Func); ym == nil || !u.nify(xm.typ, ym.typ, exact, p) {
+				ym, _ := obj.(*Func)
+				if ym == nil {
+					return false
+				}
+				u.check.objDecl(ym) // ensure fully set-up signature
+				if ym.Signature().TypeParams() != nil || !u.nify(xm.typ, ym.typ, exact, p) {
 					return false
 				}
 			}

package/bin/go/src/go/types/universe.go

@@ -27,9 +27,8 @@ var (
 	universeBool       Type
 	universeByte       Type // uint8 alias, but has name "byte"
 	universeRune       Type // int32 alias, but has name "rune"
-	universeAnyNoAlias *TypeName
-	universeAnyAlias   *TypeName
 	universeError      Type
+	universeAny        Object
 	universeComparable Object
 )
 
@@ -79,44 +78,15 @@ func defPredeclaredTypes() {
 	for _, t := range Typ {
 		def(NewTypeName(nopos, nil, t.name, t))
 	}
+
 	for _, t := range basicAliases {
 		def(NewTypeName(nopos, nil, t.name, t))
 	}
 
-	// type any = interface{}
-	//
-	// Implement two representations of any: one for the legacy gotypesalias=0,
-	// and one for gotypesalias=1. This is necessary for consistent
-	// representation of interface aliases during type checking, and is
-	// implemented via hijacking [Scope.Lookup] for the [Universe] scope.
-	//
-	// Both representations use the same distinguished pointer for their RHS
-	// interface type, allowing us to detect any (even with the legacy
-	// representation), and format it as "any" rather than interface{}, which
-	// clarifies user-facing error messages significantly.
-	//
-	// TODO(rfindley): once the gotypesalias GODEBUG variable is obsolete (and we
-	// consistently use the Alias node), we should be able to clarify user facing
-	// error messages without using a distinguished pointer for the any
-	// interface.
-	{
-		universeAnyNoAlias = NewTypeName(nopos, nil, "any", &Interface{complete: true, tset: &topTypeSet})
-		// ensure that the any TypeName reports a consistent Parent, after
-		// hijacking Universe.Lookup with gotypesalias=0.
-		universeAnyNoAlias.setParent(Universe)
-
-		// It shouldn't matter which representation of any is actually inserted
-		// into the Universe, but we lean toward the future and insert the Alias
-		// representation.
-		universeAnyAlias = NewTypeName(nopos, nil, "any", nil)
-		_ = NewAlias(universeAnyAlias, universeAnyNoAlias.Type().Underlying()) // Link TypeName and Alias
-		def(universeAnyAlias)
-	}
-
 	// type error interface{ Error() string }
 	{
 		obj := NewTypeName(nopos, nil, "error", nil)
-		typ := (*Checker)(nil).newNamed(obj, nil, nil)
+		typ := NewNamed(obj, nil, nil)
 
 		// error.Error() string
 		recv := newVar(RecvVar, nopos, nil, "", typ)
@@ -133,16 +103,17 @@ func defPredeclaredTypes() {
 		def(obj)
 	}
 
+	// type any = interface{}
+	{
+		obj := NewTypeName(nopos, nil, "any", nil)
+		NewAlias(obj, &emptyInterface)
+		def(obj)
+	}
+
 	// type comparable interface{} // marked as comparable
 	{
 		obj := NewTypeName(nopos, nil, "comparable", nil)
-		typ := (*Checker)(nil).newNamed(obj, nil, nil)
-
-		// interface{} // marked as comparable
-		ityp := &Interface{complete: true, tset: &_TypeSet{nil, allTermlist, true}}
-
-		typ.fromRHS = ityp
-		typ.Underlying()
+		NewNamed(obj, &Interface{complete: true, tset: &_TypeSet{nil, allTermlist, true}}, nil)
 		def(obj)
 	}
 }
@@ -281,6 +252,7 @@ func init() {
 	universeByte = Universe.Lookup("byte").Type()
 	universeRune = Universe.Lookup("rune").Type()
 	universeError = Universe.Lookup("error").Type()
+	universeAny = Universe.Lookup("any")
 	universeComparable = Universe.Lookup("comparable")
 }
 

package/bin/go/src/go/types/version.go

@@ -1,3 +1,6 @@
+// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
+// Source: ../../cmd/compile/internal/types2/version.go
+
 // 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.
@@ -44,6 +47,7 @@ var (
 	go1_22 = asGoVersion("go1.22")
 	go1_23 = asGoVersion("go1.23")
 	go1_26 = asGoVersion("go1.26")
+	go1_27 = asGoVersion("go1.27")
 
 	// current (deployed) Go version
 	go_current = asGoVersion(fmt.Sprintf("go1.%d", goversion.Version))

package/bin/go/src/go.mod

@@ -1,13 +1,13 @@
 module std
 
-go 1.26
+go 1.27
 
 require (
-	golang.org/x/crypto v0.46.1-0.20251210140736-7dacc380ba00
-	golang.org/x/net v0.47.1-0.20260925170545-1431957440b7
+	golang.org/x/crypto v0.52.1-0.20260526024921-9beb694f9766
+	golang.org/x/net v0.55.1-0.20260731170536-c1d18010be90
 )
 
 require (
-	golang.org/x/sys v0.39.0 // indirect
-	golang.org/x/text v0.32.0 // indirect
+	golang.org/x/sys v0.45.0 // indirect
+	golang.org/x/text v0.37.0 // indirect
 )

package/bin/go/src/go.sum

@@ -1,8 +1,8 @@
-golang.org/x/crypto v0.46.1-0.20251210140736-7dacc380ba00 h1:JgcPM1rzpSOZS8y69FQvnY0xN0ciHlpQqwTXJcuZIA4=
-golang.org/x/crypto v0.46.1-0.20251210140736-7dacc380ba00/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
-golang.org/x/net v0.47.1-0.20260925170545-1431957440b7 h1:5FtxsBBG4SLV2/Vvvf3+wW2NIHWR7CSbJfn9byVKwPk=
-golang.org/x/net v0.47.1-0.20260925170545-1431957440b7/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
-golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
-golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
-golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
+golang.org/x/crypto v0.52.1-0.20260526024921-9beb694f9766 h1:ABD+jVg0H4Hwu2sGcUtKeb3T8mlS+jS3uWrkTAPcXjs=
+golang.org/x/crypto v0.52.1-0.20260526024921-9beb694f9766/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=
+golang.org/x/net v0.55.1-0.20260731170536-c1d18010be90 h1:v8JYc8J0G5tszb4H3rnr1UU9fjQFKQLtPr8U6HjvVqI=
+golang.org/x/net v0.55.1-0.20260731170536-c1d18010be90/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
+golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
+golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
+golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=

package/bin/go/src/hash/maphash/hasher.go

@@ -0,0 +1,139 @@
+// Copyright 2025 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 maphash
+
+// A Hasher defines the interface between a hash-based container and its elements.
+// It provides a hash function and an equivalence relation over values
+// of type T, enabling those values to be inserted in hash tables
+// and similar data structures.
+//
+// Of course, comparable types can already be used as keys of Go's
+// built-in map type, but a Hasher enables non-comparable types to be
+// used as keys of a suitable hash table too.
+// Hashers may be useful even for comparable types, to define an
+// equivalence relation that differs from the usual one (==), such as a
+// field-based comparison for a pointer-to-struct type, or a
+// case-insensitive comparison for strings, as in this example:
+//
+//	// CaseInsensitive is a Hasher[string] whose
+//	// equivalence relation ignores letter case.
+//	type CaseInsensitive struct{}
+//
+//	func (CaseInsensitive) Hash(h *Hash, s string) {
+//		h.WriteString(strings.ToLower(s))
+//	}
+//
+//	func (CaseInsensitive) Equal(x, y string) bool {
+//		// (We avoid strings.EqualFold as it is not
+//		// consistent with ToLower for all values.)
+//		return strings.ToLower(x) == strings.ToLower(y)
+//	}
+//
+// A Hasher also permits values to be used with other hash-based data
+// structures such as a Bloom filter.
+// The [ComparableHasher] type makes it convenient to enable comparable
+// types to be used in such data structures under their usual (==)
+// equivalence relation.
+//
+// # Hash invariants
+//
+// If two values are equal as defined by Equal(x, y), then they must
+// have the same hash as defined by the effects of Hash(h, x) on h.
+//
+// Hashers must be logically stateless: the behavior of the Hash and
+// Equal methods depends only on the arguments.
+//
+// # Writing a good function
+//
+// When defining a hash function and equivalence relation for a data
+// type, it may help to first define a canonical encoding for values
+// of that type as a sequence of elements, each being a number,
+// string, boolean, or pointer.
+// An encoding is canonical if two values that are logically equal
+// have the same encoding, even if they are represented differently.
+// For example, a canonical case-insensitive encoding of a string is
+// [strings.ToLower].
+//
+// Once you have defined the encoding, the Hasher's Hash method should
+// encode a value into the [Hash] using a sequence of calls to
+// [Hash.Write] for byte slices, [Hash.WriteString] for strings,
+// [Hash.WriteByte] for bytes, and [WriteComparable] for elements of
+// other types. The Hasher's Equal method should compute the
+// encodings of two values, then compare their corresponding
+// elements, returning false at the first mismatch.
+//
+// A Hash method may discard information so long as it remains
+// consistent with the Equal method as defined above.
+// For example, valid implementations of CaseInsensitive.Hash might inspect
+// only the first letter of the string, or even use a constant value.
+// However, the lossier the hash function, the more frequent
+// the hash collisions and the slower the hash table.
+//
+// Some data types, such as sets, are inherently unordered: the set
+// {a, b, c} is equal to the set {c, b, a}.
+// In some cases it is possible to define a canonical encoding for a
+// set by sorting the elements into some order.
+// In other cases this may inefficient, since it may require allocating
+// memory, or infeasible, as when there is no convenient order.
+// Another way to hash an unordered set is to compute the hash
+// for each element separately, then combine all the element hashes
+// using a commutative (order-independent) operator such as + or ^.
+//
+// The Hash method below, for a hypothetical Set type, illustrates
+// this approach:
+//
+//	type Set[T comparable] struct{ ... }
+//
+//	type setHasher[T comparable] struct{}
+//
+//	func (setHasher[T]) Hash(hash *maphash.Hash, set *Set[T]) {
+//		var accum uint64
+//		for elem := range set.Elements() {
+//			// Initialize a hasher for the element,
+//			// using same seed as the outer hash.
+//			var sub maphash.Hash
+//			sub.SetSeed(hash.Seed())
+//
+//			// Hash the element.
+//			maphash.WriteComparable(&sub, elem)
+//
+//			// Mix the element's hash into the set's hash.
+//			accum ^= sub.Sum64()
+//		}
+//		maphash.WriteComparable(hash, accum)
+//	}
+//
+// In many languages, a data type's hash operation simply returns an
+// integer value.
+// However, that makes it possible for an adversary to systematically
+// construct a large number of values that all have the same hash,
+// degrading the asymptotic performance of hash tables in a
+// denial-of-service attack known as "hash flooding".
+// By contrast, computing hashes as a sequence of values emitted into
+// a [Hash] with an unpredictable [Seed] that varies from one hash
+// table to another mitigates this attack.
+//
+// In effect, the Seed chooses one of 2⁶⁴ different hash functions.
+// The code example above calls SetSeed on the element's sub-Hasher
+// so that it uses the same hash function as for the Set itself, and
+// not a random one.
+type Hasher[T any] interface {
+	Hash(*Hash, T)
+	Equal(x, y T) bool
+}
+
+// ComparableHasher is an implementation of [Hasher] whose
+// Equal(x, y) method is consistent with x == y.
+//
+// ComparableHasher is defined only for comparable types.
+// The type system will not prevent you from instantiating a type
+// such as ComparableHasher[any]; nonetheless you must not pass
+// non-comparable argument values to its Hash or Equal methods.
+type ComparableHasher[T comparable] struct {
+	_ [0]func(T) // disallow comparison, and conversion between ComparableHasher[X] and ComparableHasher[Y]
+}
+
+func (ComparableHasher[T]) Hash(h *Hash, v T) { WriteComparable(h, v) }
+func (ComparableHasher[T]) Equal(x, y T) bool { return x == y }

package/bin/go/src/hash/maphash/maphash.go

@@ -3,9 +3,13 @@
 // license that can be found in the LICENSE file.
 
 // Package maphash provides hash functions on byte sequences and comparable values.
-// These hash functions are intended to be used to implement hash tables or
-// other data structures that need to map arbitrary strings or byte
-// sequences to a uniform distribution on unsigned 64-bit integers.
+// It also defines [Hasher], the interface between a hash function and a hash table.
+//
+// These hash functions are intended to be used to implement hash
+// tables, Bloom filters, and other data structures that need to map
+// arbitrary strings or byte sequences to a uniform distribution on
+// unsigned 64-bit integers.
+//
 // Each different instance of a hash table or data structure should use its own [Seed].
 //
 // The hash functions are not cryptographically secure.
@@ -15,6 +19,8 @@ package maphash
 import (
 	"hash"
 	"internal/abi"
+	"internal/runtime/maps"
+	"unsafe"
 )
 
 // A Seed is a random value that selects the specific hash function
@@ -299,7 +305,7 @@ func Comparable[T comparable](seed Seed, v T) uint64 {
 // WriteComparable adds x to the data hashed by h.
 func WriteComparable[T comparable](h *Hash, x T) {
 	abi.EscapeNonString(x)
-	// writeComparable (not in purego mode) directly operates on h.state
+	// writeComparable directly operates on h.state
 	// without using h.buf. Mix in the buffer length so it won't
 	// commute with a buffered write, which either changes h.n or changes
 	// h.state.
@@ -308,3 +314,52 @@ func WriteComparable[T comparable](h *Hash, x T) {
 	}
 	writeComparable(h, x)
 }
+
+//go:linkname runtime_rand runtime.rand
+func runtime_rand() uint64
+
+//go:linkname runtime_memhash runtime.memhash
+//go:noescape
+func runtime_memhash(p unsafe.Pointer, seed, s uintptr) uintptr
+
+func rthash(buf []byte, seed uint64) uint64 {
+	if len(buf) == 0 {
+		return seed
+	}
+	len := len(buf)
+	// The runtime hasher only works on uintptr. For 64-bit
+	// architectures, we use the hasher directly. Otherwise,
+	// we use two parallel hashers on the lower and upper 32 bits.
+	if maps.Use64BitHash {
+		return uint64(runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed), uintptr(len)))
+	}
+	lo := runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(uint32(seed)), uintptr(len))
+	hi := runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed>>32), uintptr(len))
+	return uint64(hi)<<32 | uint64(lo)
+}
+
+func rthashString(s string, state uint64) uint64 {
+	buf := unsafe.Slice(unsafe.StringData(s), len(s))
+	return rthash(buf, state)
+}
+
+func randUint64() uint64 {
+	return runtime_rand()
+}
+
+func comparableHash[T comparable](v T, seed Seed) uint64 {
+	s := seed.s
+	var m map[T]struct{}
+	mTyp := abi.TypeOf(m)
+	hasher := (*abi.MapType)(unsafe.Pointer(mTyp)).Hasher
+	if maps.Use64BitHash {
+		return uint64(hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s)))
+	}
+	lo := hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(uint32(s)))
+	hi := hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s>>32))
+	return uint64(hi)<<32 | uint64(lo)
+}
+
+func writeComparable[T comparable](h *Hash, v T) {
+	h.state.s = comparableHash(v, h.state)
+}

package/bin/go/src/html/template/attr_string.go

@@ -22,8 +22,9 @@ const _attr_name = "attrNoneattrScriptattrScriptTypeattrStyleattrURLattrSrcsetat
 var _attr_index = [...]uint8{0, 8, 18, 32, 41, 48, 58, 73}
 
 func (i attr) String() string {
-	if i >= attr(len(_attr_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_attr_index)-1 {
 		return "attr(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _attr_name[_attr_index[i]:_attr_index[i+1]]
+	return _attr_name[_attr_index[idx]:_attr_index[idx+1]]
 }

package/bin/go/src/html/template/delim_string.go

@@ -19,8 +19,9 @@ const _delim_name = "delimNonedelimDoubleQuotedelimSingleQuotedelimSpaceOrTagEnd
 var _delim_index = [...]uint8{0, 9, 25, 41, 59}
 
 func (i delim) String() string {
-	if i >= delim(len(_delim_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_delim_index)-1 {
 		return "delim(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _delim_name[_delim_index[i]:_delim_index[i+1]]
+	return _delim_name[_delim_index[idx]:_delim_index[idx+1]]
 }

package/bin/go/src/html/template/element_string.go

@@ -21,8 +21,9 @@ const _element_name = "elementNoneelementScriptelementStyleelementTextareaelemen
 var _element_index = [...]uint8{0, 11, 24, 36, 51, 63, 74}
 
 func (i element) String() string {
-	if i >= element(len(_element_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_element_index)-1 {
 		return "element(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _element_name[_element_index[i]:_element_index[i+1]]
+	return _element_name[_element_index[idx]:_element_index[idx+1]]
 }

package/bin/go/src/html/template/jsctx_string.go

@@ -18,8 +18,9 @@ const _jsCtx_name = "jsCtxRegexpjsCtxDivOpjsCtxUnknown"
 var _jsCtx_index = [...]uint8{0, 11, 21, 33}
 
 func (i jsCtx) String() string {
-	if i >= jsCtx(len(_jsCtx_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_jsCtx_index)-1 {
 		return "jsCtx(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _jsCtx_name[_jsCtx_index[i]:_jsCtx_index[i+1]]
+	return _jsCtx_name[_jsCtx_index[idx]:_jsCtx_index[idx+1]]
 }

package/bin/go/src/html/template/state_string.go

@@ -46,8 +46,9 @@ const _state_name = "stateTextstateTagstateAttrNamestateAfterNamestateBeforeValu
 var _state_index = [...]uint16{0, 9, 17, 30, 44, 60, 72, 83, 92, 100, 111, 118, 130, 142, 156, 169, 184, 198, 216, 235, 243, 256, 269, 282, 295, 306, 322, 337, 347, 363, 382, 391}
 
 func (i state) String() string {
-	if i >= state(len(_state_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_state_index)-1 {
 		return "state(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _state_name[_state_index[i]:_state_index[i+1]]
+	return _state_name[_state_index[idx]:_state_index[idx+1]]
 }

package/bin/go/src/html/template/template.go

@@ -25,7 +25,8 @@ type Template struct {
 	// we need to keep our version of the name space and the underlying
 	// template's in sync.
 	text *template.Template
-	// The underlying template's parse tree, updated to be HTML-safe.
+	// The underlying template's parse tree, updated to be HTML-safe
+	// after the first execution.
 	Tree       *parse.Tree
 	*nameSpace // common to all associated templates
 }
@@ -331,10 +332,12 @@ func (t *Template) Name() string {
 type FuncMap = template.FuncMap
 
 // Funcs adds the elements of the argument map to the template's function map.
-// It must be called before the template is parsed.
+// Any function used in the template must be added before the template is
+// parsed. Funcs may be called more than once, including after parsing (for
+// example, after [Template.Clone]), to replace a function of the same name;
+// the replacement is used when the template is executed.
 // It panics if a value in the map is not a function with appropriate return
-// type. However, it is legal to overwrite elements of the map. The return
-// value is the template, so calls can be chained.
+// type. The return value is the template, so calls can be chained.
 func (t *Template) Funcs(funcMap FuncMap) *Template {
 	t.text.Funcs(template.FuncMap(funcMap))
 	return t

package/bin/go/src/html/template/transition.go

@@ -437,7 +437,7 @@ func tJSDelimited(c context, s []byte) (context, int) {
 			// If "</script" appears in a regex literal, the '/' should not
 			// close the regex literal, and it will later be escaped to
 			// "\x3C/script" in escapeText.
-			if i > 0 && i+7 <= len(s) && bytes.Equal(bytes.ToLower(s[i-1:i+7]), []byte("</script")) {
+			if i > 0 && i+7 <= len(s) && bytes.EqualFold(s[i-1:i+7], []byte("</script")) {
 				i++
 			} else if !inCharset {
 				c.state, c.jsCtx = stateJS, jsCtxDivOp

package/bin/go/src/html/template/urlpart_string.go

@@ -19,8 +19,9 @@ const _urlPart_name = "urlPartNoneurlPartPreQueryurlPartQueryOrFragurlPartUnknow
 var _urlPart_index = [...]uint8{0, 11, 26, 44, 58}
 
 func (i urlPart) String() string {
-	if i >= urlPart(len(_urlPart_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_urlPart_index)-1 {
 		return "urlPart(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _urlPart_name[_urlPart_index[i]:_urlPart_index[i+1]]
+	return _urlPart_name[_urlPart_index[idx]:_urlPart_index[idx+1]]
 }