jaclang 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -2,6 +2,7 @@
 
 This is a pass for formatting Jac code.
 """
+
 import re
 
 import jaclang.compiler.absyntree as ast
@@ -196,28 +197,35 @@ class JacFormatPass(Pass):
                 ):
                     self.emit_ln(node, "")
                     self.indent_level += 1
-                if stmt.name == "LBRACE":
-                    if (
-                        isinstance(node.kid[i + 1], ast.CommentToken)
-                        and node.kid[i + 1].is_inline
-                    ):
+                if stmt.name == Tok.LBRACE:
+                    next_kid = node.kid[i + 1]
+                    if isinstance(next_kid, ast.CommentToken) and next_kid.is_inline:
                         self.emit(node, f" {stmt.value}")
                     else:
                         self.emit(node, f" {stmt.value}")
-                elif stmt.name == "RBRACE":
+                elif stmt.name == Tok.RBRACE:
                     if self.indent_level > 0:
                         self.indent_level -= 1
-                    if stmt.parent.gen.jac.strip() == "{":
+                    if stmt.parent and stmt.parent.gen.jac.strip() == "{":
                         self.emit_ln(node, stmt.gen.jac.strip())
-                    elif isinstance(
-                        stmt.parent.parent,
-                        (ast.ElseIf, ast.IfStmt, ast.IterForStmt, ast.TryStmt),
+                    elif (
+                        stmt.parent
+                        and stmt.parent.parent
+                        and isinstance(
+                            stmt.parent.parent,
+                            (ast.ElseIf, ast.IfStmt, ast.IterForStmt, ast.TryStmt),
+                        )
                     ):
                         self.emit(node, f"{stmt.value}")
                     else:
-                        if i < (len(node.kid) - 1) and (
-                            isinstance(node.kid[i + 1], ast.CommentToken)
-                            and node.kid[i + 1].is_inline
+                        next_kid = (
+                            node.kid[i + 1]
+                            if i < (len(node.kid) - 1)
+                            else ast.EmptyToken()
+                        )
+                        if (
+                            isinstance(next_kid, ast.CommentToken)
+                            and next_kid.is_inline
                         ):
                             self.emit(node, f" {stmt.value}")
                         elif not (node.gen.jac).endswith("\n"):
@@ -229,10 +237,14 @@ class JacFormatPass(Pass):
                             self.emit(node, f"{stmt.value}")
                 elif isinstance(stmt, ast.CommentToken):
                     if stmt.is_inline:
-                        if isinstance(prev_token, ast.Semi) or prev_token.name in [
-                            "LBRACE",
-                            "RBRACE",
-                        ]:
+                        if isinstance(prev_token, ast.Semi) or (
+                            isinstance(prev_token, ast.Token)
+                            and prev_token.name
+                            in [
+                                Tok.LBRACE,
+                                Tok.RBRACE,
+                            ]
+                        ):
                             self.indent_level -= 1
                             self.emit(node, f" {stmt.gen.jac}")
                             self.emit_ln(node, "")
@@ -883,9 +895,11 @@ class JacFormatPass(Pass):
         for i in node.kid:
             if isinstance(i, ast.SubTag):
                 for j in i.kid:
-                    self.emit(node, j.gen.jac) if not j.gen.jac.startswith(
-                        ":"
-                    ) else self.emit(node, f"{j.gen.jac} ")
+                    (
+                        self.emit(node, j.gen.jac)
+                        if not j.gen.jac.startswith(":")
+                        else self.emit(node, f"{j.gen.jac} ")
+                    )
             else:
                 self.emit(node, f" {i.gen.jac}")
         if isinstance(node.kid[-1], ast.CommentToken) and not node.gen.jac.endswith(
@@ -1006,7 +1020,11 @@ class JacFormatPass(Pass):
         count_by: ExprType,
         body: CodeBlock,
         """
