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