将ArgumentSyntax与VariableDeclaratorSyntax转换为InvocationExpression的需求

听起来你需要自动把代码里的字符串字面量包装成自定义的StringManipulation方法调用——这正好可以用Roslyn（.NET Compiler Platform）来优雅实现，毕竟它是.NET生态里处理代码分析和重构的利器。下面是完整的解决方案，涵盖你提到的两种场景以及语法节点转换的实现：

1. 核心思路：用SyntaxRewriter修改语法树 #

Roslyn的CSharpSyntaxRewriter允许我们遍历代码的语法树，针对性地修改特定节点。我们需要处理两种核心场景：

• 变量声明初始化器（VariableDeclaratorSyntax）：把var test = "test var";转换成var test = StringManipulation("test var");
• 方法调用参数（ArgumentSyntax）：把Test("Testing");转换成Test(StringManipulation("Testing"));

2. 自定义Rewriter实现 #

创建一个继承自CSharpSyntaxRewriter的类，重写对应节点的访问方法：

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

public class StringManipulationRewriter : CSharpSyntaxRewriter
{
    // 处理变量声明的初始化逻辑
    public override SyntaxNode VisitVariableDeclarator(VariableDeclaratorSyntax node)
    {
        // 仅当初始化值是字符串字面量时才处理
        if (node.Initializer != null && node.Initializer.Value is LiteralExpressionSyntax stringLiteral 
            && stringLiteral.IsKind(SyntaxKind.StringLiteralExpression))
        {
            // 构建StringManipulation的调用表达式
            var invocation = SyntaxFactory.InvocationExpression(
                SyntaxFactory.IdentifierName("StringManipulation"))
                .AddArgumentListArguments(SyntaxFactory.Argument(stringLiteral));

            // 替换原初始化值，保留原有语法格式
            var updatedInitializer = node.Initializer.WithValue(invocation);
            return node.WithInitializer(updatedInitializer);
        }

        return base.VisitVariableDeclarator(node);
    }

    // 处理方法调用的参数逻辑
    public override SyntaxNode VisitArgument(ArgumentSyntax node)
    {
        // 仅当参数是字符串字面量时才处理
        if (node.Expression is LiteralExpressionSyntax stringLiteral 
            && stringLiteral.IsKind(SyntaxKind.StringLiteralExpression))
        {
            // 构建StringManipulation的调用表达式
            var invocation = SyntaxFactory.InvocationExpression(
                SyntaxFactory.IdentifierName("StringManipulation"))
                .AddArgumentListArguments(SyntaxFactory.Argument(stringLiteral));

            // 替换原参数表达式
            return node.WithExpression(invocation);
        }

        return base.VisitArgument(node);
    }
}

3. 使用Rewriter转换代码 #

下面是如何用这个Rewriter处理你的示例代码：

输入代码 #

// 变量声明场景
var test = "test var";

// 方法调用场景
Test("Testing");

// 你的自定义方法
public static string StringManipulation(string test) { return test + " new value"; }

转换逻辑代码 #

// 把输入代码解析成语法树
var inputTree = CSharpSyntaxTree.ParseText(yourInputCodeString);
var originalRoot = inputTree.GetRoot();

// 应用Rewriter进行转换
var rewriter = new StringManipulationRewriter();
var updatedRoot = rewriter.Visit(originalRoot);

// 获取转换后的代码字符串
var outputCode = updatedRoot.ToFullString();

转换后的输出代码 #

// 变量声明场景
var test = StringManipulation("test var");

// 方法调用场景
Test(StringManipulation("Testing"));

// 你的自定义方法
public static string StringManipulation(string test) { return test + " new value"; }

关键细节说明 #

• 精准匹配：代码只会处理字符串字面量，不会误修改数字、布尔值等其他类型的字面量。
• 格式保留：Roslyn的SyntaxFactory会自动继承原代码的缩进、空格等格式，输出代码和原代码风格一致。
• 扩展性强：如果后续需要处理更多场景（比如属性初始化器、数组元素里的字符串），只需要在Rewriter中添加对应的VisitXXX方法即可。

内容的提问来源于stack exchange，提问作者Ogglas