public override void AppendName(StringBuilder sb, GenericParameterDesc type) { string prefix = type.Kind == GenericParameterKind.Type ? "!" : "!!"; sb.Append(prefix); sb.Append(type.Name); }
private static void GetInstantiatedConstraintsRecursive(InstantiationContext typeContext, TypeDesc type, ref ArrayBuilder <TypeDesc> instantiatedConstraints) { if (!type.IsGenericParameter || typeContext == null) { return; } GenericParameterDesc genericParam = (GenericParameterDesc)type; foreach (var constraint in genericParam.TypeConstraints) { var instantiatedType = constraint.InstantiateSignature(typeContext.TypeInstantiation, typeContext.MethodInstantiation); if (instantiatedType.IsGenericParameter) { // Make sure it is save to call this method recursively if (!instantiatedConstraints.Contains(instantiatedType)) { instantiatedConstraints.Add(instantiatedType); // Constraints of this constraint apply to 'genericParam' too GetInstantiatedConstraintsRecursive(typeContext, instantiatedType, ref instantiatedConstraints); } } else { instantiatedConstraints.Add(instantiatedType); } } }
private static bool IsConstrainedAsGCPointer(GenericParameterDesc type) { foreach (var typeConstraint in type.TypeConstraints) { if (typeConstraint.IsGenericParameter) { if (IsConstrainedAsGCPointer((GenericParameterDesc)typeConstraint)) { return(true); } } if (!typeConstraint.IsInterface && typeConstraint.IsGCPointer) { // Object, ValueType, and Enum are GCPointers but they do not constrain the type to GCPointer! if (!typeConstraint.IsWellKnownType(WellKnownType.Object) && !typeConstraint.IsWellKnownType(WellKnownType.ValueType) && !typeConstraint.IsWellKnownType(WellKnownType.Enum)) { return(true); } } } return(false); }
public string FormatName(GenericParameterDesc type) { StringBuilder sb = new StringBuilder(); AppendName(sb, type); return(sb.ToString()); }
private GenericParameter HandleGenericParameter(Cts.GenericParameterDesc genParam) { var result = new GenericParameter { Kind = genParam.Kind == Cts.GenericParameterKind.Type ? GenericParameterKind.GenericTypeParameter : GenericParameterKind.GenericMethodParameter, Number = checked ((ushort)genParam.Index), }; foreach (Cts.TypeDesc constraint in genParam.TypeConstraints) { result.Constraints.Add(HandleType(constraint)); } var ecmaGenParam = genParam as Cts.Ecma.EcmaGenericParameter; if (ecmaGenParam != null) { Ecma.MetadataReader reader = ecmaGenParam.MetadataReader; Ecma.GenericParameter genParamDef = reader.GetGenericParameter(ecmaGenParam.Handle); result.Flags = genParamDef.Attributes; result.Name = HandleString(reader.GetString(genParamDef.Name)); } else { throw new NotImplementedException(); } // TODO: CustomAttributes return(result); }
private static bool CanCastGenericParameterTo(this GenericParameterDesc thisType, TypeDesc otherType, StackOverflowProtect protect) { // A boxed variable type can be cast to any of its constraints, or object, if none are specified if (otherType.IsObject) { return(true); } if (thisType.HasNotNullableValueTypeConstraint && otherType.IsWellKnownType(WellKnownType.ValueType)) { return(true); } foreach (var typeConstraint in thisType.TypeConstraints) { if (typeConstraint.CanCastToInternal(otherType, protect)) { return(true); } } return(false); }
public RuntimeDeterminedType(DefType rawCanonType, GenericParameterDesc runtimeDeterminedDetailsType) { _rawCanonType = rawCanonType; _runtimeDeterminedDetailsType = runtimeDeterminedDetailsType; }
public override void AppendName(StringBuilder sb, GenericParameterDesc type) { string prefix = type.Kind == GenericParameterKind.Type ? "!" : "!!"; sb.Append(prefix); sb.Append(type.Name); }
public override Void AppendName(StringBuilder sb, GenericParameterDesc type, FormatOptions options) { sb.Append(type.DiagnosticName); return(Void.Value); }
public RuntimeDeterminedType GetRuntimeDeterminedType(DefType plainCanonType, GenericParameterDesc detailsType) { return(_runtimeDeterminedTypes.GetOrCreateValue(new RuntimeDeterminedTypeKey(plainCanonType, detailsType))); }
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 && !CheckGenericSpecialConstraint(instantiationParam, GenericConstraints.ReferenceTypeConstraint)) { return(false); } } // Check default constructor constraint if ((constraints & GenericConstraints.DefaultConstructorConstraint) != 0) { if (!instantiationParam.HasExplicitOrImplicitDefaultConstructor() && !CheckGenericSpecialConstraint(instantiationParam, GenericConstraints.DefaultConstructorConstraint)) { return(false); } } // Check struct constraint if ((constraints & GenericConstraints.NotNullableValueTypeConstraint) != 0) { if ((!instantiationParam.IsValueType || instantiationParam.IsNullable) && !CheckGenericSpecialConstraint(instantiationParam, GenericConstraints.NotNullableValueTypeConstraint)) { return(false); } } foreach (var constraintType in genericParam.TypeConstraints) { var instantiatedType = constraintType.InstantiateSignature(typeInstantiation, methodInstantiation); if (!instantiationParam.CanCastTo(instantiatedType)) { return(false); } } return(true); }
private static bool VerifyGenericParamConstraint(Instantiation typeInstantiation, Instantiation methodInstantiation, GenericParameterDesc genericParam, TypeDesc instantiationParam) { // Check class constraint if (genericParam.HasReferenceTypeConstraint && !instantiationParam.IsGCPointer) { return(false); } // Check default constructor constraint if (genericParam.HasDefaultConstructorConstraint) { if (!instantiationParam.IsDefType) { return(false); } if (!instantiationParam.IsValueType && instantiationParam.GetDefaultConstructor() == null) { return(false); } } // Check struct constraint if (genericParam.HasNotNullableValueTypeConstraint) { 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 abstract void AppendName(StringBuilder sb, GenericParameterDesc type);
public string FormatName(GenericParameterDesc type) { StringBuilder sb = new StringBuilder(); AppendName(sb, type); return sb.ToString(); }
private static bool VerifyGenericParamConstraint(InstantiationContext genericParamContext, GenericParameterDesc genericParam, InstantiationContext instantiationParamContext, TypeDesc instantiationParam) { GenericConstraints constraints = genericParam.Constraints; // Check class constraint if ((constraints & GenericConstraints.ReferenceTypeConstraint) != 0) { if (!instantiationParam.IsGCPointer && !CheckGenericSpecialConstraint(instantiationParam, GenericConstraints.ReferenceTypeConstraint)) { return(false); } } // Check default constructor constraint if ((constraints & GenericConstraints.DefaultConstructorConstraint) != 0) { if (!instantiationParam.HasExplicitOrImplicitDefaultConstructor() && !CheckGenericSpecialConstraint(instantiationParam, GenericConstraints.DefaultConstructorConstraint)) { return(false); } } // Check struct constraint if ((constraints & GenericConstraints.NotNullableValueTypeConstraint) != 0) { if ((!instantiationParam.IsValueType || instantiationParam.IsNullable) && !CheckGenericSpecialConstraint(instantiationParam, GenericConstraints.NotNullableValueTypeConstraint)) { return(false); } } var instantiatedConstraints = new ArrayBuilder <TypeDesc>(); GetInstantiatedConstraintsRecursive(instantiationParamContext, instantiationParam, ref instantiatedConstraints); foreach (var constraintType in genericParam.TypeConstraints) { var instantiatedType = constraintType.InstantiateSignature(genericParamContext.TypeInstantiation, genericParamContext.MethodInstantiation); if (CanCastConstraint(ref instantiatedConstraints, instantiatedType)) { continue; } if (!instantiationParam.CanCastTo(instantiatedType)) { return(false); } } return(true); }
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); }
public RuntimeDeterminedType(DefType rawCanonType, GenericParameterDesc runtimeDeterminedDetailsType) { _rawCanonType = rawCanonType; _runtimeDeterminedDetailsType = runtimeDeterminedDetailsType; }
public abstract void AppendName(StringBuilder sb, GenericParameterDesc type);
private InstantiatedGenericParameter(GenericParameterDesc genericParam) { Debug.Assert(!(genericParam is InstantiatedGenericParameter)); _genericParam = genericParam; }
public override IAssemblyDesc AppendName(StringBuilder sb, GenericParameterDesc type, bool assemblyQualify) { throw new NotSupportedException(); }
public RuntimeDeterminedTypeKey(DefType plainCanonType, GenericParameterDesc detailsType) { _plainCanonType = plainCanonType; _detailsType = detailsType; }