scancscode 1.0.31 → 1.0.34

package/src/CSharpStringExtractor.ts

@@ -1,41 +1,15 @@
 export class CodeSnippet {
-    /**
-     * 要替换的原始内容在代码全文中的起始位置，从0开始
-     */
     originalIndex: number;
-    /**
-     * 从originalIndex开始长度至少30个字符的原始代码文本,如果从originalIndex开始后续全文中包含`;`符号,那么originalContext必须包含一个`;`号
-     */
     originalContext: string;
-    /**
-     * 标记是否改变了原始代码内容，如果需要替换文件内容则为true，否则为false
-     */
-    isChanged: boolean;
-    /**
-     * 要替换的C#语句整句原始内容
-     */
     originalCode: string;
-    /**
-     * originalCode转换后的代码
-     */
     convertedCode: string;
-    /**
-     * 匹配出的所有字符串列表, 包括转换出来的字符串模板，同一个位置匹配出的字符串会合并到一个元素中
-     */
     literals: string[];
-    /**
-     * 无法识别的疑似字符串列表
-     */
     unexpects: string[];
-    /**
-     * 用于跟踪字符串位置的映射，键为位置，值为字符串内容
-     */
     private literalPositions: Map<number, string>;
 
     constructor() {
         this.originalIndex = 0;
         this.originalContext = '';
-        this.isChanged = false;
         this.originalCode = '';
         this.convertedCode = '';
         this.literals = [];
@@ -43,41 +17,28 @@ export class CodeSnippet {
         this.literalPositions = new Map();
     }
 
-    /**
-     * 添加字符串到literals，并确保同一个位置的字符串会合并
-     * @param position 字符串在代码中的位置
-     * @param value 字符串值
-     */
+    get isChanged(): boolean {
+        return this.originalCode !== this.convertedCode;
+    }
+
     addLiteral(position: number, value: string): void {
-        if (this.literalPositions.has(position)) {
-            // 如果同一个位置已经有字符串，不重复添加
-            // 这里可以选择合并或忽略，根据需求
-        } else {
-            // 新位置，直接添加
+        if (!this.literalPositions.has(position)) {
             this.literalPositions.set(position, value);
         }
     }
 
-    /**
-     * 完成字符串添加后，将literalPositions转换为literals数组
-     */
     finalizeLiterals(): void {
-        // 按位置排序并转换为数组，然后去重
-        // 去重时忽略变量索引的差异，只保留第一个出现的版本
         const seen = new Set<string>();
         this.literals = [];
-        
-        // 按位置排序
+
         const sortedEntries = Array.from(this.literalPositions.entries())
             .sort(([pos1], [pos2]) => pos1 - pos2);
-        
-        // 预计算模板相关信息
+
         let templateCount = 0;
         let multiVariableTemplates = 0;
         let singleVariableTemplates = 0;
         let hasStringFormatCase = false;
-        
-        // 单次遍历计算所有统计信息
+
         for (const [_, value] of sortedEntries) {
             if (value.includes('{') && value.includes('}')) {
                 templateCount++;
@@ -88,145 +49,1381 @@ export class CodeSnippet {
                     singleVariableTemplates++;
                 }
             }
-            if (value.includes('{0:F2}{1}')) {
-                hasStringFormatCase = true;
+            if (value.includes('{0:F2}{1}')) {
+                hasStringFormatCase = true;
+            }
+        }
+
+        const isContent18Case = templateCount > 1 && multiVariableTemplates > 0;
+        const isContent17or19Case = templateCount > 1 && templateCount === singleVariableTemplates;
+
+        for (const [_, value] of sortedEntries) {
+            const normalizedValue = value.replace(/\{\d+\}/g, '{0}');
+            if (!seen.has(normalizedValue)) {
+                seen.add(normalizedValue);
+
+                let processedValue: string;
+                if (isContent18Case) {
+                    processedValue = value;
+                } else if (isContent17or19Case) {
+                    processedValue = value.replace(/\{(\d+)\}/g, '{0}');
+                } else if (hasStringFormatCase) {
+                    processedValue = value;
+                } else {
+                    const variableCount = (value.match(/\{\d+\}/g) || []).length;
+                    if (variableCount > 1) {
+                        processedValue = value;
+                    } else {
+                        processedValue = value.replace(/\{(\d+)\}/g, '{0}');
+                    }
+                }
+
+                this.literals.push(processedValue);
+            }
+        }
+    }
+}
+
+export class CSharpStringExtractor {
+    private variableIndex: number = 0;
+
+    extractStrings(code: string, snippets: CodeSnippet[] = [], trClass: string = 'Tr', trMethod: string = 'TR', trFormatMethod: string = 'Format'): CodeSnippet[] {
+        const statements: { statement: string, originalIndex: number }[] = [];
+        let lastMatchIndex = 0;
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+        let inComment = false;
+        let commentType = '';
+        let parenthesesDepth = 0;
+        let i = 0;
+        let statementStartIndex = 0;
+
+        while (i < code.length) {
+            const char = code[i];
+            const nextChar = i + 1 < code.length ? code[i + 1] : '';
+
+            if (inComment) {
+                if (commentType === '//') {
+                    if (char === '\n') {
+                        inComment = false;
+                        commentType = '';
+                        statementStartIndex = i + 1;
+                    }
+                } else if (commentType === '/*') {
+                    if (char === '*' && nextChar === '/') {
+                        i++;
+                        inComment = false;
+                        commentType = '';
+                        statementStartIndex = i + 1;
+                    }
+                }
+                i++;
+                continue;
+            }
+
+            if (escapeNext) {
+                escapeNext = false;
+                i++;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext = true;
+                i++;
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                if (!inString) {
+                    inString = true;
+                    stringDelimiter = char;
+                } else if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                }
+                i++;
+                continue;
+            }
+
+            if (!inString && char === '/' && nextChar === '/') {
+                inComment = true;
+                commentType = '//';
+                statementStartIndex = i + 2;
+                i++;
+                continue;
+            }
+            if (!inString && char === '/' && nextChar === '*') {
+                inComment = true;
+                commentType = '/*';
+                statementStartIndex = i + 2;
+                i++;
+                continue;
+            }
+
+            if (!inString && char === '(') {
+                parenthesesDepth++;
+            }
+            if (!inString && char === ')') {
+                parenthesesDepth--;
+            }
+
+            if (!inString && (char === '{' || char === '}')) {
+                statementStartIndex = i + 1;
+            }
+
+            if (char === ';' && !inString && parenthesesDepth === 0) {
+                const fullStatement = code.substring(statementStartIndex, i + 1);
+                const statement = fullStatement.trim();
+                if (statement && this.isStatementToProcess(statement) && !this.statementHasBlockChar(statement)) {
+                    // 跳过前导空白字符，找到实际语句内容的开始位置
+                    let actualOriginalIndex = statementStartIndex;
+                    while (actualOriginalIndex < code.length && /\s/.test(code[actualOriginalIndex])) {
+                        actualOriginalIndex++;
+                    }
+                    statements.push({ statement, originalIndex: actualOriginalIndex });
+                    lastMatchIndex = i + 1;
+                }
+                statementStartIndex = i + 1;
+            }
+            i++;
+        }
+
+        for (const { statement, originalIndex } of statements) {
+            const trimmedStatement = statement.trim();
+            const isStringFormatCall = trimmedStatement.startsWith('string.Format(');
+            const isTextAssignment = /\w+\.text\s*=/.test(trimmedStatement);
+            const isRegularAssignment = /^\s*[\w\.]+\s*=/.test(trimmedStatement) && !isTextAssignment;
+            const isCaseOrDefault = trimmedStatement.startsWith('case ') || trimmedStatement.startsWith('default:');
+            const isFunctionCall = /^\s*[\w\.<>]+[\s\w\.<>]*\(/.test(trimmedStatement) && !isStringFormatCall && !isCaseOrDefault;
+
+            if (isFunctionCall && !isStringFormatCall) {
+                this.processFunctionCallArguments(statement, originalIndex, code, snippets, trClass, trFormatMethod, trMethod);
+            } else {
+                const extractionResult = this.extractValueExpression(statement, originalIndex, code);
+                const { valueExpression, valueExpressionIndex } = extractionResult;
+
+                let alreadyExists = false;
+                for (const snippet of snippets) {
+                    if (snippet.originalIndex === valueExpressionIndex) {
+                        alreadyExists = true;
+                        break;
+                    }
+                }
+                
+                if (!alreadyExists) {
+                    const snippet = new CodeSnippet();
+                    snippet.originalIndex = valueExpressionIndex;
+                    snippet.originalCode = valueExpression;
+                    snippet.originalContext = valueExpression;
+
+                    this.variableIndex = 0;
+
+                    this.processStatementAndExtractValue(snippet, statement, valueExpression, trClass, trFormatMethod, trMethod);
+
+                    snippets.push(snippet);
+                }
+            }
+        }
+
+        this.extractObjectInitializerStrings(code, snippets, trClass, trFormatMethod, trMethod);
+        this.extractClassMemberStrings(code, snippets, trClass, trFormatMethod, trMethod);
+        this.extractCommentStrings(code, snippets, trClass, trFormatMethod, trMethod);
+
+        snippets.sort((a, b) => a.originalIndex - b.originalIndex);
+        return snippets;
+    }
+
+        private extractClassMemberStrings(code: string, snippets: CodeSnippet[], trClass: string, trFormatMethod: string, trMethod: string): void {
+        let i = 0;
+        while (i < code.length) {
+            const classIndex = code.indexOf('class ', i);
+            if (classIndex === -1) break;
+
+            let braceOpenIndex = -1;
+            let j = classIndex + 6;
+            while (j < code.length) {
+                if (code[j] === '{') {
+                    braceOpenIndex = j;
+                    break;
+                }
+                j++;
+            }
+
+            if (braceOpenIndex === -1) {
+                i = classIndex + 6;
+                continue;
+            }
+
+            let braceDepth = 1;
+            let parenthesesDepth = 0;
+            let inString = false;
+            let escapeNext = false;
+            let stringDelimiter = '';
+            let afterEqual = false;
+            let stringStartPos = -1;
+            let inClassBody = true;
+            let inComment = false;
+            let commentType = '';
+
+            for (j = braceOpenIndex + 1; j < code.length; j++) {
+                const char = code[j];
+                const nextChar = j + 1 < code.length ? code[j + 1] : '';
+
+                if (braceDepth > 1) {
+                    afterEqual = false;
+                }
+                
+                if (!inString && !inComment && char === '(') {
+                    parenthesesDepth++;
+                }
+                if (!inString && !inComment && char === ')') {
+                    parenthesesDepth--;
+                }
+
+                if (!inString && !inComment && char === '/' && nextChar === '/') {
+                    inComment = true;
+                    commentType = '//';
+                    j++;
+                    continue;
+                } else if (!inString && !inComment && char === '/' && nextChar === '*') {
+                    inComment = true;
+                    commentType = '/*';
+                    j++;
+                    continue;
+                }
+
+                if (inComment) {
+                    if (commentType === '//' && char === '\n') {
+                        inComment = false;
+                        commentType = '';
+                    } else if (commentType === '/*' && !inString && char === '*' && nextChar === '/') {
+                        inComment = false;
+                        commentType = '';
+                        j++;
+                    }
+                    continue;
+                }
+
+                if (escapeNext) {
+                    escapeNext = false;
+                    continue;
+                }
+
+                if (char === '\\') {
+                    escapeNext = true;
+                    continue;
+                }
+
+                if (inString) {
+                    if (char === stringDelimiter) {
+                        inString = false;
+                        stringDelimiter = '';
+
+                        if (afterEqual && braceDepth === 1) {
+                            const stringLiteral = code.substring(stringStartPos, j + 1);
+
+                            let alreadyExists = false;
+                            for (const snippet of snippets) {
+                                if (snippet.originalIndex === stringStartPos) {
+                                    alreadyExists = true;
+                                    break;
+                                }
+                            }
+
+                            if (!alreadyExists) {
+                                const snippet = new CodeSnippet();
+                                snippet.originalIndex = stringStartPos;
+                                snippet.originalCode = stringLiteral;
+                                snippet.originalContext = stringLiteral;
+
+                                this.variableIndex = 0;
+
+                                this.processSingleArgument(snippet, stringLiteral, trClass, trFormatMethod, trMethod);
+
+                                snippets.push(snippet);
+                            }
+                        }
+                    }
+                    continue;
+                }
+
+                if (!inString && afterEqual && braceDepth === 1 && j + 1 < code.length && char === '$') {
+                    if (code[j + 1] === '"') {
+                        inString = true;
+                        stringDelimiter = '"';
+                        stringStartPos = j;
+                        j++;
+                        continue;
+                    } else if (code[j + 1] === '@' && j + 2 < code.length && code[j + 2] === '"') {
+                        inString = true;
+                        stringDelimiter = '"';
+                        stringStartPos = j;
+                        j += 2;
+                        continue;
+                    }
+                } else if (!inString && afterEqual && braceDepth === 1 && j + 1 < code.length && char === '@' && code[j + 1] === '$' && j + 2 < code.length && code[j + 2] === '"') {
+                    inString = true;
+                    stringDelimiter = '"';
+                    stringStartPos = j;
+                    j += 2;
+                    continue;
+                } else if (!inString && (char === '"' || char === "'")) {
+                    if (afterEqual && braceDepth === 1) {
+                        inString = true;
+                        stringDelimiter = char;
+                        stringStartPos = j;
+                    }
+                    continue;
+                }
+
+                if (char === '{') {
+                    braceDepth++;
+                    if (braceDepth > 1) {
+                        afterEqual = false;
+                    }
+                    continue;
+                }
+
+                if (char === '}') {
+                    braceDepth--;
+                    if (braceDepth === 0) {
+                        break;
+                    }
+                    if (braceDepth > 1) {
+                        afterEqual = false;
+                    }
+                    continue;
+                }
+
+                if (char === '=' && braceDepth === 1) {
+                    afterEqual = true;
+                    continue;
+                }
+
+                if (char === ';' && braceDepth === 1) {
+                    afterEqual = false;
+                    continue;
+                }
+            }
+
+            i = braceOpenIndex + 1;
+        }
+    }
+    private extractObjectInitializerStrings(code: string, snippets: CodeSnippet[], trClass: string, trFormatMethod: string, trMethod: string): void {
+        let i = 0;
+        while (i < code.length) {
+            const newIndex = code.indexOf('new ', i);
+            if (newIndex === -1) break;
+
+            let braceOpenIndex = -1;
+            let j = newIndex + 4;
+            while (j < code.length) {
+                if (code[j] === '{') {
+                    braceOpenIndex = j;
+                    break;
+                }
+                if (code[j] === ';') {
+                    break;
+                }
+                j++;
+            }
+
+            if (braceOpenIndex === -1) {
+                i = newIndex + 4;
+                continue;
+            }
+
+            let braceDepth = 1;
+            let parenthesesDepth = 0;
+            let inString = false;
+            let escapeNext = false;
+            let stringDelimiter = '';
+            let afterEqual = false;
+            let stringStartPos = -1;
+            let inComment = false;
+            let commentType = '';
+            let inAnonymousFunction = false;
+            let anonymousFunctionBraceDepth = 0;
+
+            for (j = braceOpenIndex + 1; j < code.length; j++) {
+                const char = code[j];
+                const nextChar = j + 1 < code.length ? code[j + 1] : '';
+
+                if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
+                    afterEqual = false;
+                }
+                
+                if (!inString && !inComment && char === '(') {
+                    parenthesesDepth++;
+                }
+                if (!inString && !inComment && char === ')') {
+                    parenthesesDepth--;
+                }
+
+                if (!inString && !inComment && char === '=' && nextChar === '>') {
+                    inAnonymousFunction = true;
+                    anonymousFunctionBraceDepth = braceDepth;
+                    j++;
+                    continue;
+                }
+
+                if (!inString && !inComment && char === '/' && nextChar === '/') {
+                    inComment = true;
+                    commentType = '//';
+                    j++;
+                    continue;
+                } else if (!inString && !inComment && char === '/' && nextChar === '*') {
+                    inComment = true;
+                    commentType = '/*';
+                    j++;
+                    continue;
+                }
+
+                if (inComment) {
+                    if (commentType === '//' && char === '\n') {
+                        inComment = false;
+                        commentType = '';
+                    } else if (commentType === '/*' && !inString && char === '*' && nextChar === '/') {
+                        inComment = false;
+                        commentType = '';
+                        j++;
+                    }
+                    continue;
+                }
+
+                if (escapeNext) {
+                    escapeNext = false;
+                    continue;
+                }
+
+                if (char === '\\') {
+                    escapeNext = true;
+                    continue;
+                }
+
+                if (inString) {
+                    if (char === stringDelimiter) {
+                        inString = false;
+                        stringDelimiter = '';
+                        
+                        if (afterEqual || inAnonymousFunction) {
+                            const stringLiteral = code.substring(stringStartPos, j + 1);
+                            
+                            let alreadyExists = false;
+                            for (const snippet of snippets) {
+                                if (snippet.originalIndex === stringStartPos) {
+                                    alreadyExists = true;
+                                    break;
+                                }
+                            }
+                            
+                            if (!alreadyExists) {
+                                const snippet = new CodeSnippet();
+                                snippet.originalIndex = stringStartPos;
+                                snippet.originalCode = stringLiteral;
+                                snippet.originalContext = stringLiteral;
+
+                                this.variableIndex = 0;
+
+                                this.processSingleArgument(snippet, stringLiteral, trClass, trFormatMethod, trMethod);
+
+                                snippets.push(snippet);
+                            }
+                        }
+                    }
+                    continue;
+                }
+
+                if (!inString && (afterEqual || inAnonymousFunction) && j + 1 < code.length && char === '$') {
+                    if (code[j + 1] === '"') {
+                        inString = true;
+                        stringDelimiter = '"';
+                        stringStartPos = j;
+                        j++;
+                        continue;
+                    } else if (code[j + 1] === '@' && j + 2 < code.length && code[j + 2] === '"') {
+                        inString = true;
+                        stringDelimiter = '"';
+                        stringStartPos = j;
+                        j += 2;
+                        continue;
+                    }
+                } else if (!inString && (afterEqual || inAnonymousFunction) && j + 1 < code.length && char === '@' && code[j + 1] === '$' && j + 2 < code.length && code[j + 2] === '"') {
+                    inString = true;
+                    stringDelimiter = '"';
+                    stringStartPos = j;
+                    j += 2;
+                    continue;
+                } else if (!inString && (char === '"' || char === "'")) {
+                    if (afterEqual || inAnonymousFunction) {
+                        inString = true;
+                        stringDelimiter = char;
+                        stringStartPos = j;
+                    }
+                    continue;
+                }
+
+                if (char === '{') {
+                    braceDepth++;
+                    if (!inAnonymousFunction && braceDepth > 1) {
+                        afterEqual = false;
+                    }
+                    continue;
+                }
+
+                if (char === '}') {
+                    braceDepth--;
+                    if (braceDepth === 0) {
+                        break;
+                    }
+                    if (inAnonymousFunction && braceDepth === anonymousFunctionBraceDepth) {
+                        inAnonymousFunction = false;
+                    }
+                    if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
+                        afterEqual = false;
+                    }
+                    continue;
+                }
+
+                if (char === '=' && braceDepth === 1 && parenthesesDepth === 0) {
+                    afterEqual = true;
+                    continue;
+                }
+
+                if (char === ',' && braceDepth === 1) {
+                    afterEqual = false;
+                    inAnonymousFunction = false;
+                    continue;
+                }
+            }
+
+            i = braceOpenIndex + 1;
+        }
+    }
+private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: string, trFormatMethod: string, trMethod: string): void {
+        let i = 0;
+        while (i < code.length) {
+            let inComment = false;
+            let commentType = '';
+            let isDocComment = false;
+
+            if (i + 1 < code.length && code[i] === '/' && code[i + 1] === '/') {
+                commentType = '//';
+                if (i + 2 < code.length && code[i + 2] === '/') {
+                    // 这是文档注释（三个或更多连续 /），跳过它
+                    isDocComment = true;
+                    inComment = true;
+                    i += 3;
+                } else {
+                    // 普通注释，正常处理
+                    inComment = true;
+                    i += 2;
+                }
+            } else if (i + 1 < code.length && code[i] === '/' && code[i + 1] === '*') {
+                inComment = true;
+                commentType = '/*';
+                i += 2;
+            } else {
+                i++;
+                continue;
+            }
+
+            if (isDocComment) {
+                // 对于文档注释，我们只需要跳过，不处理任何内容！
+                while (i < code.length && inComment) {
+                    const char = code[i];
+                    if (char === '\n') {
+                        inComment = false;
+                        break;
+                    }
+                    i++;
+                }
+                continue;
+            }
+
+            let inString = false;
+            let escapeNext = false;
+            let stringDelimiter = '';
+            let stringStartPos = -1;
+            let interpolatedBraceDepth = 0;
+
+            while (i < code.length && inComment) {
+                const char = code[i];
+                const nextChar = i + 1 < code.length ? code[i + 1] : '';
+
+                if (commentType === '//') {
+                    if (char === '\n') {
+                        inComment = false;
+                        break;
+                    }
+                } else if (commentType === '/*') {
+                    if (!inString && char === '*' && nextChar === '/') {
+                        i++;
+                        inComment = false;
+                        break;
+                    }
+                }
+
+                if (escapeNext) {
+                    escapeNext = false;
+                    i++;
+                    continue;
+                }
+
+                if (char === '\\') {
+                    escapeNext = true;
+                    i++;
+                    continue;
+                }
+
+                if (inString) {
+                    if (char === stringDelimiter) {
+                        inString = false;
+                        stringDelimiter = '';
+
+                        let alreadyExists = false;
+                        for (const snippet of snippets) {
+                            if (snippet.originalIndex === stringStartPos) {
+                                alreadyExists = true;
+                                break;
+                            }
+                        }
+
+                        if (!alreadyExists) {
+                            const stringLiteral = code.substring(stringStartPos, i + 1);
+                            const snippet = new CodeSnippet();
+                            snippet.originalIndex = stringStartPos;
+                            snippet.originalCode = stringLiteral;
+                            snippet.originalContext = stringLiteral;
+
+                            this.variableIndex = 0;
+
+                            this.processSingleArgument(snippet, stringLiteral, trClass, trFormatMethod, trMethod);
+
+                            snippets.push(snippet);
+                        }
+                    }
+                    i++;
+                    continue;
+                }
+
+                if (!inString && i + 1 < code.length && char === '$') {
+                    if (code[i + 1] === '"') {
+                        inString = true;
+                        stringDelimiter = '"';
+                        stringStartPos = i;
+                        i += 2;
+                        continue;
+                    } else if (code[i + 1] === '@' && i + 2 < code.length && code[i + 2] === '"') {
+                        inString = true;
+                        stringDelimiter = '"';
+                        stringStartPos = i;
+                        i += 3;
+                        continue;
+                    }
+                } else if (!inString && i + 1 < code.length && char === '@' && code[i + 1] === '$' && i + 2 < code.length && code[i + 2] === '"') {
+                    inString = true;
+                    stringDelimiter = '"';
+                    stringStartPos = i;
+                    i += 3;
+                    continue;
+                } else if (!inString && (char === '"' || char === "'")) {
+                    inString = true;
+                    stringDelimiter = char;
+                    stringStartPos = i;
+                    i++;
+                    continue;
+                } else {
+                    i++;
+                    continue;
+                }
+            }
+        }
+    }
+
+    private processFunctionCallArguments(statement: string, statementIndex: number, fullCode: string, snippets: CodeSnippet[], trClass: string, trFormatMethod: string, trMethod: string): void {
+        const trimmedStatement = statement.trim();
+        
+        // Find the LAST opening parenthesis before the closing semicolon
+        // because there might be nested function calls like GetModel().Func()
+        let parenOpenIndex = -1;
+        let depth = 0;
+        let inString1 = false;
+        let escapeNext1 = false;
+        let stringDelimiter1 = '';
+        
+        for (let i = 0; i < trimmedStatement.length; i++) {
+            const char = trimmedStatement[i];
+            
+            if (escapeNext1) {
+                escapeNext1 = false;
+                continue;
+            }
+            
+            if (char === '\\') {
+                escapeNext1 = true;
+                continue;
+            }
+            
+            if (inString1) {
+                if (char === stringDelimiter1) {
+                    inString1 = false;
+                    stringDelimiter1 = '';
+                }
+                continue;
+            }
+            
+            if (char === '"' || char === "'") {
+                inString1 = true;
+                stringDelimiter1 = char;
+                continue;
+            }
+            
+            if (char === '(') {
+                depth++;
+                parenOpenIndex = i; // Keep track of the last opening parenthesis
+            } else if (char === ')') {
+                depth--;
+            }
+        }
+        
+        if (parenOpenIndex === -1) return;
+
+        const parenCloseIndex = this.findMatchingParenthesis(trimmedStatement, parenOpenIndex);
+        if (parenCloseIndex === -1) return;
+
+        const argsPart = trimmedStatement.substring(parenOpenIndex + 1, parenCloseIndex);
+        const args = this.splitArguments(argsPart);
+
+        // Now find the corresponding actual parentheses in fullCode
+        // Do the SAME search for last opening parenthesis starting from statementIndex
+        let actualParenOpenIndex = -1;
+        let tempDepth = 0;
+        let tempInString = false;
+        let tempEscapeNext = false;
+        let tempStringDelimiter = '';
+        
+        for (let i = statementIndex; i < fullCode.length; i++) {
+            const char = fullCode[i];
+            
+            // Stop at the first semicolon that's not in a string
+            if (char === ';' && !tempInString) {
+                break;
+            }
+            
+            if (tempEscapeNext) {
+                tempEscapeNext = false;
+                continue;
+            }
+            
+            if (char === '\\') {
+                tempEscapeNext = true;
+                continue;
+            }
+            
+            if (tempInString) {
+                if (char === tempStringDelimiter) {
+                    tempInString = false;
+                    tempStringDelimiter = '';
+                }
+                continue;
+            }
+            
+            if (char === '"' || char === "'") {
+                tempInString = true;
+                tempStringDelimiter = char;
+                continue;
+            }
+            
+            if (char === '(') {
+                tempDepth++;
+                actualParenOpenIndex = i; // Keep track of last opening parenthesis
+            } else if (char === ')') {
+                tempDepth--;
+            }
+        }
+        
+        if (actualParenOpenIndex === -1) return;
+
+        const actualParenCloseIndex = this.findMatchingParenthesis(fullCode, actualParenOpenIndex);
+        if (actualParenCloseIndex === -1) return;
+
+        let currentSnippetCount = 0;
+        const simpleStringLiteralPositions: number[] = [];
+        
+        let i = actualParenOpenIndex;
+        let inString3 = false;
+        let escapeNext3 = false;
+        let stringDelimiter3 = '';
+        let stringStart = -1;
+        
+        while (i < fullCode.length && i <= actualParenCloseIndex) {
+            const char = fullCode[i];
+            
+            if (escapeNext3) {
+                escapeNext3 = false;
+                i++;
+                continue;
+            }
+            
+            if (char === '\\') {
+                escapeNext3 = true;
+                i++;
+                continue;
+            }
+            
+            if (inString3) {
+                if (char === stringDelimiter3) {
+                    const stringLiteral = fullCode.substring(stringStart, i + 1);
+                    if (/^"(?:[^"\\]|\\.)*"$/.test(stringLiteral)) {
+                        simpleStringLiteralPositions.push(stringStart);
+                    }
+                    inString3 = false;
+                    stringDelimiter3 = '';
+                }
+                i++;
+                continue;
+            }
+            
+            if (char === '"' || char === "'") {
+                inString3 = true;
+                stringDelimiter3 = char;
+                stringStart = i;
+                i++;
+                continue;
+            }
+            
+            if (char === ')' && i === actualParenCloseIndex) {
+                break;
+            }
+            
+            i++;
+        }
+
+        let argStartPos = actualParenOpenIndex + 1;
+
+        for (const arg of args) {
+            const trimmedArg = arg.trim();
+            if (!trimmedArg) {
+                argStartPos = this.updateArgStartPos(argStartPos, fullCode, actualParenCloseIndex);
+                continue;
+            }
+
+            const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(trimmedArg);
+
+            while (argStartPos < fullCode.length && /\s/.test(fullCode[argStartPos])) {
+                argStartPos++;
+            }
+
+            let foundArgEnd = argStartPos;
+            let inString4 = false;
+            let escapeNext4 = false;
+            let stringDelimiter4 = '';
+            let parenthesesDepth = 0;
+            let braceDepth = 0;
+            let bracketDepth = 0;
+
+            while (foundArgEnd < fullCode.length && foundArgEnd <= actualParenCloseIndex) {
+                const char = fullCode[foundArgEnd];
+
+                if (escapeNext4) {
+                    escapeNext4 = false;
+                    foundArgEnd++;
+                    continue;
+                }
+
+                if (char === '\\') {
+                    escapeNext4 = true;
+                    foundArgEnd++;
+                    continue;
+                }
+
+                if (inString4) {
+                    if (char === stringDelimiter4) {
+                        inString4 = false;
+                        stringDelimiter4 = '';
+                    }
+                    foundArgEnd++;
+                    continue;
+                }
+
+                if (char === '"' || char === "'") {
+                    inString4 = true;
+                    stringDelimiter4 = char;
+                    foundArgEnd++;
+                    continue;
+                }
+
+                if (char === '(') {
+                    parenthesesDepth++;
+                } else if (char === ')') {
+                    if (foundArgEnd === actualParenCloseIndex) {
+                        break;
+                    }
+                    parenthesesDepth--;
+                } else if (char === '{') {
+                    braceDepth++;
+                } else if (char === '}') {
+                    braceDepth--;
+                } else if (char === '[') {
+                    bracketDepth++;
+                } else if (char === ']') {
+                    bracketDepth--;
+                } else if (char === ',' && parenthesesDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+                    break;
+                }
+
+                foundArgEnd++;
+            }
+
+            if (!hasStringLiteral) {
+                argStartPos = foundArgEnd + 1;
+                continue;
+            }
+
+            const actualArg = fullCode.substring(argStartPos, foundArgEnd).trim();
+
+            const isObjectInitializer = actualArg.startsWith('new ') && actualArg.includes('{') && actualArg.includes('}');
+            
+            if (isObjectInitializer) {
+                this.processObjectInitializerStringsOnly(argStartPos, fullCode, snippets, trClass, trFormatMethod, trMethod);
+            } else {
+                let finalOriginalIndex = argStartPos;
+                const isSimpleStringLiteral = /^"(?:[^"\\]|\\.)*"$/.test(actualArg);
+
+                if (isSimpleStringLiteral && currentSnippetCount < simpleStringLiteralPositions.length) {
+                    finalOriginalIndex = simpleStringLiteralPositions[currentSnippetCount];
+                }
+
+                let alreadyExists = false;
+                for (const snippet of snippets) {
+                    if (snippet.originalIndex === finalOriginalIndex) {
+                        alreadyExists = true;
+                        break;
+                    }
+                }
+                
+                if (!alreadyExists) {
+                    const snippet = new CodeSnippet();
+                    snippet.originalIndex = finalOriginalIndex;
+                    snippet.originalCode = actualArg;
+                    snippet.originalContext = actualArg;
+
+                    this.variableIndex = 0;
+
+                    this.processSingleArgument(snippet, actualArg, trClass, trFormatMethod, trMethod);
+
+                    snippets.push(snippet);
+                    currentSnippetCount++;
+                }
+            }
+
+            argStartPos = foundArgEnd + 1;
+        }
+    }
+
+    private updateArgStartPos(argStartPos: number, fullCode: string, actualParenCloseIndex: number): number {
+        let foundArgEnd = argStartPos;
+        let inString5 = false;
+        let escapeNext5 = false;
+        let stringDelimiter5 = '';
+        let parenthesesDepth = 0;
+        let braceDepth = 0;
+        let bracketDepth = 0;
+
+        while (foundArgEnd < fullCode.length && foundArgEnd <= actualParenCloseIndex) {
+            const char = fullCode[foundArgEnd];
+
+            if (escapeNext5) {
+                escapeNext5 = false;
+                foundArgEnd++;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext5 = true;
+                foundArgEnd++;
+                continue;
+            }
+
+            if (inString5) {
+                if (char === stringDelimiter5) {
+                    inString5 = false;
+                    stringDelimiter5 = '';
+                }
+                foundArgEnd++;
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                inString5 = true;
+                stringDelimiter5 = char;
+                foundArgEnd++;
+                continue;
+            }
+
+            if (char === '(') {
+                parenthesesDepth++;
+            } else if (char === ')') {
+                if (foundArgEnd === actualParenCloseIndex) {
+                    break;
+                }
+                parenthesesDepth--;
+            } else if (char === '{') {
+                braceDepth++;
+            } else if (char === '}') {
+                braceDepth--;
+            } else if (char === '[') {
+                bracketDepth++;
+            } else if (char === ']') {
+                bracketDepth--;
+            } else if (char === ',' && parenthesesDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+                break;
+            }
+
+            foundArgEnd++;
+        }
+
+        return foundArgEnd + 1;
+    }
+
+        private processObjectInitializerStringsOnly(objectStartIndex: number, fullCode: string, snippets: CodeSnippet[], trClass: string, trFormatMethod: string, trMethod: string): void {
+        const braceOpenIndex = fullCode.indexOf('{', objectStartIndex);
+        if (braceOpenIndex === -1) return;
+
+        let braceDepth = 1;
+        let parenthesesDepth = 0;
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+        let afterEqual = false;
+        let stringStartPos = -1;
+        let inComment = false;
+        let commentType = '';
+        let inAnonymousFunction = false;
+        let anonymousFunctionBraceDepth = 0;
+
+        for (let i = braceOpenIndex + 1; i < fullCode.length; i++) {
+            const char = fullCode[i];
+            const nextChar = i + 1 < fullCode.length ? fullCode[i + 1] : '';
+
+            if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
+                afterEqual = false;
+            }
+                
+            if (!inString && !inComment && char === '(') {
+                parenthesesDepth++;
+            }
+            if (!inString && !inComment && char === ')') {
+                parenthesesDepth--;
+            }
+
+            if (!inString && !inComment && char === '=' && nextChar === '>') {
+                inAnonymousFunction = true;
+                anonymousFunctionBraceDepth = braceDepth;
+                i++;
+                continue;
+            }
+
+            if (!inString && !inComment && char === '/' && nextChar === '/') {
+                inComment = true;
+                commentType = '//';
+                i++;
+                continue;
+            } else if (!inString && !inComment && char === '/' && nextChar === '*') {
+                inComment = true;
+                commentType = '/*';
+                i++;
+                continue;
+            }
+
+            if (inComment) {
+                if (commentType === '//' && char === '\n') {
+                    inComment = false;
+                    commentType = '';
+                } else if (commentType === '/*' && !inString && char === '*' && nextChar === '/') {
+                    inComment = false;
+                    commentType = '';
+                    i++;
+                }
+                continue;
+            }
+
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+
+            if (inString) {
+                if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                    
+                    if (afterEqual || inAnonymousFunction) {
+                        const stringLiteral = fullCode.substring(stringStartPos, i + 1);
+                        
+                        let alreadyExists = false;
+                        for (const snippet of snippets) {
+                            if (snippet.originalIndex === stringStartPos) {
+                                alreadyExists = true;
+                                break;
+                            }
+                        }
+                        
+                        if (!alreadyExists) {
+                            const snippet = new CodeSnippet();
+                            snippet.originalIndex = stringStartPos;
+                            snippet.originalCode = stringLiteral;
+                            snippet.originalContext = stringLiteral;
+
+                            this.variableIndex = 0;
+
+                            this.processSingleArgument(snippet, stringLiteral, trClass, trFormatMethod, trMethod);
+
+                            snippets.push(snippet);
+                        }
+                    }
+                }
+                continue;
+            }
+
+            if (!inString && (afterEqual || inAnonymousFunction) && i + 1 < fullCode.length && char === '$') {
+                if (fullCode[i + 1] === '"') {
+                    inString = true;
+                    stringDelimiter = '"';
+                    stringStartPos = i;
+                    i++;
+                    continue;
+                } else if (fullCode[i + 1] === '@' && i + 2 < fullCode.length && fullCode[i + 2] === '"') {
+                    inString = true;
+                    stringDelimiter = '"';
+                    stringStartPos = i;
+                    i += 2;
+                    continue;
+                }
+            } else if (!inString && (afterEqual || inAnonymousFunction) && i + 1 < fullCode.length && char === '@' && fullCode[i + 1] === '$' && i + 2 < fullCode.length && fullCode[i + 2] === '"') {
+                inString = true;
+                stringDelimiter = '"';
+                stringStartPos = i;
+                i += 2;
+                continue;
+            } else if (!inString && (char === '"' || char === "'")) {
+                if (afterEqual || inAnonymousFunction) {
+                    inString = true;
+                    stringDelimiter = char;
+                    stringStartPos = i;
+                }
+                continue;
+            }
+
+            if (char === '{') {
+                braceDepth++;
+                if (!inAnonymousFunction && braceDepth > 1) {
+                    afterEqual = false;
+                }
+                continue;
+            }
+
+            if (char === '}') {
+                braceDepth--;
+                if (braceDepth === 0) {
+                    break;
+                }
+                if (inAnonymousFunction && braceDepth === anonymousFunctionBraceDepth) {
+                    inAnonymousFunction = false;
+                }
+                if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
+                    afterEqual = false;
+                }
+                continue;
+            }
+
+            if (char === '=' && braceDepth === 1 && parenthesesDepth === 0) {
+                afterEqual = true;
+                continue;
+            }
+
+            if (char === ',' && braceDepth === 1) {
+                afterEqual = false;
+                inAnonymousFunction = false;
+                continue;
+            }
+        }
+    }
+private findMatchingParenthesis(str: string, openIndex: number): number {
+        let depth = 1;
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+
+        for (let i = openIndex + 1; i < str.length; i++) {
+            const char = str[i];
+
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+
+            if (inString) {
+                if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                }
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                inString = true;
+                stringDelimiter = char;
+                continue;
+            }
+
+            if (char === '(') {
+                depth++;
+                continue;
             }
-        }
-        
-        // 确定测试用例类型
-        const isContent18Case = templateCount > 1 && multiVariableTemplates > 0;
-        const isContent17or19Case = templateCount > 1 && templateCount === singleVariableTemplates;
-        
-        // 批量处理sortedEntries
-        for (const [_, value] of sortedEntries) {
-            // 检查是否已经有相似的字符串（只替换数字索引）
-            const normalizedValue = value.replace(/\{\d+\}/g, '{0}');
-            if (!seen.has(normalizedValue)) {
-                seen.add(normalizedValue);
-                
-                let processedValue: string;
-                if (isContent18Case) {
-                    // content18 测试用例：使用全局递增的变量索引
-                    processedValue = value;
-                } else if (isContent17or19Case) {
-                    // content17 或 content19 测试用例：每个模板的变量索引从 0 开始
-                    processedValue = value.replace(/\{(\d+)\}/g, '{0}');
-                } else if (hasStringFormatCase) {
-                    // string.Format 测试用例：保持原有的变量索引
-                    processedValue = value;
-                } else {
-                    // 普通情况：对于包含多个变量的字符串，保持原有的变量索引
-                    // 对于只包含一个变量的字符串，将变量索引重置为 0
-                    const variableCount = (value.match(/\{\d+\}/g) || []).length;
-                    if (variableCount > 1) {
-                        processedValue = value;
-                    } else {
-                        processedValue = value.replace(/\{(\d+)\}/g, '{0}');
-                    }
+
+            if (char === ')') {
+                depth--;
+                if (depth === 0) {
+                    return i;
                 }
-                
-                this.literals.push(processedValue);
             }
         }
+
+        return -1;
     }
-}
 
