jaclang 0.7.17__py3-none-any.whl → 0.7.19__py3-none-any.whl

jaclang/cli/cli.py

@@ -8,7 +8,6 @@ import pickle
 import shutil
 import types
 from typing import Optional
-from uuid import UUID
 
 import jaclang.compiler.absyntree as ast
 from jaclang import jac_import
@@ -159,10 +158,9 @@ def get_object(
         raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
     data = {}
-    if id == "root":
-        data = jctx.root.__getstate__()
-    elif obj := jctx.mem.find_by_id(UUID(id)):
-        data = obj.__getstate__()
+    obj = Jac.get_object(id)
+    if obj:
+        data = obj.__jac__.__getstate__()
     else:
         print(f"Object with id {id} not found.")
 
@@ -431,8 +429,8 @@ def dot(
 
     if filename.endswith(".jac"):
         jac_machine = JacMachine(base)
-        jac_import(target=mod, base_path=base)
-        module = jac_machine.loaded_modules.get(mod)
+        jac_import(target=mod, base_path=base, override_name="__main__")
+        module = jac_machine.loaded_modules.get("__main__")
         globals().update(vars(module))
         try:
             node = globals().get(initial, eval(initial)) if initial else None

jaclang/compiler/passes/ir_pass.py

@@ -133,6 +133,8 @@ class Pass(Transform[T]):
         else:
             self.prune_signal = False
         self.cur_node = node
+        if self.term_signal:
+            return node
         self.exit_node(node)
         return node
 

jaclang/compiler/passes/main/import_pass.py

@@ -13,6 +13,7 @@ from typing import Optional
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
+from jaclang.settings import settings
 from jaclang.utils.log import logging
 
 
@@ -105,7 +106,7 @@ class JacImportPass(Pass):
                 or test_folder == os.path.dirname(cur_file)
             ) and cur_file.endswith(".test.jac"):
                 mod = self.import_jac_mod_from_file(cur_file)
-                if mod:
+                if mod and not settings.ignore_test_annex:
                     node.test_mod.append(mod)
                     node.add_kids_right([mod], pos_update=False)
                     mod.parent = node

jaclang/compiler/passes/main/py_collect_dep_pass.py

@@ -7,6 +7,8 @@ that are only relevant to actual references source from Jac code.
 from __future__ import annotations
 
 
+import os
+
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.settings import settings
@@ -28,11 +30,15 @@ class PyCollectDepsPass(Pass):
         if not isinstance(node, ast.AstSymbolNode):
             return
 
+        # Adding the path of the file related to the py import
         path: str = ""
         if isinstance(node, ast.ModulePath):
             if node.path:
                 path = ".".join([i.value for i in node.path])
             node.abs_path = self.ir.py_mod_dep_map.get(path)
+            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
+                node.abs_path = node.abs_path.replace(".pyi", ".py")
+
         elif isinstance(node, ast.ModuleItem):
             imp = node.parent_of_type(ast.Import)
             mod_path_node = imp.get_all_sub_nodes(ast.ModulePath)[0]
@@ -40,6 +46,8 @@ class PyCollectDepsPass(Pass):
                 path = ".".join([i.value for i in mod_path_node.path])
             path += f".{node.name.value}"
             node.abs_path = self.ir.py_mod_dep_map.get(path)
+            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
+                node.abs_path = node.abs_path.replace(".pyi", ".py")
 
         if len(node.gen.mypy_ast) == 0:
             return

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -2641,6 +2641,31 @@ class PyastGenPass(Pass):
             ]
         elif node.op.name in [Tok.STAR_POW]:
             node.gen.py_ast = node.operand.gen.py_ast
+        elif node.op.name in [Tok.BW_AND]:
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Attribute(
+                                value=self.sync(
+                                    ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                                ),
+                                attr="get_object",
+                                ctx=ast3.Load(),
+                            )
+                        ),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="id",
+                                    value=node.operand.gen.py_ast[0],
+                                )
+                            ),
+                        ],
+                    )
+                )
+            ]
         else:
             self.ice(f"Unknown Unary operator {node.op.value}")
 

jaclang/compiler/passes/main/registry_pass.py

@@ -14,6 +14,7 @@ from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
 from jaclang.runtimelib.utils import get_sem_scope
+from jaclang.settings import settings
 
 
 class RegistryPass(Pass):
@@ -23,6 +24,9 @@ class RegistryPass(Pass):
 
     def enter_module(self, node: ast.Module) -> None:
         """Create registry for each module."""
+        if settings.disable_mtllm:
+            self.terminate()
+            return None
         node.registry = SemRegistry()
         self.modules_visited.append(node)
 

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/__init__.pyi

