public OverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, IType[] typeArguments = null, CSharpConversions 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 ?? CSharpConversions.Get(compilation); this.AllowExpandingParams = true; this.AllowOptionalParameters = true; }
public void Run(AstNode rootNode, TransformContext context) { this.context = context; this.conversions = CSharpConversions.Get(context.TypeSystem); InitializeContext(rootNode.Annotation <UsingScope>()); rootNode.AcceptVisitor(this); }
/// <remarks> /// See $7.10.10 of C# 4 Spec for details. /// </remarks> Value Visit(TypeIsResolveResult result) { var importedType = NullableType.GetUnderlyingType(Import(result.TargetType)); var val = Convert(result.Input); var conversions = CSharpConversions.Get(debuggerTypeSystem); bool evalResult = false; if (!val.IsNull) { IType inputType = NullableType.GetUnderlyingType(val.Type); if (inputType.Equals(importedType)) { evalResult = true; } else if (conversions.IsImplicitReferenceConversion(inputType, importedType)) { evalResult = true; } else if (conversions.IsBoxingConversion(inputType, importedType)) { evalResult = true; } } return(Eval.CreateValue(evalThread, evalResult)); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { base.VisitForeachStatement(foreachStatement); var rr = ctx.Resolve(foreachStatement) as ForEachResolveResult; if (rr == null) { return; } if (rr.ElementType.Kind == TypeKind.Unknown) { return; } if (ReflectionHelper.GetTypeCode(rr.ElementType) == TypeCode.Object) { return; } if (conversions == null) { conversions = CSharpConversions.Get(ctx.Compilation); } Conversion c = conversions.ImplicitConversion(rr.ElementType, rr.ElementVariable.Type); if (c.IsValid) { return; } var csResolver = ctx.GetResolverStateBefore(foreachStatement); var builder = new TypeSystemAstBuilder(csResolver); AstType elementType = builder.ConvertType(rr.ElementType); AstType variableType = foreachStatement.VariableType; string text = ctx.TranslateString("Collection element type '{0}' is not implicitly convertible to '{1}'"); AddIssue(variableType, string.Format(text, elementType.GetText(), variableType.GetText())); }
public TypeInference(ICompilation compilation) { if (compilation == null) { throw new ArgumentNullException("compilation"); } this.compilation = compilation; this.conversions = CSharpConversions.Get(compilation); }
/// <summary> /// Validates whether the given type argument satisfies the constraints for the given type parameter. /// </summary> /// <param name="typeParameter">The type parameter.</param> /// <param name="typeArgument">The type argument.</param> /// <param name="substitution">The substitution that defines how type parameters are replaced with type arguments. /// The substitution is used to check constraints that depend on other type parameters (or recursively on the same type parameter). /// May be null if no substitution should be used.</param> /// <returns>True if the constraints are satisfied; false otherwise.</returns> public static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution = null) { if (typeParameter == null) { throw new ArgumentNullException("typeParameter"); } if (typeArgument == null) { throw new ArgumentNullException("typeArgument"); } return(ValidateConstraints(typeParameter, typeArgument, substitution, CSharpConversions.Get(typeParameter.Owner.Compilation))); }
internal MetadataContext(HackedSimpleCompilation compilation, EmitSettings settings) { this.hackedCompilation = compilation; Settings = settings ?? new EmitSettings(); CSharpConversions = CSharpConversions.Get(compilation); moduleMap = compilation.Modules.ToDictionary(m => new ModuleSignature(m.Name)); Modules = moduleMap.Keys.ToImmutableArray(); MainModule = Modules[0]; mutableModule = (VirtualModule)moduleMap[MainModule]; Debug.Assert(MainModule.Name == this.Compilation.MainModule.Name); }
private ExpressionWithResolveResult HandleImplicitConversion(IMethod method, TranslatedExpression argument) { var conversions = CSharpConversions.Get(expressionBuilder.compilation); IType targetType = method.ReturnType; var conv = conversions.ImplicitConversion(argument.Type, targetType); if (!(conv.IsUserDefined && conv.Method.Equals(method))) { // implicit conversion to targetType isn't directly possible, so first insert a cast to the argument type argument = argument.ConvertTo(method.Parameters[0].Type, expressionBuilder); conv = conversions.ImplicitConversion(argument.Type, targetType); } return(new CastExpression(expressionBuilder.ConvertType(targetType), argument.Expression) .WithRR(new ConversionResolveResult(targetType, argument.ResolveResult, conv))); }
public override void VisitIsExpression(IsExpression isExpression) { base.VisitIsExpression(isExpression); var conversions = CSharpConversions.Get(ctx.Compilation); var exprType = ctx.Resolve(isExpression.Expression).Type; var providedType = ctx.ResolveType(isExpression.Type); if (exprType.Kind == TypeKind.Unknown || providedType.Kind == TypeKind.Unknown) { return; } if (IsValidReferenceOrBoxingConversion(exprType, providedType)) { return; } var exprTP = exprType as ITypeParameter; var providedTP = providedType as ITypeParameter; if (exprTP != null) { if (IsValidReferenceOrBoxingConversion(exprTP.EffectiveBaseClass, providedType) && exprTP.EffectiveInterfaceSet.All(i => IsValidReferenceOrBoxingConversion(i, providedType))) { return; } } if (providedTP != null) { if (IsValidReferenceOrBoxingConversion(exprType, providedTP.EffectiveBaseClass)) { return; } } AddIssue(isExpression, ctx.TranslateString("Given expression is never of the provided type")); }
public GatherVisitor(BaseRefactoringContext ctx) : base(ctx) { conversions = CSharpConversions.Get(ctx.Compilation); }
public override void VisitIndexerExpression(IndexerExpression indexerExpression) { base.VisitIndexerExpression(indexerExpression); var localResolveResult = context.Resolve(indexerExpression.Target) as LocalResolveResult; if (localResolveResult == null) { return; } var resolveResult = context.Resolve(indexerExpression); if (localResolveResult == null) { return; } var parent = indexerExpression.Parent; while (parent is ParenthesizedExpression) { parent = parent.Parent; } if (parent is DirectionExpression) { // The only types which are indexable and where the indexing expression // results in a variable is an actual array type AddCriterion(localResolveResult.Variable, new IsArrayTypeCriterion()); } else if (resolveResult is ArrayAccessResolveResult) { var arrayResolveResult = (ArrayAccessResolveResult)resolveResult; var arrayType = arrayResolveResult.Array.Type as ArrayType; if (arrayType != null) { var parameterTypes = arrayResolveResult.Indexes.Select(index => index.Type); var criterion = new SupportsIndexingCriterion(arrayType.ElementType, parameterTypes, CSharpConversions.Get(context.Compilation)); AddCriterion(localResolveResult.Variable, criterion); } } else if (resolveResult is CSharpInvocationResolveResult) { var invocationResolveResult = (CSharpInvocationResolveResult)resolveResult; var parameterTypes = invocationResolveResult.Arguments.Select(arg => arg.Type); var criterion = new SupportsIndexingCriterion(invocationResolveResult.Member.ReturnType, parameterTypes, CSharpConversions.Get(context.Compilation)); AddCriterion(localResolveResult.Variable, criterion); } }
void AssertDoesNotMatch(IType candidateType, IType elementType, bool isWriteAccess, params IType[] indexTypes) { var criterion = new SupportsIndexingCriterion(elementType, indexTypes, CSharpConversions.Get(compilation), isWriteAccess); Assert.IsFalse(criterion.SatisfiedBy(candidateType)); }