@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/go/types/named.go

@@ -109,9 +109,7 @@ type Named struct {
 	check *Checker  // non-nil during type-checking; nil otherwise
 	obj   *TypeName // corresponding declared object for declared types; see above for instantiated types
 
-	// flags indicating temporary violations of the invariants for fromRHS and underlying
-	allowNilRHS        bool // same as below, as well as briefly during checking of a type declaration
-	allowNilUnderlying bool // may be true from creation via [NewNamed] until [Named.SetUnderlying]
+	allowNilRHS bool // may be true from creation via [NewNamed] until [Named.SetUnderlying]
 
 	inst *instance // information for instantiated types; nil otherwise
 
@@ -120,7 +118,7 @@ type Named struct {
 	fromRHS    Type           // the declaration RHS this type is derived from
 	tparams    *TypeParamList // type parameters, or nil
 	underlying Type           // underlying type, or nil
-	finite     bool           // whether the type has finite size
+	varSize    bool           // whether the type has variable size
 
 	// methods declared for this type (not the method set of this type)
 	// Signatures are type-checked lazily.
@@ -152,10 +150,10 @@ type instance struct {
 //	unpacked
 //	└── hasMethods
 //	└── hasUnder
-//	└── hasFinite
+//	└── hasVarSize
 //
 // That is, descent down the tree is mostly linear (initial through unpacked), except upon
-// reaching the leaves (hasMethods, hasUnder, and hasFinite). A type may occupy any
+// reaching the leaves (hasMethods, hasUnder, and hasVarSize). A type may occupy any
 // combination of the leaf states at once (they are independent states).
 //
 // To represent this independence, the set of active states is represented with a bit set. State
@@ -169,7 +167,7 @@ type instance struct {
 //	11000 | unpacked, which implies lazyLoaded
 //	11100 | hasMethods, which implies unpacked (which in turn implies lazyLoaded)
 //	11010 | hasUnder, which implies unpacked ...
-//	11001 | hasFinite, which implies unpacked ...
+//	11001 | hasVarSize, which implies unpacked ...
 //	11110 | both hasMethods and hasUnder which implies unpacked ...
 //	...   | (other combinations of leaf states)
 //
@@ -182,7 +180,7 @@ const (
 	unpacked                         // methods might be unexpanded (for instances)
 	hasMethods                       // methods are all expanded (for instances)
 	hasUnder                         // underlying type is available
-	hasFinite                        // size finiteness is available
+	hasVarSize                       // varSize is available
 )
 
 // NewNamed returns a new named type for the given type name, underlying type, and associated methods.
@@ -195,7 +193,6 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 	n := (*Checker)(nil).newNamed(obj, underlying, methods)
 	if underlying == nil {
 		n.allowNilRHS = true
-		n.allowNilUnderlying = true
 	} else {
 		n.SetUnderlying(underlying)
 	}
@@ -237,9 +234,6 @@ func (n *Named) unpack() *Named {
 		return n
 	}
 
-	// underlying comes after unpacking, do not set it
-	defer (func() { assert(!n.stateHas(hasUnder)) })()
-
 	if n.inst != nil {
 		assert(n.fromRHS == nil) // instantiated types are not declared types
 		assert(n.loader == nil)  // cannot import an instantiation
@@ -256,6 +250,8 @@ func (n *Named) unpack() *Named {
 		} else {
 			n.setState(lazyLoaded | unpacked)
 		}
+		// underlying comes after unpacking, do not set it
+		assert(!n.stateHas(hasUnder))
 		return n
 	}
 
@@ -274,16 +270,23 @@ func (n *Named) unpack() *Named {
 		n.loader = nil
 
 		n.tparams = bindTParams(tparams)
+		n.underlying = underlying
 		n.fromRHS = underlying // for cycle detection
 		n.methods = methods
 
-		n.setState(lazyLoaded) // avoid deadlock calling delayed functions
+		// Careful: A delayed function could need the underlying type of
+		// the type we are loading, so we must advance to hasUnder to
+		// avoid a deadlock (see go.dev/issue/80258).
+		n.setState(lazyLoaded | unpacked | hasMethods | hasUnder)
 		for _, f := range delayed {
 			f()
 		}
+		return n
 	}
 
+	// underlying comes after unpacking, do not set it
 	n.setState(lazyLoaded | unpacked | hasMethods)
+	assert(!n.stateHas(hasUnder))
 	return n
 }
 
@@ -312,8 +315,8 @@ func (n *Named) setState(m stateMask) {
 		if m&hasUnder != 0 {
 			assert(u)
 		}
-		// hasFinite => unpacked
-		if m&hasFinite != 0 {
+		// hasVarSize => unpacked
+		if m&hasVarSize != 0 {
 			assert(u)
 		}
 	}
@@ -414,9 +417,13 @@ func (t *Named) NumMethods() int {
 
 // Method returns the i'th method of named type t for 0 <= i < t.NumMethods().
 //
-// For an ordinary or instantiated type t, the receiver base type of this
-// method is the named type t. For an uninstantiated generic type t, each
-// method receiver is instantiated with its receiver type parameters.
+// For an ordinary or instantiated type t, the receiver base type of this method
+// is the named type t. The returned Func's Signature will not have receiver
+// type parameters.
+//
+// For an uninstantiated generic type t, each method receiver is instantiated with
+// its receiver type parameters. The returned Func's Signature will have the
+// receiver type parameters used to instantiate the receiver.
 //
 // Methods are numbered deterministically: given the same list of source files
 // presented to the type checker, or the same sequence of NewMethod and AddMethod
@@ -458,62 +465,65 @@ func (t *Named) Method(i int) *Func {
 }
 
 // expandMethod substitutes type arguments in the i'th method for an
-// instantiated receiver.
+// instantiated receiver. A returned Func's Signature never has
+// receiver type parameters.
 func (t *Named) expandMethod(i int) *Func {
-	// t.orig.methods is not lazy. origm is the method instantiated with its
-	// receiver type parameters (the "origin" method).
-	origm := t.inst.orig.Method(i)
-	assert(origm != nil)
+	// t.orig.methods is not lazy. orig is the declared function on t, which
+	// must have receiver type parameters (since t is generic).
+	orig := t.inst.orig.Method(i)
+	assert(orig != nil)
 
 	check := t.check
 	// Ensure that the original method is type-checked.
 	if check != nil {
-		check.objDecl(origm)
+		check.objDecl(orig)
 	}
 
-	origSig := origm.typ.(*Signature)
-	rbase, _ := deref(origSig.Recv().Type())
+	oldSig := orig.typ.(*Signature)
+	rtpars := oldSig.rparams.list()
+	rtargs := t.inst.targs.list()
 
-	// If rbase is t, then origm is already the instantiated method we're looking
-	// for. In this case, we return origm to preserve the invariant that
-	// traversing Method->Receiver Type->Method should get back to the same
-	// method.
+	// Consider:
 	//
-	// This occurs if t is instantiated with the receiver type parameters, as in
-	// the use of m in func (r T[_]) m() { r.m() }.
-	if rbase == t {
-		return origm
-	}
+	// 	type T[P any] struct{}
+	// 	func (t T[P]) m() { t.m() }
+	//
+	// At t.m, m is expanded for T[P] to get a new Func, which must be different from
+	// the declared Func for the origin method T.m; notably, the Func for t.m lacks
+	// receiver type parameters, since it is instantiated (as opposed to declared)
+	// and thus no longer generic. One must not return the origin method here.
 
-	sig := origSig
 	// We can only substitute if we have a correspondence between type arguments
 	// and type parameters. This check is necessary in the presence of invalid
 	// code.
-	if origSig.RecvTypeParams().Len() == t.inst.targs.Len() {
-		smap := makeSubstMap(origSig.RecvTypeParams().list(), t.inst.targs.list())
+	newSig := oldSig
+	if len(rtpars) == len(rtargs) {
+		smap := makeSubstMap(rtpars, rtargs)
 		var ctxt *Context
 		if check != nil {
 			ctxt = check.context()
 		}
-		sig = check.subst(origm.pos, origSig, smap, t, ctxt).(*Signature)
+		newSig = check.subst(orig.pos, oldSig, smap, t, ctxt).(*Signature)
 	}
 
-	if sig == origSig {
+	if newSig == oldSig {
 		// No substitution occurred, but we still need to create a new signature to
 		// hold the instantiated receiver.
-		copy := *origSig
-		sig = &copy
+		copy := *oldSig
+		newSig = &copy
 	}
 
 	var rtyp Type
-	if origm.hasPtrRecv() {
+	if orig.hasPtrRecv() {
 		rtyp = NewPointer(t)
 	} else {
 		rtyp = t
 	}
 
-	sig.recv = cloneVar(origSig.recv, rtyp)
-	return cloneFunc(origm, sig)
+	newSig.recv = cloneVar(oldSig.recv, rtyp)
+	newSig.rparams = nil
+
+	return cloneFunc(orig, newSig)
 }
 
 // SetUnderlying sets the underlying type and marks t as complete.
@@ -535,7 +545,6 @@ func (t *Named) SetUnderlying(u Type) {
 	t.setState(lazyLoaded | unpacked | hasMethods) // TODO(markfreeman): Why hasMethods?
 
 	t.underlying = u
-	t.allowNilUnderlying = false
 	t.setState(hasUnder)
 }
 
@@ -597,9 +606,7 @@ func (n *Named) Underlying() Type {
 	// and complicating things there, we just check for that special case here.
 	if n.rhs() == nil {
 		assert(n.allowNilRHS)
-		if n.allowNilUnderlying {
-			return nil
-		}
+		return nil
 	}
 
 	if !n.stateHas(hasUnder) { // minor performance optimization
@@ -629,7 +636,7 @@ func (t *Named) String() string { return TypeString(t, nil) }
 // any, they were broken (by setting the respective types to invalid) during
 // the directCycles check phase.
 func (n *Named) resolveUnderlying() {
-	assert(n.stateHas(unpacked))
+	assert(n.stateHas(lazyLoaded | unpacked))
 
 	var seen map[*Named]bool // for debugging only
 	if debug {
@@ -640,9 +647,6 @@ func (n *Named) resolveUnderlying() {
 	var u Type
 	for rhs := Type(n); u == nil; {
 		switch t := rhs.(type) {
-		case nil:
-			u = Typ[Invalid]
-
 		case *Alias:
 			rhs = unalias(t)
 
@@ -664,8 +668,8 @@ func (n *Named) resolveUnderlying() {
 			path = append(path, t)
 
 			t.unpack()
-			assert(t.rhs() != nil || t.allowNilRHS)
 			rhs = t.rhs()
+			assert(rhs != nil)
 
 		default:
 			u = rhs // any type literal or predeclared type works

package/bin/go/src/go/types/object.go

@@ -399,8 +399,9 @@ func (*Var) isDependency() {} // a variable may be a dependency of an initializa
 // An abstract method may belong to many interfaces due to embedding.
 type Func struct {
 	object
-	hasPtrRecv_ bool  // only valid for methods that don't have a type yet; use hasPtrRecv() to read
 	origin      *Func // if non-nil, the Func from which this one was instantiated
+	hasPtrRecv_ bool  // only valid for methods that don't have a type yet; use hasPtrRecv() to read
+	nointerface bool
 }
 
 // NewFunc returns a new function with the given signature, representing
@@ -415,7 +416,7 @@ func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func {
 		// as this would violate object.{Type,color} invariants.
 		// TODO(adonovan): propose to disallow NewFunc with nil *Signature.
 	}
-	return &Func{object{nil, pos, pkg, name, typ, 0, nopos}, false, nil}
+	return &Func{object{nil, pos, pkg, name, typ, 0, nopos}, nil, false, false}
 }
 
 // Signature returns the signature (type) of the function or method.
@@ -594,7 +595,7 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
 		}
 		if tname.IsAlias() {
 			buf.WriteString(" =")
-			if alias, ok := typ.(*Alias); ok { // materialized? (gotypesalias=1)
+			if alias, ok := typ.(*Alias); ok { // materialized? TODO(gri) Do we still need this (e.g. for byte, rune)?
 				typ = alias.fromRHS
 			}
 		} else if t, _ := typ.(*TypeParam); t != nil {

package/bin/go/src/go/types/operand.go

@@ -57,11 +57,27 @@ var operandModeString = [...]string{
 // for built-in functions.
 // The zero value of operand is a ready to use invalid operand.
 type operand struct {
-	mode operandMode
-	expr ast.Expr
-	typ  Type
-	val  constant.Value
-	id   builtinId
+	mode_ operandMode
+	expr  ast.Expr
+	typ_  Type
+	val   constant.Value
+	id    builtinId
+}
+
+func (x *operand) mode() operandMode {
+	return x.mode_
+}
+
+func (x *operand) typ() Type {
+	return x.typ_
+}
+
+func (x *operand) isValid() bool {
+	return x.mode() != invalid
+}
+
+func (x *operand) invalidate() {
+	x.mode_ = invalid
 }
 
 // Pos returns the position of the expression corresponding to x.
@@ -113,18 +129,18 @@ func (x *operand) Pos() token.Pos {
 func operandString(x *operand, qf Qualifier) string {
 	// special-case nil
 	if isTypes2 {
-		if x.mode == nilvalue {
-			switch x.typ {
+		if x.mode() == nilvalue {
+			switch x.typ() {
 			case nil, Typ[Invalid]:
 				return "nil (with invalid type)"
 			case Typ[UntypedNil]:
 				return "nil"
 			default:
-				return fmt.Sprintf("nil (of type %s)", TypeString(x.typ, qf))
+				return fmt.Sprintf("nil (of type %s)", TypeString(x.typ(), qf))
 			}
 		}
 	} else { // go/types
-		if x.mode == value && x.typ == Typ[UntypedNil] {
+		if x.mode() == value && x.typ() == Typ[UntypedNil] {
 			return "nil"
 		}
 	}
@@ -135,11 +151,11 @@ func operandString(x *operand, qf Qualifier) string {
 	if x.expr != nil {
 		expr = ExprString(x.expr)
 	} else {
-		switch x.mode {
+		switch x.mode() {
 		case builtin:
 			expr = predeclaredFuncs[x.id].name
 		case typexpr:
-			expr = TypeString(x.typ, qf)
+			expr = TypeString(x.typ(), qf)
 		case constant_:
 			expr = x.val.String()
 		}
@@ -153,14 +169,14 @@ func operandString(x *operand, qf Qualifier) string {
 
 	// <untyped kind>
 	hasType := false
-	switch x.mode {
+	switch x.mode() {
 	case invalid, novalue, builtin, typexpr:
 		// no type
 	default:
 		// should have a type, but be cautious (don't crash during printing)
-		if x.typ != nil {
-			if isUntyped(x.typ) {
-				buf.WriteString(x.typ.(*Basic).name)
+		if x.typ() != nil {
+			if isUntyped(x.typ()) {
+				buf.WriteString(x.typ().(*Basic).name)
 				buf.WriteByte(' ')
 				break
 			}
@@ -169,10 +185,10 @@ func operandString(x *operand, qf Qualifier) string {
 	}
 
 	// <mode>
-	buf.WriteString(operandModeString[x.mode])
+	buf.WriteString(operandModeString[x.mode()])
 
 	// <val>
-	if x.mode == constant_ {
+	if x.mode() == constant_ {
 		if s := x.val.String(); s != expr {
 			buf.WriteByte(' ')
 			buf.WriteString(s)
@@ -181,9 +197,9 @@ func operandString(x *operand, qf Qualifier) string {
 
 	// <typ>
 	if hasType {
-		if isValid(x.typ) {
+		if isValid(x.typ()) {
 			var desc string
-			if isGeneric(x.typ) {
+			if isGeneric(x.typ()) {
 				desc = "generic "
 			}
 
@@ -191,14 +207,14 @@ func operandString(x *operand, qf Qualifier) string {
 			// If the type is a renamed basic type, describe the basic type,
 			// as in "int32 type MyInt" for a *Named type MyInt.
 			// If it is a type parameter, describe the constraint instead.
-			tpar, _ := Unalias(x.typ).(*TypeParam)
+			tpar, _ := Unalias(x.typ()).(*TypeParam)
 			if tpar == nil {
-				switch x.typ.(type) {
+				switch x.typ().(type) {
 				case *Alias, *Named:
-					what := compositeKind(x.typ)
+					what := compositeKind(x.typ())
 					if what == "" {
 						// x.typ must be basic type
-						what = x.typ.Underlying().(*Basic).name
+						what = x.typ().Underlying().(*Basic).name
 					}
 					desc += what + " "
 				}
@@ -206,7 +222,7 @@ func operandString(x *operand, qf Qualifier) string {
 			// desc is "" or has a trailing space at the end
 
 			buf.WriteString(" of " + desc + "type ")
-			WriteType(&buf, x.typ, qf)
+			WriteType(&buf, x.typ(), qf)
 
 			if tpar != nil {
 				buf.WriteString(" constrained by ")
@@ -285,21 +301,21 @@ func (x *operand) setConst(k token.Token, lit string) {
 
 	val := makeFromLiteral(lit, k)
 	if val.Kind() == constant.Unknown {
-		x.mode = invalid
-		x.typ = Typ[Invalid]
+		x.invalidate()
+		x.typ_ = Typ[Invalid]
 		return
 	}
-	x.mode = constant_
-	x.typ = Typ[kind]
+	x.mode_ = constant_
+	x.typ_ = Typ[kind]
 	x.val = val
 }
 
 // isNil reports whether x is the (untyped) nil value.
 func (x *operand) isNil() bool {
 	if isTypes2 {
-		return x.mode == nilvalue
+		return x.mode() == nilvalue
 	} else { // go/types
-		return x.mode == value && x.typ == Typ[UntypedNil]
+		return x.mode() == value && x.typ() == Typ[UntypedNil]
 	}
 }
 
@@ -310,12 +326,12 @@ func (x *operand) isNil() bool {
 // if assignableTo is invoked through an exported API call, i.e., when all
 // methods have been type-checked.
 func (x *operand) assignableTo(check *Checker, T Type, cause *string) (bool, Code) {
-	if x.mode == invalid || !isValid(T) {
+	if !x.isValid() || !isValid(T) {
 		return true, 0 // avoid spurious errors
 	}
 
 	origT := T
-	V := Unalias(x.typ)
+	V := Unalias(x.typ())
 	T = Unalias(T)
 
 	// x's type is identical to T
@@ -420,7 +436,7 @@ func (x *operand) assignableTo(check *Checker, T Type, cause *string) (bool, Cod
 			}
 			ok, code = x.assignableTo(check, T.typ, cause)
 			if !ok {
-				errorf("cannot assign %s to %s (in %s)", x.typ, T.typ, Tp)
+				errorf("cannot assign %s to %s (in %s)", x.typ(), T.typ, Tp)
 				return false
 			}
 			return true
@@ -439,7 +455,7 @@ func (x *operand) assignableTo(check *Checker, T Type, cause *string) (bool, Cod
 			if V == nil {
 				return false // no specific types
 			}
-			x.typ = V.typ
+			x.typ_ = V.typ
 			ok, code = x.assignableTo(check, T, cause)
 			if !ok {
 				errorf("cannot assign %s (in %s) to %s", V.typ, Vp, origT)

package/bin/go/src/go/types/range.go

@@ -37,8 +37,8 @@ func (check *Checker) rangeStmt(inner stmtContext, rangeStmt *ast.RangeStmt, noN
 	check.hasCallOrRecv = false
 	check.expr(nil, &x, rangeVar)
 
-	if isTypes2 && x.mode != invalid && sValue == nil && !check.hasCallOrRecv {
-		if t, ok := arrayPtrDeref(x.typ.Underlying()).(*Array); ok {
+	if isTypes2 && x.isValid() && sValue == nil && !check.hasCallOrRecv {
+		if t, ok := arrayPtrDeref(x.typ().Underlying()).(*Array); ok {
 			for {
 				// Put constant info on the thing inside parentheses.
 				// That's where (*../noder/writer).expr expects it.
@@ -53,19 +53,19 @@ func (check *Checker) rangeStmt(inner stmtContext, rangeStmt *ast.RangeStmt, noN
 			// (and thus side-effects will not be computed
 			// by the backend).
 			check.record(&operand{
-				mode: constant_,
-				expr: rangeVar,
-				typ:  Typ[Int],
-				val:  constant.MakeInt64(t.len),
-				id:   x.id,
+				mode_: constant_,
+				expr:  rangeVar,
+				typ_:  Typ[Int],
+				val:   constant.MakeInt64(t.len),
+				id:    x.id,
 			})
 		}
 	}
 
 	// determine key/value types
 	var key, val Type
-	if x.mode != invalid {
-		k, v, cause, ok := rangeKeyVal(check, x.typ, func(v goVersion) bool {
+	if x.isValid() {
+		k, v, cause, ok := rangeKeyVal(check, x.typ(), func(v goVersion) bool {
 			return check.allowVersion(v)
 		})
 		switch {
@@ -95,7 +95,7 @@ func (check *Checker) rangeStmt(inner stmtContext, rangeStmt *ast.RangeStmt, noN
 	lhs := [2]ast.Expr{sKey, sValue} // sKey, sValue may be nil
 	rhs := [2]Type{key, val}         // key, val may be nil
 
-	rangeOverInt := isInteger(x.typ)
+	rangeOverInt := isInteger(x.typ())
 
 	if isDef {
 		// short variable declaration
@@ -136,9 +136,9 @@ func (check *Checker) rangeStmt(inner stmtContext, rangeStmt *ast.RangeStmt, noN
 				check.initVar(obj, &x, "range clause")
 			} else {
 				var y operand
-				y.mode = value
+				y.mode_ = value
 				y.expr = lhs // we don't have a better rhs expression to use here
-				y.typ = typ
+				y.typ_ = typ
 				check.initVar(obj, &y, "assignment") // error is on variable, use "assignment" not "range clause"
 			}
 			assert(obj.typ != nil)
@@ -172,14 +172,14 @@ func (check *Checker) rangeStmt(inner stmtContext, rangeStmt *ast.RangeStmt, noN
 				// If the assignment succeeded, if x was untyped before, it now
 				// has a type inferred via the assignment. It must be an integer.
 				// (go.dev/issues/67027)
-				if x.mode != invalid && !isInteger(x.typ) {
-					check.softErrorf(lhs, InvalidRangeExpr, "cannot use iteration variable of type %s", x.typ)
+				if x.isValid() && !isInteger(x.typ()) {
+					check.softErrorf(lhs, InvalidRangeExpr, "cannot use iteration variable of type %s", x.typ())
 				}
 			} else {
 				var y operand
-				y.mode = value
+				y.mode_ = value
 				y.expr = lhs // we don't have a better rhs expression to use here
-				y.typ = typ
+				y.typ_ = typ
 				check.assignVar(lhs, nil, &y, "assignment") // error is on variable, use "assignment" not "range clause"
 			}
 		}
@@ -243,6 +243,7 @@ func rangeKeyVal(check *Checker, orig Type, allowVersion func(goVersion) bool) (
 			return bad("requires go1.23 or later")
 		}
 		// check iterator arity
+		// TODO(gri) error messages could be less verbose (consider rangeStmt error and cause returned here)
 		switch {
 		case typ.Params().Len() != 1:
 			return bad("func must be func(yield func(...) bool): wrong argument count")
@@ -269,6 +270,8 @@ func rangeKeyVal(check *Checker, orig Type, allowVersion func(goVersion) bool) (
 			} else {
 				return bad("func must be func(yield func(...) bool): yield func does not return bool")
 			}
+		case cb.Variadic():
+			return bad(check.sprintf("yield func of type %s cannot be variadic", cb))
 		}
 		assert(cb.Recv() == nil)
 		// determine key and value types, if any

package/bin/go/src/go/types/recording.go

@@ -20,25 +20,25 @@ func (check *Checker) record(x *operand) {
 	// TODO(gri) this code can be simplified
 	var typ Type
 	var val constant.Value
-	switch x.mode {
+	switch x.mode() {
 	case invalid:
 		typ = Typ[Invalid]
 	case novalue:
 		typ = (*Tuple)(nil)
 	case constant_:
-		typ = x.typ
+		typ = x.typ()
 		val = x.val
 	default:
-		typ = x.typ
+		typ = x.typ()
 	}
 	assert(x.expr != nil && typ != nil)
 
 	if isUntyped(typ) {
 		// delay type and value recording until we know the type
 		// or until the end of type checking
-		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
+		check.rememberUntyped(x.expr, false, x.mode(), typ.(*Basic), val)
 	} else {
-		check.recordTypeAndValue(x.expr, x.mode, typ, val)
+		check.recordTypeAndValue(x.expr, x.mode(), typ, val)
 	}
 }
 
@@ -97,10 +97,10 @@ func (check *Checker) recordBuiltinType(f ast.Expr, sig *Signature) {
 func (check *Checker) recordCommaOkTypes(x ast.Expr, a []*operand) {
 	assert(x != nil)
 	assert(len(a) == 2)
-	if a[0].mode == invalid {
+	if a[0].mode() == invalid {
 		return
 	}
-	t0, t1 := a[0].typ, a[1].typ
+	t0, t1 := a[0].typ(), a[1].typ()
 	assert(isTyped(t0) && isTyped(t1) && (allBoolean(t1) || t1 == universeError))
 	if m := check.Types; m != nil {
 		for {
@@ -134,6 +134,23 @@ func (check *Checker) recordInstance(expr ast.Expr, targs []Type, typ Type) {
 	assert(ident != nil)
 	assert(typ != nil)
 	if m := check.Instances; m != nil {
+		// If this is an instance of a method value/expression, replace the
+		// receiver for the Signature stored in Instances (go.dev/issue/79657).
+		if sig, _ := typ.(*Signature); sig != nil && sig.recvold != nil {
+			copy := *sig
+			copy.recvold = nil // not strictly necessary
+			if sig.recvold == methodExprSentinel {
+				pars := *copy.params
+				copy.recv = pars.vars[0]
+				pars.vars = pars.vars[1:]
+				copy.params = &pars
+				m[ident] = Instance{newTypeList(targs), &copy}
+				return
+			}
+			copy.recv = sig.recvold
+			m[ident] = Instance{newTypeList(targs), &copy}
+			return
+		}
 		m[ident] = Instance{newTypeList(targs), typ}
 	}
 }