-        if isinstance(node.parent.parent, (ast.Ability)):
+        if (
+            node.parent
+            and node.parent.parent
+            and isinstance(node.parent.parent, (ast.Ability))
+        ):
             self.emit_ln(node, "")
 
         start = True
@@ -1036,7 +1054,11 @@ class JacFormatPass(Pass):
         excepts: Optional[ExceptList],
         finally_body: Optional[FinallyStmt],
         """
-        if isinstance(node.parent.parent, (ast.Ability)):
+        if (
+            node.parent
+            and node.parent.parent
+            and isinstance(node.parent.parent, (ast.Ability))
+        ):
             self.emit_ln(node, "")
         start = True
         for i in node.kid:
@@ -1068,7 +1090,11 @@ class JacFormatPass(Pass):
         name: Optional[Token],
         body: CodeBlock,
         """
-        if isinstance(node.parent.parent, (ast.Ability)):
+        if (
+            node.parent
+            and node.parent.parent
+            and isinstance(node.parent.parent, (ast.Ability))
+        ):
             self.emit_ln(node, "")
         start = True
         for i in node.kid:
@@ -1108,7 +1134,11 @@ class JacFormatPass(Pass):
         condition: ExprType,
         body: CodeBlock,
         """
-        if isinstance(node.parent.parent, (ast.Ability)):
+        if (
+            node.parent
+            and node.parent.parent
+            and isinstance(node.parent.parent, (ast.Ability))
+        ):
             self.emit_ln(node, "")
         start = True
         for i in node.kid:
@@ -1314,7 +1344,7 @@ class JacFormatPass(Pass):
             self.comma_sep_node_list(node.signature.params)
             out += node.signature.params.gen.jac
         if node.signature.return_type:
-            out += f" -> {node.signature.return_type.tag.gen.jac}"
+            out += f" -> {node.signature.return_type.gen.jac}"
         self.emit(node, f"with {out} can {node.body.gen.jac}")
 
     def exit_unary_expr(self, node: ast.UnaryExpr) -> None:
@@ -1417,7 +1447,7 @@ class JacFormatPass(Pass):
                     self.emit(node, f" {i.gen.jac}")
                 else:
                     self.emit_ln(node, i.gen.jac)
-            elif isinstance(prev_token, ast.Token) and prev_token.name == "LBRACE":
+            elif isinstance(prev_token, ast.Token) and prev_token.name == Tok.LBRACE:
                 self.emit(node, f"{i.gen.jac}")
             elif isinstance(i, ast.Semi) or i.gen.jac == ",":
                 self.emit(node, i.gen.jac)
@@ -1504,7 +1534,10 @@ class JacFormatPass(Pass):
         key: ExprType,
         value: ExprType,
         """
-        self.emit(node, f"{node.key.gen.jac}={node.value.gen.jac}")
+        if node.key:
+            self.emit(node, f"{node.key.gen.jac}={node.value.gen.jac}")
+        else:
+            self.emit(node, f"**{node.value.gen.jac}")
 
     def exit_disconnect_op(self, node: ast.DisconnectOp) -> None:
         """Sub objects.
@@ -1566,7 +1599,7 @@ class JacFormatPass(Pass):
         from_walker: bool = False,
         """
         for i in node.kid:
-            if isinstance(i, (ast.EdgeOpRef, ast.ElseStmt)):
+            if isinstance(i, (ast.EdgeOpRef, ast.ElseStmt, ast.SpecialVarRef)):
                 self.emit(node, f" {i.gen.jac}")
             else:
                 self.emit(node, i.gen.jac)
@@ -1712,7 +1745,7 @@ class JacFormatPass(Pass):
         alias: Optional[Token],
         """
         if node.alias:
-            self.emit(node, node.expr.gen.jac + " as " + node.alias.value)
+            self.emit(node, node.expr.gen.jac + " as " + node.alias.gen.jac)
         else:
             self.emit(node, node.expr.gen.jac)
 
@@ -1723,7 +1756,11 @@ class JacFormatPass(Pass):
         collection: ExprType,
         body: SubNodeList[CodeBlockStmt],
         """
