scancscode 1.0.37 → 1.0.39

package/src/CSharpStringExtractor.ts

@@ -1,9 +1,27 @@
 export class CodeSnippet {
+    /**
+     * 代码片段在原始源代码中的起始位置索引
+     */
     originalIndex: number;
+    /**
+     * 原始上下文，与 originalCode 相同，保存原始的代码片段内容
+     */
     originalContext: string;
+    /**
+     * 从源代码中提取的原始代码片段
+     */
     originalCode: string;
+    /**
+     * 经过国际化处理后的代码片段，可能添加了 .TR() 调用或转换为 Tr.Format(...) 形式
+     */
     convertedCode: string;
+    /**
+     * 从代码片段中提取出的字符串字面量数组，已进行去重和标准化处理
+     */
     literals: string[];
+    /**
+     * 意外情况记录数组
+     */
     unexpects: string[];
     private literalPositions: Map<number, string>;
 
@@ -17,6 +35,10 @@ export class CodeSnippet {
         this.literalPositions = new Map();
     }
 
+    /**
+     * 判断代码片段是否经过修改
+     * @returns 如果 convertedCode 与 originalCode 不同则返回 true，否则返回 false
+     */
     get isChanged(): boolean {
         return this.originalCode !== this.convertedCode;
     }
@@ -85,6 +107,10 @@ export class CodeSnippet {
 }
 
 export class CSharpStringExtractor {
+    private static readonly TEXT_ASSIGNMENT_PATTERN = /\b[\p{L}\p{N}_]+\.text\s*=/u;
+    private static readonly TITLE_ASSIGNMENT_PATTERN = /\bm_btn_[\p{L}_][\p{L}\p{N}_]*\.title\s*=/u;
+    private static readonly SPECIAL_ASSIGNMENT_PATTERN = /(?:\b[\p{L}\p{N}_]+\.text|\bm_btn_[\p{L}_][\p{L}\p{N}_]*\.title)\s*=/u;
+    
     private variableIndex: number = 0;
 
     extractStrings(code: string, snippets: CodeSnippet[] = [], trClass: string = 'Tr', trMethod: string = 'TR', trFormatMethod: string = 'Format'): CodeSnippet[] {
@@ -192,7 +218,7 @@ export class CSharpStringExtractor {
         for (const { statement, originalIndex } of statements) {
             const trimmedStatement = statement.trim();
             const isStringFormatCall = trimmedStatement.startsWith('string.Format(');
-            const isTextAssignment = /\w+\.text\s*=/.test(trimmedStatement);
+            const isTextAssignment = this.isSpecialAssignment(trimmedStatement);
             const isRegularAssignment = /^[\s\S]*?=/.test(trimmedStatement);
             const isCaseOrDefault = trimmedStatement.startsWith('case ') || trimmedStatement.startsWith('default:');
             const isFunctionCall = /^\s*[\w\.<>]+[\s\w\.<>]*\(/.test(trimmedStatement) && !isStringFormatCall && !isCaseOrDefault;
@@ -1572,6 +1598,11 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         return statements;
     }
 
+    private isSpecialAssignment(statement: string): boolean {
+        const trimmedStatement = statement.trim();
+        return CSharpStringExtractor.SPECIAL_ASSIGNMENT_PATTERN.test(trimmedStatement);
+    }
+
     private isStatementToProcess(statement: string): boolean {
         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();
@@ -1595,7 +1626,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         }
 
         const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(trimmedStatement);
-        const isTextAssignment = /\w+\.text\s*=/.test(trimmedStatement);
+        const isTextAssignment = this.isSpecialAssignment(trimmedStatement);
         const isReturnStatement = trimmedStatement.startsWith('return ');
 
         return hasStringLiteral || isTextAssignment || (isReturnStatement && hasStringLiteral);
@@ -1921,8 +1952,8 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
     }
 
     private processTextAssignments(statement: string, snippet: CodeSnippet, trClass: string, trFormatMethod: string, trMethod: string): string {
-        const textAssignmentRegex = /([\s\S]*?\.text\s*=\s*)([\s\S]*?)(?=;|$)/;
-        const match = textAssignmentRegex.exec(statement);
+        const specialAssignmentRegex = /([\s\S]*?(?:\.text|\.title)\s*=\s*)([\s\S]*?)(?=;|$)/;
+        const match = specialAssignmentRegex.exec(statement);
 
         let prefix: string | null = null;
         let value: string;
@@ -1971,7 +2002,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
                     return part;
                 }
 
-                if (trimmedPart.startsWith('"') || /^\w+/.test(trimmedPart) || trimmedPart.startsWith('(')) {
+                if (trimmedPart.startsWith('"') || trimmedPart.startsWith('$"') || trimmedPart.startsWith('$@"') || trimmedPart.startsWith('@$"') || /^\w+/.test(trimmedPart) || trimmedPart.startsWith('(')) {
                     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);
@@ -1984,7 +2015,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         } else {
             const trimmedValue = value.trim();
             if (!trimmedValue.includes(`${trClass}.${trFormatMethod}(`) && !trimmedValue.endsWith(`.${trMethod}()`)) {
-                if (trimmedValue !== 'null' && (trimmedValue.startsWith('"') || /^\w+/.test(trimmedValue) || trimmedValue.startsWith('('))) {
+                if (trimmedValue !== 'null' && (trimmedValue.startsWith('"') || trimmedValue.startsWith('$"') || trimmedValue.startsWith('$@"') || trimmedValue.startsWith('@$"') || /^\w+/.test(trimmedValue) || trimmedValue.startsWith('('))) {
                     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);
@@ -2011,7 +2042,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         }
 
         const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(statement);
-        const isTextAssignment = /\w+\.text\s*=/.test(statement);
+        const isTextAssignment = this.isSpecialAssignment(statement);
 
         if (isTextAssignment) {
             return statement;
@@ -2374,15 +2405,29 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
     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);
+        let assignmentMatch: RegExpExecArray | null = null;
+        let assignmentSuffix = '';
+        
+        const textMatch = CSharpStringExtractor.TEXT_ASSIGNMENT_PATTERN.exec(trimmedStatement);
+        const titleMatch = CSharpStringExtractor.TITLE_ASSIGNMENT_PATTERN.exec(trimmedStatement);
+        
+        if (textMatch) {
+            assignmentMatch = textMatch;
+            assignmentSuffix = '.text =';
+        } else if (titleMatch) {
+            assignmentMatch = titleMatch;
+            assignmentSuffix = '.title =';
+        }
+
+        if (assignmentMatch) {
+            const assignmentIndex = assignmentMatch.index + assignmentMatch[0].indexOf(assignmentSuffix);
+            const prefix = trimmedStatement.substring(0, assignmentIndex + assignmentSuffix.length);
+            const valuePart = trimmedStatement.substring(assignmentIndex + assignmentSuffix.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 valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : assignmentIndex + assignmentSuffix.length);
 
             const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
             const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
@@ -2398,32 +2443,11 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
             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;
-                }
-            }
+            const valueStartInStatement = statement.indexOf(value);
+            const valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : 'return '.length);
+
+            const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
+            const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
 
             return {
                 valueExpression: valueExpression,
@@ -2731,7 +2755,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
 
     private processStatementAndExtractValue(snippet: CodeSnippet, fullStatement: string, valueExpression: string, trClass: string, trFormatMethod: string, trMethod: string): void {
         let processedValueExpression = valueExpression;
-        const isTextAssignment = /\w+\.text\s*=/.test(fullStatement.trim());
+        const isTextAssignment = this.isSpecialAssignment(fullStatement);
 
         this.extractTrFormatStrings(processedValueExpression, snippet, trClass, trFormatMethod);
         processedValueExpression = this.processStringTemplates(processedValueExpression, snippet, trClass, trFormatMethod);

package/src/CmdExecutor.ts

@@ -10,13 +10,12 @@ export class CmdExecutor {
     static testConvert() {
         let cwd = "E:/DATA/Projects/ZhiYou/ProjectFClient/GameClient/"
         let cscodeFolders =
-            // [cwd + "Assets/Bundles/FGUI/"]
-
-        [
-        "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/UI/",
-         "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/Battle/",
-         "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Scripts/",
-        ]
+            [
+                cwd + "Assets/Bundles/FGUI/",
+                // "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/UI/",
+                // "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/Battle/",
+                // "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Scripts/",
+            ]
 
         let gameConfigFolders = [cwd + "Assets/Bundles/GameConfigs/"]
         let outCsvFile = "E:/DATA/Projects/e-gbl-client/client/Assets/Bundles/GameConfigs/Translation/hello.csv"

package/test/CSharpStringExtractor.test.ts

@@ -93,6 +93,74 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].literals).toContain('sub');
     });
 
+    // 形如 `m_btn_xxx.title = yyy;` 的赋值语句要和形如 `xxx.text = yyy;` 的赋值语句完全等同处理, 其中 `xxx`和`yyy` 代表某段C#字面量, 可以是对象、字符串、或其他表达式, `m_btn_` 为引用符号名固定前缀; 为了便于理解, 用正则表达式表示, 也就是相当于需要同时匹配 `/^m_btn_\w+\.title\s*=/` 形式的表达式和 `/\w+\.text\s*=/` 形式的表达式, 而其中对于 `xxx` 和 `yyy` 部分的处理逻辑是完全一致的
+    test('should handle m_btn_xxx.title = yyy', () => {
+        const code = `
+        buy.title = "lkwjelkfj1";
+        m_btn1_buy.title = "lkwjelkfj2";
+        am_btn_buy.title = "lkwjelkfj3";
+        m_btn_buy.title = "lkwjelkfj4";
+        m_btn_wwefHwref.title = $"Hello";
+        m_btn_fxx_wf.title = $"Hello, {name}!";
+`;
+        const snippets = extractor.extractStrings(code);
+        {
+            let snippet = snippets[0];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj1"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj1"');
+            // `buy` 不符合 `m_btn_` 开头的条件, 不需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj1"');
+            expect(snippet.literals).toContain('lkwjelkfj1');
+            expect(snippet.isChanged).toBe(false);
+        }
+        {
+            let snippet = snippets[1];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj2"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj2"');
+            // `m_btn1_buy` 不符合 `m_btn_` 开头的条件, 不需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj2"');
+            expect(snippet.literals).toContain('lkwjelkfj2');
+            expect(snippet.isChanged).toBe(false);
+        }
+        {
+            let snippet = snippets[2];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj3"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj3"');
+            // `am_btn_buy` 不符合 `m_btn_` 开头的条件, 不需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj3"');
+            expect(snippet.literals).toContain('lkwjelkfj3');
+            expect(snippet.isChanged).toBe(false);
+        }
+        {
+            let snippet = snippets[3];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj4"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj4"');
+            // `m_btn_buy` 符合 `m_btn_` 开头的条件, 需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj4".TR()');
+            expect(snippet.literals).toContain('lkwjelkfj4');
+            expect(snippet.isChanged).toBe(true);
+        }
+        {
+            let snippet = snippets[4];
+            expect(snippet.originalIndex).toBe(code.indexOf('$"Hello"'));
+            expect(snippet.originalCode).toBe('$"Hello"');
+            // `m_btn_wwefHwref` 符合 `m_btn_` 开头的条件, 需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('$"Hello".TR()');
+            expect(snippet.literals).toContain('Hello');
+            expect(snippet.isChanged).toBe(true);
+        }
+        {
+            let snippet = snippets[5];
+            expect(snippet.originalIndex).toBe(code.indexOf('$"Hello, {name}!"'));
+            expect(snippet.originalCode).toBe('$"Hello, {name}!"');
+            // `m_btn_fxx_wf` 符合 `m_btn_` 开头的条件
+            expect(snippet.convertedCode).toBe('Tr.Format("Hello, {0}!", name)');
+            expect(snippet.literals).toContain('Hello, {0}!');
+            expect(snippet.isChanged).toBe(true);
+        }
+        expect(snippets.length).toBe(6);
+    });
+
     // 测试用 `+` 连接的字符串表达式, 确保用 `+` 符号拼接的字符串表达式被整体处理, 从中提取字符串表达式信息, 而不是分别处理 `+` 两边每个字符串表达式; 并且给 `+` 连接的每个成分追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式
     test('should handle string concatenation', () => {
         const code = 'var label2 = "Hello, " + name + "!";';
@@ -103,7 +171,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].convertedCode).toBe('"Hello, ".TR() + name.TR() + "!".TR()');
     });
 
-    // 测试 `xxx.text = yyy` 形式的赋值语句, 确保将 `yyy` 中的字符串表达式信息提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#字面量, 可以是对象、字符串、或其他表达式
+    // 测试 `xxx.text = yyy;` 形式的赋值语句, 确保将 `yyy` 中的字符串表达式信息提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#字面量, 可以是对象、字符串、或其他表达式
     test('should handle .text = assignments with function calls', () => {
         const code = 'label.text = Func();';
         const snippets = extractor.extractStrings(code);
@@ -113,7 +181,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].convertedCode).toBe('Func().TR()');
     });
 
