/// <summary> /// Constructor. /// </summary> /// <param name="retargetingAssembly"> /// Owning assembly. /// </param> /// <param name="underlyingModule"> /// The underlying ModuleSymbol, cannot be another RetargetingModuleSymbol. /// </param> public RetargetingModuleSymbol(RetargetingAssemblySymbol retargetingAssembly, SourceModuleSymbol underlyingModule) { Debug.Assert((object)retargetingAssembly != null); Debug.Assert((object)underlyingModule != null); _retargetingAssembly = retargetingAssembly; _underlyingModule = underlyingModule; this.RetargetingTranslator = new RetargetingSymbolTranslator(this); _createRetargetingMethod = CreateRetargetingMethod; _createRetargetingNamespace = CreateRetargetingNamespace; _createRetargetingNamedType = CreateRetargetingNamedType; _createRetargetingField = CreateRetargetingField; _createRetargetingProperty = CreateRetargetingProperty; _createRetargetingEvent = CreateRetargetingEvent; _createRetargetingTypeParameter = CreateRetargetingTypeParameter; }
public void IsWindowsRuntimeEvent_EventSymbolSubtypes() { var il = @" .class public auto ansi sealed Event extends [mscorlib]System.MulticastDelegate { .method private hidebysig specialname rtspecialname instance void .ctor(object 'object', native int 'method') runtime managed { } .method public hidebysig newslot specialname virtual instance void Invoke() runtime managed { } } // end of class Event .class interface public abstract auto ansi Interface`1<T> { .method public hidebysig newslot specialname abstract virtual instance void add_Normal(class Event 'value') cil managed { } .method public hidebysig newslot specialname abstract virtual instance void remove_Normal(class Event 'value') cil managed { } .method public hidebysig newslot specialname abstract virtual instance valuetype [mscorlib]System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_WinRT([in] class Event 'value') cil managed { } .method public hidebysig newslot specialname abstract virtual instance void remove_WinRT([in] valuetype [mscorlib]System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken 'value') cil managed { } .event Event Normal { .addon instance void Interface`1::add_Normal(class Event) .removeon instance void Interface`1::remove_Normal(class Event) } // end of event I`1::Normal .event Event WinRT { .addon instance valuetype [mscorlib]System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken Interface`1::add_WinRT(class Event) .removeon instance void Interface`1::remove_WinRT(valuetype [mscorlib]System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken) } } // end of class Interface "; var source = @" class C : Interface<int> { event Event Interface<int>.Normal { add { throw null; } remove { throw null; } } event Event Interface<int>.WinRT { add { throw null; } remove { throw null; } } } "; var ilRef = CompileIL(il); var comp = CreateCompilation(source, WinRtRefs.Concat(new[] { ilRef })); comp.VerifyDiagnostics(); var interfaceType = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("Interface"); var interfaceNormalEvent = interfaceType.GetMember<EventSymbol>("Normal"); var interfaceWinRTEvent = interfaceType.GetMember<EventSymbol>("WinRT"); Assert.IsType<PEEventSymbol>(interfaceNormalEvent); Assert.IsType<PEEventSymbol>(interfaceWinRTEvent); // Only depends on accessor signatures - doesn't care if it's in a windowsruntime type. Assert.False(interfaceNormalEvent.IsWindowsRuntimeEvent); Assert.True(interfaceWinRTEvent.IsWindowsRuntimeEvent); var implementingType = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("C"); var implementingNormalEvent = implementingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("Normal")); var implementingWinRTEvent = implementingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("WinRT")); Assert.IsType<SourceCustomEventSymbol>(implementingNormalEvent); Assert.IsType<SourceCustomEventSymbol>(implementingWinRTEvent); // Based on kind of explicitly implemented interface event (other checks to be tested separately). Assert.False(implementingNormalEvent.IsWindowsRuntimeEvent); Assert.True(implementingWinRTEvent.IsWindowsRuntimeEvent); var subsitutedNormalEvent = implementingNormalEvent.ExplicitInterfaceImplementations.Single(); var subsitutedWinRTEvent = implementingWinRTEvent.ExplicitInterfaceImplementations.Single(); Assert.IsType<SubstitutedEventSymbol>(subsitutedNormalEvent); Assert.IsType<SubstitutedEventSymbol>(subsitutedWinRTEvent); // Based on original definition. Assert.False(subsitutedNormalEvent.IsWindowsRuntimeEvent); Assert.True(subsitutedWinRTEvent.IsWindowsRuntimeEvent); var retargetingAssembly = new RetargetingAssemblySymbol((SourceAssemblySymbol)comp.Assembly, isLinked: false); retargetingAssembly.SetCorLibrary(comp.Assembly.CorLibrary); var retargetingType = retargetingAssembly.GlobalNamespace.GetMember<NamedTypeSymbol>("C"); var retargetingNormalEvent = retargetingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("Normal")); var retargetingWinRTEvent = retargetingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("WinRT")); Assert.IsType<RetargetingEventSymbol>(retargetingNormalEvent); Assert.IsType<RetargetingEventSymbol>(retargetingWinRTEvent); // Based on underlying symbol. Assert.False(retargetingNormalEvent.IsWindowsRuntimeEvent); Assert.True(retargetingWinRTEvent.IsWindowsRuntimeEvent); }
internal PEModuleSymbol(RetargetingAssemblySymbol assemblySymbol, PEModule module, MetadataImportOptions importOptions, int ordinal) : this((AssemblySymbol)assemblySymbol, module, importOptions, ordinal) { Debug.Assert(ordinal > 0); }