jaclang 0.8.7__py3-none-any.whl → 0.8.8__py3-none-any.whl

jaclang/tests/fixtures/params/test_failing_varargs.jac

@@ -0,0 +1,300 @@
+# Test failing variable arguments cases (*args, **kwargs)
+
+def simple_args_only(*args: int) -> int {
+    return sum(args);
+}
+
+def simple_kwargs_only(**kwargs: str) -> int {
+    return len(kwargs);
+}
+
+def args_with_required(req: str, *args: int) -> str {
+    return f"{req}: {sum(args)}";
+}
+
+def kwargs_with_required(req: int, **kwargs: str) -> dict {
+    return {"req": req, "kwargs": kwargs};
+}
+
+def full_varargs_signature(
+    pos: int,
+    /,
+    reg: str,
+    def_param: float = 1.0,
+    *args: int,
+    kw_req: bool,
+    kw_opt: str = "default",
+    **kwargs: any
+) -> dict {
+    return {
+        "pos": pos, "reg": reg, "def_param": def_param,
+        "args": list(args), "kw_req": kw_req, "kw_opt": kw_opt, "kwargs": kwargs
+    };
+}
+
+def conflicting_names(name: str, *args: str, name_kw: str, **kwargs: str) -> dict {
+    return {"name": name, "args": list(args), "name_kw": name_kw, "kwargs": kwargs};
+}
+
+def type_sensitive_varargs(*args: int, **kwargs: int) -> dict {
+    return {"args_sum": sum(args), "kwargs_sum": sum(kwargs.values())};
+}
+
+def edge_case_empty_varargs(required: str, *args: float, **kwargs: bool) -> str {
+    return f"{required}: args={len(args)}, kwargs={len(kwargs)}";
+}
+
+def double_star_issues(**kwargs: dict) -> int {
+    total = 0;
+    for (k, v) in kwargs.items() {
+        if isinstance(v, dict) {
+            total += len(v);
+        } else {
+            total += 1;
+        }
+    }
+    return total;
+}
+
+def additional_varargs_edge_cases() -> None {
+    print("\n=== ADDITIONAL VARARGS EDGE CASES ===");
+    
+    # Test 16: Empty containers passed to varargs
+    def test_empty_containers(*args: list, **kwargs: dict) -> dict {
+        return {"args_count": len(args), "kwargs_count": len(kwargs)};
+    }
+    
+    try {
+        result = test_empty_containers([], {}, third_arg=[]);
+        print("✅ PASS: Empty containers:", result);
+    } except Exception as e {
+        print("❌ FAIL: Empty containers failed");
+    }
+    
+    # Test 17: Nested data structures
+    def complex_data_varargs(*args: dict, **kwargs: list) -> dict {
+        return {"total_keys": sum(args), "total_items": len(kwargs)};
+    }
+    
+    try {
+        result = complex_data_varargs(
+            12,
+            16,
+            list1=[1, 2, 3],
+            list2=[4, 5]
+        );
+        print("✅ PASS: Complex data structures:", result);
+    } except Exception as e {
+        print("❌ FAIL: Complex data structures failed");
+    }
+    
+    # Test 18: Special character handling in kwargs keys
+    def special_chars_kwargs(**kwargs: str) -> dict {
+        return {"keys": list(kwargs.keys()), "count": len(kwargs)};
+    }
+    
+    try {
+        # Note: Most of these won't work as valid identifiers, but let's test what we can
+        result = special_chars_kwargs(normal="value", with_underscore="test");
+        print("✅ PASS: Special chars in kwargs:", result);
+    } except Exception as e {
+        print("❌ FAIL: Special chars failed");
+    }
+    
+    # Test 19: Very large argument counts
+    def stress_test_args(*args: int) -> dict {
+        return {"count": len(args), "sum": sum(args), "avg": sum(args)/len(args) if args else 0};
+    }
+    
+    try {
+        large_args = list(range(100));  # 100 arguments
+        result = stress_test_args(*large_args);
+        print("✅ PASS: Large arg count:", f"count={result['count']}, avg={result['avg']}");
+    } except Exception as e {
+        print("❌ FAIL: Large arg count failed");
+    }
+    
+    # Test 20: Mixing unpacking with explicit args
+    def mixed_unpacking_test(first: str, *args: int, last: str, **kwargs: bool) -> dict {
+        _sum = sum(args);
+        _kwargs_true_count = 0;
+        for v in kwargs.values() {
+            if v {
+                _kwargs_true_count += 1;
+            }
+        }
+        return {
+            "first": first,
+            "args_sum": _sum,
+            "last": last,
+            "kwargs_true_count": _kwargs_true_count
+        };
+    }
+    
+    try {
+        numbers = [10, 20, 30];
+        flags = {"debug": True, "verbose": False, "strict": True};
+        result = mixed_unpacking_test("start", *numbers, last="end", **flags);
+        print("✅ PASS: Mixed unpacking:", result);
+    } except Exception as e {
+        print("❌ FAIL: Mixed unpacking failed");
+    }
+    
+    # Test 21: Recursive function with varargs
+    def recursive_varargs(depth: int, *args: str, **kwargs: int) -> dict {
+        if depth <= 0 or not args {
+            return {"depth": depth, "args": list(args), "kwargs": kwargs};
+        }
+        
+        new_args = args[1:];  # Remove first arg
+        new_kwargs = {k: v+1 for (k, v) in kwargs.items()};  # Increment all values
+        
+        return recursive_varargs(depth-1, *new_args, **new_kwargs);
+    }
+    
+    try {
+        result = recursive_varargs(3, "a", "b", "c", "d", x=1, y=2);
+        print("✅ PASS: Recursive varargs:", result);
+    } except Exception as e {
+        print("❌ FAIL: Recursive varargs failed");
+    }
+}
+
+with entry {
+    print("=== TESTING VARIABLE ARGUMENTS FAILURES ===");
+    
+    # Test 1: Wrong types in *args (if type checking enabled)
+    try {
+        result = simple_args_only(1, 2, "not_int", 4);
+        print("❌ FAIL: Should catch mixed types in *args");
+    } except Exception as e {
+        print("✅ PASS: Caught *args type error");
+    }
+    
+    # Test 2: Wrong types in **kwargs (if type checking enabled)
+    try {
+        result = simple_kwargs_only(12,a="string", b=123, c="string");
+        print("❌ FAIL: Should catch mixed types in **kwargs");
+    } except Exception as e {
+        print("✅ PASS: Caught **kwargs type error");
+    }
+    
+    # Test 3: Missing required before *args
+    try {
+        result = args_with_required(1, 2, 3, apple=90);
+    } except Exception as e {
+        print("✅ PASS: Caught required param type error");
+    }
+    
+    # Test 4: Missing required before **kwargs
+    try {
+        result = kwargs_with_required(name="test", value="data");
+        print("❌ FAIL: Should catch wrong types for required");
+    } except Exception as e {
+        print("✅ PASS: Caught required before kwargs error");
+    }
+    
+    # Test 5: Complex signature - pos-only passed as keyword
+    try {
+        result = full_varargs_signature(
+            pos=1, reg="test", kw_req=True
+        );
+        print("❌ FAIL: Should reject pos-only as keyword in varargs");
+    } except Exception as e {
+        print("✅ PASS: Caught pos-only in varargs error");
+    }
+    
+    # Test 6: Complex signature - missing required kw-only
+    try {
+        result = full_varargs_signature(1, "test", 2.0, 10, 20);
+        print("❌ FAIL: Should reject missing kw-only in varargs");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only in varargs");
+    }
+    
+    # Test 7: Name conflicts between params and kwargs
+    try {
+        result = conflicting_names("test", "arg1", name_kw="kw_test", name="conflict");
+        print("❌ FAIL: Should catch parameter name conflicts");
+    } except Exception as e {
+        print("✅ PASS: Caught name conflict error");
+    }
+    
+    # Test 8: Type-sensitive varargs with wrong types
+    try {
+        result = type_sensitive_varargs(1, 2, 3, a="not_int", b=4.5);
+        print("❌ FAIL: Should catch type mismatch in kwargs");
+    } except Exception as e {
+        print("✅ PASS: Caught varargs type sensitivity error");
+    }
+    
+
+    # Test 9: Double unpacking issues
+    try {
+        data = {"a": {"nested": "dict"}, "b": "simple"};
+        result = double_star_issues(**data);
+        print("✅ INFO: Double star result:", result);
+    } except Exception as e {
+        print("✅ PASS: Caught double star error");
+    }
+    
+    # Test 10: Empty varargs but required params missing
+    try {
+        result = edge_case_empty_varargs();
+        print("❌ FAIL: Should catch missing required with empty varargs");
+    } except Exception as e {
+        print("✅ PASS: Caught missing required in empty varargs");
+    }
+    
+    
+    # Test 11: Keyword argument conflicts with *args collection
+    try {
+        items = [1, 2, 3];
+        result = args_with_required("test", *items, args="conflict");
+        print("❌ FAIL: Should catch args name conflict");
+    } except Exception as e {
+        print("✅ PASS: Caught args conflict error");
+    }
+    
+    # Test 12: **kwargs conflicts with explicit keywords
+    try {
+        extra_data = {"kw_req": True, "extra": "data"};
+        result = full_varargs_signature(1, "test", kw_req=False, **extra_data);
+        print("❌ FAIL: Should catch kwargs conflict with explicit");
+    } except Exception as e {
+        print("✅ PASS: Caught kwargs explicit conflict");
+    }
+    
+    # Test 13: Valid calls that should work
+    try {
+        result = simple_args_only(1, 2, 3, 4, 5);
+        print("✅ PASS: Valid *args call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid *args call rejected");
+    }
+    
+    try {
+        result = simple_kwargs_only(a="test", b="data", c="more");
+        print("✅ PASS: Valid **kwargs call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid **kwargs call rejected");
+    }
+    
+    try {
+        result = full_varargs_signature(
+            1,                    # pos (pos-only)
+            "regular",           # reg
+            2.5,                 # def_param
+            10, 20, 30,          # *args
+            kw_req=True,         # kw_req (required kw-only)
+            kw_opt="custom",     # kw_opt (optional kw-only)
+            extra="data",        # **kwargs
+            more="info"
+        );
+        print("✅ PASS: Valid complex varargs call keys:", list(result.keys()));
+    } except Exception as e {
+        print("❌ FAIL: Valid complex varargs rejected");
+    }
+    
+    additional_varargs_edge_cases();
+}

