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

jaclang/langserve/engine.py

@@ -2,57 +2,73 @@
 
 from __future__ import annotations
 
+from enum import IntEnum
 from hashlib import md5
-from typing import Sequence, Type
+from typing import Optional, Sequence
 
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_pass_to_pass, jac_str_to_pass
+from jaclang.compiler.compile import jac_ir_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.main.schedules import type_checker_sched
 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.langserve.utils import find_deepest_node_at_pos
+from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
-from jaclang.vendor.pygls.workspace.text_document import TextDocument
 
 import lsprotocol.types as lspt
 
 
+class ALev(IntEnum):
+    """Analysis Level."""
+
+    QUICK = 1
+    DEEP = 2
+    TYPE = 3
+
+
 class ModuleInfo:
     """Module IR and Stats."""
 
     def __init__(
         self,
         ir: ast.Module,
-        to_pass: Pass,
         errors: Sequence[Alert],
         warnings: Sequence[Alert],
+        alev: ALev,
+        parent: Optional[ModuleInfo] = None,
     ) -> None:
         """Initialize module info."""
         self.ir = ir
-        self.at_pass = to_pass
         self.errors = errors
         self.warnings = warnings
+        self.alev = alev
+        self.parent: Optional[ModuleInfo] = parent
         self.diagnostics = self.gen_diagnostics()
 
+    @property
+    def uri(self) -> str:
+        """Return uri."""
+        return uris.from_fs_path(self.ir.loc.mod_path)
+
+    @property
+    def has_syntax_error(self) -> bool:
+        """Return if there are syntax errors."""
+        return len(self.errors) > 0 and self.alev == ALev.QUICK
+
     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
+                        line=error.loc.first_line - 1, character=error.loc.col_start - 1
                     ),
                     end=lspt.Position(
-                        line=error.loc.last_line,
-                        character=error.loc.col_end,
+                        line=error.loc.last_line - 1,
+                        character=error.loc.col_end - 1,
                     ),
                 ),
                 message=error.msg,
@@ -63,11 +79,12 @@ class ModuleInfo:
             lspt.Diagnostic(
                 range=lspt.Range(
                     start=lspt.Position(
-                        line=warning.loc.first_line, character=warning.loc.col_start
+                        line=warning.loc.first_line - 1,
+                        character=warning.loc.col_start - 1,
                     ),
                     end=lspt.Position(
-                        line=warning.loc.last_line,
-                        character=warning.loc.col_end,
+                        line=warning.loc.last_line - 1,
+                        character=warning.loc.col_end - 1,
                     ),
                 ),
                 message=warning.msg,
@@ -85,18 +102,17 @@ class JacLangServer(LanguageServer):
         super().__init__("jac-lsp", "v0.1")
         self.modules: dict[str, ModuleInfo] = {}
 
-    def module_not_diff(self, doc: TextDocument) -> bool:
+    def module_not_diff(self, uri: str, alev: ALev) -> bool:
         """Check if module was changed."""
+        doc = self.workspace.get_document(uri)
         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
+            and (
+                self.modules[doc.uri].alev >= alev
+                or self.modules[doc.uri].has_syntax_error
+            )
         )
 
     def push_diagnostics(self, file_path: str) -> None:
@@ -107,66 +123,81 @@ class JacLangServer(LanguageServer):
                 self.modules[file_path].diagnostics,
             )
 
+    def unwind_to_parent(self, file_path: str) -> str:
+        """Unwind to parent."""
+        if file_path in self.modules:
+            while cur := self.modules[file_path].parent:
+                file_path = cur.uri
+        return file_path
+
+    def update_modules(self, file_path: str, build: Pass, alev: ALev) -> None:
+        """Update modules."""
+        if not isinstance(build.ir, ast.Module):
+            self.log_error("Error with module build.")
+            return
+        self.modules[file_path] = ModuleInfo(
+            ir=build.ir,
+            errors=[
+                i
+                for i in build.errors_had
+                if i.loc.mod_path == uris.to_fs_path(file_path)
+            ],
+            warnings=[
+                i
+                for i in build.warnings_had
+                if i.loc.mod_path == uris.to_fs_path(file_path)
+            ],
+            alev=alev,
+        )
+        for p in build.ir.mod_deps.keys():
+            uri = uris.from_fs_path(p)
+            self.modules[uri] = ModuleInfo(
+                ir=build.ir.mod_deps[p],
+                errors=[i for i in build.errors_had if i.loc.mod_path == p],
+                warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
+                alev=alev,
+            )
+
     def quick_check(self, file_path: str) -> None:
         """Rebuild a file."""
