public IEnumerable<DependencyListEntry> InstantiateDependencies(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation)
{
switch (_id)
{
case ReadyToRunHelperId.GetGCStaticBase:
case ReadyToRunHelperId.GetThreadStaticBase:
{
// If the type has a lazy static constructor, we also need the non-GC static base
// because that's where the class constructor context is.
TypeDesc type = (TypeDesc)_target;
if (factory.TypeSystemContext.HasLazyStaticConstructor(type))
{
return new[] {
new DependencyListEntry(
factory.GenericLookup.TypeNonGCStaticBase(type).GetTarget(factory, typeInstantiation, methodInstantiation),
"Dictionary dependency"),
new DependencyListEntry(
_lookupSignature.GetTarget(factory, typeInstantiation, methodInstantiation),
"Dictionary dependency") };
}
}
break;
}
// All other generic lookups just depend on the thing they point to
return new[] { new DependencyListEntry(
_lookupSignature.GetTarget(factory, typeInstantiation, methodInstantiation),
"Dictionary dependency") };
}
public InstantiatedMethodIL(MethodIL methodIL, Instantiation typeInstantiation, Instantiation methodInstantiation)
{
_methodIL = methodIL;
_typeInstantiation = typeInstantiation;
_methodInstantiation = methodInstantiation;
}
/// <summary>
/// Returns a new instantiation that canonicalizes all types in <paramref name="instantiation"/>
/// if possible under the policy of '<paramref name="kind"/>'
/// </summary>
/// <param name="changed">True if the returned instantiation is different from '<paramref name="instantiation"/>'.</param>
public static Instantiation ConvertInstantiationToCanonForm(Instantiation instantiation, CanonicalFormKind kind, out bool changed)
{
TypeDesc[] newInstantiation = null;
for (int i = 0; i < instantiation.Length; i++)
{
TypeDesc typeToConvert = instantiation[i];
TypeDesc convertedType = ConvertToCanon(typeToConvert, kind);
if (typeToConvert != convertedType || newInstantiation != null)
{
if (newInstantiation == null)
{
newInstantiation = new TypeDesc[instantiation.Length];
for (int j = 0; j < i; j++)
newInstantiation[j] = instantiation[j];
}
newInstantiation[i] = convertedType;
}
}
changed = newInstantiation != null;
if (changed)
{
return new Instantiation(newInstantiation);
}
return instantiation;
}
protected override Instantiation ConvertInstantiationToCanonForm(Instantiation instantiation, CanonicalFormKind kind, out bool changed)
{
if (CanonMode == CanonicalizationMode.Standard)
return StandardCanonicalizationAlgorithm.ConvertInstantiationToCanonForm(instantiation, kind, out changed);
else
return RuntimeDeterminedCanonicalizationAlgorithm.ConvertInstantiationToCanonForm(instantiation, kind, out changed);
}
public static Instantiation ConvertInstantiationToSharedRuntimeForm(Instantiation instantiation, Instantiation openInstantiation, out bool changed)
{
Debug.Assert(instantiation.Length == openInstantiation.Length);
TypeDesc[] sharedInstantiation = null;
CanonicalFormKind currentPolicy = CanonicalFormKind.Specific;
CanonicalFormKind startLoopPolicy;
do
{
startLoopPolicy = currentPolicy;
for (int instantiationIndex = 0; instantiationIndex < instantiation.Length; instantiationIndex++)
{
TypeDesc typeToConvert = instantiation[instantiationIndex];
TypeSystemContext context = typeToConvert.Context;
TypeDesc canonForm = context.ConvertToCanon(typeToConvert, ref currentPolicy);
TypeDesc runtimeDeterminedForm = typeToConvert;
Debug.Assert(openInstantiation[instantiationIndex] is GenericParameterDesc);
if ((typeToConvert != canonForm) || typeToConvert.IsCanonicalType)
{
Debug.Assert(canonForm is DefType);
if (sharedInstantiation == null)
{
sharedInstantiation = new TypeDesc[instantiation.Length];
for (int i = 0; i < instantiationIndex; i++)
sharedInstantiation[i] = instantiation[i];
}
runtimeDeterminedForm = context.GetRuntimeDeterminedType(
(DefType)canonForm, (GenericParameterDesc)openInstantiation[instantiationIndex]);
}
if (sharedInstantiation != null)
{
sharedInstantiation[instantiationIndex] = runtimeDeterminedForm;
}
}
// Optimization: even if canonical policy changed, we don't actually need to re-run the loop
// for instantiations that only have a single element.
if (instantiation.Length == 1)
{
break;
}
} while (currentPolicy != startLoopPolicy);
changed = sharedInstantiation != null;
if (changed)
{
return new Instantiation(sharedInstantiation);
}
return instantiation;
}
internal InstantiatedMethod(MethodDesc methodDef, Instantiation instantiation)
{
Debug.Assert(!(methodDef is InstantiatedMethod));
_methodDef = methodDef;
Debug.Assert(instantiation.Length > 0);
_instantiation = instantiation;
}
public override DefType[] ComputeRuntimeInterfaces(TypeDesc _type)
{
ArrayType arrayType = (ArrayType)_type;
Debug.Assert(arrayType.IsSzArray);
Instantiation arrayInstantiation = new Instantiation(new TypeDesc[] { arrayType.ElementType });
TypeDesc arrayOfTInstantiation = _arrayOfTType.Context.GetInstantiatedType(_arrayOfTType, arrayInstantiation);
return arrayOfTInstantiation.RuntimeInterfaces;
}
public virtual FieldDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
FieldDesc field = this;
TypeDesc owningType = field.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
field = instantiatedOwningType.Context.GetFieldForInstantiatedType(field.GetTypicalFieldDefinition(), (InstantiatedType)instantiatedOwningType);
return field;
}
public InstantiatedMethodIL(MethodDesc owningMethod, MethodIL methodIL)
{
Debug.Assert(methodIL.GetMethodILDefinition() == methodIL);
Debug.Assert(owningMethod.HasInstantiation || owningMethod.OwningType.HasInstantiation);
Debug.Assert(owningMethod.GetTypicalMethodDefinition() == methodIL.OwningMethod);
_methodIL = methodIL;
_method = owningMethod;
_typeInstantiation = owningMethod.OwningType.Instantiation;
_methodInstantiation = owningMethod.Instantiation;
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
MethodSignatureBuilder sigBuilder = new MethodSignatureBuilder(_signature);
sigBuilder.ReturnType = _signature.ReturnType.InstantiateSignature(typeInstantiation, methodInstantiation);
for (int i = 0; i < _signature.Length; i++)
sigBuilder[i] = _signature[i].InstantiateSignature(typeInstantiation, methodInstantiation);
MethodSignature instantiatedSignature = sigBuilder.ToSignature();
if (instantiatedSignature != _signature)
return Context.GetFunctionPointerType(instantiatedSignature);
return this;
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
GenericParameter parameter = _module.MetadataReader.GetGenericParameter(_handle);
if (parameter.Parent.Kind == HandleKind.MethodDefinition)
{
return methodInstantiation[parameter.Index];
}
else
{
Debug.Assert(parameter.Parent.Kind == HandleKind.TypeDefinition);
return typeInstantiation[parameter.Index];
}
}
public static Instantiation ConvertInstantiationToCanonForm(Instantiation instantiation, CanonicalFormKind kind, out bool changed)
{
TypeDesc[] canonInstantiation = null;
CanonicalFormKind currentKind = kind;
CanonicalFormKind startLoopKind;
// This logic is wrapped in a loop because we might potentially need to restart canonicalization if the policy
// changes due to one of the instantiation arguments already being universally canonical.
do
{
startLoopKind = currentKind;
for (int instantiationIndex = 0; instantiationIndex < instantiation.Length; instantiationIndex++)
{
TypeDesc typeToConvert = instantiation[instantiationIndex];
TypeDesc canonForm = ConvertToCanon(typeToConvert, ref currentKind);
if (typeToConvert != canonForm || canonInstantiation != null)
{
if (canonInstantiation == null)
{
canonInstantiation = new TypeDesc[instantiation.Length];
for (int i = 0; i < instantiationIndex; i++)
canonInstantiation[i] = instantiation[i];
}
canonInstantiation[instantiationIndex] = canonForm;
}
}
// Optimization: even if canonical policy changed, we don't actually need to re-run the loop
// for instantiations that only have a single element.
if (instantiation.Length == 1)
{
break;
}
} while (currentKind != startLoopKind);
changed = canonInstantiation != null;
if (changed)
{
return new Instantiation(canonInstantiation);
}
return instantiation;
}
public NoMetadataType(TypeSystemContext context, RuntimeTypeHandle genericTypeDefinition, DefType genericTypeDefinitionAsDefType, Instantiation instantiation, int hashcode)
{
_hashcode = hashcode;
_context = context;
_genericTypeDefinition = genericTypeDefinition;
_genericTypeDefinitionAsDefType = genericTypeDefinitionAsDefType;
if (_genericTypeDefinitionAsDefType == null)
_genericTypeDefinitionAsDefType = this;
_instantiation = instantiation;
// Instantiation must either be:
// Something valid (if the type is generic, or a generic type definition)
// or Empty (if the type isn't a generic of any form)
unsafe
{
Debug.Assert(((_instantiation.Length > 0) && _genericTypeDefinition.ToEETypePtr()->IsGenericTypeDefinition) ||
((_instantiation.Length == 0) && !_genericTypeDefinition.ToEETypePtr()->IsGenericTypeDefinition));
}
}
/// <summary>
/// Converts an instantiation into its canonical form.
/// </summary>
public Instantiation ConvertInstantiationToCanonForm(Instantiation instantiation, CanonicalFormKind kind)
{
return(ConvertInstantiationToCanonForm(instantiation, kind, out _));
}
public override ISymbolNode GetTarget(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation)
{
MethodDesc instantiatedMethod = _method.InstantiateSignature(typeInstantiation, methodInstantiation);
return factory.MethodGenericDictionary(instantiatedMethod);
}
public override ISymbolNode GetTarget(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation)
{
var instantiatedType = (MetadataType)_type.InstantiateSignature(typeInstantiation, methodInstantiation);
return factory.TypeGCStaticsSymbol(instantiatedType);
}
public override ISymbolNode GetTarget(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation)
{
MethodDesc instantiatedMethod = _method.InstantiateSignature(typeInstantiation, methodInstantiation);
// https://github.com/dotnet/corert/issues/2342 - we put a pointer to the virtual call helper into the dictionary
// but this should be something that will let us compute the target of the dipatch (e.g. interface dispatch cell).
return factory.ReadyToRunHelper(ReadyToRunHelperId.VirtualCall, instantiatedMethod);
}
public override MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc owningType = this.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
return ((ArrayType)instantiatedOwningType).GetArrayMethod(_kind);
else
return this;
}
// This constructor is a performance optimization - it allows supplying the hash code if it has already
// been computed prior to the allocation of this type. The supplied hash code still has to match the
// hash code this type would compute on it's own (and we assert to enforce that).
internal InstantiatedMethod(MethodDesc methodDef, Instantiation instantiation, int hashcode)
: this(methodDef, instantiation)
{
SetHashCode(hashcode);
}
public virtual MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
Instantiation instantiation = Instantiation;
TypeDesc[] clone = null;
for (int i = 0; i < instantiation.Length; i++)
{
TypeDesc uninst = instantiation[i];
TypeDesc inst = uninst.InstantiateSignature(typeInstantiation, methodInstantiation);
if (inst != uninst)
{
if (clone == null)
{
clone = new TypeDesc[instantiation.Length];
for (int j = 0; j < clone.Length; j++)
{
clone[j] = instantiation[j];
}
}
clone[i] = inst;
}
}
MethodDesc method = this;
TypeDesc owningType = method.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
{
method = Context.GetMethodForInstantiatedType(method.GetTypicalMethodDefinition(), (InstantiatedType)instantiatedOwningType);
if (clone == null && instantiation.Length != 0)
return Context.GetInstantiatedMethod(method, instantiation);
}
return (clone == null) ? method : Context.GetInstantiatedMethod(method.GetMethodDefinition(), new Instantiation(clone));
}
// Todo: This is looking up the hierarchy to DefType and ParameterizedType. It should really
// call a virtual or an outside type to handle those parts
internal bool RetrieveRuntimeTypeHandleIfPossible()
{
TypeDesc type = this;
if (!type.RuntimeTypeHandle.IsNull())
{
return(true);
}
TypeBuilderState state = GetTypeBuilderStateIfExist();
if (state != null && state.AttemptedAndFailedToRetrieveTypeHandle)
{
return(false);
}
if (type is DefType)
{
DefType typeAsDefType = (DefType)type;
TypeDesc typeDefinition = typeAsDefType.GetTypeDefinition();
RuntimeTypeHandle typeDefHandle = typeDefinition.RuntimeTypeHandle;
if (typeDefHandle.IsNull())
{
#if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
NativeFormat.NativeFormatType mdType = typeDefinition as NativeFormat.NativeFormatType;
if (mdType != null)
{
// Look up the runtime type handle in the module metadata
if (TypeLoaderEnvironment.Instance.TryGetNamedTypeForMetadata(new QTypeDefinition(mdType.MetadataReader, mdType.Handle), out typeDefHandle))
{
typeDefinition.SetRuntimeTypeHandleUnsafe(typeDefHandle);
}
}
#endif
#if ECMA_METADATA_SUPPORT
Ecma.EcmaType ecmaType = typeDefinition as Ecma.EcmaType;
if (ecmaType != null)
{
// Look up the runtime type handle in the module metadata
if (TypeLoaderEnvironment.Instance.TryGetNamedTypeForMetadata(new QTypeDefinition(ecmaType.MetadataReader, ecmaType.Handle), out typeDefHandle))
{
typeDefinition.SetRuntimeTypeHandleUnsafe(typeDefHandle);
}
}
#endif
}
if (!typeDefHandle.IsNull())
{
Instantiation instantiation = typeAsDefType.Instantiation;
if ((instantiation.Length > 0) && !typeAsDefType.IsGenericDefinition)
{
// Generic type. First make sure we have type handles for the arguments, then check
// the instantiation.
bool argumentsRegistered = true;
bool arrayArgumentsFound = false;
for (int i = 0; i < instantiation.Length; i++)
{
if (!instantiation[i].RetrieveRuntimeTypeHandleIfPossible())
{
argumentsRegistered = false;
arrayArgumentsFound = arrayArgumentsFound || (instantiation[i] is ArrayType);
}
}
RuntimeTypeHandle rtth;
// If at least one of the arguments is not known to the runtime, we take a slower
// path to compare the current type we need a handle for to the list of generic
// types statically available, by loading them as DefTypes and doing a DefType comparaison
if ((argumentsRegistered && TypeLoaderEnvironment.Instance.TryLookupConstructedGenericTypeForComponents(new TypeLoaderEnvironment.HandleBasedGenericTypeLookup(typeAsDefType), out rtth)) ||
(arrayArgumentsFound && TypeLoaderEnvironment.Instance.TryLookupConstructedGenericTypeForComponents(new TypeLoaderEnvironment.DefTypeBasedGenericTypeLookup(typeAsDefType), out rtth)))
{
typeAsDefType.SetRuntimeTypeHandleUnsafe(rtth);
return(true);
}
}
else
{
// Nongeneric, or generic type def types are just the type handle of the type definition as found above
type.SetRuntimeTypeHandleUnsafe(typeDefHandle);
return(true);
}
}
}
else if (type is ParameterizedType)
{
ParameterizedType typeAsParameterType = (ParameterizedType)type;
if (typeAsParameterType.ParameterType.RetrieveRuntimeTypeHandleIfPossible())
{
RuntimeTypeHandle rtth;
if ((type is ArrayType &&
(TypeLoaderEnvironment.Instance.TryGetArrayTypeForElementType_LookupOnly(typeAsParameterType.ParameterType.RuntimeTypeHandle, type.IsMdArray, type.IsMdArray ? ((ArrayType)type).Rank : -1, out rtth) ||
TypeLoaderEnvironment.Instance.TryGetArrayTypeHandleForNonDynamicArrayTypeFromTemplateTable(type as ArrayType, out rtth)))
||
(type is PointerType && TypeSystemContext.PointerTypesCache.TryGetValue(typeAsParameterType.ParameterType.RuntimeTypeHandle, out rtth)))
{
typeAsParameterType.SetRuntimeTypeHandleUnsafe(rtth);
return(true);
}
else if (type is ByRefType)
{
// Byref types don't have any associated type handles, so return success at this point
// since we were able to resolve the typehandle of the element type
return(true);
}
}
}
else if (type is SignatureVariable)
{
// SignatureVariables do not have RuntimeTypeHandles
}
else
{
Debug.Assert(false);
}
// Make a note on the type build state that we have attempted to retrieve RuntimeTypeHandle but there is not one
GetOrCreateTypeBuilderState().AttemptedAndFailedToRetrieveTypeHandle = true;
return(false);
}
/// <summary>
/// Instantiate an array of TypeDescs over typeInstantiation and methodInstantiation
/// </summary>
public static T[] InstantiateTypeArray <T>(T[] uninstantiatedTypes, Instantiation typeInstantiation, Instantiation methodInstantiation) where T : TypeDesc
{
T[] clone = null;
for (int i = 0; i < uninstantiatedTypes.Length; i++)
{
T uninst = uninstantiatedTypes[i];
TypeDesc inst = uninst.InstantiateSignature(typeInstantiation, methodInstantiation);
if (inst != uninst)
{
if (clone == null)
{
clone = new T[uninstantiatedTypes.Length];
for (int j = 0; j < clone.Length; j++)
{
clone[j] = uninstantiatedTypes[j];
}
}
clone[i] = (T)inst;
}
}
return(clone != null ? clone : uninstantiatedTypes);
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc[] clone = null;
for (int i = 0; i < _instantiation.Length; i++)
{
TypeDesc uninst = _instantiation[i];
TypeDesc inst = uninst.InstantiateSignature(typeInstantiation, methodInstantiation);
if (inst != uninst)
{
if (clone == null)
{
clone = new TypeDesc[_instantiation.Length];
for (int j = 0; j < clone.Length; j++)
{
clone[j] = _instantiation[j];
}
}
clone[i] = inst;
}
}
return((clone == null) ? this : _typeDef.Context.GetInstantiatedType(_typeDef, new Instantiation(clone)));
}
public virtual FieldDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
FieldDesc field = this;
TypeDesc owningType = field.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
{
field = instantiatedOwningType.Context.GetFieldForInstantiatedType(field.GetTypicalFieldDefinition(), (InstantiatedType)instantiatedOwningType);
}
return(field);
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc instantiatedElementType = this.ElementType.InstantiateSignature(typeInstantiation, methodInstantiation);
return(instantiatedElementType.Context.GetArrayType(instantiatedElementType, _rank));
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
return methodInstantiation.IsNull ? this : methodInstantiation[Index];
}
/// <summary>
/// Converts an instantiation into its canonical form. Returns the canonical instantiation. The '<paramref name="changed"/>'
/// parameter indicates whether the returned canonical instantiation is different from the specific instantiation
/// passed as the input.
/// </summary>
protected internal virtual Instantiation ConvertInstantiationToCanonForm(Instantiation instantiation, CanonicalFormKind kind, out bool changed)
{
throw new NotSupportedException();
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
if (_runtimeDeterminedDetailsType.Kind == GenericParameterKind.Type)
{
return typeInstantiation[_runtimeDeterminedDetailsType.Index];
}
else
{
Debug.Assert(_runtimeDeterminedDetailsType.Kind == GenericParameterKind.Method);
return methodInstantiation[_runtimeDeterminedDetailsType.Index];
}
}
static public InstantiatedType MakeInstantiatedType(this MetadataType typeDef, Instantiation instantiation)
{
return typeDef.Context.GetInstantiatedType(typeDef, instantiation);
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
MethodSignatureBuilder sigBuilder = new MethodSignatureBuilder(_signature);
sigBuilder.ReturnType = _signature.ReturnType.InstantiateSignature(typeInstantiation, methodInstantiation);
for (int i = 0; i < _signature.Length; i++)
{
sigBuilder[i] = _signature[i].InstantiateSignature(typeInstantiation, methodInstantiation);
}
MethodSignature instantiatedSignature = sigBuilder.ToSignature();
if (instantiatedSignature != _signature)
{
return(Context.GetFunctionPointerType(instantiatedSignature));
}
return(this);
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc instantiatedParameterType = this.ParameterType.InstantiateSignature(typeInstantiation, methodInstantiation);
return instantiatedParameterType.MakeByRefType();
}
public static InstantiatedType MakeInstantiatedType(this MetadataType typeDef, Instantiation instantiation)
{
return(typeDef.Context.GetInstantiatedType(typeDef, instantiation));
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
return typeInstantiation.IsNull ? this : typeInstantiation[Index];
}
public static InstantiatedMethod MakeInstantiatedMethod(this MethodDesc methodDef, Instantiation instantiation)
{
return(methodDef.Context.GetInstantiatedMethod(methodDef, instantiation));
}
public override TypeDesc GetNonRuntimeDeterminedTypeFromRuntimeDeterminedSubtypeViaSubstitution(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
if (_runtimeDeterminedDetailsType.Kind == GenericParameterKind.Type)
{
return(typeInstantiation[_runtimeDeterminedDetailsType.Index]);
}
else
{
Debug.Assert(_runtimeDeterminedDetailsType.Kind == GenericParameterKind.Method);
return(methodInstantiation[_runtimeDeterminedDetailsType.Index]);
}
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc elementType = this.ElementType;
TypeDesc instantiatedElementType = elementType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (instantiatedElementType != elementType)
{
return(Context.GetArrayType(instantiatedElementType, _rank));
}
return(this);
}
public abstract ISymbolNode GetTarget(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation);
public override MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc owningType = this.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
{
return(((ArrayType)instantiatedOwningType).GetArrayMethod(_kind));
}
else
{
return(this);
}
}
public override ISymbolNode GetTarget(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation)
{
// We are getting a constructed type symbol because this might be something passed to newobj.
TypeDesc instantiatedType = _type.InstantiateSignature(typeInstantiation, methodInstantiation);
return factory.ConstructedTypeSymbol(instantiatedType);
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc instantiatedParameterType = this.ParameterType.InstantiateSignature(typeInstantiation, methodInstantiation);
return instantiatedParameterType.Context.GetPointerType(instantiatedParameterType);
}
private static bool CanCastByVarianceToInterfaceOrDelegate(this TypeDesc thisType, TypeDesc otherType, StackOverflowProtect protectInput)
{
if (!thisType.HasSameTypeDefinition(otherType))
{
return(false);
}
var stackOverflowProtectKey = new CastingPair(thisType, otherType);
if (protectInput != null)
{
if (protectInput.Contains(stackOverflowProtectKey))
{
return(false);
}
}
StackOverflowProtect protect = new StackOverflowProtect(stackOverflowProtectKey, protectInput);
Instantiation instantiationThis = thisType.Instantiation;
Instantiation instantiationTarget = otherType.Instantiation;
Instantiation instantiationOpen = thisType.GetTypeDefinition().Instantiation;
Debug.Assert(instantiationThis.Length == instantiationTarget.Length &&
instantiationThis.Length == instantiationOpen.Length);
for (int i = 0; i < instantiationThis.Length; i++)
{
TypeDesc arg = instantiationThis[i];
TypeDesc targetArg = instantiationTarget[i];
if (arg != targetArg)
{
GenericParameterDesc openArgType = (GenericParameterDesc)instantiationOpen[i];
switch (openArgType.Variance)
{
case GenericVariance.Covariant:
if (!arg.IsBoxedAndCanCastTo(targetArg, protect))
{
return(false);
}
break;
case GenericVariance.Contravariant:
if (!targetArg.IsBoxedAndCanCastTo(arg, protect))
{
return(false);
}
break;
default:
// non-variant
Debug.Assert(openArgType.Variance == GenericVariance.None);
return(false);
}
}
}
return(true);
}
private static bool VerifyGenericParamConstraint(Instantiation typeInstantiation, Instantiation methodInstantiation, GenericParameterDesc genericParam, TypeDesc instantiationParam)
{
GenericConstraints constraints = genericParam.Constraints;
// Check class constraint
if ((constraints & GenericConstraints.ReferenceTypeConstraint) != 0)
{
if (!instantiationParam.IsGCPointer)
{
return(false);
}
}
// Check default constructor constraint
if ((constraints & GenericConstraints.DefaultConstructorConstraint) != 0)
{
if (!instantiationParam.HasExplicitOrImplicitDefaultConstructor())
{
return(false);
}
}
// Check struct constraint
if ((constraints & GenericConstraints.NotNullableValueTypeConstraint) != 0)
{
if (!instantiationParam.IsValueType)
{
return(false);
}
if (instantiationParam.IsNullable)
{
return(false);
}
}
foreach (var constraintType in genericParam.TypeConstraints)
{
var instantiatedType = constraintType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (!instantiationParam.CanCastTo(instantiatedType))
{
return(false);
}
}
return(true);
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc[] clone = null;
for (int i = 0; i < _instantiation.Length; i++)
{
TypeDesc uninst = _instantiation[i];
TypeDesc inst = uninst.InstantiateSignature(typeInstantiation, methodInstantiation);
if (inst != uninst)
{
if (clone == null)
{
clone = new TypeDesc[_instantiation.Length];
for (int j = 0; j < clone.Length; j++)
{
clone[j] = _instantiation[j];
}
}
clone[i] = inst;
}
}
return (clone == null) ? this : _genericTypeDefinitionAsDefType.Context.ResolveGenericInstantiation(_genericTypeDefinitionAsDefType, new Instantiation(clone));
}
public override TypeDesc GetNonRuntimeDeterminedTypeFromRuntimeDeterminedSubtypeViaSubstitution(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
Debug.Assert(false);
return(this);
}
// This constructor is a performance optimization - it allows supplying the hash code if it has already
// been computed prior to the allocation of this type. The supplied hash code still has to match the
// hash code this type would compute on it's own (and we assert to enforce that).
internal InstantiatedMethod(MethodDesc methodDef, Instantiation instantiation, int hashcode)
: this(methodDef, instantiation)
{
SetHashCode(hashcode);
}
protected override int ComputeHashCode()
{
return(TypeHashingAlgorithms.ComputeMethodHashCode(OwningType.GetHashCode(), Instantiation.ComputeGenericInstanceHashCode(TypeHashingAlgorithms.ComputeNameHashCode(Name))));
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc instantiatedParameterType = this.ParameterType.InstantiateSignature(typeInstantiation, methodInstantiation);
return(instantiatedParameterType.MakeByRefType());
}
public InstantiatedTypeKey(TypeDesc typeDef, Instantiation instantiation)
{
_typeDef = typeDef;
_instantiation = instantiation;
}
static public InstantiatedMethod MakeInstantiatedMethod(this MethodDesc methodDef, Instantiation instantiation)
{
return methodDef.Context.GetInstantiatedMethod(methodDef, instantiation);
}
public InstantiatedMethod GetInstantiatedMethod(MethodDesc methodDef, Instantiation instantiation)
{
Debug.Assert(!(methodDef is InstantiatedMethod));
return(_instantiatedMethods.GetOrCreateValue(new InstantiatedMethodKey(methodDef, instantiation)));
}
public virtual TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
return this;
}
public virtual MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
Instantiation instantiation = Instantiation;
TypeDesc[] clone = null;
for (int i = 0; i < instantiation.Length; i++)
{
TypeDesc uninst = instantiation[i];
TypeDesc inst = uninst.InstantiateSignature(typeInstantiation, methodInstantiation);
if (inst != uninst)
{
if (clone == null)
{
clone = new TypeDesc[instantiation.Length];
for (int j = 0; j < clone.Length; j++)
{
clone[j] = instantiation[j];
}
}
clone[i] = inst;
}
}
MethodDesc method = this;
TypeDesc owningType = method.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
{
method = Context.GetMethodForInstantiatedType(method.GetTypicalMethodDefinition(), (InstantiatedType)instantiatedOwningType);
if (clone == null && instantiation.Length != 0)
{
return(Context.GetInstantiatedMethod(method, instantiation));
}
}
return((clone == null) ? method : Context.GetInstantiatedMethod(method.GetMethodDefinition(), new Instantiation(clone)));
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc instantiatedParameterType = this.ParameterType.InstantiateSignature(typeInstantiation, methodInstantiation);
return(instantiatedParameterType.Context.GetPointerType(instantiatedParameterType));
}
public virtual TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
return(this);
}
public InstantiationContext(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeInstantiation = typeInstantiation;
MethodInstantiation = methodInstantiation;
}
public TypeDesc ResolveRuntimeTypeHandle(RuntimeTypeHandle rtth)
{
TypeDesc returnedType;
if (_runtimeTypeHandleResolutionCache.TryGetValue(rtth, out returnedType))
{
return(returnedType);
}
if (rtth.Equals(CanonType.RuntimeTypeHandle))
{
returnedType = CanonType;
}
else if (rtth.Equals(UniversalCanonType.RuntimeTypeHandle))
{
returnedType = UniversalCanonType;
}
else if (RuntimeAugments.IsGenericTypeDefinition(rtth))
{
returnedType = TryGetMetadataBasedTypeFromRuntimeTypeHandle_Uncached(rtth);
if (returnedType == null)
{
unsafe
{
TypeDesc[] genericParameters = new TypeDesc[rtth.ToEETypePtr()->GenericArgumentCount];
for (int i = 0; i < genericParameters.Length; i++)
{
genericParameters[i] = GetSignatureVariable(i, false);
}
returnedType = new NoMetadataType(this, rtth, null, new Instantiation(genericParameters), rtth.GetHashCode());
}
}
}
else if (RuntimeAugments.IsGenericType(rtth))
{
RuntimeTypeHandle typeDefRuntimeTypeHandle;
RuntimeTypeHandle[] genericArgRuntimeTypeHandles;
typeDefRuntimeTypeHandle = RuntimeAugments.GetGenericInstantiation(rtth, out genericArgRuntimeTypeHandles);
DefType typeDef = (DefType)ResolveRuntimeTypeHandle(typeDefRuntimeTypeHandle);
Instantiation genericArgs = ResolveRuntimeTypeHandles(genericArgRuntimeTypeHandles);
returnedType = ResolveGenericInstantiation(typeDef, genericArgs);
}
else if (RuntimeAugments.IsArrayType(rtth))
{
RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth);
TypeDesc elementType = ResolveRuntimeTypeHandle(elementTypeHandle);
unsafe
{
if (rtth.ToEETypePtr()->IsSzArray)
{
returnedType = GetArrayType(elementType);
}
else
{
returnedType = GetArrayType(elementType, rtth.ToEETypePtr()->ArrayRank);
}
}
}
else if (RuntimeAugments.IsUnmanagedPointerType(rtth))
{
RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth);
TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle);
returnedType = GetPointerType(targetType);
}
else if (RuntimeAugments.IsByRefType(rtth))
{
RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth);
TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle);
returnedType = GetByRefType(targetType);
}
else
{
returnedType = TryGetMetadataBasedTypeFromRuntimeTypeHandle_Uncached(rtth);
if (returnedType == null)
{
returnedType = new NoMetadataType(this, rtth, null, Instantiation.Empty, rtth.GetHashCode());
}
}
// We either retrieved an existing DefType that is already registered with the runtime
// or one that is not associated with an MethodTable yet. If it's not associated, associate it.
if (returnedType.RuntimeTypeHandle.IsNull())
{
TypeBuilderState state = returnedType.GetTypeBuilderStateIfExist();
bool skipStoringRuntimeTypeHandle = false;
// If we've already attempted to lookup and failed to retrieve this type handle, we
// may have already decided to create a new one. In that case, do not attempt to abort
// that creation process as it may have already begun the process of type creation
if (state != null && state.AttemptedAndFailedToRetrieveTypeHandle)
{
skipStoringRuntimeTypeHandle = true;
}
if (!skipStoringRuntimeTypeHandle)
{
returnedType.SetRuntimeTypeHandleUnsafe(rtth);
}
}
_runtimeTypeHandleResolutionCache.Add(rtth, returnedType);
return(returnedType.WithDebugName());
}
public override TypeDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
TypeDesc instantiatedElementType = this.ElementType.InstantiateSignature(typeInstantiation, methodInstantiation);
return instantiatedElementType.Context.GetArrayType(instantiatedElementType, _rank);
}
/// <summary>
/// Find a method based on owner type and nativelayout name, method instantiation, and signature.
/// </summary>
public MethodDesc ResolveGenericMethodInstantiation(bool unboxingStub, DefType owningType, MethodNameAndSignature nameAndSignature, Instantiation methodInstantiation, IntPtr functionPointer, bool usgFunctionPointer)
{
var uninstantiatedMethod = ResolveRuntimeMethod(unboxingStub, owningType, nameAndSignature, IntPtr.Zero, false);
MethodDesc returnedMethod;
if (methodInstantiation.IsNull || (methodInstantiation.Length == 0))
{
returnedMethod = uninstantiatedMethod;
}
else
{
returnedMethod = GetInstantiatedMethod(uninstantiatedMethod, methodInstantiation);
}
if (functionPointer != IntPtr.Zero)
{
returnedMethod.SetFunctionPointer(functionPointer, usgFunctionPointer);
}
return(returnedMethod);
}
public InstantiatedType GetInstantiatedType(MetadataType typeDef, Instantiation instantiation)
{
return(_instantiatedTypes.GetOrCreateValue(new InstantiatedTypeKey(typeDef, instantiation)));
}
internal static Instantiation CreateGenericMethodInstantiation(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
if (methodInstantiation.Length == 0)
{
return(methodInstantiation);
}
var genericInstantiation = CreateGenericInstantiation(methodInstantiation);
foreach (var parameter in genericInstantiation)
{
var par = (InstantiatedGenericParameter)parameter;
par._typeInstantiation = typeInstantiation;
par._methodInstantiation = genericInstantiation;
}
return(genericInstantiation);
}