jaclang 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

jaclang/settings.py

@@ -18,8 +18,6 @@ class Settings:
 
     # Compiler configuration
     ignore_test_annex: bool = False
-    pyout_jaclib_alias: str = "_jl"
-    library_mode: bool = False
     pyfile_raise: bool = False
     pyfile_raise_full: bool = False
 

jaclang/tests/fixtures/iife_functions.jac

@@ -0,0 +1,142 @@
+"""Test Immediately Invoked Function Expressions (IIFE)."""
+
+with entry {
+    # Test 1: Basic IIFE with no parameters
+    let result1 = (def get_value() -> int {
+        return 42;
+    })();
+
+    print("Test 1 - Basic IIFE:", result1);
+    # Expected: 42
+
+    # Test 2: IIFE with parameters
+    let result2 = (def calculate(x: int, y: int) -> int {
+        return x * y + x + y;
+    })(5, 3);
+
+    print("Test 2 - IIFE with parameters (5, 3):", result2);
+    # Expected: 23 (15 + 5 + 3)
+
+    # Test 3: IIFE with local variables
+    let result3 = (def compute() -> int {
+        let a = 10;
+        let b = 20;
+        let c = 30;
+        return a + b + c;
+    })();
+
+    print("Test 3 - IIFE with local variables:", result3);
+    # Expected: 60
+
+    # Test 4: IIFE with conditional logic
+    let result4 = (def check_number(n: int) -> str {
+        if n > 0 {
+            return "positive";
+        } elif n < 0 {
+            return "negative";
+        } else {
+            return "zero";
+        }
+    })(15);
+
+    print("Test 4 - IIFE with conditional:", result4);
+    # Expected: positive
+
+    # Test 5: IIFE with loop
+    let result5 = (def sum_to_n(n: int) -> int {
+        let total = 0;
+        let i = 1;
+        while i <= n {
+            total = total + i;
+            i = i + 1;
+        }
+        return total;
+    })(5);
+
+    print("Test 5 - IIFE with loop (sum 1 to 5):", result5);
+    # Expected: 15
+
+    # Test 6: IIFE returning a function
+    let adder = (def make_adder(x: int) {
+        return lambda y: int: x + y;
+    })(10);
+
+    print("Test 6 - IIFE returning function, adder(5):", adder(5));
+    # Expected: 15
+
+    # Test 7: Nested IIFE
+    let result7 = (def outer() -> int {
+        let x = (def inner() -> int {
+            return 100;
+        })();
+        return x + 50;
+    })();
+
+    print("Test 7 - Nested IIFE:", result7);
+    # Expected: 150
+
+    # Test 8: IIFE with multiple operations
+    let result8 = (def process_data(data: list) -> int {
+        let sum = 0;
+        let count = 0;
+        for item in data {
+            sum = sum + item;
+            count = count + 1;
+        }
+        if count > 0 {
+            return sum / count;
+        } else {
+            return 0;
+        }
+    })([10, 20, 30, 40, 50]);
+
+    print("Test 8 - IIFE computing average:", result8);
+    # Expected: 30
+
+    # Test 9: IIFE with try-catch
+    let result9 = (def safe_operation(a: int, b: int) -> str {
+        try {
+            let result = a / b;
+            return f"Success: {result}";
+        } except Exception {
+            return "Error occurred";
+        }
+    })(10, 2);
+
+    print("Test 9 - IIFE with try-catch:", result9);
+    # Expected: Success: 5.0
+
+    # Test 10: IIFE used in assignment chain
+    let x = 5;
+    let result10 = x + (def double(n: int) -> int {
+        return n * 2;
+    })(x);
+
+    print("Test 10 - IIFE in expression (5 + double(5)):", result10);
+    # Expected: 15
+
+    # Test 11: IIFE with object/dict creation
+    let result11 = (def create_object() -> dict {
+        let obj = {
+            "name": "Test",
+            "value": 123,
+            "active": True
+        };
+        return obj;
+    })();
+
+    print("Test 11 - IIFE creating object:", result11);
+    # Expected: {'name': 'Test', 'value': 123, 'active': True}
+
+    # Test 12: IIFE with string manipulation
+    let result12 = (def format_message(name: str, age: int) -> str {
+        let message = f"Hello, {name}!";
+        let age_part = f" You are {age} years old.";
+        return message + age_part;
+    })("Alice", 25);
+
+    print("Test 12 - IIFE with string manipulation:", result12);
+    # Expected: Hello, Alice! You are 25 years old.
+
+    print("\nAll IIFE tests completed!");
+}

