@ttsc/win32-arm64 0.33.1 → 0.34.0

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

@@ -10,7 +10,6 @@ package scanner
 import (
 	"bytes"
 	"fmt"
-	"go/internal/scannerhooks"
 	"go/token"
 	"path/filepath"
 	"strconv"
@@ -42,19 +41,14 @@ type Scanner struct {
 	lineOffset int       // current line offset
 	insertSemi bool      // insert a semicolon before next newline
 	nlPos      token.Pos // position of newline in preceding comment
-	stringEnd  token.Pos // end position; defined only for STRING tokens
+
+	endPosValid bool
+	endPos      token.Pos // overrides the offset as the default end position
 
 	// public state - ok to modify
 	ErrorCount int // number of errors encountered
 }
 
-// Provide go/parser with backdoor access to the StringEnd information.
-func init() {
-	scannerhooks.StringEnd = func(scanner any) token.Pos {
-		return scanner.(*Scanner).stringEnd
-	}
-}
-
 const (
 	bom = 0xFEFF // byte order mark, only permitted as very first character
 	eof = -1     // end of file
@@ -144,18 +138,20 @@ func (s *Scanner) Init(file *token.File, src []byte, err ErrorHandler, mode Mode
 	if file.Size() != len(src) {
 		panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
 	}
-	s.file = file
-	s.dir, _ = filepath.Split(file.Name())
-	s.src = src
-	s.err = err
-	s.mode = mode
 
-	s.ch = ' '
-	s.offset = 0
-	s.rdOffset = 0
-	s.lineOffset = 0
-	s.insertSemi = false
-	s.ErrorCount = 0
+	dir, _ := filepath.Split(file.Name())
+
+	*s = Scanner{
+		file: file,
+		dir:  dir,
+		src:  src,
+		err:  err,
+		mode: mode,
+
+		ch:          ' ',
+		endPosValid: true,
+		endPos:      token.NoPos,
+	}
 
 	s.next()
 	if s.ch == bom {
@@ -700,7 +696,7 @@ func stripCR(b []byte, comment bool) []byte {
 	return c[:i]
 }
 
-func (s *Scanner) scanRawString() (string, int) {
+func (s *Scanner) scanRawString() string {
 	// '`' opening already consumed
 	offs := s.offset - 1
 
@@ -721,12 +717,11 @@ func (s *Scanner) scanRawString() (string, int) {
 	}
 
 	lit := s.src[offs:s.offset]
-	rawLen := len(lit)
 	if hasCR {
 		lit = stripCR(lit, false)
 	}
 
-	return string(lit), rawLen
+	return string(lit)
 }
 
 func (s *Scanner) skipWhitespace() {
@@ -777,6 +772,21 @@ func (s *Scanner) switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Tok
 	return tok0
 }
 
+// End returns the position immediately after the last scanned token.
+// If [Scanner.Scan] has not been called yet, End returns [token.NoPos].
+func (s *Scanner) End() token.Pos {
+	// Handles special case:
+	// - Makes sure we return [token.NoPos], even when [Scanner.Init] has consumed a BOM.
+	// - When the previous token was a synthetic [token.SEMICOLON] inside a multi-line
+	//   comment, we make sure End returns its ending position (i.e. prevPos+len("\n")).
+	if s.endPosValid {
+		return s.endPos
+	}
+
+	// Normal case: s.file.Pos(s.offset) represents the end of the token
+	return s.file.Pos(s.offset)
+}
+
 // Scan scans the next token and returns the token position, the token,
 // and its literal string if applicable. The source end is indicated by
 // [token.EOF].
@@ -790,7 +800,9 @@ func (s *Scanner) switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Tok
 // If the returned token is [token.SEMICOLON], the corresponding
 // literal string is ";" if the semicolon was present in the source,
 // and "\n" if the semicolon was inserted because of a newline or
-// at EOF.
+// at EOF. If the newline is within a /*...*/ comment, the SEMICOLON token
+// is synthesized immediately after the COMMENT token; its position is that
+// of the actual newline within the comment.
 //
 // If the returned token is [token.ILLEGAL], the literal string is the
 // offending character.
@@ -809,10 +821,13 @@ func (s *Scanner) switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Tok
 // and thus relative to the file set.
 func (s *Scanner) Scan() (pos token.Pos, tok token.Token, lit string) {
 scanAgain:
+	s.endPosValid = false
 	if s.nlPos.IsValid() {
 		// Return artificial ';' token after /*...*/ comment
 		// containing newline, at position of first newline.
 		pos, tok, lit = s.nlPos, token.SEMICOLON, "\n"
+		s.endPos = pos + 1
+		s.endPosValid = true
 		s.nlPos = token.NoPos
 		return
 	}
@@ -860,7 +875,6 @@ scanAgain:
 			insertSemi = true
 			tok = token.STRING
 			lit = s.scanString()
-			s.stringEnd = pos + token.Pos(len(lit))
 		case '\'':
 			insertSemi = true
 			tok = token.CHAR
@@ -868,9 +882,7 @@ scanAgain:
 		case '`':
 			insertSemi = true
 			tok = token.STRING
-			var rawLen int
-			lit, rawLen = s.scanRawString()
-			s.stringEnd = pos + token.Pos(rawLen)
+			lit = s.scanRawString()
 		case ':':
 			tok = s.switch2(token.COLON, token.DEFINE)
 		case '.':

package/bin/go/src/go/token/position.go

@@ -112,6 +112,11 @@ type File struct {
 	infos []lineInfo
 }
 
+// String returns a brief description of the File.
+func (f *File) String() string {
+	return fmt.Sprintf("%s(%d-%d)", f.Name(), f.Base(), f.End())
+}
+
 // Name returns the file name of file f as registered with AddFile.
 func (f *File) Name() string {
 	return f.name
@@ -276,26 +281,12 @@ func (f *File) AddLineColumnInfo(offset int, filename string, line, column int)
 
 // fixOffset fixes an out-of-bounds offset such that 0 <= offset <= f.size.
 func (f *File) fixOffset(offset int) int {
-	switch {
-	case offset < 0:
-		if !debug {
-			return 0
-		}
-	case offset > f.size:
-		if !debug {
-			return f.size
-		}
-	default:
-		return offset
-	}
-
-	// only generate this code if needed
-	if debug {
+	if debug && !(0 <= offset && offset <= f.size) {
 		panic(fmt.Sprintf("offset %d out of bounds [%d, %d] (position %d out of bounds [%d, %d])",
 			0 /* for symmetry */, offset, f.size,
 			f.base+offset, f.base, f.base+f.size))
 	}
-	return 0
+	return max(min(f.size, offset), 0)
 }
 
 // Pos returns the Pos value for the given file offset.

package/bin/go/src/go/types/alias.go

@@ -24,24 +24,6 @@ import (
 //
 // Like a defined ([Named]) type, an alias type has a name.
 // Use the [Alias.Obj] method to access its [TypeName] object.
-//
-// Historically, Alias types were not materialized so that, in the example
-// above, A's type was represented by a Basic (int), not an Alias
-// whose [Alias.Rhs] is int. But Go 1.24 allows you to declare an
-// alias type with type parameters or arguments:
-//
-//	type Set[K comparable] = map[K]bool
-//	s := make(Set[String])
-//
-// and this requires that Alias types be materialized. Use the
-// [Alias.TypeParams] and [Alias.TypeArgs] methods to access them.
-//
-// To ease the transition, the Alias type was introduced in go1.22,
-// but the type-checker would not construct values of this type unless
-// the GODEBUG=gotypesalias=1 environment variable was provided.
-// Starting in go1.23, this variable is enabled by default.
-// This setting also causes the predeclared type "any" to be
-// represented as an Alias, not a bare [Interface].
 type Alias struct {
 	obj     *TypeName      // corresponding declared alias object
 	orig    *Alias         // original, uninstantiated alias

package/bin/go/src/go/types/api.go

@@ -186,16 +186,6 @@ type Config struct {
 	// of an error message. ErrorURL must be a format string containing
 	// exactly one "%s" format, e.g. "[go.dev/e/%s]".
 	_ErrorURL string
-
-	// If EnableAlias is set, alias declarations produce an Alias type. Otherwise
-	// the alias information is only in the type name, which points directly to
-	// the actual (aliased) type.
-	//
-	// This setting must not differ among concurrent type-checking operations,
-	// since it affects the behavior of Universe.Lookup("any").
-	//
-	// This flag will eventually be removed (with Go 1.24 at the earliest).
-	_EnableAlias bool
 }
 
 // Linkname for use from srcimporter.
@@ -455,6 +445,10 @@ type Instance struct {
 	Type     Type
 }
 
+func (inst Instance) String() string {
+	return fmt.Sprintf("%s%s", inst.TypeArgs, inst.Type)
+}
+
 // An Initializer describes a package-level variable, or a list of variables in case
 // of a multi-valued initialization expression, and the corresponding initialization
 // expression.

package/bin/go/src/go/types/api_predicates.go

@@ -31,7 +31,7 @@ func AssertableTo(V *Interface, T Type) bool {
 // The behavior of AssignableTo is unspecified if V or T is Typ[Invalid] or an
 // uninstantiated generic type.
 func AssignableTo(V, T Type) bool {
-	x := operand{mode: value, typ: V}
+	x := operand{mode_: value, typ_: V}
 	ok, _ := x.assignableTo(nil, T, nil) // check not needed for non-constant x
 	return ok
 }
@@ -42,7 +42,7 @@ func AssignableTo(V, T Type) bool {
 // The behavior of ConvertibleTo is unspecified if V or T is Typ[Invalid] or an
 // uninstantiated generic type.
 func ConvertibleTo(V, T Type) bool {
-	x := operand{mode: value, typ: V}
+	x := operand{mode_: value, typ_: V}
 	return x.convertibleTo(nil, T, nil) // check not needed for non-constant x
 }
 

package/bin/go/src/go/types/assignments.go

@@ -24,7 +24,7 @@ import (
 func (check *Checker) assignment(x *operand, T Type, context string) {
 	check.singleValue(x)
 
-	switch x.mode {
+	switch x.mode() {
 	case invalid:
 		return // error reported before
 	case nilvalue:
@@ -36,11 +36,11 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		// we may get here because of other problems (go.dev/issue/39634, crash 12)
 		// TODO(gri) do we need a new "generic" error code here?
 		check.errorf(x, IncompatibleAssign, "cannot assign %s to %s in %s", x, T, context)
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 
-	if isUntyped(x.typ) {
+	if isUntyped(x.typ()) {
 		target := T
 		// spec: "If an untyped constant is assigned to a variable of interface
 		// type or the blank identifier, the constant is first converted to type
@@ -51,20 +51,20 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 			if x.isNil() {
 				if T == nil {
 					check.errorf(x, UntypedNilUse, "use of untyped nil in %s", context)
-					x.mode = invalid
+					x.invalidate()
 					return
 				}
 			} else if T == nil || isNonTypeParamInterface(T) {
-				target = Default(x.typ)
+				target = Default(x.typ())
 			}
 		} else { // go/types
 			if T == nil || isNonTypeParamInterface(T) {
-				if T == nil && x.typ == Typ[UntypedNil] {
+				if T == nil && x.typ() == Typ[UntypedNil] {
 					check.errorf(x, UntypedNilUse, "use of untyped nil in %s", context)
-					x.mode = invalid
+					x.invalidate()
 					return
 				}
-				target = Default(x.typ)
+				target = Default(x.typ())
 			}
 		}
 		newType, val, code := check.implicitTypeAndValue(x, target)
@@ -79,24 +79,23 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 				code = IncompatibleAssign
 			}
 			check.error(x, code, msg)
-			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)
 		}
 	}
 	// x.typ is typed
 
 	// A generic (non-instantiated) function value cannot be assigned to a variable.
-	if sig, _ := x.typ.Underlying().(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
-		check.errorf(x, WrongTypeArgCount, "cannot use generic function %s without instantiation in %s", x, context)
-		x.mode = invalid
+	check.nonGeneric(newTarget(T, context), x)
+	if !x.isValid() {
 		return
 	}
 
@@ -114,12 +113,12 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		} else {
 			check.errorf(x, code, "cannot use %s as %s value in %s", x, T, context)
 		}
-		x.mode = invalid
+		x.invalidate()
 	}
 }
 
 func (check *Checker) initConst(lhs *Const, x *operand) {
-	if x.mode == invalid || !isValid(x.typ) || !isValid(lhs.typ) {
+	if !x.isValid() || !isValid(x.typ()) || !isValid(lhs.typ) {
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
@@ -127,22 +126,22 @@ func (check *Checker) initConst(lhs *Const, x *operand) {
 	}
 
 	// rhs must be a constant
-	if x.mode != constant_ {
+	if x.mode() != constant_ {
 		check.errorf(x, InvalidConstInit, "%s is not constant", x)
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
 		return
 	}
-	assert(isConstType(x.typ))
+	assert(isConstType(x.typ()))
 
 	// If the lhs doesn't have a type yet, use the type of x.
 	if lhs.typ == nil {
-		lhs.typ = x.typ
+		lhs.typ = x.typ()
 	}
 
 	check.assignment(x, lhs.typ, "constant declaration")
-	if x.mode == invalid {
+	if !x.isValid() {
 		return
 	}
 
@@ -154,23 +153,23 @@ func (check *Checker) initConst(lhs *Const, x *operand) {
 // or Typ[Invalid] in case of an error.
 // If the initialization check fails, x.mode is set to invalid.
 func (check *Checker) initVar(lhs *Var, x *operand, context string) {
-	if x.mode == invalid || !isValid(x.typ) || !isValid(lhs.typ) {
+	if !x.isValid() || !isValid(x.typ()) || !isValid(lhs.typ) {
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 
 	// If lhs doesn't have a type yet, use the type of x.
 	if lhs.typ == nil {
-		typ := x.typ
+		typ := x.typ()
 		if isUntyped(typ) {
 			// convert untyped types to default types
 			if typ == Typ[UntypedNil] {
 				check.errorf(x, UntypedNilUse, "use of untyped nil in %s", context)
 				lhs.typ = Typ[Invalid]
-				x.mode = invalid
+				x.invalidate()
 				return
 			}
 			typ = Default(typ)
@@ -219,13 +218,13 @@ func (check *Checker) lhsVar(lhs ast.Expr) Type {
 		check.usedVars[v] = v_used // restore v.used
 	}
 
-	if x.mode == invalid || !isValid(x.typ) {
+	if !x.isValid() || !isValid(x.typ()) {
 		return Typ[Invalid]
 	}
 
 	// spec: "Each left-hand side operand must be addressable, a map index
 	// expression, or the blank identifier. Operands may be parenthesized."
-	switch x.mode {
+	switch x.mode() {
 	case invalid:
 		return Typ[Invalid]
 	case variable, mapindex:
@@ -234,7 +233,7 @@ func (check *Checker) lhsVar(lhs ast.Expr) Type {
 		if sel, ok := x.expr.(*ast.SelectorExpr); ok {
 			var op operand
 			check.expr(nil, &op, sel.X)
-			if op.mode == mapindex {
+			if op.mode() == mapindex {
 				check.errorf(&x, UnaddressableFieldAssign, "cannot assign to struct field %s in map", ExprString(x.expr))
 				return Typ[Invalid]
 			}
@@ -243,7 +242,7 @@ func (check *Checker) lhsVar(lhs ast.Expr) Type {
 		return Typ[Invalid]
 	}
 
-	return x.typ
+	return x.typ()
 }
 
 // assignVar checks the assignment lhs = rhs (if x == nil), or lhs = x (if x != nil).
@@ -253,7 +252,7 @@ func (check *Checker) assignVar(lhs, rhs ast.Expr, x *operand, context string) {
 	T := check.lhsVar(lhs) // nil if lhs is _
 	if !isValid(T) {
 		if x != nil {
-			x.mode = invalid
+			x.invalidate()
 		} else {
 			check.use(rhs)
 		}
@@ -281,7 +280,7 @@ func (check *Checker) assignVar(lhs, rhs ast.Expr, x *operand, context string) {
 // operandTypes returns the list of types for the given operands.
 func operandTypes(list []*operand) (res []Type) {
 	for _, x := range list {
-		res = append(res, x.typ)
+		res = append(res, x.typ())
 	}
 	return res
 }
@@ -386,13 +385,15 @@ func (check *Checker) returnError(at positioner, lhs []*Var, rhs []*operand) {
 // If returnStmt is non-nil, initVars type-checks the implicit assignment
 // of result expressions orig_rhs to function result parameters lhs.
 func (check *Checker) initVars(lhs []*Var, orig_rhs []ast.Expr, returnStmt ast.Stmt) {
+	l, r := len(lhs), len(orig_rhs)
+
 	context := "assignment"
 	if returnStmt != nil {
 		context = "return statement"
+	} else if l > 1 {
+		context = "multiple assignment"
 	}
 
-	l, r := len(lhs), len(orig_rhs)
-
 	// If l == 1 and the rhs is a single call, for a better
 	// error message don't handle it as n:n mapping below.
 	isCall := false
@@ -444,7 +445,7 @@ func (check *Checker) initVars(lhs []*Var, orig_rhs []ast.Expr, returnStmt ast.S
 		}
 		// Only record comma-ok expression if both initializations succeeded
 		// (go.dev/issue/59371).
-		if commaOk && rhs[0].mode != invalid && rhs[1].mode != invalid {
+		if commaOk && rhs[0].mode() != invalid && rhs[1].mode() != invalid {
 			check.recordCommaOkTypes(orig_rhs[0], rhs)
 		}
 		return
@@ -452,7 +453,7 @@ func (check *Checker) initVars(lhs []*Var, orig_rhs []ast.Expr, returnStmt ast.S
 
 	// In all other cases we have an assignment mismatch.
 	// Only report a mismatch error if there are no other errors on the rhs.
-	if rhs[0].mode != invalid {
+	if rhs[0].mode() != invalid {
 		if returnStmt != nil {
 			check.returnError(returnStmt, lhs, rhs)
 		} else {
@@ -472,6 +473,11 @@ func (check *Checker) initVars(lhs []*Var, orig_rhs []ast.Expr, returnStmt ast.S
 func (check *Checker) assignVars(lhs, orig_rhs []ast.Expr) {
 	l, r := len(lhs), len(orig_rhs)
 
+	context := "assignment"
+	if l > 1 {
+		context = "multiple assignment"
+	}
+
 	// If l == 1 and the rhs is a single call, for a better
 	// error message don't handle it as n:n mapping below.
 	isCall := false
@@ -483,7 +489,7 @@ func (check *Checker) assignVars(lhs, orig_rhs []ast.Expr) {
 	// each value can be assigned to its corresponding variable.
 	if l == r && !isCall {
 		for i, lhs := range lhs {
-			check.assignVar(lhs, orig_rhs[i], nil, "assignment")
+			check.assignVar(lhs, orig_rhs[i], nil, context)
 		}
 		return
 	}
@@ -504,11 +510,11 @@ func (check *Checker) assignVars(lhs, orig_rhs []ast.Expr) {
 	r = len(rhs)
 	if l == r {
 		for i, lhs := range lhs {
-			check.assignVar(lhs, nil, rhs[i], "assignment")
+			check.assignVar(lhs, nil, rhs[i], context)
 		}
 		// Only record comma-ok expression if both assignments succeeded
 		// (go.dev/issue/59371).
-		if commaOk && rhs[0].mode != invalid && rhs[1].mode != invalid {
+		if commaOk && rhs[0].mode() != invalid && rhs[1].mode() != invalid {
 			check.recordCommaOkTypes(orig_rhs[0], rhs)
 		}
 		return
@@ -516,7 +522,7 @@ func (check *Checker) assignVars(lhs, orig_rhs []ast.Expr) {
 
 	// In all other cases we have an assignment mismatch.
 	// Only report a mismatch error if there are no other errors on the rhs.
-	if rhs[0].mode != invalid {
+	if rhs[0].mode() != invalid {
 		check.assignError(orig_rhs, l, r)
 	}
 	check.useLHS(lhs...)