public static IEnumerable <IDeclaration> GetDeclarationsFromRoot(this ITreeNode from) { if (from is PascalBlock) { return(from.Children().Where(it => it is PascalVariableDeclarationPart).TryGetSingleItem()?.GetDeclarationsInDescendants() ?? Enumerable.Empty <IDeclaration>()); } if (from is PascalProcedureDeclaration || from is PascalFunctionDeclaration) { return(from.Children().Where(it => it is PascalFormalParameterList).TryGetSingleItem()?.GetDeclarationsInDescendants() ?? Enumerable.Empty <IDeclaration>()); } return(Enumerable.Empty <IDeclaration>()); }
private IEnumerable <IReference> GetReferencesImpl(ITreeNode element) { if (!(element is INitraAst)) { yield break; } var reference = element as IReference; if (reference != null) { yield return(reference); } if (element is ITokenNode) { yield break; } foreach (var n in element.Children()) { if (ReferenceEquals(n, element)) { continue; } foreach (var reference1 in GetReferencesImpl(n)) { yield return(reference1); } } }
public IEnumerable <ClassificationTemplate> AvailableObservedDataCategoriesIn(ITreeNode <IClassification> parentClassificationNode) { return(parentClassificationNode.Children <ObservedDataNode>().SelectMany(node => node.Tag.Repository.ExtendedProperties) .Select(property => property.Name) .Distinct() .Select(property => new ClassificationTemplate(property))); }
private static void Traverse(ITreeNode node, StringBuilder sb, int depth, CompletionTargetMarker marker) { if (node.IsWhitespaceToken()) { return; } sb.Indent(depth); sb.ObjectId(node, marker); sb.AppendLine(); foreach (var child in node.Children()) { if (Visited.Contains(child)) { sb.Indent(depth); sb.Append("--> "); sb.ObjectId(node, marker); sb.AppendLine(); } else { Visited.Add(child); Traverse(child, sb, depth + 1, marker); } } }
public override void VisitNode(ITreeNode node, ISet <MethodRef> context) { foreach (var childNode in node.Children <ICSharpTreeNode>()) { childNode.Accept(this, context); } }
private static void ProcessCSharpChildren([NotNull] ITreeNode node, [NotNull] CodeStructureElement parentElement, [NotNull] CSharpCodeStructureProcessingState state) { foreach (ITreeNode childNode in node.Children()) { ProcessCSharpNode(childNode, parentElement, state); } }
static IEnumerable <ICSharpTreeNode> GetAllChildrenRecursive([NotNull] ITreeNode node) { foreach (var childNode in node.Children <ICSharpTreeNode>()) { yield return(childNode); foreach (var n in GetAllChildrenRecursive(childNode)) { yield return(n); } } }
public static IReferenceExpression TryGetFirstReferenceExpression(ITreeNode currentNode) { var childNodes = currentNode.Children(); var firstChildNode = childNodes.FirstOrDefault(); if (firstChildNode == null) { return(null); } return(firstChildNode as IReferenceExpression ?? TryGetFirstReferenceExpression(firstChildNode)); }
public override void VisitNode(ITreeNode node, IList <IStatement> context) { node.Children <ICSharpTreeNode>().ForEach( child => { try { child.Accept(this, context); } catch (NullReferenceException) { } catch (AssertException) { } }); }
public static int CountChildren <T>(this ITreeNode node) where T : ITreeNode { var treeNodes = node.Children().ToList(); var childOfType = treeNodes.OfType <T>(); var count = childOfType.Count(); foreach (var childNodes in treeNodes) { count += CountChildren <T>(childNodes); } return(count); }
private void HighlightMethodChainsThatAreTooLong(ITreeNode statement, IHighlightingConsumer consumer, int threshold) { var children = statement.Children(); foreach (var treeNode in children) { if (treeNode is IReferenceExpression referenceExpression) { HighlightReferenceExpressionIfNeeded(referenceExpression, consumer, threshold); } else { HighlightMethodChainsThatAreTooLong(treeNode, consumer, threshold); } } }
public static List <IDeclaration> GetSiblingDecls(ITreeNode element) { var res = new List <IDeclaration>(); if (element is HaskellTopdecl || element is HaskellDecl || element is HaskellFunlhs || element is HaskellApat) { res = element.Children().SelectMany(x => GetSiblingDecls(x)).ToList(); } if (element is IDeclaration d) { res.Add(d); } return(res); }
private static IEnumerable<IStructuralMatchResult> FindMatches(IStructuralMatcher matcher, ITreeNode statement) { if (statement == null || !statement.IsValid()) yield break; var result = matcher.Match(statement); if (result.Matched) { yield return result; yield break; } foreach (var r in statement.Children().SelectMany(node => FindMatches(matcher, node))) { yield return r; } }
public static IEnumerable <ITreeNode> GetEnvDTEModelChildren([NotNull] this ITreeNode node) { foreach (var directChild in node.Children()) { if (PsiElementRegistrar.ShouldAddToModel(directChild)) { yield return(directChild); } else if (PsiElementRegistrar.ShouldVisitChildren(directChild)) { foreach (var modelChild in GetEnvDTEModelChildren(directChild)) { yield return(modelChild); } } } }
public static int GetChildrenDepth(this ITreeNode node) { var childrenDepth = 0; var children = node.Children(); foreach (var block in children) { var levelOfCurrentBlock = GetChildrenDepth(block); childrenDepth = Math.Max(levelOfCurrentBlock, childrenDepth); } if (IsNodeThatIncreasesDepth(node)) { return(childrenDepth + 1); } return(childrenDepth); }
static IEnumerable <ICSharpTreeNode> GetAllChildrenRecursive([NotNull] ITreeNode node) { foreach (var childNode in node.Children <ICSharpTreeNode>()) { if (childNode is ILocalFunctionDeclaration || childNode is IAnonymousFunctionExpression) { continue; // skip the element (do not drill down) } yield return(childNode); foreach (var n in GetAllChildrenRecursive(childNode)) { yield return(n); } } }
public static IEnumerable <T> GetChildrenRecursive <T>(this ITreeNode node) where T : ITreeNode { var nodeChildren = node.Children().ToList(); var list = new List <T>(); var childOfType = nodeChildren.OfType <T>(); list.AddRange(childOfType); foreach (var childNode in nodeChildren) { var childrenOfType = GetChildrenRecursive <T>(childNode); list.AddRange(childrenOfType); } return(list); }
private static IEnumerable <IStructuralMatchResult> FindMatches(IStructuralMatcher matcher, ITreeNode statement) { if (statement == null || !statement.IsValid()) { yield break; } var result = matcher.Match(statement); if (result.Matched) { yield return(result); yield break; } foreach (var r in statement.Children().SelectMany(node => FindMatches(matcher, node))) { yield return(r); } }
private IEnumerable<IReference> GetReferencesImpl(ITreeNode element) { if (!(element is INitraAst)) yield break; var reference = element as IReference; if (reference != null) yield return reference; if (element is ITokenNode) yield break; foreach (var n in element.Children()) { if (ReferenceEquals(n, element)) continue; foreach (var reference1 in GetReferencesImpl(n)) yield return reference1; } }
private static void AddScope(ITreeNode node, Scope parentScope) { var scope = parentScope; if (node is SpringDefine define) { define.ParentScope = parentScope; } else if (node is SpringLambda lambda) { lambda.Scope = new Scope(parentScope); scope = lambda.Scope; } else if (node is SpringLet let) { let.Scope = new Scope(parentScope); scope = let.Scope; } else if (node is SpringIdent ident) { ident.ParentScope = scope; } else if (node is SpringIdentDecl decl) { scope.Add(decl.DeclaredElement); } else if (node is SpringBindingExpr) { // Let node passes to Bind (<ident> <expr>) // newly created scope, but <expr> have to have // it's parent scope. scope = scope.ParentScope; } foreach (var child in node.Children()) { AddScope(child, scope); } }
public IDictionary <int, IList <ITreeNode> > Visit(ITreeNode treeRootNode, IDictionary <int, IList <ITreeNode> > mapTree) { CheckVisitParameters(treeRootNode, mapTree); IList <ITreeNode> listNodes = null; if (mapTree.TryGetValue(treeRootNode.Level(), out listNodes)) { listNodes.Add(treeRootNode); } else { listNodes = new List <ITreeNode>(); listNodes.Add(treeRootNode); mapTree.Add(treeRootNode.Level(), listNodes); } foreach (var treeNode in treeRootNode.Children()) { mapTree = Visit(treeNode, mapTree); } return(mapTree); }
public virtual void RemoveChildrenClassifications(ITreeNode <IClassification> parentClassificationNode) { parentClassificationNode.Children <ITreeNode <IClassification> >().Each(c => removeClassification(c, recursive: true)); }
public override void VisitNode(ITreeNode node, SST context) { _cancellationToken.ThrowIfCancellationRequested(); node.Children <ICSharpTreeNode>().ForEach(child => child.Accept(this, context)); }
public static IReadOnlyList <ITreeNode <T> > NodesWithTags <T>(this ITreeNode treeNode) { return(treeNode.Children <ITreeNode <T> >()); }
private ITreeNode simulationConfigurationNodeUnder(ITreeNode simulationNode) { return(simulationNode.Children <BuildConfigurationNode>().First()); }
public override void VisitNode(ITreeNode node, IHighlightingConsumer consumer) { var sourceFile = node.GetSourceFile(); if (sourceFile == null) { return; } if (!myInternalMode && myProcessKind != DaemonProcessKind.VISIBLE_DOCUMENT) { return; } if (myProcessKind == DaemonProcessKind.VISIBLE_DOCUMENT) { // TODO: Highlight identifiers // if (myIdentifierHighlightingEnabled) var info = myVisualElementHighlighter.CreateColorHighlightingInfo(node); if (info != null) { consumer.AddHighlighting(info.Highlighting, info.Range); } } var references = node.GetReferences(myReferenceProvider); myResolveProblemHighlighter.CheckForResolveProblems(node, consumer, references); // TODO: Move to ShaderLabSyntaxHighlightingStage // (Not Rider's syntax highlighting though!) // E.g. protobuf support has a SyntaxHighlightingStage that will do this, // plus look for simple syntax validation errors, e.g. enums must have at // least one value defined, correct value for `syntax "proto3"`, etc. // And then a separate identifier if (!sourceFile.PsiModule.IsMiscFilesProjectModule() && node is IErrorElement errorElement) { DocumentRange range; if (node.Children().Any(t => t.Children <ICgContent>().Any())) { range = node.MeaningfulChildren().FirstOrDefault()?.GetDocumentRange() ?? DocumentRange.InvalidRange; } else { range = errorElement.GetDocumentRange(); } if (!range.IsValid()) { range = node.Parent.GetDocumentRange(); } if (range.TextRange.IsEmpty) { if (range.TextRange.EndOffset < range.Document.GetTextLength()) { range = range.ExtendRight(1); } else if (range.TextRange.StartOffset > 0) { range = range.ExtendLeft(1); } } consumer.AddHighlighting(new ShaderLabSyntaxError(errorElement.ErrorDescription, range)); } base.VisitNode(node, consumer); }