C# ExpressionSyntax.ReplaceNode方法代码示例

        private async Task<bool> SemanticsChangedAsync(
            Document document,
            VariableDeclarationSyntax declaration,
            ExpressionSyntax invocationOrCreation,
            TypeSyntax newType,
            IdentifierNameSyntax identifier,
            DeclarationExpressionSyntax declarationExpression,
            CancellationToken cancellationToken)
        {
            if (newType.IsVar)
            {
                // Options want us to use 'var' if we can.  Make sure we didn't change
                // the semantics of teh call by doing this.

                // Find the symbol that the existing invocation points to.
                var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                var previousSymbol = semanticModel.GetSymbolInfo(invocationOrCreation).Symbol;

                var annotation = new SyntaxAnnotation();
                var updatedInvocationOrCreation = invocationOrCreation.ReplaceNode(
                    identifier, declarationExpression).WithAdditionalAnnotations(annotation);

                // Note(cyrusn): "https://github.com/dotnet/roslyn/issues/14384" prevents us from just
                // speculatively binding the new expression.  So, instead, we fork things and see if
                // the new symbol we bind to is equivalent to the previous one.
                var newDocument = document.WithSyntaxRoot(
                    root.ReplaceNode(invocationOrCreation, updatedInvocationOrCreation));

                var newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                var newSemanticModel = await newDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

                updatedInvocationOrCreation = (ExpressionSyntax)newRoot.GetAnnotatedNodes(annotation).Single();

                var updatedSymbol = newSemanticModel.GetSymbolInfo(updatedInvocationOrCreation).Symbol;

                if (!SymbolEquivalenceComparer.Instance.Equals(previousSymbol, updatedSymbol))
                {
                    // We're pointing at a new symbol now.  Semantic have changed.
                    return true;
                }
            }

            return false;
        }

        protected ExpressionSyntax RewritePostfixUnarys(ExpressionSyntax node)
        {
            var expressions = node.DescendentNodesAndSelf().OfType<PostfixUnaryExpressionSyntax>().ToArray();
            if (expressions.Length == 0)
                return node;

            List<string> names = new List<string> (expressions.Length);
            foreach (var expr in expressions)
            {
                if (expr.Kind != SyntaxKind.PostIncrementExpression && expr.Kind != SyntaxKind.PostDecrementExpression)
                    continue; // These aren't the droids we're looking for.

                IdentifierNameSyntax name = FindIdentifierName (expr);
                if (name == null)
                    continue; // We didn't find a name

                if (names.Contains (name.PlainName))
                {
                    var newExpr = GetLogExpression (name.PlainName, expr);
                    node = node.ReplaceNode (expr, newExpr);
                }
                else
                    names.Add (name.PlainName);
            }

            // We'll use a string builder construct our expression.
            StringBuilder builder = new StringBuilder ("LogPostfixValues ((");
            builder.Append (node.ToString());
            builder.Append ("), ");

            bool found = false;
            foreach (string name in names)
            {
                if (found)
                    builder.Append (", ");

                // We need to specify our generic types so we match
                // the params argument type
                builder.Append ("new Tuple<string, object> (\"");
                builder.Append (name);
                builder.Append ("\", ");
                builder.Append (name);
                builder.Append (")");
                found = true;
            }

            if (!found)
                return node; // We didn't find any usable expressions

            builder.Append (")");

            // Parse and return our new expression.
            return Syntax.ParseExpression (builder.ToString());
        }