scancscode 1.0.35 → 1.0.36

package/src/CSharpStringExtractor.ts

@@ -193,9 +193,16 @@ export class CSharpStringExtractor {
             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 isRegularAssignment = /^[\s\S]*?=/.test(trimmedStatement);
             const isCaseOrDefault = trimmedStatement.startsWith('case ') || trimmedStatement.startsWith('default:');
             const isFunctionCall = /^\s*[\w\.<>]+[\s\w\.<>]*\(/.test(trimmedStatement) && !isStringFormatCall && !isCaseOrDefault;
+            
+            if ((isRegularAssignment && !isTextAssignment) && !isFunctionCall) {
+                const assignmentIndex = statement.indexOf('=');
+                if (assignmentIndex !== -1) {
+                    this.processAllFunctionCallsInRange(originalIndex, originalIndex + assignmentIndex, code, snippets, trClass, trFormatMethod, trMethod);
+                }
+            }
 
             if (isFunctionCall && !isStringFormatCall) {
                 this.processFunctionCallArguments(statement, originalIndex, code, snippets, trClass, trFormatMethod, trMethod);
@@ -203,6 +210,8 @@ export class CSharpStringExtractor {
                 const extractionResult = this.extractValueExpression(statement, originalIndex, code);
                 const { valueExpression, valueExpressionIndex } = extractionResult;
 
+                const hasStringInValue = /"(?:[^"\\]|\\.)*"|'[^']*'|\$"[\s\S]*?"|\$@"[\s\S]*?"|@\$"[\s\S]*?"/.test(valueExpression);
+
                 let alreadyExists = false;
                 for (const snippet of snippets) {
                     if (snippet.originalIndex === valueExpressionIndex) {
@@ -211,7 +220,7 @@ export class CSharpStringExtractor {
                     }
                 }
                 
-                if (!alreadyExists) {
+                if (!alreadyExists && (hasStringInValue || isTextAssignment)) {
                     const snippet = new CodeSnippet();
                     snippet.originalIndex = valueExpressionIndex;
                     snippet.originalCode = valueExpression;
@@ -219,7 +228,11 @@ export class CSharpStringExtractor {
 
                     this.variableIndex = 0;
 
-                    this.processStatementAndExtractValue(snippet, statement, valueExpression, trClass, trFormatMethod, trMethod);
+                    if (isCaseOrDefault) {
+                        this.processSingleArgument(snippet, valueExpression, trClass, trFormatMethod, trMethod);
+                    } else {
+                        this.processStatementAndExtractValue(snippet, statement, valueExpression, trClass, trFormatMethod, trMethod);
+                    }
 
                     snippets.push(snippet);
                 }
@@ -265,6 +278,8 @@ export class CSharpStringExtractor {
             let inClassBody = true;
             let inComment = false;
             let commentType = '';
+            let isInterpolatedString = false;
+            let interpolatedBraceDepth = 0;
 
             for (j = braceOpenIndex + 1; j < code.length; j++) {
                 const char = code[j];
@@ -316,9 +331,11 @@ export class CSharpStringExtractor {
                 }
 
                 if (inString) {
-                    if (char === stringDelimiter) {
+                    if (char === stringDelimiter && (!isInterpolatedString || interpolatedBraceDepth === 0)) {
                         inString = false;
                         stringDelimiter = '';
+                        isInterpolatedString = false;
+                        interpolatedBraceDepth = 0;
 
                         if (afterEqual && braceDepth === 1) {
                             const stringLiteral = code.substring(stringStartPos, j + 1);
@@ -344,6 +361,12 @@ export class CSharpStringExtractor {
                                 snippets.push(snippet);
                             }
                         }
+                    } else if (isInterpolatedString) {
+                        if (char === '{' && !escapeNext) {
+                            interpolatedBraceDepth++;
+                        } else if (char === '}' && !escapeNext && interpolatedBraceDepth > 0) {
+                            interpolatedBraceDepth--;
+                        }
                     }
                     continue;
                 }
@@ -351,12 +374,14 @@ export class CSharpStringExtractor {
                 if (!inString && afterEqual && braceDepth === 1 && j + 1 < code.length && char === '$') {
                     if (code[j + 1] === '"') {
                         inString = true;
+                        isInterpolatedString = true;
                         stringDelimiter = '"';
                         stringStartPos = j;
                         j++;
                         continue;
                     } else if (code[j + 1] === '@' && j + 2 < code.length && code[j + 2] === '"') {
                         inString = true;
+                        isInterpolatedString = true;
                         stringDelimiter = '"';
                         stringStartPos = j;
                         j += 2;
@@ -364,13 +389,15 @@ export class CSharpStringExtractor {
                     }
                 } else if (!inString && afterEqual && braceDepth === 1 && j + 1 < code.length && char === '@' && code[j + 1] === '$' && j + 2 < code.length && code[j + 2] === '"') {
                     inString = true;
+                    isInterpolatedString = true;
                     stringDelimiter = '"';
                     stringStartPos = j;
                     j += 2;
                     continue;
-                } else if (!inString && (char === '"' || char === "'")) {
+                } else if (!inString && char === '"') {
                     if (afterEqual && braceDepth === 1) {
                         inString = true;
+                        isInterpolatedString = false;
                         stringDelimiter = char;
                         stringStartPos = j;
                     }
@@ -445,6 +472,8 @@ export class CSharpStringExtractor {
             let commentType = '';
             let inAnonymousFunction = false;
             let anonymousFunctionBraceDepth = 0;
+            let isInterpolatedString = false;
+            let interpolatedBraceDepth = 0;
 
             for (j = braceOpenIndex + 1; j < code.length; j++) {
                 const char = code[j];
@@ -503,9 +532,11 @@ export class CSharpStringExtractor {
                 }
 
                 if (inString) {
-                    if (char === stringDelimiter) {
+                    if (char === stringDelimiter && (!isInterpolatedString || interpolatedBraceDepth === 0)) {
                         inString = false;
                         stringDelimiter = '';
+                        isInterpolatedString = false;
+                        interpolatedBraceDepth = 0;
                         
                         if (afterEqual || inAnonymousFunction) {
                             const stringLiteral = code.substring(stringStartPos, j + 1);
@@ -531,6 +562,12 @@ export class CSharpStringExtractor {
                                 snippets.push(snippet);
                             }
                         }
+                    } else if (isInterpolatedString) {
+                        if (char === '{' && !escapeNext) {
+                            interpolatedBraceDepth++;
+                        } else if (char === '}' && !escapeNext && interpolatedBraceDepth > 0) {
+                            interpolatedBraceDepth--;
+                        }
                     }
                     continue;
                 }
@@ -538,12 +575,14 @@ export class CSharpStringExtractor {
                 if (!inString && (afterEqual || inAnonymousFunction) && j + 1 < code.length && char === '$') {
                     if (code[j + 1] === '"') {
                         inString = true;
+                        isInterpolatedString = true;
                         stringDelimiter = '"';
                         stringStartPos = j;
                         j++;
                         continue;
                     } else if (code[j + 1] === '@' && j + 2 < code.length && code[j + 2] === '"') {
                         inString = true;
+                        isInterpolatedString = true;
                         stringDelimiter = '"';
                         stringStartPos = j;
                         j += 2;
@@ -551,13 +590,15 @@ export class CSharpStringExtractor {
                     }
                 } else if (!inString && (afterEqual || inAnonymousFunction) && j + 1 < code.length && char === '@' && code[j + 1] === '$' && j + 2 < code.length && code[j + 2] === '"') {
                     inString = true;
+                    isInterpolatedString = true;
                     stringDelimiter = '"';
                     stringStartPos = j;
                     j += 2;
                     continue;
-                } else if (!inString && (char === '"' || char === "'")) {
+                } else if (!inString && char === '"') {
                     if (afterEqual || inAnonymousFunction) {
                         inString = true;
+                        isInterpolatedString = false;
                         stringDelimiter = char;
                         stringStartPos = j;
                     }
@@ -611,12 +652,10 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
             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;
                 }
@@ -630,7 +669,6 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
             }
 
             if (isDocComment) {
-                // 对于文档注释，我们只需要跳过，不处理任何内容！
                 while (i < code.length && inComment) {
                     const char = code[i];
                     if (char === '\n') {
@@ -647,10 +685,12 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
             let stringDelimiter = '';
             let stringStartPos = -1;
             let interpolatedBraceDepth = 0;
+            let isInterpolatedString = false;
 
             while (i < code.length && inComment) {
                 const char = code[i];
                 const nextChar = i + 1 < code.length ? code[i + 1] : '';
+                const nextNextChar = i + 2 < code.length ? code[i + 2] : '';
 
                 if (commentType === '//') {
                     if (char === '\n') {
@@ -678,9 +718,11 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                 }
 
                 if (inString) {
-                    if (char === stringDelimiter) {
+                    if (char === stringDelimiter && (!isInterpolatedString || interpolatedBraceDepth === 0)) {
                         inString = false;
                         stringDelimiter = '';
+                        isInterpolatedString = false;
+                        interpolatedBraceDepth = 0;
 
                         let alreadyExists = false;
                         for (const snippet of snippets) {
@@ -703,6 +745,12 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
 
                             snippets.push(snippet);
                         }
+                    } else if (isInterpolatedString) {
+                        if (char === '{' && !escapeNext) {
+                            interpolatedBraceDepth++;
+                        } else if (char === '}' && !escapeNext && interpolatedBraceDepth > 0) {
+                            interpolatedBraceDepth--;
+                        }
                     }
                     i++;
                     continue;
@@ -711,12 +759,14 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                 if (!inString && i + 1 < code.length && char === '$') {
                     if (code[i + 1] === '"') {
                         inString = true;
+                        isInterpolatedString = true;
                         stringDelimiter = '"';
                         stringStartPos = i;
                         i += 2;
                         continue;
                     } else if (code[i + 1] === '@' && i + 2 < code.length && code[i + 2] === '"') {
                         inString = true;
+                        isInterpolatedString = true;
                         stringDelimiter = '"';
                         stringStartPos = i;
                         i += 3;
@@ -724,12 +774,14 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                     }
                 } else if (!inString && i + 1 < code.length && char === '@' && code[i + 1] === '$' && i + 2 < code.length && code[i + 2] === '"') {
                     inString = true;
+                    isInterpolatedString = true;
                     stringDelimiter = '"';
                     stringStartPos = i;
                     i += 3;
                     continue;
-                } else if (!inString && (char === '"' || char === "'")) {
+                } else if (!inString && char === '"') {
                     inString = true;
+                    isInterpolatedString = false;
                     stringDelimiter = char;
                     stringStartPos = i;
                     i++;
@@ -1872,12 +1924,15 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         const textAssignmentRegex = /([\s\S]*?\.text\s*=\s*)([\s\S]*?)(?=;|$)/;
         const match = textAssignmentRegex.exec(statement);
 
-        if (!match) {
-            return statement;
-        }
+        let prefix: string | null = null;
+        let value: string;
 
-        const prefix = match[1];
-        const value = match[2];
+        if (match) {
+            prefix = match[1];
+            value = match[2];
+        } else {
+            value = statement;
+        }
 
         let processedValue = value;
 
@@ -1929,7 +1984,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         } else {
             const trimmedValue = value.trim();
             if (!trimmedValue.includes(`${trClass}.${trFormatMethod}(`) && !trimmedValue.endsWith(`.${trMethod}()`)) {
-                if (trimmedValue.startsWith('"') || /^\w+/.test(trimmedValue) || trimmedValue.startsWith('(')) {
+                if (trimmedValue !== 'null' && (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);
@@ -1938,13 +1993,16 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
             }
         }
 
-        if (processedValue !== value) {
-            const hasSemicolon = statement.trim().endsWith(';');
-            const result = prefix + processedValue;
-            return hasSemicolon ? result + ';' : result;
+        if (prefix) {
+            if (processedValue !== value) {
+                const hasSemicolon = statement.trim().endsWith(';');
+                const result = prefix + processedValue;
+                return hasSemicolon ? result + ';' : result;
+            }
+            return statement;
+        } else {
+            return processedValue;
         }
-
-        return statement;
     }
 
     private processStringConcatenation(statement: string, snippet: CodeSnippet, trClass: string, trFormatMethod: string, trMethod: string): string {
@@ -2011,12 +2069,62 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
         const hasSemicolon = statement.endsWith(';');
         let statementWithoutSemicolon = hasSemicolon ? statement.slice(0, -1) : statement;
 
-        const assignmentMatch = statementWithoutSemicolon.match(/(.*=\s*)([\s\S]*)/);
+        // Find actual assignment operator = that's not inside string, parentheses, etc.
+        let assignmentIndex = -1;
+        let tempInString = false;
+        let tempEscapeNext = false;
+        let tempStringDelimiter = '';
+        let parenDepth = 0;
+        let braceDepth = 0;
+        let bracketDepth = 0;
+        for (let i = 0; i < statementWithoutSemicolon.length; i++) {
+            const char = statementWithoutSemicolon[i];
+            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 === '(') {
+                parenDepth++;
+            } else if (char === ')') {
+                parenDepth--;
+            } else if (char === '{') {
+                braceDepth++;
+            } else if (char === '}') {
+                braceDepth--;
+            } else if (char === '[') {
+                bracketDepth++;
+            } else if (char === ']') {
+                bracketDepth--;
+            } else if (char === '=' && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+                assignmentIndex = i;
+                break;
+            }
+        }
 
-        if (assignmentMatch) {
-            const leftSide = assignmentMatch[1];
-            const rightSide = assignmentMatch[2];
+        let leftSide = '';
+        let rightSide = '';
+        if (assignmentIndex !== -1) {
+            leftSide = statementWithoutSemicolon.substring(0, assignmentIndex + 1); // Include =
+            rightSide = statementWithoutSemicolon.substring(assignmentIndex + 1);
+        }
 
+        if (assignmentIndex !== -1) {
             const parts = this.splitExpression(rightSide);
             const processedParts: string[] = [];
 
@@ -2058,7 +2166,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
                     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 if (trimmedPart && !trimmedPart.match(/^\s*$/) && !trimmedPart.match(/^\d+$/)) {
+                } else if (trimmedPart !== 'null' && trimmedPart && !trimmedPart.match(/^\s*$/) && !trimmedPart.match(/^\d+$/)) {
                     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);
@@ -2111,7 +2219,7 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
                 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 if (trimmedPart && !trimmedPart.match(/^\s*$/) && !trimmedPart.match(/^\d+$/)) {
+            } else if (trimmedPart !== 'null' && trimmedPart && !trimmedPart.match(/^\s*$/) && !trimmedPart.match(/^\d+$/)) {
                 if (trimmedPart.includes(`${trClass}.${trFormatMethod}(`)) {
                     processedParts.push(part);
                     continue;
@@ -2456,6 +2564,92 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
             }
         }
 
+        let startInStatement = -1;
+        
+        for (let i = 0; i < statement.length - 1; i++) {
+            const char = statement[i];
+            const nextChar = i + 1 < statement.length ? statement[i + 1] : '';
+            const nextNextChar = i + 2 < statement.length ? statement[i + 2] : '';
+            
+            if ((char === '$' && nextChar === '"') ||
+                (char === '$' && nextChar === '@' && nextNextChar === '"') ||
+                (char === '@' && nextChar === '$' && nextNextChar === '"')) {
+                startInStatement = i;
+                break;
+            }
+        }
+        
+        if (startInStatement === -1) {
+            for (let i = 0; i < statement.length; i++) {
+                if (statement[i] === '"' || statement[i] === "'") {
+                    startInStatement = i;
+                    break;
+                }
+            }
+        }
+        
+        if (startInStatement !== -1) {
+            const finalIndex = statementIndex + startInStatement;
+            
+            let stringEnd = startInStatement;
+            let inString = false;
+            let escapeNext = false;
+            let stringDelimiter = '';
+            let interpolatedBraceDepth = 0;
+            
+            let j = startInStatement;
+            const char = statement[j];
+            const nextChar = j + 1 < statement.length ? statement[j + 1] : '';
+            const nextNextChar = j + 2 < statement.length ? statement[j + 2] : '';
+            
+            if ((char === '$' && nextChar === '"')) {
+                inString = true;
+                stringDelimiter = '"';
+                j += 2;
+            } else if (char === '$' && nextChar === '@' && nextNextChar === '"') {
+                inString = true;
+                stringDelimiter = '"';
+                j += 3;
+            } else if (char === '@' && nextChar === '$' && nextNextChar === '"') {
+                inString = true;
+                stringDelimiter = '"';
+                j += 3;
+            } else if (char === '"' || char === "'") {
+                inString = true;
+                stringDelimiter = char;
+                j++;
+            }
+            
+            while (j < statement.length && inString) {
+                const currentChar = statement[j];
+                
+                if (escapeNext) {
+                    escapeNext = false;
+                } else if (currentChar === '\\') {
+                    escapeNext = true;
+                } else if (currentChar === stringDelimiter && interpolatedBraceDepth === 0) {
+                    inString = false;
+                    j++;
+                    stringEnd = j;
+                    break;
+                } else if (currentChar === '{' && !escapeNext) {
+                    interpolatedBraceDepth++;
+                } else if (currentChar === '}' && !escapeNext && interpolatedBraceDepth > 0) {
+                    interpolatedBraceDepth--;
+                }
+                
+                j++;
+            }
+            
+            if (!inString) {
+                const valueExpression = statement.substring(startInStatement, stringEnd).trim();
+                return {
+                    valueExpression,
+                    valueExpressionIndex: finalIndex
+                };
+            }
+        }
+        
         return {
             valueExpression: trimmedStatement,
             valueExpressionIndex: statementIndex
@@ -2536,113 +2730,384 @@ private findMatchingParenthesis(str: string, openIndex: number): number {
     }
 
     private processStatementAndExtractValue(snippet: CodeSnippet, fullStatement: string, valueExpression: string, trClass: string, trFormatMethod: string, trMethod: string): void {
-        let processedFullStatement = fullStatement;
+        let processedValueExpression = valueExpression;
+        const isTextAssignment = /\w+\.text\s*=/.test(fullStatement.trim());
 
-        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);
+        this.extractTrFormatStrings(processedValueExpression, snippet, trClass, trFormatMethod);
+        processedValueExpression = this.processStringTemplates(processedValueExpression, snippet, trClass, trFormatMethod);
+        processedValueExpression = this.processStringFormat(processedValueExpression, snippet, trClass, trFormatMethod);
+        processedValueExpression = this.processStringConcatenation(processedValueExpression, snippet, trClass, trFormatMethod, trMethod);
+        if (isTextAssignment) {
+            processedValueExpression = this.processTextAssignments(processedValueExpression, snippet, trClass, trFormatMethod, trMethod);
+        }
+        this.extractPlainStrings(processedValueExpression, snippet, trClass, trFormatMethod);
 
         const regex = new RegExp(`${trClass}\\.${trFormatMethod}\\(([^)]*)\\)\\.${trMethod}\\(\\)`, 'g');
-        processedFullStatement = processedFullStatement.replace(regex, `${trClass}.${trFormatMethod}($1)`);
+        processedValueExpression = processedValueExpression.replace(regex, `${trClass}.${trFormatMethod}($1)`);
         snippet.finalizeLiterals();
 
-        let convertedValueExpression = valueExpression;
+        let convertedValueExpression = processedValueExpression;
 
-        const trimmedFullStatement = fullStatement.trim();
-        const trimmedProcessedStatement = processedFullStatement.trim();
+        if (convertedValueExpression.endsWith(';')) {
+            convertedValueExpression = convertedValueExpression.slice(0, -1).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();
+        snippet.convertedCode = convertedValueExpression;
+    }
+
+    private processAllFunctionCallsInRange(startIndex: number, endIndex: number, fullCode: string, snippets: CodeSnippet[], trClass: string, trFormatMethod: string, trMethod: string): void {
+        let i = startIndex;
+        while (i < endIndex) {
+            let actualParenOpenIndex = -1;
+            let tempDepth = 0;
+            let tempInString = false;
+            let tempEscapeNext = false;
+            let tempStringDelimiter = '';
+            let isStringFormat = false;
+            let functionNameStart = -1;
+            
+            for (let j = i; j < endIndex; j++) {
+                const char = fullCode[j];
+                const nextChar = j + 1 < fullCode.length ? fullCode[j + 1] : '';
+                const nextNextChar = j + 2 < fullCode.length ? fullCode[j + 2] : '';
+                
+                if (tempEscapeNext) {
+                    tempEscapeNext = false;
+                    continue;
                 }
-                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();
+                
+                if (char === '\\') {
+                    tempEscapeNext = true;
+                    continue;
                 }
-            } else {
-                const assignmentIndex = trimmedFullStatement.indexOf('=');
-                if (assignmentIndex !== -1) {
-                    if (fullStatement === processedFullStatement) {
-                        convertedValueExpression = valueExpression;
+                
+                if (tempInString) {
+                    if (char === tempStringDelimiter) {
+                        tempInString = false;
+                        tempStringDelimiter = '';
+                    }
+                    continue;
+                }
+                
+                if ((char === '$' && nextChar === '"') || 
+                    (char === '$' && nextChar === '@' && nextNextChar === '"') || 
+                    (char === '@' && nextChar === '$' && nextNextChar === '"')) {
+                    tempInString = true;
+                    tempStringDelimiter = '"';
+                    if (nextChar === '@') {
+                        j += 2;
                     } else {
-                        const prefix = trimmedFullStatement.substring(0, assignmentIndex + 1);
-                        const valuePart = trimmedProcessedStatement.substring(assignmentIndex + 1);
-                        const value = this.extractValueUntilSemicolon(valuePart);
-                        convertedValueExpression = value.trim();
+                        j += 1;
                     }
-                } else if (valueExpression.startsWith('string.Format(')) {
-                    const processedMatch = trimmedProcessedStatement.match(/^(Tr\.Format[\s\S]*?)(;|$)/);
-                    if (processedMatch) {
-                        convertedValueExpression = processedMatch[1].trim();
+                    continue;
+                }
+                
+                if (char === '"' || char === "'") {
+                    tempInString = true;
+                    tempStringDelimiter = char;
+                    continue;
+                }
+                
+                if (char === '(') {
+                    tempDepth++;
+                    if (actualParenOpenIndex === -1) {
+                        actualParenOpenIndex = j;
+                        if (functionNameStart !== -1) {
+                            const funcName = fullCode.substring(functionNameStart, j).trim();
+                            isStringFormat = funcName === 'string.Format';
+                        }
                     }
-                } 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 if (char === ')') {
+                    tempDepth--;
+                    if (tempDepth === 0 && actualParenOpenIndex !== -1 && !isStringFormat) {
+                        const actualParenCloseIndex = j;
+                        let currentSnippetCount = 0;
+                        const stringLiteralPositions: number[] = [];
+                        
+                        let k = actualParenOpenIndex;
+                        let inString3 = false;
+                        let escapeNext3 = false;
+                        let stringDelimiter3 = '';
+                        let stringStart = -1;
+                        
+                        while (k < fullCode.length && k <= actualParenCloseIndex) {
+                            const char = fullCode[k];
+                            const nextChar = k + 1 < fullCode.length ? fullCode[k + 1] : '';
+                            const nextNextChar = k + 2 < fullCode.length ? fullCode[k + 2] : '';
+                            
+                            if (escapeNext3) {
+                                escapeNext3 = false;
+                                k++;
+                                continue;
+                            }
+                            
+                            if (char === '\\') {
+                                escapeNext3 = true;
+                                k++;
+                                continue;
+                            }
+                            
+                            if (inString3) {
+                                if (char === stringDelimiter3) {
+                                    stringLiteralPositions.push(stringStart);
+                                    inString3 = false;
+                                    stringDelimiter3 = '';
+                                }
+                                k++;
+                                continue;
                             }
-                        } else {
-                            const parenOpenIndex = trimmedFullStatement.indexOf('(');
-                            if (parenOpenIndex !== -1) {
-                                const parenCloseIndex = this.findMatchingParenthesis(trimmedProcessedStatement, parenOpenIndex);
-                                if (parenCloseIndex !== -1) {
-                                    convertedValueExpression = trimmedProcessedStatement.substring(parenOpenIndex + 1, parenCloseIndex).trim();
+                            
+                            if ((char === '$' && nextChar === '"') || 
+                                (char === '$' && nextChar === '@' && nextNextChar === '"') || 
+                                (char === '@' && nextChar === '$' && nextNextChar === '"')) {
+                                inString3 = true;
+                                stringDelimiter3 = '"';
+                                stringStart = k;
+                                if (nextChar === '@') {
+                                    k += 2;
                                 } else {
-                                    convertedValueExpression = valueExpression;
+                                    k += 1;
                                 }
-                            } else {
-                                convertedValueExpression = valueExpression;
+                                continue;
                             }
+                            
+                            if (char === '"' || char === "'") {
+                                inString3 = true;
+                                stringDelimiter3 = char;
+                                stringStart = k;
+                                k++;
+                                continue;
+                            }
+                            
+                            if (char === ')' && k === actualParenCloseIndex) {
+                                break;
+                            }
+                            
+                            k++;
                         }
-                    }
-                } 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();
+
+                        let argStartPos = actualParenOpenIndex + 1;
+                        
+                        const trimmedCode = fullCode.substring(actualParenOpenIndex + 1, actualParenCloseIndex);
+                        const args = this.splitArguments(trimmedCode);
+
+                        for (const arg of args) {
+                            const trimmedArg = arg.trim();
+                            if (!trimmedArg) {
+                                argStartPos = this.updateArgStartPos(argStartPos, fullCode, actualParenCloseIndex);
+                                continue;
+                            }
+
+                            const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(trimmedArg) || 
+                                                    /\$"[\s\S]*?"/.test(trimmedArg) ||
+                                                    /\$@"[\s\S]*?"/.test(trimmedArg) ||
+                                                    /@\$"[\s\S]*?"/.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];
+                                const nextChar = foundArgEnd + 1 < fullCode.length ? fullCode[foundArgEnd + 1] : '';
+                                const nextNextChar = foundArgEnd + 2 < fullCode.length ? fullCode[foundArgEnd + 2] : '';
+
+                                if (escapeNext4) {
+                                    escapeNext4 = false;
+                                    foundArgEnd++;
+                                    continue;
+                                }
+
+                                if (char === '\\') {
+                                    escapeNext4 = true;
+                                    foundArgEnd++;
+                                    continue;
+                                }
+
+                                if (inString4) {
+                                    if (char === stringDelimiter4) {
+                                        inString4 = false;
+                                        stringDelimiter4 = '';
+                                    }
+                                    foundArgEnd++;
+                                    continue;
+                                }
+
+                                if ((char === '$' && nextChar === '"') || 
+                                    (char === '$' && nextChar === '@' && nextNextChar === '"') || 
+                                    (char === '@' && nextChar === '$' && nextNextChar === '"')) {
+                                    inString4 = true;
+                                    stringDelimiter4 = '"';
+                                    if (nextChar === '@') {
+                                        foundArgEnd += 2;
+                                    } else {
+                                        foundArgEnd += 1;
+                                    }
+                                    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;
+                                
+                                if (currentSnippetCount < stringLiteralPositions.length) {
+                                    finalOriginalIndex = stringLiteralPositions[currentSnippetCount];
+                                }
+
+                                let alreadyExists = false;
+                                for (const snippet of snippets) {
+                                    if (snippet.originalIndex === finalOriginalIndex) {
+                                        alreadyExists = true;
+                                        break;
+                                    }
+                                }
+                                
+                                if (!alreadyExists) {
+                                    let finalArg = actualArg;
+                                    
+                                    if (currentSnippetCount < stringLiteralPositions.length) {
+                                        const stringStart = stringLiteralPositions[currentSnippetCount];
+                                        let stringEnd = stringStart;
+                                        
+                                        let j = stringStart;
+                                        let inString = false;
+                                        let escapeNext = false;
+                                        let stringDelimiter = '';
+                                        let braceDepth = 0;
+                                        let interpolatedBraceDepth = 0;
+                                        
+                                        const char = fullCode[j];
+                                        const nextChar = j + 1 < fullCode.length ? fullCode[j + 1] : '';
+                                        const nextNextChar = j + 2 < fullCode.length ? fullCode[j + 2] : '';
+                                        
+                                        if ((char === '$' && nextChar === '"')) {
+                                            inString = true;
+                                            stringDelimiter = '"';
+                                            j += 2;
+                                        } else if (char === '$' && nextChar === '@' && j + 2 < fullCode.length && fullCode[j + 2] === '"') {
+                                            inString = true;
+                                            stringDelimiter = '"';
+                                            j += 3;
+                                        } else if (char === '@' && nextChar === '$' && j + 2 < fullCode.length && fullCode[j + 2] === '"') {
+                                            inString = true;
+                                            stringDelimiter = '"';
+                                            j += 3;
+                                        } else if (char === '"' || char === "'") {
+                                            inString = true;
+                                            stringDelimiter = char;
+                                            j++;
+                                        }
+                                        
+                                        while (j < fullCode.length && inString) {
+                                            const currentChar = fullCode[j];
+                                            
+                                            if (escapeNext) {
+                                                escapeNext = false;
+                                            } else if (currentChar === '\\') {
+                                                escapeNext = true;
+                                            } else if (currentChar === stringDelimiter && interpolatedBraceDepth === 0) {
+                                                inString = false;
+                                                j++;
+                                                stringEnd = j;
+                                                break;
+                                            } else if (currentChar === '{' && !escapeNext) {
+                                                interpolatedBraceDepth++;
+                                            } else if (currentChar === '}' && !escapeNext && interpolatedBraceDepth > 0) {
+                                                interpolatedBraceDepth--;
+                                            }
+                                            
+                                            j++;
+                                        }
+                                        
+                                        if (!inString) {
+                                            finalArg = fullCode.substring(stringStart, stringEnd);
+                                        }
+                                    }
+                                    
+                                    const snippet = new CodeSnippet();
+                                    snippet.originalIndex = finalOriginalIndex;
+                                    snippet.originalCode = finalArg;
+                                    snippet.originalContext = finalArg;
+
+                                    this.variableIndex = 0;
+
+                                    this.processSingleArgument(snippet, finalArg, trClass, trFormatMethod, trMethod);
+
+                                    snippets.push(snippet);
+                                    currentSnippetCount++;
+                                }
+                            }
+
+                            argStartPos = foundArgEnd + 1;
                         }
+                        
+                        i = actualParenCloseIndex + 1;
+                        actualParenOpenIndex = -1;
+                        isStringFormat = false;
+                        functionNameStart = -1;
+                    } else if (tempDepth === 0 && actualParenOpenIndex !== -1 && isStringFormat) {
+                        i = j + 1;
+                        actualParenOpenIndex = -1;
+                        isStringFormat = false;
+                        functionNameStart = -1;
                     }
-                } else {
-                    convertedValueExpression = trimmedProcessedStatement;
-                    if (convertedValueExpression.endsWith(';')) {
-                        convertedValueExpression = convertedValueExpression.slice(0, -1).trim();
-                    }
+                } else if (!tempInString && char === '.' && tempDepth === 0) {
+                    functionNameStart = -1;
+                } else if (!tempInString && /[a-zA-Z_]/.test(char) && tempDepth === 0 && functionNameStart === -1) {
+                    functionNameStart = j;
                 }
             }
+            
+            if (actualParenOpenIndex === -1) {
+                break;
+            }
         }
-
-        snippet.convertedCode = convertedValueExpression;
     }
 }