jaclang 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

jaclang/jac/passes/main/tests/test_type_check_pass.py

@@ -0,0 +1,42 @@
+"""Test pass module."""
+from typing import List
+
+from jaclang.jac.passes.main import JacTypeCheckPass
+from jaclang.jac.passes.main.schedules import py_code_gen_typed
+from jaclang.jac.transpiler import jac_file_to_pass
+from jaclang.utils.test import TestCase
+
+
+class MypyTypeCheckPassTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        self.__messages: List[str] = []
+        return super().setUp()
+
+    def __message_cb(
+        self, filename: str | None, new_messages: list[str], is_serious: bool
+    ) -> None:
+        for message in new_messages:
+            self.__messages.append(
+                message.replace(self.fixture_abs_path("func.jac"), "")
+            )
+
+    def test_type_errors(self) -> None:
+        """Basic test for pass."""
+        JacTypeCheckPass.message_cb = self.__message_cb
+
+        jac_file_to_pass(
+            file_path=self.fixture_abs_path("func.jac"),
+            schedule=py_code_gen_typed,
+        )
+
+        errs = "\n".join(self.__messages)
+        for i in [
+            "File::4",
+            "File::12",
+            '(got "int", expected "str")',
+            '(got "str", expected "int")',
+        ]:
+            self.assertIn(i, errs)

jaclang/jac/passes/main/type_check_pass.py

