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

jaclang/compiler/passes/main/tests/test_predynamo_pass.py

@@ -4,7 +4,7 @@ import io
 import os
 import sys
 
-from jaclang.compiler.program import JacProgram
+from jaclang.compiler.program import JacProgram, py_code_gen
 from jaclang.utils.test import TestCase
 from jaclang.settings import settings
 from jaclang.compiler.passes.main import PreDynamoPass
@@ -16,42 +16,41 @@ class PreDynamoPassTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
+        settings.predynamo_pass = True
         return super().setUp()
-    
+
+    def tearDown(self) -> None:
+        """Tear down test."""
+        settings.predynamo_pass = False
+        # Remove PreDynamoPass from global py_code_gen list if it was added
+        if PreDynamoPass in py_code_gen:
+            py_code_gen.remove(PreDynamoPass)
+        return super().tearDown()
+
     def test_predynamo_where_assign(self) -> None:
         """Test torch.where transformation."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        os.environ["JAC_PREDYNAMO_PASS"] = "True"
-        settings.load_env_vars()
+        settings.predynamo_pass = True
         code_gen = JacProgram().compile(self.fixture_abs_path("predynamo_where_assign.jac"))
         sys.stdout = sys.__stdout__
         self.assertIn("torch.where", code_gen.unparse())
-        os.environ["JAC_PREDYNAMO_PASS"] = "false"
-        settings.load_env_vars()
         
     def test_predynamo_where_return(self) -> None:
         """Test torch.where transformation."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        os.environ["JAC_PREDYNAMO_PASS"] = "True"
-        settings.load_env_vars()
         code_gen = JacProgram().compile(self.fixture_abs_path("predynamo_where_return.jac"))
         sys.stdout = sys.__stdout__
         self.assertIn("torch.where", code_gen.unparse())
-        os.environ["JAC_PREDYNAMO_PASS"] = "false"
-        settings.load_env_vars()
+
 
     def test_predynamo_fix3(self) -> None:
         """Test torch.where transformation."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        os.environ["JAC_PREDYNAMO_PASS"] = "True"
-        settings.load_env_vars()
         code_gen = JacProgram().compile(self.fixture_abs_path("predynamo_fix3.jac"))
         sys.stdout = sys.__stdout__
         unparsed_code = code_gen.unparse()
         self.assertIn("__inv_freq = torch.where(", unparsed_code)
         self.assertIn("self.register_buffer('inv_freq', __inv_freq, persistent=False);", unparsed_code)
-        os.environ["JAC_PREDYNAMO_PASS"] = "false"
-        settings.load_env_vars()

jaclang/compiler/passes/tool/doc_ir_gen_pass.py

@@ -135,20 +135,53 @@ class DocIRGenPass(UniPass):
     def exit_import(self, node: uni.Import) -> None:
         """Exit import node."""
         parts: list[doc.DocType] = []
+        mod_items: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
+        is_in_items: bool = False
         for i in node.kid:
             if isinstance(i, uni.Token) and i.name == Tok.COMMA:
-                parts.pop()
-                parts.append(i.gen.doc_ir)
-                parts.append(self.space())
+                if is_in_items:
+                    mod_items.pop()
+                    mod_items.append(i.gen.doc_ir)
+                    mod_items.append(self.line())
+                else:
+                    parts.pop()
+                    parts.append(i.gen.doc_ir)
+                    parts.append(self.line())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
             elif isinstance(i, uni.Token) and i.name == Tok.RBRACE:
+                is_in_items = False
+                mod_items.pop()
+                parts.append(
+                    self.group(
+                        self.concat(
+                            [
+                                self.indent(self.concat([self.line(), *mod_items])),
+                                self.line(),
+                            ]
+                        )
+                    )
+                )
                 parts.append(i.gen.doc_ir)
-            else:
+            elif isinstance(i, uni.Token) and i.name == Tok.LBRACE:
+                is_in_items = True
                 parts.append(i.gen.doc_ir)
-                parts.append(self.space())
+            else:
+                if is_in_items:
+                    mod_items.append(i.gen.doc_ir)
+                    mod_items.append(self.space())
+                else:
+                    parts.append(i.gen.doc_ir)
+                    parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_module_item(self, node: uni.ModuleItem) -> None:
         """Generate DocIR for module items."""
@@ -178,6 +211,7 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for archetypes."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         prev_item = None
         in_body = False
         for i in node.kid:
@@ -198,6 +232,10 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif isinstance(node.body, Sequence) and i in node.body:
                 if not in_body:
                     body_parts.append(self.hard_line())
@@ -225,13 +263,15 @@ class DocIRGenPass(UniPass):
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
-
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_ability(self, node: uni.Ability) -> None:
         """Generate DocIR for abilities."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         in_body = False
         for i in node.kid:
             if i == node.doc or (node.decorators and i in node.decorators):
