jaclang 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/langserve/engine.jac

@@ -8,7 +8,6 @@ import from typing { Callable , Optional }
 
 import jaclang.compiler.unitree as uni;
 import from jaclang { JacMachineInterface as Jac }
-import from jaclang.compiler.passes.main { CompilerMode as CMode }
 import from jaclang.compiler.program { JacProgram }
 import from jaclang.compiler.unitree { UniScopeNode }
 import from sem_manager { SemTokManager }
@@ -33,9 +32,9 @@ class ModuleManager {
     ) -> None {
         file_path = file_path.removeprefix('file://');
         self.program.mod.hub[file_path] = build;
-        self.sem_managers[file_path] = SemTokManager(ir=build);
         if update_annexed {
-            for (p,mod) in self.program.mod.hub.items() { if p != file_path {
+            self.sem_managers[file_path] = SemTokManager(ir=build);
+            for (p, mod) in self.program.mod.hub.items() { if p != file_path {
                 self.sem_managers[p] = SemTokManager(ir=mod);
             } }
         }
@@ -43,8 +42,10 @@ class ModuleManager {
 
     """Remove errors and warnings for a specific file from the lists."""
     def clear_alerts_for_file(self: ModuleManager, file_path_fs: str) -> None {
-        self.program.errors_had = [ e for e in self.program.errors_had if e.loc.mod_path != file_path_fs ];
-        self.program.warnings_had = [ w for w in self.program.warnings_had if w.loc.mod_path != file_path_fs ];
+        self.program.errors_had =
+            [ e for e in self.program.errors_had if e.loc.mod_path != file_path_fs ];
+        self.program.warnings_had =
+            [ w for w in self.program.warnings_had if w.loc.mod_path != file_path_fs ];
     }
 }
 
@@ -56,16 +57,17 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         LanguageServer.init(self, 'jac-lsp', 'v0.1');
         JacProgram.init(self);
         self.executor = ThreadPoolExecutor();
-        self.tasks: <>dict[(str,asyncio.Task)] = {};
-        self.sem_managers: <>dict[(str,SemTokManager)] = {};
+        self.tasks: <>dict[(str, asyncio.Task)] = {} ;
+        self.sem_managers: <>dict[(str, SemTokManager)] = {} ;
         self.module_manager = ModuleManager(self, self.sem_managers);
     }
 
     """Return diagnostics for all files as a dict {uri: diagnostics}."""
     @ property
     def diagnostics(self: JacLangServer, ) -> <>dict[str, <>list] {
-        result = {};
-        for file_path in self.mod.hub { uri = uris.from_fs_path(file_path); result[uri] = utils.gen_diagnostics(uri, self.errors_had, self.warnings_had); }
+        result = {} ;
+        for file_path in self.mod.hub { uri = uris.from_fs_path(file_path); result[uri] =
+            utils.gen_diagnostics(uri, self.errors_had, self.warnings_had); }
         return result;
     }
 
@@ -90,28 +92,30 @@ class JacLangServer ( JacProgram , LanguageServer ) {
 
     """Rebuild a file (syntax only)."""
     def quick_check(self: JacLangServer, file_path: str) -> bool {
-        try { file_path_fs = file_path.removeprefix('file://'); document = self.workspace.get_text_document(file_path); self._clear_alerts_for_file(file_path_fs); build = self.compile_from_str(
-            source_str=document.source, file_path=document.path, mode=CMode.PARSE
-        ); self.update_modules(file_path_fs, build, need=False); self.publish_diagnostics(
+        try { file_path_fs = file_path.removeprefix('file://'); document =
+            self.workspace.get_text_document(file_path); self._clear_alerts_for_file(file_path_fs); build =
+            self.compile(use_str=document.source, file_path=document.path); self.update_modules(file_path_fs, build, need=False); self.publish_diagnostics(
             file_path, utils.gen_diagnostics(
                 file_path, self.errors_had, self.warnings_had
             )
-        ); return len(self.errors_had) == 0; } except Exception as e { self.log_error(f"'Error during syntax check: '{e}"); return False; }
+        ); build_errors =
+            [ e for e in self.errors_had if e.loc.mod_path == file_path_fs ]; return len(build_errors) == 0;  } except Exception as e { self.log_error(f"'Error during syntax check: '{e}"); return False;  }
     }
 
     """Rebuild a file and its dependencies (typecheck)."""
     def deep_check(
         self: JacLangServer, file_path: str, annex_view: Optional[str] = None
     ) -> bool {
-        try { start_time = time.time(); file_path_fs = file_path.removeprefix('file://'); document = self.workspace.get_text_document(file_path); self._clear_alerts_for_file(file_path_fs); build = self.compile_from_str(
-            source_str=document.source, file_path=document.path, mode=CMode.TYPECHECK
-        ); self.update_modules(file_path_fs, build); if build.annexable_by {
+        try { start_time = time.time(); file_path_fs =
+            file_path.removeprefix('file://'); document =
+            self.workspace.get_text_document(file_path); self._clear_alerts_for_file(file_path_fs); build =
+            self.build(use_str=document.source, file_path=document.path); self.update_modules(file_path_fs, build); if build.annexable_by {
             return self.deep_check(
                 uris.from_fs_path(build.annexable_by), annex_view=file_path
             );
         } self.publish_diagnostics(
-            annex_view if annex_view else file_path , utils.gen_diagnostics(
-                annex_view if annex_view else file_path , self.errors_had, self.warnings_had
+            annex_view if annex_view else file_path, utils.gen_diagnostics(
+                annex_view if annex_view else file_path, self.errors_had, self.warnings_had
             )
         ); if annex_view {
             self.publish_diagnostics(
@@ -121,12 +125,12 @@ class JacLangServer ( JacProgram , LanguageServer ) {
             );
         } self.log_py(
             f"'PROFILE: Deep check took '{(time.time() - start_time)}' seconds.'"
-        ); return len(self.errors_had) == 0; } except Exception as e { self.log_error(f"'Error during deep check: '{e}"); return False; }
+        ); return len(self.errors_had) == 0;  } except Exception as e { self.log_py(f"'Error during deep check: '{e}"); return False;  }
     }
 
     """Analyze and publish diagnostics."""
-    async def launch_quick_check(self: JacLangServer, uri: str) -> None {
-        await asyncio.get_event_loop().run_in_executor(
+    async def launch_quick_check(self: JacLangServer, uri: str) -> bool {
+        return await asyncio.get_event_loop().run_in_executor(
             self.executor, self.quick_check, uri
         );
     }
@@ -134,7 +138,7 @@ class JacLangServer ( JacProgram , LanguageServer ) {
     """Analyze and publish diagnostics."""
     async def launch_deep_check(self: JacLangServer, uri: str) -> None {
         async def run_in_executor(
-            func: Callable[([str,Optional[str]],bool)], file_path: str, annex_view: Optional[str] = None
+            func: Callable[([str, Optional[str]], bool)], file_path: str, annex_view: Optional[str] = None
         ) -> None {
             loop = asyncio.get_event_loop();
             await loop.run_in_executor(self.executor, func, file_path, annex_view);
@@ -142,7 +146,7 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         if uri in self.tasks and not self.tasks[uri].done()  {
             self.log_py(f"'Canceling '{uri}' deep check...'");
             self.tasks[uri].cancel();
-            del (self.tasks[uri],) ;
+            del (self.tasks[uri], ) ;
         }
         self.log_py(f"'Analyzing '{uri}'...'");
         task = asyncio.create_task(run_in_executor(self.deep_check, uri));
@@ -154,49 +158,42 @@ class JacLangServer ( JacProgram , LanguageServer ) {
     def get_completion(
         self: JacLangServer, file_path: str, position: lspt.Position, completion_trigger: Optional[str]
     ) -> lspt.CompletionList {
-        document = self.workspace.get_text_document(file_path);
-        mod_ir = self.get_ir(file_path);
-        if not mod_ir {
+        try { document = self.workspace.get_text_document(file_path); mod_ir =
+            self.get_ir(file_path); if not mod_ir {
             return lspt.CompletionList(is_incomplete=False, items=[]);
-        }
-        current_line = document.lines[position.line];
-        current_pos = position.character;
-        current_symbol_path = utils.parse_symbol_path(current_line, current_pos);
-        builtin_mod = next(
-            ( mod for (name,mod) in self.mod.hub.items() if 'builtins' in name )
-        );
-        builtin_tab = builtin_mod.sym_tab;
-        assert isinstance(builtin_tab, UniScopeNode) ;
-        completion_items = [];
-        node_selected = utils.find_deepest_symbol_node_at_pos(
-            mod_ir, position.line, (position.character - 2)
-        );
-        mod_tab = mod_ir.sym_tab if not node_selected else node_selected.sym_tab ;
-        current_symbol_table = mod_tab;
-        if completion_trigger == '.' {
+        } current_line = document.lines[position.line]; current_pos =
+            position.character; current_symbol_path =
+            utils.parse_symbol_path(current_line, current_pos); builtin_mod =
+            next(( mod for (name, mod) in self.mod.hub.items() if 'builtins' in name )); builtin_tab =
+            builtin_mod.sym_tab; assert isinstance(builtin_tab, UniScopeNode) ; completion_items =
+            []; node_selected =
+            utils.find_deepest_symbol_node_at_pos(
+                mod_ir, position.line, (position.character - 2)
+            ); mod_tab = mod_ir.sym_tab if not node_selected else node_selected.sym_tab; current_symbol_table =
+            mod_tab; if completion_trigger == '.' {
             if current_symbol_path {
                 temp_tab = mod_tab;
                 for symbol in current_symbol_path { if symbol == 'self' {
-                    is_ability_def = temp_tab
-                    if isinstance(temp_tab, uni.ImplDef)
-                    else temp_tab.find_parent_of_type(uni.ImplDef)
-                    ;
+                    is_ability_def =
+                        temp_tab
+                        if isinstance(temp_tab, uni.ImplDef)
+                        else temp_tab.find_parent_of_type(uni.ImplDef);
                     if not is_ability_def {
                         archi_owner = mod_tab.find_parent_of_type(uni.Archetype);
-                        temp_tab = archi_owner.sym_tab
-                        if archi_owner and archi_owner.sym_tab
-                        else mod_tab
-                        ;
+                        temp_tab =
+                            archi_owner.sym_tab
+                            if archi_owner and archi_owner.sym_tab
+                            else mod_tab;
                         continue;
                     } else {
-                        archi_owner = is_ability_def.decl_link.find_parent_of_type(uni.Archetype)
-                        if is_ability_def.decl_link
-                        else None
-                        ;
-                        temp_tab = archi_owner.sym_tab
-                        if archi_owner and archi_owner.sym_tab
-                        else temp_tab
-                        ;
+                        archi_owner =
+                            is_ability_def.decl_link.find_parent_of_type(uni.Archetype)
+                            if is_ability_def.decl_link
+                            else None;
+                        temp_tab =
+                            archi_owner.sym_tab
+                            if archi_owner and archi_owner.sym_tab
+                            else temp_tab;
                         continue;
                     }
                 } symb = temp_tab.lookup(symbol); if symb {
@@ -204,14 +201,14 @@ class JacLangServer ( JacProgram , LanguageServer ) {
                     if fetc_tab {
                         temp_tab = fetc_tab;
                     } else {
-                        temp_tab = symb.defn[0].type_sym_tab
-                        if symb.defn[0].type_sym_tab
-                        else temp_tab
-                        ;
+                        temp_tab =
+                            symb.defn[0].type_sym_tab
+                            if symb.defn[0].type_sym_tab
+                            else temp_tab;
                     }
                 } else {
                     break;
-                } }
+                }  }
                 completion_items += utils.collect_all_symbols_in_scope(
                     temp_tab, up_tree=False
                 );
@@ -230,11 +227,14 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         } elif 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)];
+            self_symbol =
+
+                [lspt.CompletionItem(
+                    label='self', kind=lspt.CompletionItemKind.Variable
+                )];
         } else {
             self_symbol = [];
-        }
-        return lspt.CompletionList(is_incomplete=False, items=completion_items);
+        }   return lspt.CompletionList(is_incomplete=False, items=completion_items);  } except Exception as e { self.log_py(f"'Error during completion: '{e}"); return lspt.CompletionList(is_incomplete=False, items=[]);  }
     }
 
     """Rename module."""
@@ -242,27 +242,30 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         if old_path in self.mod.hub and new_path != old_path  {
             self.mod.hub[new_path] = self.mod.hub[old_path];
             self.sem_managers[new_path] = self.sem_managers[old_path];
-            del (self.mod.hub[old_path],) ;
-            del (self.sem_managers[old_path],) ;
+            del (self.mod.hub[old_path], ) ;
+            del (self.sem_managers[old_path], ) ;
         }
     }
 
     """Delete module."""
     def delete_module(self: JacLangServer, uri: str) -> None {
         if uri in self.mod.hub {
-            del (self.mod.hub[uri],) ;
+            del (self.mod.hub[uri], ) ;
         }
         if uri in self.sem_managers {
-            del (self.sem_managers[uri],) ;
+            del (self.sem_managers[uri], ) ;
         }
     }
 
     """Return formatted jac."""
     def formatted_jac(self: JacLangServer, file_path: str) -> <>list[lspt.TextEdit] {
-        try { document = self.workspace.get_text_document(file_path); formatted_text = JacProgram.jac_str_formatter(
-            source_str=document.source, file_path=document.path
-        ); } except Exception as e { self.log_error(f"'Error during formatting: '{e}"); formatted_text = document.source; }
-        return [lspt.TextEdit(
+        try { document = self.workspace.get_text_document(file_path); formatted_text =
+            JacProgram.jac_str_formatter(
+                source_str=document.source, file_path=document.path
+            ); } 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
@@ -283,14 +286,13 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         if not sem_mgr {
             return None;
         }
-        token_index = utils.find_index(
-            sem_mgr.sem_tokens, position.line, position.character
-        );
+        token_index =
+            utils.find_index(sem_mgr.sem_tokens, position.line, position.character);
         if token_index is None {
             return None;
         }
         node_selected = sem_mgr.static_sem_tokens[token_index][3];
-        value = self.get_node_info(node_selected) if node_selected else None ;
+        value = self.get_node_info(node_selected) if node_selected else None;
         if value {
             return lspt.Hover(
                 contents=lspt.MarkupContent(
@@ -305,7 +307,8 @@ class JacLangServer ( JacProgram , LanguageServer ) {
     def get_node_info(self: JacLangServer, <>node: uni.AstSymbolNode) -> Optional[str] {
         try { if isinstance(<>node, uni.NameAtom) {
             <>node = <>node.name_of;
-        } access = (<>node.sym.access.value + ' ') if <>node.sym else None ; node_info = f"'('{access if access else '' }{<>node.sym_category.value}') '{<>node.sym_name}"; if <>node.name_spec.clean_type {
+        } access = (<>node.sym.access.value + ' ') if <>node.sym else None; node_info =
+            f"'('{access if access else ''}{<>node.sym_category.value}') '{<>node.sym_name}"; if <>node.name_spec.clean_type {
             node_info += f"': '{<>node.name_spec.clean_type}";
         } if isinstance(<>node, uni.AstDocNode) and <>node.doc  {
             node_info += f"'\n'{<>node.doc.value}";
@@ -338,9 +341,8 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         if not sem_mgr {
             return None;
         }
-        token_index = utils.find_index(
-            sem_mgr.sem_tokens, position.line, position.character
-        );
+        token_index =
+            utils.find_index(sem_mgr.sem_tokens, position.line, position.character);
         if token_index is None {
             return None;
         }
@@ -352,7 +354,7 @@ class JacLangServer ( JacProgram , LanguageServer ) {
              {
                 spec = node_selected.parent.parent.abs_path;
                 if spec {
-                    spec = spec[ 5 : ] if spec.startswith('File:') else spec ;
+                    spec = spec[ 5 : ] if spec.startswith('File:') else spec;
                     return lspt.Location(
                         uri=uris.from_fs_path(spec), range=lspt.Range(
                             start=lspt.Position(line=0, character=0), end=lspt.Position(line=0, character=0)
@@ -364,12 +366,13 @@ class JacLangServer ( JacProgram , LanguageServer ) {
             } elif node_selected.parent
             and isinstance(node_selected.parent, uni.ModuleItem)
              {
-                path = node_selected.parent.abs_path
-                or node_selected.parent.from_mod_path.abs_path
-                ;
-                loc_range = (0,0,0,0);
+                path =
+                    node_selected.parent.abs_path
+                    or node_selected.parent.from_mod_path.abs_path
+                    ;
+                loc_range = (0, 0, 0, 0);
                 if path and loc_range  {
-                    path = path[ 5 : ] if path.startswith('File:') else path ;
+                    path = path[ 5 : ] if path.startswith('File:') else path;
                     return lspt.Location(
                         uri=uris.from_fs_path(path), range=lspt.Range(
                             start=lspt.Position(
@@ -381,16 +384,15 @@ class JacLangServer ( JacProgram , LanguageServer ) {
             } elif isinstance(node_selected, uni.ElementStmt) {
                 return None;
             }
-            decl_node = node_selected.parent.body.target
-            if node_selected.parent
-            and isinstance(node_selected.parent, uni.AstImplNeedingNode)
-            and isinstance(node_selected.parent.body, uni.ImplDef)
-
-            else node_selected.sym.decl
-            if node_selected.sym and node_selected.sym.decl
-            else node_selected
-
-            ;
+            decl_node =
+                node_selected.parent.body.target
+                if node_selected.parent
+                and isinstance(node_selected.parent, uni.AstImplNeedingNode)
+                and isinstance(node_selected.parent.body, uni.ImplDef)
+
+                else node_selected.sym.decl
+                if node_selected.sym and node_selected.sym.decl
+                else node_selected;
             if isinstance(decl_node, list) {
                 valid_path = decl_node[0].loc.mod_path;
             } else {
@@ -402,7 +404,7 @@ class JacLangServer ( JacProgram , LanguageServer ) {
             } else {
                 valid_range = decl_node.loc;
             }
-            try { decl_range = utils.create_range(valid_range); } except ValueError { return None; }
+            try { decl_range = utils.create_range(valid_range); } except ValueError { return None;  }
             decl_location = lspt.Location(uri=decl_uri, range=decl_range);
             return decl_location;
         } else {
@@ -422,15 +424,17 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         if not sem_mgr {
             return [];
         }
-        index1 = utils.find_index(sem_mgr.sem_tokens, position.line, position.character);
+        index1 =
+            utils.find_index(sem_mgr.sem_tokens, position.line, position.character);
         if index1 is None {
             return [];
         }
         node_selected = sem_mgr.static_sem_tokens[index1][3];
         if node_selected and node_selected.sym  {
-            list_of_references: <>list[lspt.Location] = [ lspt.Location(
-                uri=uris.from_fs_path(<>node.loc.mod_path), range=utils.create_range(<>node.loc)
-            ) for <>node in node_selected.sym.uses ];
+            list_of_references: <>list[lspt.Location] =
+                [ lspt.Location(
+                    uri=uris.from_fs_path(<>node.loc.mod_path), range=utils.create_range(<>node.loc)
+                ) for <>node in node_selected.sym.uses ];
             return list_of_references;
         }
         return [];
@@ -448,16 +452,17 @@ class JacLangServer ( JacProgram , LanguageServer ) {
         if not sem_mgr {
             return None;
         }
-        index1 = utils.find_index(sem_mgr.sem_tokens, position.line, position.character);
+        index1 =
+            utils.find_index(sem_mgr.sem_tokens, position.line, position.character);
         if index1 is None {
             return None;
         }
         node_selected = sem_mgr.static_sem_tokens[index1][3];
         if node_selected and node_selected.sym  {
-            changes: <>dict[(str,<>list[lspt.TextEdit])] = {};
-            for <>node in [*node_selected.sym.uses,node_selected.sym.defn[0]] { key = uris.from_fs_path(<>node.loc.mod_path); new_edit = lspt.TextEdit(
-                range=utils.create_range(<>node.loc), new_text=new_name
-            ); utils.add_unique_text_edit(changes, key, new_edit); }
+            changes: <>dict[(str, <>list[lspt.TextEdit])] = {} ;
+            for <>node in [*node_selected.sym.uses, node_selected.sym.defn[0]] { key =
+                uris.from_fs_path(<>node.loc.mod_path); new_edit =
+                lspt.TextEdit(range=utils.create_range(<>node.loc), new_text=new_name); utils.add_unique_text_edit(changes, key, new_edit); }
             return lspt.WorkspaceEdit(changes=changes);
         }
         return None;

jaclang/langserve/server.jac

@@ -30,6 +30,10 @@ async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) ->
 @server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
 async def did_save(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None {
     file_path = params.text_document.uri;
+    quick_check_passed = await ls.launch_quick_check(file_path);
+    if not quick_check_passed {
+        return;
+    }
     await ls.launch_deep_check(file_path);
     ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
 }
@@ -42,8 +46,19 @@ async def did_change(
     params: lspt.DidChangeTextDocumentParams
 ) -> None {
     file_path = params.text_document.uri;
-    await ls.launch_quick_check(file_path);
-    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+    quick_check_passed = await ls.launch_quick_check(file_path);
+
+    if quick_check_passed {
+        document = ls.workspace.get_text_document(file_path);
+        lines = document.source.splitlines();
+        sem_manager = ls.sem_managers[file_path.removeprefix('file://')];
+        sem_manager.update_sem_tokens(
+            params,sem_manager.sem_tokens,lines
+        );
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+        await ls.launch_deep_check(file_path);
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+    }
 }