-        if isinstance(node.parent.parent, (ast.Ability)):
+        if (
+            node.parent
+            and node.parent.parent
+            and isinstance(node.parent.parent, (ast.Ability))
+        ):
             self.indent_level -= 1
             self.emit_ln(node, "")
             self.indent_level += 1
@@ -1831,10 +1868,10 @@ class JacFormatPass(Pass):
             elif isinstance(i, ast.Semi):
                 self.emit(node, i.gen.jac)
             elif isinstance(i, ast.Token):
-                if i.name == "LBRACE":
+                if i.name == Tok.LBRACE:
                     self.emit_ln(node, f" {i.value}")
                     self.indent_level += 1
-                elif i.name == "RBRACE":
+                elif i.name == Tok.RBRACE:
                     self.indent_level -= 1
                     self.emit(node, f"{i.value}")
                 else:

jaclang/compiler/passes/tool/schedules.py

@@ -1,4 +1,5 @@
 """Pass schedules."""
+
 from typing import Type
 
 from jaclang.compiler.passes.ir_pass import Pass

jaclang/compiler/passes/tool/sym_tab_printer_pass.py

@@ -1,4 +1,5 @@
 """Jac Blue pass for drawing AST."""
+
 from __future__ import annotations
 
 from typing import Optional

jaclang/compiler/passes/tool/tests/test_ast_print_pass.py

@@ -1,8 +1,9 @@
 """Test pass module."""
+
 import os
 
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.tool import AstDotGraphPass, AstPrinterPass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 

jaclang/compiler/passes/tool/tests/test_fuse_comments_pass.py

@@ -1,4 +1,5 @@
 """Test ast build pass module."""
+
 from jaclang.compiler.passes.tool import JacFormatPass
 
 

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -1,13 +1,14 @@
 """Test ast build pass module."""
+
 import ast as ast3
 from difflib import unified_diff
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.compile import jac_file_to_pass, jac_str_to_pass
 from jaclang.compiler.passes.main import PyastGenPass
 from jaclang.compiler.passes.main.schedules import py_code_gen as without_format
 from jaclang.compiler.passes.tool import JacFormatPass
 from jaclang.compiler.passes.tool.schedules import format_pass
-from jaclang.compiler.transpiler import jac_file_to_pass, jac_str_to_pass
 from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
 
 
@@ -107,8 +108,8 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
                 len(code_gen_pure.ir.source.comments),
                 len(code_gen_jac.ir.source.comments),
             )
