C# ExpressionSyntax.GetAncestorOrThis方法代码示例

        protected override Task<Tuple<Document, SyntaxNode, int>> IntroduceFieldAsync(
            SemanticDocument document,
            ExpressionSyntax expression,
            bool allOccurrences,
            bool isConstant,
            CancellationToken cancellationToken)
        {
            var oldTypeDeclaration = expression.GetAncestorOrThis<TypeDeclarationSyntax>();

            var oldType = oldTypeDeclaration != null
                ? document.SemanticModel.GetDeclaredSymbol(oldTypeDeclaration, cancellationToken) as INamedTypeSymbol
                : document.SemanticModel.Compilation.ScriptClass;
            var newNameToken = GenerateUniqueFieldName(document, expression, isConstant, cancellationToken);

            var newQualifiedName = oldTypeDeclaration != null
                ? SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseName(oldType.ToNameDisplayString()), SyntaxFactory.IdentifierName(newNameToken))
                : (ExpressionSyntax)SyntaxFactory.IdentifierName(newNameToken);

            newQualifiedName = newQualifiedName.WithAdditionalAnnotations(Simplifier.Annotation);

            var newFieldDeclaration = SyntaxFactory.FieldDeclaration(
                default(SyntaxList<AttributeListSyntax>),
                MakeFieldModifiers(isConstant, inScript: oldType.IsScriptClass),
                SyntaxFactory.VariableDeclaration(
                    GetTypeSymbol(document, expression, cancellationToken).GenerateTypeSyntax(),
                    SyntaxFactory.SingletonSeparatedList(
                        SyntaxFactory.VariableDeclarator(
                            newNameToken.WithAdditionalAnnotations(RenameAnnotation.Create()),
                            null,
                            SyntaxFactory.EqualsValueClause(expression))))).WithAdditionalAnnotations(Formatter.Annotation);

            if (oldTypeDeclaration != null)
            {
                var newTypeDeclaration = Rewrite(
                    document, expression, newQualifiedName, document, oldTypeDeclaration, allOccurrences, cancellationToken);

                var insertionIndex = isConstant ?
                    DetermineConstantInsertPosition(oldTypeDeclaration.Members, newTypeDeclaration.Members) :
                    DetermineFieldInsertPosition(oldTypeDeclaration.Members, newTypeDeclaration.Members);

                var finalTypeDeclaration = InsertMember(newTypeDeclaration, newFieldDeclaration, insertionIndex);

                SyntaxNode destination = oldTypeDeclaration;
                var newRoot = document.Root.ReplaceNode(oldTypeDeclaration, finalTypeDeclaration);
                return Task.FromResult(Tuple.Create(document.Document.WithSyntaxRoot(newRoot), destination, insertionIndex));
            }
            else
            {
                var oldCompilationUnit = (CompilationUnitSyntax)document.Root;
                var newCompilationUnit = Rewrite(
                    document, expression, newQualifiedName, document, oldCompilationUnit, allOccurrences, cancellationToken);

                var insertionIndex = isConstant ?
                    DetermineConstantInsertPosition(oldCompilationUnit.Members, newCompilationUnit.Members) :
                    DetermineFieldInsertPosition(oldCompilationUnit.Members, newCompilationUnit.Members);

                SyntaxNode destination = oldCompilationUnit;
                var newRoot = newCompilationUnit.WithMembers(newCompilationUnit.Members.Insert(insertionIndex, newFieldDeclaration));
                return Task.FromResult(Tuple.Create(document.Document.WithSyntaxRoot(newRoot), destination, insertionIndex));
            }
        }

        private Document IntroduceLocalForSingleOccurrenceIntoBlock(
            SemanticDocument document,
            ExpressionSyntax expression,
            NameSyntax localName,
            LocalDeclarationStatementSyntax localDeclaration,
            bool allOccurrences,
            CancellationToken cancellationToken)
        {
            var oldStatement = expression.GetAncestorOrThis<StatementSyntax>();
            var newStatement = Rewrite(
                document, expression, localName, document, oldStatement, allOccurrences, cancellationToken);

            if (oldStatement.IsParentKind(SyntaxKind.Block))
            {
                var oldBlock = oldStatement.Parent as BlockSyntax;
                var statementIndex = oldBlock.Statements.IndexOf(oldStatement);

                var newBlock = oldBlock.WithStatements(CreateNewStatementList(
                    oldBlock.Statements, localDeclaration, newStatement, statementIndex));

                var newRoot = document.Root.ReplaceNode(oldBlock, newBlock);
                return document.Document.WithSyntaxRoot(newRoot);
            }
            else if (oldStatement.IsParentKind(SyntaxKind.SwitchSection))
            {
                var oldSwitchSection = oldStatement.Parent as SwitchSectionSyntax;
                var statementIndex = oldSwitchSection.Statements.IndexOf(oldStatement);

                var newSwitchSection = oldSwitchSection.WithStatements(CreateNewStatementList(
                    oldSwitchSection.Statements, localDeclaration, newStatement, statementIndex));

                var newRoot = document.Root.ReplaceNode(oldSwitchSection, newSwitchSection);
                return document.Document.WithSyntaxRoot(newRoot);
            }
            else
            {
                // we need to introduce a block to put the original statement, along with
                // the statement we're generating
                var newBlock = SyntaxFactory.Block(localDeclaration, newStatement).WithAdditionalAnnotations(Formatter.Annotation);

                var newRoot = document.Root.ReplaceNode(oldStatement, newBlock);
                return 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 Document RewriteExpressionBodiedMemberAndIntroduceLocalDeclaration(
			SemanticDocument document,
			ExpressionSyntax expression,
			NameSyntax newLocalName,
			LocalDeclarationStatementSyntax declarationStatement,
			bool allOccurrences,
			CancellationToken cancellationToken)
		{
			var oldBody = expression.GetAncestorOrThis<ArrowExpressionClauseSyntax>();
			var oldParentingNode = oldBody.Parent;
			var leadingTrivia = oldBody.GetLeadingTrivia()
			                           .AddRange(oldBody.ArrowToken.TrailingTrivia);

			var newStatement = Rewrite(document, expression, newLocalName, document, oldBody.Expression, allOccurrences, cancellationToken);
			var newBody = SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(newStatement))
			                           .WithLeadingTrivia(leadingTrivia)
			                           .WithTrailingTrivia(oldBody.GetTrailingTrivia())
			                           .WithAdditionalAnnotations(Formatter.Annotation);

			SyntaxNode newParentingNode = null;
			if (oldParentingNode is BasePropertyDeclarationSyntax)
			{
				var getAccessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, newBody);
				var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getAccessor }));

				newParentingNode = ((BasePropertyDeclarationSyntax)oldParentingNode).RemoveNode(oldBody, SyntaxRemoveOptions.KeepNoTrivia);

				if (newParentingNode.IsKind(SyntaxKind.PropertyDeclaration))
				{
					var propertyDeclaration = ((PropertyDeclarationSyntax)newParentingNode);
					newParentingNode = propertyDeclaration
						.WithAccessorList(accessorList)
						.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
						.WithTrailingTrivia(propertyDeclaration.SemicolonToken.TrailingTrivia);
				}
				else if (newParentingNode.IsKind(SyntaxKind.IndexerDeclaration))
				{
					var indexerDeclaration = ((IndexerDeclarationSyntax)newParentingNode);
					newParentingNode = indexerDeclaration
						.WithAccessorList(accessorList)
						.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
						.WithTrailingTrivia(indexerDeclaration.SemicolonToken.TrailingTrivia);
				}
			}
			else if (oldParentingNode is BaseMethodDeclarationSyntax)
			{
				newParentingNode = ((BaseMethodDeclarationSyntax)oldParentingNode)
					.RemoveNode(oldBody, SyntaxRemoveOptions.KeepNoTrivia)
					.WithBody(newBody);

				if (newParentingNode.IsKind(SyntaxKind.MethodDeclaration))
				{
					var methodDeclaration = ((MethodDeclarationSyntax)newParentingNode);
					newParentingNode = methodDeclaration
						.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
						.WithTrailingTrivia(methodDeclaration.SemicolonToken.TrailingTrivia);
				}
				else if (newParentingNode.IsKind(SyntaxKind.OperatorDeclaration))
				{
					var operatorDeclaration = ((OperatorDeclarationSyntax)newParentingNode);
					newParentingNode = operatorDeclaration
						.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
						.WithTrailingTrivia(operatorDeclaration.SemicolonToken.TrailingTrivia);
				}
				else if (newParentingNode.IsKind(SyntaxKind.ConversionOperatorDeclaration))
				{
					var conversionOperatorDeclaration = ((ConversionOperatorDeclarationSyntax)newParentingNode);
					newParentingNode = conversionOperatorDeclaration
						.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
						.WithTrailingTrivia(conversionOperatorDeclaration.SemicolonToken.TrailingTrivia);
				}
			}

			var newRoot = document.Root.ReplaceNode(oldParentingNode, newParentingNode);
			return document.Document.WithSyntaxRoot(newRoot);
		}