jaclang/tests/fixtures/iife_functions_client.jac

@@ -0,0 +1,143 @@
+"""Test Immediately Invoked Function Expressions (IIFE) for client-side (JavaScript) execution."""
+
+cl with entry {
+    # Test 1: Basic IIFE with no parameters
+    let result1 = (def get_value() -> int {
+        return 42;
+    })();
+
+    print("Test 1 - Basic IIFE:", result1);
+    # Expected: 42
+
+    # Test 2: IIFE with parameters
+    let result2 = (def calculate(x: int, y: int) -> int {
+        return x * y + x + y;
+    })(5, 3);
+
+    print("Test 2 - IIFE with parameters (5, 3):", result2);
+    # Expected: 23 (15 + 5 + 3)
+
+    # Test 3: IIFE with local variables
+    let result3 = (def compute() -> int {
+        let a = 10;
+        let b = 20;
+        let c = 30;
+        return a + b + c;
+    })();
+
+    print("Test 3 - IIFE with local variables:", result3);
+    # Expected: 60
+
+    # Test 4: IIFE with conditional logic
+    let result4 = (def check_number(n: int) -> str {
+        if n > 0 {
+            return "positive";
+        } elif n < 0 {
+            return "negative";
+        } else {
+            return "zero";
+        }
+    })(15);
+
+    print("Test 4 - IIFE with conditional:", result4);
+    # Expected: positive
+
+    # Test 5: IIFE with loop
+    let result5 = (def sum_to_n(n: int) -> int {
+        let total = 0;
+        let i = 1;
+        while i <= n {
+            total = total + i;
+            i = i + 1;
+        }
+        return total;
+    })(5);
+
+    print("Test 5 - IIFE with loop (sum 1 to 5):", result5);
+    # Expected: 15
+
+    # Test 6: IIFE returning a function
+    let adder = (def make_adder(x: int) {
+        return lambda y: int: x + y;
+    })(10);
+
+    print("Test 6 - IIFE returning function, adder(5):", adder(5));
+    # Expected: 15
+
+    # Test 7: Nested IIFE
+    let result7 = (def outer() -> int {
+        let x = (def inner() -> int {
+            return 100;
+        })();
+        return x + 50;
+    })();
+
+    print("Test 7 - Nested IIFE:", result7);
+    # Expected: 150
+
+    # Test 8: IIFE with array operations
+    let result8 = (def process_data(data: list) -> int {
+        let sum = 0;
+        let count = 0;
+        for item in data {
+            sum = sum + item;
+            count = count + 1;
+        }
+        if count > 0 {
+            return sum / count;
+        } else {
+            return 0;
+        }
+    })([10, 20, 30, 40, 50]);
+
+    print("Test 8 - IIFE computing average:", result8);
+    # Expected: 30
+
+    # Test 9: IIFE used in assignment chain
+    let x = 5;
+    let result9 = x + (def double(n: int) -> int {
+        return n * 2;
+    })(x);
+
+    print("Test 9 - IIFE in expression (5 + double(5)):", result9);
+    # Expected: 15
+
+    # Test 10: IIFE with object creation
+    let result10 = (def create_object() -> dict {
+        let obj = {
+            "name": "Test",
+            "value": 123,
+            "active": True
+        };
+        return obj;
+    })();
+
+    print("Test 10 - IIFE creating object:", result10);
+    # Expected: {name: 'Test', value: 123, active: true}
+
+    # Test 11: IIFE with string manipulation
+    let result11 = (def format_message(name: str, age: int) -> str {
+        let message = "Hello, " + name + "!";
+        let age_part = " You are " + str(age) + " years old.";
+        return message + age_part;
+    })("Alice", 25);
+
+    print("Test 11 - IIFE with string manipulation:", result11);
+    # Expected: Hello, Alice! You are 25 years old.
+
+    # Test 12: IIFE with closure
+    let counter = (def create_counter() {
+        let count = 0;
+        return lambda () {
+            count = count + 1;
+            return count;
+        };
+    })();
+
+    print("Test 12 - IIFE with closure, call 1:", counter());
+    print("Test 12 - IIFE with closure, call 2:", counter());
+    print("Test 12 - IIFE with closure, call 3:", counter());
+    # Expected: 1, 2, 3
+
+    print("\nAll client-side IIFE tests completed!");
+}