-            before = ast3.dump(code_gen_pure.ir.gen.py_ast, indent=2)
-            after = ast3.dump(code_gen_jac.ir.gen.py_ast, indent=2)
+            before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
+            after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
             self.assertEqual(
                 len("\n".join(unified_diff(before.splitlines(), after.splitlines()))),
                 0,

jaclang/compiler/passes/tool/tests/test_symtab_print_pass.py

@@ -1,12 +1,13 @@
 """Test pass module."""
+
 import os
 
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.tool.schedules import (
     SymbolTableDotGraphPass,
     SymbolTablePrinterPass,
     sym_tab_print,
 )
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 

jaclang/compiler/passes/transform.py

@@ -1,4 +1,5 @@
 """Standardized transformation process and error interface."""
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -1,22 +1,35 @@
 """Overrides to mypy build manager for direct AST pass through."""
+
 from __future__ import annotations
 
 import ast
+import os
+import pathlib
 
-import jaclang.vendor.mypy.build as myb
-import jaclang.vendor.mypy.errors as mye
-import jaclang.vendor.mypy.fastparse as myfp
+import jaclang
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.passes import Pass
-from jaclang.vendor.mypy.build import BuildSource
-from jaclang.vendor.mypy.build import BuildSourceSet
-from jaclang.vendor.mypy.build import FileSystemCache
-from jaclang.vendor.mypy.build import compute_search_paths
-from jaclang.vendor.mypy.build import load_graph
-from jaclang.vendor.mypy.build import load_plugins
-from jaclang.vendor.mypy.build import process_graph
-from jaclang.vendor.mypy.options import Options
-from jaclang.vendor.mypy.semanal_main import semantic_analysis_for_scc
+
+import mypy.build as myb
+import mypy.errors as mye
+import mypy.fastparse as myfp
+from mypy.build import BuildSource
+from mypy.build import BuildSourceSet
+from mypy.build import FileSystemCache
+from mypy.build import Graph
+from mypy.build import ModuleNotFound
+from mypy.build import PRI_INDIRECT
+from mypy.build import compute_search_paths
+from mypy.build import find_module_simple
+from mypy.build import load_plugins
+from mypy.build import process_graph
+from mypy.options import Options
+from mypy.semanal_main import semantic_analysis_for_scc
+
+
+os.environ["MYPYPATH"] = str(
+    pathlib.Path(os.path.dirname(jaclang.__file__)).parent / "stubs"
+)
 
 
 mypy_to_jac_node_map: dict[tuple[int, int | None, int | None, int | None], AstNode] = {}
@@ -32,7 +45,7 @@ class BuildManager(myb.BuildManager):
         source: str,
         ignore_errors: bool,
         options: myb.Options,
-        ast_override: ast.AST | None = None,
+        ast_override: myb.MypyFile | None = None,
     ) -> myb.MypyFile:
         """Parse the source of a file with the given name.
 
@@ -83,7 +96,7 @@ class State(myb.State):
         # process it. With this flag, any changes to external state as well
         # as error reporting should be avoided.
         temporary: bool = False,
-        ast_override: ast.AST | None = None,
+        ast_override: myb.MypyFile | None = None,
     ) -> None:
         """Override to mypy state for AST pass through."""
         if not temporary:
@@ -187,7 +200,7 @@ class State(myb.State):
             self.compute_dependencies()
 
     def parse_file(
-        self, *, temporary: bool = False, ast_override: ast.AST | None = None
+        self, *, temporary: bool = False, ast_override: myb.MypyFile | None = None
     ) -> None:
         """Parse file and run first pass of semantic analysis.
 
@@ -304,13 +317,14 @@ class ASTConverter(myfp.ASTConverter):
             visitor = getattr(self, method)
             self.visitor_cache[typeobj] = visitor
         ret = visitor(node)
+        # Mypy sometimes inserts its own nodes, such as a Return around lambdas.
         if hasattr(node, "jac_link"):
             node.jac_link.gen.mypy_ast.append(ret)
             mypy_to_jac_node_map[
                 (ret.line, ret.column, ret.end_line, ret.end_column)
             ] = node.jac_link
-        else:
-            raise Exception("AST node not linked to Jac node")
+        # else:
+        #     raise Exception("AST node not linked to Jac node")
         return ret
 
 
@@ -364,6 +378,178 @@ class Errors(mye.Errors):
             )
 
 
