Improve pre test output

Author: DecimalTurn

server/src/test/antlr-parser-pre.test.ts

@@ -27,6 +27,92 @@ describe('ANTLR VBA Preprocessor Parser', () => {
         return implicitTokens;
     }
 
+    /**
+     * Helper function to create a hierarchical tree view of the parse tree
+     */
+    function logParseTree(parseTree: any, indent: string = '    ', isLast: boolean = true): void {
+        if (!parseTree) return;
+        
+        const nodeType = parseTree.constructor.name || 'UnknownNode';
+        const prefix = isLast ? '└── ' : '├── ';
+        
+        // If it's a terminal node (token), show the token value
+        if (parseTree.symbol) {
+            const token = parseTree.symbol;
+            const displayText = (token.text || '').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+            console.log(`${indent}${prefix}${nodeType} [${token.type}] = "${displayText}"`);
+        } else {
+            console.log(`${indent}${prefix}${nodeType}`);
+        }
+        
+        // Recursively display children
+        if (parseTree.children && parseTree.children.length > 0) {
+            const childIndent = indent + (isLast ? '    ' : '│   ');
+            parseTree.children.forEach((child: any, index: number) => {
+                const isLastChild = index === parseTree.children.length - 1;
+                logParseTree(child, childIndent, isLastChild);
+            });
+        }
+    }
+
+    /**
+     * Helper function to create a hierarchical token view based on line structure
+     */
+    function logTokenHierarchy(input: string, tokenInfo: Array<{type: number, text: string, typeName: string}>): void {
+        console.log('    🔗 Token Hierarchy:');
+        
+        const lines = input.split(/\r?\n/);
+        const nonEmptyLines = lines.map((line, index) => ({ line, index })).filter(item => item.line.trim());
+        let tokenIndex = 0;
+        
+        nonEmptyLines.forEach((lineItem, displayIndex) => {
+            const { line, index: lineNum } = lineItem;
+            const isLastLine = displayIndex === nonEmptyLines.length - 1;
+            const linePrefix = isLastLine ? '└── ' : '├── ';
+            
+            console.log(`      ${linePrefix}Line ${lineNum + 1}: "${line}"`);
+            
+            // Find tokens that belong to this line
+            const lineTokens: typeof tokenInfo = [];
+            const currentPos = 0;
+            
+            // Simple heuristic to group tokens by line
+            while (tokenIndex < tokenInfo.length) {
+                const token = tokenInfo[tokenIndex];
+                
+                // If it's a newline token, we've reached the end of this line
+                if (token.typeName === 'NEWLINE') {
+                    tokenIndex++;
+                    break;
+                }
+                
+                lineTokens.push(token);
+                tokenIndex++;
+                
+                // If we've processed all tokens, break
+                if (tokenIndex >= tokenInfo.length) break;
+            }
+            
+            // Display tokens for this line in a hierarchical manner
+            lineTokens.forEach((token, idx) => {
+                const isLastToken = idx === lineTokens.length - 1;
+                const tokenPrefix = isLastToken ? '└── ' : '├── ';
+                const lineConnector = isLastLine ? '    ' : '│   ';
+                const displayText = token.text.replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+                console.log(`      ${lineConnector}${tokenPrefix}${token.typeName.padEnd(12)} = "${displayText}"`);
+            });
+        });
+        
+        // Handle any remaining tokens that weren't processed
+        while (tokenIndex < tokenInfo.length) {
+            const token = tokenInfo[tokenIndex];
+            if (token.typeName === 'NEWLINE') {
+                console.log(`      └── [End] NEWLINE = "${token.text.replace(/\n/g, '\\n').replace(/\r/g, '\\r')}"`);
+            }
+            tokenIndex++;
+        }
+    }
+
     /**
      * Helper function to log parsing results consistently
      */
@@ -39,11 +125,23 @@ describe('ANTLR VBA Preprocessor Parser', () => {
                 console.log(`      ${(index + 1).toString().padStart(2)}: ${line}`);
             }
         });
-        console.log('    🔤 Tokens:');
+        
+        // Original flat token view
+        console.log('    🔤 Tokens (Flat):');
         result.tokenInfo.forEach((t, i) => {
             const displayText = t.text.replace(/\n/g, '\\n').replace(/\r/g, '\\r');
             console.log(`      ${i.toString().padStart(2)}: ${t.typeName.padEnd(12)} = "${displayText}"`);
         });
+        
+        // New hierarchical token view
+        logTokenHierarchy(input, result.tokenInfo);
+        
+        // Parse tree hierarchy (if available)
+        if (result.parseTree) {
+            console.log('    🌳 Parse Tree:');
+            logParseTree(result.parseTree);
+        }
+        
         if (result.lexerErrors.length > 0) {
             console.log('    ❌ Lexer errors:', result.lexerErrors);
         }