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 TypeSymbol SubstituteTypeParameters(
PEModuleSymbol moduleSymbol,
TypeSymbol genericTypeDef,
ImmutableArray <KeyValuePair <TypeSymbol, ImmutableArray <ModifierInfo <TypeSymbol> > > > arguments,
ImmutableArray <bool> refersToNoPiaLocalType)
{
if (genericTypeDef is UnsupportedMetadataTypeSymbol)
{
return(genericTypeDef);
}
// Let's return unsupported metadata type if any argument is unsupported metadata type
foreach (var arg in arguments)
{
if (arg.Key.Kind == SymbolKind.ErrorType &&
arg.Key is UnsupportedMetadataTypeSymbol)
{
return(new UnsupportedMetadataTypeSymbol());
}
}
NamedTypeSymbol genericType = (NamedTypeSymbol)genericTypeDef;
//// See if it is or its enclosing type is a non-interface closed over NoPia local types.
//ImmutableArray<AssemblySymbol> linkedAssemblies = moduleSymbol.ContainingAssembly.GetLinkedReferencedAssemblies();
//bool noPiaIllegalGenericInstantiation = false;
//if (!linkedAssemblies.IsDefaultOrEmpty || moduleSymbol.Module.ContainsNoPiaLocalTypes())
//{
// NamedTypeSymbol typeToCheck = genericType;
// int argumentIndex = refersToNoPiaLocalType.Length - 1;
// do
// {
// if (!typeToCheck.IsInterface)
// {
// break;
// }
// else
// {
// argumentIndex -= typeToCheck.Arity;
// }
// typeToCheck = typeToCheck.ContainingType;
// }
// while ((object)typeToCheck != null);
// for (int i = argumentIndex; i >= 0; i--)
// {
// if (refersToNoPiaLocalType[i] ||
// (!linkedAssemblies.IsDefaultOrEmpty &&
// MetadataDecoder.IsOrClosedOverATypeFromAssemblies(arguments[i].Key, linkedAssemblies)))
// {
// noPiaIllegalGenericInstantiation = true;
// break;
// }
// }
//}
// Collect generic parameters for the type and its containers in the order
// that matches passed in arguments, i.e. sorted by the nesting.
ImmutableArray <TypeParameterSymbol> typeParameters = genericType.GetAllTypeParameters();
Debug.Assert(typeParameters.Length > 0);
if (typeParameters.Length != arguments.Length)
{
return(new UnsupportedMetadataTypeSymbol());
}
TypeMap substitution = new TypeMap(typeParameters, arguments.SelectAsArray(arg => new TypeWithModifiers(arg.Key, CSharpCustomModifier.Convert(arg.Value))));
NamedTypeSymbol constructedType = substitution.SubstituteNamedType(genericType);
//if (noPiaIllegalGenericInstantiation)
//{
// constructedType = new NoPiaIllegalGenericInstantiationSymbol(moduleSymbol, constructedType);
//}
return(constructedType);
}
internal override NamedTypeSymbol GetEffectiveBaseClass(ConsList <TypeParameterSymbol> inProgress)
{
return(_map.SubstituteNamedType(_substitutedFrom.GetEffectiveBaseClass(inProgress)));
}