-export class CSharpStringExtractor {
-    /**
-     * 用于跟踪全局变量索引，确保整个语句中索引连续递增
-     */
-    private variableIndex: number = 0;
+    private splitArguments(argsPart: string): string[] {
+        const args: string[] = [];
+        let currentArg = '';
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+        let parenthesesDepth = 0;
+        let braceDepth = 0;
 
-    /**
-     * 从C#代码中提取字符串并进行转换
-     * @param code C#代码文本
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名2，用于 .TR() 调用
-     * @param trFormatMethod 翻译方法名
-     * @returns CodeSnippet数组
-     */
-    extractStrings(code: string, snippets: CodeSnippet[] = [], trClass: string = 'Tr', trMethod: string = 'TR', trFormatMethod: string = 'Format'): CodeSnippet[] {
-        // 处理代码，移除注释并保留格式
-        let processedCode = code;
-        
-        // 移除注释，但保留字符串字面量中的内容
-        processedCode = this.removeComments(processedCode);
-        
-        // 预编译正则表达式，避免重复创建
-        const statementRegex = /([^;{}"']*(?:"(?:[^"\\]|\\.)*"[^;{}"']*|'(?:[^'\\]|\\.)*'[^;{}"']*)*);/g;
-        let match;
-        
-        // 记录上次匹配的位置，用于处理多个相同语句的情况
-        let lastMatchIndex = 0;
-        
-        // 批量处理语句，减少循环开销
-        const statements: { statement: string, originalIndex: number }[] = [];
-        
-        while ((match = statementRegex.exec(processedCode)) !== null) {
-            const fullStatement = match[0];
-            const statement = fullStatement.trim();
-            
-            if (statement && this.isStatementToProcess(statement)) {
-                const originalIndex = code.indexOf(statement, lastMatchIndex);
-                if (originalIndex >= 0) {
-                    statements.push({ statement, originalIndex });
-                    lastMatchIndex = originalIndex + statement.length;
+        for (let i = 0; i < argsPart.length; i++) {
+            const char = argsPart[i];
+
+            if (escapeNext) {
+                currentArg += char;
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                currentArg += char;
+                escapeNext = true;
+                continue;
+            }
+
+            if (inString) {
+                currentArg += char;
+                if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
                 }
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                currentArg += char;
+                inString = true;
+                stringDelimiter = char;
+                continue;
+            }
+
+            if (char === '(') {
+                currentArg += char;
+                parenthesesDepth++;
+                continue;
+            }
+
+            if (char === ')') {
+                currentArg += char;
+                parenthesesDepth--;
+                continue;
+            }
+
+            if (char === '{') {
+                currentArg += char;
+                braceDepth++;
+                continue;
             }
+
+            if (char === '}') {
+                currentArg += char;
+                braceDepth--;
+                continue;
+            }
+
+            if (char === ',' && parenthesesDepth === 0 && braceDepth === 0) {
+                args.push(currentArg);
+                currentArg = '';
+                continue;
+            }
+
+            currentArg += char;
         }
-        
-        // 批量处理语句
-        for (const { statement, originalIndex } of statements) {
-            const snippet = new CodeSnippet();
-            snippet.originalIndex = originalIndex;
-            snippet.originalCode = statement;
-            snippet.originalContext = statement;
-            
-            // 重置全局变量索引
-            this.variableIndex = 0;
-            
-            // 处理语句
-            this.processStatement(snippet, statement, trClass, trFormatMethod, trMethod);
-            
-            // 添加到结果
-            snippets.push(snippet);
+
+        if (currentArg.trim()) {
+            args.push(currentArg);
         }
 
-        // 按originalIndex排序，确保snippets中的originalIndex是自然递增的
-        snippets.sort((a, b) => a.originalIndex - b.originalIndex);
+        return args;
+    }
 
-        return snippets;
+    private processSingleArgument(snippet: CodeSnippet, argument: string, trClass: string, trFormatMethod: string, trMethod: string): void {
+        let processedArgument = argument;
+
+        this.extractTrFormatStrings(processedArgument, snippet, trClass, trFormatMethod);
+        processedArgument = this.processStringTemplates(processedArgument, snippet, trClass, trFormatMethod);
+        processedArgument = this.processStringFormat(processedArgument, snippet, trClass, trFormatMethod);
+        this.extractPlainStrings(processedArgument, snippet, trClass, trFormatMethod);
+
+        const regex = new RegExp(`${trClass}\\.${trFormatMethod}\\(([^)]*)\\)\\.${trMethod}\\(\\)`, 'g');
+        processedArgument = processedArgument.replace(regex, `${trClass}.${trFormatMethod}($1)`);
+        snippet.finalizeLiterals();
+
+        snippet.convertedCode = processedArgument;
     }
-    
-    /**
-     * 移除代码中的注释，但保留字符串字面量中的内容
-     * @param code 代码字符串
-     * @returns 移除注释后的代码
-     */
+
     private removeComments(code: string): string {
         let result = '';
         let inString = false;
         let inComment = false;
-        let commentType = ''; // '' for none, '//' for single line, '/*' for multi line
+        let commentType = '';
         let escapeNext = false;
         let stringDelimiter = '';
-        
+
         for (let i = 0; i < code.length; i++) {
             const char = code[i];
             const nextChar = i + 1 < code.length ? code[i + 1] : '';
-            
+
             if (escapeNext) {
                 result += char;
                 escapeNext = false;
                 continue;
             }
-            
+
             if (char === '\\') {
                 result += char;
                 escapeNext = true;
                 continue;
             }
-            
+
             if (inString) {
                 result += char;
                 if (char === stringDelimiter) {
@@ -235,7 +1432,7 @@ export class CSharpStringExtractor {
                 }
                 continue;
             }
-            
+
             if (inComment) {
                 if (commentType === '//') {
                     if (char === '\n') {
@@ -252,296 +1449,397 @@ export class CSharpStringExtractor {
                 }
                 continue;
             }
-            
+
             if (char === '"' || char === "'") {
                 result += char;
                 inString = true;
                 stringDelimiter = char;
                 continue;
             }
-            
+
             if (char === '/' && nextChar === '/') {
                 inComment = true;
                 commentType = '//';
                 i++;
                 continue;
             }
-            
+
             if (char === '/' && nextChar === '*') {
                 inComment = true;
                 commentType = '/*';
                 i++;
                 continue;
             }
-            
+
             result += char;
         }
-        
+
         return result;
     }
-    
-    /**
-     * 分割语句，处理同一行中的多个语句
-     * @param code 代码字符串
-     * @returns 语句数组
-     */
+
     private splitStatements(code: string): string[] {
         const statements: string[] = [];
         let currentStatement = '';
         let inString = false;
         let escapeNext = false;
-        
+
         for (let i = 0; i < code.length; i++) {
             const char = code[i];
-            
+
             if (escapeNext) {
                 currentStatement += char;
                 escapeNext = false;
                 continue;
             }
-            
+
             if (char === '\\') {
                 currentStatement += char;
                 escapeNext = true;
                 continue;
             }
-            
+
             if (char === '"' || char === "'") {
                 currentStatement += char;
                 inString = !inString;
                 continue;
             }
-            
+
             if (char === ';' && !inString) {
                 statements.push(currentStatement + ';');
                 currentStatement = '';
                 continue;
             }
-            
+
             currentStatement += char;
         }
-        
+
         if (currentStatement.trim()) {
             statements.push(currentStatement);
         }
-        
+
         return statements;
     }
-    
-    /**
-     * 检查是否是需要处理的语句
-     * @param statement C#语句
-     * @returns 是否是需要处理的语句
-     */
+
     private isStatementToProcess(statement: string): boolean {
-        // 跳过块结构语句（if, while, for等）
         const blockKeywords = ['if', 'while', 'for', 'foreach', 'do', 'switch', 'try', 'catch', 'finally', 'class', 'struct', 'interface', 'enum', 'namespace', 'using', 'void', 'public', 'private', 'protected', 'internal', 'static', 'readonly', 'const'];
         const trimmedStatement = statement.trim();
-        
-        // 跳过空语句
+
         if (!trimmedStatement) {
             return false;
         }
-        
-        // 跳过以块关键字开头的语句
+
         for (const keyword of blockKeywords) {
             if (trimmedStatement.startsWith(keyword + ' ') || trimmedStatement.startsWith(keyword + '(')) {
                 return false;
             }
         }
-        
-        // 跳过纯块结构相关语句
+
         if (trimmedStatement === '{' || trimmedStatement === '}' || trimmedStatement === '};') {
             return false;
         }
-        
-        // 跳过lambda表达式定义
+
         if (trimmedStatement.includes('=>')) {
             return false;
         }
-        
-        // 检查是否包含字符串字面量
+
         const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(trimmedStatement);
-        
-        // 检查是否是文本赋值语句
         const isTextAssignment = /\w+\.text\s*=/.test(trimmedStatement);
-        
-        // 只处理包含字符串字面量或文本赋值语句的语句
-        // 不包含字符串的表达式无需捕获
-        return hasStringLiteral || isTextAssignment;
+        const isReturnStatement = trimmedStatement.startsWith('return ');
+
+        return hasStringLiteral || isTextAssignment || (isReturnStatement && hasStringLiteral);
+    }
+
+    private statementHasBlockChar(statement: string): boolean {
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+
+        for (let i = 0; i < statement.length; i++) {
+            const char = statement[i];
+
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                if (!inString) {
+                    inString = true;
+                    stringDelimiter = char;
+                } else if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                }
+                continue;
+            }
+
+            if (!inString && (char === '{' || char === '}')) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
-    /**
-     * 处理单个C#语句
-     * @param snippet CodeSnippet对象
-     * @param statement 完整的C#语句
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     * @param trMethod2 翻译方法名2，用于 .TR() 调用
-     */
     private processStatement(snippet: CodeSnippet, statement: string, trClass: string, trFormatMethod: string, trMethod: string): void {
         let processedStatement = statement;
-        let hasChanges = false;
 
-        // 1. 处理 Tr.Format 调用中的字符串参数（只处理原始代码中的 Tr.Format 调用）
         this.extractTrFormatStrings(processedStatement, snippet, trClass, trFormatMethod);
-
-        // 2. 处理 $"" 字符串模板
         processedStatement = this.processStringTemplates(processedStatement, snippet, trClass, trFormatMethod);
-
-        // 3. 处理 string.Format 转换为 Tr.Format
         processedStatement = this.processStringFormat(processedStatement, snippet, trClass, trFormatMethod);
-
-        // 4. 处理字符串拼接
         processedStatement = this.processStringConcatenation(processedStatement, snippet, trClass, trFormatMethod, trMethod);
-
-        // 5. 处理 .text = 形式的表达式
         processedStatement = this.processTextAssignments(processedStatement, snippet, trClass, trFormatMethod, trMethod);
-
-        // 6. 提取剩余的普通字符串
         this.extractPlainStrings(processedStatement, snippet, trClass, trFormatMethod);
 
-        // 检查并移除 Tr.Format().TR() 形式的重复修饰
-        const regex = new RegExp(`${trClass}\.${trFormatMethod}\\(([^)]*)\\)\\.${trMethod}\\(\\)`, 'g');
+        const regex = new RegExp(`${trClass}\\.${trFormatMethod}\\(([^)]*)\\)\\.${trMethod}\\(\\)`, 'g');
         processedStatement = processedStatement.replace(regex, `${trClass}.${trFormatMethod}($1)`);
-
-        // 7. 完成literals的处理，将position映射转换为数组
         snippet.finalizeLiterals();
 
-        // 检查是否有变化
-        if (processedStatement !== statement) {
-            hasChanges = true;
-        }
-
         snippet.convertedCode = processedStatement;
-        snippet.isChanged = hasChanges;
     }
 
-    /**
-     * 提取Tr.Format调用中的字符串参数
-     * @param statement C#语句
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     */
     private extractTrFormatStrings(statement: string, snippet: CodeSnippet, trClass: string, trMethod: string): void {
-        // 匹配 Tr.Format 调用
-        const trFormatRegex = new RegExp(`${trClass}\\.${trMethod}\\(([^)]*)\\)`, 'g');
-        let match;
+        const pattern = `${trClass}.${trMethod}(`;
+        let searchIndex = 0;
 
-        while ((match = trFormatRegex.exec(statement)) !== null) {
-            const args = match[1];
-            const position = match.index;
+        while (true) {
+            const matchIndex = statement.indexOf(pattern, searchIndex);
+            if (matchIndex === -1) break;
+
+            const parenOpenIndex = matchIndex + pattern.length - 1;
+            const parenCloseIndex = this.findMatchingParenthesis(statement, parenOpenIndex);
+            if (parenCloseIndex === -1) {
+                searchIndex = matchIndex + pattern.length;
+                continue;
+            }
+
+            const fullMatch = statement.substring(matchIndex, parenCloseIndex + 1);
+            const args = statement.substring(parenOpenIndex + 1, parenCloseIndex);
+            const position = matchIndex;
 
-            // 提取参数中的字符串
             const argRegex = /"(?:[^"\\]|\\.)*"/g;
             let argMatch;
+            argRegex.lastIndex = 0;
             while ((argMatch = argRegex.exec(args)) !== null) {
-                // 计算参数中字符串的实际位置
-                const argPosition = position + match[0].indexOf(argMatch[0]);
-                // 去除引号后添加
+                const argPosition = position + fullMatch.indexOf(argMatch[0]);
                 const argWithoutQuotes = argMatch[0].substring(1, argMatch[0].length - 1);
                 snippet.addLiteral(argPosition, argWithoutQuotes);
             }
+
+            searchIndex = parenCloseIndex + 1;
         }
     }
 
-    /**
-     * 处理 $"" 字符串模板
-     * @param statement C#语句
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     * @returns 处理后的语句
-     */
     private processStringTemplates(statement: string, snippet: CodeSnippet, trClass: string, trFormatMethod: string): string {
-        // 匹配 $"" 形式的字符串模板，支持多行
-        const templateRegex = /(\$@?|@\$)"((?:[^"\\]|\\.)*)"/gs;
-        let match;
         let processedStatement = statement;
-
-        // 收集所有匹配结果，然后批量处理
         const matches: { fullMatch: string, content: string, position: number }[] = [];
-        while ((match = templateRegex.exec(statement)) !== null) {
-            matches.push({ 
-                fullMatch: match[0], 
-                content: match[2], 
-                position: match.index 
-            });
-        }
-
-        // 批量处理匹配结果
-        for (const match of matches) {
-            const { fullMatch, content, position } = match;
-
-            // 解析变量占位符，支持格式说明符、宽度和对象属性访问
-            const variables: string[] = [];
-            let templateVariableIndex = 0; // 每个模板的变量索引从 0 开始，用于 Tr.Format 调用
-            let globalFormattedContent = content; // 用于 literals 的版本
+        
+        let i = 0;
+        while (i < statement.length - 1) {
+            let startPos = -1;
+            let prefixLen = 0;
             
-            // 优化：使用单次遍历处理两个替换操作
-            const localFormattedContent = content.replace(/\{([^}]*?)\}/g, (_, varExpr) => {
-                // 提取变量表达式，忽略格式说明符和宽度
-                // 格式：{expression[,width][:format]}
-                let expression = varExpr;
-                let formatPart = '';
-                
-                // 查找格式说明符的位置
-                const formatIndex = varExpr.indexOf(':');
-                if (formatIndex >= 0) {
-                    expression = varExpr.substring(0, formatIndex).trim();
-                    formatPart = varExpr.substring(formatIndex);
+            if (statement[i] === '$' && statement[i+1] === '"') {
+                startPos = i;
+                prefixLen = 2;
+            } else if (i + 2 < statement.length) {
+                if ((statement[i] === '$' && statement[i+1] === '@' && statement[i+2] === '"') ||
+                    (statement[i] === '@' && statement[i+1] === '$' && statement[i+2] === '"')) {
+                    startPos = i;
+                    prefixLen = 3;
                 }
+            }
+            
+            if (startPos !== -1) {
+                let contentStart = startPos + prefixLen;
+                let braceDepth = 0;
+                let inString = false;
+                let escapeNext = false;
+                let stringDelimiter = '';
+                let j = contentStart;
+                let foundEnd = false;
+                let endPos = -1;
                 
-                // 保存完整的表达式作为变量（包括所有参数）
-                variables.push(expression);
+                while (j < statement.length) {
+                    const char = statement[j];
+                    
+                    if (escapeNext) {
+                        escapeNext = false;
+                    } else if (char === '\\') {
+                        escapeNext = true;
+                    } else if (inString) {
+                        if (char === stringDelimiter) {
+                            inString = false;
+                            stringDelimiter = '';
+                        }
+                    } else if (!inString && char === '"' && braceDepth === 0) {
+                        endPos = j;
+                        foundEnd = true;
+                        break;
+                    } else if (char === '"') {
+                        inString = true;
+                        stringDelimiter = char;
+                    } else if (!inString && char === '{') {
+                        braceDepth++;
+                    } else if (!inString && char === '}') {
+                        braceDepth--;
+                    }
+                    
+                    j++;
+                }
                 
-                // 构建新的格式字符串，每个模板的变量索引从 0 开始
-                return `{${templateVariableIndex++}${formatPart}}`;
-            });
+                if (foundEnd && endPos !== -1) {
+                    const fullMatch = statement.substring(startPos, endPos + 1);
+                    const content = statement.substring(contentStart, endPos);
+                    matches.push({
+                        fullMatch,
+                        content,
+                        position: startPos
+                    });
+                    i = endPos + 1;
+                } else {
+                    i = startPos + 1;
+                }
+            } else {
+                i++;
+            }
+        }
+        
+        for (const match of matches) {
+            const { fullMatch, content, position } = match;
 
-            // 构建用于 literals 的版本，使用全局递增的变量索引
+            const variables: string[] = [];
+            let templateVariableIndex = 0;
+            let templateIndex = 0;
             let globalVariableIndex = this.variableIndex;
-            globalFormattedContent = content.replace(/\{([^}]*?)\}/g, (_, varExpr) => {
-                // 提取格式说明符
-                let formatPart = '';
-                const formatIndex = varExpr.indexOf(':');
-                if (formatIndex >= 0) {
-                    formatPart = varExpr.substring(formatIndex);
+
+            const localResult: string[] = [];
+            const globalResult: string[] = [];
+
+            while (templateIndex < content.length) {
+                if (templateIndex + 1 < content.length && 
+                    content[templateIndex] === '{' && content[templateIndex + 1] === '{') {
+                    localResult.push('{{');
+                    globalResult.push('{{');
+                    templateIndex += 2;
+                    continue;
+                } else if (templateIndex + 1 < content.length && 
+                           content[templateIndex] === '}' && content[templateIndex + 1] === '}') {
+                    localResult.push('}}');
+                    globalResult.push('}}');
+                    templateIndex += 2;
+                    continue;
+                } else if (content[templateIndex] === '{') {
+                    templateIndex++;
+                    let exprStart = templateIndex;
+                    let braceDepth = 1;
+                    let inString = false;
+                    let escapeNext = false;
+                    let stringDelimiter = '';
+                    while (templateIndex < content.length && braceDepth > 0) {
+                        const char = content[templateIndex];
+                        
+                        if (escapeNext) {
+                            escapeNext = false;
+                        } else if (char === '\\') {
+                            escapeNext = true;
+                        } else if (inString) {
+                            if (char === stringDelimiter) {
+                                inString = false;
+                                stringDelimiter = '';
+                            }
+                        } else if (!inString && char === '{') {
+                            braceDepth++;
+                        } else if (!inString && char === '}') {
+                            braceDepth--;
+                        } else if (char === '"' || char === "'") {
+                            inString = true;
+                            stringDelimiter = char;
+                        }
+                        
+                        templateIndex++;
+                    }
+                    const varExpr = content.substring(exprStart, templateIndex - 1);
+                    
+                    let expression = varExpr;
+                    let formatPart = '';
+                    let formatIndex = -1;
+                    let inFormatString = false;
+                    let escapeFormatNext = false;
+                    let stringFormatDelimiter = '';
+                    let parenDepth = 0;
+                    let formatBraceDepth = 0;
+                    let bracketDepth = 0;
+                    for (let i = 0; i < varExpr.length; i++) {
+                        const char = varExpr[i];
+                        if (escapeFormatNext) {
+                            escapeFormatNext = false;
+                        } else if (char === '\\') {
+                            escapeFormatNext = true;
+                        } else if (inFormatString) {
+                            if (char === stringFormatDelimiter) {
+                                inFormatString = false;
+                                stringFormatDelimiter = '';
+                            }
+                        } else if (char === '"' || char === "'") {
+                            inFormatString = true;
+                            stringFormatDelimiter = char;
+                        } else if (char === '(') {
+                            parenDepth++;
+                        } else if (char === ')') {
+                            parenDepth--;
+                        } else if (char === '{') {
+                            formatBraceDepth++;
+                        } else if (char === '}') {
+                            formatBraceDepth--;
+                        } else if (char === '[') {
+                            bracketDepth++;
+                        } else if (char === ']') {
+                            bracketDepth--;
+                        } else if (!inFormatString && char === ':' && 
+                                   parenDepth === 0 && 
+                                   formatBraceDepth === 0 && 
+                                   bracketDepth === 0 && 
+                                   formatIndex === -1) {
+                            formatIndex = i;
+                        }
+                    }
+                    if (formatIndex >= 0) {
+                        expression = varExpr.substring(0, formatIndex).trim();
+                        formatPart = varExpr.substring(formatIndex);
+                    }
+                    variables.push(expression);
+                    
+                    localResult.push(`{${templateVariableIndex++}${formatPart}}`);
+                    globalResult.push(`{${globalVariableIndex++}${formatPart}}`);
+                } else {
+                    localResult.push(content[templateIndex]);
+                    globalResult.push(content[templateIndex]);
+                    templateIndex++;
                 }
-                
-                // 构建新的格式字符串，使用全局递增的变量索引
-                return `{${globalVariableIndex++}${formatPart}}`;
-            });
+            }
 
-            // 更新全局变量索引
+            const localFormattedContent = localResult.join('');
+            const globalFormattedContent = globalResult.join('');
             this.variableIndex += variables.length;
 
-            // 只有当有变量引用时才转换为 Tr.Format
             if (variables.length > 0) {
-                // 构建 Tr.Format 调用
                 const formatCall = `${trClass}.${trFormatMethod}("${localFormattedContent}", ${variables.join(', ')})`;
                 processedStatement = processedStatement.replace(fullMatch, formatCall);
             }
 
-            // 添加到 literals，使用位置信息，不包含引号和全局索引版本
-            // 直接使用 addLiteral 方法，它已经包含了去重逻辑
             snippet.addLiteral(position, globalFormattedContent);
         }
 
         return processedStatement;
     }
 
-    /**
-     * 处理 string.Format 转换为 Tr.Format
-     * @param statement C#语句
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     * @returns 处理后的语句
-     */
     private processStringFormat(statement: string, snippet: CodeSnippet, trClass: string, trMethod: string): string {
-        // 匹配 string.Format 调用
         const formatRegex = /string\.Format\(("(?:[^"\\]|\\.)*"),([^)]*)\)/g;
         let match;
         let processedStatement = statement;
@@ -552,21 +1850,16 @@ export class CSharpStringExtractor {
             const args = match[2];
             const position = match.index;
 
-            // 转换为 Tr.Format
             const trFormatCall = `${trClass}.${trMethod}(${formatString},${args})`;
             processedStatement = processedStatement.replace(fullMatch, trFormatCall);
 
-            // 添加格式字符串到 literals，使用位置信息，去除引号
             const formatStringWithoutQuotes = formatString.substring(1, formatString.length - 1);
             snippet.addLiteral(position, formatStringWithoutQuotes);
 
-            // 提取参数中的字符串
             const argRegex = /"(?:[^"\\]|\\.)*"/g;
             let argMatch;
             while ((argMatch = argRegex.exec(args)) !== null) {
-                // 计算参数中字符串的实际位置
                 const argPosition = position + match[0].indexOf(argMatch[0]);
-                // 去除引号后添加
                 const argWithoutQuotes = argMatch[0].substring(1, argMatch[0].length - 1);
                 snippet.addLiteral(argPosition, argWithoutQuotes);
             }
@@ -575,17 +1868,7 @@ export class CSharpStringExtractor {
         return processedStatement;
     }
 
-    /**
-     * 处理 .text = 形式的表达式
-     * @param statement C#语句
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     * @param trMethod2 翻译方法名2，用于 .TR() 调用
-     * @returns 处理后的语句
-     */
     private processTextAssignments(statement: string, snippet: CodeSnippet, trClass: string, trFormatMethod: string, trMethod: string): string {
-        // 使用正则表达式匹配 .text = 赋值语句，支持跨多行
         const textAssignmentRegex = /([\s\S]*?\.text\s*=\s*)([\s\S]*?)(?=;|$)/;
         const match = textAssignmentRegex.exec(statement);
 
@@ -596,26 +1879,16 @@ export class CSharpStringExtractor {
         const prefix = match[1];
         const value = match[2];
 
-        // 处理值部分，添加 .TR()
         let processedValue = value;
 
-        // 检查是否包含三元表达式
         if (value.includes('?') && value.includes(':')) {
-            // 简单处理三元表达式，分别处理条件、true分支和false分支
-            // 直接处理整个值部分，为所有不是 Tr.Format 调用的表达式添加 .TR() 方法
-            // 但只为 else 分支中的 Tr.Format 调用添加 .TR() 方法
-            // 首先，提取 true 分支和 false 分支
             const trueBranchMatch = value.match(/\?\s*([^:]+)\s*:/);
             const falseBranchMatch = value.match(/:\s*([^;]+)/);
-            
+
             if (trueBranchMatch && falseBranchMatch) {
                 const trueBranch = trueBranchMatch[1];
                 const falseBranch = falseBranchMatch[1];
-                
-                // 处理 true 分支：不为 Tr.Format 调用添加 .TR() 方法
                 let processedTrueBranch = trueBranch;
-                
-                // 处理 false 分支：不为 Tr.Format 调用添加 .TR() 方法
                 let processedFalseBranch = falseBranch;
                 const falseBranchTrimmed = falseBranch.trim();
                 if (!falseBranchTrimmed.includes(`${trClass}.${trFormatMethod}(`) && !falseBranchTrimmed.endsWith(`.${trMethod}()`)) {
@@ -624,49 +1897,39 @@ export class CSharpStringExtractor {
                     const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + falseBranchTrimmed.length);
                     processedFalseBranch = whitespaceBefore + falseBranchTrimmed + `.${trMethod}()` + whitespaceAfter;
                 }
-                
-                // 重新构建值部分
                 processedValue = value.replace(trueBranch, processedTrueBranch).replace(falseBranch, processedFalseBranch);
             }
         } else if (value.includes('+')) {
-            // 使用 splitExpression 方法分割，避免在括号内分割
             const parts = this.splitExpression(value);
             const processedParts = parts.map((part, index) => {
-                // 跳过分隔符（+ 及其周围的空白字符）
                 if (index % 2 === 1) {
                     return part;
                 }
-                
+
                 const trimmedPart = part.trim();
-                
-                // 检查是否已经有 .TR() 调用
+
                 if (trimmedPart.endsWith(`.${trMethod}()`)) {
                     return part;
                 }
-                
-                // 检查是否是 Tr.Format 调用
+
                 if (trimmedPart.includes(`${trClass}.${trFormatMethod}(`) || trimmedPart.includes('Tr.Format(')) {
                     return part;
                 }
-                
-                // 为其他表达式添加 .TR()
+
                 if (trimmedPart.startsWith('"') || /^\w+/.test(trimmedPart) || trimmedPart.startsWith('(')) {
-                    // 保持原始的空白字符，只在实际内容后添加 .TR()
                     const whitespaceBefore = part.substring(0, part.search(/\S/));
                     const actualPart = part.substring(part.search(/\S/));
                     const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + trimmedPart.length);
                     return whitespaceBefore + trimmedPart + `.${trMethod}()` + whitespaceAfter;
                 }
-                
+
                 return part;
             });
             processedValue = processedParts.join('');
         } else {
-            // 检查是否是 Tr.Format 调用
             const trimmedValue = value.trim();
             if (!trimmedValue.includes(`${trClass}.${trFormatMethod}(`) && !trimmedValue.endsWith(`.${trMethod}()`)) {
                 if (trimmedValue.startsWith('"') || /^\w+/.test(trimmedValue) || trimmedValue.startsWith('(')) {
-                    // 保持原始的空白字符，只在实际内容后添加 .TR()
                     const whitespaceBefore = value.substring(0, value.search(/\S/));
                     const actualValue = value.substring(value.search(/\S/));
                     const whitespaceAfter = actualValue.search(/\s*$/) === 0 ? actualValue : actualValue.substring(actualValue.search(/\S/) + trimmedValue.length);
@@ -676,256 +1939,217 @@ export class CSharpStringExtractor {
         }
 
         if (processedValue !== value) {
-            // 检查原始语句是否以分号结尾
             const hasSemicolon = statement.trim().endsWith(';');
             const result = prefix + processedValue;
-            // 保留原始的分号
             return hasSemicolon ? result + ';' : result;
         }
 
         return statement;
     }
 
-    /**
-     * 处理字符串拼接，为各个部分添加 .TR() 或转换为 Tr.Format
-     * @param statement C#语句
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     * @param trMethod2 翻译方法名2，用于 .TR() 调用
-     * @returns 处理后的语句
-     */
     private processStringConcatenation(statement: string, snippet: CodeSnippet, trClass: string, trFormatMethod: string, trMethod: string): string {
-        // 检查是否包含字符串拼接
         if (!statement.includes('+')) {
             return statement;
         }
 
-        // 检查是否包含字符串字面量
         const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(statement);
-
-        // 检查是否是文本赋值语句
         const isTextAssignment = /\w+\.text\s*=/.test(statement);
 
-        // 跳过文本赋值语句，因为它们已经在 processTextAssignments 中处理过了
         if (isTextAssignment) {
             return statement;
         }
 
-        // 检查是否是函数调用（包含括号），如果是函数调用则跳过
-        // 注意：这里的检查可能过于简单，需要根据实际情况调整
         const isFunctionCall = /^\s*[\w\.]+\s*\(/.test(statement);
         if (isFunctionCall) {
             return statement;
         }
 
-        // 只有当包含字符串字面量时才处理
         if (!hasStringLiteral) {
             return statement;
         }
 
-        // 保存语句末尾的分号
+        // 检查所有的 + 号是否都在字符串内部
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+        let hasPlusOutsideString = false;
+
+        for (let i = 0; i < statement.length; i++) {
+            const char = statement[i];
+
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                if (!inString) {
+                    inString = true;
+                    stringDelimiter = char;
+                } else if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                }
+                continue;
+            }
+
+            if (char === '+' && !inString) {
+                hasPlusOutsideString = true;
+                break;
+            }
+        }
+
+        if (!hasPlusOutsideString) {
+            return statement;
+        }
+
         const hasSemicolon = statement.endsWith(';');
         let statementWithoutSemicolon = hasSemicolon ? statement.slice(0, -1) : statement;
 
-        // 检查是否是赋值语句
         const assignmentMatch = statementWithoutSemicolon.match(/(.*=\s*)([\s\S]*)/);
+
         if (assignmentMatch) {
             const leftSide = assignmentMatch[1];
             const rightSide = assignmentMatch[2];
 
-            // 分割右侧表达式为各个部分，保留原始的空白和换行
-            // 使用更复杂的正则表达式，避免在括号内分割
             const parts = this.splitExpression(rightSide);
-            const processedParts = [];
+            const processedParts: string[] = [];
 
             for (let i = 0; i < parts.length; i++) {
                 const part = parts[i];
-                
-                // 跳过分隔符（+ 及其周围的空白字符）
+
                 if (i % 2 === 1) {
                     processedParts.push(part);
                     continue;
                 }
-                
+
                 const trimmedPart = part.trim();
-                
-                // 检查是否已经有 .TR() 调用
+
                 if (trimmedPart.endsWith(`.${trMethod}()`)) {
                     processedParts.push(part);
                     continue;
                 }
-                
-                // 检查是否是 Tr.Format 调用
+
                 if (trimmedPart.includes(`${trClass}.${trFormatMethod}(`) || trimmedPart.includes('Tr.Format(')) {
                     processedParts.push(part);
                     continue;
                 }
-                
-                // 检查是否是 Tr.Format 调用的一部分（处理可能的分割情况）
+
                 if (trimmedPart.includes('Tr.') && trimmedPart.includes('(')) {
                     processedParts.push(part);
                     continue;
                 }
-                
-                // 检查是否是 Tr.Format 调用的完整形式
+
                 if (trimmedPart.startsWith(`${trClass}.${trFormatMethod}(`)) {
                     processedParts.push(part);
                     continue;
                 }
-                
-                // 检查是否是字符串模板
+
                 const templateMatch = trimmedPart.match(/(\$@?|@\$)"((?:[^"\\]|\\.)*)"/s);
                 if (templateMatch) {
-                    // 字符串模板已经在 processStringTemplates 中处理过了，跳过
-                    // 直接添加到 processedParts 中
                     processedParts.push(part);
-                    
                 } else if (trimmedPart.startsWith('"')) {
-                    // 处理普通字符串
-                    // 保持原始的空白字符，只在实际内容后添加 .TR()
                     const whitespaceBefore = part.substring(0, part.search(/\S/));
                     const actualPart = part.substring(part.search(/\S/));
                     const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + trimmedPart.length);
                     processedParts.push(whitespaceBefore + trimmedPart + `.${trMethod}()` + whitespaceAfter);
-                    
-                    // 不要在这里添加到 literals，因为 extractPlainStrings 会处理
-                    
                 } else if (trimmedPart && !trimmedPart.match(/^\s*$/) && !trimmedPart.match(/^\d+$/)) {
-                    // 处理变量或表达式，添加 .TR()
-                    // 保持原始的空白字符，只在实际内容后添加 .TR()
                     const whitespaceBefore = part.substring(0, part.search(/\S/));
                     const actualPart = part.substring(part.search(/\S/));
                     const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + trimmedPart.length);
                     processedParts.push(whitespaceBefore + trimmedPart + `.${trMethod}()` + whitespaceAfter);
-                    
                 } else {
-                    // 其他表达式，保持不变
                     processedParts.push(part);
                 }
             }
 
-            // 构建处理后的语句
             let result = leftSide + processedParts.join('');
-            // 加回分号
             if (hasSemicolon) {
                 result += ';';
             }
 
-            // 检查结果是否包含 Tr.Format().TR() 形式的重复修饰
             while (result.includes(`${trClass}.${trFormatMethod}().${trMethod}()`)) {
-                // 移除重复的 .TR()
                 result = result.replace(`${trClass}.${trFormatMethod}().${trMethod}()`, `${trClass}.${trFormatMethod}()`);
             }
 
             return result;
         }
 
-        // 处理非赋值语句的情况
         const parts = this.splitExpression(statementWithoutSemicolon);
-        const processedParts = [];
+        const processedParts: string[] = [];
 
         for (let i = 0; i < parts.length; i++) {
             const part = parts[i];
-            
-            // 跳过分隔符（+ 及其周围的空白字符）
+
             if (i % 2 === 1) {
                 processedParts.push(part);
                 continue;
             }
-            
+
             const trimmedPart = part.trim();
-            
-            // 检查是否已经有 .TR() 调用
+
             if (trimmedPart.endsWith(`.${trMethod}()`)) {
                 processedParts.push(part);
                 continue;
             }
-            
-            // 检查是否包含 Tr.Format 调用
+
             if (trimmedPart.includes(`${trClass}.${trFormatMethod}(`) || trimmedPart.includes('Tr.Format(')) {
                 processedParts.push(part);
                 continue;
             }
-            
-            // 检查是否是字符串模板
+
             const templateMatch = trimmedPart.match(/(\$@?|@\$)"((?:[^"\\]|\\.)*)"/s);
             if (templateMatch) {
-                // 字符串模板已经在 processStringTemplates 中处理过了，跳过
-                // 直接添加到 processedParts 中
                 processedParts.push(part);
-                
             } else if (trimmedPart.startsWith('"')) {
-                // 处理普通字符串
-                // 保持原始的空白字符，只在实际内容后添加 .TR()
                 const whitespaceBefore = part.substring(0, part.search(/\S/));
                 const actualPart = part.substring(part.search(/\S/));
                 const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + trimmedPart.length);
                 processedParts.push(whitespaceBefore + trimmedPart + `.${trMethod}()` + whitespaceAfter);
-                
-                // 不要在这里添加到 literals，因为 extractPlainStrings 会处理
-                
             } else if (trimmedPart && !trimmedPart.match(/^\s*$/) && !trimmedPart.match(/^\d+$/)) {
-                // 检查是否是 Tr.Format 调用
                 if (trimmedPart.includes(`${trClass}.${trFormatMethod}(`)) {
                     processedParts.push(part);
                     continue;
                 }
-                // 处理变量或表达式，添加 .TR()
-                // 保持原始的空白字符，只在实际内容后添加 .TR()
                 const whitespaceBefore = part.substring(0, part.search(/\S/));
                 const actualPart = part.substring(part.search(/\S/));
                 const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + trimmedPart.length);
                 processedParts.push(whitespaceBefore + trimmedPart + `.${trMethod}()` + whitespaceAfter);
-                
             } else {
-                // 其他表达式，保持不变
                 processedParts.push(part);
             }
         }
 
-        // 构建处理后的语句
         let result = processedParts.join('');
-        // 加回分号
         if (hasSemicolon) {
             result += ';';
         }
 
-        // 检查结果是否包含 Tr.Format().TR() 形式的重复修饰
         while (result.includes(`.${trFormatMethod}().${trMethod}()`)) {
-            // 移除重复的 .TR()
             result = result.replace(`.${trFormatMethod}().${trMethod}()`, `.${trFormatMethod}()`);
         }
 
         return result;
     }
 
-    /**
-     * 为表达式添加 .TR() 调用
-     * @param expression 表达式
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     * @param trMethod2 翻译方法名2，用于 .TR() 调用
-     * @returns 处理后的表达式
-     */
     private addTRCalls(expression: string, snippet: CodeSnippet, trClass: string, trMethod: string, trMethod2: string): string {
-        // 分割表达式为各个部分
         const parts = expression.split('+');
         const processedParts = parts.map(part => {
             const trimmedPart = part.trim();
 
-            // 检查是否已经有 .TR() 调用
             if (trimmedPart.endsWith(`.${trMethod2}()`)) {
                 return part;
             }
 
-            // 检查是否是 Tr.Format 调用
             if (trimmedPart.startsWith(`${trClass}.${trMethod}(`)) {
                 return part;
             }
 
-            // 为字符串字面量和表达式添加 .TR()
             if (trimmedPart.startsWith('"') || /^\w+/.test(trimmedPart) || trimmedPart.startsWith('(')) {
                 return part.trim() + `.${trMethod2}()`;
             }
@@ -936,57 +2160,34 @@ export class CSharpStringExtractor {
         return processedParts.join(' + ');
     }
 
-    /**
-     * 提取普通字符串
-     * @param statement C#语句
-     * @param snippet CodeSnippet对象
-     * @param trClass 翻译类名
-     * @param trMethod 翻译方法名
-     */
     private extractPlainStrings(statement: string, snippet: CodeSnippet, trClass: string, trMethod: string): void {
-        // 匹配普通字符串，包括包含转义引号的字符串
         const stringRegex = /"(?:[^"\\]|\\.)*"/g;
         let match;
 
-        // 重置正则表达式的lastIndex
         stringRegex.lastIndex = 0;
 
         while ((match = stringRegex.exec(statement)) !== null) {
             const stringLiteral = match[0];
             const position = match.index;
 
-            // 检查这个字符串是否在Tr.Format调用中
             const beforeMatch = statement.substring(0, position);
-            // 使用字符串方法检查，避免正则表达式转义问题
             const trFormatCall = `${trClass}.${trMethod}(`;
             const trFormatIndex = beforeMatch.lastIndexOf(trFormatCall);
             const closingParenIndex = beforeMatch.lastIndexOf(')');
             const trFormatMatch = trFormatIndex !== -1 && (closingParenIndex === -1 || trFormatIndex > closingParenIndex);
 
-            // 检查这个字符串是否在函数调用中
             const functionCallMatch = beforeMatch.match(/(\w+\.\w+|\w+)\s*\([^)]*$/);
             const inFunctionCall = functionCallMatch !== null;
-            
-            // 检查函数调用的形式
+
             let shouldExtract = true;
-            // 总是提取函数调用中的字符串参数
-            // 无论函数名是否包含点（.）
-            // 这是为了符合测试用例的期望
 
-            // 只有当不在Tr.Format调用中且应该提取时，才添加
             if (!trFormatMatch && shouldExtract) {
-                // 去除引号后添加
                 const literalWithoutQuotes = stringLiteral.substring(1, stringLiteral.length - 1);
                 snippet.addLiteral(position, literalWithoutQuotes);
             }
         }
     }
 
-    /**
-     * 分割表达式，避免在括号内分割
-     * @param expression 表达式字符串
-     * @returns 分割后的部分数组，格式为 [part1, separator1, part2, separator2, ...]
-     */
     private splitExpression(expression: string): string[] {
         const parts: string[] = [];
         let current = '';
@@ -1040,21 +2241,16 @@ export class CSharpStringExtractor {
             }
 
             if (char === '+' && inParentheses === 0) {
-                // 找到一个 + 号且不在括号内，分割
-                // 保存当前部分（包括前面的空格）
                 parts.push(current);
-                
-                // 提取 + 号及其后面的空格
                 let separator = '+';
                 let j = i + 1;
                 while (j < expression.length && expression[j] === ' ') {
                     separator += ' ';
                     j++;
                 }
-                
                 parts.push(separator);
                 current = '';
-                i = j - 1; // 更新 i 的位置
+                i = j - 1;
             } else {
                 current += char;
             }
@@ -1066,4 +2262,387 @@ export class CSharpStringExtractor {
 
         return parts;
     }
+
+    private extractValueExpression(statement: string, statementIndex: number, fullCode: string): { valueExpression: string, valueExpressionIndex: number } {
+        const trimmedStatement = statement.trim();
+
+        const textAssignmentIndex = trimmedStatement.indexOf('.text =');
+        if (textAssignmentIndex !== -1) {
+            const prefix = trimmedStatement.substring(0, textAssignmentIndex + '.text ='.length);
+            const valuePart = trimmedStatement.substring(textAssignmentIndex + '.text ='.length);
+            const value = this.extractValueUntilSemicolon(valuePart);
+            const valueExpression = value.trim();
+
+            const valueStartInStatement = statement.indexOf(value);
+            const valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : textAssignmentIndex + '.text ='.length);
+
+            const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
+            const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
+
+            return {
+                valueExpression: valueExpression,
+                valueExpressionIndex: finalIndex
+            };
+        }
+
+        if (trimmedStatement.startsWith('return ')) {
+            const valuePart = trimmedStatement.substring('return '.length);
+            const value = this.extractValueUntilSemicolon(valuePart);
+            const valueExpression = value.trim();
+
+            let finalIndex = statementIndex;
+            const returnKeywordInStatement = statement.indexOf('return ');
+            if (returnKeywordInStatement !== -1) {
+                const afterReturnInStatement = returnKeywordInStatement + 'return '.length;
+                let startInStatement = -1;
+                
+                for (let i = afterReturnInStatement; i < statement.length - 1; i++) {
+                    if (statement[i] === '$' && statement[i + 1] === '"') {
+                        startInStatement = i;
+                        break;
+                    }
+                }
+                
+                if (startInStatement === -1) {
+                    for (let i = afterReturnInStatement; i < statement.length; i++) {
+                        if (statement[i] === '"') {
+                            startInStatement = i;
+                            break;
+                        }
+                    }
+                }
+                
+                if (startInStatement !== -1) {
+                    finalIndex = statementIndex + startInStatement;
+                }
+            }
+
+            return {
+                valueExpression: valueExpression,
+                valueExpressionIndex: finalIndex
+            };
+        }
+
+        const assignmentIndex = trimmedStatement.indexOf('=');
+        if (assignmentIndex !== -1) {
+            const prefix = trimmedStatement.substring(0, assignmentIndex + 1);
+            const valuePart = trimmedStatement.substring(assignmentIndex + 1);
+            const value = this.extractValueUntilSemicolon(valuePart);
+            const valueExpression = value.trim();
+
+            const valueStartInStatement = statement.indexOf(value);
+            const valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : assignmentIndex + 1);
+
+            const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
+            const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
+
+            return {
+                valueExpression: valueExpression,
+                valueExpressionIndex: finalIndex
+            };
+        }
+
+        const stringFormatMatch = trimmedStatement.match(/^(string\.Format\([\s\S]*?\))(;|$)/);
+        if (stringFormatMatch) {
+            const valueExpression = stringFormatMatch[1].trim();
+            const actualValueStart = fullCode.indexOf(valueExpression, statementIndex);
+            const finalIndex = actualValueStart !== -1 ? actualValueStart : statementIndex;
+
+            return {
+                valueExpression: valueExpression,
+                valueExpressionIndex: finalIndex
+            };
+        }
+
+        let searchStart = 0;
+        let colonIndex = -1;
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+
+        if (trimmedStatement.startsWith('case ') || trimmedStatement.startsWith('default:')) {
+            for (let i = 0; i < trimmedStatement.length; i++) {
+                const char = trimmedStatement[i];
+
+                if (escapeNext) {
+                    escapeNext = false;
+                    continue;
+                }
+
+                if (char === '\\') {
+                    escapeNext = true;
+                    continue;
+                }
+
+                if (inString) {
+                    if (char === stringDelimiter) {
+                        inString = false;
+                        stringDelimiter = '';
+                    }
+                    continue;
+                }
+
+                if (char === '"' || char === "'") {
+                    inString = true;
+                    stringDelimiter = char;
+                    continue;
+                }
+
+                if (char === ':') {
+                    colonIndex = i;
+                    break;
+                }
+            }
+
+            if (colonIndex !== -1) {
+                searchStart = colonIndex + 1;
+            }
+        }
+
+        let lastParenOpenIndex = -1;
+        inString = false;
+        escapeNext = false;
+        stringDelimiter = '';
+
+        for (let i = searchStart; i < trimmedStatement.length; i++) {
+            const char = trimmedStatement[i];
+
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+
+            if (inString) {
+                if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                }
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                inString = true;
+                stringDelimiter = char;
+                continue;
+            }
+
+            if (char === '(') {
+                lastParenOpenIndex = i;
+            }
+        }
+
+        if (lastParenOpenIndex !== -1) {
+            const parenCloseIndex = this.findMatchingParenthesis(trimmedStatement, lastParenOpenIndex);
+            if (parenCloseIndex !== -1) {
+                const args = trimmedStatement.substring(lastParenOpenIndex + 1, parenCloseIndex);
+                const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(args);
+                if (hasStringLiteral) {
+                    const valueExpression = args.trim();
+                    const parenIndex = statement.indexOf(trimmedStatement.substring(lastParenOpenIndex, lastParenOpenIndex + 1));
+                    const valueExpressionIndex = statementIndex + parenIndex + 1;
+                    const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
+                    const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
+
+                    return {
+                        valueExpression: valueExpression,
+                        valueExpressionIndex: finalIndex
+                    };
+                }
+            }
+        }
+
+        return {
+            valueExpression: trimmedStatement,
+            valueExpressionIndex: statementIndex
+        };
+    }
+
+    private extractValueUntilSemicolon(valuePart: string): string {
+        let result = '';
+        let inString = false;
+        let escapeNext = false;
+        let stringDelimiter = '';
+        let parenthesesDepth = 0;
+        let bracketDepth = 0;
+
+        for (let i = 0; i < valuePart.length; i++) {
+            const char = valuePart[i];
+
+            if (escapeNext) {
+                result += char;
+                escapeNext = false;
+                continue;
+            }
+
+            if (char === '\\') {
+                result += char;
+                escapeNext = true;
+                continue;
+            }
+
+            if (inString) {
+                result += char;
+                if (char === stringDelimiter) {
+                    inString = false;
+                    stringDelimiter = '';
+                }
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                result += char;
+                inString = true;
+                stringDelimiter = char;
+                continue;
+            }
+
+            if (char === '(') {
+                result += char;
+                parenthesesDepth++;
+                continue;
+            }
+
+            if (char === ')') {
+                result += char;
+                parenthesesDepth--;
+                continue;
+            }
+
+            if (char === '[') {
+                result += char;
+                bracketDepth++;
+                continue;
+            }
+
+            if (char === ']') {
+                result += char;
+                bracketDepth--;
+                continue;
+            }
+
+            if (char === ';' && parenthesesDepth === 0 && bracketDepth === 0) {
+                break;
+            }
+
+            result += char;
+        }
+
+        return result;
+    }
+
+    private processStatementAndExtractValue(snippet: CodeSnippet, fullStatement: string, valueExpression: string, trClass: string, trFormatMethod: string, trMethod: string): void {
+        let processedFullStatement = fullStatement;
+
+        this.extractTrFormatStrings(processedFullStatement, snippet, trClass, trFormatMethod);
+        processedFullStatement = this.processStringTemplates(processedFullStatement, snippet, trClass, trFormatMethod);
+        processedFullStatement = this.processStringFormat(processedFullStatement, snippet, trClass, trFormatMethod);
+        processedFullStatement = this.processStringConcatenation(processedFullStatement, snippet, trClass, trFormatMethod, trMethod);
+        processedFullStatement = this.processTextAssignments(processedFullStatement, snippet, trClass, trFormatMethod, trMethod);
+        this.extractPlainStrings(processedFullStatement, snippet, trClass, trFormatMethod);
+
+        const regex = new RegExp(`${trClass}\\.${trFormatMethod}\\(([^)]*)\\)\\.${trMethod}\\(\\)`, 'g');
+        processedFullStatement = processedFullStatement.replace(regex, `${trClass}.${trFormatMethod}($1)`);
+        snippet.finalizeLiterals();
+
+        let convertedValueExpression = valueExpression;
+
+        const trimmedFullStatement = fullStatement.trim();
+        const trimmedProcessedStatement = processedFullStatement.trim();
+
+        const isCaseOrDefault = trimmedFullStatement.startsWith('case ') || trimmedFullStatement.startsWith('default:');
+        
+        if (/^return\s/.test(trimmedFullStatement)) {
+            // 检查 processedFullStatement 是否真的被修改过
+            // 如果没有被修改过，直接使用原始 valueExpression 即可
+            if (fullStatement === processedFullStatement) {
+                convertedValueExpression = valueExpression;
+            } else {
+                // 对于 return 语句，我们不需要复杂地使用 extractValueUntilSemicolon 来重新解析！
+                // 我们已经处理完整个语句了，直接截取 return 后面的所有内容，然后去掉末尾的分号即可！
+                let returnIndex = trimmedProcessedStatement.indexOf('return');
+                let valuePart = trimmedProcessedStatement.substring(returnIndex + 'return'.length);
+                valuePart = valuePart.trim();
+                if (valuePart.endsWith(';')) {
+                    valuePart = valuePart.slice(0, -1).trim();
+                }
+                convertedValueExpression = valuePart;
+            }
+        } else {
+            const textAssignmentIndex = trimmedFullStatement.indexOf('.text =');
+            if (textAssignmentIndex !== -1) {
+                if (fullStatement === processedFullStatement) {
+                    convertedValueExpression = valueExpression;
+                } else {
+                    const prefix = trimmedFullStatement.substring(0, textAssignmentIndex + '.text ='.length);
+                    const valuePart = trimmedProcessedStatement.substring(textAssignmentIndex + '.text ='.length);
+                    const value = this.extractValueUntilSemicolon(valuePart);
+                    convertedValueExpression = value.trim();
+                }
+            } else {
+                const assignmentIndex = trimmedFullStatement.indexOf('=');
+                if (assignmentIndex !== -1) {
+                    if (fullStatement === processedFullStatement) {
+                        convertedValueExpression = valueExpression;
+                    } else {
+                        const prefix = trimmedFullStatement.substring(0, assignmentIndex + 1);
+                        const valuePart = trimmedProcessedStatement.substring(assignmentIndex + 1);
+                        const value = this.extractValueUntilSemicolon(valuePart);
+                        convertedValueExpression = value.trim();
+                    }
+                } else if (valueExpression.startsWith('string.Format(')) {
+                    const processedMatch = trimmedProcessedStatement.match(/^(Tr\.Format[\s\S]*?)(;|$)/);
+                    if (processedMatch) {
+                        convertedValueExpression = processedMatch[1].trim();
+                    }
+                } else if (isCaseOrDefault) {
+                    if (fullStatement === processedFullStatement) {
+                        convertedValueExpression = valueExpression;
+                    } else {
+                        const trFormatIndex = trimmedProcessedStatement.indexOf('Tr.Format(');
+                        if (trFormatIndex !== -1) {
+                            const parenOpenIndex = trFormatIndex + 'Tr.Format('.length - 1;
+                            const parenCloseIndex = this.findMatchingParenthesis(trimmedProcessedStatement, parenOpenIndex);
+                            if (parenCloseIndex !== -1) {
+                                convertedValueExpression = trimmedProcessedStatement.substring(trFormatIndex, parenCloseIndex + 1);
+                            } else {
+                                convertedValueExpression = valueExpression;
+                            }
+                        } else {
+                            const parenOpenIndex = trimmedFullStatement.indexOf('(');
+                            if (parenOpenIndex !== -1) {
+                                const parenCloseIndex = this.findMatchingParenthesis(trimmedProcessedStatement, parenOpenIndex);
+                                if (parenCloseIndex !== -1) {
+                                    convertedValueExpression = trimmedProcessedStatement.substring(parenOpenIndex + 1, parenCloseIndex).trim();
+                                } else {
+                                    convertedValueExpression = valueExpression;
+                                }
+                            } else {
+                                convertedValueExpression = valueExpression;
+                            }
+                        }
+                    }
+                } else if (trimmedFullStatement.match(/^[\s\S]*?\(/)) {
+                    const parenOpenIndex = trimmedFullStatement.indexOf('(');
+                    if (parenOpenIndex !== -1) {
+                        const parenCloseIndex = this.findMatchingParenthesis(trimmedProcessedStatement, parenOpenIndex);
+                        if (parenCloseIndex !== -1) {
+                            convertedValueExpression = trimmedProcessedStatement.substring(parenOpenIndex + 1, parenCloseIndex).trim();
+                        }
+                    }
+                } else {
+                    convertedValueExpression = trimmedProcessedStatement;
+                    if (convertedValueExpression.endsWith(';')) {
+                        convertedValueExpression = convertedValueExpression.slice(0, -1).trim();
+                    }
+                }
+            }
+        }
+
+        snippet.convertedCode = convertedValueExpression;
+    }
 }