-        document = self.workspace.get_document(file_path)
-        if self.module_not_diff(document):
+        if self.module_not_diff(file_path, ALev.QUICK):
             return
         try:
+            document = self.workspace.get_document(file_path)
             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,
-            )
+        self.update_modules(file_path, build, ALev.QUICK)
 
     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
-        ):
+        if file_path in self.modules:
+            self.quick_check(file_path)
+        if self.module_not_diff(file_path, ALev.DEEP):
             return
         try:
-            build = jac_pass_to_pass(in_pass=self.modules[file_path].at_pass)
+            file_path = self.unwind_to_parent(file_path)
+            build = jac_ir_to_pass(ir=self.modules[file_path].ir)
         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,
-            )
+        self.update_modules(file_path, build, ALev.DEEP)
 
     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
-        ):
+        if file_path not in self.modules:
+            self.deep_check(file_path)
+        if self.module_not_diff(file_path, ALev.TYPE):
             return
         try:
-            build = jac_pass_to_pass(
-                in_pass=self.modules[file_path].at_pass,
-                target=AccessCheckPass,
-                schedule=py_code_gen_typed,
+            file_path = self.unwind_to_parent(file_path)
+            build = jac_ir_to_pass(
+                ir=self.modules[file_path].ir, schedule=type_checker_sched
             )
         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,
-            )
+        self.update_modules(file_path, build, ALev.TYPE)
 
     def get_completion(
         self, file_path: str, position: lspt.Position
@@ -224,52 +255,109 @@ class JacLangServer(LanguageServer):
             )
         ]
 
-    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_hover_info(
+        self, file_path: str, position: lspt.Position
+    ) -> Optional[lspt.Hover]:
+        """Return hover information for a file."""
+        node_selected = find_deepest_node_at_pos(
+            self.modules[file_path].ir, position.line, position.character
+        )
+        value = self.get_node_info(node_selected) if node_selected else None
+        if value:
+            return lspt.Hover(
+                contents=lspt.MarkupContent(
+                    kind=lspt.MarkupKind.PlainText, value=f"{value}"
+                ),
             )
+        return None
 
