jaclang 0.6.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast as ast3
+from hashlib import md5
 from types import EllipsisType
 from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar
 
@@ -4081,6 +4082,7 @@ class JacSource(EmptyToken):
         """Initialize source string."""
         super().__init__()
         self.value = source
+        self.hash = md5(source.encode()).hexdigest()
         self.file_path = mod_path
         self.comments: list[CommentToken] = []
 

jaclang/compiler/parser.py

@@ -28,7 +28,7 @@ class JacParser(Pass):
             JacParser.make_dev()
         Pass.__init__(self, input_ir=input_ir, prior=None)
 
-    def transform(self, ir: ast.AstNode) -> ast.AstNode:
+    def transform(self, ir: ast.AstNode) -> ast.Module:
         """Transform input IR."""
         try:
             tree, comments = JacParser.parse(
@@ -36,6 +36,10 @@ class JacParser(Pass):
             )
             mod = JacParser.TreeToAST(parser=self).transform(tree)
             self.source.comments = [self.proc_comment(i, mod) for i in comments]
+            if isinstance(mod, ast.Module):
+                return mod
+            else:
+                raise self.ice()
         except jl.UnexpectedInput as e:
             catch_error = ast.EmptyToken()
             catch_error.file_path = self.mod_path
@@ -43,11 +47,16 @@ class JacParser(Pass):
             catch_error.c_start = e.column
             catch_error.c_end = e.column
             self.error(f"Syntax Error: {e}", node_override=catch_error)
-            mod = self.source
         except Exception as e:
-            mod = self.source
             self.error(f"Internal Error: {e}")
-        return mod
+        return ast.Module(
+            name="",
+            source=self.source,
+            doc=None,
+            body=[],
+            is_imported=False,
+            kid=[ast.EmptyToken()],
+        )
 
     @staticmethod
     def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken:

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -1161,7 +1161,7 @@ class JacFormatPass(Pass):
         if (
             node.parent
             and node.parent.parent
-            and isinstance(node.parent.parent, (ast.Ability))
+            and not isinstance(node.parent.parent, (ast.Ability, ast.ModuleCode))
             and node.parent.kid[1].gen.jac != "self.jaseci_sdk = {};\n"
         ):
             self.emit_ln(node, "")
