@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/go/types/check.go

@@ -11,10 +11,8 @@ import (
 	"go/ast"
 	"go/constant"
 	"go/token"
-	"internal/godebug"
 	. "internal/types/errors"
 	"os"
-	"sync/atomic"
 )
 
 // nopos, noposn indicate an unknown position
@@ -27,42 +25,6 @@ const debug = false // leave on during development
 // position tracing for panics during type checking
 const tracePos = true
 
-// gotypesalias controls the use of Alias types.
-// As of Apr 16 2024 they are used by default.
-// To disable their use, set GODEBUG to gotypesalias=0.
-// This GODEBUG flag will be removed in the near future (tentatively Go 1.24).
-var gotypesalias = godebug.New("gotypesalias")
-
-// _aliasAny changes the behavior of [Scope.Lookup] for "any" in the
-// [Universe] scope.
-//
-// This is necessary because while Alias creation is controlled by
-// [Config._EnableAlias], based on the gotypealias variable, the representation
-// of "any" is a global. In [Scope.Lookup], we select this global
-// representation based on the result of [aliasAny], but as a result need to
-// guard against this behavior changing during the type checking pass.
-// Therefore we implement the following rule: any number of goroutines can type
-// check concurrently with the same EnableAlias value, but if any goroutine
-// tries to type check concurrently with a different EnableAlias value, we
-// panic.
-//
-// To achieve this, _aliasAny is a state machine:
-//
-//	0:        no type checking is occurring
-//	negative: type checking is occurring without _EnableAlias set
-//	positive: type checking is occurring with _EnableAlias set
-var _aliasAny int32
-
-func aliasAny() bool {
-	v := gotypesalias.Value()
-	useAlias := v != "0"
-	inuse := atomic.LoadInt32(&_aliasAny)
-	if inuse != 0 && useAlias != (inuse > 0) {
-		panic(fmt.Sprintf("gotypealias mutated during type checking, gotypesalias=%s, inuse=%d", v, inuse))
-	}
-	return useAlias
-}
-
 // exprInfo stores information about an untyped expression.
 type exprInfo struct {
 	isLhs bool // expression is lhs operand of a shift with delayed type-check
@@ -220,34 +182,6 @@ func (check *Checker) addDeclDep(to Object) {
 	from.addDep(to)
 }
 
-// Note: The following three alias-related functions are only used
-//       when Alias types are not enabled.
-
-// brokenAlias records that alias doesn't have a determined type yet.
-// It also sets alias.typ to Typ[Invalid].
-// Not used if check.conf._EnableAlias is set.
-func (check *Checker) brokenAlias(alias *TypeName) {
-	assert(!check.conf._EnableAlias)
-	if check.brokenAliases == nil {
-		check.brokenAliases = make(map[*TypeName]bool)
-	}
-	check.brokenAliases[alias] = true
-	alias.typ = Typ[Invalid]
-}
-
-// validAlias records that alias has the valid type typ (possibly Typ[Invalid]).
-func (check *Checker) validAlias(alias *TypeName, typ Type) {
-	assert(!check.conf._EnableAlias)
-	delete(check.brokenAliases, alias)
-	alias.typ = typ
-}
-
-// isBrokenAlias reports whether alias doesn't have a determined type yet.
-func (check *Checker) isBrokenAlias(alias *TypeName) bool {
-	assert(!check.conf._EnableAlias)
-	return check.brokenAliases[alias]
-}
-
 func (check *Checker) rememberUntyped(e ast.Expr, lhs bool, mode operandMode, typ *Basic, val constant.Value) {
 	m := check.untyped
 	if m == nil {
@@ -316,9 +250,6 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 	//
 	// (previously, pkg.goVersion was mutated here: go.dev/issue/61212)
 
-	// In go/types, conf._EnableAlias is controlled by gotypesalias.
-	conf._EnableAlias = gotypesalias.Value() != "0"
-
 	return &Checker{
 		conf:         conf,
 		ctxt:         conf.Context,
@@ -497,20 +428,6 @@ func (check *Checker) Files(files []*ast.File) (err error) {
 // syntax is properly type annotated even in a package containing
 // errors.
 func (check *Checker) checkFiles(files []*ast.File) {
-	// Ensure that _EnableAlias is consistent among concurrent type checking
-	// operations. See the documentation of [_aliasAny] for details.
-	if check.conf._EnableAlias {
-		if atomic.AddInt32(&_aliasAny, 1) <= 0 {
-			panic("EnableAlias set while !EnableAlias type checking is ongoing")
-		}
-		defer atomic.AddInt32(&_aliasAny, -1)
-	} else {
-		if atomic.AddInt32(&_aliasAny, -1) >= 0 {
-			panic("!EnableAlias set while EnableAlias type checking is ongoing")
-		}
-		defer atomic.AddInt32(&_aliasAny, 1)
-	}
-
 	print := func(msg string) {
 		if check.conf._Trace {
 			fmt.Println()

package/bin/go/src/go/types/const.go

@@ -20,7 +20,7 @@ import (
 // For untyped constants, it checks that the value doesn't become
 // arbitrarily large.
 func (check *Checker) overflow(x *operand, opPos token.Pos) {
-	assert(x.mode == constant_)
+	assert(x.mode() == constant_)
 
 	if x.val.Kind() == constant.Unknown {
 		// TODO(gri) We should report exactly what went wrong. At the
@@ -34,8 +34,8 @@ func (check *Checker) overflow(x *operand, opPos token.Pos) {
 	// their type after each constant operation.
 	// x.typ cannot be a type parameter (type
 	// parameters cannot be constant types).
-	if isTyped(x.typ) {
-		check.representable(x, x.typ.Underlying().(*Basic))
+	if isTyped(x.typ()) {
+		check.representable(x, x.typ().Underlying().(*Basic))
 		return
 	}
 
@@ -48,6 +48,18 @@ func (check *Checker) overflow(x *operand, opPos token.Pos) {
 		}
 		check.errorf(atPos(opPos), InvalidConstVal, "constant %soverflow", op)
 		x.val = constant.MakeUnknown()
+		return
+	}
+
+	// String values must not become arbitrarily long (go.dev/issue/78346).
+	const maxLen = int64(2e9) // cmd/internal/obj.MaxSymSize
+	if x.val.Kind() == constant.String {
+		len := constant.StringLen(x.val)
+		if len > maxLen {
+			check.errorf(atPos(opPos), InvalidConstVal, "constant string too long (%d bytes > %d bytes)", len, maxLen)
+			x.val = constant.MakeUnknown()
+			return
+		}
 	}
 }
 
@@ -240,7 +252,7 @@ func (check *Checker) representable(x *operand, typ *Basic) {
 	v, code := check.representation(x, typ)
 	if code != 0 {
 		check.invalidConversion(code, x, typ)
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 	assert(v != nil)
@@ -252,10 +264,10 @@ func (check *Checker) representable(x *operand, typ *Basic) {
 //
 // If no such representation is possible, it returns a non-zero error code.
 func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, Code) {
-	assert(x.mode == constant_)
+	assert(x.mode() == constant_)
 	v := x.val
 	if !representableConst(x.val, check, typ, &v) {
-		if isNumeric(x.typ) && isNumeric(typ) {
+		if isNumeric(x.typ()) && isNumeric(typ) {
 			// numeric conversion : error msg
 			//
 			// integer -> integer : overflows
@@ -263,7 +275,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, Co
 			// float   -> integer : truncated
 			// float   -> float   : overflows
 			//
-			if !isInteger(x.typ) && isInteger(typ) {
+			if !isInteger(x.typ()) && isInteger(typ) {
 				return nil, TruncatedFloat
 			} else {
 				return nil, NumericOverflow
@@ -294,15 +306,15 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 			t = safeUnderlying(target)
 		}
 		check.invalidConversion(code, x, t)
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 	if val != nil {
 		x.val = val
 		check.updateExprVal(x.expr, val)
 	}
-	if newType != x.typ {
-		x.typ = newType
+	if newType != x.typ() {
+		x.typ_ = newType
 		check.updateExprType(x.expr, newType, false)
 	}
 }

package/bin/go/src/go/types/conversions.go

@@ -18,7 +18,7 @@ import (
 // conversion type-checks the conversion T(x).
 // The result is in x.
 func (check *Checker) conversion(x *operand, T Type) {
-	constArg := x.mode == constant_
+	constArg := x.mode() == constant_
 
 	constConvertibleTo := func(T Type, val *constant.Value) bool {
 		switch t, _ := T.Underlying().(*Basic); {
@@ -26,7 +26,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 			// nothing to do
 		case representableConst(x.val, check, t, val):
 			return true
-		case isInteger(x.typ) && isString(t):
+		case isInteger(x.typ()) && isString(t):
 			codepoint := unicode.ReplacementChar
 			if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune {
 				codepoint = rune(i)
@@ -48,9 +48,9 @@ func (check *Checker) conversion(x *operand, T Type) {
 		// A conversion from an integer constant to an integer type
 		// can only fail if there's overflow. Give a concise error.
 		// (go.dev/issue/63563)
-		if !ok && isInteger(x.typ) && isInteger(T) {
+		if !ok && isInteger(x.typ()) && isInteger(T) {
 			check.errorf(x, InvalidConversion, "constant %s overflows %s", x.val, T)
-			x.mode = invalid
+			x.invalidate()
 			return
 		}
 	case constArg && isTypeParam(T):
@@ -65,11 +65,11 @@ func (check *Checker) conversion(x *operand, T Type) {
 				cause = check.sprintf("%s does not contain specific types", T)
 				return false
 			}
-			if isString(x.typ) && isBytesOrRunes(u) {
+			if isString(x.typ()) && isBytesOrRunes(u) {
 				return true
 			}
 			if !constConvertibleTo(u, nil) {
-				if isInteger(x.typ) && isInteger(u) {
+				if isInteger(x.typ()) && isInteger(u) {
 					// see comment above on constant conversion
 					cause = check.sprintf("constant %s overflows %s (in %s)", x.val, u, T)
 				} else {
@@ -79,11 +79,11 @@ func (check *Checker) conversion(x *operand, T Type) {
 			}
 			return true
 		})
-		x.mode = value // type parameters are not constants
+		x.mode_ = value // type parameters are not constants
 	case x.convertibleTo(check, T, &cause):
 		// non-constant conversion
 		ok = true
-		x.mode = value
+		x.mode_ = value
 	}
 
 	if !ok {
@@ -92,14 +92,14 @@ func (check *Checker) conversion(x *operand, T Type) {
 		} else {
 			check.errorf(x, InvalidConversion, "cannot convert %s to type %s", x, T)
 		}
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 
 	// The conversion argument types are final. For untyped values the
 	// conversion provides the type, per the spec: "A constant may be
 	// given a type explicitly by a constant declaration or conversion,...".
-	if isUntyped(x.typ) {
+	if isUntyped(x.typ()) {
 		final := T
 		// - For conversions to interfaces, except for untyped nil arguments
 		//   and isTypes2, use the argument's default type.
@@ -109,17 +109,17 @@ func (check *Checker) conversion(x *operand, T Type) {
 		// - If !isTypes2, keep untyped nil for untyped nil arguments.
 		// - For constant integer to string conversions, keep the argument type.
 		//   (See also the TODO below.)
-		if isTypes2 && x.typ == Typ[UntypedNil] {
+		if isTypes2 && x.typ() == Typ[UntypedNil] {
 			// ok
 		} else if isNonTypeParamInterface(T) || constArg && !isConstType(T) || !isTypes2 && x.isNil() {
-			final = Default(x.typ) // default type of untyped nil is untyped nil
-		} else if x.mode == constant_ && isInteger(x.typ) && allString(T) {
-			final = x.typ
+			final = Default(x.typ()) // default type of untyped nil is untyped nil
+		} else if x.mode() == constant_ && isInteger(x.typ()) && allString(T) {
+			final = x.typ()
 		}
 		check.updateExprType(x.expr, final, true)
 	}
 
-	x.typ = T
+	x.typ_ = T
 }
 
 // TODO(gri) convertibleTo checks if T(x) is valid. It assumes that the type
@@ -143,7 +143,7 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	}
 
 	origT := T
-	V := Unalias(x.typ)
+	V := Unalias(x.typ())
 	T = Unalias(T)
 	Vu := V.Underlying()
 	Tu := T.Underlying()
@@ -253,7 +253,7 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 			if V == nil {
 				return false // no specific types
 			}
-			x.typ = V.typ
+			x.typ_ = V.typ
 			return Tp.is(func(T *term) bool {
 				if T == nil {
 					return false // no specific types
@@ -271,7 +271,7 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 			if V == nil {
 				return false // no specific types
 			}
-			x.typ = V.typ
+			x.typ_ = V.typ
 			if !x.convertibleTo(check, T, cause) {
 				errorf("cannot convert %s (in %s) to type %s", V.typ, Vp, origT)
 				return false
@@ -284,7 +284,7 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 				return false // no specific types
 			}
 			if !x.convertibleTo(check, T.typ, cause) {
-				errorf("cannot convert %s to type %s (in %s)", x.typ, T.typ, Tp)
+				errorf("cannot convert %s to type %s (in %s)", x.typ(), T.typ, Tp)
 				return false
 			}
 			return true

package/bin/go/src/go/types/cycles.go

@@ -106,50 +106,37 @@ func (check *Checker) directCycle(tname *TypeName, pathIdx map[*TypeName]int) {
 	}
 }
 
-// TODO(markfreeman): Can the value cached on Named be used in validType / hasVarSize?
-
-// finiteSize returns whether a type has finite size.
-func (check *Checker) finiteSize(t Type) bool {
-	switch t := Unalias(t).(type) {
+// isComplete returns whether a type is complete (i.e. up to having an underlying type).
+// Incomplete types will panic if [Type.Underlying] is called on them.
+func (check *Checker) isComplete(t Type) bool {
+	var (
+		obj Object
+		rhs Type
+	)
+	switch t := t.(type) {
+	case *Alias:
+		obj = t.obj
+		rhs = t.fromRHS
 	case *Named:
-		if t.stateHas(hasFinite) {
-			return t.finite
-		}
-
-		if i, ok := check.objPathIdx[t.obj]; ok {
-			cycle := check.objPath[i:]
-			check.cycleError(cycle, firstInSrc(cycle))
-			return false
-		}
-		check.push(t.obj)
-		defer check.pop()
-
-		isFinite := check.finiteSize(t.fromRHS)
-
-		t.mu.Lock()
-		defer t.mu.Unlock()
-		// Careful, t.finite has lock-free readers. Since we might be racing
-		// another call to finiteSize, we have to avoid overwriting t.finite.
-		// Otherwise, the race detector will be tripped.
-		if !t.stateHas(hasFinite) {
-			t.finite = isFinite
-			t.setState(hasFinite)
-		}
-
-		return isFinite
-
-	case *Array:
-		// The array length is already computed. If it was a valid length, it
-		// is finite; else, an error was reported in the computation.
-		return check.finiteSize(t.elem)
+		obj = t.obj
+		rhs = t.fromRHS
+	default:
+		return true
+	}
 
-	case *Struct:
-		for _, f := range t.fields {
-			if !check.finiteSize(f.typ) {
-				return false
-			}
-		}
+	if i, found := check.objPathIdx[obj]; found {
+		cycle := check.objPath[i:]
+		check.cycleError(cycle, firstInSrc(cycle))
+		return false
 	}
 
-	return true
+	// We must walk through names because we permit certain cycles of names.
+	// Consider:
+	//
+	//   type A B
+	//   type B [unsafe.Sizeof(A{})]int
+	//
+	// starting at B. At the site of A{}, A has no underlying type, and so a
+	// cycle must be reported.
+	return check.isComplete(rhs)
 }

package/bin/go/src/go/types/decl.go

@@ -201,26 +201,7 @@ loop:
 				break loop
 			}
 
-			// Determine if the type name is an alias or not. For
-			// package-level objects, use the object map which
-			// provides syntactic information (which doesn't rely
-			// on the order in which the objects are set up). For
-			// local objects, we can rely on the order, so use
-			// the object's predicate.
-			// TODO(gri) It would be less fragile to always access
-			// the syntactic information. We should consider storing
-			// this information explicitly in the object.
-			var alias bool
-			if check.conf._EnableAlias {
-				alias = obj.IsAlias()
-			} else {
-				if d := check.objMap[obj]; d != nil {
-					alias = d.tdecl.Assign.IsValid() // package-level object
-				} else {
-					alias = obj.IsAlias() // function local object
-				}
-			}
-			if !alias {
+			if !obj.IsAlias() {
 				ndef++
 			}
 		case *Func:
@@ -276,6 +257,10 @@ func (check *Checker) cycleError(cycle []Object, start int) {
 	// may refer to imported types. See go.dev/issue/50788.
 	// TODO(gri) This functionality is used elsewhere. Factor it out.
 	name := func(obj Object) string {
+		// include any type arguments in the reported error message
+		if n := asNamed(obj.Type()); n != nil && n.inst != nil {
+			return TypeString(n, check.qualifier)
+		}
 		return packagePrefix(obj.Pkg(), check.qualifier) + obj.Name()
 	}
 
@@ -283,14 +268,8 @@ func (check *Checker) cycleError(cycle []Object, start int) {
 	obj := cycle[start]
 	tname, _ := obj.(*TypeName)
 	if tname != nil {
-		if check.conf._EnableAlias {
-			if a, ok := tname.Type().(*Alias); ok {
-				a.fromRHS = Typ[Invalid]
-			}
-		} else {
-			if tname.IsAlias() {
-				check.validAlias(tname, Typ[Invalid])
-			}
+		if a, ok := tname.Type().(*Alias); ok {
+			a.fromRHS = Typ[Invalid]
 		}
 	}
 
@@ -546,52 +525,35 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec) {
 			versionErr = true
 		}
 
-		if check.conf._EnableAlias {
-			alias := check.newAlias(obj, nil)
-
-			// If we could not type the RHS, set it to invalid. This should
-			// only ever happen if we panic before setting.
-			defer func() {
-				if alias.fromRHS == nil {
-					alias.fromRHS = Typ[Invalid]
-					unalias(alias)
-				}
-			}()
+		alias := check.newAlias(obj, nil)
 
-			// handle type parameters even if not allowed (Alias type is supported)
-			if tparam0 != nil {
-				check.openScope(tdecl, "type parameters")
-				defer check.closeScope()
-				check.collectTypeParams(&alias.tparams, tdecl.TypeParams)
+		// If we could not type the RHS, set it to invalid. This should
+		// only ever happen if we panic before setting.
+		defer func() {
+			if alias.fromRHS == nil {
+				alias.fromRHS = Typ[Invalid]
+				unalias(alias)
 			}
+		}()
 
-			rhs = check.declaredType(tdecl.Type, obj)
-			assert(rhs != nil)
-			alias.fromRHS = rhs
+		// handle type parameters even if not allowed (Alias type is supported)
+		if tparam0 != nil {
+			check.openScope(tdecl, "type parameters")
+			defer check.closeScope()
+			check.collectTypeParams(&alias.tparams, tdecl.TypeParams)
+		}
 
-			// spec: In an alias declaration the given type cannot be a type parameter declared in the same declaration."
-			// (see also go.dev/issue/75884, go.dev/issue/#75885)
-			if tpar, ok := rhs.(*TypeParam); ok && alias.tparams != nil && slices.Index(alias.tparams.list(), tpar) >= 0 {
-				check.error(tdecl.Type, MisplacedTypeParam, "cannot use type parameter declared in alias declaration as RHS")
-				alias.fromRHS = Typ[Invalid]
-			}
-		} else {
-			// With Go1.23, the default behavior is to use Alias nodes,
-			// reflected by check.enableAlias. Signal non-default behavior.
-			//
-			// TODO(gri) Testing runs tests in both modes. Do we need to exclude
-			//           tracking of non-default behavior for tests?
-			gotypesalias.IncNonDefault()
-
-			if !versionErr && tparam0 != nil {
-				check.error(tdecl, UnsupportedFeature, "generic type alias requires GODEBUG=gotypesalias=1 or unset")
-				versionErr = true
-			}
+		rhs = check.declaredType(tdecl.Type, obj)
+		assert(rhs != nil)
+		alias.fromRHS = rhs
 
-			check.brokenAlias(obj)
-			rhs = check.typ(tdecl.Type)
-			check.validAlias(obj, rhs)
+		// spec: In an alias declaration the given type cannot be a type parameter declared in the same declaration."
+		// (see also go.dev/issue/75884, go.dev/issue/#75885)
+		if tpar, ok := rhs.(*TypeParam); ok && alias.tparams != nil && slices.Index(alias.tparams.list(), tpar) >= 0 {
+			check.error(tdecl.Type, MisplacedTypeParam, "cannot use type parameter declared in alias declaration as RHS")
+			alias.fromRHS = Typ[Invalid]
 		}
+
 		return
 	}
 
@@ -601,19 +563,6 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec) {
 	}
 
 	named := check.newNamed(obj, nil, nil)
-
-	// The RHS of a named N can be nil if, for example, N is defined as a cycle of aliases with
-	// gotypesalias=0. Consider:
-	//
-	//   type D N    // N.unpack() will panic
-	//   type N A
-	//   type A = N  // N.fromRHS is not set before N.unpack(), since A does not call setDefType
-	//
-	// There is likely a better way to detect such cases, but it may not be worth the effort.
-	// Instead, we briefly permit a nil N.fromRHS while type-checking D.
-	named.allowNilRHS = true
-	defer (func() { named.allowNilRHS = false })()
-
 	if tdecl.TypeParams != nil {
 		check.openScope(tdecl, "type parameters")
 		defer check.closeScope()
@@ -822,6 +771,9 @@ func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
 	fdecl := decl.fdecl
 	check.funcType(sig, fdecl.Recv, fdecl.Type)
 
+	// types2 handles go:nointerface pragma here by setting obj.nointerface.
+	// go/types currently doesn't handle pragmas.
+
 	// Set the scope's extent to the complete "func (...) { ... }"
 	// so that Scope.Innermost works correctly.
 	sig.scope.pos = fdecl.Pos()