jaclang/tests/fixtures/multistatement_lambda.jac

@@ -0,0 +1,116 @@
+"""Test multi-statement lambda expressions."""
+
+with entry {
+    # Test 1: Basic multi-statement lambda
+    let add_and_multiply = lambda x: int, y: int -> int {
+        let sum = x + y;
+        let product = x * y;
+        return sum + product;
+    };
+
+    let result1 = add_and_multiply(3, 4);
+    print("Test 1 - Multi-statement lambda (3 + 4) + (3 * 4):", result1);
+    # Expected: 19 (7 + 12)
+
+    # Test 2: Lambda with conditional logic
+    let get_grade = lambda score: int -> str {
+        if score >= 90 {
+            return "A";
+        } elif score >= 80 {
+            return "B";
+        } elif score >= 70 {
+            return "C";
+        } else {
+            return "F";
+        }
+    };
+
+    print("Test 2 - Grade for 85:", get_grade(85));
+    print("Test 2 - Grade for 95:", get_grade(95));
+    print("Test 2 - Grade for 65:", get_grade(65));
+    # Expected: B, A, F
+
+    # Test 3: Lambda with loop
+    let sum_range = lambda n: int -> int {
+        let total = 0;
+        let i = 0;
+        while i < n {
+            total = total + i;
+            i = i + 1;
+        }
+        return total;
+    };
+
+    print("Test 3 - Sum of 0 to 9:", sum_range(10));
+    # Expected: 45
+
+    # Test 4: Lambda with multiple statements and variables
+    let complex_calc = lambda a: int, b: int, c: int -> int {
+        let x = a * 2;
+        let y = b + 10;
+        let z = c - 5;
+        let result = x + y + z;
+        return result;
+    };
+
+    print("Test 4 - Complex calculation (5, 3, 8):", complex_calc(5, 3, 8));
+    # Expected: (10 + 13 + 3) = 26
+
+    # Test 5: Lambda that returns another lambda
+    let make_adder = lambda x: int {
+        return lambda y: int: x + y;
+    };
+
+    let add_five = make_adder(5);
+    print("Test 5 - add_five(10):", add_five(10));
+    # Expected: 15
+
+    # Test 6: Lambda with try-catch
+    let safe_divide = lambda a: int, b: int -> str {
+        try {
+            let result = a / b;
+            return f"Result: {result}";
+        } except Exception {
+            return "Division by zero error";
+        }
+    };
+
+    print("Test 6 - safe_divide(10, 2):", safe_divide(10, 2));
+    print("Test 6 - safe_divide(10, 0):", safe_divide(10, 0));
+    # Expected: Result: 5.0, Division by zero error
+
+    # Test 7: Lambda as higher-order function argument
+    let apply_operation = lambda x: int, y: int -> int {
+        let multiply = lambda a: int, b: int -> int {
+            let result = a * b;
+            return result;
+        };
+        return multiply(x, y);
+    };
+
+    print("Test 7 - apply_operation(6, 7):", apply_operation(6, 7));
+    # Expected: 42
+
+    # Test 8: Lambda with list operations
+    let process_list = lambda items: list {
+        let result = [];
+        for item in items {
+            result.append(item * 2);
+        }
+        return result;
+    };
+
+    print("Test 8 - process_list([1, 2, 3, 4]):", process_list([1, 2, 3, 4]));
+    # Expected: [2, 4, 6, 8]
+
+    # Test 9: Lambda with explicit function signature syntax
+    let format_pair = lambda (first: str, second: str) -> str {
+        let separator = "-";
+        return first + separator + second;
+    };
+
+    print("Test 9 - format_pair('foo', 'bar'):", format_pair("foo", "bar"));
+    # Expected: foo-bar
+
+    print("\nAll multi-statement lambda tests completed!");
+}

jaclang/tests/fixtures/multistatement_lambda_client.jac