-    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 get_node_info(self, node: ast.AstNode) -> Optional[str]:
+        """Extract meaningful information from the AST node."""
+        try:
+            if isinstance(node, ast.Token):
+                if isinstance(node, ast.AstSymbolNode):
+                    if isinstance(node, ast.String):
+                        return None
+                    if node.sym_link and node.sym_link.decl:
+                        decl_node = node.sym_link.decl
+                        if isinstance(decl_node, ast.Architype):
+                            if decl_node.doc:
+                                node_info = f"({decl_node.arch_type.value}) {node.value} \n{decl_node.doc.lit_value}"
+                            else:
+                                node_info = (
+                                    f"({decl_node.arch_type.value}) {node.value}"
+                                )
+                            if decl_node.semstr:
+                                node_info += f"\n{decl_node.semstr.lit_value}"
+                        elif isinstance(decl_node, ast.Ability):
+                            node_info = f"(ability) can {node.value}"
+                            if decl_node.signature:
+                                node_info += f" {decl_node.signature.unparse()}"
+                            if decl_node.doc:
+                                node_info += f"\n{decl_node.doc.lit_value}"
+                            if decl_node.semstr:
+                                node_info += f"\n{decl_node.semstr.lit_value}"
+                        elif isinstance(decl_node, ast.Name):
+                            if (
+                                decl_node.parent
+                                and isinstance(decl_node.parent, ast.SubNodeList)
+                                and decl_node.parent.parent
+                                and isinstance(decl_node.parent.parent, ast.Assignment)
+                                and decl_node.parent.parent.type_tag
+                            ):
+                                node_info = (
+                                    f"(variable) {decl_node.value}: "
+                                    f"{decl_node.parent.parent.type_tag.unparse()}"
+                                )
+                                if decl_node.parent.parent.semstr:
+                                    node_info += (
+                                        f"\n{decl_node.parent.parent.semstr.lit_value}"
+                                    )
+                            else:
+                                if decl_node.value in [
+                                    "str",
+                                    "int",
+                                    "float",
+                                    "bool",
+                                    "bytes",
+                                    "list",
+                                    "tuple",
+                                    "set",
+                                    "dict",
+                                    "type",
+                                ]:
+                                    node_info = f"({decl_node.value}) Built-in type"
+                                else:
+                                    node_info = f"(variable) {decl_node.value}: None"
+                        elif isinstance(decl_node, ast.HasVar):
+                            if decl_node.type_tag:
+                                node_info = f"(variable) {decl_node.name.value} {decl_node.type_tag.unparse()}"
+                            else:
+                                node_info = f"(variable) {decl_node.name.value}"
+                            if decl_node.semstr:
+                                node_info += f"\n{decl_node.semstr.lit_value}"
+                        elif isinstance(decl_node, ast.ParamVar):
+                            if decl_node.type_tag:
+                                node_info = f"(parameter) {decl_node.name.value} {decl_node.type_tag.unparse()}"
+                            else:
+                                node_info = f"(parameter) {decl_node.name.value}"
+                            if decl_node.semstr:
+                                node_info += f"\n{decl_node.semstr.lit_value}"
+                        elif isinstance(decl_node, ast.ModuleItem):
+                            node_info = (
+                                f"(ModuleItem) {node.value}"  # TODO: Add more info
+                            )
+                        else:
+                            node_info = f"{node.value}"
+                    else:
+                        node_info = f"{node.value}"  # non symbol node
+                else:
+                    return None
+            else:
+                return None
+        except AttributeError as e:
+            self.log_warning(f"Attribute error when accessing node attributes: {e}")
+        return node_info.strip()
 
     def log_error(self, message: str) -> None:
         """Log an error message."""

jaclang/langserve/server.py

@@ -29,7 +29,6 @@ def analyze_and_publish(ls: JacLangServer, uri: str) -> None:
 
     analysis_thread = threading.Thread(target=run_analysis)
     analysis_thread.start()
-    ls.log_info("Analysis restarted")
 
 
 def stop_analysis() -> None:
