/// <summary> /// Processes a node, before its descendants are processed. /// </summary> /// <param name="element">The node to process.</param> public override void ProcessBeforeInterior(ITreeNode element) { string attributeId = GetHighlightingAttributeId(element); if (attributeId != null) { DocumentRange range = element.GetHighlightingRange(); AddHighlighting(new HighlightingInfo(range, new PredefinedHighlighting(attributeId, range))); } }
public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var statements = match.GetMatchedElementList("statements").Cast<ICSharpStatement>(); var collectedTypes = statements.SelectMany(statement => { var returnTypeCollector = new ReturnTypeCollector(new UniversalContext(statement.GetPsiModule())); statement.ProcessThisAndDescendants(returnTypeCollector); return returnTypeCollector.CollectedTypes; }); foreach (var type in collectedTypes) { var declaredType = type as IDeclaredType; if (declaredType != null) { var typeElement = declaredType.GetTypeElement(); if (typeElement != null) { yield return new ServiceRegistration(registrationRootElement, typeElement); } } } } }
public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var argument = match.GetMatchedElement(ElementName) as ICSharpArgument; if (argument == null) { yield break; } // match typeof() expressions var typeOfExpression = argument.Value as ITypeofExpression; if (typeOfExpression != null) { var typeElement = ((IDeclaredType)typeOfExpression.ArgumentType).GetTypeElement(); if (typeElement == null) // can happen if the typeof() expression is empty { yield break; } yield return new ComponentRegistration(registrationRootElement, typeElement); } } }
/// <summary> /// The code must not contain multiple whitespace in a row. /// </summary> /// <param name="node"> /// The node. /// </param> public void CodeMustNotContainMultipleWhitespaceInARow(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ITokenNode currentToken = currentNode as ITokenNode; ITokenNode previousToken = currentToken.GetPrevToken(); if (previousToken != null) { if (currentToken.GetTokenType() == CSharpTokenType.WHITE_SPACE && previousToken.GetTokenType() == CSharpTokenType.WHITE_SPACE) { using (WriteLockCookie.Create(true)) { LowLevelModificationUtil.DeleteChild(currentToken); } } } } if (currentNode.FirstChild != null) { this.CodeMustNotContainMultipleWhitespaceInARow(currentNode.FirstChild); } } }
public TreeConnection(ITreeNode ignParent, ITreeNode ignChild, List<DPoint> lstPt) : this() { IgnChild = ignChild; IgnParent = ignParent; LstPt = lstPt; }
public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { // This entire thing is one big hack. Need to come back to it one day :) // There is (currently) no way to create a pattern that would match the Bind() call with implicit this in ReSharper SSR. // Therefore I'm only matching by the method name only, and later verifying that the method invocation's qualifier // is indeed derived from global::Ninject.Syntax.IBindingRoot if (!IsNinjectBindCall(registrationRootElement)) { yield break; } IExpressionStatement statement = GetParentExpressionStatemenmt(registrationRootElement); if (statement == null) { yield break; } foreach (var toPattern in toPatterns) { var implementedByRegistration = toPattern.GetComponentRegistrations(statement.Expression) .Cast<ComponentRegistration>() .FirstOrDefault(); if (implementedByRegistration != null) { foreach (var registration in DoCreateRegistrations(statement.Expression).OfType<ComponentRegistration>()) { registration.Implementation = implementedByRegistration.ServiceType; yield return registration; } } } }
private static bool IsAssignment(ITreeNode referenceExpression) { var binaryexpression = referenceExpression.Parent as IBinaryExpression; return binaryexpression != null && binaryexpression.LeftOperand == referenceExpression && IsAssignmentImpl(binaryexpression); }
private static void PrintTree(IDomainTree domainTree, ITreeNode node, String tab = "") { var outputAttributeId = domainTree.Attributes.Count - 1; if (node.IsLeaf()) { var values = domainTree.GetAllSymbolicValuesOfAttribute(SymbolicDomainDataParams.CreateIt(node.Data, outputAttributeId)); if (values.Length == 0) { Console.WriteLine("{0}\t{1} = \"null\";", tab, domainTree.Attributes[outputAttributeId]); } else { Console.WriteLine("{0}\t{1} = \"{2}\";", tab, domainTree.Attributes[outputAttributeId], domainTree.Domain[outputAttributeId][values[0]]); } return; } var numvalues = node.Children.Length; for (var i = 0; i < numvalues; i++) { Console.WriteLine(tab + "if( " + domainTree.Attributes[node.TestAttribute] + " == \"" + domainTree.Domain[node.TestAttribute][i] + "\") {"); PrintTree(domainTree, node.Children[i], tab + "\t"); if (i != numvalues - 1) Console.Write(tab + "} else "); else Console.WriteLine(tab + "}"); } }
private static void GetNodePairs(ITreeNode firstNode, ITreeNode lastNode, IList<FormattingRange> list) { var firstChild = firstNode; var lastChild = lastNode; var commonParent = firstNode.FindCommonParent(lastNode); while (firstChild != null && firstChild.Parent != commonParent) { firstChild = firstChild.Parent; } while (lastChild != null && lastChild.Parent != commonParent) { lastChild = lastChild.Parent; } Assertion.Assert(firstChild != null, "firstChild != null"); Assertion.Assert(lastChild != null, "lastChild != null"); var node = firstChild; while (node != null && node != lastChild.NextSibling) { if (!node.IsWhitespaceToken()) { GetNodePairs(node, list, commonParent); } node = node.NextSibling; } }
// Same public bool HasReference(ITreeNode element, ICollection<string> names) { var literal = element as ILiteralExpression; if (literal != null && literal.ConstantValue.Value is string) return names.Contains((string)literal.ConstantValue.Value); return false; }
public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { var parentExpression = registrationRootElement.GetParentExpression<IExpressionStatement>(); if (parentExpression == null) { yield break; } IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var expression = match.GetMatchedElement<ICSharpExpression>("expression"); if (IsResolvedToObject(expression)) { yield break; } IEnumerable<IComponentRegistration> componentRegistrations = GetRegistrationsFromExpression(registrationRootElement, expression); IEnumerable<FilteredRegistrationBase> basedOnRegistrations = basedOnPatterns.SelectMany( basedOnPattern => basedOnPattern.GetBasedOnRegistrations(parentExpression.Expression)).ToList(); var registrations = componentRegistrations.Concat(basedOnRegistrations).ToList(); if (registrations.Any()) { yield return new CompositeRegistration(registrationRootElement, registrations); } } }
public void ProcessBeforeInterior(ITreeNode element) { var declaration = element as IDeclaration; if (declaration == null) return; var declaredElement = declaration.DeclaredElement; if (declaredElement == null || declaredElement.ShortName == SharedImplUtil.MISSING_DECLARATION_NAME) return; IUnitTestElement testElement = null; var testClass = declaredElement as IClass; if (testClass != null) testElement = ProcessTestClass(testClass); var testMethod = declaredElement as IMethod; if (testMethod != null) testElement = ProcessTestMethod(testMethod); if (testElement != null) { var nameRange = declaration.GetNameDocumentRange().TextRange; var documentRange = declaration.GetDocumentRange().TextRange; if (nameRange.IsValid && documentRange.IsValid) { var disposition = new UnitTestElementDisposition(testElement, psiFile.GetSourceFile().ToProjectFile(), nameRange, documentRange); consumer(disposition); } } }
public bool InteriorShouldBeProcessed(ITreeNode element) { if (element is ITypeMemberDeclaration) return (element is ITypeDeclaration); return true; }
/// <summary> /// The get component registrations. /// </summary> /// <param name="registrationRootElement"> /// The registration root element. /// </param> /// <returns> /// </returns> public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var invocationExpression = match.MatchedElement as IInvocationExpression; if (invocationExpression == null) { yield break; } if (invocationExpression.TypeArguments.Count > 0) { foreach (IComponentRegistration registration in FromGenericArguments(invocationExpression)) { yield return registration; } } else { foreach (IComponentRegistration registration in FromArguments(invocationExpression)) { yield return registration; } } } }
public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IExpressionStatement parentExpression = GetParentExpressionStatemenmt(registrationRootElement); if (parentExpression == null) { yield break; } IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var arguments = match.GetMatchedElementList("assemblies").Cast<ICSharpArgument>(); IEnumerable<IModule> modules = arguments.SelectNotNull(argument => ModuleExtractor.GetTargetModule(argument.Value)); foreach (IModule module in modules) { var registration = new ModuleBasedOnRegistration(module, new DefaultScanAssemblyRegistration(registrationRootElement)); var basedOnRegistrations = BasedOnPatterns.SelectMany( basedOnPattern => basedOnPattern.GetBasedOnRegistrations(parentExpression.Expression)); yield return new CompositeRegistration(registrationRootElement, registration, basedOnRegistrations.ToArray()); } } }
public override IEnumerable<BasedOnRegistrationBase> GetBasedOnRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var argument = match.GetMatchedElement("argument") as ICSharpArgument; if (argument == null) { yield break; } var typeofExpression = argument.Value as ITypeofExpression; if (typeofExpression != null) { var declaredType = typeofExpression.ArgumentType as IDeclaredType; if (declaredType != null) { ITypeElement typeElement = declaredType.GetTypeElement(); if (typeElement != null) { yield return registrationCreator.Create(registrationRootElement, typeElement); } } } } }
public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { // ReSharper does not currently match generic and non-generic overloads separately, meaning that Register<T> and Register(typeof(T)) // will be both matched with a single pattern Register($arguments$). // Therefire I am using this pattern to look for both generic and non-generic (with typeof) overloads of the pattern IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var invocationExpression = match.MatchedElement as IInvocationExpression; if (invocationExpression == null) { yield break; } if (invocationExpression.TypeArguments.Any()) { foreach (var registration in FromGenericArguments(invocationExpression)) { yield return registration; } } else { foreach (var registration in FromArguments(invocationExpression)) { yield return registration; } } } }
public BasedOnRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement) : base(registrationRootElement) { this.basedOnElement = basedOnElement; name = basedOnElement.GetClrName().FullName; }
public PsiUnresolvedVariableReferenceHighlighting(IVariableName element) { myElement = element; myReference = (element as VariableName).Reference; }
public IReference[] GetReferences(ITreeNode element, IReference[] oldReferences) { var literal = element as ILiteralExpression; if (literal != null && literal.ConstantValue.Value is string) { var agument = literal.Parent as IVBArgument; var attribute = AttributeNavigator.GetByArgument(agument); if (attribute != null) { var @class = attribute.AttributeType.Reference.Resolve().DeclaredElement as IClass; if (@class != null && Equals(@class.GetClrName(), DataAttributeName)) { var typeElement = (from a in attribute.Arguments where a is INamedArgument && a.ArgumentName == TypeMemberName select GetTypeof(a.Expression as IGetTypeExpression)).FirstOrDefault(); var member = MethodDeclarationNavigator.GetByAttribute(attribute) as ITypeMemberDeclaration; if (member != null && member.DeclaredElement != null && typeElement == null) typeElement = member.DeclaredElement.GetContainingType(); if (typeElement == null) return EmptyArray<IReference>.Instance; var reference = CreateReference(typeElement, literal); return oldReferences != null && oldReferences.Length == 1 && Equals(oldReferences[0], reference) ? oldReferences : new[] { reference }; } } } return EmptyArray<IReference>.Instance; }
private static bool IsAssignmentImpl(ITreeNode binaryexpression) { var treeElement = binaryexpression.FirstChild; if (treeElement == null) return false; for (; treeElement != null; treeElement = treeElement.NextSibling) { var javaScriptTokenBase = treeElement as JavaScriptTokenBase; if (javaScriptTokenBase != null) { NodeType nodeType = javaScriptTokenBase.NodeType; if (nodeType == JavaScriptTokenType.EQ || nodeType == JavaScriptTokenType.PLUSEQ || nodeType == JavaScriptTokenType.MINUSEQ || nodeType == JavaScriptTokenType.TIMESEQ || nodeType == JavaScriptTokenType.PERCENTEQ || nodeType == JavaScriptTokenType.LSHIFTEQ || nodeType == JavaScriptTokenType.RSHIFTEQ || nodeType == JavaScriptTokenType.GT3EQ || nodeType == JavaScriptTokenType.AMPEREQ || nodeType == JavaScriptTokenType.PIPEEQ || nodeType == JavaScriptTokenType.CAROTEQ || nodeType == JavaScriptTokenType.DIVIDEEQ) { return true; } } } return false; }
public IReference[] GetReferences(ITreeNode element, IReference[] oldReferences) { var literal = element as ILiteralExpression; if (literal != null && literal.ConstantValue.Value is string) { var attribute = AttributeNavigator.GetByConstructorArgumentExpression(literal as ICSharpExpression); if (attribute != null) { var @class = attribute.Name.Reference.Resolve().DeclaredElement as IClass; if (@class != null && Equals(@class.GetClrName(), DataAttributeName)) { var typeElement = (from a in attribute.PropertyAssignments where a.PropertyNameIdentifier.Name == TypeMemberName select GetTypeof(a.Source as ITypeofExpression)).FirstOrDefault(); var member = MethodDeclarationNavigator.GetByAttribute(attribute); if (member != null && member.DeclaredElement != null && typeElement == null) typeElement = member.DeclaredElement.GetContainingType(); if (typeElement == null) return EmptyArray<IReference>.Instance; var reference = CreateReference(typeElement, literal); return oldReferences != null && oldReferences.Length == 1 && Equals(oldReferences[0], reference) ? oldReferences : new[] {reference}; } } } return EmptyArray<IReference>.Instance; }
/// <summary> /// Replace one node with another. /// </summary> /// <param name="rootNode">The root node.</param> /// <param name="replaceThisNode">The node to replace.</param> /// <param name="replaceWith">What to replace with.</param> public static void Process(ITreeNode rootNode, ITreeNode replaceThisNode, ITreeNode replaceWith) { bool done = false; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse(rootNode, (n) => { if (done) { return false; } for (int i = 0; i < n.ChildNodes.Count; i++) { ITreeNode childNode = n.ChildNodes[i]; if (childNode == replaceThisNode) { n.ChildNodes[i] = replaceWith; done = true; return false; } } return true; }); }
private void Compile(ITreeNode node, StringBuilder builder) { if (node.Descriptor != "ROOT") { builder.Append(node.Descriptor); builder.Append('{'); } foreach(var child in node.Children) { Compile(child, builder); } foreach(var expression in node.Expressions) { builder.Append(expression.Expression.Key); builder.Append(':'); builder.Append(expression.Expression.Value); builder.Append(';'); } if (node.Descriptor != "ROOT") { builder.Append('}'); } }
IEnumerable<BasedOnRegistrationBase> IBasedOnPattern.GetBasedOnRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { ITreeNode element = match.GetMatchedElement("argument"); if (element != null) { foreach (var whereArgumentPattern in whereArgumentPatterns) { var registrations = whereArgumentPattern.GetBasedOnRegistrations(element).ToArray(); if (!registrations.Any()) { // try with the root element. registrations = whereArgumentPattern.GetBasedOnRegistrations(registrationRootElement).ToArray(); } foreach (var registration in registrations) { yield return registration; } } } } }
public void Drop(ITreeNode targetData) { if (targetData ==null ) { } }
protected override bool HasReference(ITreeNode element, ICollection<string> names) { var stringLiteral = element as IJavaScriptLiteralExpression; if (stringLiteral == null) return false; var file = element.GetContainingFile(); if (file == null) return false; // TODO: We can't use this, due to losing data when we reparse for code completion // When we start code completion, the tree node is reparsed with new text inserted, // so that references have something to attach to. Reparsing works with IChameleon // blocks that allow for resync-ing in-place. Our AngularJs nodes don't have any // chameleon blocks (for JS, it's the Block class - anything with braces) so we end // up re-parsing the file. This creates a new IFile, (in a sandbox that allows access // to the original file's reference provider) but it doesn't copy the user data. We // could theoretically look for a containing sandbox, get the context node and try // and get the user data there, but that just makes it feel like this is the wrong // solution. I think maybe this should be a reference provider for HTML, not AngularJs. // It would have the context of the attribute name, but should really work with the // injected AngularJs language, if only to see that it's a string literal //var originalAttributeType = file.UserData.GetData(AngularJsFileData.OriginalAttributeType); //if (originalAttributeType != elementTypes.AngularJsUrlType.Name) // return false; return true; }
public PsiIntentionResult(List<ITemplateFieldHolder> holders, IDeclaration declaration, ITreeNode anchor, DocumentRange range) { myDeclaration = declaration; myHolders = holders; myPrefferedSelection = range; myAnchor = anchor; }
protected void _newChild(ITreeNode nTreeNode) { if (null != m_tNewChildTreeNode) { this.m_tNewChildTreeNode(nTreeNode); } }
public TokenHighlighting(ITreeNode element) { myElement = element; string lang = element.UserData.GetData(Constants.YcLanguage); string tokenName = element.UserData.GetData(Constants.YcTokenName); attributeId = LanguageHelper.GetColor(lang, tokenName); }