@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/go/types/infer.go

@@ -65,7 +65,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 	// If we have invalid (ordinary) arguments, an error was reported before.
 	// Avoid additional inference errors and exit early (go.dev/issue/60434).
 	for _, arg := range args {
-		if arg.mode == invalid {
+		if !arg.isValid() {
 			return nil
 		}
 	}
@@ -114,7 +114,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 	// Unify parameter and argument types for generic parameters with typed arguments
 	// and collect the indices of generic parameters with untyped arguments.
 	// Terminology: generic parameter = function parameter with a type-parameterized type
-	u := newUnifier(tparams, targs, check.allowVersion(go1_21))
+	u := newUnifier(check, tparams, targs, check.allowVersion(go1_21))
 
 	errorf := func(tpar, targ Type, arg *operand) {
 		// provide a better error message if we can
@@ -165,7 +165,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 	}
 
 	for i, arg := range args {
-		if arg.mode == invalid {
+		if !arg.isValid() {
 			// An error was reported earlier. Ignore this arg
 			// and continue, we may still be able to infer all
 			// targs resulting in fewer follow-on errors.
@@ -173,12 +173,12 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 			continue
 		}
 		par := params.At(i)
-		if isParameterized(tparams, par.typ) || isParameterized(tparams, arg.typ) {
+		if isParameterized(tparams, par.typ) || isParameterized(tparams, arg.typ()) {
 			// Function parameters are always typed. Arguments may be untyped.
 			// Collect the indices of untyped arguments and handle them later.
-			if isTyped(arg.typ) {
-				if !u.unify(par.typ, arg.typ, assign) {
-					errorf(par.typ, arg.typ, arg)
+			if isTyped(arg.typ()) {
+				if !u.unify(par.typ, arg.typ(), assign) {
+					errorf(par.typ, arg.typ(), arg)
 					return nil
 				}
 			} else if _, ok := par.typ.(*TypeParam); ok && !arg.isNil() {
@@ -340,11 +340,11 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 			}
 			max := maxUntyped[tpar]
 			if max == nil {
-				max = arg.typ
+				max = arg.typ()
 			} else {
-				m := maxType(max, arg.typ)
+				m := maxType(max, arg.typ())
 				if m == nil {
-					err.addf(arg, "mismatched types %s and %s (cannot infer %s)", max, arg.typ, tpar)
+					err.addf(arg, "mismatched types %s and %s (cannot infer %s)", max, arg.typ(), tpar)
 					return nil
 				}
 				max = m
@@ -434,7 +434,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 				// TODO(gri) Consider doing this in Checker.subst.
 				//           Then this would fall out automatically here and also
 				//           in instantiation (where we also explicitly nil out
-				//           type parameters). See the *Signature TODO in subst.
+				//           type parameters).
 				if sig, _ := t1.(*Signature); sig != nil && sig.TypeParams().Len() > 0 && !isParameterized(tparams, sig) {
 					sig.tparams = nil
 				}

package/bin/go/src/go/types/instantiate.go

@@ -24,7 +24,7 @@ type genericType interface {
 }
 
 // Instantiate instantiates the type orig with the given type arguments targs.
-// orig must be an *Alias, *Named, or *Signature type. If there is no error,
+// orig must be a generic *Alias, *Named, or *Signature type. If there is no error,
 // the resulting Type is an instantiated type of the same kind (*Alias, *Named
 // or *Signature, respectively).
 //
@@ -39,30 +39,37 @@ type genericType interface {
 // signatures will yield different instances. The use of a shared context does
 // not guarantee that identical instances are deduplicated in all cases.
 //
-// If validate is set, Instantiate verifies that the number of type arguments
-// and parameters match, and that the type arguments satisfy their respective
-// type constraints. If verification fails, the resulting error may wrap an
-// *ArgumentError indicating which type argument did not satisfy its type parameter
-// constraint, and why.
+// If validate is set, Instantiate verifies that the type orig is in fact generic,
+// that the number of type arguments and parameters match, and that the type arguments
+// satisfy their respective type constraints.
+// If verification fails, the resulting error may wrap an *ArgumentError indicating
+// which type argument did not satisfy its type parameter constraint, and why.
 //
-// If validate is not set, Instantiate does not verify the type argument count
-// or whether the type arguments satisfy their constraints. Instantiate is
-// guaranteed to not return an error, but may panic. Specifically, for
-// *Signature types, Instantiate will panic immediately if the type argument
+// If validate is not set, Instantiate does not check if orig is generic, verify the
+// type argument count, or check whether the type arguments satisfy their constraints.
+// Instantiate is guaranteed to not return an error, but may panic. Specifically,
+// for *Signature types, Instantiate will panic immediately if the type argument
 // count is incorrect; for *Named types, a panic may occur later inside the
 // *Named API.
 func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error) {
-	assert(len(targs) > 0)
 	if ctxt == nil {
 		ctxt = NewContext()
 	}
-	orig_ := orig.(genericType) // signature of Instantiate must not change for backward-compatibility
+	orig_, ok := orig.(genericType) // signature of Instantiate must not change for backward-compatibility
+	if !ok {
+		panic(sprintf(nil, nil, false, "cannot instantiate non-generic %s: expected *Named, *Alias, or *Signature", orig))
+	}
+	if len(targs) == 0 {
+		panic(sprintf(nil, nil, false, "cannot instantiate %s: empty type argument list", orig))
+	}
 
 	if validate {
 		tparams := orig_.TypeParams().list()
-		assert(len(tparams) > 0)
+		if len(tparams) == 0 {
+			return nil, fmt.Errorf("cannot instantiate non-generic %s: has no type parameters", orig)
+		}
 		if len(targs) != len(tparams) {
-			return nil, fmt.Errorf("got %d type arguments but %s has %d type parameters", len(targs), orig, len(tparams))
+			return nil, fmt.Errorf("cannot instantiate %s: got %d type arguments but have %d type parameters", orig, len(targs), len(tparams))
 		}
 		if i, err := (*Checker)(nil).verify(nopos, tparams, targs, ctxt); err != nil {
 			return nil, &ArgumentError{i, err}
@@ -149,6 +156,11 @@ func (check *Checker) instance(pos token.Pos, orig genericType, targs []Type, ex
 
 	case *Signature:
 		assert(expanding == nil) // function instances cannot be reached from Named types
+		// Note that orig may be a generic method on a generic type. In that case, orig
+		// is an instantiated type. It will not have receiver type parameters, but will
+		// still have ordinary type parameters.
+		assert(orig.RecvTypeParams() == nil)
+		assert(orig.TypeParams() != nil)
 
 		tparams := orig.TypeParams()
 		// TODO(gri) investigate if this is needed (type argument and parameter count seem to be correct here)
@@ -248,7 +260,7 @@ func (check *Checker) implements(V, T Type, constraint bool, cause *string) bool
 		if cause != nil {
 			var detail string
 			if isInterfacePtr(Tu) {
-				detail = check.sprintf("type %s is pointer to interface, not interface", T)
+				detail = check.interfacePtrError(T)
 			} else {
 				detail = check.sprintf("%s is not an interface", T)
 			}

package/bin/go/src/go/types/interface.go

@@ -188,13 +188,13 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 			continue // ignore
 		}
 
-		// The go/parser doesn't accept method type parameters but an ast.FuncType may have them.
+		// The go/parser doesn't accept interface method type parameters but an ast.FuncType may have them.
 		if sig.tparams != nil {
 			var at positioner = f.Type
 			if ftyp, _ := f.Type.(*ast.FuncType); ftyp != nil && ftyp.TypeParams != nil {
 				at = ftyp.TypeParams
 			}
-			check.error(at, InvalidSyntaxTree, "methods cannot have type parameters")
+			check.error(at, InvalidSyntaxTree, "interface methods cannot have type parameters")
 		}
 
 		// use named receiver type if available (for better error messages)

package/bin/go/src/go/types/literals.go

@@ -61,18 +61,18 @@ func (check *Checker) basicLit(x *operand, e *ast.BasicLit) {
 		const limit = 10000
 		if len(e.Value) > limit {
 			check.errorf(e, InvalidConstVal, "excessively long constant: %s... (%d chars)", e.Value[:10], len(e.Value))
-			x.mode = invalid
+			x.invalidate()
 			return
 		}
 	}
 	x.setConst(e.Kind, e.Value)
-	if x.mode == invalid {
+	if !x.isValid() {
 		// The parser already establishes syntactic correctness.
 		// If we reach here it's because of number under-/overflow.
 		// TODO(gri) setConst (and in turn the go/constant package)
 		// should return an error describing the issue.
 		check.errorf(e, InvalidConstVal, "malformed constant: %s", e.Value)
-		x.mode = invalid
+		x.invalidate()
 		return
 	}
 	// Ensure that integer values don't overflow (go.dev/issue/54280).
@@ -100,11 +100,11 @@ func (check *Checker) funcLit(x *operand, e *ast.FuncLit) {
 				check.funcBody(decl, "<function literal>", sig, e.Body, iota)
 			}).describef(e, "func literal")
 		}
-		x.mode = value
-		x.typ = sig
+		x.mode_ = value
+		x.typ_ = sig
 	} else {
 		check.errorf(e, InvalidSyntaxTree, "invalid function literal %v", e)
-		x.mode = invalid
+		x.invalidate()
 	}
 }
 
@@ -147,6 +147,12 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 		base = typ
 	}
 
+	// We cannot create a literal of an incomplete type; make sure it's complete.
+	if !check.isComplete(base) {
+		x.invalidate()
+		return
+	}
+
 	switch u, _ := commonUnder(base, nil); utyp := u.(type) {
 	case *Struct:
 		if len(e.Elts) == 0 {
@@ -158,7 +164,7 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 		fields := utyp.fields
 		if _, ok := e.Elts[0].(*ast.KeyValueExpr); ok {
 			// all elements must have keys
-			visited := make([]bool, len(fields))
+			visited := make(trie[*Var])
 			for _, e := range e.Elts {
 				kv, _ := e.(*ast.KeyValueExpr)
 				if kv == nil {
@@ -168,31 +174,42 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 				key, _ := kv.Key.(*ast.Ident)
 				// do all possible checks early (before exiting due to errors)
 				// so we don't drop information on the floor
-				check.expr(nil, x, kv.Value)
+				check.genericExpr(x, kv.Value, nil)
 				if key == nil {
 					check.errorf(kv, InvalidLitField, "invalid field name %s in struct literal", kv.Key)
 					continue
 				}
-				i := fieldIndex(fields, check.pkg, key.Name, false)
-				if i < 0 {
-					var alt Object
-					if j := fieldIndex(fields, check.pkg, key.Name, true); j >= 0 {
-						alt = fields[j]
-					}
+				obj, index, indirect := lookupFieldOrMethod(utyp, false, check.pkg, key.Name, false)
+				if obj == nil {
+					alt, _, _ := lookupFieldOrMethod(utyp, false, check.pkg, key.Name, true)
 					msg := check.lookupError(base, key.Name, alt, true)
 					check.error(kv.Key, MissingLitField, msg)
 					continue
 				}
-				fld := fields[i]
+				fld, _ := obj.(*Var)
+				if fld == nil {
+					check.errorf(kv.Key, MissingLitField, "%s is not a field", kv.Key)
+					continue
+				}
+				if len(index) > 1 && !check.verifyVersionf(kv.Key, go1_27, "use of promoted field %s in struct literal of type %s", fieldPath(utyp, index), base) {
+					continue
+				}
+				if indirect {
+					check.errorf(kv.Key, InvalidLitField, "invalid implicit pointer indirection to reach %s", kv.Key)
+					continue
+				}
 				check.recordUse(key, fld)
 				etyp := fld.typ
 				check.assignment(x, etyp, "struct literal")
-				// 0 <= i < len(fields)
-				if visited[i] {
-					check.errorf(kv, DuplicateLitField, "duplicate field name %s in struct literal", key.Name)
-					continue
+				if alt, n := visited.insert(index, fld); n != 0 {
+					if fld == alt {
+						check.errorf(kv, DuplicateLitField, "duplicate field name %s in struct literal", fld.name)
+					} else if n < len(index) {
+						check.errorf(kv, DuplicateLitField, "cannot specify promoted field %s and enclosing embedded field %s", fld.name, alt.name)
+					} else { // n > len(index)
+						check.errorf(kv, DuplicateLitField, "cannot specify embedded field %s and enclosed promoted field %s", fld.name, alt.name)
+					}
 				}
-				visited[i] = true
 			}
 		} else {
 			// no element must have a key
@@ -201,7 +218,7 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 					check.error(kv, MixedStructLit, "mixture of field:value and value elements in struct literal")
 					continue
 				}
-				check.expr(nil, x, e)
+				check.genericExpr(x, e, nil)
 				if i >= len(fields) {
 					check.errorf(x, InvalidStructLit, "too many values in struct literal of type %s", base)
 					break // cannot continue
@@ -216,7 +233,14 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 				check.assignment(x, etyp, "struct literal")
 			}
 			if len(e.Elts) < len(fields) {
-				check.errorf(inNode(e, e.Rbrace), InvalidStructLit, "too few values in struct literal of type %s", base)
+				var hint string
+				for _, fld := range fields {
+					if !fld.Exported() && fld.pkg != check.pkg {
+						hint = " (type has unexported fields - use key:value pairs)"
+						break
+					}
+				}
+				check.errorf(inNode(e, e.Rbrace), InvalidStructLit, "too few values in struct literal of type %s%s", base, hint)
 				// ok to continue
 			}
 		}
@@ -257,22 +281,22 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 				check.error(e, MissingLitKey, "missing key in map literal")
 				continue
 			}
-			check.exprWithHint(x, kv.Key, utyp.key)
+			check.genericExpr(x, kv.Key, utyp.key)
 			check.assignment(x, utyp.key, "map literal")
-			if x.mode == invalid {
+			if !x.isValid() {
 				continue
 			}
-			if x.mode == constant_ {
+			if x.mode() == constant_ {
 				duplicate := false
 				xkey := keyVal(x.val)
 				if keyIsInterface {
 					for _, vtyp := range visited[xkey] {
-						if Identical(vtyp, x.typ) {
+						if Identical(vtyp, x.typ()) {
 							duplicate = true
 							break
 						}
 					}
-					visited[xkey] = append(visited[xkey], x.typ)
+					visited[xkey] = append(visited[xkey], x.typ())
 				} else {
 					_, duplicate = visited[xkey]
 					visited[xkey] = nil
@@ -282,7 +306,7 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 					continue
 				}
 			}
-			check.exprWithHint(x, kv.Value, utyp.elem)
+			check.genericExpr(x, kv.Value, utyp.elem)
 			check.assignment(x, utyp.elem, "map literal")
 		}
 
@@ -309,13 +333,13 @@ func (check *Checker) compositeLit(x *operand, e *ast.CompositeLit, hint Type) {
 				cause = " (no common underlying type)"
 			}
 			check.errorf(e, InvalidLit, "invalid composite literal%s type %s%s", qualifier, typ, cause)
-			x.mode = invalid
+			x.invalidate()
 			return
 		}
 	}
 
-	x.mode = value
-	x.typ = typ
+	x.mode_ = value
+	x.typ_ = typ
 }
 
 // indexedElts checks the elements (elts) of an array or slice composite literal
@@ -359,7 +383,7 @@ func (check *Checker) indexedElts(elts []ast.Expr, typ Type, length int64) int64
 
 		// check element against composite literal element type
 		var x operand
-		check.exprWithHint(&x, eval, typ)
+		check.genericExpr(&x, eval, typ)
 		check.assignment(&x, typ, "array or slice literal")
 	}
 	return max

package/bin/go/src/go/types/lookup.go

@@ -9,7 +9,10 @@
 
 package types
 
-import "bytes"
+import (
+	"bytes"
+	"strings"
+)
 
 // LookupSelection selects the field or method whose ID is Id(pkg,
 // name), on a value of type T. If addressable is set, T is the type
@@ -390,6 +393,7 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
 		ambigSel
 		ptrRecv
 		field
+		nointerface
 	)
 
 	state := ok
@@ -453,6 +457,11 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
 				check.objDecl(f)
 			}
 
+			if f.nointerface {
+				state = nointerface
+				break
+			}
+
 			if !equivalent(f.typ, m.typ) {
 				state = wrongSig
 				break
@@ -512,6 +521,8 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
 			*cause = check.sprintf("(method %s has pointer receiver)", m.Name())
 		case field:
 			*cause = check.sprintf("(%s.%s is a field, not a method)", V, m.Name())
+		case nointerface:
+			*cause = check.sprintf("(%s method is marked 'nointerface')", m.Name())
 		default:
 			panic("unreachable")
 		}
@@ -648,19 +659,6 @@ func concat(list []int, i int) []int {
 	return append(t, i)
 }
 
-// fieldIndex returns the index for the field with matching package and name, or a value < 0.
-// See Object.sameId for the meaning of foldCase.
-func fieldIndex(fields []*Var, pkg *Package, name string, foldCase bool) int {
-	if name != "_" {
-		for i, f := range fields {
-			if f.sameId(pkg, name, foldCase) {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
 // methodIndex returns the index of and method with matching package and name, or (-1, nil).
 // See Object.sameId for the meaning of foldCase.
 func methodIndex(methods []*Func, pkg *Package, name string, foldCase bool) (int, *Func) {
@@ -673,3 +671,22 @@ func methodIndex(methods []*Func, pkg *Package, name string, foldCase bool) (int
 	}
 	return -1, nil
 }
+
+// Given a (possibly pointer to a) struct type and field index sequence,
+// fieldPath returns the dot-separated concatenated field names for the
+// given index sequence (e.g. "a.b.c").
+// Use for error reporting etc. where speed is not important.
+func fieldPath(typ Type, index []int) string {
+	var names []string
+	for _, i := range index {
+		u, ok := derefStructPtr(typ).Underlying().(*Struct)
+		if !ok {
+			// should not happen if index is valid for typ
+			break
+		}
+		fld := u.Field(i)
+		names = append(names, fld.name)
+		typ = fld.typ
+	}
+	return strings.Join(names, ".")
+}