protected override IEnumerable<IHighlighting> DoRun(IInvocationExpression invocationExpression, ContractRequires contractAssertion, MemberWithAccess preconditionContainer) { var preconditionException = contractAssertion.GenericArgumentDeclaredType .With(x => x.Resolve()) .With(x => x.DeclaredElement as IClass); if (preconditionException != null) { if (ExceptionIsLessVisible(preconditionContainer, preconditionException)) { yield return new RequiresExceptionInconsistentVisibiityHighlighting(preconditionException, preconditionContainer); } if (DoesntHaveAppropriateConstructor(preconditionException)) { yield return new RequiresExceptionValidityHighlighting(preconditionException, preconditionContainer); } } if (!MessageIsAppropriateForContractRequires(contractAssertion.Message)) { yield return new InvalidRequiresMessageHighlighting(contractAssertion.Message); } }
private static void CalculateConnectionOfDisposableVariables(IInvocationExpression invocationExpression, ControlFlowElementData data, List<IRegularParameterDeclaration> thisConnections, Dictionary<IRegularParameterDeclaration, IVariableDeclaration> connections) { foreach (var argument in invocationExpression.InvocationExpressionReference.Invocation.Arguments) { var cSharpArgument = argument as ICSharpArgument; if (cSharpArgument == null) continue; var argumentExpression = cSharpArgument.Value; IRegularParameterDeclaration matchingVarDecl; if (argumentExpression is IThisExpression && data.ThisStatus != null) { if (GetMatchingParameterDeclaration(argument, out matchingVarDecl)) continue; thisConnections.Add(matchingVarDecl); continue; } var varDecl = TreeNodeHandlerUtil.GetVariableDeclarationForReferenceExpression(argumentExpression); if (data[varDecl] != null) // Если переменную не рассматриваем. { if (GetMatchingParameterDeclaration(argument, out matchingVarDecl)) continue; connections[matchingVarDecl] = varDecl; } } }
public InvocationMessage(IExpression originalExpression, IInvocationExpression invocationExpression) : base(originalExpression) { Contract.Requires(invocationExpression != null); _invocationExpression = invocationExpression; }
public static IPropertyDeclaration GetPropertyDeclaration(IClassDeclaration classDeclaration, IInvocationExpression invocationExpression) { IPropertyDeclaration propertyDeclaration = null; if (invocationExpression.ArgumentList.Arguments.Count >= 1) { string propertyName = null; var argument = invocationExpression.ArgumentList.Arguments[0]; if (argument.Value is ILambdaExpression) { var lambdaExpression = argument.Value as ILambdaExpression; var referenceExpression = lambdaExpression.BodyExpression as IReferenceExpression; if (referenceExpression != null) { propertyName = referenceExpression.NameIdentifier.Name; } } else if (argument.Value != null && argument.Value.ConstantValue != null) { propertyName = argument.Value.ConstantValue.Value.ToString(); } if (!string.IsNullOrEmpty(propertyName) && classDeclaration.DeclaredElement != null) { var property = (from member in classDeclaration.DeclaredElement.GetMembers().OfType<IProperty>() where member.ShortName == propertyName select member).FirstOrDefault(); if (property != null) { propertyDeclaration = (IPropertyDeclaration) property.GetDeclarations().FirstOrDefault(); } } } return propertyDeclaration; }
private void AnalyzeInvocationExpression(IInvocationExpression operation, INamedTypeSymbol stringComparisonType, Action<Diagnostic> reportDiagnostic) { IMethodSymbol methodSymbol = operation.TargetMethod; if (methodSymbol != null && methodSymbol.ContainingType.SpecialType == SpecialType.System_String && IsEqualsOrCompare(methodSymbol.Name)) { if (!IsAcceptableOverload(methodSymbol, stringComparisonType)) { // wrong overload reportDiagnostic(Diagnostic.Create(Rule, GetMethodNameLocation(operation.Syntax))); } else { IArgument lastArgument = operation.ArgumentsInSourceOrder.Last(); if (lastArgument.Value.Kind == OperationKind.FieldReferenceExpression) { IFieldSymbol fieldSymbol = ((IFieldReferenceExpression)lastArgument.Value).Field; if (fieldSymbol != null && fieldSymbol.ContainingType.Equals(stringComparisonType) && !IsOrdinalOrOrdinalIgnoreCase(fieldSymbol.Name)) { // right overload, wrong value reportDiagnostic(lastArgument.Syntax.CreateDiagnostic(Rule)); } } } } }
public override void VisitInvocationExpression(IInvocationExpression invocation, IHighlightingConsumer consumer) { if (IsCallWithTheSameContextAsFunctionOwner(invocation)) consumer.AddHighlighting(new CallWithSameContextWarning(invocation), invocation.GetHighlightingRange(), File); base.VisitInvocationExpression(invocation, consumer); }
protected override IEnumerable<IComponentRegistration> FromArguments(IInvocationExpression invocationExpression) { if (invocationExpression.Arguments.Count != 2) { yield break; } ICSharpArgument arg1 = invocationExpression.Arguments.First(); ITypeElement typeElement = arg1.With(f => f.Value as ITypeofExpression) .With(f => f.ArgumentType as IDeclaredType) .With(f => f.GetTypeElement()); if (typeElement == null) { yield break; } ICSharpArgument arg2 = invocationExpression.Arguments.Last(); IEnumerable<ITypeElement> concreteTypes = arg2.With(f => f.Value) .With(f => f.GetRegisteredTypes()).ToList(); if (concreteTypes.Any()) { yield return CreateRegistrations(invocationExpression, typeElement, concreteTypes); } }
protected virtual IEnumerable<IComponentRegistration> FromGenericArguments(IInvocationExpression invocationExpression) { var first = invocationExpression.TypeArguments.First() as IDeclaredType; var last = invocationExpression.TypeArguments.Last() as IDeclaredType; return CreateRegistration(invocationExpression, first, last); }
public InvalidRequiresMessageHighlighting(IInvocationExpression invocationExpression, Message contractMessage) { Contract.Requires(contractMessage != null); Contract.Requires(invocationExpression != null); _range = invocationExpression.GetHighlightingRange(); _contractMessage = contractMessage; }
public override bool IsAvailable(IUserDataHolder cache) { var topLevelNode = myProvider.GetTopLevelNode(); if (topLevelNode == null) return false; myChainedInvocation = FindInvocationChain(topLevelNode); return myChainedInvocation != null; }
private static IDeclaredType GetGenericRequiresType(IInvocationExpression invocationExpression) { Contract.Requires(invocationExpression != null); return invocationExpression.Reference .With(x => x.Invocation) .With(x => x.TypeArguments.FirstOrDefault()) .Return(x => x as IDeclaredType); }
private static ContractAssertionType? GetContractAssertionType(IInvocationExpression invocationExpression) { var clrType = invocationExpression.GetCallSiteType(); var method = invocationExpression.GetCalledMethod(); if (clrType.Return(x => x.FullName) != typeof(Contract).FullName) return null; return ParseAssertionType(method); }
internal RequiresExceptionValidityHighlighting(IInvocationExpression invocationExpression, IClass exceptionDeclaration, MemberWithAccess preconditionContainer) { Contract.Requires(exceptionDeclaration != null); Contract.Requires(preconditionContainer != null); Contract.Requires(invocationExpression != null); _range = invocationExpression.GetHighlightingRange(); _exceptionDeclaration = exceptionDeclaration; _preconditionContainer = preconditionContainer; }
public InvocationTestDeclaration( IIdentity identity, IProject project, string text, IInvocationExpression invocationExpression) : base(invocationExpression) { _identity = identity; _project = project; _text = text; }
public sealed override bool IsAvailable(IUserDataHolder cache) { myOuterInvocation = null; myExistingLambdaParameterName = null; var topLevelNode = myProvider.GetTopLevelNode(); if (topLevelNode == null) return false; myOuterInvocation = FindChain(topLevelNode); return myOuterInvocation != null; }
private Ranges GetUnitTestElementLocation(IInvocationExpression invocation) { var reference = (invocation.InvokedExpression as IReferenceExpression) .AssertNotNull("invocationExpression.InvokedExpression is not a IReferenceExpression"); var startOffset = reference.NameIdentifier.GetDocumentStartOffset(); var endOffset = invocation.GetDocumentRange().EndOffsetRange(); var textRange = startOffset.JoinRight(endOffset); return new Ranges(textRange, textRange); }
private UnitTestElementLocation GetUnitTestElementLocation(IInvocationExpression invocation) { var projectFile = invocation.GetSourceFile().ToProjectFile(); var reference = (invocation.InvokedExpression as IReferenceExpression) .AssertNotNull("invocationExpression.InvokedExpression is not a IReferenceExpression"); var startOffset = reference.NameIdentifier.GetDocumentStartOffset(); var endOffset = invocation.GetDocumentRange().EndOffsetRange(); var textRange = startOffset.JoinRight(endOffset).TextRange; return new UnitTestElementLocation(projectFile, textRange, textRange); }
private static bool IsCallWithTheSameContextAsFunctionOwner(IInvocationExpression invocation) { var invokedReference = invocation.InvokedExpression as IReferenceExpression; if (invokedReference == null || invokedReference.Name != "call") return false; var function = invokedReference.Qualifier as IReferenceExpression; if (function == null) return false; return AreSame(function.Qualifier, invocation.Arguments.FirstOrDefault()); }
private static string CalculateRestrictions(IInvocationExpression invokedExpression) { // TODO: Set default restrictions per version const string defaultRestrictions = "AE"; // First argument is traditionally the identifier (i.e. the directive name) but can also // be an object literal, where the keys are the directive names and the values are the // factory functions. We don't support this. // Second argument can be: // * factory function, which is injectable // * array literal specifying injectables for the factory function // Return value of the factory function can be: // * the "postlink" function, which means we use defaults // * a directive definition object, wich is an object literal that contains properties such as restrict var argument = invokedExpression.Arguments[1]; var function = argument as IFunctionExpression; if (function == null) { var arrayLiteral = argument as IArrayLiteral; if (arrayLiteral != null && arrayLiteral.ArrayElements.Count > 0) { var lastElement = arrayLiteral.ArrayElements.Last(); function = lastElement as IFunctionExpression; } } if (function == null || function.Block.Statements.Count == 0) return defaultRestrictions; IObjectLiteral objectLiteral = null; // TODO: Perhaps this should get the JS type, and get the return value of the function // This might be better than trying to find an object literal used as a return value var lastStatement = function.Block.Statements.Last(); var returnStatement = lastStatement as IReturnStatement; if (returnStatement != null) { objectLiteral = returnStatement.Value.LastExpression as IObjectLiteral; } if (objectLiteral == null) return defaultRestrictions; foreach (var initializer in objectLiteral.Properties.OfType<IObjectPropertyInitializer>()) { if (initializer.DeclaredName == "restrict") return initializer.Value.GetStringLiteralValue() ?? defaultRestrictions; } return defaultRestrictions; }
public string Present(IInvocationExpression invocationExpression) { var method = invocationExpression.Reference.GetResolved<IMethod>(); if (method == null) return null; var displayFormatAttributeData = method.GetAttributeData<DisplayFormatAttribute>(); if (displayFormatAttributeData == null) return null; var displayFormatAttribute = displayFormatAttributeData.ToCommon(); var commonExpressions = invocationExpression.Arguments.Select(GetConstantValue); return _introspectionPresenter.Present(displayFormatAttribute, commonExpressions); }
private void ScanInvocation([NotNull] IInvocationExpression operation, [NotNull] IMethodSymbol methodToFind) { if (methodToFind.MethodKind == MethodKind.ExplicitInterfaceImplementation) { ScanExplicitInterfaceInvocation(operation, methodToFind); } else { if (methodsToFind.Any(method => method.Equals(operation.TargetMethod))) { HasFoundInvocation = true; } } }
private static bool IsPossibleLinqInvocation(IInvocationExpression invocation) { switch (invocation.TargetMethod.Name) { case "Last": case "LastOrDefault": case "First": case "FirstOrDefault": case "Count": return true; default: return false; } }
protected override bool IsAvailable() { var expressionInitializer = FieldDeclaration.Initial as IExpressionInitializer; _invocationExpression = null; if (expressionInitializer != null) { _invocationExpression = expressionInitializer.Value as IInvocationExpression; } return _invocationExpression != null && (_invocationExpression.ArgumentList.Arguments.Count == 4 && ((_invocationExpression.ArgumentList.Arguments[3].Value is ICSharpLiteralExpression) && (_invocationExpression.ArgumentList.Arguments[3].Value as ICSharpLiteralExpression).Literal.GetTokenType() == CSharpTokenType.FALSE_KEYWORD)); }
public override void VisitInvocationExpression(IInvocationExpression invocationExpressionParam, HotMethodAnalyzerContext context) { // Do not add analysis for invocation expression here. Use 'AnalyzeInvocationExpression' for this goal; AnalyzeInvocationExpression(invocationExpressionParam, context); // Restriction for depth of analysis if (myMaxDepth <= context.Depth) { return; } var reference = (invocationExpressionParam.InvokedExpression as IReferenceExpression)?.Reference; var declaredElement = reference?.Resolve().DeclaredElement as IMethod; if (declaredElement == null) { return; } context.RegisterInvocationInMethod(declaredElement, reference); context.MarkCurrentAsVisited(); // find all declarations in current file var declarations = declaredElement.GetDeclarationsIn(mySourceFile).Where(t => t.GetSourceFile() == mySourceFile); // update current declared element in context and then restore it var originDeclaredElement = context.CurrentDeclaredElement; context.CurrentDeclaredElement = declaredElement; foreach (var declaration in declarations) { // Do not visit methods twice if (!context.IsCurrentElementVisited()) { ourCheckForInterrupt(); declaration.ProcessDescendants(this, context); } } context.CurrentDeclaredElement = originDeclaredElement; // propagate costly reachable methods back // Note : on this step there is methods that can be marked as costly reachable later (e.g. recursion) // so we will propagate costly reachable mark later if (context.IsDeclaredElementCostlyReachable(declaredElement)) { context.MarkCurrentAsCostlyReachable(); } }
public PreferAddressByIdToGraphicsParamsQuickFix(PreferAddressByIdToGraphicsParamsWarning warning) { myInvocationExpression = warning.InvocationMethod; myArgument = warning.Argument; myFieldName = myGraphicsPropertyName = warning.Literal; if (!ValidityChecker.IsValidIdentifier(myFieldName)) { myFieldName = "Property"; } myArgumentExpression = warning.ArgumentExpression; myMapFunction = warning.MapFunction; myTypeName = warning.TypeName; }
private string GetMethodName(IInvocationExpression itemAsT) { var methodName = itemAsT.MethodName; if (itemAsT.TypeArguments.Any()) { var typeArgs = itemAsT.TypeArguments .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .Select(x => x.ToFullString()) .ToList(); var typeArgString = string.Join(", ", typeArgs); methodName += "<" + typeArgString + ">"; } return(methodName); }
public IEnumerable <string> GetMockedMethodParameterTypes(IInvocationExpression invocation) { var mockedMethod = GetMockedMethodFromSetupMethod(invocation); var methodInvocation = GetMockedMethodInvocation(invocation); var substitution = methodInvocation?.Reference?.Resolve()?.Substitution; return(mockedMethod.Parameters.Select(p => { if (substitution == null) { return p.Type.GetPresentableName(CSharpLanguage.Instance); } return substitution.Apply(p.Type).GetPresentableName(CSharpLanguage.Instance); })); }
private static bool IsPossibleLinqInvocation(IInvocationExpression invocation) { switch (invocation.TargetMethod.Name) { case "Last": case "LastOrDefault": case "First": case "FirstOrDefault": case "Count": return(true); default: return(false); } }
public TempValue?AddFunctionCall(IInvocationExpression exp) { var referenceType = exp.DataType.Known().UnderlyingReferenceType(); if (referenceType is null) { return(null); } var reference = ReferenceToNewInvocationReturnedObject(exp); var temp = ReferenceGraph.AddTempValue(exp, referenceType); temp.AddReference(reference); return(temp); }
public static bool IsInvocationExpensive([NotNull] IInvocationExpression invocationExpression) { invocationExpression.GetPsiServices().Locks.AssertReadAccessAllowed(); var reference = (invocationExpression.InvokedExpression as IReferenceExpression)?.Reference; if (reference == null) { return(false); } var declaredElement = reference.Resolve().DeclaredElement as IMethod; return(IsInvokedElementExpensive(declaredElement)); }
private void ProcessDirective(IInvocationExpression invokedExpression, string identifier, int offset) { if (invokedExpression.Arguments.Count != 2) { return; } var restrictions = CalculateRestrictions(invokedExpression); // Directives declared in code cannot be applied to just a single tag var tags = new string[0]; var directive = new Directive(identifier, DirectiveUtil.GetNormalisedName(identifier), restrictions, tags, offset, new List <Parameter>()); cacheItemsBuilder.Add(directive); }
protected virtual IEnumerable<IComponentRegistration> FromArguments(IInvocationExpression invocationExpression) { List<ITypeofExpression> arguments = invocationExpression.ArgumentList.Arguments .Where(argument => { var declaredType = argument.Value.Type() as IDeclaredType; return declaredType != null && declaredType.IsType(); }).Select(argument => argument.Value as ITypeofExpression) .ToList(); var first = arguments.First().ArgumentType as IDeclaredType; var last = arguments.Last().ArgumentType as IDeclaredType; return CreateRegistration(invocationExpression, first, last); }
public sealed override bool IsAvailable(IUserDataHolder cache) { myOuterInvocation = null; myExistingLambdaParameterName = null; var topLevelNode = myProvider.GetTopLevelNode(); if (topLevelNode == null) { return(false); } myOuterInvocation = FindChain(topLevelNode); return(myOuterInvocation != null); }
public override void VisitInvocationExpression([NotNull] IInvocationExpression operation) { if (!HasFoundInvocation) { foreach (IMethodSymbol methodToFind in methodsToFind) { ScanInvocation(operation, methodToFind); } if (!HasFoundInvocation) { base.VisitInvocationExpression(operation); } } }
public static string GetCalledMethod(this IInvocationExpression invocationExpression) { Contract.Requires(invocationExpression != null); var result = invocationExpression .With(x => x.InvokedExpression) .With(x => x as IReferenceExpression) .With(x => x.Reference) .With(x => x.Resolve()) .With(x => x.DeclaredElement) .With(x => x as IClrDeclaredElement) .Return(x => x.ShortName); return(result); }
private CodeContractStatement(ICSharpStatement statement, IInvocationExpression invocationExpression, CodeContractStatementType statementType) : base(statement) { Contract.Requires(invocationExpression != null); _invocationExpression = invocationExpression; _statementType = statementType; // Due to weird bug in CC compiler, I can't use the same variable in Contract.Requires // and in lambda expression. _codeContractExpression = JetBrains.Util.Lazy.Lazy.Of( () => Assertions.ContractStatementFactory.TryCreateAssertion(_invocationExpression)); }
private CodeContractStatement(ICSharpStatement statement, IInvocationExpression invocationExpression, CodeContractStatementType statementType) : base(statement) { Contract.Requires(invocationExpression != null); _invocationExpression = invocationExpression; _statementType = statementType; // Due to weird bug in CC compiler, I can't use the same variable in Contract.Requires // and in lambda expression. _codeContractExpression = JetBrains.Util.Lazy.Of( () => Assertions.ContractStatementFactory.TryCreateAssertion(_invocationExpression), true); }
private IEnumerable <IComponentRegistration> FromArguments(IInvocationExpression invocationExpression) { List <ITypeofExpression> arguments = invocationExpression.ArgumentList.Arguments .Where(argument => { var declaredType = argument.Value.Type() as IDeclaredType; return(declaredType != null && declaredType.GetClrName().Equals(clrTypeName)); }).Select(argument => argument.Value as ITypeofExpression) .ToList(); var first = arguments.First().ArgumentType as IDeclaredType; var last = arguments.Last().ArgumentType as IDeclaredType; return(CreateRegistration(invocationExpression, first, last)); }
private static bool IsSpecificMethod(IInvocationExpression invocationExpression, IClrTypeName typeName, params string[] methodNames) { var declaredElement = invocationExpression.Reference.Resolve().DeclaredElement as IMethod; if (declaredElement == null) { return(false); } if (methodNames.Any(t => t.Equals(declaredElement.ShortName))) { return(declaredElement.GetContainingType()?.GetClrName().Equals(typeName) == true); } return(false); }
private void AddWarning(IInvocationExpression element, IHighlightingConsumer consumer) { DocumentRange range; if (element.FirstChild?.LastChild is ITypeArgumentList typeInvocation) { range = typeInvocation.GetDocumentRange(); } else { range = element.InvokedExpression.GetDocumentRange(); } AddHighlighting(consumer, range); }
public IExpression CreateMigrationExpression(IInvocationExpression invocationExpression) { var arguments = invocationExpression.Arguments .Select(x => x.Value) .ToArray(); if (!arguments.Any()) { return(invocationExpression); } var factory = CSharpElementFactory.GetInstance(invocationExpression); var actualValue = GetActualValue(arguments); var shouldMethod = invocationExpression.GetFluentAssertionsPredefinedType().GetShouldMethod(actualValue.Type()); if (shouldMethod is null) { return(invocationExpression); } var shouldExpression = factory.CreateReferenceExpression("$0.$1", actualValue, shouldMethod); var replacementMethod = GetReplacementMethod(shouldMethod); if (replacementMethod is null) { return(invocationExpression); } var replacementMethodExpression = factory.CreateReferenceExpression("$0().$1", shouldExpression, replacementMethod); var list = new List <object> { replacementMethodExpression }; var expectedValue = GetExpectedValue(arguments); if (expectedValue != null) { list.Add(expectedValue); list.AddRange(arguments.Skip(GetExpectedValueSkipArgumentsCount())); } else { list.AddRange(arguments.Skip(1)); } var expressionFormat = $"$0({list.GetExpressionFormatArguments()})"; return(factory.CreateExpression(expressionFormat, list.ToArray())); }
private bool IsMethod([CanBeNull] IInvocationExpression invocationExpression, Func <IDeclaredElement, bool> methodFilter) { if (invocationExpression == null || invocationExpression.Reference == null) { return(false); } var resolveResult = invocationExpression.Reference.Resolve(); if (resolveResult.ResolveErrorType == ResolveErrorType.MULTIPLE_CANDIDATES) { return(resolveResult.Result.Candidates.Any(methodFilter)); } return(methodFilter(resolveResult.DeclaredElement)); }
/// <summary> /// Do not prefix calls with base unless local implementation exists. /// </summary> /// <param name="node"> /// The node to process. /// </param> private void DoNotPrefixCallsWithBaseUnlessLocalImplementationExists(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { IInvocationExpression invocationExpression = currentNode as IInvocationExpression; if (invocationExpression != null) { SwapBaseToThisUnlessLocalImplementation(invocationExpression); } if (currentNode.FirstChild != null) { this.DoNotPrefixCallsWithBaseUnlessLocalImplementationExists(currentNode.FirstChild); } } }
public virtual IDeclaredElement GetInvokedElement([NotNull] IInvocationExpression invocationExpression) { if (invocationExpression == null) { throw new ArgumentNullException("invocationExpression"); } if (invocationExpression.InvocationExpressionReference.CurrentResolveResult != null) { return(invocationExpression.InvocationExpressionReference.CurrentResolveResult.DeclaredElement); } else { throw new ExpressionHelperException("Null resolved result of invocation expression", invocationExpression); } }
public string Present(IInvocationExpression invocationExpression) { var method = invocationExpression.Reference.GetResolved<IMethod>(); if (method == null) return null; var displayFormatAttributeData = method.GetAttributeData<DisplayFormatAttribute>(); if (displayFormatAttributeData == null) return null; var displayFormatAttribute = displayFormatAttributeData.ToCommon(); var commonExpressions = invocationExpression.Arguments .Select((x, i) => new { Index = i, Object = GetConstantValue(x) }) .ToDictionary(x => x.Index.ToString(), x => x.Object); return _introspectionPresenter.Present(displayFormatAttribute, commonExpressions); }
public static IClrTypeName GetCallSiteType(this IInvocationExpression invocationExpression) { Contract.Requires(invocationExpression != null); var type = invocationExpression .With(x => x.InvokedExpression) .With(x => x as IReferenceExpression) .With(x => x.Reference) .With(x => x.Resolve()) .With(x => x.DeclaredElement) .With(x => x as IClrDeclaredElement) .With(x => x.GetContainingType()) .Return(x => x.GetClrName()); return(type); }
public override void VisitInvocationExpression(IInvocationExpression operation) { LogString(nameof(IInvocationExpression)); var isVirtualStr = operation.IsVirtual ? "virtual " : string.Empty; var isStaticStr = operation.Instance == null ? "static " : string.Empty; var spacing = !operation.IsVirtual && operation.Instance != null ? " " : string.Empty; LogString($" ({isVirtualStr}{isStaticStr}{spacing}"); LogSymbol(operation.TargetMethod, header: string.Empty); LogString(")"); LogCommonPropertiesAndNewLine(operation); VisitInstanceExpression(operation.Instance); VisitArguments(operation); }
private static void CheckInvocationExpression([NotNull] IInvocationExpression invocation, [NotNull] IHighlightingConsumer consumer) { var invokedExpression = invocation.InvokedExpression; if (invokedExpression == null) { return; } CheckInvocationInfo(invocation, invokedExpression as IReferenceExpression, consumer); var invocationReference = invocation.InvocationExpressionReference.NotNull("reference != null"); var resolveResult = invocationReference.Resolve(); if (resolveResult.ResolveErrorType != ResolveErrorType.OK) { return; } var method = resolveResult.DeclaredElement as IMethod; if (method == null) { return; } if (method.IsIterator) { consumer.AddHighlighting( new ObjectAllocationHighlighting(invocation, "iterator method call"), invokedExpression.GetExpressionRange()); } else if (method.ReturnType.Classify == TypeClassification.REFERENCE_TYPE) { var annotationsCache = invocation.GetPsiServices().GetCodeAnnotationsCache(); var linqTunnelAnnotationProvider = annotationsCache.GetProvider <LinqTunnelAnnotationProvider>(); var pureAnnotationProvider = annotationsCache.GetProvider <PureAnnotationProvider>(); if (pureAnnotationProvider.GetInfo(method) && linqTunnelAnnotationProvider.GetInfo(method)) { consumer.AddHighlighting( new ObjectAllocationHighlighting(invocation, "LINQ method call"), invokedExpression.GetExpressionRange()); } } }
// todo: ?. invocations? private static void CheckInvocationExpression([NotNull] IInvocationExpression invocationExpression, [NotNull] IHighlightingConsumer consumer) { var invokedReference = invocationExpression.InvokedExpression as IReferenceExpression; if (invokedReference == null) { return; } var resolveResult = invocationExpression.InvocationExpressionReference.Resolve(); if (!resolveResult.ResolveErrorType.IsAcceptable) { return; } var method = resolveResult.DeclaredElement as IMethod; if (method == null || method.IsStatic) { return; } var classType = method.GetContainingType() as IClass; if (classType == null) { return; } var qualifierType = GetQualifierExpressionType(invokedReference.QualifierExpression, invokedReference); const string description = "inherited 'System.Object' virtual method call on value type instance"; if (qualifierType.IsValueType()) { consumer.AddHighlighting( new BoxingAllocationHighlighting(invocationExpression, description), invokedReference.NameIdentifier.GetDocumentRange()); } else if (qualifierType.IsUnconstrainedGenericType()) { consumer.AddHighlighting( new BoxingAllocationPossibleHighlighting(invocationExpression, description), invokedReference.NameIdentifier.GetDocumentRange()); } }
private static bool TryConvertSyncCallToAsyncCall([NotNull] IInvocationExpression invocationExpression, [NotNull] CSharpElementFactory factory, [NotNull] IPsiModule psiModule) { var referenceCurrentResolveResult = invocationExpression.Reference?.Resolve(); if (referenceCurrentResolveResult?.IsValid() != true) { return(false); } var invocationMethod = referenceCurrentResolveResult.DeclaredElement as IMethod; if (invocationMethod == null) { return(false); } var invokedObjectType = (invocationExpression.ConditionalQualifier as IReferenceExpression)?.QualifierExpression?.Type(); var asyncMethod = FindEquivalentAsyncMethod(invocationMethod, invokedObjectType, psiModule); if (asyncMethod != null) { if (!TryConvertInnerReferenceToAsync(invocationExpression, factory, psiModule)) { return(false); } ReplaceCallToAsync(invocationExpression, factory, useAsync: true); return(true); } var asyncMethodWithFunc = FindEquivalentAsyncMethodWithAsyncFunc(invocationMethod); if (asyncMethodWithFunc == null) { return(false); } if (!TryConvertInnerReferenceToAsync(invocationExpression, factory, psiModule)) { return(false); } if (TryConvertParameterFuncToAsync(invocationExpression, factory, psiModule)) { ReplaceCallToAsync(invocationExpression, factory, useAsync: true); } return(true); }
public static ICSharpArgument GetTemplateArgument(this IInvocationExpression invocationExpression) { if (!(invocationExpression.Reference.Resolve().DeclaredElement is ITypeMember typeMember)) { return(null); } var templateParameterName = typeMember.GetTemplateParameterName(); if (string.IsNullOrEmpty(templateParameterName)) { return(null); } return(invocationExpression.ArgumentList.Arguments.FirstOrDefault( a => a.MatchingParameter?.Element.ShortName == templateParameterName)); }
private static IEnumerable <IComponentRegistration> CreateRegistration(IInvocationExpression invocationExpression, IDeclaredType first, IDeclaredType last) { if (first == null || last == null) { yield break; } ITypeElement fromType = first.GetTypeElement(); ITypeElement toType = last.GetTypeElement(); if (fromType != null && toType != null) { yield return(fromType.Equals(toType) ? new ComponentRegistration(invocationExpression, fromType) : new ComponentRegistration(invocationExpression, fromType, toType)); } }
private static IReferenceExpression ExtractContractResultReference(IInvocationExpression contractResultExpression) { Contract.Requires(contractResultExpression != null); var callSiteType = contractResultExpression.GetCallSiteType(); var method = contractResultExpression.GetCalledMethod(); if (callSiteType.With(x => x.FullName) != typeof(Contract).FullName || method != "Result") { return(null); } return(contractResultExpression .With(x => x.InvokedExpression) .Return(x => x as IReferenceExpression)); }
public string Present(IInvocationExpression invocationExpression) { var method = invocationExpression.Reference.NotNull().GetResolved <IMethod>(); var displayFormatAttributeData = method?.GetAttributeData <DisplayFormatAttribute>(); if (displayFormatAttributeData == null) { return(null); } var displayFormatAttribute = displayFormatAttributeData.ToCommon(); var commonExpressions = invocationExpression.Arguments .Select((x, i) => new { Index = i, Object = GetConstantValue(x) }) .ToDictionary(x => x.Index.ToString(), x => x.Object); return(_introspectionPresenter.Present(displayFormatAttribute, commonExpressions)); }
private IEnumerable<IComponentRegistration> CreateRegistration(IInvocationExpression invocationExpression, IDeclaredType first, IDeclaredType last) { if (first == null || last == null) { yield break; } ITypeElement fromType = first.GetTypeElement(); ITypeElement toType = last.GetTypeElement(); if (fromType != null && toType != null) { yield return fromType.Equals(toType) ? new ComponentRegistration(invocationExpression, fromType) : new ComponentRegistration(invocationExpression, fromType, toType); } }
private static bool GetTypeParameters(IInvocationExpression invocation, out IType[] typeParameters) { typeParameters = new IType[0]; if (invocation.Arguments.Count != 0) { ICSharpExpression[] expressions; if (invocation.Arguments[0].Expression is IArrayCreationExpression) { var initiallizer = ((IArrayCreationExpression)invocation.Arguments[0].Expression).ArrayInitializer; if (initiallizer != null) { expressions = initiallizer.ElementInitializers .Cast <IExpressionInitializer>() .Select(i => i.Value) .ToArray(); } else { expressions = new ICSharpExpression[0]; } } else { expressions = invocation.Arguments.Select(a => a.Expression) .Cast <ICSharpExpression>() .ToArray(); } typeParameters = new IType[expressions.Length]; for (int i = 0; i < expressions.Length; i++) { var resolvedType = ResolveReflectedTypeInternal(expressions[i]); if (resolvedType.ResolvedAs == ReflectedTypeResolution.Exact) { typeParameters[i] = resolvedType.Type; } else { return(false); // } } } return(true); }
protected override IEnumerable<IComponentRegistration> FromGenericArguments(IInvocationExpression invocationExpression) { var serviceType = invocationExpression.TypeArguments.First() as IDeclaredType; if (serviceType == null) { yield break; } var typeElement = serviceType.GetTypeElement(); if (typeElement == null) { yield break; } IEnumerable<ITypeElement> concreteTypes = invocationExpression.Arguments.SelectMany(argument => argument.Value.GetRegisteredTypes()); yield return CreateRegistrations(invocationExpression, typeElement, concreteTypes); }
// This will be called multiple times in the case of chained method calls. public override void VisitInvocationExpression(IInvocationExpression invocationExpressionParam) { // TODO: Loop through here somehow and work up through the string calls like ToLower().ToUpper() et et. //do // { IReferenceExpression expression = invocationExpressionParam.InvokedExpression as IReferenceExpression; if (expression == null) return; // As I understand it this takes the abstract syntax element that is e.ToString() and resolves it such that // we know it's the System.Enum.ToString() method call. IResolveResult resolveResult = expression.Reference.Resolve(); IDeclaredElement e = resolveResult.DeclaredElement; if (e == null) return; ITypeElement containingType = e.GetContainingType(); // work up through the string calls //invocationExpressionParam = invocationExpressionParam.InvocationExpressionReference as IInvocationExpression; //var allowed = new[] { "ToUpper", "ToLower", "ToString" }; //if (!new List<string>(allowed).Contains(e.ShortName)) // return; // } //while (containingType != null && containingType.CLRName == "System.String"); if(containingType == null) return; if(containingType.CLRName == "System.Enum" && e.ShortName == "ToString") { Found = true; // Save the enum declaration so we can implement the fix. this.FoundEnumReference = invocationExpressionParam.Reference; this.EnumReferenceName = expression.QualifierExpression.GetText(); IExpressionType qe = expression.QualifierExpression.GetExpressionType(); this.EnumDeclaredName = ((IDeclaredType)qe).GetPresentableName(PsiLanguageType.GetByProjectFile(invocationExpressionParam.GetProjectFile())); } }
/// <summary>The is available.</summary> /// <param name="cache">The cache.</param> /// <returns>The <see cref="bool"/>.</returns> public override bool IsAvailable(IUserDataHolder cache) { this.InvocationExpression = null; var invocationExpression = this.provider.GetSelectedElement<IInvocationExpression>(true, true); if (invocationExpression == null) { return false; } var referenceExpression = invocationExpression.InvokedExpression as IReferenceExpression; if (referenceExpression == null) { return false; } var declaredElement = referenceExpression.Reference.Resolve().DeclaredElement; if (declaredElement == null) { return false; } if (declaredElement.ShortName != "GetItem") { return false; } var containingType = this.GetContainingTypeName(declaredElement); if (containingType == null) { return false; } if (containingType != "Sitecore.Data.Database") { return false; } this.InvocationExpression = invocationExpression; return true; }
private IDeclaredType GetDeclaredType(IInvocationExpression invocationExpression) { if (invocationExpression.TypeArguments.Count > 0) { return invocationExpression.TypeArguments[0].GetScalarType(); } if (invocationExpression.ArgumentList.Arguments.Count > 0) { var typeOfExpression = invocationExpression.ArgumentList.Arguments[0].Value as ITypeofExpression; if (typeOfExpression == null) { return null; } return typeOfExpression.ArgumentType.GetScalarType(); } return null; }