IBoundDelegateCreationExpression API

[333fred]

Given the following C# code:

class Program
{
    delegate void DType();
    void Main()
    {
        DType d1 = M1;
    }
    void M1()
    { }
}

We currently get the following IOperation tree:

IOperation tree for "DType d1 = M1"

IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'DType d1 = M1;')
  IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'DType d1 = M1;')
    Variables: Local_1: Program.DType d1
    Initializer: IMethodBindingExpression: void Program.M1() (OperationKind.MethodBindingExpression, Type: Program.DType) (Syntax: 'M1')
        Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: Program) (Syntax: 'M1')

This is inconsistent with the SemanticModel. For GetTypeInfo on the M1 IdentifierSyntaxNode, we have a Type of null and a ConvertedType of Program.DType. Note that the underlying BoundNode structure is actually a BoundLocalDeclaration, with an initializer of BoundConversion. We actually detect ConversionKind.MethodGroup and turn them into IMethodBindingExpressions. We should synthesize this expression under a conversion expression, and the type of the IMethodBindingExpression should be null.

Further complicating this is the VB equivalent. The following is the equivalent VB code:

Module Program
    Delegate Sub DType()
    Sub Main(args As String())
        Dim d1 As DType = AddressOf M1
    End Sub
    Sub M1()
    End Sub
End Module

This has an IOperation tree of:

IOperation tree for "Dim d1 As DType = AddressOf M1"

IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim d1 As D ... ddressOf M1')
  IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'd1')
    Variables: Local_1: d1 As Program.DType
    Initializer: IOperation:  (OperationKind.None) (Syntax: 'AddressOf M1')

The OperationKind.None is because BoundMethodCreationExpression support in VB is not currently implemented, see #19917. The complication is that the SemanticModel API does not return the same results. AddressOf M1 has a Type of Program.DType, and a ConvertedType of Program.DType. Consistency here would, I think, imply that we shouldn't have an IConversionExpression, as we never seem to have them for identity conversions. However, this would be inconsistent with the C# API, which I think is more important here. We need to discuss how to resolve these at the IOp meeting.

[333fred]

Fyi @dotnet/analyzer-ioperation

[CyrusNajmabadi]

DType d = M1 // Should be a delegate construction with a method reference
DType d = new DType(M1); // Should be a delegate construction with a method reference
DType d = new DType(() => { }); // Should be a delegate construction with a conversion and lambda
DType d = () => { }; // Should be a delegate construction with a conversion and a lambda


d as DType = addressof M1 ' Should be a delegate construction with a method reference
d as DType = new DType(addressof M1) ' Should be a delegate construction with a method reference 
d as DType = new DType(sub () end sub) ' Should be a delegate construction with a conversion and lambda
d as DType = sub () end sub ' Should be a delegate construction with a conversion and a lambda

Need IsCached (but maybe v2 if really hard to provide)

[333fred]

@CyrusNajmabadi @AlekseyTs @dotnet/analyzer-ioperation, another set of expressions to consider:

Action a = delegate() { };

Currently, this ends up being represented as an ILambda, with the appropriate IConversion from lambda to Action. Do we want this to appear the same as our idealized lambda above, DType d = () => { };, ie a delegate construction with a conversion and lambda?

[AlekseyTs]

This is another syntax for a lambda, there should be no difference with a regular lambda, I think.

[333fred]

API proposal:

    /// <summary>
    /// Represents a delegate creation expression. This is created whenever a new delegate is created.
    /// </summary>
    /// <remarks>
    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
    /// change it in the future.
    /// </remarks>
    public interface IDelegateCreationExpression : IHasArgumentsExpression
    {
        /// <summary>
        /// Symbol of the method being referenced by this delegate, if any.
        /// </summary>
        IMethodSymbol Method { get; }
    }

In C#, the argument will directly be the argument of the BoundDelegateCreationExpression. In VB, we will synthesize an IMethodBindingExpression from the BoundDelegateCreationExpression, and use that as the argument for the IDelegateCreationExpression.

For lambdas, we will synthesize IDelegateCreationExpressions when encountering specific IConversionExpressions. In C#, this will be any with ConversionKind.MethodGroup. In VB, I'm still determining what this list will look like, but at an initial look it appears that it will be all conversions with ConversionKind.Lambda set.

[jinujoseph]

Design Team Decision

It probably doesn't make sense to expose the constructor for the delegate and it doesn't make sense to expose it as arguments. We are contracting the delegate either from the method or from the conversion. 

We should probably have one node IOperationTarget Target is either conversion on top of the Lamda or it represents the method binding. 

[jinujoseph]

Address #8913 as part of this work

[333fred]

Small point for design discussion today:

Given this code:

using System;

class P
{
    void M1()
    {
        Action m = (Action)M2;
    }

    void M2()
    {
    }
}

I'm going to create the following IOperation tree:

IDelegateCreationExpression (OperationKind.DelegateCreationExpression, Type: System.Action) (Syntax: '(Action)M2')
    Target: IMethodBindingExpression: void P.M2() (OperationKind.MethodBindingExpression, Type: System.Action) (Syntax: 'M2')
        Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')

The question is how to indicate that this was an explicit cast. I talked with @AlekseyTs, and he proposed using the IsImplicit flag on the IDelegateCreationExpression for this. I like it, but for the sake of discussion, the other option is to put an IConversionExpression above the IDelegateCreationExpression.

[333fred]

Another small question: given the following code

using System;

class P
{
    void M1()
    {
        Action m = new Action((Action)M2);
    }

    void M2()
    {
    }
}

The underlying BoundNodes have a BoundDelegateCreation with a BoundConversion underneath. Should we detect this case and ensure there is only one IDelegateCreationExpression in the resulting tree, or show that there are in fact two creations here?

[AlekseyTs]

Should we detect this case and ensure there is only one IDelegateCreationExpression in the resulting tree, or show that there are in fact two creations here?

I believe the two nodes are using different target methods, so we should keep both.

[CyrusNajmabadi]

Design decision:

// Method reference, wrapped with explicit delegate creation.
Action m = (Action)M2;

// Method reference, wrapped with implicit delegate creation
Action m = M2;