C# ITreeNode.GetPsiModule方法代码示例

        public override IEnumerable<FilteredRegistrationBase> GetBasedOnRegistrations(ITreeNode registrationRootElement)
        {
            IStructuralMatchResult match = Match(registrationRootElement);

            if (match.Matched)
            {
                ITypeElement objectTypeElement = registrationRootElement.GetPsiModule()
                                                                        .GetPredefinedType()
                                                                        .Object.GetTypeElement();

                if (objectTypeElement != null)
                {
                    yield return registrationCreator.Create(registrationRootElement, objectTypeElement);
                }
            }
        }

    public CreatePsiRuleTarget(PsiRuleReference reference)
    {
      myReference = reference;
      myElement = reference.GetTreeNode();
      string name = reference.GetName();

      var node = myElement.NextSibling;
      while (node != null)
      {
        if (!node.IsWhitespaceToken())
        {
          if (!(node is IRuleParameters))
          {
            break;
          }
          var child = node.FirstChild;
          while (child != null)
          {
            if (!child.IsWhitespaceToken())
            {
              if (child is IRuleBraceParameters)
              {
                myHasBraceParameters = true;
              }
              if (child is IRuleBracketParameters)
              {
                CollectVariableParameters(child as IRuleBracketParameters);
              }
            }
            child = child.NextSibling;
          }
          break;
        }
        node = node.NextSibling;
      }


      myDeclaration = PsiElementFactory.GetInstance(myElement.GetPsiModule()).CreateRuleDeclaration(name, myHasBraceParameters, myVariableParameters);

      Anchor = myElement.GetContainingNode<IRuleDeclaration>();
    }

        public void ProcessBeforeInterior(ITreeNode element)
        {
            var functionDeclaration = element as ICSharpFunctionDeclaration;
            if (functionDeclaration == null)
                return;
            var psiModule = element.GetPsiModule();
            var sourceFile = element.GetSourceFile();
            if (sourceFile == null)
                return;
            var resolveContext = sourceFile.ResolveContext;
            var disposableInterface = DisposeUtil.GetDisposableInterface(psiModule, resolveContext);
            if (disposableInterface == null)
                return;
            var graf = CSharpControlFlowBuilder.Build(functionDeclaration) as CSharpControlFlowGraf;
            if (graf == null)
                return;

            var name = functionDeclaration.DeclaredName;
            var offset = InvokedExpressionData.GetOffsetByNode(functionDeclaration);

            var grafInspector = new ControlFlowInspector(functionDeclaration, graf, disposableInterface);
            var methodArguments = grafInspector.GetMethodArgumentStatuses();
            _statuses.Add(new DisposeMethodStatus(name, offset, methodArguments, sourceFile));
        }

        private bool IsNinjectBindCall(ITreeNode element)
        {
            var invocationExpression = element as IInvocationExpression;
            if (invocationExpression == null)
            {
                return false;
            }

            var resolve = invocationExpression.InvocationExpressionReference.Resolve().Result;
            var method = resolve.DeclaredElement as IMethod;
            if (method == null)
            {
                return false;
            }
            ITypeElement containingType = method.GetContainingType();
            if (containingType == null)
            {
                return false;
            }

            if (bindingRootType == null)
            {
                bindingRootType = TypeFactory.CreateTypeByCLRName("Ninject.Syntax.IBindingRoot", element.GetPsiModule());
            }

            return containingType.IsDescendantOf(bindingRootType.GetTypeElement());
        }

        /// <summary>
        /// Creates a DocCommentBlockNode with the text provided.
        /// </summary>
        /// <param name="element">
        /// The element to create for.
        /// </param>
        /// <param name="text">
        /// The text to use to create the doc.
        /// </param>
        /// <returns>
        /// An IDocCommentBlockNode that has been created.
        /// </returns>
        public static IDocCommentBlockNode CreateDocCommentBlockNode(ITreeNode element, string text)
        {
            // Fix up the xml terminators to remove the extra space.
            text = text.Replace(" />", "/>");

            StringBuilder builder = new StringBuilder();
            foreach (string line in text.Split('\n'))
            {
                string outputLine = line;
                if (line.StartsWith(" "))
                {
                    outputLine = line.Substring(1);
                }

                builder.Append("/// " + outputLine + Environment.NewLine);
            }

            builder.Append("void fec();");
            IDocCommentBlockOwnerNode declaration =
                (IDocCommentBlockOwnerNode)CSharpElementFactory.GetInstance(element.GetPsiModule()).CreateTypeMemberDeclaration(builder.ToString());

            return declaration.GetDocCommentBlockNode();
        }

 public static IDeclaredType CreateTypeByClrName(ITreeNode node, string containerClrTypeName)
 {
     return TypeFactory.CreateTypeByCLRName(containerClrTypeName, node.GetPsiModule());
 }