jaclang/tests/fixtures/params/test_kwonly_params.jac

@@ -0,0 +1,29 @@
+# Test keyword-only parameters
+
+def simple_kwonly(*, x: int) -> int {
+    return x;
+}
+
+def kwonly_with_defaults(*, x: int = 10, y: str = "def") -> str {
+    return f"{x}-{y}";
+}
+
+def regular_plus_kwonly(normal: int, *, kw: str) -> str {
+    return f"{normal}|{kw}";
+}
+
+def mixed_kwonly(pos: int, reg: str = "def", *, kw1: float, kw2: bool = True) -> str {
+    return f"{pos}-{reg}-{kw1}-{kw2}";
+}
+
+def all_kwonly(*, a: int, b: str = "test", c: float = 1.0) -> str {
+    return f"{a}:{b}:{c}";
+}
+
+with entry {
+    print("KW_SIMPLE:", simple_kwonly(x=42));
+    print("KW_DEF:", kwonly_with_defaults(), kwonly_with_defaults(x=20));
+    print("REG_KW:", regular_plus_kwonly(10, kw="test"));
+    print("MIXED_KW:", mixed_kwonly(1, kw1=2.5), mixed_kwonly(2, "custom", kw1=3.5, kw2=False));
+    print("ALL_KW:", all_kwonly(a=100), all_kwonly(a=200, b="hi", c=9.9));
+}

