C# SyntaxTree.TryGetRoot方法代码示例

 public IEnumerable<SyntaxNode> GetMatchingSyntaxNodes(SyntaxTree syntaxTree)
 {
     SyntaxNode root;
     if (syntaxTree.TryGetRoot(out root))
     {
         // Just return the root if not filtering by declaration
         if (string.IsNullOrWhiteSpace(_declarationFilter))
         {
             return new[] { root };
         }
         else
         {
             // Filter by declaration
             return root
                 .DescendantNodes(x => !SyntaxNodeMatchesDeclaration(x))
                 .Where(x => SyntaxNodeMatchesDeclaration(x));
         }
     }
     return new SyntaxNode[] { };
 }

    public static SyntaxNode GetAnyCallNodeAboveTriggerPoint(ITrackingPoint triggerPoint, ITextSnapshot snapshot, SyntaxTree parseTree) {
      Contract.Requires(snapshot != null);
      Contract.Requires(parseTree != null);
      Contract.Requires(triggerPoint != null);

      SyntaxNode syntaxRoot;
      if (!parseTree.TryGetRoot(out syntaxRoot))
        return null;

      var leafNode = syntaxRoot.FindToken(triggerPoint.GetPosition(snapshot), false);
      if (leafNode.IsKind(SyntaxKind.None))
        return null;

      //Is anyone in our ancestry a call node?
      var nodeInQuestion = leafNode.Parent;
      SyntaxNode ptn = null;

      while (nodeInQuestion != null) {
        //Is the node in question a node call?
        var asCall = nodeInQuestion as InvocationExpressionSyntax;
        if (asCall != null) {
          ptn = asCall;
          break;
        }

        var asCtorCall = nodeInQuestion as ObjectCreationExpressionSyntax;
        if (asCtorCall != null) {
          ptn = asCtorCall;
          break;
        }

        //Climb higher up our ancestry for the next iteration
        nodeInQuestion = nodeInQuestion.Parent;
      }

      //Did we successfully find a call node?
      return ptn;
    }

    public static SyntaxNode GetTargetAtTriggerPoint(ITrackingPoint triggerPoint, ITextSnapshot snapshot, SyntaxTree parseTree)
    {
      Contract.Requires(snapshot != null);
      Contract.Requires(parseTree != null);
      Contract.Requires(triggerPoint != null);

      SyntaxNode syntaxRoot;
      if (!parseTree.TryGetRoot(out syntaxRoot))
        return null;

      var leafToken = syntaxRoot.FindToken(triggerPoint.GetPosition(snapshot), false);
      if (leafToken.IsKind(SyntaxKind.None))
        return null;

      var leafNode = leafToken.Parent;

      var asPropDecl = leafNode as PropertyDeclarationSyntax;
      if (asPropDecl != null)
      {
          return asPropDecl;
      }

      //Is our leaf node a name?
      var asName = leafNode as IdentifierNameSyntax;
      if (asName == null)
        return null;

      //Is anyone in our ancestry a call node?
      var nodeInQuestion = leafNode;
      var lastNonBinaryOperatorNode = leafNode;
      var lastNode = leafNode;
      while (nodeInQuestion != null) {

        //Is the node in question a node call?
        var asCall = nodeInQuestion as InvocationExpressionSyntax;
        if (asCall != null) {

          //Make sure we aren't on the right side of the call
          if (asCall.Expression == leafNode)
            return asCall;

          MemberAccessExpressionSyntax memberAccessExpression = asCall.Expression as MemberAccessExpressionSyntax;
          if (memberAccessExpression != null && memberAccessExpression.Name == leafNode)
            return asCall;

          GenericNameSyntax genericNameSyntax = asCall.Expression as GenericNameSyntax;
          if (genericNameSyntax != null && genericNameSyntax.Identifier == leafToken)
            return asCall;

          return null;
        }

        var asProp = nodeInQuestion as MemberAccessExpressionSyntax;
        if (asProp != null)
        {
            //Make sure we aren't on the left side of the dot
            if (asProp.Name == lastNode && asProp.Name is IdentifierNameSyntax)
            {
                return asProp;
            }
        }

        var asCtorCall = nodeInQuestion as ObjectCreationExpressionSyntax;
        if (asCtorCall != null)
        {
            return asCtorCall;
        }

        var declNode = nodeInQuestion as MemberDeclarationSyntax;
        if (declNode != null)
        {
            if (lastNode == leafNode) { return declNode; }
            return null;
        }

#warning What exactly is this doing?
#if false
        NamedAssignmentNode na = nodeInQuestion as NamedAssignmentNode;
        if (na != null)
        {
            if (na.Identifier == asName)
            {
                return na;
            }
        }
#endif

        //Is our parent a binary operator?
        var asBinaryOperator = nodeInQuestion as BinaryExpressionSyntax;
        if (asBinaryOperator != null) {

          //Make sure we are always on the rightmost of any binary operator
          if (asBinaryOperator.Right != lastNonBinaryOperatorNode)
            return null;

        } else
          lastNonBinaryOperatorNode = nodeInQuestion;

        //Climb higher up our ancestry for the next iteration
        lastNode = nodeInQuestion;
//.........这里部分代码省略.........