C# ExpressionSyntax.GetAncestorsOrThis方法代码示例

        protected override Task<Document> IntroduceQueryLocalAsync(
            SemanticDocument document, ExpressionSyntax expression, bool allOccurrences, CancellationToken cancellationToken)
        {
            var oldOutermostQuery = expression.GetAncestorsOrThis<QueryExpressionSyntax>().LastOrDefault();

            var newLocalNameToken = GenerateUniqueLocalName(
                document, expression, isConstant: false, 
                container: oldOutermostQuery, cancellationToken: cancellationToken);
            var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken);

            var letClause = SyntaxFactory.LetClause(
                newLocalNameToken.WithAdditionalAnnotations(RenameAnnotation.Create()),
                expression).WithAdditionalAnnotations(Formatter.Annotation);

            var matches = FindMatches(document, expression, document, oldOutermostQuery, allOccurrences, cancellationToken);
            var innermostClauses = new HashSet<SyntaxNode>(
                matches.Select(expr => expr.GetAncestorsOrThis<SyntaxNode>().First(IsAnyQueryClause)));

            if (innermostClauses.Count == 1)
            {
                // If there was only one match, or all the matches came from the same
                // statement, then we want to place the declaration right above that
                // statement. Note: we special case this because the statement we are going
                // to go above might not be in a block and we may have to generate it
                return Task.FromResult(IntroduceQueryLocalForSingleOccurrence(
                    document, expression, newLocalName, letClause, allOccurrences, cancellationToken));
            }

            var oldInnerMostCommonQuery = matches.FindInnermostCommonNode<QueryExpressionSyntax>();
            var newInnerMostQuery = Rewrite(
                document, expression, newLocalName, document, oldInnerMostCommonQuery, allOccurrences, cancellationToken);

            var allAffectedClauses = new HashSet<SyntaxNode>(matches.SelectMany(expr => expr.GetAncestorsOrThis<SyntaxNode>().Where(IsAnyQueryClause)));

            var oldClauses = oldInnerMostCommonQuery.GetAllClauses();
            var newClauses = newInnerMostQuery.GetAllClauses();

            var firstClauseAffectedInQuery = oldClauses.First(allAffectedClauses.Contains);
            var firstClauseAffectedIndex = oldClauses.IndexOf(firstClauseAffectedInQuery);

            var finalClauses = newClauses.Take(firstClauseAffectedIndex)
                                         .Concat(letClause)
                                         .Concat(newClauses.Skip(firstClauseAffectedIndex)).ToList();

            var finalQuery = newInnerMostQuery.WithAllClauses(finalClauses);
            var newRoot = document.Root.ReplaceNode(oldInnerMostCommonQuery, finalQuery);

            return Task.FromResult(document.Document.WithSyntaxRoot(newRoot));
        }

        private SyntaxNode GetContainerToGenerateInto(
            SemanticDocument document, ExpressionSyntax expression, CancellationToken cancellationToken)
        {
            var anonymousMethodParameters = GetAnonymousMethodParameters(document, expression, cancellationToken);
            var lambdas = anonymousMethodParameters.SelectMany(p => p.ContainingSymbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax(cancellationToken)).AsEnumerable())
                                                   .Where(n => n is ParenthesizedLambdaExpressionSyntax || n is SimpleLambdaExpressionSyntax)
                                                   .ToSet();

            var parentLambda = GetParentLambda(expression, lambdas);

            if (parentLambda != null)
            {
                return parentLambda;
            }
            else if (IsInExpressionBodiedMember(expression))
            {
                return expression.GetAncestorOrThis<ArrowExpressionClauseSyntax>();
            }
            else
            {
                return expression.GetAncestorsOrThis<BlockSyntax>().LastOrDefault();
            }
        }

		private async Task<Document> IntroduceLocalDeclarationIntoBlockAsync(
			SemanticDocument document,
			ExpressionSyntax expression,
			NameSyntax newLocalName,
			LocalDeclarationStatementSyntax declarationStatement,
			bool allOccurrences,
			CancellationToken cancellationToken)
		{
			declarationStatement = declarationStatement.WithAdditionalAnnotations(Formatter.Annotation);

			var oldOutermostBlock = expression.GetAncestorsOrThis<BlockSyntax>().LastOrDefault();
			var matches = FindMatches(document, expression, document, oldOutermostBlock, allOccurrences, cancellationToken);
			Debug.Assert(matches.Contains(expression));

			var complexified = await ComplexifyParentingStatements(document, matches, cancellationToken).ConfigureAwait(false);
			document = complexified.Item1;
			matches = complexified.Item2;

			// Our original expression should have been one of the matches, which were tracked as part
			// of complexification, so we can retrieve the latest version of the expression here.
			expression = document.Root.GetCurrentNodes(expression).First();

			var innermostStatements = new HashSet<StatementSyntax>(
				matches.Select(expr => expr.GetAncestorOrThis<StatementSyntax>()));

			if (innermostStatements.Count == 1)
			{
				// If there was only one match, or all the matches came from the same
				// statement, then we want to place the declaration right above that
				// statement. Note: we special case this because the statement we are going
				// to go above might not be in a block and we may have to generate it
				return IntroduceLocalForSingleOccurrenceIntoBlock(
					document, expression, newLocalName, declarationStatement, allOccurrences, cancellationToken);
			}

			var oldInnerMostCommonBlock = matches.FindInnermostCommonBlock();
			var allAffectedStatements = new HashSet<StatementSyntax>(matches.SelectMany(expr => expr.GetAncestorsOrThis<StatementSyntax>()));
			var firstStatementAffectedInBlock = oldInnerMostCommonBlock.Statements.First(allAffectedStatements.Contains);

			var firstStatementAffectedIndex = oldInnerMostCommonBlock.Statements.IndexOf(firstStatementAffectedInBlock);

			var newInnerMostBlock = Rewrite(
				document, expression, newLocalName, document, oldInnerMostCommonBlock, allOccurrences, cancellationToken);

			var statements = new List<StatementSyntax>();
			statements.AddRange(newInnerMostBlock.Statements.Take(firstStatementAffectedIndex));
			statements.Add(declarationStatement);
			statements.AddRange(newInnerMostBlock.Statements.Skip(firstStatementAffectedIndex));

			var finalInnerMostBlock = newInnerMostBlock.WithStatements(
				SyntaxFactory.List<StatementSyntax>(statements));

			var newRoot = document.Root.ReplaceNode(oldInnerMostCommonBlock, finalInnerMostBlock);
			return document.Document.WithSyntaxRoot(newRoot);
		}