@@ -259,12 +299,18 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif not in_body and isinstance(i, uni.Token) and i.name == Tok.DECOR_OP:
                 parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_func_signature(self, node: uni.FuncSignature) -> None:
         """Generate DocIR for function signatures."""
@@ -401,7 +447,7 @@ class DocIRGenPass(UniPass):
                         ]
                     )
                 )
-                parts.append(self.if_break(broken, flat))
+                parts.append(self.group(self.if_break(broken, flat)))
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -901,16 +947,16 @@ class DocIRGenPass(UniPass):
                 return [expr]
 
         exprs = __flatten_bool_expr(node)
-        for i in range(0, len(exprs) - 1, 2):
+        parts += [exprs[0].gen.doc_ir, self.line()]
+        for i in range(1, len(exprs), 2):
             (
-                expr,
                 op,
+                expr,
             ) = (
-                exprs[i],
                 exprs[i + 1],
+                exprs[i],
             )
             parts += [expr.gen.doc_ir, self.space(), op.gen.doc_ir, self.line()]
-        parts += [exprs[-1].gen.doc_ir, self.line()]
         parts.pop()
         flat = self.concat(parts)
         node.gen.doc_ir = self.group(flat)
@@ -1108,6 +1154,8 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for assert statements."""
         parts: list[doc.DocType] = []
         for i in node.kid:
+            if isinstance(i, uni.Token) and i.name == Tok.SEMI and len(parts):
+                parts.pop()
             parts.append(i.gen.doc_ir)
             parts.append(self.space())
         parts.pop()
@@ -1125,6 +1173,7 @@ class DocIRGenPass(UniPass):
     def exit_global_vars(self, node: uni.GlobalVars) -> None:
         """Generate DocIR for global variables."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
@@ -1133,15 +1182,22 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_module_code(self, node: uni.ModuleCode) -> None:
         """Generate DocIR for module code."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         in_body = False
         for i in node.kid:
             if node.doc and i is node.doc:
@@ -1153,6 +1209,10 @@ class DocIRGenPass(UniPass):
             elif isinstance(i, uni.Token) and i.name == Tok.COLON:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif isinstance(node.body, Sequence) and i in node.body:
                 if not in_body:
                     parts.pop()
@@ -1175,6 +1235,8 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_global_stmt(self, node: uni.GlobalStmt) -> None:
         """Generate DocIR for global statements."""
@@ -1264,7 +1326,9 @@ class DocIRGenPass(UniPass):
                 ]
             )
         )
-        if isinstance(node.parent, uni.Assignment):
+        if isinstance(node.parent, (uni.Assignment)) or (
+            isinstance(node.parent, uni.IfStmt) and isinstance(node.value, uni.BoolExpr)
+        ):
             node.gen.doc_ir = self.if_break(
                 flat_contents=self.group(self.concat(parts[1:-1])),
                 break_contents=broken,
@@ -1300,6 +1364,7 @@ class DocIRGenPass(UniPass):
     def exit_py_inline_code(self, node: uni.PyInlineCode) -> None:
         """Generate DocIR for Python inline code blocks."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
@@ -1309,14 +1374,21 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.text("::py::"))
                 parts.append(self.hard_line())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_test(self, node: uni.Test) -> None:
         """Generate DocIR for test nodes."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
@@ -1325,10 +1397,16 @@ class DocIRGenPass(UniPass):
                 if not i.value.startswith("_jac_gen_"):
                     parts.append(i.gen.doc_ir)
                     parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_match_stmt(self, node: uni.MatchStmt) -> None:
         """Generate DocIR for match statements."""
@@ -1512,6 +1590,7 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for implementation definitions."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         in_body = False
         for i in node.kid:
             if i == node.doc or (node.decorators and i in node.decorators):
@@ -1519,6 +1598,10 @@ class DocIRGenPass(UniPass):
                 parts.append(self.hard_line())
             elif self.is_within(i, node.target):
                 parts.append(i.gen.doc_ir)
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif (
                 in_body
                 or isinstance(node.body, Sequence)
@@ -1546,10 +1629,13 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_sem_def(self, node: uni.SemDef) -> None:
         """Generate DocIR for semantic definitions."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i in node.target:
                 parts.append(i.gen.doc_ir)
