com.alibaba.qlexpress4.Express4RunnerTest#scripTimeoutTest unit test with timeout

Author: DQinYuan

src/main/java/com/alibaba/qlexpress4/Express4Runner.java

@@ -229,21 +229,23 @@ public Set<String> getOutVarNames(String script) {
         VariableDetector.Context context;
         try {
             context = variableDetector.detect(programNode);
-        } catch (Exception e) {
+        }
+        catch (Exception e) {
             throw new RuntimeException("Failed to detect variables", e);
         }
-
+        
         // Get all variable reads (external variables are those that are read but not declared)
         Set<String> allVars = context.getAllVariableNames();
-
+        
         // Remove declared variables (local variables)
-        for (com.alibaba.qlexpress4.parser.visitor.VariableDetector.VariableDeclaration decl : context.getVariableDeclarations()) {
+        for (com.alibaba.qlexpress4.parser.visitor.VariableDetector.VariableDeclaration decl : context
+            .getVariableDeclarations()) {
             allVars.remove(decl.getVariableName());
         }
-
+        
         return allVars;
     }
-
+    
     /**
      * Get external variable attribute access paths referenced by the script.
      *
@@ -256,15 +258,17 @@ public Set<List<String>> getOutVarAttrs(String script) {
         VariableDetector.Context context;
         try {
             context = variableDetector.detect(programNode);
-        } catch (Exception e) {
+        }
+        catch (Exception e) {
             throw new RuntimeException("Failed to detect variable attributes", e);
         }
-
+        
         // Convert variable accesses to attribute paths
         // Note: This is a simplified implementation - the original implementation
         // handles complex cases like field access chains
         Set<List<String>> outVarAttrs = new java.util.HashSet<>();
-        for (com.alibaba.qlexpress4.parser.visitor.VariableDetector.VariableAccess access : context.getVariableReads()) {
+        for (com.alibaba.qlexpress4.parser.visitor.VariableDetector.VariableAccess access : context
+            .getVariableReads()) {
             if (access.getType() == com.alibaba.qlexpress4.parser.visitor.VariableDetector.VariableAccessType.READ) {
                 List<String> path = new java.util.ArrayList<>();
                 path.add(access.getVariableName());
@@ -273,7 +277,7 @@ public Set<List<String>> getOutVarAttrs(String script) {
         }
         return outVarAttrs;
     }
-
+    
     /**
      * Get external functions (those that must be provided via context) referenced by the script.
      *
@@ -286,17 +290,19 @@ public Set<String> getOutFunctions(String script) {
         List<com.alibaba.qlexpress4.parser.visitor.FunctionExtractor.FunctionCall> functionCalls;
         try {
             functionCalls = functionExtractor.extract(programNode);
-        } catch (Exception e) {
+        }
+        catch (Exception e) {
             throw new RuntimeException("Failed to extract functions", e);
         }
-
+        
         // Filter for direct calls (external functions)
         return functionCalls.stream()
-                .filter(fc -> fc.getType() == com.alibaba.qlexpress4.parser.visitor.FunctionExtractor.FunctionCallType.DIRECT_CALL)
-                .map(com.alibaba.qlexpress4.parser.visitor.FunctionExtractor.FunctionCall::getName)
-                .collect(Collectors.toSet());
+            .filter(fc -> fc
+                .getType() == com.alibaba.qlexpress4.parser.visitor.FunctionExtractor.FunctionCallType.DIRECT_CALL)
+            .map(com.alibaba.qlexpress4.parser.visitor.FunctionExtractor.FunctionCall::getName)
+            .collect(Collectors.toSet());
     }
-
+    
     /**
      * Get the expression trace trees for the script without executing it.
      *
@@ -307,8 +313,9 @@ public List<TracePointTree> getExpressionTracePoints(String script) {
         ProgramNode programNode = parseToSyntaxTree(script);
         TraceGenerator traceGenerator = new TraceGenerator();
         try {
-            ((com.alibaba.qlexpress4.parser.ast.ASTNode) programNode).accept(traceGenerator, null);
-        } catch (Exception e) {
+            ((com.alibaba.qlexpress4.parser.ast.ASTNode)programNode).accept(traceGenerator, null);
+        }
+        catch (Exception e) {
             throw new RuntimeException("Failed to generate trace points", e);
         }
         return traceGenerator.getTracePoints();
@@ -335,13 +342,14 @@ public void addOrReplaceMacro(String name, String macroScript) {
 
     private MacroDefine parseMacroDefine(String name, String macroScript) {
         ProgramNode macroProgram = parseToSyntaxTree(macroScript);
-
+        
         try {
             // Compile the macro using the new AST compiler
-            QLambdaDefinitionInner macroLambdaDef = (QLambdaDefinitionInner) ASTCompiler.compile(macroProgram, operatorManager);
+            QLambdaDefinitionInner macroLambdaDef =
+                (QLambdaDefinitionInner)ASTCompiler.compile(macroProgram, operatorManager);
             QLInstruction[] macroInstructionsArray = macroLambdaDef.getInstructions();
             List<QLInstruction> macroInstructions = java.util.Arrays.asList(macroInstructionsArray);
-
+            
             // Determine if the last statement is an expression
             // The new AST's ProgramNode has a list of statements
             boolean lastStmtExpress = false;
@@ -351,9 +359,10 @@ private MacroDefine parseMacroDefine(String name, String macroScript) {
                 // Check if the last statement is an expression (implements ExpressionNode)
                 lastStmtExpress = lastStmt instanceof com.alibaba.qlexpress4.parser.ast.ExpressionNode;
             }
-
+            
             return new MacroDefine(macroInstructions, lastStmtExpress);
-        } catch (Exception e) {
+        }
+        catch (Exception e) {
             throw new RuntimeException("Failed to parse macro definition: " + name, e);
         }
     }
@@ -564,7 +573,8 @@ public Object invoke(Object obj, Object[] args)
         });
     }
 
-    public ProgramNode parseToSyntaxTree(String script) throws QLSyntaxException {
+    public ProgramNode parseToSyntaxTree(String script)
+        throws QLSyntaxException {
         try {
             return SyntaxTreeFactory.buildTree(script,
                 operatorManager,
@@ -575,32 +585,32 @@ public ProgramNode parseToSyntaxTree(String script) throws QLSyntaxException {
                 initOptions.getSelectorStart(),
                 initOptions.getSelectorEnd(),
                 initOptions.isStrictNewLines());
-        } catch (com.alibaba.qlexpress4.parser.parser.QLexpressParser.ParseException e) {
+        }
+        catch (com.alibaba.qlexpress4.parser.parser.QLexpressParser.ParseException e) {
             // Convert ParseException to QLSyntaxException
             // position is -1 (unknown) since ParseException doesn't provide character offset
-            throw QLException.reportScannerErr(
-                script,
+            throw QLException.reportScannerErr(script,
                 -1,
                 e.getLine(),
                 e.getColumn(),
-                "",  // lexeme is not available from ParseException
+                "", // lexeme is not available from ParseException
                 QLErrorCodes.SYNTAX_ERROR.name(),
                 e.getMessage());
         }
     }
-
+    
     public void check(String script, CheckOptions checkOptions)
         throws QLSyntaxException {
         // 1. Parse syntax tree (reuse existing parseToSyntaxTree logic)
         ProgramNode programNode = parseToSyntaxTree(script);
-
+        
         // 2. Create ScriptChecker and pass validation configuration and script content
         ScriptChecker scriptChecker = new ScriptChecker(checkOptions, script);
-
+        
         // 3. Traverse syntax tree and perform operator validation during traversal
         scriptChecker.check(programNode);
     }
-
+    
     public void check(String script)
         throws QLSyntaxException {
         check(script, CheckOptions.DEFAULT_OPTIONS);
@@ -645,7 +655,7 @@ public QCompileCache parseToDefinitionWithCache(String script) {
     public Value loadField(Object object, String fieldName) {
         return reflectLoader.loadField(object, fieldName, true, PureErrReporter.INSTANCE);
     }
-
+    
     /**
      * Clear the compilation cache.
      * This method clears the cache that stores compiled scripts for performance optimization.
@@ -672,20 +682,23 @@ private Future<QCompileCache> getParseFuture(String script) {
 
     private QCompileCache parseDefinition(String script) {
         ProgramNode programNode = parseToSyntaxTree(script);
-
+        
         try {
             if (initOptions.isTraceExpression()) {
                 // Compile with trace points
                 ASTCompiler.CompilationResult result = ASTCompiler.compileWithTrace(programNode, operatorManager);
                 return new QCompileCache(result.getLambdaDefinition(), result.getTracePoints());
-            } else {
+            }
+            else {
                 // Compile without trace points
-                QLambdaDefinitionInner qLambdaDefinition = (QLambdaDefinitionInner) ASTCompiler.compile(programNode, operatorManager);
+                QLambdaDefinitionInner qLambdaDefinition =
+                    (QLambdaDefinitionInner)ASTCompiler.compile(programNode, operatorManager);
                 return new QCompileCache(qLambdaDefinition, Collections.emptyList());
             }
-        } catch (Exception e) {
+        }
+        catch (Exception e) {
             if (e instanceof QLSyntaxException) {
-                throw (QLSyntaxException) e;
+                throw (QLSyntaxException)e;
             }
             throw new RuntimeException("Compilation failed", e);
         }

src/main/java/com/alibaba/qlexpress4/parser/ASTCompiler.java

@@ -31,11 +31,11 @@
  * @author QLExpress Team
  */
 public class ASTCompiler {
-
+    
     private ASTCompiler() {
         // Static utility class
     }
-
+    
     /**
      * Compiles a ProgramNode to a QLambdaDefinition.
      * <p>
@@ -48,30 +48,30 @@ private ASTCompiler() {
      * @throws Exception if compilation fails
      */
     public static QLambdaDefinition compile(ProgramNode programNode, OperatorManager operatorManager)
-            throws Exception {
+        throws Exception {
         if (programNode == null) {
             throw new IllegalArgumentException("programNode cannot be null");
         }
         if (operatorManager == null) {
             throw new IllegalArgumentException("operatorManager cannot be null");
         }
-
+        
         // Create instruction generator
         InstructionGenerator generator = new InstructionGenerator(operatorManager);
-
+        
         // Generate instructions from AST
-        GenerationResult result = ((ASTNode) programNode).accept(generator, new GenerationContext());
-
+        GenerationResult result = ((ASTNode)programNode).accept(generator, new GenerationContext());
+        
         // Extract instructions
         List<QLInstruction> instructions = result.getInstructions();
-
+        
         // Calculate max stack size
         int maxStackSize = calculateMaxStackSize(instructions);
-
+        
         // Create main lambda definition
         return new QLambdaDefinitionInner("main", instructions, Collections.emptyList(), maxStackSize);
     }
-
+    
     /**
      * Compiles a ProgramNode to a QLambdaDefinition with trace points.
      * <p>
@@ -83,25 +83,24 @@ public static QLambdaDefinition compile(ProgramNode programNode, OperatorManager
      * @return A CompilationResult containing the lambda definition and trace points
      * @throws Exception if compilation fails
      */
-    public static CompilationResult compileWithTrace(ProgramNode programNode,
-                                                      OperatorManager operatorManager)
-            throws Exception {
+    public static CompilationResult compileWithTrace(ProgramNode programNode, OperatorManager operatorManager)
+        throws Exception {
         if (programNode == null) {
             throw new IllegalArgumentException("programNode cannot be null");
         }
         if (operatorManager == null) {
             throw new IllegalArgumentException("operatorManager cannot be null");
         }
-
+        
         // Compile to lambda definition
         QLambdaDefinition lambdaDefinition = compile(programNode, operatorManager);
-
+        
         // Generate trace points
         List<TracePointTree> tracePoints = generateTracePoints(programNode);
-
+        
         return new CompilationResult(lambdaDefinition, tracePoints);
     }
-
+    
     /**
      * Generates execution trace points from a ProgramNode.
      *
@@ -112,19 +111,20 @@ public static List<TracePointTree> generateTracePoints(ProgramNode programNode)
         if (programNode == null) {
             throw new IllegalArgumentException("programNode cannot be null");
         }
-
+        
         TraceGenerator traceGenerator = new TraceGenerator();
         try {
-            ((ASTNode) programNode).accept(traceGenerator, null);
-        } catch (Exception e) {
+            ((ASTNode)programNode).accept(traceGenerator, null);
+        }
+        catch (Exception e) {
             // Trace generation should not fail compilation
             // Return empty list on error
             return Collections.emptyList();
         }
-
+        
         return traceGenerator.getTracePoints();
     }
-
+    
     /**
      * Calculates the maximum stack size needed for a list of instructions.
      * <p>
@@ -139,7 +139,7 @@ private static int calculateMaxStackSize(List<QLInstruction> instructions) {
         // This matches the heuristic used in the original QvmInstructionVisitor
         return Math.max(10, instructions.size() / 2 + 5);
     }
-
+    
     /**
      * Compilation result containing both the lambda definition and trace points.
      * <p>
@@ -148,18 +148,18 @@ private static int calculateMaxStackSize(List<QLInstruction> instructions) {
      */
     public static class CompilationResult {
         private final QLambdaDefinition lambdaDefinition;
+        
         private final List<TracePointTree> tracePoints;
-
-        public CompilationResult(QLambdaDefinition lambdaDefinition,
-                                 List<TracePointTree> tracePoints) {
+        
+        public CompilationResult(QLambdaDefinition lambdaDefinition, List<TracePointTree> tracePoints) {
             this.lambdaDefinition = lambdaDefinition;
             this.tracePoints = tracePoints;
         }
-
+        
         public QLambdaDefinition getLambdaDefinition() {
             return lambdaDefinition;
         }
-
+        
         public List<TracePointTree> getTracePoints() {
             return tracePoints;
         }