-    // 测试 `xxx.text = xxx + xxx` 形式的赋值语句, 确保将 `xxx.text` 中的 `xxx` 字符串表达式提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
+    // 测试 `xxx.text = xxx + xxx;` 形式的赋值语句, 确保将 `xxx.text` 中的 `xxx` 字符串表达式提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
     test('should handle .text = assignments with multiple function calls', () => {
         const code = 'label.text = Func() + Func();';
         const snippets = extractor.extractStrings(code);
@@ -123,7 +191,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].convertedCode).toBe('Func().TR() + Func().TR()');
     });
 
-    // 测试 `xxx.text = yyy` 形式的赋值语句, 确保将 `yyy` 中的 `xxx` 内插字符串提取出来, 并转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
+    // 测试 `xxx.text = yyy;` 形式的赋值语句, 确保将 `yyy` 中的 `xxx` 内插字符串提取出来, 并转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
     test('should handle .text = assignments with string templates', () => {
         const code = 'label.text = $"pre{Func()}sub";';
         const snippets = extractor.extractStrings(code);
@@ -215,7 +283,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippet.isChanged).toBe(true);
     });
 
-    // 测试处理 `xxx.text = yyy` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式, 需要从 `yyy` 中正确提取字符串表达式信息, 并给普通字符串表达式追加 `.TR()` 或者让内插字符串转换为 `Tr.Format(...)` 形式
+    // 测试处理 `xxx.text = yyy;` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式, 需要从 `yyy` 中正确提取字符串表达式信息, 并给普通字符串表达式追加 `.TR()` 或者让内插字符串转换为 `Tr.Format(...)` 形式
     test('should handle .text = assignments', () => {
         const code = 'label.text = "Test";';
         const snippets = extractor.extractStrings(code);
@@ -329,9 +397,9 @@ describe('CSharpStringExtractor', () => {
 
         const snippet = snippets[0];
         expect(snippet.originalCode).toBe('$"[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]"');
-        expect(snippet.convertedCode).toBe('$"[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]"');
+        expect(snippet.convertedCode).toBe('$"[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]".TR()');
         expect(snippet.literals).toEqual(['[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]']);
-        expect(snippet.isChanged).toBe(false);
+        expect(snippet.isChanged).toBe(true);
     });
 
     // 处理C#多行语句
@@ -1967,7 +2035,7 @@ namespace TestNamespace{
         }
     });
     // 正确识别C# 行注释语句边界, 行注释不能影响上下行的字符串提取