jaclang/tests/fixtures/py2jac_params.py

@@ -0,0 +1,8 @@
+from typing_extensions import TypeAlias
+import collections.abc
+
+_ClassInfo: TypeAlias = type | tuple[object, ...]
+Sized = collections.abc.Sized
+
+def isinstance(obj: object, class_or_tuple: _ClassInfo, /) -> bool: ...
+def len(obj: Sized,astt ,/, z: int, j: str,a= 90) -> int: ...

jaclang/tests/fixtures/run_test.jac

@@ -1,17 +1,17 @@
 glob a = 5, b = 2;
 
 test t1 {
-    check almostEqual(a, 6);
+    assert almostEqual(a, 6);
 }
 
 test t2 {
-    check a != b;
+    assert a != b;
 }
 
 test t3 {
-    check "d" in "abc";
+    assert "d" in "abc";
 }
 
 test t4 {
-    check a - b == 3;
+    assert a - b == 3;
 }

jaclang/tests/test_cli.py

@@ -7,6 +7,7 @@ import os
 import re
 import subprocess
 import sys
+import tempfile
 import traceback
 import unittest
 from jaclang.cli import cli
@@ -432,6 +433,41 @@ class JacCliTests(TestCase):
             "sorted(users, key=lambda x: x['email'], reverse=True)", stdout_value
         )
 