@@ -1557,10 +1643,16 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_event_signature(self, node: uni.EventSignature) -> None:
         """Generate DocIR for event signatures."""
@@ -1614,14 +1706,6 @@ class DocIRGenPass(UniPass):
             and isinstance(node.parent, uni.FString)
         )
 
-        if "\n" in node.value:
-            lines = node.value.split("\n")
-            parts: list[doc.DocType] = [self.text(lines[0])]
-            for line in lines[1:]:
-                parts.append(self.hard_line())
-                parts.append(self.text(line.lstrip()))
-            node.gen.doc_ir = self.group(self.concat(parts))
-            return
         if is_escaped_curly:
             node.gen.doc_ir = self.concat(
                 [self.text(node.value), self.text(node.value)]

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -51,7 +51,7 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
 
             if isinstance(cur, doc.Text):
                 remaining -= len(cur.text)
-                if remaining < 0:
+                if remaining <= 0:
                     return False
 
             elif isinstance(cur, doc.Line):
@@ -63,7 +63,7 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
                     continue
                 # regular soft line becomes a single space in flat mode
                 remaining -= 1
-                if remaining < 0:
+                if remaining <= 0:
                     return False
 
             # --- Structural nodes (walk children in LIFO) ---

jaclang/compiler/passes/tool/tests/fixtures/import_fmt.jac

@@ -1,6 +1,12 @@
 import from datetime { datetime }
 import from uuid { UUID, uuid4 }
 import from jaclang.compiler.constant { EdgeDir }
-import from jaclang.plugin { Archetype, ArchetypeProtocol, DSFunc, AbsRootHook, hookimpl }
+import from jaclang.plugin {
+    Archetype,
+    ArchetypeProtocol,
+    DSFunc,
+    AbsRootHook,
+    hookimpl
+}
 import math;
 import numpy as np;

jaclang/compiler/passes/tool/tests/fixtures/tagbreak.jac

@@ -1,5 +1,5 @@
 #this file is part of formatter tests and is not meant to be run
- class SemTokManager {
+class SemTokManager {
     """Initialize semantic token manager."""
     def init(self: SemTokManager, ir: uni.Module) -> None {
         self.aaaaastatic_sem_tokens:
@@ -23,25 +23,23 @@ def walrus_example() {
 with entry {
     c = (
         a()
-        if 1 and
-        isinstance(a, int) and
-        isinstance(a, int) and
-        isinstance(a, int) and
-        isinstance(a, int) and
-        isinstance(a, int)
+        if 1
+        and isinstance(a, int)
+        and isinstance(a, int)
+        and isinstance(a, int)
+        and isinstance(a, int)
+        and isinstance(a, int)
         else (
             999
-            if isinstance(a, int) and
-            isinstance(a, int) and
-            isinstance(a, int) and
-            isinstance(4, bool)
+            if isinstance(a, int)
+            and isinstance(a, int)
+            and isinstance(a, int)
+            and isinstance(4, bool)
             else 7
         )
     );
-    print(
-        """This is a long
-        line of code."""
-    );
+    print("""This is a long
+        line of code.""");
 }
 
 
@@ -95,7 +93,7 @@ class ModuleManager {
 
 
 ## expr as item extra space issue
- with entry {
+with entry {
     with open(f"Apple{apple}.txt") as f {
         # Fix syntax highlighting
         print(
@@ -106,7 +104,7 @@ class ModuleManager {
 
 
 def func_with_very_long_params(
-    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: int,
+    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: int,
     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: int,
 ) -> None {
     print(
@@ -132,9 +130,9 @@ def func_with_short_params(a: int, b: int) -> None {
 
 with entry {
     if (
-        node_selected and
-        node_selected.find_parent_of_type(uni.Archetype) or
-        node_selected.find_parent_of_type(uni.ImplDef)
+        node_selected
+        and node_selected.find_parent_of_type(uni.Archetype)
+        or node_selected.find_parent_of_type(uni.ImplDef)
     ) {
         self_symbol = [
             lspt.CompletionItem(label='self', kind=lspt.CompletionItemKind.Variable)
@@ -143,27 +141,35 @@ with entry {
         self_symbol = [];
     }
     x = (
-        1222222222 and
-        2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
+        1222222222
+        and 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
     );
     a = 4 if True else 4;
 }
 
 
+import from typing { Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar }
+
+import from jaclang.compiler.constant {
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType,
+}
+
+
 """Return diagnostics."""
 def gen_diagnostics(
     from_path: str, errors: list[Alert], warnings: list[Alert]
 ) -> list[lspt.Diagnostic] {
     if (
-        isinstance(node_selected, uni.Name) and
-        node_selected.parent and
-        isinstance(node_selected.parent, uni.ModulePath)
+        isinstance(node_selected, uni.Name)
+        and node_selected.parent
+        and isinstance(node_selected.parent, uni.ModulePath)
     ) {
         node_selected = node_selected.name_of;
     } elif (
-        isinstance(node_selected, uni.Name) and
-        node_selected.parent and
-        isinstance(node_selected.parent, uni.ModulePath)
+        isinstance(node_selected, uni.Name)
+        and node_selected.parent
+        and isinstance(node_selected.parent, uni.ModulePath)
     ) {
         spec = node_selected.parent.parent.abs_path;
     }
@@ -171,8 +177,108 @@ def gen_diagnostics(
 
 
 @decorator
-def x() { }
+def x() {
+    assert gg == 7;
+}
 
 
 @decorator()
 class KK {}
+
+
+# kkk
+import pygame, random, math;
+
+
+# fff
+with entry {
+    # gg
+    a = 9;
+}
+
+
+# kkk
+class X {}
+
+
+# comment
+@decorator
+def xxx() { }
+
+
+# ddd
+glob a = 7;
+def get_node_info(self: JacLangServer, sym_node: uni.AstSymbolNode) -> Optional[str] {
+    try {
+        if isinstance(sym_node, uni.NameAtom) {
+            sym_node = sym_node.name_of;
+        }
+        access = (sym_node.sym.access.value + ' ') if sym_node.sym else None;
+        node_info = f"'('{(access if access else '')}{sym_node.sym_category.value}') '{sym_node.sym_name}";
+        if sym_node.name_spec.clean_type {
+            node_info += f"': '{sym_node.name_spec.clean_type}";
+        }
+        if (
+            isinstance(sym_node, uni.AstSymbolNode)
+            and isinstance(sym_node.name_spec.type, ClassType)
+        ) {
+            node_info += f"': '{sym_node.name_spec.type.shared.class_name}";
+        }
+        if (isinstance(sym_node, uni.AstDocNode) and sym_node.doc) {
+            node_info += f"'\n'{sym_node.doc.value}";
+        }
+        if (isinstance(sym_node, uni.Ability) and sym_node.signature) {
+            node_info += f"'\n'{sym_node.signature.unparse()}";
+        }
+    } except AttributeError as e {
+        self.log_warning(f"'Attribute error when accessing node attributes: '{e}");
+    }
+    return node_info.strip();
+}
+
+
+class foo {
+    """Get information about a node."""
+    def get_node_info(
+        self: JacLangServer, sym_node: uni.AstSymbolNode
+    ) -> Optional[str] {
+        if isinstance(sym_node, uni.AstVarNode) {
+            var_name = sym_node.name;
+            var_type = sym_node.var_type if sym_node.var_type else 'unknown';
+            return f" 'Variable: ' {var_name} ', Type: ' {var_type} ";
+        } elif isinstance(sym_node, uni.AstFuncNode) {
+            func_name = sym_node.name;
+            params = ', '.join(
+                [f" {p.name} ': ' {p.param_type} " for p in sym_node.params]
+            );
+            return f" 'Function: ' {func_name} '(' {params} ')' ";
+        }
+    }
+}
+
+
+def x3() {
+    if dest_type.is_class_instance() and src_type.is_class_instance() {
+        print("x");
+    }
+    if (
+        dest_type.is_class_instance()
+        and src_type.is_class_instance()
+        and src_type.is_class_instance()
+    ) {
+        print("x");
+    }
+    if (dest_type.is_class_instance() and src_type.is_class_instance()) {
+        print("x");
+    }
+}
+
+
+class HH {
+    def test()  -> Optional[str] {
+        a = """!
+hello
+hru
+""";
+    }
+}

jaclang/compiler/program.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import ast as py_ast
 import marshal
 import types
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.parser import JacParser
@@ -32,11 +32,13 @@ from jaclang.compiler.passes.tool import (
     FuseCommentsPass,
     JacFormatPass,
 )
-from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
 from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.settings import settings
 from jaclang.utils.log import logging
 
+if TYPE_CHECKING:
+    from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
+
 
 logger = logging.getLogger(__name__)
 
@@ -71,6 +73,8 @@ class JacProgram:
 
     def get_type_evaluator(self) -> TypeEvaluator:
         """Return the type evaluator."""
+        from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
+
         if not self.type_evaluator:
             self.type_evaluator = TypeEvaluator(program=self)
         return self.type_evaluator