public ImmutableArray <Cci.ITypeDefinitionMember> GetSynthesizedMembers(Cci.ITypeDefinition container) { SynthesizedDefinitions defs = GetCacheOfSynthesizedDefinitions((TNamedTypeSymbol)container, addIfNotFound: false); if (defs == null) { return(ImmutableArray <Cci.ITypeDefinitionMember> .Empty); } return(defs.GetAllMembers()); }
internal override bool TryGetTypeHandle(Cci.ITypeDefinition def, out TypeDefinitionHandle handle) { if (mapToMetadata.MapDefinition(def) is PENamedTypeSymbol other) { handle = other.Handle; return(true); } handle = default; return(false); }
private static T VisitTypeMembers <T>( Cci.ITypeDefinition otherContainer, T member, Func <Cci.ITypeDefinition, IEnumerable <T> > getMembers, Func <T, T, bool> predicate) where T : class, Cci.ITypeDefinitionMember { // We could cache the members by name (see Matcher.VisitNamedTypeMembers) // but the assumption is this class is only used for types with few members // so caching is not necessary and linear search is acceptable. return(getMembers(otherContainer).FirstOrDefault(otherMember => predicate(member, otherMember))); }
internal override bool TryGetTypeHandle(Cci.ITypeDefinition def, out TypeDefinitionHandle handle) { var other = this.mapToMetadata.MapDefinition(def) as PENamedTypeSymbol; if ((object)other != null) { handle = other.Handle; return(true); } else { handle = default(TypeDefinitionHandle); return(false); } }
private IReadOnlyDictionary <AnonymousTypeKey, AnonymousTypeValue> MapAnonymousTypes(IReadOnlyDictionary <AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap) { Dictionary <AnonymousTypeKey, AnonymousTypeValue> result = new Dictionary <AnonymousTypeKey, AnonymousTypeValue>(); foreach (KeyValuePair <AnonymousTypeKey, AnonymousTypeValue> pair in anonymousTypeMap) { AnonymousTypeKey key = pair.Key; AnonymousTypeValue value = pair.Value; Cci.ITypeDefinition type = (Cci.ITypeDefinition)MapDefinition(value.Type); Debug.Assert(type != null); result.Add(key, new AnonymousTypeValue(value.Name, value.UniqueIndex, type)); } return(result); }
public VtblGap(Cci.ITypeDefinition containingType, string name) { this.ContainingType = containingType; _name = name; }
protected override IEnumerable <Cci.IFieldDefinition> GetFields(Cci.ITypeDefinition def) { return(def.GetFields(_otherContext)); }
protected override IEnumerable <Cci.INestedTypeDefinition> GetNestedTypes(Cci.ITypeDefinition def) { return(def.GetNestedTypes(_otherContext)); }
protected override IEnumerable <Cci.IFieldDefinition> GetFields(Cci.ITypeDefinition def) { var type = (PENamedTypeSymbol)def; return(type.GetFieldsToEmit().Cast <Cci.IFieldDefinition>()); }
protected override IEnumerable <Cci.INestedTypeDefinition> GetNestedTypes(Cci.ITypeDefinition def) { var type = (PENamedTypeSymbol)def; return(type.GetTypeMembers().Cast <Cci.INestedTypeDefinition>()); }
protected abstract IEnumerable <Cci.IFieldDefinition> GetFields(Cci.ITypeDefinition def);
protected abstract IEnumerable <Cci.INestedTypeDefinition> GetNestedTypes(Cci.ITypeDefinition def);
internal abstract bool TryGetTypeHandle(Cci.ITypeDefinition def, out TypeDefinitionHandle handle);
public VtblGap(Cci.ITypeDefinition containingType, string name) { this.ContainingType = containingType; this.name = name; }
static string getName(Cci.ITypeDefinition type) => ((Cci.INamedEntity)type).Name !;
/// <summary> /// Merges synthesized members generated during lowering of the current compilation with aggregate synthesized members /// from all previous source generations (gen >= 1). /// </summary> /// <remarks> /// Suppose {S -> {A, B, D}, T -> {E, F}} are all synthesized members in previous generations, /// and {S' -> {A', B', C}, U -> {G, H}} members are generated in the current compilation. /// /// Where X matches X' via this matcher, i.e. X' is from the new compilation and /// represents the same metadata entity as X in the previous compilation. /// /// Then the resulting collection shall have the following entries: /// {S' -> {A', B', C, D}, U -> {G, H}, T -> {E, F}} /// </remarks> internal ImmutableDictionary <Cci.ITypeDefinition, ImmutableArray <Cci.ITypeDefinitionMember> > MapSynthesizedMembers( ImmutableDictionary <Cci.ITypeDefinition, ImmutableArray <Cci.ITypeDefinitionMember> > previousMembers, ImmutableDictionary <Cci.ITypeDefinition, ImmutableArray <Cci.ITypeDefinitionMember> > newMembers) { // Note: we can't just return previous members if there are no new members, since we still need to map the symbols to the new compilation. if (previousMembers.Count == 0) { return(newMembers); } ImmutableDictionary <Cci.ITypeDefinition, ImmutableArray <Cci.ITypeDefinitionMember> > .Builder synthesizedMembersBuilder = ImmutableDictionary.CreateBuilder <Cci.ITypeDefinition, ImmutableArray <Cci.ITypeDefinitionMember> >(); synthesizedMembersBuilder.AddRange(newMembers); foreach (KeyValuePair <Cci.ITypeDefinition, ImmutableArray <Cci.ITypeDefinitionMember> > pair in previousMembers) { Cci.ITypeDefinition previousContainer = pair.Key; ImmutableArray <Cci.ITypeDefinitionMember> memberDefs = pair.Value; Cci.ITypeDefinition mappedContainer = (Cci.ITypeDefinition)MapDefinition(previousContainer); if (mappedContainer == null) { // No update to any member of the container type. synthesizedMembersBuilder.Add(previousContainer, memberDefs); continue; } if (!newMembers.TryGetValue(mappedContainer, out ImmutableArray <Cci.ITypeDefinitionMember> newSynthesizedMembers)) { // The container has been updated but the update didn't produce any synthesized members. synthesizedMembersBuilder.Add(mappedContainer, memberDefs); continue; } // The container has been updated and synthesized members produced. // They might be new or replacing existing ones. Merge existing with new. ArrayBuilder <Cci.ITypeDefinitionMember> memberBuilder = ArrayBuilder <Cci.ITypeDefinitionMember> .GetInstance(); memberBuilder.AddRange(newSynthesizedMembers); foreach (Cci.ITypeDefinitionMember memberDef in memberDefs) { Cci.ITypeDefinitionMember mappedMemberDef = (Cci.ITypeDefinitionMember)MapDefinition(memberDef); if (mappedMemberDef != null) { // If the matcher found a member in the current compilation corresponding to previous memberDef, // then the member has to be synthesized and produced as a result of a method update // and thus already contained in newSynthesizedMembers. Debug.Assert(newSynthesizedMembers.Contains(mappedMemberDef)); } else { memberBuilder.Add(memberDef); } } synthesizedMembersBuilder[mappedContainer] = memberBuilder.ToImmutableAndFree(); } return(synthesizedMembersBuilder.ToImmutable()); }