@@ -0,0 +1,103 @@
+"""Integrate mypy infrastructure into Jac.
+
+This is used to call mypy type checking into Jac files by integrating
+mypy apis into Jac and use jac py ast in it.
+"""
+import os
+import pathlib
+import sys
+from typing import Callable, List, Optional
+
+
+import jaclang.jac.absyntree as ast
+import jaclang.jac.passes.utils.mypy_ast_build as myab
+from jaclang.jac.passes import Pass
+
+
+class JacTypeCheckPass(Pass):
+    """Python and bytecode file printing pass."""
+
+    message_cb: Optional[Callable[[str | None, List[str], bool], None]] = None
+
+    def before_pass(self) -> None:
+        """Before pass."""
+        self.__path = (
+            pathlib.Path(os.path.dirname(__file__)).parent.parent.parent
+            / "vendor"
+            / "mypy"
+        )
+        return super().before_pass()
+
+    def enter_module(self, node: ast.Module) -> None:
+        """Call mypy checks on module level only."""
+        self.api(node, node.loc.mod_path)
+        self.terminate()
+
+    def default_message_cb(
+        self, filename: str | None, new_messages: list[str], is_serious: bool
+    ) -> None:
+        """Mypy errors reporter."""
+        for msg in new_messages:
+            self.warning(msg)
+
+    def api(self, node: ast.Module, mod_path: str) -> None:
+        """Call mypy APIs to implement type checking in Jac."""
+        # Creating mypy api obbjects
+        options = myab.Options()
+        errors = myab.Errors(options)
+        fs_cache = myab.FileSystemCache()
+        search_paths = myab.compute_search_paths([], options, str(self.__path))
+        plugin, snapshot = myab.load_plugins(options, errors, sys.stdout, [])
+
+        if self.message_cb is not None:
+            message_cb = self.message_cb
+        else:
+            message_cb = self.default_message_cb
+
+        manager = myab.BuildManager(
+            data_dir=".",
+            search_paths=search_paths,
+            ignore_prefix=os.getcwd(),
+            source_set=myab.BuildSourceSet([]),
+            reports=None,
+            options=options,
+            version_id="1.8.0+dev",
+            plugin=plugin,
+            plugins_snapshot=snapshot,
+            errors=errors,
+            flush_errors=message_cb,
+            fscache=fs_cache,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+
+        tree = myab.ASTConverter(
+            options=options,
+            is_stub=False,
+            errors=errors,
+            ignore_errors=False,
+            strip_function_bodies=False,
+        ).visit(node.gen.py_ast)
+
+        st = myab.State(
+            id="Jac Module",
+            path="File:" + mod_path,
+            source="",
+            manager=manager,
+            root_source=False,
+            ast_override=tree,
+        )
+
+        graph = myab.load_graph(
+            [
+                myab.BuildSource(
+                    path=str(self.__path / "typeshed" / "stdlib" / "builtins.pyi"),
+                    module="builtins",
+                )
+            ],
+            manager,
+            old_graph={"JacTree": st},
+        )
+        myab.process_graph(graph, manager)
+
+        myab.semantic_analysis_for_scc(graph, ["JacTree"], errors)

jaclang/jac/passes/tool/fuse_comments_pass.py

@@ -13,7 +13,7 @@ class FuseCommentsPass(Pass):
     def before_pass(self) -> None:
         """Before pass."""
         self.all_tokens: list[ast.Token] = []
-        self.comments: list[ast.Token] = (
+        self.comments: list[ast.CommentToken] = (
             self.ir.source.comments if isinstance(self.ir, ast.Module) else []
         )
         return super().before_pass()
@@ -25,44 +25,62 @@ class FuseCommentsPass(Pass):
 
     def after_pass(self) -> None:
         """Insert comment tokens into all_tokens."""
-        chomp: list[ast.CommentToken] = [*self.comments]
-        new_tokens: list[ast.Token] = []
-        if not len(chomp):
-            return
-        for i in range(len(self.all_tokens)):
-            chomp[0].is_inline = chomp[0].is_inline or (
-                self.all_tokens[i].loc.first_line == chomp[0].loc.first_line
-            )
-            if i == len(self.all_tokens) - 1:
-                if len(chomp):
-                    new_tokens.append(self.all_tokens[i])
-                    new_tokens += chomp
-                break
-            while (i < len(self.all_tokens) - 1) and (
-                (
-                    self.all_tokens[i].loc.first_line == chomp[0].loc.first_line
-                    and self.all_tokens[i].loc.col_start > chomp[0].loc.col_start
-                )
-                or (self.all_tokens[i].loc.first_line > chomp[0].loc.first_line)
+        comment_stream = iter(self.comments)  # Iterator for comments
+        code_stream = iter(self.all_tokens)  # Iterator for code tokens
+        new_stream = []  # New stream to hold ordered tokens
+
+        try:
+            next_comment = next(comment_stream)  # Get the first comment
+        except StopIteration:
+            next_comment = None
+
+        try:
+            next_code = next(code_stream)  # Get the first code token
+        except StopIteration:
+            next_code = None
+
+        while next_comment or next_code:
+            if next_comment and (
+                not next_code or is_comment_next(next_comment, next_code)
             ):
-                new_tokens.append(chomp[0])
-                chomp = chomp[1:]
-                if not len(chomp):
-                    new_tokens.extend(self.all_tokens[i + 1 :])
-                    break
-            new_tokens.append(self.all_tokens[i])
-            if not len(chomp):
-                break
-        for i in range(len(new_tokens)):
-            if isinstance(new_tokens[i], ast.CommentToken):
+                # Add the comment to the new stream
+                new_stream.append(next_comment)
+                try:
+                    next_comment = next(comment_stream)
+                except StopIteration:
+                    next_comment = None
+            elif next_code:
+                # Add the code token to the new stream
+                new_stream.append(next_code)
+                try:
+                    next_code = next(code_stream)
+                except StopIteration:
+                    next_code = None
+
+        # Insert the tokens back into the AST
+        for i, token in enumerate(new_stream):
+            if isinstance(token, ast.CommentToken):
                 if i == 0:
-                    self.ir.add_kids_left([new_tokens[i]])
-                    continue
-                new_val = new_tokens[i - 1]
-                if new_val.parent is not None:
-                    new_kids = new_val.parent.kid
-                    new_kids.insert(new_kids.index(new_val) + 1, new_tokens[i])
-                    new_val.parent.set_kids(new_kids)
+                    self.ir.add_kids_left([token])
                 else:
-                    new_val.pp()
-                    raise self.ice("Token without parent in AST should be impossible")
+                    prev_token = new_stream[i - 1]
+                    if prev_token.parent is not None:
+                        parent_kids = prev_token.parent.kid
+                        insert_index = parent_kids.index(prev_token) + 1
+                        parent_kids.insert(insert_index, token)
+                        prev_token.parent.set_kids(parent_kids)
+                    else:
+                        prev_token.pp()
+                        raise self.ice(
+                            "Token without parent in AST should be impossible"
+                        )
+
+
+def is_comment_next(cmt: ast.CommentToken, code: ast.Token) -> bool:
+    """Compare two CodeLocInfo objects."""
+    if cmt.loc.first_line < code.loc.first_line:
+        return True
+    elif cmt.loc.first_line == code.loc.first_line:
+        cmt.is_inline = True
+        return cmt.loc.col_start < code.loc.col_start
+    return False