public static ImmutableArray <T> SubstituteExplicitInterfaceImplementations <T>(ImmutableArray <T> unsubstitutedExplicitInterfaceImplementations, TypeMap map) where T : Symbol
{
var builder = ArrayBuilder <T> .GetInstance();
foreach (var unsubstitutedPropertyImplemented in unsubstitutedExplicitInterfaceImplementations)
{
var unsubstitutedInterfaceType = unsubstitutedPropertyImplemented.ContainingType;
Debug.Assert((object)unsubstitutedInterfaceType != null);
var explicitInterfaceType = map.SubstituteNamedType(unsubstitutedInterfaceType);
Debug.Assert((object)explicitInterfaceType != null);
var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified
T substitutedMemberImplemented = null;
foreach (var candidateMember in explicitInterfaceType.GetMembers(name))
{
if (candidateMember.OriginalDefinition == unsubstitutedPropertyImplemented.OriginalDefinition)
{
substitutedMemberImplemented = (T)candidateMember;
break;
}
}
Debug.Assert((object)substitutedMemberImplemented != null); //if it was an explicit implementation before the substitution, it should still be after
builder.Add(substitutedMemberImplemented);
}
return(builder.ToImmutableAndFree());
}
internal override NamedTypeSymbol GetEffectiveBaseClass(
ConsList <TypeParameterSymbol> inProgress
)
{
return(_map.SubstituteNamedType(
_underlyingTypeParameter.GetEffectiveBaseClass(inProgress)
));
}
internal FieldSymbol DefineCallSiteStorageSymbol(NamedTypeSymbol containerDefinition, NamedTypeSymbol delegateTypeOverMethodTypeParameters, TypeMap methodToContainerTypeParametersMap)
{
var fieldName = GeneratedNames.MakeDynamicCallSiteFieldName(_callSiteIdDispenser++);
var delegateTypeOverContainerTypeParameters = methodToContainerTypeParametersMap.SubstituteNamedType(delegateTypeOverMethodTypeParameters);
var callSiteType = _factory.Compilation.GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_CallSite_T).Construct(new[] { delegateTypeOverContainerTypeParameters });
var field = new SynthesizedFieldSymbol(containerDefinition, callSiteType, fieldName, isPublic: true, isStatic: true);
_factory.AddField(containerDefinition, field);
return _currentDynamicCallSiteContainer.IsGenericType ? field.AsMember(_currentDynamicCallSiteContainer) : field;
}
private static FieldSymbol SubstituteField(FieldSymbol field, TypeMap typeMap)
{
Debug.Assert(!field.IsStatic);
Debug.Assert(!field.IsReadOnly);
Debug.Assert(field.CustomModifiers.Length == 0);
// CONSIDER: Instead of digging fields out of the unsubstituted type and then performing substitution
// on each one individually, we could dig fields out of the substituted type.
return new EEDisplayClassFieldSymbol(typeMap.SubstituteNamedType(field.ContainingType), field.Name, typeMap.SubstituteType(field.Type));
}
private NamedTypeSymbol GetFixedDelegate(NamedTypeSymbol delegateType)
{
Debug.Assert((object)delegateType != null);
Debug.Assert(delegateType.IsDelegateType());
// We have a delegate where the input types use no unfixed parameters. Create
// a substitution context; we can substitute unfixed parameters for themselves
// since they don't actually occur in the inputs. (They may occur in the outputs,
// or there may be input parameters fixed to _unfixed_ method type variables.
// Both of those scenarios are legal.)
var fixedArguments = ArrayBuilder<TypeWithModifiers>.GetInstance(_methodTypeParameters.Length);
for (int iParam = 0; iParam < _methodTypeParameters.Length; iParam++)
{
fixedArguments.Add(new TypeWithModifiers(IsUnfixed(iParam) ? _methodTypeParameters[iParam] : _fixedResults[iParam]));
}
TypeMap typeMap = new TypeMap(_constructedContainingTypeOfMethod, _methodTypeParameters, fixedArguments.ToImmutableAndFree());
return typeMap.SubstituteNamedType(delegateType);
}
internal EENamedTypeSymbol(
NamespaceSymbol container,
NamedTypeSymbol baseType,
CSharpSyntaxNode syntax,
MethodSymbol currentFrame,
string typeName,
Func<MethodSymbol, EENamedTypeSymbol, ImmutableArray<MethodSymbol>> getMethods)
{
_container = container;
_baseType = baseType;
_syntax = syntax;
_name = typeName;
// What we want is to map all original type parameters to the corresponding new type parameters
// (since the old ones have the wrong owners). Unfortunately, we have a circular dependency:
// 1) Each new type parameter requires the entire map in order to be able to construct its constraint list.
// 2) The map cannot be constructed until all new type parameters exist.
// Our solution is to pass each new type parameter a lazy reference to the type map. We then
// initialize the map as soon as the new type parameters are available - and before they are
// handed out - so that there is never a period where they can require the type map and find
// it uninitialized.
var sourceType = currentFrame.ContainingType;
this.SourceTypeParameters = sourceType.GetAllTypeParameters();
TypeMap typeMap = null;
var getTypeMap = new Func<TypeMap>(() => typeMap);
_typeParameters = this.SourceTypeParameters.SelectAsArray(
(tp, i, arg) => (TypeParameterSymbol)new EETypeParameterSymbol(this, tp, i, getTypeMap),
(object)null);
typeMap = new TypeMap(this.SourceTypeParameters, _typeParameters);
VerifyTypeParameters(this, _typeParameters);
this.SubstitutedSourceType = typeMap.SubstituteNamedType(sourceType);
TypeParameterChecker.Check(this.SubstitutedSourceType, _typeParameters);
_methods = getMethods(currentFrame, this);
}