internal sealed override ImmutableArray <Symbol> GetMembersUnordered()
{
var builder = ArrayBuilder <Symbol> .GetInstance();
if (_unbound)
{
foreach (var t in OriginalDefinition.GetMembersUnordered())
{
if (t.Kind == SymbolKind.NamedType)
{
builder.Add(((NamedTypeSymbol)t).AsMember(this));
}
}
}
else
{
foreach (var t in OriginalDefinition.GetMembersUnordered())
{
builder.Add(t.SymbolAsMember(this));
}
}
if (IsTupleType)
{
builder = AddOrWrapTupleMembers(builder.ToImmutableAndFree());
Debug.Assert(builder is object);
}
return(builder.ToImmutableAndFree());
}
public sealed override ImmutableArray <Symbol> GetMembers()
{
var builder = ArrayBuilder <Symbol> .GetInstance();
if (_unbound)
{
// Preserve order of members.
foreach (var t in OriginalDefinition.GetMembers())
{
if (t.Kind == SymbolKind.NamedType)
{
builder.Add(((NamedTypeSymbol)t).AsMember(this));
}
}
}
else
{
foreach (var t in OriginalDefinition.GetMembers())
{
builder.Add(t.SymbolAsMember(this));
}
}
return(builder.ToImmutableAndFree());
}
private ImmutableArray <Symbol> GetMembersWorker(string name)
{
var originalMembers = OriginalDefinition.GetMembers(name);
if (originalMembers.IsDefaultOrEmpty)
{
return(originalMembers);
}
var builder = ArrayBuilder <Symbol> .GetInstance(originalMembers.Length);
foreach (var t in originalMembers)
{
builder.Add(t.SymbolAsMember(this));
}
var substitutedMembers = builder.ToImmutableAndFree();
// cache of size 8 seems reasonable here.
// considering that substituted methods have about 10 reference fields,
// reusing just one may make the cache profitable.
var cache = _lazyMembersByNameCache ??
(_lazyMembersByNameCache = new ConcurrentCache <string, ImmutableArray <Symbol> >(8));
cache.TryAdd(name, substitutedMembers);
return(substitutedMembers);
}
public override TypeSymbol GetTypeInferredDuringReduction(TypeParameterSymbol reducedFromTypeParameter)
{
// This will throw if API shouldn't be supported or there is a problem with the argument.
var notUsed = OriginalDefinition.GetTypeInferredDuringReduction(reducedFromTypeParameter);
Debug.Assert((object)notUsed == null && (object)OriginalDefinition.ReducedFrom != null);
return(this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type);
}
internal override ImmutableArray <Symbol> GetEarlyAttributeDecodingMembers()
{
return(_unbound
? GetMembers()
: OriginalDefinition
.GetEarlyAttributeDecodingMembers()
.SelectAsArray(s_symbolAsMemberFunc, this));
}
internal override NamedTypeSymbol FixedImplementationType(PEModuleBuilder emitModule)
{
// This occurs rarely, if ever. The scenario would be a generic struct
// containing a fixed-size buffer. Given the rarity there would be little
// benefit to "optimizing" the performance of this by caching the
// translated implementation type.
return((NamedTypeSymbol)_containingType.TypeSubstitution.SubstituteType(OriginalDefinition.FixedImplementationType(emitModule)).Type);
}
public sealed override ImmutableArray <NamedTypeSymbol> GetTypeMembers(
string name,
int arity
)
{
return(OriginalDefinition
.GetTypeMembers(name, arity)
.SelectAsArray((t, self) => t.AsMember(self), this));
}
internal override TypeWithAnnotations GetFieldType(ConsList <FieldSymbol> fieldsBeingBound)
{
if (_lazyType == null)
{
var type = _containingType.TypeSubstitution.SubstituteType(OriginalDefinition.GetFieldType(fieldsBeingBound));
Interlocked.CompareExchange(ref _lazyType, new TypeWithAnnotations.Boxed(type), null);
}
return(_lazyType.Value);
}
internal override ImmutableArray <Symbol> GetEarlyAttributeDecodingMembers(string name)
{
if (_unbound)
{
return(GetMembers(name));
}
var builder = ArrayBuilder <Symbol> .GetInstance();
foreach (var t in OriginalDefinition.GetEarlyAttributeDecodingMembers(name))
{
builder.Add(t.SymbolAsMember(this));
}
return(builder.ToImmutableAndFree());
}
internal sealed override bool TryGetThisParameter(out ParameterSymbol thisParameter)
{
// Required in EE scenarios. Specifically, the EE binds in the context of a
// substituted method, whereas the core compiler always binds within the
// context of an original definition.
// There should never be any reason to call this in normal compilation
// scenarios, but the behavior should be sensible if it does occur.
ParameterSymbol originalThisParameter;
if (!OriginalDefinition.TryGetThisParameter(out originalThisParameter))
{
thisParameter = null;
return(false);
}
thisParameter =
(object)originalThisParameter != null ? new ThisParameterSymbol(this) : null;
return(true);
}
/// <summary>
/// Returns an unbound generic type of this named type.
/// </summary>
public NamedTypeSymbol ConstructUnboundGenericType()
{
return(OriginalDefinition.AsUnboundGenericType());
}
internal override TypeSymbol GetFieldType(ConsList <FieldSymbol> fieldsBeingBound)
{
if ((object)_lazyType == null)
{
Interlocked.CompareExchange(ref _lazyType, _containingType.TypeSubstitution.SubstituteTypeWithTupleUnification(OriginalDefinition.GetFieldType(fieldsBeingBound)).Type, null);
}
return(_lazyType);
}
public override int GetHashCode()
{
return(Hash.Combine(_containingType, OriginalDefinition.GetHashCode()));
}
internal sealed override bool CallsAreOmitted(SyntaxTree syntaxTree)
{
return(OriginalDefinition.CallsAreOmitted(syntaxTree));
}
internal sealed override NamedTypeSymbol GetDeclaredBaseType(ConsList <Symbol> basesBeingResolved)
{
return(_unbound ? null : Map.SubstituteNamedType(OriginalDefinition.GetDeclaredBaseType(basesBeingResolved)));
}
internal sealed override ImmutableArray <NamedTypeSymbol> GetDeclaredInterfaces(ConsList <Symbol> basesBeingResolved)
{
return(_unbound ? ImmutableArray <NamedTypeSymbol> .Empty : Map.SubstituteNamedTypes(OriginalDefinition.GetDeclaredInterfaces(basesBeingResolved)));
}
internal sealed override ImmutableArray <NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList <Symbol> basesBeingResolved)
{
return(_unbound ? ImmutableArray <NamedTypeSymbol> .Empty : Map.SubstituteNamedTypes(OriginalDefinition.InterfacesNoUseSiteDiagnostics(basesBeingResolved)));
}
public override ImmutableArray <CSharpAttributeData> GetAttributes()
{
return(OriginalDefinition.GetAttributes());
}
internal override TypeSymbolWithAnnotations GetFieldType(ConsList <FieldSymbol> fieldsBeingBound)
{
if (_lazyType.IsNull)
{
_lazyType.InterlockedInitialize(_containingType.TypeSubstitution.SubstituteTypeWithTupleUnification(OriginalDefinition.GetFieldType(fieldsBeingBound)));
}
return(_lazyType.ToType());
}
internal sealed override ImmutableArray <NamedTypeSymbol> GetTypeMembersUnordered()
{
return(OriginalDefinition.GetTypeMembersUnordered().SelectAsArray((t, self) => t.AsMember(self), this));
}
internal override bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, Symbol owner, ref HashSet <TypeSymbol> checkedTypes) => OriginalDefinition.GetUnificationUseSiteDiagnosticRecursive(ref result, owner, ref checkedTypes);