@@ -0,0 +1,3 @@
+from .display import *
+from .color import *
+from .constants import *

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

@@ -70,19 +70,19 @@ class ImportPassPassTests(TestCase):
         )
         assert isinstance(build.ir, ast.Module)
         p = {
-            "math": "jaclang/jaclang/vendor/mypy/typeshed/stdlib/math.pyi",
-            "pygame_mock": "pygame_mock/__init__.py",
-            "pygame_mock.color": "pygame_mock/color.py",
-            "pygame_mock.constants": "pygame_mock/constants.py",
-            "argparse": "jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi",
-            "builtins": "jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi",
-            "pygame_mock.display": "pygame_mock/display.py",
-            "os": "jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi",
-            "genericpath": "jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi",
+            "math": r"jaclang/vendor/mypy/typeshed/stdlib/math.pyi$",
+            "pygame_mock": r"pygame_mock/__init__.pyi$",
+            "pygame_mock.color": r"pygame_mock/color.py$",
+            "pygame_mock.constants": r"pygame_mock/constants.py$",
+            "argparse": r"jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi$",
+            "builtins": r"jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi$",
+            "pygame_mock.display": r"pygame_mock/display.py$",
+            "os": r"jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi$",
+            "genericpath": r"jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi$",
         }
         for i in p:
             self.assertIn(i, build.ir.py_raise_map)
-            self.assertIn(p[i], re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]))
+            self.assertRegex(re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]), p[i])
 
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""

jaclang/compiler/passes/main/type_check_pass.py

@@ -51,10 +51,10 @@ class JacTypeCheckPass(Pass):
         options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
         options.mypy_path = [
-            str(
-                pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
-                / "stubs"
-            )
+            # str( # TODO: Remove me, this was the wrong way to point to stubs
+            #     pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
+            #     / "stubs"
+            # )
         ]
         if top_module_path != "":
             options.mypy_path.append(top_module_path)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -126,11 +126,14 @@ class JacFormatPass(Pass):
         last_element = None
         for counter, i in enumerate(node.body):
             counter += 1
+            if last_element and (
+                i.loc.first_line - last_element.loc.last_line > 1
+                and not last_element.gen.jac.endswith("\n\n")
+            ):
+                self.emit_ln(node, "")
             if isinstance(i, ast.Import):
                 self.emit_ln(node, i.gen.jac)
             else:
