public override ResolveResult Resolve(CppResolver resolver) { ResolveResult lhs = left.Resolve(resolver); ResolveResult rhs = right.Resolve(resolver); return(resolver.ResolveBinaryOperator(operatorType, lhs, rhs)); }
public override object Invoke(CppResolver resolver, object lhs, object rhs) { if (lhs == null && rhs == null) { return(!Negate); // ==: true; !=: false } if (lhs == null || rhs == null) { return(Negate); // ==: false; !=: true } lhs = resolver.CSharpPrimitiveCast(Type, lhs); rhs = resolver.CSharpPrimitiveCast(Type, rhs); bool equal; if (Type == TypeCode.Single) { equal = (float)lhs == (float)rhs; } else if (Type == TypeCode.Double) { equal = (double)lhs == (double)rhs; } else { equal = object.Equals(lhs, rhs); } return(equal ^ Negate); }
public IList<ResolveResult> GetArgumentsWithConversions() { if (bestCandidate == null) return arguments; var conversions = this.ArgumentConversions; ResolveResult[] args = new ResolveResult[arguments.Length]; for (int i = 0; i < args.Length; i++) { if (conversions[i] == Conversion.IdentityConversion) { args[i] = arguments[i]; } else { int parameterIndex = bestCandidate.ArgumentToParameterMap[i]; IType parameterType; if (parameterIndex >= 0) { parameterType = bestCandidate.ParameterTypes[parameterIndex]; } else { parameterType = SpecialType.UnknownType; } if (arguments[i].IsCompileTimeConstant && conversions[i] != Conversion.None) { args[i] = new CppResolver(compilation).ResolveCast(parameterType, arguments[i]); } else { args[i] = new ConversionResolveResult(parameterType, arguments[i], conversions[i]); } } } return args; }
public IEnumerable <IEnumerable <IMethod> > GetEligibleExtensionMethods(bool substituteInferredTypes) { var result = new List <List <IMethod> >(); foreach (var methodGroup in GetExtensionMethods()) { var outputGroup = new List <IMethod>(); foreach (var method in methodGroup) { IType[] inferredTypes; if (CppResolver.IsEligibleExtensionMethod( method.Compilation, Conversions.Get(method.Compilation), this.TargetType, method, true, out inferredTypes)) { if (substituteInferredTypes && inferredTypes != null) { outputGroup.Add(new SpecializedMethod(method.DeclaringType, method, inferredTypes)); } else { outputGroup.Add(method); } } } if (outputGroup.Count > 0) { result.Add(outputGroup); } } return(result); }
InvocationResolveResult GetCtorInvocation() { ResolveResult rr = this.ctorInvocation; if (rr != null) { LazyInit.ReadBarrier(); return(rr as InvocationResolveResult); } else { CppResolver resolver = new CppResolver(context); int totalArgumentCount = unresolved.positionalArguments.Count + unresolved.namedCtorArguments.Count; ResolveResult[] arguments = new ResolveResult[totalArgumentCount]; string[] argumentNames = new string[totalArgumentCount]; int i = 0; while (i < unresolved.positionalArguments.Count) { IConstantValue cv = unresolved.positionalArguments[i]; arguments[i] = cv.Resolve(context); i++; } foreach (var pair in unresolved.namedCtorArguments) { argumentNames[i] = pair.Key; arguments[i] = pair.Value.Resolve(context); i++; } rr = resolver.ResolveObjectCreation(attributeType, arguments, argumentNames); return(LazyInit.GetOrSet(ref this.ctorInvocation, rr) as InvocationResolveResult); } }
public override ResolveResult Resolve(CppResolver resolver) { return(resolver.ResolveConditional( condition.Resolve(resolver), trueExpr.Resolve(resolver), falseExpr.Resolve(resolver) )); }
public override object Invoke(CppResolver resolver, object input) { if (input == null) { return(null); } return(func((T)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T)), input))); }
/// <summary> /// Creates a new TypeSystemAstBuilder. /// </summary> /// <param name="resolver"> /// A resolver initialized for the position where the type will be inserted. /// </param> public TypeSystemAstBuilder(CppResolver resolver) { if (resolver == null) { throw new ArgumentNullException("resolver"); } this.resolver = resolver; InitProperties(); }
public override object Invoke(CppResolver resolver, object lhs, object rhs) { if (lhs == null || rhs == null) { return(null); } return(func((T1)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T1)), lhs), (T2)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T2)), rhs))); }
public IList <ControlFlowNode> BuildControlFlowGraph(Statement statement, CancellationToken cancellationToken = default(CancellationToken)) { if (statement == null) { throw new ArgumentNullException("statement"); } CppResolver r = new CppResolver(MinimalCorlib.Instance.CreateCompilation()); return(BuildControlFlowGraph(statement, new CppAstResolver(r, statement), cancellationToken)); }
bool AreEqualConstants(ResolveResult c1, ResolveResult c2) { if (c1 == null || c2 == null || !c1.IsCompileTimeConstant || !c2.IsCompileTimeConstant) { return(false); } CppResolver r = new CppResolver(typeResolveContext); ResolveResult c = r.ResolveBinaryOperator(BinaryOperatorType.Equality, c1, c2); return(c.IsCompileTimeConstant && (c.ConstantValue as bool?) == true); }
public override object Invoke(CppResolver resolver, object lhs, object rhs) { if (lhs == null || rhs == null) { return(null); } Func <T1, T2, T1> func = resolver.CheckForOverflow ? checkedFunc : uncheckedFunc; return(func((T1)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T1)), lhs), (T2)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T2)), rhs))); }
/// <summary> /// Gets all candidate extension methods. /// Note: this includes candidates that are not eligible due to an inapplicable /// this argument. /// </summary> /// <remarks> /// The results are stored in nested lists because they are grouped by using scope. /// That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }", /// the return value will be /// new List { /// new List { all extensions from MoreExtensions }, /// new List { all extensions from SomeExtensions } /// } /// </remarks> public IEnumerable <IEnumerable <IMethod> > GetExtensionMethods() { if (resolver != null) { Debug.Assert(extensionMethods == null); try { extensionMethods = resolver.GetExtensionMethods(methodName, typeArguments); } finally { resolver = null; } } return(extensionMethods ?? Enumerable.Empty <IEnumerable <IMethod> >()); }
public override ResolveResult Resolve(CppResolver resolver) { ResolveResult rr; if (targetType != null) { rr = new TypeResolveResult(targetType.Resolve(resolver.CurrentTypeResolveContext)); } else { rr = targetExpression.Resolve(resolver); } return(resolver.ResolveMemberAccess(rr, memberName, typeArguments.Resolve(resolver.CurrentTypeResolveContext))); }
/// <summary> /// Creates a new C# AST resolver. /// Use this overload if you are resolving code snippets (not necessarily complete files). /// </summary> /// <param name="resolver">The resolver state at the root node (to be more precise: outside the root node).</param> /// <param name="rootNode">The root node of the resolved tree.</param> /// <param name="parsedFile">The parsed file for the nodes being resolved. This parameter is used only /// when the root node is on the type level; it is not necessary when an expression is passed. /// This parameter may be null.</param> public CppAstResolver(CppResolver resolver, AstNode rootNode, CppParsedFile parsedFile = null) { if (resolver == null) { throw new ArgumentNullException("resolver"); } if (rootNode == null) { throw new ArgumentNullException("rootNode"); } this.initialResolverState = resolver; this.rootNode = rootNode; this.parsedFile = parsedFile; this.resolveVisitor = new ResolveVisitor(initialResolverState, parsedFile); }
public override ResolveResult Resolve(CppResolver resolver) { ResolveResult[] elements = new ResolveResult[arrayElements.Count]; for (int i = 0; i < elements.Length; i++) { elements[i] = arrayElements[i].Resolve(resolver); } if (elementType != null) { return(resolver.ResolveArrayCreation(elementType.Resolve(resolver.CurrentTypeResolveContext), 1, null, elements)); } else { return(resolver.ResolveArrayCreation(null, 1, null, elements)); } }
/// <summary> /// Gets the resolver state immediately before the specified node. /// That is, if the node is a variable declaration, the returned state will not contain the newly declared variable. /// </summary> public CppResolver GetResolverStateBefore(AstNode node, CancellationToken cancellationToken = default(CancellationToken)) { if (node == null || node.IsNull) { throw new ArgumentNullException("node"); } InitResolver(); resolveVisitor.cancellationToken = cancellationToken; try { CppResolver resolver = resolveVisitor.GetResolverStateBefore(node); Debug.Assert(resolver != null); return(resolver); } finally { resolveVisitor.cancellationToken = CancellationToken.None; } }
/// <summary> /// Creates a new C# AST resolver. /// Use this overload if you are resolving within a complete C# file. /// </summary> /// <param name="compilation">The current compilation.</param> /// <param name="parsedFile"> /// Result of the <see cref="TypeSystemConvertVisitor"/> for the file being passed. This is used for setting up the context on the resolver. The parsed file must be registered in the compilation. /// </param> /// <param name="compilationUnit">The compilation unit corresponding to the specified parsed file.</param> public CppAstResolver(ICompilation compilation, CompilationUnit compilationUnit, CppParsedFile parsedFile) { if (compilation == null) { throw new ArgumentNullException("compilation"); } if (parsedFile == null) { throw new ArgumentNullException("parsedFile"); } if (compilationUnit == null) { throw new ArgumentNullException("compilationUnit"); } this.initialResolverState = new CppResolver(compilation); this.rootNode = compilationUnit; this.parsedFile = parsedFile; this.resolveVisitor = new ResolveVisitor(initialResolverState, parsedFile); }
public override ResolveResult Resolve(CppResolver resolver) { ResolveResult targetRR = target.Resolve(resolver); if (targetRR.IsError) { return(targetRR); } IList <IType> typeArgs = typeArguments.Resolve(resolver.CurrentTypeResolveContext); using (var busyLock = BusyManager.Enter(this)) { if (busyLock.Success) { return(resolver.ResolveMemberType(targetRR, identifier, typeArgs)); } else { // This can happen for "class Test : $Test.Base$ { public class Base {} }": return(ErrorResolveResult.UnknownError); // don't cache this error } } }
List <string> GetUsedNamespaces() { var scope = CSharpParsedFile.GetUsingScope(location); var result = new List <string> (); var resolver = new CppResolver(ctx); while (scope != null) { result.Add(scope.NamespaceName); foreach (var u in scope.Usings) { var ns = u.ResolveNamespace(resolver); if (ns == null) { continue; } result.Add(ns.FullName); } scope = scope.Parent; } return(result); }
/// <summary> /// Gets the resolver state immediately after the specified node. /// That is, if the node is a variable declaration, the returned state will include the newly declared variable. /// </summary> public CppResolver GetResolverStateAfter(AstNode node, CancellationToken cancellationToken = default(CancellationToken)) { if (node == null || node.IsNull) { throw new ArgumentNullException("node"); } while (node != null && IsUnresolvableNode(node)) { node = node.Parent; } if (node == null) { return(initialResolverState); } InitResolver(); resolveVisitor.cancellationToken = cancellationToken; try { CppResolver resolver = resolveVisitor.GetResolverStateAfter(node); Debug.Assert(resolver != null); return(resolver); } finally { resolveVisitor.cancellationToken = CancellationToken.None; } }
public override ResolveResult Resolve(CppResolver resolver) { return(resolver.ResolveCast(targetType.Resolve(resolver.CurrentTypeResolveContext), expression.Resolve(resolver))); }
public override ResolveResult Resolve(CppResolver resolver) { return(resolver.ResolveUnaryOperator(operatorType, expression.Resolve(resolver))); }
public override ResolveResult Resolve(CppResolver resolver) { return(resolver.ResolveDefaultValue(type.Resolve(resolver.CurrentTypeResolveContext))); }
public override ResolveResult Resolve(CppResolver resolver) { return(expression.Resolve(resolver.WithCheckForOverflow(checkForOverflow))); }
public override ResolveResult Resolve(CppResolver resolver) { var typeArgs = typeArguments.Resolve(resolver.CurrentTypeResolveContext); return(resolver.LookupSimpleNameOrTypeName(identifier, typeArgs, lookupMode)); }
public override ResolveResult Resolve(CppResolver resolver) { return(resolver.ResolveSimpleName(identifier, typeArguments.Resolve(resolver.CurrentTypeResolveContext))); }
public abstract ResolveResult Resolve(CppResolver resolver);
public override ResolveResult Resolve(CppResolver resolver) { return(resolver.ResolveTypeOf(type.Resolve(resolver.CurrentTypeResolveContext))); }
public override ResolveResult Resolve(CppResolver resolver) { return(new ConstantResolveResult(type.Resolve(resolver.CurrentTypeResolveContext), value)); }