+def load_graph(
+    sources: list[BuildSource],
+    manager: BuildManager,
+    old_graph: Graph | None = None,
+    new_modules: list[State] | None = None,
+) -> Graph:
+    """Given some source files, load the full dependency graph.
+
+    If an old_graph is passed in, it is used as the starting point and
+    modified during graph loading.
+
+    If a new_modules is passed in, any modules that are loaded are
+    added to the list. This is an argument and not a return value
+    so that the caller can access it even if load_graph fails.
+
+    As this may need to parse files, this can raise CompileError in case
+    there are syntax errors.
+    """
+    graph: Graph = old_graph if old_graph is not None else {}
+
+    # The deque is used to implement breadth-first traversal.
+    # TODO: Consider whether to go depth-first instead.  This may
+    # affect the order in which we process files within import cycles.
+    new = new_modules if new_modules is not None else []
+    entry_points: set[str] = set()
+    # Seed the graph with the initial root sources.
+    for bs in sources:
+        try:
+            st = State(
+                id=bs.module,
+                path=bs.path,
+                source=bs.text,
+                manager=manager,
+                root_source=not bs.followed,
+            )
+        except ModuleNotFound:
+            continue
+        if st.id in graph:
+            manager.errors.set_file(st.xpath, st.id, manager.options)
+            manager.errors.report(
+                -1,
+                -1,
+                f'Duplicate module named "{st.id}" (also at "{graph[st.id].xpath}")',
+                blocker=True,
+            )
+            manager.errors.report(
+                -1,
+                -1,
+                "See https://mypy.readthedocs.io/en/stable/running_mypy.html#mapping-file-paths-to-modules "
+                "for more info",
+                severity="note",
+            )
+            manager.errors.report(
+                -1,
+                -1,
+                "Common resolutions include: a) using `--exclude` to avoid checking one of them, "
+                "b) adding `__init__.py` somewhere, c) using `--explicit-package-bases` or "
+                "adjusting MYPYPATH",
+                severity="note",
+            )
+
+            manager.errors.raise_error()
+        graph[st.id] = st
+        new.append(st)
+        entry_points.add(bs.module)
+
+    # Note: Running this each time could be slow in the daemon. If it's a problem, we
+    # can do more work to maintain this incrementally.
+    seen_files = {st.abspath: st for st in graph.values() if st.path}
+
+    # Collect dependencies.  We go breadth-first.
+    # More nodes might get added to new as we go, but that's fine.
+    for st in new:
+        assert st.ancestors is not None
+        # Strip out indirect dependencies.  These will be dealt with
+        # when they show up as direct dependencies, and there's a
+        # scenario where they hurt:
+        # - Suppose A imports B and B imports C.
+        # - Suppose on the next round:
+        #   - C is deleted;
+        #   - B is updated to remove the dependency on C;
+        #   - A is unchanged.
+        # - In this case A's cached *direct* dependencies are still valid
+        #   (since direct dependencies reflect the imports found in the source)
+        #   but A's cached *indirect* dependency on C is wrong.
+        dependencies = [
+            dep
+            for dep in st.dependencies
+            if st.priorities.get(dep) != PRI_INDIRECT and "jaclang.vendor" not in dep
+        ]
+        if not manager.use_fine_grained_cache():
+            # TODO: Ideally we could skip here modules that appeared in st.suppressed
+            # because they are not in build with `follow-imports=skip`.
+            # This way we could avoid overhead of cloning options in `State.__init__()`
+            # below to get the option value. This is quite minor performance loss however.
+            added = [dep for dep in st.suppressed if find_module_simple(dep, manager)]
+        else:
+            # During initial loading we don't care about newly added modules,
+            # they will be taken care of during fine grained update. See also
+            # comment about this in `State.__init__()`.
+            added = []
+        for dep in st.ancestors + dependencies + st.suppressed:
+            ignored = dep in st.suppressed_set and dep not in entry_points
+            if ignored and dep not in added:
+                manager.missing_modules.add(dep)
+            elif dep not in graph:
+                try:
+                    if dep in st.ancestors:
+                        # TODO: Why not 'if dep not in st.dependencies' ?
+                        # Ancestors don't have import context.
+                        newst = State(
+                            id=dep,
+                            path=None,
+                            source=None,
+                            manager=manager,
+                            ancestor_for=st,
+                        )
+                    else:
+                        newst = State(
+                            id=dep,
+                            path=None,
+                            source=None,
+                            manager=manager,
+                            caller_state=st,
+                            caller_line=st.dep_line_map.get(dep, 1),
+                        )
+                except ModuleNotFound:
+                    if dep in st.dependencies_set:
+                        st.suppress_dependency(dep)
+                else:
+                    if newst.path:
+                        newst_path = os.path.abspath(newst.path)
+
+                        if newst_path in seen_files:
+                            manager.errors.report(
+                                -1,
+                                0,
+                                "Source file found twice under different module names: "
+                                '"{}" and "{}"'.format(
+                                    seen_files[newst_path].id, newst.id
+                                ),
+                                blocker=True,
+                            )
+                            manager.errors.report(
+                                -1,
+                                0,
+                                "See https://mypy.readthedocs.io/en/stable/running"
+                                + "_mypy.html#mapping-file-paths-to-modules "
+                                "for more info",
+                                severity="note",
+                            )
+                            manager.errors.report(
+                                -1,
+                                0,
+                                "Common resolutions include: a) adding `__init__.py` somewhere, "
+                                "b) using `--explicit-package-bases` or adjusting MYPYPATH",
+                                severity="note",
+                            )
+                            manager.errors.raise_error()
+
+                        seen_files[newst_path] = newst
+
+                    assert newst.id not in graph, newst.id
+                    graph[newst.id] = newst
+                    new.append(newst)  # noqa: B038
+            if dep in graph and dep in st.suppressed_set:
+                # Previously suppressed file is now visible
+                st.add_dependency(dep)
+    manager.plugin.set_modules(manager.modules)
+    return graph
+
+
 __all__ = [
     "BuildManager",
     "State",

jaclang/compiler/symtable.py

@@ -1,4 +1,5 @@
 """Jac Symbol Table."""
+
 from __future__ import annotations
 
 from enum import Enum

jaclang/compiler/tests/test_importer.py

@@ -1,4 +1,5 @@
 """Tests for Jac Loader."""
+
 import sys
 
 from jaclang import jac_import
@@ -14,11 +15,11 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        h = jac_import("fixtures.hello_world")
+        h = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
-        jac_import("fixtures.hello_world")
+        jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn("module 'hello_world'", str(sys.modules))
         self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))