-    test('should handle comment boundary 2', () => {
+    test('should handle comment boundary 3', () => {
         const code = `
 // klwjfe
 namespace TestNamespace{
@@ -2166,7 +2234,7 @@ namespace FaBao.UI.Comp
     });
 
     // 正确提取C#方法参数中的字符串表达式信息, 支持1到多个形参有默认值的情形
-    test('should handle string expression in method call parameter 3', () => {
+    test('should handle string expression in method call parameter 4', () => {
         const code = `
 namespace FaBao.UI.Comp
 {
@@ -2393,7 +2461,7 @@ namespace FaBao.UI.MainUI
     });
 
     // 需要正确识别C#代码中的匿名函数, 匿名函数中的字符串表达式也同样需要提取; 匿名函数通常以 `0到多个修饰词 (可选参数列表) => { ... }` 或者 `0到多个修饰词 (可选参数列表) => 一句表达式` 形式定义实现.
-    test('should handle class member initialization assignment with anonymous function 2', () => {
+    test('should handle class member initialization assignment with anonymous function 3', () => {
         const code = `
                 FUISys.Instance.ShowLayer<MainConfirmDialog>(UISceneType.Main, new MainConfirmDialog.MainConfirmDialogParam()
                 {
@@ -2418,7 +2486,7 @@ namespace FaBao.UI.MainUI
     });
 
     // 需要正确识别C#代码中的匿名函数, 匿名函数中的字符串表达式也同样需要提取; 匿名函数通常以 `0到多个修饰词 (可选参数列表) => { ... }` 或者 `0到多个修饰词 (可选参数列表) => 一句表达式` 形式定义实现.
-    test('should handle class member initialization assignment with anonymous function 3', () => {
+    test('should handle class member initialization assignment with anonymous function 4', () => {
         const code = `
                 FUISys.Instance.ShowLayer<MainConfirmDialog>(UISceneType.Main, new MainConfirmDialog.MainConfirmDialogParam()
                 {
@@ -2440,7 +2508,7 @@ namespace FaBao.UI.MainUI
     });
 
     // 需要正确识别C#代码中的匿名函数, 匿名函数中的字符串表达式也同样需要提取; 匿名函数通常以 `0到多个修饰词 (可选参数列表) => { ... }` 或者 `0到多个修饰词 (可选参数列表) => 一句表达式` 形式定义实现.
-    test('should handle class member initialization assignment with anonymous function 4', () => {
+    test('should handle class member initialization assignment with anonymous function 5', () => {
         const code = `
                 FUISys.Instance.ShowLayer<MainConfirmDialog>(UISceneType.Main, new MainConfirmDialog.MainConfirmDialogParam()
                 {
@@ -2461,7 +2529,7 @@ namespace FaBao.UI.MainUI
         }
     });
 
-    // 测试处理 `xxx.text = yyy` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
+    // 测试处理 `xxx.text = yyy;` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
     test('should handle .text = format 1', () => {
         const code = `m_text_iwff.text = info ;`;
         const snippets = extractor.extractStrings(code);
@@ -2476,8 +2544,8 @@ namespace FaBao.UI.MainUI
         }
     });
 
-    // 测试处理 `xxx.text = yyy` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
-    test('should handle .text = format 1', () => {
+    // 测试处理 `xxx.text = yyy;` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
+    test('should handle .text = format 2', () => {
         const code = `m_text_info.text = info1.member1 + info2.member2;`;
         const snippets = extractor.extractStrings(code);
         {
@@ -2559,7 +2627,7 @@ namespace FaBao.UI.MainUI
     });
 
     // 支持处理字符串里出现各种特殊符号的情况
-    test('should handle special characters in string 8', () => {
+    test('should handle special characters in string 9', () => {
         const code = `
                 (GetChild($"m_textAnime{GetNextNumber()}") as TurtleTextAnimeComp)?.SetText(word);
 `;
@@ -2578,7 +2646,7 @@ namespace FaBao.UI.MainUI
     });
 
     // 支持处理字符串里出现各种特殊符号的情况
-    test('should handle special characters in string 9', () => {
+    test('should handle special characters in string 10', () => {
         const code = `
                 (GetChild($"m_textAnime{GetNextNumber()}") as TurtleTextAnimeComp)?.SetText(word);
 `;
@@ -2676,4 +2744,62 @@ namespace FaBao.UI.MainUI
         expect(snippets.length).toBe(0);
     });
 
+    // 需要正确获取 `originalIndex`, `originalIndex` 的定义为 `originalIndex=code.indexOf(originalCode)`, 其中 `code` 表示原始代码, `originalCode` 表示匹配出的原始代码中的字符串表达式
+    test('should handle calculate originalIndex', () => {
+        const code = `
+namespace FaBao
+{
+    public partial class UserInfoModel
+    {
+        public bool HasJoinedGuild()
+        {
+            return !string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0";
+        }
+
+        public void UpdateBargain(BargainShopData bargainShopData)
+        {
+            MyGuildInfo.IsBargainShopBargain = true;
+        }
+
+    }
+}
+`;
+        const snippets = extractor.extractStrings(code);
+        {
+            let targetSnippet = snippets[0];
+            expect(targetSnippet.originalCode).toBe(`!string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0"`);
+            expect(targetSnippet.originalIndex).toBe(code.indexOf(`!string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0"`));
+            expect(targetSnippet.convertedCode).toBe(`!string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0"`);
+            expect(targetSnippet.literals).toEqual([
+                '0'
+            ]);
+            expect(targetSnippet.isChanged).toBe(false);
+        }
+    });
+
+    // 测试 `xxx.text = yyy;` 和 `m_btn_xxx.title = yyy;` 形式的赋值语句都需要支持中文， 包括字符串表达式中也要支持包含中文的情况
+    test('should handle .text = assignments contains chinese', () => {
+        const code = `
+        为栓饭cxs12.text = 南方eflkj.d文件 + "完善ew";
+        m_btn_为栓饭cxs12.title = bw尅kljekl.完善 + "栏栏nfc";
+`;
+        const snippets = extractor.extractStrings(code);
+        {
+            let snippet = snippets[0];
+            expect(snippet.originalCode).toBe('南方eflkj.d文件 + "完善ew"');
+            expect(snippet.convertedCode).toBe('南方eflkj.d文件.TR() + "完善ew".TR()');
+            expect(snippet.literals).toEqual([
+                '完善ew'
+            ]);
+        }
+        {
+            let snippet = snippets[1];
+            expect(snippet.originalCode).toBe('bw尅kljekl.完善 + "栏栏nfc"');
+            expect(snippet.convertedCode).toBe('bw尅kljekl.完善.TR() + "栏栏nfc".TR()');
+            expect(snippet.literals).toEqual([
+                '栏栏nfc'
+            ]);
+        }
+    });
+
 });

package/test/TestConvert.test.ts

@@ -2,7 +2,7 @@ import { CmdExecutor } from "../src/CmdExecutor";
 
 describe('TestCmdExecutor', () => {
     test("test convert", async () => {
-        await CmdExecutor.testConvert();
+        // await CmdExecutor.testConvert();
         expect(true).toBe(true);
     }, 50000);
 });