public bool IsSubclassOf(IType other) { if (null == other) { return(false); } if (BaseType != null && (BaseType == other || BaseType.IsSubclassOf(other))) { return(true); } if (other.IsInterface && Array.Exists( GetInterfaces(), i => TypeCompatibilityRules.IsAssignableFrom(other, i))) { return(true); } if (null != other.ConstructedInfo && ConstructedInfo.GenericDefinition == other.ConstructedInfo.GenericDefinition) { for (int i = 0; i < ConstructedInfo.GenericArguments.Length; ++i) { if (!ConstructedInfo.GenericArguments[i].IsSubclassOf(other.ConstructedInfo.GenericArguments[i])) { return(false); } } return(true); } return(false); }
private int CalculateArgumentScore(IType parameterType, IType argumentType) { if (parameterType == argumentType || (TypeSystemServices.IsSystemObject(argumentType) && TypeSystemServices.IsSystemObject(parameterType))) { return(parameterType is ICallableType ? CallableExactMatchScore : ExactMatchScore); } if (TypeCompatibilityRules.IsAssignableFrom(parameterType, argumentType)) { var callableType = parameterType as ICallableType; var callableArg = argumentType as ICallableType; if (callableType != null && callableArg != null) { return(CalculateCallableScore(callableType, callableArg)); } return(UpCastScore); } if (TypeSystemServices.FindImplicitConversionOperator(argumentType, parameterType) != null) { return(ImplicitConversionScore); } if (TypeSystemServices.CanBeReachedByPromotion(parameterType, argumentType)) { return(IsWideningPromotion(parameterType, argumentType) ? WideningPromotion : NarrowingPromotion); } if (MyDowncastPermissions().CanBeReachedByDowncast(parameterType, argumentType)) { return(DowncastScore); } return(-1); }
internal static bool ValidAsyncTypeBound(Method value) { var ret = (IType)value.ReturnType.Entity; var tss = My <TypeSystemServices> .Instance; return(ret == tss.VoidType || ret == tss.TaskType || TypeCompatibilityRules.IsAssignableFrom(tss.GenericTaskType, ret)); }
private void CreateDispose() { BooMethodBuilder dispose = _enumerator.AddVirtualMethod("Dispose", TypeSystemServices.VoidType); if (TypeCompatibilityRules.IsAssignableFrom(TypeSystemServices.IDisposableType, _sourceEnumeratorType)) { dispose.Body.Add(CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateReference(_enumeratorField), Methods.InstanceActionOf <IDisposable>(d => d.Dispose))); } }
public bool IsSubclassOf(IType other) { if (null == other) { return(false); } if (BaseType != null && (BaseType == other || BaseType.IsSubclassOf(other))) { return(true); } return(other.IsInterface && Array.Exists( GetInterfaces(), i => TypeCompatibilityRules.IsAssignableFrom(other, i))); }
private static bool SameOrEquivalentGenericTypes(IType t1, IType t2, ref bool genericType) { if (t1 == t2) { return(true); } var g1 = t1 as IGenericParameter; var g2 = t2 as IGenericParameter; if (g1 == null || g2 == null) { var c1 = t1 as IConstructedTypeInfo; var c2 = t2 as IConstructedTypeInfo; if (c1 == null || c2 == null) { return(false); } if (c1.GenericDefinition != c2.GenericDefinition) { return(false); } for (var i = 0; i < c1.GenericArguments.Length; ++i) { if (!SameOrEquivalentGenericTypes(c1.GenericArguments[i], c2.GenericArguments[i], ref genericType)) { return(false); } } return(true); } genericType = true; var constraints = g2.GetTypeConstraints(); if (constraints.Length > 0 && !constraints.Any(c => TypeCompatibilityRules.IsAssignableFrom(g1, c))) { return(false); } return(g1.Variance == g2.Variance && g1.MustHaveDefaultConstructor == g2.MustHaveDefaultConstructor); }
private bool IsAssignableFrom(IType expectedType, IType actualType) { return(TypeCompatibilityRules.IsAssignableFrom(expectedType, actualType)); }
public bool IsAssignableFrom(IType other) { if (other == this) { return(true); } if (other.IsNull()) { return(IsClass); } var otherParameter = other as IGenericParameter; if (otherParameter != null && Array.Exists(otherParameter.GetTypeConstraints(), constraint => TypeCompatibilityRules.IsAssignableFrom(this, constraint))) { return(true); } return(false); }
bool IsAstAttribute(IType type) { return(TypeCompatibilityRules.IsAssignableFrom(_astAttributeInterface, type)); }
private bool MaintainsParameterConstraints(IGenericParameter parameter, IType argument) { if (argument == null || TypeSystemServices.IsError(argument)) { return(true); } if (argument == parameter) { return(true); } if (argument == _typeSystemServices.VoidType) { Errors.Add(CompilerErrorFactory.InvalidGenericParameterType(ConstructionNode, argument)); return(false); } bool valid = true; // Check type semantics constraints if (parameter.IsClass && !(argument.IsClass || argument.IsInterface)) { Errors.Add(CompilerErrorFactory.GenericArgumentMustBeReferenceType(ConstructionNode, parameter, argument)); valid = false; } if (parameter.IsValueType && !argument.IsValueType) { Errors.Add(CompilerErrorFactory.GenericArgumentMustBeValueType(ConstructionNode, parameter, argument)); valid = false; } // Don't check for default constructor constraint if value type constraint failed else if (parameter.MustHaveDefaultConstructor && !HasDefaultConstructor(argument)) { Errors.Add(CompilerErrorFactory.GenericArgumentMustHaveDefaultConstructor(ConstructionNode, parameter, argument)); valid = false; } // Check base type constraints IType[] baseTypes = parameter.GetTypeConstraints(); if (baseTypes != null) { foreach (IType baseType in baseTypes) { // Foo<T> where T : Foo<T> if (null != _definition && TypeCompatibilityRules.IsAssignableFrom(baseType, _definition) && argument == _constructionNode.ParentNode.Entity) { continue; } // Don't check for System.ValueType supertype constraint // if parameter also has explicit value type constraint if (baseType == _typeSystemServices.ValueTypeType && parameter.IsValueType) { continue; } if (!TypeCompatibilityRules.IsAssignableFrom(baseType, argument)) { Errors.Add(CompilerErrorFactory.GenericArgumentMustHaveBaseType(ConstructionNode, parameter, argument, baseType)); valid = false; } } } return(valid); }
private bool IsAssignableFrom(IType t1, IType t2) { return(TypeCompatibilityRules.IsAssignableFrom(t1, t2)); }