@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/go/types/call.go

@@ -50,7 +50,7 @@ func (check *Checker) funcInst(T *target, pos token.Pos, x *operand, ix *indexed
 		xlist = ix.indices
 		targs = check.typeList(xlist)
 		if targs == nil {
-			x.mode = invalid
+			x.invalidate()
 			return nil
 		}
 		assert(len(targs) == len(xlist))
@@ -59,12 +59,12 @@ func (check *Checker) funcInst(T *target, pos token.Pos, x *operand, ix *indexed
 	// Check the number of type arguments (got) vs number of type parameters (want).
 	// Note that x is a function value, not a type expression, so we don't need to
 	// call Underlying below.
-	sig := x.typ.(*Signature)
+	sig := x.typ().(*Signature)
 	got, want := len(targs), sig.TypeParams().Len()
 	if got > want {
 		// Providing too many type arguments is always an error.
 		check.errorf(ix.indices[got-1], WrongTypeArgCount, "got %d type arguments but want %d", got, want)
-		x.mode = invalid
+		x.invalidate()
 		return nil
 	}
 
@@ -101,7 +101,7 @@ func (check *Checker) funcInst(T *target, pos token.Pos, x *operand, ix *indexed
 			// that makes sense when reported in error messages from infer, below.
 			expr := ast.NewIdent(T.desc)
 			expr.NamePos = x.Pos() // correct position
-			args = []*operand{{mode: value, expr: expr, typ: T.sig}}
+			args = []*operand{{mode_: value, expr: expr, typ_: T.sig}}
 			reverse = true
 		}
 
@@ -115,7 +115,7 @@ func (check *Checker) funcInst(T *target, pos token.Pos, x *operand, ix *indexed
 			if !err.empty() {
 				err.report()
 			}
-			x.mode = invalid
+			x.invalidate()
 			return nil
 		}
 		got = len(targs)
@@ -124,8 +124,8 @@ func (check *Checker) funcInst(T *target, pos token.Pos, x *operand, ix *indexed
 
 	// instantiate function signature
 	sig = check.instantiateSignature(x.Pos(), x.expr, sig, targs, xlist)
-	x.typ = sig
-	x.mode = value
+	x.typ_ = sig
+	x.mode_ = value
 	return nil
 }
 
@@ -176,7 +176,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 			// Delay function instantiation to argument checking,
 			// where we combine type and value arguments for type
 			// inference.
-			assert(x.mode == value)
+			assert(x.mode() == value)
 		} else {
 			ix = nil
 		}
@@ -187,7 +187,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	}
 	// x.typ may be generic
 
