public override BoundNode VisitEventAssignmentOperator(BoundEventAssignmentOperator node)
{
BoundExpression rewrittenReceiverOpt = VisitExpression(node.ReceiverOpt);
BoundExpression rewrittenArgument = VisitExpression(node.Argument);
if (rewrittenReceiverOpt != null && node.Event.ContainingAssembly.IsLinked && node.Event.ContainingType.IsInterfaceType())
{
var @interface = node.Event.ContainingType;
foreach (var attrData in @interface.GetAttributes())
{
if (attrData.IsTargetAttribute(@interface, AttributeDescription.ComEventInterfaceAttribute) &&
attrData.CommonConstructorArguments.Length == 2)
{
return(RewriteNoPiaEventAssignmentOperator(node, rewrittenReceiverOpt, rewrittenArgument));
}
}
}
if (node.Event.IsWindowsRuntimeEvent)
{
EventAssignmentKind kind = node.IsAddition ? EventAssignmentKind.Addition : EventAssignmentKind.Subtraction;
return(RewriteWindowsRuntimeEventAssignmentOperator(node.Syntax, node.Event, kind, node.IsDynamic, rewrittenReceiverOpt, rewrittenArgument));
}
var rewrittenArguments = ImmutableArray.Create <BoundExpression>(rewrittenArgument);
MethodSymbol method = node.IsAddition ? node.Event.AddMethod : node.Event.RemoveMethod;
return(MakeCall(node.Syntax, rewrittenReceiverOpt, method, rewrittenArguments, node.Type));
}
/// <summary>
/// If we have a WinRT type event, we need to encapsulate the adder call
/// (which returns an EventRegistrationToken) with a call to
/// WindowsRuntimeMarshal.AddEventHandler or RemoveEventHandler, but these
/// require us to create a new Func representing the adder and another
/// Action representing the Remover.
///
/// The rewritten call looks something like:
///
/// WindowsRuntimeMarshal.AddEventHandler<EventHandler>
/// (new Func<EventHandler, EventRegistrationToken>(@object.add),
/// new Action<EventRegistrationToken>(@object.remove), handler);
///
/// Where @object is a compiler-generated local temp if needed.
/// </summary>
/// <remarks>
/// TODO: use or delete isDynamic.
/// </remarks>
private BoundExpression RewriteWindowsRuntimeEventAssignmentOperator(SyntaxNode syntax, EventSymbol eventSymbol, EventAssignmentKind kind, bool isDynamic, BoundExpression rewrittenReceiverOpt, BoundExpression rewrittenArgument)
{
BoundAssignmentOperator tempAssignment = null;
BoundLocal boundTemp = null;
if (!eventSymbol.IsStatic && CanChangeValueBetweenReads(rewrittenReceiverOpt))
{
boundTemp = _factory.StoreToTemp(rewrittenReceiverOpt, out tempAssignment);
}
NamedTypeSymbol tokenType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken);
NamedTypeSymbol marshalType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal);
NamedTypeSymbol actionType = _factory.WellKnownType(WellKnownType.System_Action_T).Construct(tokenType);
TypeSymbol eventType = eventSymbol.Type;
BoundExpression delegateCreationArgument = boundTemp ?? rewrittenReceiverOpt ?? _factory.Type(eventType);
BoundDelegateCreationExpression removeDelegate = new BoundDelegateCreationExpression(
syntax: syntax,
argument: delegateCreationArgument,
methodOpt: eventSymbol.RemoveMethod,
isExtensionMethod: false,
type: actionType);
BoundExpression clearCall = null;
if (kind == EventAssignmentKind.Assignment)
{
MethodSymbol clearMethod;
if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__RemoveAllEventHandlers, out clearMethod))
{
clearCall = MakeCall(
syntax: syntax,
rewrittenReceiver: null,
method: clearMethod,
rewrittenArguments: ImmutableArray.Create<BoundExpression>(removeDelegate),
type: clearMethod.ReturnType);
}
else
{
clearCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundNode>(removeDelegate), ErrorTypeSymbol.UnknownResultType);
}
}
ImmutableArray<BoundExpression> marshalArguments;
WellKnownMember helper;
if (kind == EventAssignmentKind.Subtraction)
{
helper = WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__RemoveEventHandler_T;
marshalArguments = ImmutableArray.Create<BoundExpression>(removeDelegate, rewrittenArgument);
}
else
{
NamedTypeSymbol func2Type = _factory.WellKnownType(WellKnownType.System_Func_T2).Construct(eventType, tokenType);
BoundDelegateCreationExpression addDelegate = new BoundDelegateCreationExpression(
syntax: syntax,
argument: delegateCreationArgument,
methodOpt: eventSymbol.AddMethod,
isExtensionMethod: false,
type: func2Type);
helper = WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__AddEventHandler_T;
marshalArguments = ImmutableArray.Create<BoundExpression>(addDelegate, removeDelegate, rewrittenArgument);
}
BoundExpression marshalCall;
MethodSymbol marshalMethod;
if (TryGetWellKnownTypeMember(syntax, helper, out marshalMethod))
{
marshalMethod = marshalMethod.Construct(eventType);
marshalCall = MakeCall(
syntax: syntax,
rewrittenReceiver: null,
method: marshalMethod,
rewrittenArguments: marshalArguments,
type: marshalMethod.ReturnType);
}
else
{
marshalCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol>.Empty, StaticCast<BoundNode>.From(marshalArguments), ErrorTypeSymbol.UnknownResultType);
}
// In this case, we don't need a sequence.
if (boundTemp == null && clearCall == null)
{
return marshalCall;
}
ImmutableArray<LocalSymbol> tempSymbols = boundTemp == null
? ImmutableArray<LocalSymbol>.Empty
: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol);
ArrayBuilder<BoundExpression> sideEffects = ArrayBuilder<BoundExpression>.GetInstance(2); //max size
if (clearCall != null) sideEffects.Add(clearCall);
if (tempAssignment != null) sideEffects.Add(tempAssignment);
Debug.Assert(sideEffects.Any(), "Otherwise, we shouldn't be building a sequence");
return new BoundSequence(syntax, tempSymbols, sideEffects.ToImmutableAndFree(), marshalCall, marshalCall.Type);
}
/// <summary>
/// If we have a WinRT type event, we need to encapsulate the adder call
/// (which returns an EventRegistrationToken) with a call to
/// WindowsRuntimeMarshal.AddEventHandler or RemoveEventHandler, but these
/// require us to create a new Func representing the adder and another
/// Action representing the Remover.
///
/// The rewritten call looks something like:
///
/// WindowsRuntimeMarshal.AddEventHandler<EventHandler>
/// (new Func<EventHandler, EventRegistrationToken>(@object.add),
/// new Action<EventRegistrationToken>(@object.remove), handler);
///
/// Where @object is a compiler-generated local temp if needed.
/// </summary>
/// <remarks>
/// TODO: use or delete isDynamic.
/// </remarks>
private BoundExpression RewriteWindowsRuntimeEventAssignmentOperator(SyntaxNode syntax, EventSymbol eventSymbol, EventAssignmentKind kind, bool isDynamic, BoundExpression rewrittenReceiverOpt, BoundExpression rewrittenArgument)
{
BoundAssignmentOperator tempAssignment = null;
BoundLocal boundTemp = null;
if (!eventSymbol.IsStatic && CanChangeValueBetweenReads(rewrittenReceiverOpt))
{
boundTemp = _factory.StoreToTemp(rewrittenReceiverOpt, out tempAssignment);
}
NamedTypeSymbol tokenType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken);
NamedTypeSymbol marshalType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal);
NamedTypeSymbol actionType = _factory.WellKnownType(WellKnownType.System_Action_T).Construct(tokenType);
TypeSymbol eventType = eventSymbol.Type;
BoundExpression delegateCreationArgument = boundTemp ?? rewrittenReceiverOpt ?? _factory.Type(eventType);
BoundDelegateCreationExpression removeDelegate = new BoundDelegateCreationExpression(
syntax: syntax,
argument: delegateCreationArgument,
methodOpt: eventSymbol.RemoveMethod,
isExtensionMethod: false,
type: actionType);
BoundExpression clearCall = null;
if (kind == EventAssignmentKind.Assignment)
{
MethodSymbol clearMethod;
if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__RemoveAllEventHandlers, out clearMethod))
{
clearCall = MakeCall(
syntax: syntax,
rewrittenReceiver: null,
method: clearMethod,
rewrittenArguments: ImmutableArray.Create <BoundExpression>(removeDelegate),
type: clearMethod.ReturnType);
}
else
{
clearCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray <Symbol> .Empty, ImmutableArray.Create <BoundExpression>(removeDelegate), ErrorTypeSymbol.UnknownResultType);
}
}
ImmutableArray <BoundExpression> marshalArguments;
WellKnownMember helper;
if (kind == EventAssignmentKind.Subtraction)
{
helper = WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__RemoveEventHandler_T;
marshalArguments = ImmutableArray.Create <BoundExpression>(removeDelegate, rewrittenArgument);
}
else
{
NamedTypeSymbol func2Type = _factory.WellKnownType(WellKnownType.System_Func_T2).Construct(eventType, tokenType);
BoundDelegateCreationExpression addDelegate = new BoundDelegateCreationExpression(
syntax: syntax,
argument: delegateCreationArgument,
methodOpt: eventSymbol.AddMethod,
isExtensionMethod: false,
type: func2Type);
helper = WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__AddEventHandler_T;
marshalArguments = ImmutableArray.Create <BoundExpression>(addDelegate, removeDelegate, rewrittenArgument);
}
BoundExpression marshalCall;
MethodSymbol marshalMethod;
if (TryGetWellKnownTypeMember(syntax, helper, out marshalMethod))
{
marshalMethod = marshalMethod.Construct(eventType);
marshalCall = MakeCall(
syntax: syntax,
rewrittenReceiver: null,
method: marshalMethod,
rewrittenArguments: marshalArguments,
type: marshalMethod.ReturnType);
}
else
{
marshalCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray <Symbol> .Empty, marshalArguments, ErrorTypeSymbol.UnknownResultType);
}
// In this case, we don't need a sequence.
if (boundTemp == null && clearCall == null)
{
return(marshalCall);
}
ImmutableArray <LocalSymbol> tempSymbols = boundTemp == null
? ImmutableArray <LocalSymbol> .Empty
: ImmutableArray.Create <LocalSymbol>(boundTemp.LocalSymbol);
ArrayBuilder <BoundExpression> sideEffects = ArrayBuilder <BoundExpression> .GetInstance(2); //max size
if (clearCall != null)
{
sideEffects.Add(clearCall);
}
if (tempAssignment != null)
{
sideEffects.Add(tempAssignment);
}
Debug.Assert(sideEffects.Any(), "Otherwise, we shouldn't be building a sequence");
return(new BoundSequence(syntax, tempSymbols, sideEffects.ToImmutableAndFree(), marshalCall, marshalCall.Type));
}