@@ -0,0 +1,113 @@
+"""Test multi-statement lambda expressions for client-side (JavaScript) execution."""
+
+cl with entry {
+    # Test 1: Basic multi-statement lambda
+    let add_and_multiply = lambda x: int, y: int -> int {
+        let sum = x + y;
+        let product = x * y;
+        return sum + product;
+    };
+
+    let result1 = add_and_multiply(3, 4);
+    print("Test 1 - Multi-statement lambda (3 + 4) + (3 * 4):", result1);
+    # Expected: 19 (7 + 12)
+
+    # Test 2: Lambda with conditional logic
+    let get_grade = lambda score: int -> str {
+        if score >= 90 {
+            return "A";
+        } elif score >= 80 {
+            return "B";
+        } elif score >= 70 {
+            return "C";
+        } else {
+            return "F";
+        }
+    };
+
+    print("Test 2 - Grade for 85:", get_grade(85));
+    print("Test 2 - Grade for 95:", get_grade(95));
+    print("Test 2 - Grade for 65:", get_grade(65));
+    # Expected: B, A, F
+
+    # Test 3: Lambda with loop
+    let sum_range = lambda n: int -> int {
+        let total = 0;
+        let i = 0;
+        while i < n {
+            total = total + i;
+            i = i + 1;
+        }
+        return total;
+    };
+
+    print("Test 3 - Sum of 0 to 9:", sum_range(10));
+    # Expected: 45
+
+    # Test 4: Lambda with multiple statements and variables
+    let complex_calc = lambda a: int, b: int, c: int -> int {
+        let x = a * 2;
+        let y = b + 10;
+        let z = c - 5;
+        let result = x + y + z;
+        return result;
+    };
+
+    print("Test 4 - Complex calculation (5, 3, 8):", complex_calc(5, 3, 8));
+    # Expected: (10 + 13 + 3) = 26
+
+    # Test 5: Lambda that returns another lambda
+    let make_adder = lambda x: int {
+        return lambda y: int: x + y;
+    };
+
+    let add_five = make_adder(5);
+    print("Test 5 - add_five(10):", add_five(10));
+    # Expected: 15
+
+    # Test 6: Lambda as higher-order function argument
+    let apply_operation = lambda op: any, x: int, y: int -> int {
+        return op(x, y);
+    };
+
+    let multiply_op = lambda a: int, b: int -> int {
+        let result = a * b;
+        return result;
+    };
+
+    print("Test 6 - apply_operation with multiply:", apply_operation(multiply_op, 6, 7));
+    # Expected: 42
+
+    # Test 7: Lambda with array operations
+    let process_list = lambda items: list {
+        let result = [];
+        for item in items {
+            result.append(item * 2);
+        }
+        return result;
+    };
+
+    print("Test 7 - process_list([1, 2, 3, 4]):", process_list([1, 2, 3, 4]));
+    # Expected: [2, 4, 6, 8]
+
+    # Test 8: Lambda with string concatenation
+    let format_name = lambda first: str, last: str -> str {
+        let space = " ";
+        let full_name = first + space + last;
+        return full_name;
+    };
+
+    print("Test 8 - format_name('John', 'Doe'):", format_name("John", "Doe"));
+    # Expected: John Doe
+
+    # Test 9: Lambda with explicit function signature syntax
+    let join_labels = lambda (left: str, right: str) -> str {
+        let delimiter = " :: ";
+        return left + delimiter + right;
+    };
+
+    print("Test 9 - join_labels('alpha', 'beta'):", join_labels("alpha", "beta"));
+    # Expected: alpha :: beta
+
+    print("\nAll client-side multi-statement lambda tests completed!");
+}

jaclang/tests/fixtures/needs_import_dup.jac

@@ -1,17 +1,19 @@
 """Test of jac importing python."""
 import os;
-import pyfunc;
+import jaclang.tests.fixtures.pyfunc as pyfunc;
 import random;
-import from pyfunc { my_print }
+import from jaclang.tests.fixtures.pyfunc { my_print }
 
 with entry {
 
+    pyfunc.__name__ = "pyfunc";
+    pyfunc.__spec__ = None;
     my_print(pyfunc);
     print(random.random());
 }
 
