Need a Definition for the Term “receiver”

[RexJaeschke]

I’m working on a future proposal, and it refers to “receiver,” a term with which I was not previously familiar. A look through the current spec base shows uses of this term, but no definition. Those uses are:

classes.md:

15.6.10 Extension methods

An extension method is a regular static method. In addition, where its enclosing static class is in scope, an extension method may be invoked using instance method invocation syntax (§12.7.6.3), using the receiver expression as the first argument.

expressions.md:

12.3 Static and Dynamic Binding|12.3.1 General

Binding is the process of determining what an operation refers to, based on the type or value of expressions (arguments, operands, receivers). For instance, the binding of a method call is determined based on the type of the receiver and arguments. The binding of an operator is determined based on the type of its operands.

12.3.4 Types of subexpressions

When an operation is statically bound, the type of a subexpression (e.g., a receiver, and argument, an index or an operand) is always considered to be the compile-time type of that expression.

12.6.2.2 Corresponding parameters

For virtual methods and indexers defined in classes, the parameter list is picked from the first declaration or override of the function member found when starting with the static type of the receiver, and searching through its base classes.

12.6.5 Compile-time checking of dynamic member invocation

• For an indexer access (§12.7.7.3) the set of accessible indexers in the receiver is known at compile-time.
• If F is a static method, the method group shall not have resulted from a member_access whose receiver is known at compile-time to be a variable or value.
• If F is an instance method, the method group shall not have resulted from a member_access whose receiver is known at compile-time to be a type.

12.7.6 Invocation expressions|12.7.6.1 General

• Otherwise, the result is a value, with an associated type of the return type of the method or delegate after any type argument substitutions (§12.7.6.2) have been performed. If the invocation is of an instance method, and the receiver is of a class type T, the associated type is picked from the first declaration or override of the method found when starting with T and searching through its base classes.

12.16.5 Anonymous functions and dynamic binding

An anonymous function cannot be a receiver, argument, or operand of a dynamically bound operation.

[RexJaeschke]

Jon's initial thoughts in private mail to me:

Without any context (and I haven't checked the docs) I'd expect it to be the opposite of a "caller". So for example, suppose you have:

public class X
{
    public virtual void Foo() {}
}

public class Y : X
{
   public override void Foo() {}
}

public class Z
{
    public void CallFoo(X x)
    {
        x.Foo();
    }

    public void CallCallFoo()
    {
         CallFoo(new Y());
    }
}

With respect to the Foo method, Z.CallFoo is the caller, X is the "declarer" of the method, but Y is the "receiver" of the method at execution time. But I may be way off base :)

[KalleOlaviNiemitalo]

I would think that "receiver" is a compile-time concept and means any of:

• the primary_expression in member_access : primary_expression '.' identifier type_argument_list?
• the primary_expression in null_conditional_expression : primary_expression null_conditional_operations in C# 6.0 feature: specification for null-conditional-operator #7
• the primary_no_array_creation_expression in element_access : primary_no_array_creation_expression '[' argument_list ']'

So in x.Foo(), x would be the receiver, regardless of whether Foo is an extension method. In x++, x would be an operand and not a receiver.

But if the expression is just Foo(), then I suppose this could be the receiver, even though it does not appear in the expression. So maybe it is not a lexical thing after all.

[Nigel-Ecma]

On 19/08/2021, at 1:26 am, Rex Jaeschke ***@***.***> wrote: I’m working on a future proposal, and it refers to “receiver,” a term with which I was not previously familiar. A look through the current spec base shows uses of this term, but no definition.

From a CS point-of-view it is a common term. For functions “caller”/“calling" and “callee” are commonly used – callee being the function. For methods/messages (depending on the OO model terminology) the terms are “caller”/“sender” and “receiver” – receiver being the object (this/self/etc.) on which the method/message operates. So callee and receiver are similar but different; the former is usually the code of the function, the latter is the object and maybe the method code. That said the terminology choices/distinctions vary Terminology choice may also vary for static/class methods depending on whether the language treats classes themselves as objects – in which case the class object is the receiver – or not – in which case more function-oriented terms may be used. I don’t think the Standard needs to define caller/callee/receiver/et al, but it can do so. HTH, Nigel