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); }