Merge pull request #396 from lunasaw/20250807_support_function_post_definition

feat(function): post function reference

Author: DQinYuan

src/main/java/com/alibaba/qlexpress4/aparser/QvmInstructionVisitor.java

@@ -184,12 +184,29 @@ public Void visitBlockStatements(BlockStatementsContext blockStatementsContext)
             .stream()
             .filter(bs -> !(bs instanceof EmptyStatementContext))
             .collect(Collectors.toList());
+        
+        // First pass: process macro definitions to ensure they are available for functions
         for (BlockStatementContext child : nonEmptyChildren) {
-            if (isPreExpress) {
-                // pop if expression without acceptor
-                addInstruction(new PopInstruction(PureErrReporter.INSTANCE));
+            if (child instanceof MacroStatementContext) {
+                child.accept(this);
+            }
+        }
+        
+        // Second pass: process all function definitions to support forward references
+        for (BlockStatementContext child : nonEmptyChildren) {
+            if (child instanceof FunctionStatementContext) {
+                child.accept(this);
+            }
+        }
+        
+        // Third pass: process all other statements
+        for (BlockStatementContext child : nonEmptyChildren) {
+            if (!(child instanceof FunctionStatementContext) && !(child instanceof MacroStatementContext)) {
+                if (isPreExpress) {
+                    addInstruction(new PopInstruction(PureErrReporter.INSTANCE));
+                }
+                isPreExpress = handleStmt(child);
             }
-            isPreExpress = handleStmt(child);
         }
 
         if (context == Context.BLOCK) {

src/test/java/com/alibaba/qlexpress4/TestSuiteRunner.java

@@ -61,7 +61,7 @@ public void suiteTest()
     @Test
     public void featureDebug()
         throws URISyntaxException, IOException {
-        Path filePath = getTestSuiteRoot().resolve("java/property/null_set_invoke.ql");
+        Path filePath = getTestSuiteRoot().resolve("independent/function/nested_function_calls.ql");
         handleFile(filePath, filePath.toString(), true);
     }
 

src/test/resources/testsuite/independent/function/complex_parameters.ql

@@ -0,0 +1,67 @@
+// Test functions with various parameter types and complexity
+assert(processData(5, true) == 15)
+assert(calculateComplex(1.5, 2.5, 10) == 160.0)
+
+// Test function calls with complex expressions as parameters
+assert(mathOperations(add(2, 3), multiply(2, 2)) == 625) // 5^4 = 625
+
+function processData(int count, boolean flag) {
+    int result = count * 2;
+    if (flag) {
+        result = result + 5;
+    }
+    return result;
+}
+
+function calculateComplex(double x, double y, int multiplier) {
+    double base = x + y;
+    return base * base * multiplier;
+}
+
+function mathOperations(int a, int b) {
+    return power(a, b);
+}
+
+function add(int x, int y) {
+    return x + y;
+}
+
+function multiply(int x, int y) {
+    return x * y;
+}
+
+function power(int base, int exp) {
+    if (exp == 0) {
+        return 1;
+    }
+    int result = 1;
+    for (int i = 0; i < exp; i++) {
+        result *= base;
+    }
+    return result;
+}
+
+// Test functions with no parameters
+assert(getConstant() == 42)
+assert(generateRandom() > 0)
+
+function getConstant() {
+    return 42;
+}
+
+function generateRandom() {
+    // Simple pseudo-random using current execution context
+    return 123; // For deterministic testing
+}
+
+// Test function overloading-like behavior with different parameter counts
+assert(calculate(5) == 25)
+assert(calculate2(5, 3) == 39) // 5*5 + 3*3 + 5 = 25 + 9 + 5 = 39
+
+function calculate(int x) {
+    return x * x;
+}
+
+function calculate2(int x, int y) {
+    return x * x + y * y + 5;
+}

src/test/resources/testsuite/independent/function/edge_cases.ql

@@ -0,0 +1,100 @@
+// Test edge cases for function hoisting
+// Test function called immediately at global level before definition
+int immediateResult = callImmediately();
+assert(immediateResult == 42)
+
+// Test function in conditional blocks called before definition  
+if (true) {
+    assert(conditionalFunction(5) == 10)
+}
+
+// Test function in loop called before definition
+for (int i = 0; i < 2; i++) {
+    assert(loopFunction(i) == i * 3)
+}
+
+// Test function with same name as built-in (should work)
+assert(toString(123) == "custom_123")
+
+// Test function that returns function call result
+assert(chainReturn() == 999)
+
+// Function definitions (after all calls)
+function callImmediately() {
+    return 42;
+}
+
+function conditionalFunction(int x) {
+    return x * 2;
+}
+
+function loopFunction(int x) {
+    return x * 3;
+}
+
+function toString(int value) {
+    return "custom_" + value;
+}
+
+function chainReturn() {
+    return getSpecialValue();
+}
+
+function getSpecialValue() {
+    return 999;
+}
+
+// Test empty function
+assert(emptyFunction() == null)
+
+function emptyFunction() {
+    // Empty body
+}
+
+// Test function that just returns constant
+assert(constantFunction() == "CONSTANT")
+
+function constantFunction() {
+    return "CONSTANT";
+}
+
+// Test functions with early returns
+assert(earlyReturnFunction(true) == 1)
+assert(earlyReturnFunction(false) == 2)
+
+function earlyReturnFunction(boolean condition) {
+    if (condition) {
+        return 1;
+    }
+    return 2;
+}
+
+// Test function calling itself indirectly (through another function)
+assert(indirectSelfCall(3) == 6)
+
+function indirectSelfCall(int n) {
+    if (n <= 0) {
+        return 0;
+    }
+    return n + helperForIndirect(n - 1);
+}
+
+function helperForIndirect(int n) {
+    return indirectSelfCall(n);
+}
+
+// Test function with multiple return types based on conditions
+function dynamicReturn(int choice) {
+    if (choice == 1) {
+        return 100;
+    } else if (choice == 2) {
+        return "text";
+    } else {
+        return true;
+    }
+}
+
+// Test the dynamic returns
+assert(dynamicReturn(1) == 100)
+assert(dynamicReturn(2) == "text")
+assert(dynamicReturn(3) == true)

src/test/resources/testsuite/independent/function/function_call.ql

@@ -12,4 +12,8 @@ assert(sub(3,1)==2)
 
 assertErrorCode(() -> {add(1, "2")}, "INVALID_ARGUMENT")
 
+assert(check(3,1)==false)
 
+function check(a, b) {
+    return a < b;
+}

src/test/resources/testsuite/independent/function/function_scoping.ql

@@ -0,0 +1,84 @@
+// Test function scoping and parameter shadowing
+int outerVariable = 10;
+
+// Test function with same parameter name as global variable
+assert(testScoping(5) == 15)
+
+// Test that global variable is not affected
+assert(outerVariable == 10)
+
+function testScoping(int outerVariable) {
+    // Parameter shadows global variable
+    return outerVariable + 10;
+}
+
+// Test nested scoping with local variables
+assert(nestedScoping(3) == 18)
+
+function nestedScoping(int x) {
+    int localVar = x * 2; // 6
+    if (localVar > 5) {
+        int innerVar = localVar * 2; // 12
+        return innerVar + 6; // 18
+    }
+    return localVar;
+}
+
+// Test functions that call other functions with same parameter names
+assert(chainedScoping(2) == 14)
+
+function chainedScoping(int value) {
+    return helperFunction(value + 1);
+}
+
+function helperFunction(int value) {
+    // Different 'value' parameter
+    return value * 4 + 2; // (2+1) * 4 + 2 = 14
+}
+
+// Test function with multiple parameters having local scope
+assert(multipleParams(1, 2, 3) == 12)
+
+function multipleParams(int a, int b, int c) {
+    int sum = a + b + c;
+    int doubled = sum * 2;
+    return doubled;
+}
+
+// Test function that modifies parameters (local copies)
+int originalValue = 5;
+assert(modifyParameter(originalValue) == 25)
+assert(originalValue == 5) // Original should remain unchanged
+
+function modifyParameter(int param) {
+    param = param * 5; // Modifying local copy
+    return param;
+}
+
+// Test function with conditional blocks and local variables
+assert(conditionalScoping(true, 10) == 30)
+assert(conditionalScoping(false, 10) == 0) // 10 - 10 = 0
+
+function conditionalScoping(boolean condition, int base) {
+    int result = base;
+    if (condition) {
+        int bonus = 20;
+        result = result + bonus;
+    } else {
+        int penalty = 10;
+        result = result - penalty;
+    }
+    return result;
+}
+
+// Test loops with local scope
+assert(loopScoping(3) == 6)
+
+function loopScoping(int count) {
+    int total = 0;
+    for (int i = 1; i <= count; i++) {
+        int squared = i; // Local to loop iteration
+        total += squared;
+    }
+    return total; // 1 + 2 + 3 = 6
+}

src/test/resources/testsuite/independent/function/mixed_declarations.ql

@@ -0,0 +1,54 @@
+// Test mixed function and variable declarations with forward references
+int globalVar = computeInitialValue();
+int message = formatMessage(42, getValue());
+
+assert(globalVar == 100)
+assert(message == 92) // 42 + 50 = 92
+
+// Variables referencing functions before they're defined
+int result1 = doubleValue(25);
+assert(result1 == 50)
+
+function computeInitialValue() {
+    return 100;
+}
+
+function formatMessage(int prefix, int value) {
+    return prefix + value;
+}
+
+function getValue() {
+    return 50;
+}
+
+function doubleValue(int x) {
+    return x * 2;
+}
+
+// Test functions that modify and return based on global state
+int counter = 0;
+
+function increment() {
+    counter = counter + 1;
+    return counter;
+}
+
+function getCounterValue() {
+    return counter;
+}
+
+// Test the counter functions
+int first = increment();   // Should be 1
+int second = increment();  // Should be 2
+int current = getCounterValue(); // Should be 2
+
+assert(first == 1)
+assert(second == 2) 
+assert(current == 2)
+
+// Test simple calculation with constants
+function simpleCalculation() {
+    return 10 * 30; // 300
+}
+
+assert(simpleCalculation() == 300)