-	switch x.mode {
+	switch x.mode() {
 	case invalid:
 		check.use(call.Args...)
 		x.expr = call
@@ -196,17 +196,22 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	case typexpr:
 		// conversion
 		check.nonGeneric(nil, x)
-		if x.mode == invalid {
+		if !x.isValid() {
+			return conversion
+		}
+		T := x.typ()
+		x.invalidate()
+		// We cannot convert a value to an incomplete type; make sure it's complete.
+		if !check.isComplete(T) {
+			x.expr = call
 			return conversion
 		}
-		T := x.typ
-		x.mode = invalid
 		switch n := len(call.Args); n {
 		case 0:
 			check.errorf(inNode(call, call.Rparen), WrongArgCount, "missing argument in conversion to %s", T)
 		case 1:
-			check.expr(nil, x, call.Args[0])
-			if x.mode != invalid {
+			check.expr(newTarget(T, "conversion"), x, call.Args[0])
+			if x.isValid() {
 				if hasDots(call) {
 					check.errorf(call.Args[0], BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T)
 					break
@@ -230,11 +235,11 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 		// no need to check for non-genericity here
 		id := x.id
 		if !check.builtin(x, call, id) {
-			x.mode = invalid
+			x.invalidate()
 		}
 		x.expr = call
 		// a non-constant result implies a function call
-		if x.mode != invalid && x.mode != constant_ {
+		if x.isValid() && x.mode() != constant_ {
 			check.hasCallOrRecv = true
 		}
 		return predeclaredFuncs[id].kind
@@ -242,11 +247,11 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 
 	// ordinary function/method call
 	// signature may be generic
-	cgocall := x.mode == cgofunc
+	cgocall := x.mode() == cgofunc
 
 	// If the operand type is a type parameter, all types in its type set
 	// must have a common underlying type, which must be a signature.
-	u, err := commonUnder(x.typ, func(t, u Type) *typeError {
+	u, err := commonUnder(x.typ(), func(t, u Type) *typeError {
 		if _, ok := u.(*Signature); u != nil && !ok {
 			return typeErrorf("%s is not a function", t)
 		}
@@ -254,7 +259,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	})
 	if err != nil {
 		check.errorf(x, InvalidCall, invalidOp+"cannot call %s: %s", x, err.format(check))
-		x.mode = invalid
+		x.invalidate()
 		x.expr = call
 		return statement
 	}
@@ -271,7 +276,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 		targs = check.typeList(xlist)
 		if targs == nil {
 			check.use(call.Args...)
-			x.mode = invalid
+			x.invalidate()
 			x.expr = call
 			return statement
 		}
@@ -282,7 +287,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 		if got > want {
 			check.errorf(xlist[want], WrongTypeArgCount, "got %d type arguments but want %d", got, want)
 			check.use(call.Args...)
-			x.mode = invalid
+			x.invalidate()
 			x.expr = call
 			return statement
 		}
@@ -314,25 +319,32 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	// determine result
 	switch sig.results.Len() {
 	case 0:
-		x.mode = novalue
+		x.mode_ = novalue
 	case 1:
 		if cgocall {
-			x.mode = commaerr
+			x.mode_ = commaerr
 		} else {
-			x.mode = value
+			x.mode_ = value
+		}
+		typ := sig.results.vars[0].typ // unpack tuple
+		// We cannot return a value of an incomplete type; make sure it's complete.
+		if !check.isComplete(typ) {
+			x.invalidate()
+			x.expr = call
+			return statement
 		}
-		x.typ = sig.results.vars[0].typ // unpack tuple
+		x.typ_ = typ
 	default:
-		x.mode = value
-		x.typ = sig.results
+		x.mode_ = value
+		x.typ_ = sig.results
 	}
 	x.expr = call
 	check.hasCallOrRecv = true
 
 	// if type inference failed, a parameterized result must be invalidated
 	// (operands cannot have a parameterized type)
-	if x.mode == value && sig.TypeParams().Len() > 0 && isParameterized(sig.TypeParams().list(), x.typ) {
-		x.mode = invalid
+	if x.mode() == value && sig.TypeParams().Len() > 0 && isParameterized(sig.TypeParams().list(), x.typ()) {
+		x.invalidate()
 	}
 
 	return statement
@@ -370,7 +382,7 @@ func (check *Checker) genericExprList(elist []ast.Expr) (resList []*operand, tar
 				if i < len(targsList) {
 					if n := len(targsList[i]); n > 0 {
 						// x must be a partially instantiated function
-						assert(n < x.typ.(*Signature).TypeParams().Len())
+						assert(n < x.typ().(*Signature).TypeParams().Len())
 					}
 				}
 			}
@@ -378,7 +390,7 @@ func (check *Checker) genericExprList(elist []ast.Expr) (resList []*operand, tar
 	}
 
 	// Before Go 1.21, uninstantiated or partially instantiated argument functions are
-	// nor permitted. Checker.funcInst must infer missing type arguments in that case.
+	// not permitted. Checker.funcInst must infer missing type arguments in that case.
 	infer := true // for -lang < go1.21
 	n := len(elist)
 	if n > 0 && check.allowVersion(go1_21) {
@@ -407,11 +419,11 @@ func (check *Checker) genericExprList(elist []ast.Expr) (resList []*operand, tar
 			// x is not a function instantiation (it may still be a generic function).
 			check.rawExpr(nil, &x, e, nil, true)
 			check.exclude(&x, 1<<novalue|1<<builtin|1<<typexpr)
-			if t, ok := x.typ.(*Tuple); ok && x.mode != invalid {
+			if t, ok := x.typ().(*Tuple); ok && x.isValid() {
 				// x is a function call returning multiple values; it cannot be generic.
 				resList = make([]*operand, t.Len())
 				for i, v := range t.vars {
-					resList[i] = &operand{mode: value, expr: e, typ: v.typ}
+					resList[i] = &operand{mode_: value, expr: e, typ_: v.typ}
 				}
 			} else {
 				// x is exactly one value (possibly invalid or uninstantiated generic function).
@@ -439,7 +451,7 @@ func (check *Checker) genericExprList(elist []ast.Expr) (resList []*operand, tar
 				}
 			} else {
 				// x is exactly one value (possibly invalid or uninstantiated generic function).
-				check.genericExpr(&x, e)
+				check.genericExpr(&x, e, nil)
 			}
 			resList[i] = &x
 		}
@@ -570,7 +582,7 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type
 	if enableReverseTypeInference {
 		for i, arg := range args {
 			// generic arguments cannot have a defined (*Named) type - no need for underlying type below
-			if asig, _ := arg.typ.(*Signature); asig != nil && asig.TypeParams().Len() > 0 {
+			if asig, _ := arg.typ().(*Signature); asig != nil && asig.TypeParams().Len() > 0 {
 				// The argument type is a generic function signature. This type is
 				// pointer-identical with (it's copied from) the type of the generic
 				// function argument and thus the function object.
@@ -585,7 +597,7 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type
 				atparams, tmp := check.renameTParams(call.Pos(), asig.TypeParams().list(), asig)
 				asig = tmp.(*Signature)
 				asig.tparams = &TypeParamList{atparams} // renameTParams doesn't touch associated type parameters
-				arg.typ = asig                          // new type identity for the function argument
+				arg.typ_ = asig                         // new type identity for the function argument
 				tparams = append(tparams, atparams...)
 				// add partial list of type arguments, if any
 				if i < len(atargs) {
@@ -640,11 +652,11 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type
 		j := n
 		for _, i := range genericArgs {
 			arg := args[i]
-			asig := arg.typ.(*Signature)
+			asig := arg.typ().(*Signature)
 			k := j + asig.TypeParams().Len()
 			// targs[j:k] are the inferred type arguments for asig
-			arg.typ = check.instantiateSignature(call.Pos(), arg.expr, asig, targs[j:k], nil) // TODO(gri) provide xlist if possible (partial instantiations)
-			check.record(arg)                                                                 // record here because we didn't use the usual expr evaluators
+			arg.typ_ = check.instantiateSignature(call.Pos(), arg.expr, asig, targs[j:k], nil) // TODO(gri) provide xlist if possible (partial instantiations)
+			check.record(arg)                                                                  // record here because we didn't use the usual expr evaluators
 			j = k
 		}
 	}
@@ -745,28 +757,28 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 			switch exp := exp.(type) {
 			case *Const:
 				assert(exp.Val() != nil)
-				x.mode = constant_
-				x.typ = exp.typ
+				x.mode_ = constant_
+				x.typ_ = exp.typ
 				x.val = exp.val
 			case *TypeName:
-				x.mode = typexpr
-				x.typ = exp.typ
+				x.mode_ = typexpr
+				x.typ_ = exp.typ
 			case *Var:
-				x.mode = variable
-				x.typ = exp.typ
+				x.mode_ = variable
+				x.typ_ = exp.typ
 				if pkg.cgo && strings.HasPrefix(exp.name, "_Cvar_") {
-					x.typ = x.typ.(*Pointer).base
+					x.typ_ = x.typ().(*Pointer).base
 				}
 			case *Func:
-				x.mode = funcMode
-				x.typ = exp.typ
+				x.mode_ = funcMode
+				x.typ_ = exp.typ
 				if pkg.cgo && strings.HasPrefix(exp.name, "_Cmacro_") {
-					x.mode = value
-					x.typ = x.typ.(*Signature).results.vars[0].typ
+					x.mode_ = value
+					x.typ_ = x.typ().(*Signature).results.vars[0].typ
 				}
 			case *Builtin:
-				x.mode = builtin
-				x.typ = exp.typ
+				x.mode_ = builtin
+				x.typ_ = exp.typ
 				x.id = exp.id
 			default:
 				check.dump("%v: unexpected object %v", e.Sel.Pos(), exp)
@@ -778,7 +790,7 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 	}
 
 	check.exprOrType(x, e.X, false)
-	switch x.mode {
+	switch x.mode() {
 	case builtin:
 		// types2 uses the position of '.' for the error
 		check.errorf(e.Sel, UncalledBuiltin, "invalid use of %s in selector expression", x)
@@ -787,8 +799,12 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 		goto Error
 	}
 
-	// Avoid crashing when checking an invalid selector in a method declaration
-	// (i.e., where def is not set):
+	// We cannot select on an incomplete type; make sure it's complete.
+	if !check.isComplete(x.typ()) {
+		goto Error
+	}
+
+	// Avoid crashing when checking an invalid selector in a method declaration.
 	//
 	//   type S[T any] struct{}
 	//   type V = S[any]
@@ -798,18 +814,21 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 	// expecting a type expression, it is an error.
 	//
 	// See go.dev/issue/57522 for more details.
-	//
-	// TODO(rfindley): We should do better by refusing to check selectors in all cases where
-	// x.typ is incomplete.
 	if wantType {
 		check.errorf(e.Sel, NotAType, "%s is not a type", ast.Expr(e))
 		goto Error
 	}
 
-	obj, index, indirect = lookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel, false)
+	// Additionally, if x.typ is a pointer type, selecting implicitly dereferences the value, meaning
+	// its base type must also be complete.
+	if p, ok := x.typ().Underlying().(*Pointer); ok && !check.isComplete(p.base) {
+		goto Error
+	}
+
+	obj, index, indirect = lookupFieldOrMethod(x.typ(), x.mode() == variable, check.pkg, sel, false)
 	if obj == nil {
 		// Don't report another error if the underlying type was invalid (go.dev/issue/49541).
-		if !isValid(x.typ.Underlying()) {
+		if !isValid(x.typ().Underlying()) {
 			goto Error
 		}
 
@@ -820,93 +839,92 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 		}
 
 		if indirect {
-			if x.mode == typexpr {
-				check.errorf(e.Sel, InvalidMethodExpr, "invalid method expression %s.%s (needs pointer receiver (*%s).%s)", x.typ, sel, x.typ, sel)
+			if x.mode() == typexpr {
+				check.errorf(e.Sel, InvalidMethodExpr, "invalid method expression %s.%s (needs pointer receiver (*%s).%s)", x.typ(), sel, x.typ(), sel)
 			} else {
-				check.errorf(e.Sel, InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ)
+				check.errorf(e.Sel, InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ())
 			}
 			goto Error
 		}
 
 		var why string
-		if isInterfacePtr(x.typ) {
-			why = check.interfacePtrError(x.typ)
+		if isInterfacePtr(x.typ()) {
+			why = check.interfacePtrError(x.typ())
 		} else {
-			alt, _, _ := lookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel, true)
-			why = check.lookupError(x.typ, sel, alt, false)
+			alt, _, _ := lookupFieldOrMethod(x.typ(), x.mode() == variable, check.pkg, sel, true)
+			why = check.lookupError(x.typ(), sel, alt, false)
 		}
 		check.errorf(e.Sel, MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why)
 		goto Error
 	}
+	// obj != nil
 
-	// methods may not have a fully set up signature yet
-	if m, _ := obj.(*Func); m != nil {
-		check.objDecl(m)
-	}
-
-	if x.mode == typexpr {
-		// method expression
-		m, _ := obj.(*Func)
-		if m == nil {
-			check.errorf(e.Sel, MissingFieldOrMethod, "%s.%s undefined (type %s has no method %s)", x.expr, sel, x.typ, sel)
+	switch obj := obj.(type) {
+	case *Var:
+		if x.mode() == typexpr {
+			check.errorf(e.X, MissingFieldOrMethod, "operand for field selector %s must be value of type %s", sel, x.typ())
 			goto Error
 		}
 
-		check.recordSelection(e, MethodExpr, x.typ, m, index, indirect)
-
-		sig := m.typ.(*Signature)
-		if sig.recv == nil {
-			check.error(e, InvalidDeclCycle, "illegal cycle in method declaration")
-			goto Error
+		// field value
+		check.recordSelection(e, FieldVal, x.typ(), obj, index, indirect)
+		if x.mode() == variable || indirect {
+			x.mode_ = variable
+		} else {
+			x.mode_ = value
 		}
+		x.typ_ = obj.typ
 
-		// the receiver type becomes the type of the first function
-		// argument of the method expression's function type
-		var params []*Var
-		if sig.params != nil {
-			params = sig.params.vars
-		}
-		// Be consistent about named/unnamed parameters. This is not needed
-		// for type-checking, but the newly constructed signature may appear
-		// in an error message and then have mixed named/unnamed parameters.
-		// (An alternative would be to not print parameter names in errors,
-		// but it's useful to see them; this is cheap and method expressions
-		// are rare.)
-		name := ""
-		if len(params) > 0 && params[0].name != "" {
-			// name needed
-			name = sig.recv.name
-			if name == "" {
-				name = "_"
-			}
-		}
-		params = append([]*Var{NewParam(sig.recv.pos, sig.recv.pkg, name, x.typ)}, params...)
-		x.mode = value
-		x.typ = &Signature{
-			tparams:  sig.tparams,
-			params:   NewTuple(params...),
-			results:  sig.results,
-			variadic: sig.variadic,
-		}
+	case *Func:
+		check.objDecl(obj) // ensure fully set-up signature
+		check.addDeclDep(obj)
+		// TODO(mark): Assert that sig.rparams is nil here?
 
-		check.addDeclDep(m)
+		if x.mode() == typexpr {
+			// method expression
+			check.recordSelection(e, MethodExpr, x.typ(), obj, index, indirect)
 
-	} else {
-		// regular selector
-		switch obj := obj.(type) {
-		case *Var:
-			check.recordSelection(e, FieldVal, x.typ, obj, index, indirect)
-			if x.mode == variable || indirect {
-				x.mode = variable
-			} else {
-				x.mode = value
+			sig := obj.typ.(*Signature)
+			if sig.recv == nil {
+				check.error(e, InvalidDeclCycle, "illegal cycle in method declaration")
+				goto Error
 			}
-			x.typ = obj.typ
 
-		case *Func:
+			// The receiver type becomes the type of the first function
+			// argument of the method expression's function type.
+			var params []*Var
+			if sig.params != nil {
+				params = sig.params.vars
+			}
+			// Be consistent about named/unnamed parameters. This is not needed
+			// for type-checking, but the newly constructed signature may appear
+			// in an error message and then have mixed named/unnamed parameters.
+			// (An alternative would be to not print parameter names in errors,
+			// but it's useful to see them; this is cheap and method expressions
+			// are rare.)
+			name := ""
+			if len(params) > 0 && params[0].name != "" {
+				// name needed
+				name = sig.recv.name
+				if name == "" {
+					name = "_"
+				}
+			}
+			params = append([]*Var{NewParam(sig.recv.pos, sig.recv.pkg, name, x.typ())}, params...)
+			x.mode_ = value
+			x.typ_ = &Signature{
+				tparams:  sig.tparams,
+				recvold:  methodExprSentinel,
+				params:   NewTuple(params...),
+				results:  sig.results,
+				variadic: sig.variadic,
+			}
+		} else {
+			// method value
+
 			// TODO(gri) If we needed to take into account the receiver's
 			// addressability, should we report the type &(x.typ) instead?
-			check.recordSelection(e, MethodVal, x.typ, obj, index, indirect)
+			check.recordSelection(e, MethodVal, x.typ(), obj, index, indirect)
 
 			// TODO(gri) The verification pass below is disabled for now because
 			//           method sets don't match method lookup in some cases.
@@ -921,8 +939,8 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 				// _before_ calling NewMethodSet: LookupFieldOrMethod completes
 				// any incomplete interfaces so they are available to NewMethodSet
 				// (which assumes that interfaces have been completed already).
-				typ := x.typ
-				if x.mode == variable {
+				typ := x.typ_
+				if x.mode() == variable {
 					// If typ is not an (unnamed) pointer or an interface,
 					// use *typ instead, because the method set of *typ
 					// includes the methods of typ.
@@ -953,18 +971,17 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 				}
 			}
 
-			x.mode = value
+			x.mode_ = value
 
-			// remove receiver
+			// remove/stash receiver
 			sig := *obj.typ.(*Signature)
+			sig.recvold = sig.recv
 			sig.recv = nil
-			x.typ = &sig
-
-			check.addDeclDep(obj)
-
-		default:
-			panic("unreachable")
+			x.typ_ = &sig
 		}
+
+	default:
+		panic("unreachable")
 	}
 
 	// everything went well
@@ -972,8 +989,8 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr, wantType bool) {
 	return
 
 Error:
-	x.mode = invalid
-	x.typ = Typ[Invalid]
+	x.invalidate()
+	x.typ_ = Typ[Invalid]
 	x.expr = e
 }
 
@@ -1001,7 +1018,7 @@ func (check *Checker) useN(args []ast.Expr, lhs bool) bool {
 
 func (check *Checker) use1(e ast.Expr, lhs bool) bool {
 	var x operand
-	x.mode = value // anything but invalid
+	x.mode_ = value // anything but invalid
 	switch n := ast.Unparen(e).(type) {
 	case nil:
 		// nothing to do
@@ -1033,5 +1050,5 @@ func (check *Checker) use1(e ast.Expr, lhs bool) bool {
 	default:
 		check.rawExpr(nil, &x, e, nil, true)
 	}
-	return x.mode != invalid
+	return x.isValid()
 }