+    def test_param_arg(self) -> None:
+        """Test for lambda argument annotation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        from jaclang.compiler.program import JacProgram
+        
+        filename = self.fixture_abs_path('../../tests/fixtures/params/test_complex_params.jac')
+        cli.jac2py(f"{self.fixture_abs_path('../../tests/fixtures/params/test_complex_params.jac')}")
+        py_code = JacProgram().compile(file_path=filename).gen.py
+        
+        # Create temporary Python file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
+            temp_file.write(py_code)
+            py_file_path = temp_file.name
+        
+        try:
+            jac_code = JacProgram().compile(use_str=py_code, file_path=py_file_path).unparse()
+            # Create temporary Jac file
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.jac', delete=False) as temp_file:
+                temp_file.write(jac_code)
+                jac_file_path = temp_file.name
+            cli.run(jac_file_path)
+        finally:
+                os.remove(py_file_path)
+                os.remove(jac_file_path)
+        
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("ULTIMATE_MIN: 1|def|2.5|0|test|100|0", stdout_value[-7])
+        self.assertEqual("ULTIMATE_FULL: 1|custom|3.14|3|req|200|1", stdout_value[-6])
+        self.assertEqual("SEPARATORS: 42", stdout_value[-5])
+        self.assertEqual("EDGE_MIX: 1-test-2-True-1", stdout_value[-4])
+        self.assertEqual("RECURSIVE: 7 11", stdout_value[-3])
+        self.assertEqual("VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[-2])
+
     def test_caching_issue(self) -> None:
         """Test for Caching Issue."""
         test_file = self.fixture_abs_path("test_caching_issue.jac")
@@ -441,7 +477,7 @@ class JacCliTests(TestCase):
                 f.write(
                     f"""
                 test mytest{{
-                    check 10 == {x};
+                    assert 10 == {x};
                 }}
                 """
                 )

jaclang/tests/test_language.py

@@ -3,7 +3,7 @@
 import io
 import os
 import sys
-import sysconfig
+import pytest
 import tempfile
 import subprocess
 from pathlib import Path
@@ -514,14 +514,13 @@ class JacLanguageTests(TestCase):
                 ),
                 prog=JacProgram(),
             ).ir_out.unparse()
-        self.assertIn("def greet2(**kwargs: Any)", output)
+        self.assertIn("def greet2( **kwargs: Any) {", output)
         self.assertEqual(output.count("with entry {"), 14)
         self.assertIn("assert (x == 5) , 'x should be equal to 5' ;", output)
         self.assertIn("if not (x == y) {", output)
-        self.assertIn("def greet2(**kwargs: Any) {", output)
-        self.assertIn("squares_dict = { x : (x ** 2) for x in numbers };", output)
+        self.assertIn("squares_dict = {x : (x ** 2) for x in numbers};", output)
         self.assertIn(
-            '\n\n"""Say hello"""\n@ my_decorator\n\n def say_hello() {', output
+            '\n\n"""Say hello"""\n@my_decorator\n\n def say_hello() {', output
         )
 
     def test_pyfunc_2(self) -> None:
@@ -589,6 +588,27 @@ class JacLanguageTests(TestCase):
         self.assertIn("case Container(inner = Inner(x = a, y = b)):\n", output)
         self.assertIn("case _:\n", output)
 
+    def test_py2jac_params(self) -> None:
+        """Test py ast to Jac ast conversion."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as ast
+        import ast as py_ast
+
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py2jac_params.py")
+        with open(py_out_path) as f:
+            file_source = f.read()
+            output = PyastBuildPass(
+                ir_in=ast.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=ast.Source(file_source, py_out_path),
+                ),
+                prog=None,
+            ).ir_out.unparse()
+        self.assertIn(
+            "def isinstance( <>obj: object , class_or_tuple: _ClassInfo , /)  -> bool {", output)
+        self.assertIn(
+            "def len(<>obj: Sized, astt: Any, /, z: int, j: str, a: Any = 90) -> int {", output)
+
     def test_refs_target(self) -> None:
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
@@ -712,6 +732,7 @@ class JacLanguageTests(TestCase):
         mypass = JacProgram().compile(self.fixture_abs_path("byllmissue.jac"))
         self.assertIn("2:5 - 4:8", mypass.pp())
 