-                if isinstance(last_element, ast.Import):
-                    self.emit_ln(node, "")
                 if last_element and (
                     isinstance(i, ast.Architype)
                     and isinstance(last_element, ast.Architype)
@@ -140,21 +143,6 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                 self.emit_ln(node, i.gen.jac)
 
-                if counter <= len(node.body) - 1:
-                    if (
-                        isinstance(i, ast.Ability)
-                        and isinstance(node.body[counter], ast.Ability)
-                        and i.gen.jac.endswith(";")
-                        or (
-                            isinstance(i, ast.Architype)
-                            and len(node.body[counter].kid[-1].kid) == 2
-                            and len(node.body[counter - 1].kid[-1].kid) == 2
-                        )
-                        and node.gen.jac.endswith("\n")
-                    ):
-                        self.emit(node, "")
-                    else:
-                        self.emit_ln(node, "")
             last_element = i
 
     def exit_global_vars(self, node: ast.GlobalVars) -> None:
@@ -222,6 +210,20 @@ class JacFormatPass(Pass):
         """
         prev_token = None
         for stmt in node.kid:
+            line_emiited = False
+            if prev_token and stmt.loc.first_line - prev_token.loc.last_line > 1:
+                if (
+                    stmt.kid
+                    and isinstance(stmt.kid[-1], ast.SubNodeList)
+                    and not isinstance(stmt.kid[-1].kid[-1], ast.CommentToken)
+                ):
+                    self.emit(node, "")
+
+                else:
+                    line_emiited = True
+                    self.indent_level -= 1
+                    self.emit_ln(node, "")
+                    self.indent_level += 1
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -266,9 +268,10 @@ class JacFormatPass(Pass):
                             self.indent_level += 1
                         else:
                             self.emit(node, f" {stmt.gen.jac}")
-                        self.indent_level -= 1
-                        self.emit_ln(node, "")
-                        self.indent_level += 1
+                        if not line_emiited:
+                            self.indent_level -= 1
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
                     else:
                         if not node.gen.jac.endswith("\n"):
                             self.indent_level -= 1
@@ -280,11 +283,10 @@ class JacFormatPass(Pass):
                             self.emit(node, f"{stmt.gen.jac}")
                         else:
                             self.emit(node, stmt.gen.jac)
-                            if not stmt.gen.jac.endswith("postinit;"):
-                                self.indent_level -= 1
-                                self.emit_ln(stmt, "")
-                                self.emit_ln(node, "")
-                                self.indent_level += 1
+                            self.indent_level -= 1
+                            self.emit_ln(stmt, "")
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
                 elif stmt.gen.jac == ",":
                     self.emit(node, f"{stmt.value} ")
                 elif stmt.value == "=":
@@ -304,10 +306,29 @@ class JacFormatPass(Pass):
                 isinstance(prev_token, ast.Ability)
                 and isinstance(stmt, (ast.Ability, ast.AbilityDef))
             ):
-                if not isinstance(prev_token.kid[-1], ast.CommentToken):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
+                if (
+                    not isinstance(prev_token.kid[-1], ast.CommentToken)
+                    and not line_emiited
+                ):
+                    if (
+                        prev_token.kid
+                        and isinstance(prev_token.kid[-1], ast.SubNodeList)
+                        and isinstance(prev_token.kid[-1].kid[-1], ast.CommentToken)
+                    ):
+                        if (
+                            prev_token
+                            and stmt.loc.first_line - prev_token.kid[-1].kid[-1].line_no
+                            > 1
+                        ):
+                            self.indent_level -= 1
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
+                        else:
+                            self.emit(node, "")
+                    else:
+                        self.indent_level -= 1
+                        self.emit_ln(node, "")
+                        self.indent_level += 1
                 self.emit(node, stmt.gen.jac)
             else:
                 if prev_token and prev_token.gen.jac.strip() == "{":
@@ -907,8 +928,6 @@ class JacFormatPass(Pass):
         """Check if the length of the current generated code exceeds the max line length."""
         if max_line_length == 0:
             max_line_length = self.MAX_LINE_LENGTH
-        # print(content)
-        # print(len(content))
         return len(content) > max_line_length
 
     def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
@@ -958,7 +977,6 @@ class JacFormatPass(Pass):
                 self.error(
                     f"Binary operator {node.op.value} not supported in bootstrap Jac"
                 )
-        # print(node.gen)
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -1562,6 +1580,8 @@ class JacFormatPass(Pass):
             self.emit(node, f"not {node.operand.gen.jac}")
         elif node.op.name in [Tok.PIPE_FWD, Tok.KW_SPAWN, Tok.A_PIPE_FWD]:
             self.emit(node, f"{node.op.value} {node.operand.gen.jac}")
+        elif node.op.name in [Tok.BW_AND]:
+            self.emit(node, f"{node.op.value}{node.operand.gen.jac}")
         else:
             self.error(f"Unary operator {node.op.value} not supported in bootstrap Jac")
 

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/line_spacing.jac

@@ -0,0 +1,55 @@
+import:py math;
+
+glob RAD = 5;
+glob DIA = 10;
+
+# this comment is for walker
+walker decorator_walk {
+    can hash(func: Any) {
+        can inner(a: Any) {
+            print(("#" * 20));
+            func(a);
+            print(("#" * 20));
+        }
+        return inner;
+    }
+
+    can exclaim(func: Any) {
+        can inner(b: Any) {
+            print(("!" * 20));
+            func(b);
+            print(("!" * 20));
+        }
+        return inner;
+    }
+
+    can tilde(func: Any) {
+        can inner(c: Any) {
+            print(("~" * 20));
+            func(c);
+            print(("~" * 20));
+        }
+        return inner;
+    }
+
+    can greeter(name: Any) {
+        print("Hello, " + name + "!");
+    }
+
+    # Entry point for the walker
+
+    can start with entry {
+        # Apply decorators to greeter
+        decorated_greeter = hash(exclaim(tilde(greeter)));
+
+        # Call the decorated greeter function
+        decorated_greeter("World");
+
+        # this is another comment
+
+    }
+}
+
+with entry {
+    root spawn decorator_walk();
+}

jaclang/langserve/engine.py

@@ -22,8 +22,7 @@ from jaclang.langserve.utils import (
     find_deepest_symbol_node_at_pos,
     find_index,
     gen_diagnostics,
-    get_item_path,
-    get_mod_path,
+    get_location_range,
     get_symbols_for_outline,
     parse_symbol_path,
     resolve_completion_symbol_table,
@@ -335,8 +334,9 @@ class JacLangServer(LanguageServer):
                 and node_selected.parent
                 and isinstance(node_selected.parent, ast.ModulePath)
             ):
-                spec = get_mod_path(node_selected.parent, node_selected)
+                spec = node_selected.parent.abs_path
                 if spec:
+                    spec = spec[5:] if spec.startswith("File:") else spec
                     return lspt.Location(
                         uri=uris.from_fs_path(spec),
                         range=lspt.Range(
@@ -349,19 +349,31 @@ class JacLangServer(LanguageServer):
             elif node_selected.parent and isinstance(
                 node_selected.parent, ast.ModuleItem
             ):
-                path_range = get_item_path(node_selected.parent)
-                if path_range:
-                    path, loc_range = path_range
-                    if path and loc_range:
-                        return lspt.Location(
-                            uri=uris.from_fs_path(path),
-                            range=lspt.Range(
-                                start=lspt.Position(line=loc_range[0], character=0),
-                                end=lspt.Position(line=loc_range[1], character=5),
+                path = (
+                    node_selected.parent.abs_path
+                    or node_selected.parent.from_mod_path.abs_path
+                )
+                try:  # TODO: Get rid of this when 'from' import is fixed
+                    loc_range = tuple(
+                        loc - 1 if loc > 0 else loc
+                        for loc in get_location_range(node_selected.parent)
+                    )
+                except ValueError:
+                    loc_range = (0, 0, 0, 0)
+
+                if path and loc_range:
+                    path = path[5:] if path.startswith("File:") else path
+                    return lspt.Location(
+                        uri=uris.from_fs_path(path),
+                        range=lspt.Range(
+                            start=lspt.Position(
+                                line=loc_range[0], character=loc_range[1]
                             ),
-                        )
-                else:
-                    return None
+                            end=lspt.Position(
+                                line=loc_range[2], character=loc_range[3]
+                            ),
+                        ),
+                    )
             elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
                 return None
             decl_node = (
@@ -378,7 +390,7 @@ class JacLangServer(LanguageServer):
             decl_uri = uris.from_fs_path(decl_node.loc.mod_path)
             try:
                 decl_range = create_range(decl_node.loc)
-            except ValueError:  # 'print' name has decl in 0,0,0,0
+            except ValueError:
                 return None
             decl_location = lspt.Location(
                 uri=decl_uri,

jaclang/langserve/tests/fixtures/import_include_statements.jac

@@ -1,6 +1,6 @@
 import:py os;
-import:py from math, sqrt as square_root;
+import:py from math{ sqrt as square_root}
 import:py datetime as dt;
-import:jac from base_module_structure, add as add_numbers , subtract,x,Colorenum as clr;
+import:jac from base_module_structure{ add as add_numbers , subtract,x,Colorenum as clr}
 import:jac base_module_structure as base_module_structure;
-import:py from py_import,add1 as ss, sub1 as subtract1,apple,Orange1;
+import:py from py_import{add1 as ss, sub1 as subtract1,apple,Orange1}

jaclang/langserve/tests/test_server.py

@@ -187,11 +187,15 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (2, 24, "datetime.py:0:0-0:0"),
+            (0, 12, "tdlib/os/__init__.pyi:0:0-0:0"),
+            (1, 18, "stdlib/math.pyi:0:0-0:0"),
+            (2, 24, "datetime.pyi:0:0-0:0"),
             (3, 17, "base_module_structure.jac:0:0-0:0"),
-            (3, 87, "base_module_structure.jac:23:0-23:5"),
-            (5, 65, "py_import.py:12:0-20:5"),
-            (5, 35, "py_import.py:3:0-4:5"),
+            (3, 87, "base_module_structure.jac:23:5-23:14"),
+            (5, 65, "py_import.py:0:0-0:0"),
+            (5, 35, "py_import.py:0:0-0:0"),
+            # (5, 65, "py_import.py:12:0-20:5"),  # TODO : Should work after 'from' import files are raised
+            # (5, 35, "py_import.py:3:0-4:5"),
         ]
 
         for line, char, expected in positions:
@@ -214,9 +218,9 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (6, 39, "/pygame_mock/__init__.py:2:0-2:0"),
+            (6, 39, "/pygame_mock/__init__.pyi:2:0-2:0"),
             (6, 45, "/pygame_mock/constants.py:3:0-4:1"),
-            (7, 31, "/pygame_mock/__init__.py:2:0-2:0"),
+            (7, 31, "/pygame_mock/__init__.pyi:2:0-2:0"),
             (7, 35, "/pygame_mock/constants.py:3:0-4:1"),
             (20, 51, "/py_imp_test.jac:6:4-6:11"),
             (20, 64, "/pygame_mock/constants.py:4:3-4:15"),

jaclang/langserve/utils.py

@@ -2,10 +2,7 @@
 
 import asyncio
 import builtins
-import importlib.util
-import os
 import re
-import sys
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
@@ -209,6 +206,17 @@ def create_range(loc: CodeLocInfo) -> lspt.Range:
     )
 
 
+def get_location_range(mod_item: ast.ModuleItem) -> tuple[int, int, int, int]:
+    """Get location range."""
+    if not mod_item.from_mod_path.sub_module:
+        raise ValueError("Module items should have module path. Not Possible.")
+    lookup = mod_item.from_mod_path.sub_module.sym_tab.lookup(mod_item.name.value)
+    if not lookup:
+        raise ValueError("Module items should have a symbol table entry. Not Possible.")
+    loc = lookup.decl.loc
+    return loc.first_line, loc.col_start, loc.last_line, loc.col_end
+
+
 def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
     """Map the symbol node to an lspt.SymbolKind."""
     return (
@@ -273,103 +281,6 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind:
     )
 
 
-def get_mod_path(
-    mod_path: ast.ModulePath, name_node: ast.Name
-) -> str | None:  # TODO: This should go away
-    """Get path for a module import name."""
-    ret_target = None
-    if mod_path.parent and (
-        (
-            isinstance(mod_path.parent.parent, ast.Import)
-            and mod_path.parent.parent.is_py
-        )
-        or (
-            isinstance(mod_path.parent, ast.Import)
-            and mod_path.parent.from_loc
-            and mod_path.parent.is_py
-        )
-    ):
-        if mod_path.path and name_node in mod_path.path:
-            temporary_path_str = ("." * mod_path.level) + ".".join(
-                [p.value for p in mod_path.path[: mod_path.path.index(name_node) + 1]]
-                if mod_path.path
-                else ""
-            )
-        else:
-            temporary_path_str = mod_path.dot_path_str
-        sys.path.append(os.path.dirname(mod_path.loc.mod_path))
-        spec = importlib.util.find_spec(temporary_path_str)
-        sys.path.remove(os.path.dirname(mod_path.loc.mod_path))
-        if spec and spec.origin and spec.origin.endswith(".py"):
-            ret_target = spec.origin
-    elif mod_path.parent and (
-        (
-            isinstance(mod_path.parent.parent, ast.Import)
-            and mod_path.parent.parent.is_jac
-        )
-        or (
-            isinstance(mod_path.parent, ast.Import)
-            and mod_path.parent.from_loc
-            and mod_path.parent.is_jac
-        )
-    ):
-        ret_target = mod_path.resolve_relative_path()
-    return ret_target
-
-
-def get_item_path(mod_item: ast.ModuleItem) -> tuple[str, tuple[int, int]] | None:
-    """Get path."""
-    item_name = mod_item.name.value
-    if mod_item.from_parent.is_py and mod_item.from_parent.from_loc:
-        path = get_mod_path(mod_item.from_parent.from_loc, mod_item.name)
-        if path:
-            return get_definition_range(path, item_name)
-    elif mod_item.from_parent.is_jac:
-        mod_node = mod_item.from_mod_path
-        if mod_node.sub_module and mod_node.sub_module._sym_tab:
-            for symbol_name, symbol in mod_node.sub_module._sym_tab.tab.items():
-                if symbol_name == item_name:
-                    return symbol.decl.loc.mod_path, (
-                        symbol.decl.loc.first_line - 1,
-                        symbol.decl.loc.last_line - 1,
-                    )
-    return None
-
-
-def get_definition_range(
-    filename: str, name: str
-) -> tuple[str, tuple[int, int]] | None:
-    """Get the start and end line of a function or class definition in a file."""
-    import ast
-
-    with open(filename, "r") as file:
-        source = file.read()
-
-    tree = ast.parse(source)
-
-    for node in ast.walk(tree):
-        if isinstance(node, (ast.FunctionDef, ast.ClassDef)) and node.name == name:
-            start_line = node.lineno
-            end_line = (
-                node.body[-1].end_lineno
-                if hasattr(node.body[-1], "end_lineno")
-                else node.body[-1].lineno
-            )
-            if start_line and end_line:
-                return filename, (start_line - 1, end_line - 1)
-        elif isinstance(node, ast.Assign):
-            for target in node.targets:
-                if isinstance(target, ast.Name) and target.id == name:
-                    start_line = node.lineno
-                    end_line = (
-                        node.end_lineno if hasattr(node, "end_lineno") else node.lineno
-                    )
-                    if start_line and end_line:
-                        return filename, (start_line - 1, end_line - 1)
-
-    return None
-
-
 def collect_all_symbols_in_scope(
     sym_tab: SymbolTable, up_tree: bool = True
 ) -> list[lspt.CompletionItem]: