@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/go/constant/kind_string.go

@@ -21,8 +21,9 @@ const _Kind_name = "UnknownBoolStringIntFloatComplex"
 var _Kind_index = [...]uint8{0, 7, 11, 17, 20, 25, 32}
 
 func (i Kind) String() string {
-	if i < 0 || i >= Kind(len(_Kind_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_Kind_index)-1 {
 		return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
+	return _Kind_name[_Kind_index[idx]:_Kind_index[idx+1]]
 }

package/bin/go/src/go/constant/value.go

@@ -137,15 +137,13 @@ func (x *stringVal) String() string {
 // concatenation. See golang.org/issue/23348.
 func (x *stringVal) string() string {
 	x.mu.Lock()
+	defer x.mu.Unlock()
 	if x.l != nil {
 		x.s = strings.Join(reverse(x.appendReverse(nil)), "")
 		x.l = nil
 		x.r = nil
 	}
-	s := x.s
-	x.mu.Unlock()
-
-	return s
+	return x.s
 }
 
 // reverse reverses x in place and returns it.
@@ -609,6 +607,30 @@ func Val(x Value) any {
 	}
 }
 
+// StringLen returns the length of x if x is a [String].
+// If x is [Unknown], the result is 0.
+// In all other cases, the function panics.
+func StringLen(x Value) int64 {
+	switch x := x.(type) {
+	case *stringVal:
+		return x.len()
+	case unknownVal:
+		return 0
+	default:
+		panic(fmt.Sprintf("%v not a String", x))
+	}
+}
+
+// len computes and returns the length of x without constructing the entire string.
+func (x *stringVal) len() int64 {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.l != nil {
+		return x.l.len() + x.r.len()
+	}
+	return int64(len(x.s))
+}
+
 // Make returns the [Value] for x.
 //
 //	type of x        result Kind

package/bin/go/src/go/doc/comment/std.go

@@ -47,5 +47,6 @@ var stdPkgs = []string{
 	"unicode",
 	"unique",
 	"unsafe",
+	"uuid",
 	"weak",
 }

package/bin/go/src/go/importer/importer.go

@@ -41,9 +41,10 @@ type Lookup func(path string) (io.ReadCloser, error)
 // it is assumed that the translation to canonical import paths is being
 // done by the client of the importer.
 //
-// A lookup function must be provided for correct module-aware operation.
-// Deprecated: If lookup is nil, for backwards-compatibility, the importer
-// will attempt to resolve imports in the $GOPATH workspace.
+// A lookup function must be provided for correct module-aware
+// operation. Providing a nil value for lookup is deprecated but, for
+// backwards-compatibility, the importer will in this case attempt to
+// resolve imports in the $GOPATH workspace.
 func ForCompiler(fset *token.FileSet, compiler string, lookup Lookup) types.Importer {
 	switch compiler {
 	case "gc":

package/bin/go/src/go/internal/gccgoimporter/parser.go

@@ -75,6 +75,8 @@ type importError struct {
 	err error
 }
 
+var _ error = importError{}
+
 func (e importError) Error() string {
 	return fmt.Sprintf("import error %s (byte offset = %d): %s", e.pos, e.pos.Offset, e.err)
 }

package/bin/go/src/go/internal/gcimporter/ureader.go

@@ -5,9 +5,9 @@
 package gcimporter
 
 import (
+	"cmp"
 	"go/token"
 	"go/types"
-	"internal/godebug"
 	"internal/pkgbits"
 	"slices"
 	"strings"
@@ -31,6 +31,10 @@ type pkgReader struct {
 
 	// laterFns holds functions that need to be invoked at the end of
 	// import reading.
+	//
+	// TODO(mdempsky): Is it safe to have a single "later" slice or do
+	// we need to have multiple passes? See comments on CL 386002 and
+	// go.dev/issue/52104.
 	laterFns []func()
 
 	// ifaces holds a list of constructed Interfaces, which need to have
@@ -119,12 +123,11 @@ type reader struct {
 // A readerDict holds the state for type parameters that parameterize
 // the current unified IR element.
 type readerDict struct {
-	// bounds is a slice of typeInfos corresponding to the underlying
-	// bounds of the element's type parameters.
-	bounds []typeInfo
+	rtbounds []typeInfo         // contains constraint types for each parameter in rtparams
+	rtparams []*types.TypeParam // contains receiver type parameters for an element
 
-	// tparams is a slice of the constructed TypeParams for the element.
-	tparams []*types.TypeParam
+	tbounds []typeInfo         // contains constraint types for each parameter in tparams
+	tparams []*types.TypeParam // contains type parameters for an element
 
 	// derived is a slice of types derived from tparams, which may be
 	// instantiated while reading the current element.
@@ -309,7 +312,11 @@ func (r *reader) doTyp() (res types.Type) {
 		return name.Type()
 
 	case pkgbits.TypeTypeParam:
-		return r.dict.tparams[r.Len()]
+		n := r.Len()
+		if n < len(r.dict.rtbounds) {
+			return r.dict.rtparams[n]
+		}
+		return r.dict.tparams[n-len(r.dict.rtbounds)]
 
 	case pkgbits.TypeArray:
 		len := int64(r.Uint64())
@@ -474,6 +481,12 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 		return objPkg, objName
 	}
 
+	// TODO(mark): This, like the above splitVargenSuffix, is not ideal.
+	// Ignore generic methods promoted to global scope.
+	if strings.Contains(objName, ".") {
+		return objPkg, objName
+	}
+
 	if objPkg.Scope().Lookup(objName) == nil {
 		dict := pr.objDictIdx(idx)
 
@@ -492,7 +505,7 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 			pos := r.pos()
 			var tparams []*types.TypeParam
 			if r.Version().Has(pkgbits.AliasTypeParamNames) {
-				tparams = r.typeParamNames()
+				tparams = r.typeParamNames(false)
 			}
 			typ := r.typ()
 			declare(newAliasTypeName(pos, objPkg, objName, typ, tparams))
@@ -505,7 +518,10 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 
 		case pkgbits.ObjFunc:
 			pos := r.pos()
-			tparams := r.typeParamNames()
+			if r.Version().Has(pkgbits.GenericMethods) {
+				assert(!r.Bool()) // generic methods are read in their defining type
+			}
+			tparams := r.typeParamNames(false)
 			sig := r.signature(nil, nil, tparams)
 			declare(types.NewFunc(pos, objPkg, objName, sig))
 
@@ -516,7 +532,7 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 			named := types.NewNamed(obj, nil, nil)
 			declare(obj)
 
-			named.SetTypeParams(r.typeParamNames())
+			named.SetTypeParams(r.typeParamNames(false))
 
 			underlying := r.typ().Underlying()
 
@@ -546,8 +562,66 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 
 			named.SetUnderlying(underlying)
 
-			for i, n := 0, r.Len(); i < n; i++ {
-				named.AddMethod(r.method())
+			if r.Version().Has(pkgbits.GenericMethods) {
+				// V4 (go1.27.0) emitted all non-generic methods
+				// before all generic ones, discarding source
+				// order: a bug (go.dev/issue/81188).
+				// V5 (go1.27.x) fixes it by emitting an explicit
+				// index along with each method.
+				type indexedMethod struct {
+					index int // (or -1 in V4)
+					fn    *types.Func
+				}
+
+				var methods []indexedMethod
+
+				// ordinary methods
+				for range r.Len() {
+					idx, m := r.method()
+					methods = append(methods, indexedMethod{idx, m})
+				}
+
+				// generic methods
+				for range r.Len() {
+					// Careful: objIdx is used to read in package-scoped declarations, which
+					// methods are not. Instead, decode it here. This makes it easier to
+					// associate it with the type and avoids the main objIdx loop.
+					idx := r.Reloc(pkgbits.SectionObj)
+
+					r := pr.tempReader(pkgbits.SectionObj, idx, pkgbits.SyncObject1)
+					r.dict = pr.objDictIdx(idx)
+
+					pos := r.pos()
+					assert(r.Bool()) // generic method
+					pkg, name := r.selector()
+					rtparams := r.typeParamNames(true)
+					recv := r.param(types.RecvVar)
+					methodIdx := -1
+					if r.Version().Has(pkgbits.PreserveMethodOrder) {
+						methodIdx = r.Len()
+					}
+					tparams := r.typeParamNames(false)
+					sig := r.signature(recv, rtparams, tparams)
+
+					pr.retireReader(r)
+					methods = append(methods, indexedMethod{methodIdx, types.NewFunc(pos, pkg, name, sig)})
+				}
+
+				if r.Version().Has(pkgbits.PreserveMethodOrder) {
+					slices.SortFunc(methods, func(a, b indexedMethod) int {
+						return cmp.Compare(a.index, b.index)
+					})
+				}
+
+				for _, m := range methods {
+					named.AddMethod(m.fn)
+				}
+
+			} else {
+				for range r.Len() {
+					_, m := r.method()
+					named.AddMethod(m)
+				}
 			}
 
 		case pkgbits.ObjVar:
@@ -570,9 +644,20 @@ func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
 			errorf("unexpected object with %v implicit type parameter(s)", implicits)
 		}
 
-		dict.bounds = make([]typeInfo, r.Len())
-		for i := range dict.bounds {
-			dict.bounds[i] = r.typInfo()
+		nreceivers := 0
+		if r.Version().Has(pkgbits.GenericMethods) {
+			nreceivers = r.Len()
+		}
+		nexplicits := r.Len()
+
+		dict.rtbounds = make([]typeInfo, nreceivers)
+		for i := range dict.rtbounds {
+			dict.rtbounds[i] = r.typInfo()
+		}
+
+		dict.tbounds = make([]typeInfo, nexplicits)
+		for i := range dict.tbounds {
+			dict.tbounds[i] = r.typInfo()
 		}
 
 		dict.derived = make([]derivedInfo, r.Len())
@@ -591,15 +676,24 @@ func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
 	return &dict
 }
 
-func (r *reader) typeParamNames() []*types.TypeParam {
+func (r *reader) typeParamNames(isGenMeth bool) []*types.TypeParam {
 	r.Sync(pkgbits.SyncTypeParamNames)
 
-	// Note: This code assumes it only processes objects without
-	// implement type parameters. This is currently fine, because
-	// reader is only used to read in exported declarations, which are
-	// always package scoped.
+	// Note: This code assumes there are no implicit type parameters.
+	// This is fine since it only reads exported declarations, which
+	// never have implicits.
 
-	if len(r.dict.bounds) == 0 {
+	var in []typeInfo
+	var out *[]*types.TypeParam
+	if isGenMeth {
+		in = r.dict.rtbounds
+		out = &r.dict.rtparams
+	} else {
+		in = r.dict.tbounds
+		out = &r.dict.tparams
+	}
+
+	if len(in) == 0 {
 		return nil
 	}
 
@@ -608,52 +702,50 @@ func (r *reader) typeParamNames() []*types.TypeParam {
 	// create all the TypeNames and TypeParams, then we construct and
 	// set the bound type.
 
-	r.dict.tparams = make([]*types.TypeParam, len(r.dict.bounds))
-	for i := range r.dict.bounds {
+	// We have to save tparams outside of the closure, because typeParamNames
+	// can be called multiple times with the same dictionary instance.
+	tparams := make([]*types.TypeParam, len(in))
+	*out = tparams
+
+	for i := range in {
 		pos := r.pos()
 		pkg, name := r.localIdent()
 
 		tname := types.NewTypeName(pos, pkg, name, nil)
-		r.dict.tparams[i] = types.NewTypeParam(tname, nil)
+		tparams[i] = types.NewTypeParam(tname, nil)
 	}
 
-	typs := make([]types.Type, len(r.dict.bounds))
-	for i, bound := range r.dict.bounds {
-		typs[i] = r.p.typIdx(bound, r.dict)
+	// The reader dictionary will continue mutating before we have time
+	// to call delayed functions; make a local copy of the constraints.
+	types := make([]types.Type, len(in))
+	for i, info := range in {
+		types[i] = r.p.typIdx(info, r.dict)
 	}
 
-	// TODO(mdempsky): This is subtle, elaborate further.
-	//
-	// We have to save tparams outside of the closure, because
-	// typeParamNames() can be called multiple times with the same
-	// dictionary instance.
-	//
-	// Also, this needs to happen later to make sure SetUnderlying has
-	// been called.
-	//
-	// TODO(mdempsky): Is it safe to have a single "later" slice or do
-	// we need to have multiple passes? See comments on CL 386002 and
-	// go.dev/issue/52104.
-	tparams := r.dict.tparams
+	// This needs to happen later to make sure SetUnderlying has been called.
 	r.p.later(func() {
-		for i, typ := range typs {
+		for i, typ := range types {
 			tparams[i].SetConstraint(typ)
 		}
 	})
 
-	return r.dict.tparams
+	return tparams
 }
 
-func (r *reader) method() *types.Func {
+func (r *reader) method() (int, *types.Func) {
 	r.Sync(pkgbits.SyncMethod)
+	idx := -1
+	if r.Version().Has(pkgbits.PreserveMethodOrder) {
+		idx = r.Len()
+	}
 	pos := r.pos()
 	pkg, name := r.selector()
 
-	rparams := r.typeParamNames()
+	rparams := r.typeParamNames(false)
 	sig := r.signature(r.param(types.RecvVar), rparams, nil)
 
 	_ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go.
-	return types.NewFunc(pos, pkg, name, sig)
+	return idx, types.NewFunc(pos, pkg, name, sig)
 }
 
 func (r *reader) qualifiedIdent() (*types.Package, string) { return r.ident(pkgbits.SyncSym) }
@@ -678,15 +770,8 @@ func pkgScope(pkg *types.Package) *types.Scope {
 
 // newAliasTypeName returns a new TypeName, with a materialized *types.Alias if supported.
 func newAliasTypeName(pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
-	// When GODEBUG=gotypesalias=1 or unset, the Type() of the return value is a
-	// *types.Alias. Copied from x/tools/internal/aliases.NewAlias.
-	switch godebug.New("gotypesalias").Value() {
-	case "", "1":
-		tname := types.NewTypeName(pos, pkg, name, nil)
-		a := types.NewAlias(tname, rhs) // form TypeName -> Alias cycle
-		a.SetTypeParams(tparams)
-		return tname
-	}
-	assert(len(tparams) == 0)
-	return types.NewTypeName(pos, pkg, name, rhs)
+	tname := types.NewTypeName(pos, pkg, name, nil)
+	a := types.NewAlias(tname, rhs) // form TypeName -> Alias cycle
+	a.SetTypeParams(tparams)
+	return tname
 }

package/bin/go/src/go/parser/parser.go

@@ -28,7 +28,6 @@ import (
 	"fmt"
 	"go/ast"
 	"go/build/constraint"
-	"go/internal/scannerhooks"
 	"go/scanner"
 	"go/token"
 	"strings"
@@ -53,10 +52,9 @@ type parser struct {
 	goVersion   string            // minimum Go version found in //go:build comment
 
 	// Next token
-	pos       token.Pos   // token position
-	tok       token.Token // one token look-ahead
-	lit       string      // token literal
-	stringEnd token.Pos   // position immediately after token; STRING only
+	pos token.Pos   // token position
+	tok token.Token // one token look-ahead
+	lit string      // token literal
 
 	// Error recovery
 	// (used to limit the number of calls to parser.advance
@@ -87,6 +85,11 @@ func (p *parser) init(file *token.File, src []byte, mode Mode) {
 	p.next()
 }
 
+// end returns the end position of the current token
+func (p *parser) end() token.Pos {
+	return p.scanner.End()
+}
+
 // ----------------------------------------------------------------------------
 // Parsing support
 
@@ -165,10 +168,6 @@ func (p *parser) next0() {
 				continue
 			}
 		} else {
-			if p.tok == token.STRING {
-				p.stringEnd = scannerhooks.StringEnd(&p.scanner)
-			}
-
 			// Found a non-comment; top of file is over.
 			p.top = false
 		}
@@ -726,7 +725,7 @@ func (p *parser) parseFieldDecl() *ast.Field {
 
 	var tag *ast.BasicLit
 	if p.tok == token.STRING {
-		tag = &ast.BasicLit{ValuePos: p.pos, ValueEnd: p.stringEnd, Kind: p.tok, Value: p.lit}
+		tag = &ast.BasicLit{ValuePos: p.pos, ValueEnd: p.end(), Kind: p.tok, Value: p.lit}
 		p.next()
 	}
 
@@ -1480,11 +1479,7 @@ func (p *parser) parseOperand() ast.Expr {
 		return x
 
 	case token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING:
-		end := p.pos + token.Pos(len(p.lit))
-		if p.tok == token.STRING {
-			end = p.stringEnd
-		}
-		x := &ast.BasicLit{ValuePos: p.pos, ValueEnd: end, Kind: p.tok, Value: p.lit}
+		x := &ast.BasicLit{ValuePos: p.pos, ValueEnd: p.end(), Kind: p.tok, Value: p.lit}
 		p.next()
 		return x
 
@@ -2525,7 +2520,7 @@ func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Token, _ int) as
 	var path string
 	if p.tok == token.STRING {
 		path = p.lit
-		end = p.stringEnd
+		end = p.end()
 		p.next()
 	} else if p.tok.IsLiteral() {
 		p.error(pos, "import path must be a string")
@@ -2799,12 +2794,6 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 	var tparams *ast.FieldList
 	if p.tok == token.LBRACK {
 		tparams = p.parseTypeParameters()
-		if recv != nil && tparams != nil {
-			// Method declarations do not have type parameters. We parse them for a
-			// better error message and improved error recovery.
-			p.error(tparams.Opening, "method must have no type parameters")
-			tparams = nil
-		}
 	}
 	params := p.parseParameters(false)
 	results := p.parseParameters(true)

package/bin/go/src/go/printer/math.go

@@ -0,0 +1,28 @@
+// 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 printer
+
+import "math"
+
+// log2ish returns a crude approximation to log₂(x).
+// The result is only used for heuristic alignment decisions and should
+// not be used where precision matters.
+// The approximation is guaranteed to produce identical results
+// across all architectures.
+func log2ish(x float64) float64 {
+	f, e := math.Frexp(x)
+	return float64(e) + 2*(f-1)
+}
+
+// exp2ish returns a crude approximation to 2**x.
+// The result is only used for heuristic alignment decisions and should
+// not be used where precision matters.
+// The approximation is guaranteed to produce identical results
+// across all architectures.
+func exp2ish(x float64) float64 {
+	n := math.Floor(x)
+	f := x - n
+	return math.Ldexp(1+f, int(n))
+}

package/bin/go/src/go/printer/nodes.go

@@ -11,7 +11,6 @@ package printer
 import (
 	"go/ast"
 	"go/token"
-	"math"
 	"strconv"
 	"strings"
 	"unicode"
@@ -183,9 +182,9 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp
 
 	// We use the ratio between the geometric mean of the previous key sizes and
 	// the current size to determine if there should be a break in the alignment.
-	// To compute the geometric mean we accumulate the ln(size) values (lnsum)
+	// To compute the geometric mean we accumulate the log₂(size) values (log2sum)
 	// and the number of sizes included (count).
-	lnsum := 0.0
+	log2sum := 0.0
 	count := 0
 
 	// print all list elements
@@ -228,8 +227,8 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp
 			if count == 0 || prevSize <= smallSize && size <= smallSize {
 				useFF = false
 			} else {
-				const r = 2.5                               // threshold
-				geomean := math.Exp(lnsum / float64(count)) // count > 0
+				const r = 2.5                                // threshold
+				geomean := exp2ish(log2sum / float64(count)) // count > 0
 				ratio := float64(size) / geomean
 				useFF = r*ratio <= 1 || r <= ratio
 			}
@@ -260,7 +259,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp
 				// the section), reset the geomean variables since we are
 				// starting a new group of elements with the next element.
 				if nbreaks > 1 {
-					lnsum = 0
+					log2sum = 0
 					count = 0
 				}
 			}
@@ -284,7 +283,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp
 		}
 
 		if size > 0 {
-			lnsum += math.Log(float64(size))
+			log2sum += log2ish(float64(size))
 			count++
 		}
 
@@ -1310,13 +1309,29 @@ func (p *printer) controlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, po
 	}
 }
 
+// isCompositeLitLike reports whether x is a composite literal or an expression
+// whose core is a composite literal (e.g. &T{...}), ignoring parentheses.
+func isCompositeLitLike(x ast.Expr) bool {
+	switch x := stripParensAlways(x).(type) {
+	case *ast.CompositeLit:
+		return true
+	case *ast.UnaryExpr:
+		_, ok := stripParensAlways(x.X).(*ast.CompositeLit)
+		return x.Op == token.AND && ok
+	}
+	return false
+}
+
 // indentList reports whether an expression list would look better if it
 // were indented wholesale (starting with the very first element, rather
 // than starting at the first line break).
+// Currently this function is only used to improve formatting of return
+// statements.
 func (p *printer) indentList(list []ast.Expr) bool {
 	// Heuristic: indentList reports whether there are more than one multi-
-	// line element in the list, or if there is any element that is not
-	// starting on the same line as the previous one ends.
+	// line element (such as a complex expression, but excluding composite
+	// literals) in the list, or if there is any element that is not starting
+	// on the same line as the previous one ends.
 	if len(list) >= 2 {
 		var b = p.lineFor(list[0].Pos())
 		var e = p.lineFor(list[len(list)-1].End())
@@ -1332,8 +1347,10 @@ func (p *printer) indentList(list []ast.Expr) bool {
 					// line as the previous one ended
 					return true
 				}
-				if xb < xe {
-					// x is a multi-line element
+				if xb < xe && !isCompositeLitLike(x) {
+					// x is a multi-line element but not a composite literal
+					// (composite literals have their own field indentation
+					// already, see go.dev/issue/7195)
 					n++
 				}
 				line = xe

package/bin/go/src/go/printer/printer.go

@@ -739,7 +739,9 @@ func (p *printer) intersperseComments(next token.Position, tok token.Token) (wro
 	for p.commentBefore(next) {
 		list := p.comment.List
 		changed := false
-		if p.lastTok != token.IMPORT && // do not rewrite cgo's import "C" comments
+
+		if tok != token.IDENT &&
+			p.lastTok != token.IMPORT && // do not rewrite cgo's import "C" comments
 			p.posFor(p.comment.Pos()).Column == 1 &&
 			p.posFor(p.comment.End()+1) == next {
 			// Unindented comment abutting next token position:

package/bin/go/src/go/scanner/errors.go

@@ -20,6 +20,8 @@ type Error struct {
 	Msg string
 }
 
+var _ error = (*Error)(nil) // *Error (not Error) is the correct type in error.Is tests.
+
 // Error implements the error interface.
 func (e Error) Error() string {
 	if e.Pos.Filename != "" || e.Pos.IsValid() {