+    @pytest.mark.xfail(reason="TODO: Support symtable for inheritance")
     def test_inherit_baseclass_sym(self) -> None:
         """Basic test for symtable support for inheritance."""
         mypass = JacProgram().compile(
@@ -746,6 +767,43 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue()
         self.assertIn("i work", stdout_value)
 
+    def test_kwonly_params(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("test_kwonly_params", base_path=self.fixture_abs_path("./params"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("KW_SIMPLE: 42", stdout_value[0])
+        self.assertEqual("KW_DEF: 10-def 20-def", stdout_value[1])
+        self.assertEqual("REG_KW: 10|test", stdout_value[2])
+        self.assertEqual("MIXED_KW: 1-def-2.5-True 2-custom-3.5-False", stdout_value[3])
+        self.assertEqual("ALL_KW: 100:test:1.0 200:hi:9.9", stdout_value[4])
+
+    def test_complex_params(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("test_complex_params", base_path=self.fixture_abs_path("./params"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("ULTIMATE_MIN: 1|def|2.5|0|test|100|0", stdout_value[0])
+        self.assertEqual("ULTIMATE_FULL: 1|custom|3.14|3|req|200|1", stdout_value[1])
+        self.assertEqual("SEPARATORS: 42", stdout_value[2])
+        self.assertEqual("EDGE_MIX: 1-test-2-True-1", stdout_value[3])
+        self.assertEqual("RECURSIVE: 7 11", stdout_value[4])
+        self.assertEqual("VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[5])
+
+    def test_param_failing(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        for i in ["test_failing_posonly", "test_failing_kwonly", "test_failing_varargs"]:
+            Jac.jac_import(i, base_path=self.fixture_abs_path("./params"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertNotIn('FAILED', stdout_value)
+
     def test_double_import_exec(self) -> None:
         """Test importing python."""
         captured_output = io.StringIO()
@@ -1238,9 +1296,9 @@ class JacLanguageTests(TestCase):
             ).ir_out.unparse()
         self.assertIn("(prev_token_index is None)", output)
         self.assertIn("(next_token_index is None)", output)
-        self.assertIn("(tok[ 0 ] > change_end_line)", output)
-        self.assertIn("(tok[ 0 ] == change_end_line)", output)
-        self.assertIn("(tok[ 1 ] > change_end_char)", output)
+        self.assertIn("(tok[0] > change_end_line)", output)
+        self.assertIn("(tok[0] == change_end_line)", output)
+        self.assertIn("(tok[1] > change_end_char)", output)
 
     def test_here_visitor_usage(self) -> None:
         """Test visitor, here keyword usage in jaclang."""
@@ -1378,7 +1436,7 @@ class JacLanguageTests(TestCase):
             test_content = "Hello, 世界! 🌍 Testing UTF-8 encoding."
             f.write(test_content)
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertEqual(result, test_content)
@@ -1391,7 +1449,7 @@ class JacLanguageTests(TestCase):
             test_content = "Hello, 世界! UTF-16 encoding test."
             f.write(test_content)
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertEqual(result, test_content)
@@ -1404,7 +1462,7 @@ class JacLanguageTests(TestCase):
             test_content = "Hello, UTF-8 BOM test! 🚀"
             f.write(test_content)
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertEqual(result, test_content)
@@ -1431,9 +1489,9 @@ class JacLanguageTests(TestCase):
         with tempfile.NamedTemporaryFile(delete=False) as f:
             binary_data = bytes([0xFF, 0xFE, 0x00, 0x48, 0x65, 0x6C, 0x6C, 0x6F])
             f.write(binary_data)
-            f.flush()  
+            f.flush()
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertIsInstance(result, str)
@@ -1446,15 +1504,15 @@ class JacLanguageTests(TestCase):
         with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
             test_content = (
                 "Special chars: åäö ñ ü ç é\n"
-                "Symbols: ©®™ §¶†‡•\n" 
+                "Symbols: ©®™ §¶†‡•\n"
                 "Math: ∑∏∫√±≤≥≠\n"
                 "Arrows: ←→↑↓↔\n"
                 "Emoji: 😀😍🎉🔥💯\n"
             )
             f.write(test_content)
-            f.flush()  
+            f.flush()
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
 

jaclang/utils/helpers.py

@@ -192,6 +192,37 @@ def dump_traceback(e: Exception) -> str:
     return trace_dump
 
 
+# FIXME: Use a proper color library and/or move this somewhere common to jac stack and use it everywhere.
+# Reference: https://gist.github.com/rene-d/9e584a7dd2935d0f461904b9f2950007
+class ANSIColors:
+    """ANSI color codes."""
+
+    BLACK = "\033[0;30m"
+    RED = "\033[0;31m"
+    GREEN = "\033[0;32m"
+    BROWN = "\033[0;33m"
+    BLUE = "\033[0;34m"
+    PURPLE = "\033[0;35m"
+    CYAN = "\033[0;36m"
+    LIGHT_GRAY = "\033[0;37m"
+    DARK_GRAY = "\033[1;30m"
+    LIGHT_RED = "\033[1;31m"
+    LIGHT_GREEN = "\033[1;32m"
+    YELLOW = "\033[1;33m"
+    LIGHT_BLUE = "\033[1;34m"
+    LIGHT_PURPLE = "\033[1;35m"
+    LIGHT_CYAN = "\033[1;36m"
+    LIGHT_WHITE = "\033[1;37m"
+    BOLD = "\033[1m"
+    FAINT = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+    BLINK = "\033[5m"
+    NEGATIVE = "\033[7m"
+    CROSSED = "\033[9m"
+    END = "\033[0m"
+
+
 # TODO: After implementing the TextRange (or simillar named) class to mark a text range
 # refactor the parameter to accept an instace of that text range object.
 def pretty_print_source_location(
@@ -200,6 +231,8 @@ def pretty_print_source_location(
     error_line: int,
     pos_start: int,
     pos_end: int,
+    *,
+    colors: bool = False,
 ) -> str:
     """Pretty print internal method for the pretty_print method."""
     # NOTE: The Line numbers and the column numbers are starts with 1.
@@ -241,7 +274,16 @@ def pretty_print_source_location(
         idx_line_start = idx
         while idx < len(file_source) and file_source[idx] != "\n":
             idx += 1  # Run to the line end.
-        pretty_dump += file_source[idx_line_start:idx]
+
+        if colors and (curr_line == error_line):
+            pretty_dump += (
+                file_source[idx_line_start:pos_start]
+                + f"{ANSIColors.RED}{file_source[pos_start:pos_end]}{ANSIColors.END}"
+                + file_source[pos_end:idx]
+            )
+        else:
+            pretty_dump += file_source[idx_line_start:idx]
+
         pretty_dump += "\n"
 
         if curr_line == error_line:  # Print the current line with indicator.
@@ -252,7 +294,10 @@ def pretty_print_source_location(
                 spaces += "\t" if file_source[idx_pre] == "\t" else " "
 
             err_token_len = pos_end - pos_start
-            pretty_dump += spaces + ("^" * err_token_len) + "\n"
+            underline = "^" * err_token_len
+            if colors:
+                underline = f"{ANSIColors.RED}{underline}{ANSIColors.END}"
+            pretty_dump += spaces + underline + "\n"
 
         if idx == len(file_source):
             break

jaclang/utils/module_resolver.py

@@ -30,6 +30,16 @@ def get_jac_search_paths(base_path: Optional[str] = None) -> list[str]:
     return list(dict.fromkeys(filter(None, paths)))
 
 
+# TODO: need to be removed once python modules are fully supported in jac
+def get_py_search_paths(base_path: Optional[str] = None) -> list[str]:
+    """Construct a list of paths to search for Python modules."""
+    paths = []
+    if base_path:
+        paths.append(base_path)
+    paths.append(os.getcwd())
+    return list(dict.fromkeys(filter(None, paths)))
+
+
 def _candidate_from(base: str, parts: list[str]) -> Optional[Tuple[str, str]]:
     candidate = os.path.join(base, *parts)
     if os.path.isdir(candidate):