public TypeInference(ICompilation compilation) { if (compilation == null) throw new ArgumentNullException("compilation"); this.compilation = compilation; this.conversions = Conversions.Get(compilation); }
internal TypeInference(ICompilation compilation, Conversions conversions) { Debug.Assert(compilation != null); Debug.Assert(conversions != null); this.compilation = compilation; this.conversions = conversions; }
public CppResolver(ICompilation compilation) { if (compilation == null) throw new ArgumentNullException("compilation"); this.compilation = compilation; this.conversions = Conversions.Get(compilation); this.context = new CppTypeResolveContext(compilation.MainAssembly); }
public CppResolver(CppTypeResolveContext context) { if (context == null) throw new ArgumentNullException("context"); this.compilation = context.Compilation; this.conversions = Conversions.Get(compilation); this.context = context; if (context.CurrentTypeDefinition != null) currentTypeDefinitionCache = new TypeDefinitionCache(context.CurrentTypeDefinition); }
private CppResolver(ICompilation compilation, Conversions conversions, CppTypeResolveContext context, bool checkForOverflow, bool isWithinLambdaExpression, TypeDefinitionCache currentTypeDefinitionCache, ImmutableStack<IVariable> localVariableStack, ObjectInitializerContext objectInitializerStack) { this.compilation = compilation; this.conversions = conversions; this.context = context; this.checkForOverflow = checkForOverflow; this.isWithinLambdaExpression = isWithinLambdaExpression; this.currentTypeDefinitionCache = currentTypeDefinitionCache; this.localVariableStack = localVariableStack; this.objectInitializerStack = objectInitializerStack; }
public void use_a_runtime_converter_against_NULL() { var conversions = new Conversions(); conversions.RegisterRuntimeConversion<ColorConverter>(); var cellHandling = new CellHandling(new EquivalenceChecker(), conversions); var cell = new Cell(cellHandling, "color", typeof (Color)); var values = new StepValues("foo"); cell.ConvertValues(new Step("foo").With("color", "NULL"), values); values.Get("color").ShouldBeNull(); }
public void use_a_runtime_converter_with_a_value() { var conversions = new Conversions(); conversions.RegisterRuntimeConversion<ColorConverter>(); var cellHandling = new CellHandling(new EquivalenceChecker(), conversions); var cell = new Cell(cellHandling, "color", typeof (Color)); var values = new StepValues("foo"); cell.ConvertValues(new Step("foo").With("color", "Red"), values); var delayed = values.DelayedConversions.Single(); delayed.Key.ShouldBe("color"); delayed.Raw.ShouldBe("Red"); delayed.Converter.ShouldBeOfType<ColorConverter>(); }
internal static bool IsEligibleExtensionMethod(ICompilation compilation, Conversions conversions, IType targetType, IMethod method, bool useTypeInference, out IType[] outInferredTypes) { outInferredTypes = null; if (targetType == null) return true; if (method.Parameters.Count == 0) return false; IType thisParameterType = method.Parameters[0].Type; if (useTypeInference && method.TypeParameters.Count > 0) { // We need to infer type arguments from targetType: TypeInference ti = new TypeInference(compilation, conversions); ResolveResult[] arguments = { new ResolveResult(targetType) }; IType[] parameterTypes = { method.Parameters[0].Type }; bool success; var inferredTypes = ti.InferTypeArguments(method.TypeParameters, arguments, parameterTypes, out success); var substitution = new TypeParameterSubstitution(null, inferredTypes); // Validate that the types that could be inferred (aren't unknown) satisfy the constraints: bool hasInferredTypes = false; for (int i = 0; i < inferredTypes.Length; i++) { if (inferredTypes[i].Kind != TypeKind.Unknown && inferredTypes[i].Kind != TypeKind.UnboundTypeArgument) { hasInferredTypes = true; if (!OverloadResolution.ValidateConstraints(method.TypeParameters[i], inferredTypes[i], substitution, conversions)) return false; } else { inferredTypes[i] = method.TypeParameters[i]; // do not substitute types that could not be inferred } } if (hasInferredTypes) outInferredTypes = inferredTypes; thisParameterType = thisParameterType.AcceptVisitor(substitution); } Conversion c = conversions.ImplicitConversion(targetType, thisParameterType); return c.IsValid && (c.IsIdentityConversion || c.IsReferenceConversion || c.IsBoxingConversion); }
/// <summary> /// Sets the converter to all DataMembers that have this returnType /// <para xml:lang="es"> /// Establece el convertidor para todos los miembros de datos que tienen este returnType. /// </para> /// </summary> /// <param name="converter">Converter to use /// <para xml:lang="es">Convertidor a usar</para> /// </param> /// <param name="returnType">Return type of the members that will have the converter set /// <para xml:lang="es">Tipo de retorno de los miembros que tendra el convertidor setConverter a usar.</para> /// </param> public static void SetConverter(Conversions.ConverterBase converter, Type returnType) { foreach (DataType dtype in DataType.AllDataTypes) { foreach (DataMember dmember in dtype.DataMembers.Where(dm => dm.Expression.ReturnType.Equals(returnType))) { dmember.Converter = converter; //set right column type if (Sql.DbTypeMapper.DbTypeMap.ContainsValue(converter.ColumnType) && converter.ColumnType != typeof(object)) { dmember.Column.DbType = Sql.DbTypeMapper.Parse(converter.ColumnType); } else if (converter.ColumnType.GetTypeInfo().IsEnum) { dmember.Column.DbType = Sql.DbType.Int32; } } } }
public ArrayConversion(Conversions conversions) { _conversions = conversions; }
/// <summary> /// Sets the converter to all DataMembers that have this returnType /// </summary> /// <param name="converter">Converter to use</param> /// <param name="returnType">Return type of the members that will have the converter set</param> public static void SetConverter(Conversions.ConverterBase converter, Type returnType) { foreach (DataType dtype in DataType.AllDataTypes) { foreach (DataMember dmember in dtype.DataMembers.Where(dm => dm.Member.ReturnType.Equals(returnType))) { dmember.Converter = converter; } } }
/// <summary> /// Gets whether the lambda body is valid for the given parameter types and return type. /// </summary> /// <returns> /// Produces a conversion with <see cref="Conversion.IsAnonymousFunctionConversion"/>=<c>true</c> if the lambda is valid; /// otherwise returns <see cref="Conversion.None"/>. /// </returns> public abstract Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions);
public NullableConvertor(Conversions conversions) { _conversions = conversions; }
internal static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution, Conversions conversions) { switch (typeArgument.Kind) { // void, null, and pointers cannot be used as type arguments case TypeKind.Void: case TypeKind.Null: case TypeKind.Pointer: return false; } if (typeParameter.HasReferenceTypeConstraint) { if (typeArgument.IsReferenceType != true) return false; } if (typeParameter.HasValueTypeConstraint) { if (!NullableType.IsNonNullableValueType(typeArgument)) return false; } if (typeParameter.HasDefaultConstructorConstraint) { ITypeDefinition def = typeArgument.GetDefinition(); if (def != null && def.IsAbstract) return false; var ctors = typeArgument.GetConstructors( m => m.Parameters.Count == 0 && m.Accessibility == Accessibility.Public, GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions ); if (!ctors.Any()) return false; } foreach (IType constraintType in typeParameter.DirectBaseTypes) { IType c = constraintType; if (substitution != null) c = c.AcceptVisitor(substitution); if (!conversions.IsConstraintConvertible(typeArgument, c)) return false; } return true; }
public ConstraintValidatingSubstitution(IList<IType> classTypeArguments, IList<IType> methodTypeArguments, OverloadResolution overloadResolution) : base(classTypeArguments, methodTypeArguments) { this.conversions = overloadResolution.conversions; }
public OverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, IType[] typeArguments = null, Conversions conversions = null) { if (compilation == null) throw new ArgumentNullException("compilation"); if (arguments == null) throw new ArgumentNullException("arguments"); if (argumentNames == null) argumentNames = new string[arguments.Length]; else if (argumentNames.Length != arguments.Length) throw new ArgumentException("argumentsNames.Length must be equal to arguments.Length"); this.compilation = compilation; this.arguments = arguments; this.argumentNames = argumentNames; // keep explicitlyGivenTypeArguments==null when no type arguments were specified if (typeArguments != null && typeArguments.Length > 0) this.explicitlyGivenTypeArguments = typeArguments; this.conversions = conversions ?? Conversions.Get(compilation); this.AllowExpandingParams = true; }