@@ -130,6 +129,14 @@ def formatting(
     return ls.formatted_jac(params.text_document.uri)
 
 
+@server.feature(lspt.TEXT_DOCUMENT_HOVER, lspt.HoverOptions(work_done_progress=True))
+def hover(
+    ls: JacLangServer, params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Hover]:
+    """Provide hover information for the given hover request."""
+    return ls.get_hover_info(params.text_document.uri, params.position)
+
+
 def run_lang_server() -> None:
     """Run the language server."""
     server.start_io()

jaclang/langserve/tests/fixtures/circle.jac

@@ -0,0 +1,73 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+# Module-level global var
+
+glob RAD = 5;
+
+"""Function to calculate the area of a circle."""
+can calculate_area(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+#* (This is multiline comments in Jac)
+Above we have the demonstration of a function to calculate the area of a circle.
+Below we have the demonstration of a class to calculate the area of a circle.
+*#
+
+"""Enum for shape types"""
+enum ShapeType  {
+    CIRCLE="Circle",
+    UNKNOWN="Unknown"
+}
+
+"""Base class for a shape."""
+obj Shape {
+    has shape_type: ShapeType;
+
+    """Abstract method to calculate the area of a shape."""
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    can init(radius: float) {
+        super.init(ShapeType.CIRCLE);
+        self.radius = radius;
+    }
+
+    """Overridden method to calculate the area of the circle."""
+    override can area -> float {
+        return math.pi * self.radius * self.radius;
+    }
+}
+
+with entry {
+    c = Circle(RAD);
+}
+# Global also works here
+
+with entry:__main__ {
+# To run the program functionality
+print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
+print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+}
+# Unit Tests!
+
+glob expected_area = 78.53981633974483;
+
+test calc_area   {
+    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test circle_area   {
+    c = Circle(RAD);
+    check.assertAlmostEqual(c.area(), expected_area);
+}
+
+test circle_type   {
+    c = Circle(RAD);
+    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/langserve/tests/fixtures/circle_err.jac

@@ -0,0 +1,73 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+# Module-level global var
+
+glob RAD = 5;
+
+"""Function to calculate the area of a circle."""
+can calculate_area(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+#* (This is multiline comments in Jac)
+Above we have the demonstration of a function to calculate the area of a circle.
+Below we have the demonstration of a class to calculate the area of a circle.
+*#
+
+"""Enum for shape types"""
+enum ShapeType  {
+    CIRCLE="Circle"
+    UNKNOWN="Unknown"
+}
+
+"""Base class for a shape."""
+obj Shape {
+    has shape_type: ShapeType;
+
+    """Abstract method to calculate the area of a shape."""
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    can init(radius: float) {
+        super.init(ShapeType.CIRCLE);
+        self.radius = radius;
+    }
+
+    """Overridden method to calculate the area of the circle."""
+    override can area -> float {
+        return math.pi * self.radius * self.radius;
+    }
+}
+
+with entry {
+    c = Circle(RAD);
+}
+# Global also works here
+
+with entry:__main__ {
+# To run the program functionality
+print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
+print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+}
+# Unit Tests!
+
+glob expected_area = 78.53981633974483;
+
+test calc_area   {
+    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test circle_area   {
+    c = Circle(RAD);
+    check.assertAlmostEqual(c.area(), expected_area);
+}
+
+test circle_type   {
+    c = Circle(RAD);
+    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/langserve/tests/fixtures/circle_pure.impl.jac

@@ -0,0 +1,28 @@
+"""Enum for shape types"""
+
+:enum:ShapeType {
+    CIRCLE="Circle",
+    UNKNOWN="Unknown"
+}
+
+"""Function to calculate the area of a circle."""
+:can:calculate_area
+(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+
+:obj:Circle:can:init
+(radius: float) {
+    self.radius = radius;
+    super.init(ShapeType.CIRCLE);
+}
+
+"""Overridden method to calculate the area of the circle."""
+:obj:Circle:can:area -> float {
+    return math.pi * self.radius * self.radius;
+}
+
+:can:main_run {
+    print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
+    print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+}

jaclang/langserve/tests/fixtures/circle_pure.jac

@@ -0,0 +1,34 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+
+enum ShapeType;
+
+can calculate_area(radius: float) -> float;
+can main_run;
+
+"""Base class for a shape."""
+obj Shape {
+    has shape_type: ShapeType;
+
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    has radius: float;
+
+    can init(radius: float);
+    can area -> float;
+}
+# Radius of the demo circle
+
+glob RAD = 5, c = Circle(radius=RAD);
+
+"""Here we run the main program."""
+with entry:__main__ {
+    main_run();
+}

jaclang/langserve/tests/fixtures/circle_pure_err.impl.jac

@@ -0,0 +1,32 @@
+"""Enum for shape types"""
+
+:enum:ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
+}
+
+"""Function to calculate the area of a circle."""
+:can:calculate_area
+(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+
+:obj:Circle:can:init
+(radius: float) {
+    self.radius = radius;
+    super.init(ShapeType.CIRCLE);
+}
+
+"""Overridden method to calculate the area of the circle."""
+:obj:Circle:can:area -> float {
+    return math.pi * self.radius * self.radius;
+}
+
+:can:main_run {
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
+}