jaclang/compiler/tests/test_parser.py

@@ -1,4 +1,5 @@
 """Tests for Jac parser."""
+
 import inspect
 
 from jaclang.compiler import jac_lark as jl

jaclang/compiler/tests/test_workspace.py

@@ -1,4 +1,5 @@
 """Tests for Jac Workspace."""
+
 import os
 
 from jaclang.compiler.workspace import Workspace

jaclang/compiler/workspace.py

@@ -1,14 +1,16 @@
 """Living Workspace of Jac project."""
+
 from __future__ import annotations
 
 import os
 from typing import Sequence
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.compile import jac_str_to_pass
 from jaclang.compiler.passes.main import DefUsePass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.transform import Alert
 from jaclang.compiler.symtable import Symbol, SymbolTable
-from jaclang.compiler.transpiler import jac_str_to_pass
 
 
 def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> Sequence[SymbolTable]:
@@ -103,7 +105,7 @@ class Workspace:
         build = jac_str_to_pass(
             jac_str=source,
             file_path=file_path,
-            target=DefUsePass,
+            schedule=py_code_gen_typed,
         )
         if not isinstance(build.ir, ast.Module):
             src = ast.JacSource(source, mod_path=file_path)
@@ -146,15 +148,26 @@ class Workspace:
         """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.Import]:
+    def get_dependencies(
+        self, file_path: str, deep: bool = False
+    ) -> list[ast.ModulePath]:
         """Return a list of dependencies for a file."""
         if deep:
-            return self.modules[file_path].ir.get_all_sub_nodes(ast.Import)
+            return [
+                i
+                for i in self.modules[file_path].ir.get_all_sub_nodes(ast.ModulePath)
+                if i.parent
+                and isinstance(i.parent, ast.Import)
+                and i.parent.lang.tag.value == "jac"
+            ]
         else:
             return [
                 i
-                for i in self.modules[file_path].ir.get_all_sub_nodes(ast.Import)
+                for i in self.modules[file_path].ir.get_all_sub_nodes(ast.ModulePath)
                 if i.loc.mod_path == file_path
+                and i.parent
+                and isinstance(i.parent, ast.Import)
+                and i.parent.lang.tag.value == "jac"
             ]
 
     def get_symbols(self, file_path: str) -> Sequence[Symbol]: