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