protected Location GetLocation(ICSharpTreeNode expression) { var start = expression.GetDocumentStartOffset().Offset; var end = expression.GetDocumentEndOffset().Offset; return(new Location(MyParams.GetPersistentFileId(), start, end)); }
private void AddIf(ICSharpTreeNode node, CompletionCase completionCase, IList <IStatement> body) { if (IsTargetMatch(node, completionCase)) { body.Add(EmptyCompletionExpression); } }
private bool IsTargetMatch(ICSharpTreeNode o, CompletionCase completionCase) { var isValid = _marker.HandlingNode != null; var isMatch = o == _marker.HandlingNode; var isRightCase = _marker.Case == completionCase; return(isValid && isMatch && isRightCase); }
private void AnalyzeStatements([NotNull] ICSharpTreeNode scope, [NotNull] PropertiesAccessContainer referencesContainer) { var visitor = new PropertiesAnalyzerVisitor(referencesContainer, scope, new Dictionary <IReferenceExpression, IEnumerator <ITreeNode> >(ourComparer), new HashSet <IReferenceExpression>(ourComparer)); scope.ProcessThisAndDescendants(visitor); }
internal EmptyArrayInitializationHighlighting( [NotNull] string message, [NotNull] ICSharpTreeNode treeNode, [NotNull] IType arrayElementType) : base(message) { TreeNode = treeNode; ArrayElementType = arrayElementType; }
public CachePropertyValueQuickFix(InefficientPropertyAccessWarning warning) { myReferences = warning.References; myHighlightedReference = warning.HighlightedReference; myInlineCache = warning.InlineCacheValue; myInlineRestore = warning.InlineRestoreValue; myCacheAnchor = warning.CacheAnchor; myRestoreAnchor = warning.RestoreAnchor; }
public SnapNode([NotNull] ICSharpTreeNode node) { if (node == null) { throw new ArgumentNullException("node"); } Node = node; Occurences = new Dictionary <Guid, ExpressionKind>(); InitialOccurence = Guid.Empty; }
protected override void Analyze(ITreeNode node, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { // container to collect groups of IReferenceExpressions which can be cached var container = new PropertiesAccessContainer(consumer); ICSharpTreeNode scope = null; switch (node) { case ICSharpParametersOwnerDeclaration parametersOwnerDeclaration: var codeBody = parametersOwnerDeclaration.GetCodeBody(); scope = codeBody.BlockBody ?? (ICSharpTreeNode)codeBody.ExpressionBody; break; case ILambdaExpression lambdaExpression: codeBody = lambdaExpression.GetCodeBody(); scope = codeBody.BlockBody ?? (ICSharpTreeNode)codeBody.ExpressionBody; break; case IPropertyDeclaration propertyDeclaration: var initial = propertyDeclaration.Initial; if (initial != null) { scope = initial; } else { foreach (var accessorDeclaration in propertyDeclaration.AccessorDeclarationsEnumerable) { codeBody = accessorDeclaration.GetCodeBody(); var body = codeBody.BlockBody ?? (ICSharpTreeNode)codeBody.ExpressionBody; if (body != null) { AnalyzeStatements(body, container); container.InvalidateCachedValues(); } } } break; default: return; } if (scope == null) { return; } AnalyzeStatements(scope, container); // cache all references which is not invalidated dut to no related expression was found container.InvalidateCachedValues(); }
private IInvocationExpression FindInvocationChain([NotNull] ICSharpTreeNode topLevelNode) { foreach (var invocation in topLevelNode.Descendants().OfType <IInvocationExpression>()) { if (MatchChain(invocation)) { return(invocation); } } return(null); }
/// <summary> /// Handles the removal of an import directive. /// </summary> /// <param name="psiServices">The PSI services.</param> /// <param name="scope">The namespace scope.</param> /// <param name="usingDirective">The using directive to remove.</param> /// <param name="action">The action to perform to remove the directive.</param> public void HandleRemoveImport(IPsiServices psiServices, ICSharpTypeAndNamespaceHolderDeclaration scope, IUsingDirective usingDirective, Action action) { ICSharpTreeNode namespaceNode = usingDirective.GetUsedNamespaceNode(); if (namespaceNode == null) { Assertion.Fail("Only a namespace using can be removed."); } else { TreeTextRange range = namespaceNode.GetTreeTextRange(); HandleRemoveImportInternal(psiServices, scope, usingDirective, action, CSharpLanguage.Instance, range); } }
public static HashSet <Assertion> CollectAssertions( [NotNull] AssertionMethodAnnotationProvider assertionMethodAnnotationProvider, [NotNull] AssertionConditionAnnotationProvider assertionConditionAnnotationProvider, [NotNull] ICSharpTreeNode rootNode) { var forTypeLevelInitializersOnly = rootNode is IClassLikeDeclaration; var assertions = new HashSet <Assertion>(); foreach (var expression in rootNode.Descendants <ICSharpExpression>()) { Debug.Assert(expression != null); var isInTypeLevelInitializer = expression.PathToRoot() .Any(node => node is IExpressionInitializer && (node.Parent is IFieldDeclaration || node.Parent is IPropertyDeclaration)); if (forTypeLevelInitializersOnly != isInTypeLevelInitializer) { continue; } switch (expression) { case IInvocationExpression invocationExpression: var assertionStatement = AssertionStatement.TryFromInvocationExpression( invocationExpression, assertionMethodAnnotationProvider, assertionConditionAnnotationProvider); if (assertionStatement != null) { assertions.Add(assertionStatement); } var inlineAssertion = InlineAssertion.TryFromInvocationExpression(invocationExpression); if (inlineAssertion != null) { assertions.Add(inlineAssertion); } break; case ISuppressNullableWarningExpression suppressNullableWarningExpression: assertions.Add(new NullForgivingOperation(suppressNullableWarningExpression)); break; } } return(assertions); }
private void AddAny(ExpressionKind expressionKind, ICSharpTreeNode sharpTreeNode) { if (expressionKind == ExpressionKind.None || expressionKind == ExpressionKind.StubCandidate) { return; } var node = SnapNodes.SingleOrDefault(t => t.Node == sharpTreeNode); if (node == null) { SnapNodes.Add(new SnapNode(sharpTreeNode, expressionKind)); } else { node.AddKind(expressionKind); } }
public bool IsUnder(ICSharpTreeNode node) { var store = node.GetSettingsStore(); var customTypes = store.EnumIndexedValues(AsyncConverterSettingsAccessor.ConfigureAwaitIgnoreAttributeTypes).ToArray(); if (customTypes.IsNullOrEmpty()) { return(false); } var containingFunctionLikeDeclarationOrClosure = node.GetContainingFunctionDeclarationIgnoringClosures(); if (containingFunctionLikeDeclarationOrClosure?.ContainsAttribute(customTypes) == true) { return(true); } return(false); }
public UnexpectedReferenceTypeException(IDeclaredElement declaredElement, ReferenceExpressionEater eater, ICSharpTreeNode node) : base(string.Format("Unexpected reference declared type. Expected field, property, event, constant, variable or class, but was [{0}]", declaredElement.GetType()), eater, node) { DeclaredElement = declaredElement; }
public MoqStubOptionWrongTypeException(ICSharpNodeEater eater, ICSharpTreeNode node) : base(string.Format("Moq-stub options has wrong type. Expected conditional-and, equility, invocation, reference expressions. But was [{0}]", node.GetType()), eater, node) { }
public MoqStubWrongSyntaxException(string message, ICSharpNodeEater eater, ICSharpTreeNode node) : base(message, eater, node) { }
public EatingException(string message, Exception exception, ICSharpNodeEater eater, ICSharpTreeNode node) : this(message, eater, node) { Exception = exception; }
private static IType GetQualifierExpressionType([CanBeNull] ICSharpExpression qualifierExpression, [NotNull] ICSharpTreeNode context) { if (qualifierExpression.IsThisOrBaseOrNull()) { var structDeclaration = context.GetContainingTypeDeclaration() as IStructDeclaration; var structTypeElement = structDeclaration?.DeclaredElement; if (structTypeElement == null) { return(null); } return(TypeFactory.CreateType(structTypeElement)); } var expressionType = qualifierExpression.GetExpressionType(); return(expressionType.ToIType()); }
public EatingException(Exception exception, ICSharpNodeEater eater, ICSharpTreeNode node) : this(exception.Message, exception, eater, node) { }
public UnexpectedAssignDestinationException(ICSharpExpression destination, AssignmentExpressionEater eater, ICSharpTreeNode node) : base(string.Format("Unexpected assign destination. Expected IReferenceExpression, but was [{0}]", destination.GetType()), eater, node) { Destination = destination; }
public EatingException(string message, ICSharpNodeEater eater, ICSharpTreeNode node) { Message = message; Eater = eater; Node = node; }
public SnapNode(ICSharpTreeNode node, ExpressionKind kind) : this(node) { AddKind(kind); }
public void InvalidateCachedValues(IReferenceExpression key) { if (!myPropertiesMap.ContainsKey(key)) { return; } var highlighitingElements = myPropertiesMap[key]; Assertion.Assert(highlighitingElements.Count > 0, "highlighitingElements.Length > 0"); // calculate read/write operations for property int write = 0; int read = 0; int startHighlightIndex = -1; ICSharpTreeNode readAnchor = null; bool inlineCacheValue = false; ICSharpTreeNode writeAnchor = null; IReferenceExpression lastWriteExpression = null; bool inlineRestoreValue = false; for (int i = 0; i < highlighitingElements.Count; i++) { var referenceExpression = highlighitingElements[i]; var accessType = referenceExpression.GetAccessType(); if (read == 0 && write == 0) { readAnchor = referenceExpression.GetContainingStatementLike().NotNull("readAnchor != null"); var previousRelatedExpression = GetPreviousRelatedExpression(referenceExpression, readAnchor); // if we have related expression before considered reference expression, we can only inline reading into statement // Example: // transform.Position = (transform.localPosition = Vector3.Up) + transform.position + transform.position; // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // transform.localPosition is related to transform.position, but we need cache our variable // The result is: // var cache = transform.position; // transform.position = (transform.localPosition = Vector3.Up) + (cache = transform.position) + cache; inlineCacheValue = previousRelatedExpression != null; } if (accessType.HasFlag(ExpressionAccessType.Write)) { write++; lastWriteExpression = referenceExpression; } if (accessType.HasFlag(ExpressionAccessType.Read)) { read++; } if (startHighlightIndex == -1 && (read == 2 || write == 2 | read + write == 3)) { startHighlightIndex = i; } } if (lastWriteExpression != null) { writeAnchor = lastWriteExpression.GetContainingStatementLike().NotNull("writeAnchor != null"); if (writeAnchor is IReturnStatement || writeAnchor is IYieldStatement yieldStatement && yieldStatement.StatementType == YieldStatementType.YIELD_RETURN) { inlineRestoreValue = true; } else { var relatedExpressions = GetFinder(lastWriteExpression).GetRelatedExpressions(writeAnchor, lastWriteExpression); inlineRestoreValue = relatedExpressions.Any(); } }
public UnexpectedTypeOfNodeToEatException(Type expectedType, ICSharpNodeEater eater, ICSharpTreeNode node) : base(string.Format("Unexpected type of tree node no eat. Expected [{0}], but was [{1}]", expectedType, node.GetType()), eater, node) { }
public MoqStubOptionTargetWrongTypeException(ICSharpNodeEater eater, ICSharpTreeNode node) : base(string.Format("Moq-stub option target has wrong type. Expected invocation or reference expression. But was [{0}]", node.GetType()), eater, node) { }
private static bool HasError(ICSharpTreeNode prev) { return(prev.LastChild is IErrorElement); }
protected TreeNodeBase(ICSharpTreeNode treeNode) { _treeNode = treeNode; }
internal ThrowExceptionInUnexpectedLocationWarning([NotNull] string message, [NotNull] ICSharpTreeNode thrownStatementOrExpression) : base(message) => this.thrownStatementOrExpression = thrownStatementOrExpression;