@@ -1229,7 +1229,7 @@ class JacFormatPass(Pass):
 
         body: CodeBlock,
         """
-        self.emit(node, "finally")
+        self.emit(node, " finally")
 
         self.emit(node, node.body.gen.jac)
 

jaclang/compiler/passes/transform.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Generic, Optional
+from typing import Generic, Optional, Type
 
 from jaclang.compiler.absyntree import AstNode, T
 from jaclang.compiler.codeloc import CodeLocInfo
@@ -13,10 +13,11 @@ from jaclang.utils.log import logging
 class Alert:
     """Alert interface."""
 
-    def __init__(self, msg: str, loc: CodeLocInfo) -> None:
+    def __init__(self, msg: str, loc: CodeLocInfo, from_pass: Type[Transform]) -> None:
         """Initialize alert."""
         self.msg = msg
         self.loc: CodeLocInfo = loc
+        self.from_pass: Type[Transform] = from_pass
 
     def __str__(self) -> str:
         """Return string representation of alert."""
@@ -52,14 +53,22 @@ class Transform(ABC, Generic[T]):
 
     def log_error(self, msg: str, node_override: Optional[AstNode] = None) -> None:
         """Pass Error."""
-        alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
+        alrt = Alert(
+            msg,
+            self.cur_node.loc if not node_override else node_override.loc,
+            self.__class__,
+        )
         self.errors_had.append(alrt)
         # print("Error:", str(alrt))
         self.logger.error(str(alrt))
 
     def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
         """Pass Error."""
-        alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
+        alrt = Alert(
+            msg,
+            self.cur_node.loc if not node_override else node_override.loc,
+            self.__class__,
+        )
         self.warnings_had.append(alrt)
         # print("Warning:", str(alrt))
         self.logger.warning(str(alrt))

jaclang/compiler/tests/fixtures/mod_doc_test.jac

@@ -1 +1,3 @@
-with entry { print("hello"); }
+with entry {
+    print("hello");
+}

jaclang/langserve/engine.py

@@ -0,0 +1,287 @@
+"""Living Workspace of Jac project."""
+
+from __future__ import annotations
+
+from hashlib import md5
+from typing import Sequence, Type
+
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.compile import jac_pass_to_pass, jac_str_to_pass
+from jaclang.compiler.parser import JacParser
+from jaclang.compiler.passes import Pass
+from jaclang.compiler.passes.main.schedules import (
+    AccessCheckPass,
+    PyBytecodeGenPass,
+    py_code_gen_typed,
+)
+from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
+from jaclang.compiler.passes.transform import Alert
+from jaclang.compiler.symtable import Symbol
+from jaclang.langserve.utils import sym_tab_list
+from jaclang.vendor.pygls.server import LanguageServer
+from jaclang.vendor.pygls.workspace.text_document import TextDocument
+
+import lsprotocol.types as lspt
+
+
+class ModuleInfo:
+    """Module IR and Stats."""
+
+    def __init__(
+        self,
+        ir: ast.Module,
+        to_pass: Pass,
+        errors: Sequence[Alert],
+        warnings: Sequence[Alert],
+    ) -> None:
+        """Initialize module info."""
+        self.ir = ir
+        self.at_pass = to_pass
+        self.errors = errors
+        self.warnings = warnings
+        self.diagnostics = self.gen_diagnostics()
+
+    def gen_diagnostics(self) -> list[lspt.Diagnostic]:
+        """Return diagnostics."""
+        return [
+            lspt.Diagnostic(
+                range=lspt.Range(
+                    start=lspt.Position(
+                        line=error.loc.first_line, character=error.loc.col_start
+                    ),
+                    end=lspt.Position(
+                        line=error.loc.last_line,
+                        character=error.loc.col_end,
+                    ),
+                ),
+                message=error.msg,
+                severity=lspt.DiagnosticSeverity.Error,
+            )
+            for error in self.errors
+        ] + [
+            lspt.Diagnostic(
+                range=lspt.Range(
+                    start=lspt.Position(
+                        line=warning.loc.first_line, character=warning.loc.col_start
+                    ),
+                    end=lspt.Position(
+                        line=warning.loc.last_line,
+                        character=warning.loc.col_end,
+                    ),
+                ),
+                message=warning.msg,
+                severity=lspt.DiagnosticSeverity.Warning,
+            )
+            for warning in self.warnings
+        ]
+
+
+class JacLangServer(LanguageServer):
+    """Class for managing workspace."""
+
+    def __init__(self) -> None:
+        """Initialize workspace."""
+        super().__init__("jac-lsp", "v0.1")
+        self.modules: dict[str, ModuleInfo] = {}
+
+    def module_not_diff(self, doc: TextDocument) -> bool:
+        """Check if module was changed."""
+        return (
+            doc.uri in self.modules
+            and self.modules[doc.uri].ir.source.hash
+            == md5(doc.source.encode()).hexdigest()
+        )
+
+    def module_reached_pass(self, doc: TextDocument, target: Type[Pass]) -> bool:
+        """Check if module reached a pass."""
+        return doc.uri in self.modules and isinstance(
+            self.modules[doc.uri].at_pass, target
+        )
+
+    def push_diagnostics(self, file_path: str) -> None:
+        """Push diagnostics for a file."""
+        if file_path in self.modules:
+            self.publish_diagnostics(
+                file_path,
+                self.modules[file_path].diagnostics,
+            )
+
+    def quick_check(self, file_path: str) -> None:
+        """Rebuild a file."""
+        document = self.workspace.get_document(file_path)
+        if self.module_not_diff(document):
+            return
+        try:
+            build = jac_str_to_pass(
+                jac_str=document.source, file_path=document.path, schedule=[]
+            )
+        except Exception as e:
+            self.log_error(f"Error during syntax check: {e}")
+        if isinstance(build.ir, ast.Module):
+            self.modules[file_path] = ModuleInfo(
+                ir=build.ir,
+                to_pass=build,
+                errors=build.errors_had,
+                warnings=build.warnings_had,
+            )
+
+    def deep_check(self, file_path: str) -> None:
+        """Rebuild a file and its dependencies."""
+        document = self.workspace.get_document(file_path)
+        if self.module_not_diff(document) and self.module_reached_pass(
+            document, PyBytecodeGenPass
+        ):
+            return
+        try:
+            build = jac_pass_to_pass(in_pass=self.modules[file_path].at_pass)
+        except Exception as e:
+            self.log_error(f"Error during syntax check: {e}")
+        if isinstance(build.ir, ast.Module):
+            self.modules[file_path] = ModuleInfo(
+                ir=build.ir,
+                to_pass=build,
+                errors=build.errors_had,
+                warnings=build.warnings_had,
+            )
+
+    def type_check(self, file_path: str) -> None:
+        """Rebuild a file and its dependencies."""
+        document = self.workspace.get_document(file_path)
+        if self.module_not_diff(document) and self.module_reached_pass(
+            document, AccessCheckPass
+        ):
+            return
+        try:
+            build = jac_pass_to_pass(
+                in_pass=self.modules[file_path].at_pass,
+                target=AccessCheckPass,
+                schedule=py_code_gen_typed,
+            )
+        except Exception as e:
+            self.log_error(f"Error during type check: {e}")
+        if isinstance(build.ir, ast.Module):
+            self.modules[file_path] = ModuleInfo(
+                ir=build.ir,
+                to_pass=build,
+                errors=build.errors_had,
+                warnings=build.warnings_had,
+            )
+
+    def get_completion(
+        self, file_path: str, position: lspt.Position
+    ) -> lspt.CompletionList:
+        """Return completion for a file."""
+        items = []
+        document = self.workspace.get_document(file_path)
+        current_line = document.lines[position.line].strip()
+        if current_line.endswith("hello."):
+
+            items = [
+                lspt.CompletionItem(label="world"),
+                lspt.CompletionItem(label="friend"),
+            ]
+        return lspt.CompletionList(is_incomplete=False, items=items)
+
+    def rename_module(self, old_path: str, new_path: str) -> None:
+        """Rename module."""
+        if old_path in self.modules and new_path != old_path:
+            self.modules[new_path] = self.modules[old_path]
+            del self.modules[old_path]
+
+    def delete_module(self, uri: str) -> None:
+        """Delete module."""
+        if uri in self.modules:
+            del self.modules[uri]
+
+    def formatted_jac(self, file_path: str) -> list[lspt.TextEdit]:
+        """Return formatted jac."""
+        try:
+            document = self.workspace.get_document(file_path)
+            format = jac_str_to_pass(
+                jac_str=document.source,
+                file_path=document.path,
+                target=JacFormatPass,
+                schedule=[FuseCommentsPass, JacFormatPass],
+            )
+            formatted_text = (
+                format.ir.gen.jac
+                if JacParser not in [e.from_pass for e in format.errors_had]
+                else document.source
+            )
+        except Exception as e:
+            self.log_error(f"Error during formatting: {e}")
+            formatted_text = document.source
+        return [
+            lspt.TextEdit(
+                range=lspt.Range(
+                    start=lspt.Position(line=0, character=0),
+                    end=lspt.Position(
+                        line=len(document.source.splitlines()) + 1, character=0
+                    ),
+                ),
+                new_text=(formatted_text),
+            )
+        ]
+
+    def get_dependencies(
+        self, file_path: str, deep: bool = False
+    ) -> list[ast.ModulePath]:
+        """Return a list of dependencies for a file."""
+        mod_ir = self.modules[file_path].ir
+        if deep:
+            return (
+                [
+                    i
+                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
+                    if i.parent_of_type(ast.Import).hint.tag.value == "jac"
+                ]
+                if mod_ir
+                else []
+            )
+        else:
+            return (
+                [
+                    i
+                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
+                    if i.loc.mod_path == file_path
+                    and i.parent_of_type(ast.Import).hint.tag.value == "jac"
+                ]
+                if mod_ir
+                else []
+            )
+
+    def get_symbols(self, file_path: str) -> list[Symbol]:
+        """Return a list of symbols for a file."""
+        symbols = []
+        mod_ir = self.modules[file_path].ir
+        if file_path in self.modules:
+            root_table = mod_ir.sym_tab if mod_ir else None
+            if file_path in self.modules and root_table:
+                for i in sym_tab_list(sym_tab=root_table, file_path=file_path):
+                    symbols += list(i.tab.values())
+        return symbols
+
+    def get_definitions(
+        self, file_path: str
+    ) -> Sequence[ast.AstSymbolNode]:  # need test
+        """Return a list of definitions for a file."""
+        defs = []
+        for i in self.get_symbols(file_path):
+            defs += i.defn
+        return defs
+
+    def log_error(self, message: str) -> None:
+        """Log an error message."""
+        self.show_message_log(message, lspt.MessageType.Error)
+        self.show_message(message, lspt.MessageType.Error)
+
+    def log_warning(self, message: str) -> None:
+        """Log a warning message."""
+        self.show_message_log(message, lspt.MessageType.Warning)
+        self.show_message(message, lspt.MessageType.Warning)
+
+    def log_info(self, message: str) -> None:
+        """Log an info message."""
+        self.show_message_log(message, lspt.MessageType.Info)
+        self.show_message(message, lspt.MessageType.Info)

jaclang/langserve/server.py

@@ -2,101 +2,132 @@
 
 from __future__ import annotations
 
-from jaclang.compiler.compile import jac_str_to_pass
-from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
-from jaclang.langserve.utils import debounce, log, log_error
-from jaclang.vendor.pygls.server import LanguageServer
+import threading
+from typing import Optional
+
+from jaclang.langserve.engine import JacLangServer
+from jaclang.langserve.utils import debounce
 
 import lsprotocol.types as lspt
 
-server = LanguageServer("jac-lsp", "v0.1")
+server = JacLangServer()
+analysis_thread: Optional[threading.Thread] = None
+analysis_stop_event = threading.Event()
+
+
+def analyze_and_publish(ls: JacLangServer, uri: str) -> None:
+    """Analyze and publish diagnostics."""
+    global analysis_thread, analysis_stop_event
+
+    def run_analysis() -> None:
+        ls.quick_check(uri)
+        ls.push_diagnostics(uri)
+        ls.deep_check(uri)
+        ls.push_diagnostics(uri)
+        ls.type_check(uri)
+        ls.push_diagnostics(uri)
+
+    analysis_thread = threading.Thread(target=run_analysis)
+    analysis_thread.start()
+    ls.log_info("Analysis restarted")
+
+
+def stop_analysis() -> None:
+    """Stop analysis."""
+    global analysis_thread, analysis_stop_event
+    if analysis_thread is not None:
+        analysis_stop_event.set()
+        analysis_thread.join()
+        analysis_stop_event.clear()
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
+async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+    """Check syntax on change."""
+    stop_analysis()
+    analyze_and_publish(ls, params.text_document.uri)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
-@debounce(0.3)
+@debounce(0.1)
 async def did_change(
-    ls: LanguageServer, params: lspt.DidChangeTextDocumentParams
+    ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
 ) -> None:
     """Check syntax on change."""
-    document = ls.workspace.get_document(params.text_document.uri)
-    try:
-        result = jac_str_to_pass(
-            jac_str=document.source,
-            file_path=document.path,
-            schedule=[],
-        )
-        if not result.errors_had and not result.warnings_had:
-            ls.publish_diagnostics(document.uri, [])
-        else:
-            ls.publish_diagnostics(
-                document.uri,
-                [
-                    lspt.Diagnostic(
-                        range=lspt.Range(
-                            start=lspt.Position(
-                                line=error.loc.first_line, character=error.loc.col_start
-                            ),
-                            end=lspt.Position(
-                                line=error.loc.last_line,
-                                character=error.loc.col_end,
-                            ),
-                        ),
-                        message=error.msg,
-                        severity=lspt.DiagnosticSeverity.Error,
-                    )
-                    for error in result.errors_had
-                ],
-            )
-    except Exception as e:
-        log_error(ls, f"Error during syntax check: {e}")
-        log(f"Error during syntax check: {e}")
+    stop_analysis()
+    analyze_and_publish(ls, params.text_document.uri)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+async def did_save(ls: JacLangServer, params: lspt.DidSaveTextDocumentParams) -> None:
+    """Check syntax on save."""
+    stop_analysis()
+    analyze_and_publish(ls, params.text_document.uri)
+
+
+@server.feature(
+    lspt.WORKSPACE_DID_CREATE_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[
+            lspt.FileOperationFilter(pattern=lspt.FileOperationPattern("**/*.jac"))
+        ]
+    ),
+)
+async def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None:
+    """Check syntax on file creation."""
+    for file in params.files:
+        ls.quick_check(file.uri)
+        ls.push_diagnostics(file.uri)
+
+
+@server.feature(
+    lspt.WORKSPACE_DID_RENAME_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[
+            lspt.FileOperationFilter(pattern=lspt.FileOperationPattern("**/*.jac"))
+        ]
+    ),
+)
+async def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None:
+    """Check syntax on file rename."""
+    new_uris = [file.new_uri for file in params.files]
+    old_uris = [file.old_uri for file in params.files]
+    for i in range(len(new_uris)):
+        ls.rename_module(old_uris[i], new_uris[i])
+        ls.quick_check(new_uris[i])
+
+
+@server.feature(
+    lspt.WORKSPACE_DID_DELETE_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[
+            lspt.FileOperationFilter(pattern=lspt.FileOperationPattern("**/*.jac"))
+        ]
+    ),
+)
+async def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
+    """Check syntax on file delete."""
+    for file in params.files:
+        ls.delete_module(file.uri)
 
 
 @server.feature(
     lspt.TEXT_DOCUMENT_COMPLETION,
     lspt.CompletionOptions(trigger_characters=[".", ":", ""]),
 )
-def completions(params: lspt.CompletionParams) -> lspt.CompletionList:
-    """Provide completions for the given completion request."""
-    items = []
-    document = server.workspace.get_text_document(params.text_document.uri)
-    current_line = document.lines[params.position.line].strip()
-    if current_line.endswith("hello."):
-
-        items = [
-            lspt.CompletionItem(label="world"),
-            lspt.CompletionItem(label="friend"),
-        ]
-    return lspt.CompletionList(is_incomplete=False, items=items)
+async def completion(
+    ls: JacLangServer, params: lspt.CompletionParams
+) -> lspt.CompletionList:
+    """Provide completion."""
+    return ls.get_completion(params.text_document.uri, params.position)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
 def formatting(
-    ls: LanguageServer, params: lspt.DocumentFormattingParams
+    ls: JacLangServer, params: lspt.DocumentFormattingParams
 ) -> list[lspt.TextEdit]:
     """Format the given document."""
-    try:
-        document = ls.workspace.get_document(params.text_document.uri)
-        formatted_text = jac_str_to_pass(
-            jac_str=document.source,
-            file_path=document.path,
-            target=JacFormatPass,
-            schedule=[FuseCommentsPass, JacFormatPass],
-        ).ir.gen.jac
-    except Exception as e:
-        log_error(ls, f"Error during formatting: {e}")
-        formatted_text = document.source
-    return [
-        lspt.TextEdit(
-            range=lspt.Range(
-                start=lspt.Position(line=0, character=0),
-                end=lspt.Position(
-                    line=len(formatted_text.splitlines()) + 1, character=0
-                ),
-            ),
-            new_text=formatted_text,
-        )
-    ]
+    return ls.formatted_jac(params.text_document.uri)
 
 
 def run_lang_server() -> None:

jaclang/langserve/utils.py

@@ -1,24 +1,11 @@
 """Utility functions for the language server."""
 
 import asyncio
-import logging
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, ParamSpec, TypeVar
 
-from jaclang.vendor.pygls.server import LanguageServer
-
-import lsprotocol.types as lspt
-
-
-def log_error(ls: LanguageServer, message: str) -> None:
-    """Log an error message."""
-    ls.show_message_log(message, lspt.MessageType.Error)
-    ls.show_message(message, lspt.MessageType.Error)
-
-
-def log(info: str) -> None:
-    """Log an info message."""
-    logging.warning(info)
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.symtable import SymbolTable
 
 
 T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
@@ -51,3 +38,18 @@ def debounce(wait: float) -> Callable[[T], Callable[..., Awaitable[None]]]:
         return debounced
 
     return decorator
+
+
+def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]:
+    """Iterate through symbol table."""
+    sym_tabs = (
+        [sym_tab]
+        if not (
+            isinstance(sym_tab.owner, ast.Module)
+            and sym_tab.owner.loc.mod_path != file_path
+        )
+        else []
+    )
+    for i in sym_tab.kid:
+        sym_tabs += sym_tab_list(i, file_path=file_path)
+    return sym_tabs

jaclang/plugin/default.py

@@ -189,8 +189,8 @@ class JacFeatureDefaults:
 
         @wraps(inner_init)
         def new_init(self: Architype, *args: object, **kwargs: object) -> None:
-            inner_init(self, *args, **kwargs)
             arch_base.__init__(self)
+            inner_init(self, *args, **kwargs)
 
         cls.__init__ = new_init  # type: ignore
         return cls

{jaclang-0.6.5.dist-info → jaclang-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.6.5
+Version: 0.7.0
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
          width="20%">
   </picture>
 
-[Website][Jaclang] | [Getting started] | [Learn] | [Documentation] | [Contributing]
+[Jac Website] | [Getting started] | [Learn] | [Documentation] | [Contributing]
 
   [![PyPI version](https://img.shields.io/pypi/v/jaclang.svg)](https://pypi.org/project/jaclang/) [![Tests](https://github.com/chandralegend/jaclang/actions/workflows/run_pytest.yml/badge.svg?branch=main)](https://github.com/chandralegend/jaclang/actions/workflows/run_pytest.yml) [![codecov](https://codecov.io/github/chandralegend/jaclang/graph/badge.svg?token=OAX26B0FE4)](https://codecov.io/github/chandralegend/jaclang)
 </div>
@@ -33,30 +33,22 @@ Description-Content-Type: text/markdown
 This is the main source code repository for the [Jac] programming language. It contains the compiler, language server, and documentation.
 
 [Jac]: https://www.jac-lang.org/
+[Jac Website]: https://www.jac-lang.org/
 [Getting Started]: https://www.jac-lang.org//start/
 [Learn]: https://www.jac-lang.org//learn
 [Documentation]: https://www.jac-lang.org//learn/guide/
 [Contributing]: .github/CONTRIBUTING.md
 
-## Why Jac?
+## What and Why Jac?
 
-- **Easy:** Jac is designed to be easy to learn and use, while also being powerful.
+- **Native Superset of Python** - Jac is a native superset of python, meaning the entire python ecosystem is directly interoperable with Jac without any trickery (no interop interface needed). Like Typescript is to Javascript, or C++ is to C, Jac is to Python. (every Jac program can be ejected to pure python, and every python program can be transpiled to a Jac program)
 
-- **Reliability:** Our rich type system and runtime checks ensure your code is correct.
+- **AI as a Programming Language Constructs** - Jac includes a novel (neurosymbolic) language construct that allows replacing code with generative AI models themselves. Jac's philosophy abstracts away prompt engineering. (Imagine taking a function body and swapping it out with a model.)
 
-- **AI Ready:** Jac provide easy to use Abstractions specially designed for LLMs.
+- **New Modern Abstractions** - Jac introduces a paradigm that reasons about persistence and the notion of users as a language level construct. This enables writing simple programs for which no code changes are needed whether they run in a simple command terminal, or distributed across a large cloud. Jac's philosophy abstracts away dev ops and container/cloud configuration.
 
-- **Data Spatial Programming:** Jac provides easy to use Abstractions for Data Spatial Programming.
+- **Jac Improves on Python** - Jac makes multiple thoughtful quality-of-life improvements/additions to Python. These include new modern operators, new types of comprehensions, new ways of organizing modules (i.e., separating implementations from declarations), etc.
 
-- **Support:** Jac compiles to Python, which is widely used and has a large ecosystem. Making it easy to integrate with existing code.
-
-- **Dev Friendly:** Highly Refactorable, Jac is designed to be easy to refactor and maintain. VSCode Editor support. Builtin language server protocol support.
-
-- **Cloud-native:** Jac is designed to be cloud-native, making it easy to deploy and scale.
-
-
-
-[jac-analyzer]: https://github.com/Jaseci-Labs/jac-analyzer
 
 ## Quick Start
 

{jaclang-0.6.5.dist-info → jaclang-0.7.0.dist-info}/RECORD

@@ -6,12 +6,12 @@ jaclang/cli/cli.py,sha256=d352zfA5_Da5InyQkv4V-qaxIcdIaVYJVeYt8npSB3I,13553
 jaclang/cli/cmdreg.py,sha256=u0jAd6A8czt7tBgPBBKBhYAG4By1FrjEGaTU2XFKeYs,8372
 jaclang/compiler/.gitignore,sha256=n1k2_xXTorp9PY8hhYM4psHircn-NMaFx95bSgDKopo,10
 jaclang/compiler/__init__.py,sha256=JA3L1ran0PlZI5Pcj2CIrFgrZGRNFHHC5kRh1QYgYlY,3146
-jaclang/compiler/absyntree.py,sha256=PXHefWmwDO2ZD9iShs_Mt3-m_JP0f0HVCsE4UfPZjQg,126904
+jaclang/compiler/absyntree.py,sha256=yHKyIqPTajrZa8KE2gneilkLk9xFBU0EPaknVelmAZ4,126981
 jaclang/compiler/codeloc.py,sha256=KMwf5OMQu3_uDjIdH7ta2piacUtXNPgUV1t8OuLjpzE,2828
 jaclang/compiler/compile.py,sha256=IOjTLv42IULW6HbCpFINNrRhwjHDebKO1vdon0EX85k,2772
 jaclang/compiler/constant.py,sha256=C8nOgWLAg-fRg8Qax_jRcYp6jGyWSSA1gwzk9Zdy7HE,6534
 jaclang/compiler/jac.lark,sha256=TI8ctvs_cASPp-EDPrMiCeL80Ngvj_7WxGMUFtGN7vs,17040
-jaclang/compiler/parser.py,sha256=Cp_3p5lR7QekGqYYGYm6Blye5tmQAux7EuP6CBDRNpY,138547
+jaclang/compiler/parser.py,sha256=Fy6qsTdh82YvXSgXoevIT5dIGjAn3hqbN45muJ5jFNY,138789
 jaclang/compiler/passes/__init__.py,sha256=0Tw0d130ZjzA05jVcny9cf5NfLjlaM70PKqFnY4zqn4,69
 jaclang/compiler/passes/ir_pass.py,sha256=gh1Zd8ouu79FoxerW1sMxktmfeC9gHyp4H_MoAviYP8,5504
 jaclang/compiler/passes/main/__init__.py,sha256=m8vZ0F6EiwOm0e0DWKRYgc8JcgiT2ayBrY6GojZkTfY,945
@@ -64,7 +64,7 @@ jaclang/compiler/passes/main/tests/test_typeinfo_pass.py,sha256=ehC0_giLg7NwB7fR
 jaclang/compiler/passes/main/type_check_pass.py,sha256=-f41Ukr3B1w4rkQdZ2xJy6nozymgnVKjJ8E1fn7qJmI,3339
 jaclang/compiler/passes/tool/__init__.py,sha256=xekCOXysHIcthWm8NRmQoA1Ah1XV8vFbkfeHphJtUdc,223
 jaclang/compiler/passes/tool/fuse_comments_pass.py,sha256=N9a84qArNuTXX1iaXsBzqcufx6A3zYq2p-1ieH6FmHc,3133
-jaclang/compiler/passes/tool/jac_formatter_pass.py,sha256=oYXDWWlxYj0FGXxXUOPnmwnkFPmayd2fRoWngvDgXwc,86113
+jaclang/compiler/passes/tool/jac_formatter_pass.py,sha256=xpM10gIhILS37Ne2NVFMruJwmG1GfDcY0y8fbgqWrdM,86134
 jaclang/compiler/passes/tool/schedules.py,sha256=kmbsCazAMizGAdQuZpFky5BPlYlMXqNw7wOUzdi_wBo,432
 jaclang/compiler/passes/tool/tests/__init__.py,sha256=AeOaZjA1rf6VAr0JqIit6jlcmOzW7pxGr4U1fOwgK_Y,24
 jaclang/compiler/passes/tool/tests/fixtures/corelib.jac,sha256=GA5_CDQQo9awG6H8wed8tp06KoWtQ8nR70LVbBwCFIY,12416
@@ -99,7 +99,7 @@ jaclang/compiler/passes/tool/tests/fixtures/simple_walk_fmt.jac,sha256=6jwYKXxJ1
 jaclang/compiler/passes/tool/tests/test_fuse_comments_pass.py,sha256=ZeWHsm7VIyyS8KKpoB2SdlHM4jF22fMfSrfTfxt2MQw,398
 jaclang/compiler/passes/tool/tests/test_jac_format_pass.py,sha256=P4vBRbwVAkb8svFSAOf4VKioZS8BkoaVfYdn-LCrRqA,6144
 jaclang/compiler/passes/tool/tests/test_unparse_validate.py,sha256=Tg9k7BOSkWngAZLvSHmPt95ILJzdIvdHxKBT__mgpS0,2910
-jaclang/compiler/passes/transform.py,sha256=Z3TuHMJ7TyyBHt0XmRWEjMk8-t6logKs7XG_OTDJIvo,2162
+jaclang/compiler/passes/transform.py,sha256=jh2pMGFs6J9ZbQ2E-3r21khDm53yKXbNq5GstLMkBpg,2374
 jaclang/compiler/passes/utils/__init__.py,sha256=UsI5rUopTUiStAzup4kbPwIwrnC5ofCrqWBCBbM2-k4,35
 jaclang/compiler/passes/utils/mypy_ast_build.py,sha256=DbTYKwQ2K-3JXS_RybLyvqDz_381Li8JfFKNeEQhbRY,26324
 jaclang/compiler/symtable.py,sha256=f-9c3eQJTDhEG22kYC3Vd4i5gRWf77_CsqFm7t8Wsng,6031
@@ -109,13 +109,11 @@ jaclang/compiler/tests/fixtures/activity.py,sha256=fSvxYDKufsPeQIrbuh031zHw_hdbR
 jaclang/compiler/tests/fixtures/fam.jac,sha256=DGR9vJI8H73plbyvwdTHbsvSRd_0hT-Kq9IIIrQ1GLU,1544
 jaclang/compiler/tests/fixtures/hello_world.jac,sha256=uT67nGzdYY7YT6Xj5-OHFAZPEHfIl4zGlfyNs7-zRBI,78
 jaclang/compiler/tests/fixtures/kwesc.jac,sha256=OXxVL_fwiFuvYO1YX1RHa2hpETSpb0QD1-gMYnMY6DA,103
-jaclang/compiler/tests/fixtures/mod_doc_test.jac,sha256=p3n-JMJAerocPBA0p_MGf_F7KY-OosIqjHEqcjVrB30,31
+jaclang/compiler/tests/fixtures/mod_doc_test.jac,sha256=aFZpjn7V5lvCHp0lPoGXtdkcY3CK8_-SKeZGruutv4Y,35
 jaclang/compiler/tests/fixtures/staticcheck.jac,sha256=t849--dTkSSjCJX1OiMV-lgao_hIDSKwKVs-aS6IwK8,342
 jaclang/compiler/tests/fixtures/stuff.jac,sha256=qOq6WOwhlprMmJpiqQudgqnr4qTd9uhulQSDGQ3o6sY,82
 jaclang/compiler/tests/test_importer.py,sha256=JNmte5FsHhnng9jzw7N5BenflAFCasuhezN1sytDVyg,1739
 jaclang/compiler/tests/test_parser.py,sha256=C81mUo8EGwypPTTLRVS9BglP0Dyye9xaPSQtw7cwnnI,4814
-jaclang/compiler/tests/test_workspace.py,sha256=SEBcvz_daTbonrLHK9FbjiH86TUbOtVGH-iZ3xkJSMk,3184
-jaclang/compiler/workspace.py,sha256=I1MF2jaSylDOcQQV4Ez3svi4FdOyfmbNupuZT7q9aFQ,7797
 jaclang/core/__init__.py,sha256=jDDYBCV82qPhmcDVk3NIvHbhng0ebSrXD3xrojg0-eo,34
 jaclang/core/aott.py,sha256=MMFmel9cf1KrREjLUY9vV0b38pdb_4N3pxe5jMedBYA,7582
 jaclang/core/construct.py,sha256=ZwgOO-P2OTv8d7mnxBkRg-AitrzYxsbFNqJZjRE9YqM,18649
@@ -134,7 +132,8 @@ jaclang/core/registry.py,sha256=4uuXahPN4SMVEWwJ6Gjm5LM14rePMGoyjQtSbDQmQZs,4178
 jaclang/core/shelve_storage.py,sha256=UsZRHM8KPGUlZTX_bfcxzabInNrTaQVNMatQifycMYg,1692
 jaclang/core/utils.py,sha256=5e4DyjtSweFxKeIuEyeYGV2MsuTtfnncfIwRdoyFdys,7736
 jaclang/langserve/__init__.py,sha256=3qbnivBBcLZCfmDYRMIeKkG08Lx7XQsJJg-qG8TU8yc,51
-jaclang/langserve/server.py,sha256=6SSsYDU6OBNHbgO0p6O38yrLZrjqFfpiRMwVnA79XJs,3553
+jaclang/langserve/engine.py,sha256=3XIOhM8S5mlnfS42po8DKPlg4ptGfDMmYmlF8grnsGs,10079
+jaclang/langserve/server.py,sha256=17u6mgK4JgLcnnlpixHmOXKj5-OJiwUurMXJ9Qt7s4Q,3992
 jaclang/langserve/tests/__init__.py,sha256=iDM47k6c3vahaWhwxpbkdEOshbmX-Zl5x669VONjS2I,23
 jaclang/langserve/tests/defaults.py,sha256=8UWHuCHY-WatPcWFhyX9-4KLuJgODTlLNj0wNnKomIM,7608
 jaclang/langserve/tests/fixtures/hello.jac,sha256=iRMKtYVCw1zLvjOQbj3q__3Manj1Di1YeDTNMEvYtBc,36
@@ -145,10 +144,10 @@ jaclang/langserve/tests/pylsp_jsonrpc/exceptions.py,sha256=NGHeFQawZcjoLUcgDmY3b
 jaclang/langserve/tests/pylsp_jsonrpc/streams.py,sha256=R80_FvICIkrbdGmNtlemWYaxrr7-XldPgLaASnyv0W8,3332
 jaclang/langserve/tests/session.py,sha256=3pIRoQjZnsnUWIYnO2SpK7c1PAiHMCFrrStNK2tawRM,9572
 jaclang/langserve/tests/test_server.py,sha256=Zqo4bnlUg9TH1xHSpT4VBpTefT6tLCWjOZbFI9hEzUs,1411
-jaclang/langserve/utils.py,sha256=VsSdZQNVW5lS8ko8z-h4CnbCugs4UK44NLAqYqTGjwA,1490
+jaclang/langserve/utils.py,sha256=p0ohiZwvasbBWY-jtHj5lULL3ZYPXuc9B80eFzhk5TQ,1602
 jaclang/plugin/__init__.py,sha256=5t2krHKt_44PrCTGojzxEimxpNHYVQcn89jAiCSXE_k,165
 jaclang/plugin/builtin.py,sha256=PP2Vs4p_oDbGYEx0iBFDYH49I4uSRnNVWgx2aOzorVA,1187
-jaclang/plugin/default.py,sha256=EegsveW7I41Pvkh261LVr3smC08rcbUXLBkrhLTh9mY,27142
+jaclang/plugin/default.py,sha256=bi8qyiKkXAwr-TjT_VSI0_KSW4l5fqHCGp7dV0egfI0,27142
 jaclang/plugin/feature.py,sha256=Qi30JWJvt51s9nx3eJ0_BSTYIeTYLHe-e26y0IjJLz8,9444
 jaclang/plugin/spec.py,sha256=mJRUMGaIhlHbZIvO2J-A1q3eNhnIWJ0iBCPmxhHiHx4,9043
 jaclang/plugin/tests/__init__.py,sha256=rn_tNG8jCHWwBc_rx4yFkGc4N1GISb7aPuTFVRTvrTk,38
@@ -1470,7 +1469,7 @@ jaclang/vendor/typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjW
 jaclang/vendor/typing_extensions-4.12.2.dist-info/RECORD,sha256=XS4fBVrPI7kaNZ56Ggl2RGa76jySWLqTzcrUpZIQTVM,418
 jaclang/vendor/typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
 jaclang/vendor/typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451
-jaclang-0.6.5.dist-info/METADATA,sha256=6vtnoi2-XOXoeB-n3ZgVJv5X7qAQ4C8p-LQglGBl-nc,4213
-jaclang-0.6.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jaclang-0.6.5.dist-info/entry_points.txt,sha256=8sMi4Tvi9f8tQDN2QAXsSA2icO27zQ4GgEdph6bNEZM,49
-jaclang-0.6.5.dist-info/RECORD,,
+jaclang-0.7.0.dist-info/METADATA,sha256=t3CGvduif1vz_lYjQFxjon55vqB3fO2adkxvMxHHxXw,4756
+jaclang-0.7.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+jaclang-0.7.0.dist-info/entry_points.txt,sha256=8sMi4Tvi9f8tQDN2QAXsSA2icO27zQ4GgEdph6bNEZM,49
+jaclang-0.7.0.dist-info/RECORD,,

jaclang/compiler/tests/test_workspace.py

@@ -1,93 +0,0 @@
-"""Tests for Jac Workspace."""
-
-import os
-
-from jaclang.compiler.workspace import Workspace
-from jaclang.utils.test import TestCase
-
-
-class TestWorkspace(TestCase):
-    """Test Jac Workspace."""
-
-    def test_workspace_basic(self) -> None:
-        """Basic test of functionarlity."""
-        ws = Workspace(path=os.path.join(os.path.dirname(__file__)))
-        self.assertGreater(len(ws.modules.keys()), 4)
-
-    def test_dependecies_basic(self) -> None:
-        """Basic test of functionarlity."""
-        ws = Workspace(path=os.path.join(os.path.dirname(__file__)))
-        key = [i for i in ws.modules.keys() if "fam.jac" in i][0]
-        self.assertGreater(len(ws.get_dependencies(key)), 0)
-
-    def test_symbols_basic(self) -> None:
-        """Basic test of functionarlity."""
-        ws = Workspace(path=os.path.join(os.path.dirname(__file__)))
-        key = [i for i in ws.modules.keys() if "fam.jac" in i][0]
-        self.assertGreater(len(ws.get_symbols(key)), 5)
-
-    def test_get_defs_basic(self) -> None:
-        """Basic test of functionarlity."""
-        ws = Workspace(path=os.path.join(os.path.dirname(__file__)))
-        key = [i for i in ws.modules.keys() if "fam.jac" in i][0]
-        self.assertGreater(len(ws.get_definitions(key)), 5)
-
-    def test_get_uses_basic(self) -> None:
-        """Basic test of functionarlity."""
-        ws = Workspace(path=os.path.join(os.path.dirname(__file__)))
-        key = [i for i in ws.modules.keys() if "fam.jac" in i][0]
-        self.assertGreater(len(ws.get_uses(key)), 5)
-
-    def test_man_code_dir(self) -> None:
-        """Test of circle workspace."""
-        loc = os.path.join(os.path.dirname(__file__))
-        ws = Workspace(path=loc + "/../../../examples/manual_code")
-        key = [i for i in ws.modules.keys() if "circle.jac" in i][0]
-        # print(ws.modules[key].ir.sym_tab.pp())
-        # for i in ws.get_symbols(key):
-        #     print(i.decl.pp(depth=2))
-        out = ""
-        for i in ws.get_uses(key):
-            # print(i.pp(depth=2).strip())
-            out += i.pp(depth=2)
-        for i in [
-            "math",
-            "calculate_area",
-            "RAD",
-            "expected_area",
-            "Circle",
-            "c",
-            "ShapeType",
-            "float",
-            "radius",
-            "CIRCLE",
-            "Shape",
-            "__init__",
-            "print",
-        ]:
-            self.assertIn(i, out)
-
-    # def test_decl_impl(self) -> None:
-    #     """Test of circle workspace."""
-    #     loc = os.path.join(os.path.dirname(__file__))
-    #     ws = Workspace(path=loc + "/../../../examples/manual_code")
-    #     key = [i for i in ws.modules.keys() if "circle_clean.jac" in i][0]
-    #     out = ""
-    #     for i in ws.get_uses(key):
-    #         out += i.pp(depth=2)
-    #     for i in [
-    #         "math",
-    #         "calculate_area",
-    #         "RAD",
-    #         "expected_area",
-    #         "Circle",
-    #         "c",
-    #         "ShapeType",
-    #         "float",
-    #         "radius",
-    #         "CIRCLE",
-    #         "Shape",
-    #         "__init__",
-    #         "print",
-    #     ]:
-    #         self.assertIn(i, out)

jaclang/compiler/workspace.py

@@ -1,234 +0,0 @@
-"""Living Workspace of Jac project."""
-
-from __future__ import annotations
-
-import os
-from typing import Optional, Sequence
-
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_str_to_pass
-from jaclang.compiler.passes.main import DefUsePass, schedules
-from jaclang.compiler.passes.transform import Alert
-from jaclang.compiler.symtable import Symbol, SymbolTable
-
-
-def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> Sequence[SymbolTable]:
-    """Iterate through symbol table."""
-    sym_tabs = (
-        [sym_tab]
-        if not (
-            isinstance(sym_tab.owner, ast.Module)
-            and sym_tab.owner.loc.mod_path != file_path
-        )
-        else []
-    )
-    for i in sym_tab.kid:
-        sym_tabs += sym_tab_list(i, file_path=file_path)
-    return sym_tabs
-
-
-class ModuleInfo:
-    """Module IR and Stats."""
-
-    def __init__(
-        self,
-        ir: Optional[ast.Module],
-        errors: Sequence[Alert],
-        warnings: Sequence[Alert],
-    ) -> None:
-        """Initialize module info."""
-        self.ir = ir
-        self.errors = errors
-        self.warnings = warnings
-
-
-class Workspace:
-    """Class for managing workspace."""
-
-    def __init__(
-        self, path: str, lazy_parse: bool = False, type_check: bool = False
-    ) -> None:
-        """Initialize workspace."""
-        self.path = path
-        self.modules: dict[str, ModuleInfo] = {}
-        self.lazy_parse = lazy_parse
-        self.type_check = type_check
-        self.rebuild_workspace()
-
-    def rebuild_workspace(self) -> None:
-        """Rebuild workspace."""
-        self.modules = {}
-        for file in [
-            os.path.normpath(os.path.join(root, name))
-            for root, _, files in os.walk(self.path)
-            for name in files
-            if name.endswith(".jac")
-        ]:
-            if file in self.modules:
-                continue
-            if self.lazy_parse:
-                # If lazy_parse is True, add the file to modules with empty IR
-                self.modules[file] = ModuleInfo(
-                    ir=None,
-                    errors=[],
-                    warnings=[],
-                )
-                continue
-
-            with open(file, "r") as f:
-                source = f.read()
-            build = jac_str_to_pass(
-                jac_str=source,
-                file_path=file,
-                schedule=(
-                    schedules.py_code_gen_typed
-                    if self.type_check
-                    else schedules.py_code_gen
-                ),
-                target=DefUsePass if not self.type_check else None,
-            )
-            if not isinstance(build.ir, ast.Module):
-                src = ast.JacSource(source, mod_path=file)
-                self.modules[file] = ModuleInfo(
-                    ir=ast.Module(
-                        name="",
-                        doc=None,
-                        body=[],
-                        source=src,
-                        is_imported=False,
-                        kid=[src],
-                    ),
-                    errors=build.errors_had,
-                    warnings=build.warnings_had,
-                )
-                continue
-            self.modules[file] = ModuleInfo(
-                ir=build.ir,
-                errors=build.errors_had,
-                warnings=build.warnings_had,
-            )
-            if build.ir:
-                for sub in build.ir.mod_deps:
-                    self.modules[sub] = ModuleInfo(
-                        ir=build.ir.mod_deps[sub],
-                        errors=build.errors_had,
-                        warnings=build.warnings_had,
-                    )
-
-    def rebuild_file(
-        self, file_path: str, deep: bool = False, source: str = ""
-    ) -> bool:
-        """Rebuild a file."""
-        if source == "":
-            with open(file_path, "r") as f:
-                source = f.read()
-        build = jac_str_to_pass(
-            jac_str=source,
-            file_path=file_path,
-            schedule=(
-                schedules.py_code_gen_typed
-                if self.type_check
-                else schedules.py_code_gen
-            ),
-            target=DefUsePass if not self.type_check else None,
-        )
-        if not isinstance(build.ir, ast.Module):
-            src = ast.JacSource(source, mod_path=file_path)
-            self.modules[file_path] = ModuleInfo(
-                ir=ast.Module(
-                    name="",
-                    doc=None,
-                    body=[],
-                    source=src,
-                    is_imported=False,
-                    kid=[src],
-                ),
-                errors=build.errors_had,
-                warnings=build.warnings_had,
-            )
-            return False
-        self.modules[file_path] = ModuleInfo(
-            ir=build.ir,
-            errors=build.errors_had,
-            warnings=build.warnings_had,
-        )
-        if deep:
-            for sub in build.ir.mod_deps:
-                self.modules[sub] = ModuleInfo(
-                    ir=build.ir.mod_deps[sub],
-                    errors=build.errors_had,
-                    warnings=build.warnings_had,
-                )
-        return True
-
-    def add_file(self, file_path: str) -> None:
-        """Add a file to the workspace."""
-        self.rebuild_file(file_path)
-
-    def del_file(self, file_path: str) -> None:
-        """Delete a file from the workspace."""
-        del self.modules[file_path]
-
-    def file_list(self) -> Sequence[str]:
-        """Return a list of files in the workspace."""
-        return list(self.modules.keys())
-
-    def get_dependencies(
-        self, file_path: str, deep: bool = False
-    ) -> list[ast.ModulePath]:
-        """Return a list of dependencies for a file."""
-        mod_ir = self.modules[file_path].ir
-        if deep:
-            return (
-                [
-                    i
-                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
-                    if i.parent_of_type(ast.Import).hint.tag.value == "jac"
-                ]
-                if mod_ir
-                else []
-            )
-        else:
-            return (
-                [
-                    i
-                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
-                    if i.loc.mod_path == file_path
-                    and i.parent_of_type(ast.Import).hint.tag.value == "jac"
-                ]
-                if mod_ir
-                else []
-            )
-
-    def get_symbols(self, file_path: str) -> Sequence[Symbol]:
-        """Return a list of symbols for a file."""
-        symbols = []
-        mod_ir = self.modules[file_path].ir
-        if file_path in self.modules:
-            root_table = mod_ir.sym_tab if mod_ir else None
-            if file_path in self.modules and root_table:
-                for i in sym_tab_list(sym_tab=root_table, file_path=file_path):
-                    symbols += list(i.tab.values())
-        return symbols
-
-    def get_definitions(
-        self, file_path: str
-    ) -> Sequence[ast.AstSymbolNode]:  # need test
-        """Return a list of definitions for a file."""
-        defs = []
-        for i in self.get_symbols(file_path):
-            defs += i.defn
-        return defs
-
-    def get_uses(self, file_path: str) -> Sequence[ast.AstSymbolNode]:  # need test
-        """Return a list of definitions for a file."""
-        mod_ir = self.modules[file_path].ir
-        uses: list[ast.AstSymbolNode] = []
-        if self.lazy_parse:
-            return uses
-        if file_path in self.modules:
-            root_table = mod_ir.sym_tab if mod_ir else None
-            if file_path in self.modules and root_table:
-                for i in sym_tab_list(sym_tab=root_table, file_path=file_path):
-                    uses += i.uses
-        return uses