-import circle_pysolo;
-import from circle_pysolo { calculate_area }
+import jaclang.tests.fixtures.circle_pysolo;
+import from jaclang.tests.fixtures.circle_pysolo { calculate_area }
 
 with entry {
     print(f"are {calculate_area(2.0)}");

jaclang/tests/fixtures/py_run.py

@@ -1,8 +1,9 @@
-# Print Hello, World!
-print("Hello, World!")
+"""Simple Python script used by CLI integration tests."""
 
 a = 5
 b = 3
+
+print("Hello, World!")
 sum_ab = a + b
 print("Sum:", sum_ab)
 
@@ -12,12 +13,13 @@ if num % 2 == 0:
 else:
     print(num, "is odd")
 
-# Loop through a list
 fruits = ["apple", "banana", "cherry"]
 for fruit in fruits:
     print(fruit)
 
-def greet(name):
+
+def greet(name: str) -> str:
     return f"Hello, {name}!"
 
-print(greet("Alice"))
+
+print(greet("Alice"))

jaclang/tests/fixtures/pyfunc_fstr.py

@@ -21,5 +21,5 @@ print(f"Hello {name} , yoo {relation} is {mom_name}. Myself, I am {name}.")
 item = "Apple"
 price = 1.23
 
-print(f"Left aligned: {item:<10} | Price: {price:.2f}")
-print(f"{name = } 🤔") 
+print(f"Left aligned: {item:<10}".rstrip() + f" | Price: {price:.2f}")
+print(f"name = {name} 🤔")

jaclang/tests/fixtures/simple_lambda_test.jac

@@ -0,0 +1,12 @@
+"""Simple test for multi-statement lambda."""
+
+with entry {
+    # Test 1: Basic multi-statement lambda
+    let add = lambda x: int, y: int -> int {
+        let sum = x + y;
+        return sum;
+    };
+
+    let result = add(3, 4);
+    print("Result:", result);
+}

jaclang/tests/test_cli.py

@@ -674,7 +674,7 @@ class JacCliTests(TestCase):
         self.assertEqual(
             process.returncode, 1, "run command should exit with code 1 on syntax error"
         )
-        self.assertIn("Error running", stderr)
+        self.assertIn("Error", stderr)
 
         # Test build command with syntax error
         process = subprocess.Popen(

jaclang/tests/test_language.py

@@ -346,7 +346,10 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("one level deeperslHello World!", stdout_value)
-        self.assertIn("module 'pyfunc' from ", stdout_value)
+        self.assertTrue(
+            "module 'pyfunc' from " in stdout_value
+            or "module 'jaclang.tests.fixtures.pyfunc' from " in stdout_value
+        )
 
     def test_deep_outer_imports_from_loc(self) -> None:
         """Parse micro jac file."""
@@ -357,7 +360,10 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("one level deeperslHello World!", stdout_value)
-        self.assertIn("module 'pyfunc' from ", stdout_value)
+        self.assertTrue(
+            "module 'jaclang.tests.fixtures.pyfunc' from " in stdout_value
+            or "module 'pyfunc' from " in stdout_value
+        )
 
     def test_has_lambda_goodness(self) -> None:
         """Test has lambda_goodness."""
@@ -551,7 +557,7 @@ class JacLanguageTests(TestCase):
                 ),
                 prog=JacProgram(),
             ).ir_out.unparse()
-        self.assertIn("class X {\n    with entry {\n        a_b = 67;", output)
+        self.assertIn("class X {\n    with entry {\n        let a_b = 67;", output)
         self.assertIn("br = b'Hello\\\\\\\\nWorld'", output)
         self.assertIn(
             "class Circle {\n    def init(self: Circle, radius: float", output
@@ -1604,39 +1610,4 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Matched a.b.c Hello Jaseci!", stdout_value[0])
-        
-    def test_known_builtins_matches_actual(self) -> None:
-        """Test that KNOWN_BUILTINS in PyastGenPass matches actual builtins."""
-        from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
-        import jaclang.runtimelib.builtin as builtin_module
-
-        # Get actual builtins from the module (excluding private members)
-        actual_builtins = {
-            name for name in builtin_module.__all__
-            if not name.startswith('_')
-        }
-
-        # Exceptions: builtins that are imported from other sources
-        # - Enum: imported via needs_enum() from standard library's enum module
-        exceptions = {'Enum'}
-        actual_builtins_to_check = actual_builtins - exceptions
-
-        # Get the KNOWN_BUILTINS set from PyastGenPass
-        known_builtins = PyastGenPass.KNOWN_BUILTINS
-
-        # Find missing and extra builtins
-        missing = actual_builtins_to_check - known_builtins
-        extra = known_builtins - actual_builtins_to_check
-
-        # Build error message
-        error_msg = []
-        if missing:
-            error_msg.append(f"Missing from KNOWN_BUILTINS: {sorted(missing)}")
-        if extra:
-            error_msg.append(f"Extra in KNOWN_BUILTINS (not in builtin module): {sorted(extra)}")
-
-        # Assert they match
-        self.assertEqual(
-            known_builtins, actual_builtins_to_check,
-            "\n".join(error_msg) if error_msg else ""
-        )
+