internal override Microsoft.CodeAnalysis.Emit.Generation CreateGeneration(
Microsoft.CodeAnalysis.Common.CommonCompilation commonCompilation,
Microsoft.CodeAnalysis.Emit.LocalVariableSyntaxProvider localDeclarations,
Microsoft.CodeAnalysis.Emit.LocalVariableMapProvider localMap)
{
var compilation = (Compilation)commonCompilation;
var previousToNext = new SymbolMatcher(
this.compilation.SourceAssembly,
compilation.SourceAssembly,
caseSensitive: true);
var delta = new Microsoft.CodeAnalysis.Emit.GenerationDelta(
previousToNext.Match(this.delta.TypesAdded),
previousToNext.Match(this.delta.EventsAdded),
previousToNext.Match(this.delta.FieldsAdded),
previousToNext.Match(this.delta.MethodsAdded),
previousToNext.Match(this.delta.PropertiesAdded),
tableEntriesAdded: this.delta.TableEntriesAdded,
blobStreamLengthAdded: this.delta.BlobStreamLengthAdded,
stringStreamLengthAdded: this.delta.StringStreamLengthAdded,
userStringStreamLengthAdded: this.delta.UserStringStreamLengthAdded,
guidStreamLengthAdded: this.delta.GuidStreamLengthAdded,
localNamesAddedOrChanged: this.delta.LocalNamesAddedOrChanged,
localNames: this.delta.LocalNames,
localDeclarationsAddedOrChanged: this.delta.LocalDeclarationsAddedOrChanged);
return Generation.CreateNextGeneration(
compilation,
this.OriginalMetadata,
this.Ordinal,
encId,
delta,
localDeclarations,
localMap);
}
internal override Microsoft.CodeAnalysis.Emit.Generation CreateGeneration(
Microsoft.CodeAnalysis.Common.CommonCompilation commonCompilation,
Microsoft.CodeAnalysis.Emit.LocalVariableSyntaxProvider localDeclarations,
Microsoft.CodeAnalysis.Emit.LocalVariableMapProvider localMap)
{
var compilation = (Compilation)commonCompilation;
var previousToNext = new SymbolMatcher(
this.compilation.SourceAssembly,
compilation.SourceAssembly,
caseSensitive: true);
var delta = new Microsoft.CodeAnalysis.Emit.GenerationDelta(
previousToNext.Match(this.delta.TypesAdded),
previousToNext.Match(this.delta.EventsAdded),
previousToNext.Match(this.delta.FieldsAdded),
previousToNext.Match(this.delta.MethodsAdded),
previousToNext.Match(this.delta.PropertiesAdded),
tableEntriesAdded: this.delta.TableEntriesAdded,
blobStreamLengthAdded: this.delta.BlobStreamLengthAdded,
stringStreamLengthAdded: this.delta.StringStreamLengthAdded,
userStringStreamLengthAdded: this.delta.UserStringStreamLengthAdded,
guidStreamLengthAdded: this.delta.GuidStreamLengthAdded,
localNamesAddedOrChanged: this.delta.LocalNamesAddedOrChanged,
localNames: this.delta.LocalNames,
localDeclarationsAddedOrChanged: this.delta.LocalDeclarationsAddedOrChanged);
return(Generation.CreateNextGeneration(
compilation,
this.OriginalMetadata,
this.Ordinal,
encId,
delta,
localDeclarations,
localMap));
}
/// <summary>
/// Matches the datatype of the symbol and the candidates
/// </summary>
/// <param name="symbol">The symbol.</param>
/// <returns>True if there are candidates left</returns>
private IEnumerable <IBaseConfigModel> MatchDataType(ISymbol symbol, IEnumerable <IBaseConfigModel> candidates)
{
var matches = new List <IBaseConfigModel>();
foreach (Member member in candidates)
{
var typeMatch = true;
if (member.DataType?.Custom == true && member.DataType.TypeName == ((Component)member.Parent).Name)
{
// returns the parentname, can be checked
typeMatch = SymbolMatcher.MatchDataType(symbol, symbol.ContainingSymbol.Name);
}
else if (member.DataType?.Custom == false)
{
typeMatch = SymbolMatcher.MatchDataType(symbol, member.DataType.Type.Name);
}
else
{
// Not able to determine the correct type at this time
}
if (member.DataType != null)
{
typeMatch &= SymbolMatcher.MatchCollection(symbol, member.DataType.Collection);
}
if (typeMatch)
{
matches.Add(member);
}
}
return(matches);
}
public PEDeltaAssemblyBuilder(
SourceAssemblySymbol sourceAssembly,
string outputName,
OutputKind outputKind,
ModulePropertiesForSerialization serializationProperties,
IEnumerable<ResourceDescription> manifestResources,
Func<AssemblySymbol, AssemblyIdentity> assemblySymbolMapper,
EmitBaseline previousGeneration,
IEnumerable<SemanticEdit> edits)
: base(sourceAssembly, outputName, outputKind, serializationProperties, manifestResources, assemblySymbolMapper, additionalTypes: ImmutableArray<NamedTypeSymbol>.Empty, metadataOnly:false)
{
var context = new EmitContext(this, null, new DiagnosticBag());
var module = previousGeneration.OriginalMetadata;
var compilation = sourceAssembly.DeclaringCompilation;
var metadataAssembly = compilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(module), MetadataImportOptions.All);
var metadataDecoder = new Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE.MetadataDecoder(metadataAssembly.PrimaryModule);
previousGeneration = EnsureInitialized(previousGeneration, metadataDecoder);
var matchToMetadata = new SymbolMatcher(previousGeneration.AnonymousTypeMap, sourceAssembly, context, metadataAssembly);
SymbolMatcher matchToPrevious = null;
if (previousGeneration.Ordinal > 0)
{
var previousAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly;
var previousContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag());
matchToPrevious = new SymbolMatcher(previousGeneration.AnonymousTypeMap, sourceAssembly, context, previousAssembly, previousContext);
}
this.previousDefinitions = new CSharpDefinitionMap(previousGeneration.OriginalMetadata.Module, edits, metadataDecoder, matchToMetadata, matchToPrevious);
this.previousGeneration = previousGeneration;
this.changes = new SymbolChanges(this.previousDefinitions, edits);
}
public AddedOrChangedMethodInfo MapTypes(SymbolMatcher map)
{
var mappedLocals = ImmutableArray.CreateRange(this.Locals, MapLocalInfo, map);
var mappedHoistedLocalSlots = StateMachineHoistedLocalSlotsOpt.IsDefault ? StateMachineHoistedLocalSlotsOpt : ImmutableArray.CreateRange(StateMachineHoistedLocalSlotsOpt, MapHoistedLocalSlot, map);
var mappedAwaiterSlots = StateMachineAwaiterSlotsOpt.IsDefault ? StateMachineAwaiterSlotsOpt : ImmutableArray.CreateRange(StateMachineAwaiterSlotsOpt, map.MapReference);
return new AddedOrChangedMethodInfo(this.MethodId, mappedLocals, LambdaDebugInfo, ClosureDebugInfo, StateMachineTypeNameOpt, mappedHoistedLocalSlots, mappedAwaiterSlots);
}
private static EncHoistedLocalInfo MapHoistedLocalSlot(EncHoistedLocalInfo info, SymbolMatcher map)
{
if (info.IsUnused)
{
return info;
}
return new EncHoistedLocalInfo(info.SlotInfo, map.MapReference(info.Type));
}
public void ConcurrentAccess()
{
var source =
@"class A
{
B F;
D P { get; set; }
void M(A a, B b, S s, I i) { }
delegate void D(S s);
class B { }
struct S { }
interface I { }
}
class B
{
A M<T, U>() where T : A where U : T, I { return null; }
event D E;
delegate void D(S s);
struct S { }
interface I { }
}";
var compilation0 = CreateCompilationWithMscorlib(source, options: TestOptions.DebugDll);
var compilation1 = CreateCompilationWithMscorlib(source, options: TestOptions.DebugDll);
var builder = ArrayBuilder<Symbol>.GetInstance();
var type = compilation1.GetMember<NamedTypeSymbol>("A");
builder.Add(type);
builder.AddRange(type.GetMembers());
type = compilation1.GetMember<NamedTypeSymbol>("B");
builder.Add(type);
builder.AddRange(type.GetMembers());
var members = builder.ToImmutableAndFree();
Assert.True(members.Length > 10);
for (int i = 0; i < 10; i++)
{
var matcher = new SymbolMatcher(
null,
compilation1.SourceAssembly,
default(EmitContext),
compilation0.SourceAssembly,
default(EmitContext));
var tasks = new Task[10];
for (int j = 0; j < tasks.Length; j++)
{
int startAt = i + j + 1;
tasks[j] = Task.Run(() =>
{
MatchAll(matcher, members, startAt);
Thread.Sleep(10);
});
}
Task.WaitAll(tasks);
}
}
/// <summary>
/// Match the parameters of the methodsymbol with the parameters of the method candidates
/// </summary>
/// <param name="symbol">The current method symbol</param>
/// <param name="candidates">The method candidates</param>
/// <returns>A list of matching members</returns>
private (IEnumerable <IBaseConfigModel> matchedCandidates, Dictionary <Member, List <ParameterMatch> > parameterMatches) MatchMethodParameters(IMethodSymbol symbol, IEnumerable <IBaseConfigModel> candidates)
{
var matches = new List <IBaseConfigModel>();
var parameterMatches = new Dictionary <Member, List <ParameterMatch> >();
foreach (Member candidate in candidates)
{
var componentName = ((Component)candidate.Parent).Name;
var parameterSymbols = symbol.Parameters;
// If no parameters are defined, match is valid by default.
if (candidate.Parameters.Count == 0)
{
matches.Add(candidate);
}
else
{
var methodParameterMatch = true;
foreach (var parameter in candidate.Parameters)
{
var hasParameterMatch = false;
foreach (var parameterSymbol in parameterSymbols)
{
var currentParameterMatch = SymbolMatcher.MatchMethodSymbolParameter(parameterSymbol, parameter, componentName);
hasParameterMatch |= currentParameterMatch;
if (currentParameterMatch && base.IsCustomAndParent(parameter.DataType, ((Component)candidate.Parent).Name))
{
// add custom types to parametermatches, for easier mapping later on.
if (!parameterMatches.ContainsKey(candidate))
{
parameterMatches.Add(candidate, new List <ParameterMatch>());
}
parameterMatches[candidate].Add(new ParameterMatch()
{
Parameter = parameter, ParameterSymbol = parameterSymbol
});
}
}
methodParameterMatch &= hasParameterMatch;
}
if (methodParameterMatch)
{
matches.Add(candidate);
}
}
}
return(matches, parameterMatches);
}
private static void MatchAll(SymbolMatcher matcher, ImmutableArray<Symbol> members, int startAt)
{
int n = members.Length;
for (int i = 0; i < n; i++)
{
var member = members[(i + startAt) % n];
var other = matcher.MapDefinition((Cci.IDefinition)member);
Assert.NotNull(other);
}
}
private static EncLocalInfo MapLocalInfo(EncLocalInfo info, SymbolMatcher map)
{
Debug.Assert(!info.IsDefault);
if (info.IsUnused)
{
Debug.Assert(info.Signature != null);
return info;
}
return new EncLocalInfo(info.SlotInfo, map.MapReference(info.Type), info.Constraints, info.Signature);
}
public EncVariableSlotAllocator(
CommonMessageProvider messageProvider,
SymbolMatcher symbolMap,
Func<SyntaxNode, SyntaxNode> syntaxMapOpt,
IMethodSymbolInternal previousTopLevelMethod,
DebugId methodId,
ImmutableArray<EncLocalInfo> previousLocals,
IReadOnlyDictionary<int, KeyValuePair<DebugId, int>> lambdaMapOpt,
IReadOnlyDictionary<int, DebugId> closureMapOpt,
string stateMachineTypeNameOpt,
int hoistedLocalSlotCount,
IReadOnlyDictionary<EncHoistedLocalInfo, int> hoistedLocalSlotsOpt,
int awaiterCount,
IReadOnlyDictionary<Cci.ITypeReference, int> awaiterMapOpt)
{
Debug.Assert(messageProvider != null);
Debug.Assert(symbolMap != null);
Debug.Assert(previousTopLevelMethod != null);
Debug.Assert(!previousLocals.IsDefault);
_messageProvider = messageProvider;
_symbolMap = symbolMap;
_syntaxMapOpt = syntaxMapOpt;
_previousLocals = previousLocals;
_previousTopLevelMethod = previousTopLevelMethod;
_methodId = methodId;
_hoistedLocalSlotsOpt = hoistedLocalSlotsOpt;
_hoistedLocalSlotCount = hoistedLocalSlotCount;
_stateMachineTypeNameOpt = stateMachineTypeNameOpt;
_awaiterCount = awaiterCount;
_awaiterMapOpt = awaiterMapOpt;
_lambdaMapOpt = lambdaMapOpt;
_closureMapOpt = closureMapOpt;
// Create a map from local info to slot.
var previousLocalInfoToSlot = new Dictionary<EncLocalInfo, int>();
for (int slot = 0; slot < previousLocals.Length; slot++)
{
var localInfo = previousLocals[slot];
Debug.Assert(!localInfo.IsDefault);
if (localInfo.IsUnused)
{
// Unrecognized or deleted local.
continue;
}
previousLocalInfoToSlot.Add(localInfo, slot);
}
_previousLocalSlots = previousLocalInfoToSlot;
}
/// <summary>
/// Matches the modifier of the symbol with the access modifier of the candidates. Remove the candidates that do not match the modifier.
/// </summary>
/// <param name="symbol">The symbol.</param>
/// <returns>True if there are any candidates left.</returns>
protected IEnumerable <IBaseConfigModel> MatchModifier(ISymbol symbol, IEnumerable <IBaseConfigModel> candidates)
{
var matches = new List <IBaseConfigModel>();
foreach (var candidate in candidates)
{
if (SymbolMatcher.MatchModifier(symbol, candidate.Modifier))
{
matches.Add(candidate);
}
}
return(matches);
}
/// <summary>
/// Matches the type of the symbol with the membertype of the candidates
/// </summary>
/// <param name="symbol">The symbol.</param>
/// <returns>True if there are any candidates left</returns>
private IEnumerable <IBaseConfigModel> MatchSymbolType(ISymbol symbol, IEnumerable <IBaseConfigModel> candidates)
{
var matches = new List <IBaseConfigModel>();
foreach (Member candidate in candidates)
{
if (SymbolMatcher.MatchSymbolKind(symbol, candidate.MemberType))
{
matches.Add(candidate);
}
}
return(matches);
}
/// <summary>
/// Добавляет правило, проверяющее текущий символ на соответствие типа и других условий
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="st"></param>
/// <param name="symbolIdentifier"></param>
/// <param name="symbolSubidentifier"></param>
/// <param name="matchFunc"></param>
/// <returns></returns>
public SymbolRuleStoreBuilder AddSimpleMatcher <T>(
string name,
SymbolType?st = null,
Enum symbolIdentifier = null,
Enum symbolSubidentifier = null,
Func <T, bool> matchFunc = null)
where T : Symbol
{
Dictionary.Add(name, SymbolMatcher.CreateSimpleMatcher(
st,
symbolIdentifier,
symbolSubidentifier,
matchFunc));
return(this);
}
public CSharpDefinitionMap(
PEModule module,
IEnumerable<SemanticEdit> edits,
MetadataDecoder metadataDecoder,
SymbolMatcher mapToMetadata,
SymbolMatcher mapToPrevious)
: base(module, edits)
{
Debug.Assert(mapToMetadata != null);
Debug.Assert(metadataDecoder != null);
this.mapToMetadata = mapToMetadata;
this.mapToPrevious = mapToPrevious ?? mapToMetadata;
this.metadataDecoder = metadataDecoder;
}
public DefinitionMap(
PEModule module,
MetadataDecoder metadataDecoder,
SymbolMatcher mapToMetadata,
SymbolMatcher mapToPrevious,
IReadOnlyDictionary<MethodSymbol, MethodDefinitionEntry> methodMap)
{
Debug.Assert(module != null);
Debug.Assert(metadataDecoder != null);
Debug.Assert(mapToMetadata != null);
Debug.Assert(methodMap != null);
this.module = module;
this.metadataDecoder = metadataDecoder;
this.mapToMetadata = mapToMetadata;
this.mapToPrevious = mapToPrevious ?? mapToMetadata;
this.methodMap = methodMap;
}
public void MatchDataTypeTest()
{
// Arrange
var helpers = new TestHelpers();
var fieldMember = helpers.GetMockMember(Constants.PrivateFieldMember, "TestMemberName");
var methodMember = helpers.GetMockMember(Constants.PublicMethodMember, "TestMemberName");
var namedTypeMember = helpers.GetMockMember(Constants.PublicNamedTypeMember, "TestMemberName");
var propertyMember = helpers.GetMockMember(Constants.PublicPropertyMember, "TestMemberName");
var eventMember = helpers.GetMockMember(Constants.PublicEventMember, "TestMemberName");
// Act
var fieldMatch = SymbolMatcher.MatchDataType(fieldMember, "String");
var methodMatch = SymbolMatcher.MatchDataType(methodMember, "Void");
var namedTypeMatch = SymbolMatcher.MatchDataType(namedTypeMember, "TestMemberName");
var propertyMatch = SymbolMatcher.MatchDataType(propertyMember, "String");
var eventMatch = SymbolMatcher.MatchDataType(eventMember, "DelegateMember");
var anyMatch = SymbolMatcher.MatchDataType(fieldMember, string.Empty);
var noFieldMatch = SymbolMatcher.MatchDataType(fieldMember, "wrong");
var noMethodMatch = SymbolMatcher.MatchDataType(methodMember, "wrong");
var noNamedTypeMatch = SymbolMatcher.MatchDataType(namedTypeMember, "wrong");
var noPropertyMatch = SymbolMatcher.MatchDataType(propertyMember, "wrong");
var noEventMatch = SymbolMatcher.MatchDataType(eventMember, "wrong");
// Assert
Assert.IsTrue(fieldMatch);
Assert.IsTrue(methodMatch);
Assert.IsTrue(namedTypeMatch);
Assert.IsTrue(propertyMatch);
Assert.IsTrue(eventMatch);
Assert.IsTrue(anyMatch);
Assert.IsFalse(noFieldMatch);
Assert.IsFalse(noMethodMatch);
Assert.IsFalse(noNamedTypeMatch);
Assert.IsFalse(noPropertyMatch);
Assert.IsFalse(noEventMatch);
}
public void MatchSymbolKindTest()
{
// Arrange
var helpers = new TestHelpers();
var fieldMember = helpers.GetMockMember(Constants.PrivateFieldMember, "TestMemberName");
var methodMember = helpers.GetMockMember(Constants.PublicMethodMember, "TestMemberName");
var namedTypeMember = helpers.GetMockMember(Constants.PublicNamedTypeMember, "TestMemberName");
var propertyMember = helpers.GetMockMember(Constants.PublicPropertyMember, "TestMemberName");
var eventMember = helpers.GetMockMember(Constants.PublicEventMember, "TestMemberName");
// Act
var fieldMatch = SymbolMatcher.MatchSymbolKind(fieldMember, MemberType.Field);
var methodMatch = SymbolMatcher.MatchSymbolKind(methodMember, MemberType.Method);
var namedTypeMatch = SymbolMatcher.MatchSymbolKind(namedTypeMember, MemberType.Class);
var propertyMatch = SymbolMatcher.MatchSymbolKind(propertyMember, MemberType.Property);
var eventMatch = SymbolMatcher.MatchSymbolKind(eventMember, MemberType.Event);
var anyMatch = SymbolMatcher.MatchSymbolKind(fieldMember, MemberType.Any);
var noFieldMatch = SymbolMatcher.MatchSymbolKind(fieldMember, MemberType.Property);
var noMethodMatch = SymbolMatcher.MatchSymbolKind(methodMember, MemberType.Field);
var noNamedTypeMatch = SymbolMatcher.MatchSymbolKind(namedTypeMember, MemberType.Field);
var noPropertyMatch = SymbolMatcher.MatchSymbolKind(propertyMember, MemberType.Field);
var noEventMatch = SymbolMatcher.MatchSymbolKind(eventMember, MemberType.Field);
// Assert
Assert.IsTrue(fieldMatch);
Assert.IsTrue(methodMatch);
Assert.IsTrue(namedTypeMatch);
Assert.IsTrue(propertyMatch);
Assert.IsTrue(eventMatch);
Assert.IsTrue(anyMatch);
Assert.IsFalse(noFieldMatch);
Assert.IsFalse(noMethodMatch);
Assert.IsFalse(noNamedTypeMatch);
Assert.IsFalse(noPropertyMatch);
Assert.IsFalse(noEventMatch);
}
public void MatchModifierTest()
{
// Arrange
var helpers = new TestHelpers();
var abstractMember = helpers.GetMockMember(Constants.AbstractMember, "TestMemberName");
var overrideMember = helpers.GetMockMember(Constants.OverrideMember, "TestMemberName");
var sealedMember = helpers.GetMockMember(Constants.SealedMember, "TestMemberName");
var staticMember = helpers.GetMockMember(Constants.StaticMember, "TestMemberName");
var virtualMember = helpers.GetMockMember(Constants.VirtualMember, "TestMemberName");
// Act
var abstractMatch = SymbolMatcher.MatchModifier(abstractMember, Models.Modifier.Abstract);
var overrideMatch = SymbolMatcher.MatchModifier(overrideMember, Models.Modifier.Override);
var sealedMatch = SymbolMatcher.MatchModifier(sealedMember, Models.Modifier.Sealed);
var staticMatch = SymbolMatcher.MatchModifier(staticMember, Models.Modifier.Static);
var virtualMatch = SymbolMatcher.MatchModifier(virtualMember, Models.Modifier.Virtual);
var anyMatch = SymbolMatcher.MatchModifier(abstractMember, Models.Modifier.Any);
var noAbstractMatch = SymbolMatcher.MatchModifier(abstractMember, Models.Modifier.Virtual);
var noOverrideMatch = SymbolMatcher.MatchModifier(overrideMember, Models.Modifier.Abstract);
var noSealedMatch = SymbolMatcher.MatchModifier(sealedMember, Models.Modifier.Abstract);
var noStaticMatch = SymbolMatcher.MatchModifier(staticMember, Models.Modifier.Abstract);
var noVirtualMatch = SymbolMatcher.MatchModifier(virtualMember, Models.Modifier.Abstract);
// Assert
Assert.IsTrue(abstractMatch);
Assert.IsTrue(overrideMatch);
Assert.IsTrue(sealedMatch);
Assert.IsTrue(staticMatch);
Assert.IsTrue(virtualMatch);
Assert.IsTrue(anyMatch);
Assert.IsFalse(noAbstractMatch);
Assert.IsFalse(noOverrideMatch);
Assert.IsFalse(noSealedMatch);
Assert.IsFalse(noStaticMatch);
Assert.IsFalse(noVirtualMatch);
}
public void SymbolMatcher_TypeArguments()
{
const string source =
@"class A<T>
{
class B<U>
{
static A<V> M<V>(A<U>.B<T> x, A<object>.S y)
{
return null;
}
static A<V> M<V>(A<U>.B<T> x, A<V>.S y)
{
return null;
}
}
struct S
{
}
}";
var compilation0 = CreateCompilationWithMscorlib(source, compOptions: TestOptions.UnoptimizedDll);
var compilation1 = CreateCompilationWithMscorlib(source, compOptions: TestOptions.UnoptimizedDll);
var matcher = new SymbolMatcher(
null,
compilation1.SourceAssembly,
default(Microsoft.CodeAnalysis.Emit.Context),
compilation0.SourceAssembly,
default(Microsoft.CodeAnalysis.Emit.Context));
var members = compilation1.GetMember<NamedTypeSymbol>("A.B").GetMembers("M");
Assert.Equal(members.Length, 2);
foreach (var member in members)
{
var other = matcher.MapDefinition((Cci.IMethodDefinition)member);
Assert.NotNull(other);
}
}
public void SymbolMatcher_Constraints()
{
const string source =
@"interface I<T> where T : I<T>
{
}
class C
{
static void M<T>(I<T> o) where T : I<T>
{
}
}";
var compilation0 = CreateCompilationWithMscorlib(source, compOptions: TestOptions.UnoptimizedDll);
var compilation1 = CreateCompilationWithMscorlib(source, compOptions: TestOptions.UnoptimizedDll);
var matcher = new SymbolMatcher(
null,
compilation1.SourceAssembly,
default(Microsoft.CodeAnalysis.Emit.Context),
compilation0.SourceAssembly,
default(Microsoft.CodeAnalysis.Emit.Context));
var member = compilation1.GetMember<MethodSymbol>("C.M");
var other = matcher.MapDefinition((Cci.IMethodDefinition)member);
Assert.NotNull(other);
}
public void SymbolMatcher_CustomModifiers()
{
var ilSource =
@".class public abstract A
{
.method public hidebysig specialname rtspecialname instance void .ctor() { ret }
.method public abstract virtual instance object modopt(A) [] F(int32 modopt(object) *p) { }
}";
var metadataRef = CompileIL(ilSource);
const string source =
@"unsafe class B : A
{
public override object[] F(int* p) { return null; }
}";
var compilation0 = CreateCompilationWithMscorlib(source, compOptions: TestOptions.UnoptimizedDll.WithAllowUnsafe(true), references: new[] { metadataRef });
var compilation1 = CreateCompilationWithMscorlib(source, compOptions: TestOptions.UnoptimizedDll.WithAllowUnsafe(true), references: new[] { metadataRef });
var member1 = compilation1.GetMember<MethodSymbol>("B.F");
Assert.Equal(((PointerTypeSymbol)member1.Parameters[0].Type).CustomModifiers.Length, 1);
Assert.Equal(((ArrayTypeSymbol)member1.ReturnType).CustomModifiers.Length, 1);
var matcher = new SymbolMatcher(
null,
compilation1.SourceAssembly,
default(Microsoft.CodeAnalysis.Emit.Context),
compilation0.SourceAssembly,
default(Microsoft.CodeAnalysis.Emit.Context));
var other = (MethodSymbol)matcher.MapDefinition((Cci.IMethodDefinition)member1);
Assert.NotNull(other);
Assert.Equal(((PointerTypeSymbol)other.Parameters[0].Type).CustomModifiers.Length, 1);
Assert.Equal(((ArrayTypeSymbol)other.ReturnType).CustomModifiers.Length, 1);
}
