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

jaclang/compiler/absyntree.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast as ast3
+import os
 from hashlib import md5
 from types import EllipsisType
 from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar
@@ -31,7 +32,6 @@ class AstNode:
         self.kid: list[AstNode] = [x.set_parent(self) for x in kid]
         self.sym_tab: Optional[SymbolTable] = None
         self._sub_node_tab: dict[type, list[AstNode]] = {}
-        self._typ: type = type(None)
         self.gen: CodeGenTarget = CodeGenTarget()
         self.meta: dict[str, str] = {}
         self.loc: CodeLocInfo = CodeLocInfo(*self.resolve_tok_range())
@@ -111,11 +111,15 @@ class AstNode:
 
         return Pass.get_all_sub_nodes(node=self, typ=typ, brute_force=brute_force)
 
-    def parent_of_type(self, typ: Type[T]) -> T:
+    def find_parent_of_type(self, typ: Type[T]) -> Optional[T]:
         """Get parent of type."""
         from jaclang.compiler.passes import Pass
 
-        ret = Pass.has_parent_of_type(node=self, typ=typ)
+        return Pass.has_parent_of_type(node=self, typ=typ)
+
+    def parent_of_type(self, typ: Type[T]) -> T:
+        """Get parent of type."""
+        ret = self.find_parent_of_type(typ)
         if isinstance(ret, typ):
             return ret
         else:
@@ -178,6 +182,8 @@ class AstSymbolNode(AstNode):
         self.sym_link: Optional[Symbol] = None
         self.sym_name: str = sym_name
         self.sym_name_node = sym_name_node
+        if isinstance(self.sym_name_node, NameSpec):
+            self.sym_name_node.name_of = self
         self.sym_type: SymbolType = sym_type
         self.sym_info: SymbolInfo = SymbolInfo()
         self.py_ctx_func: Type[ast3.AST] = ast3.Load
@@ -258,8 +264,11 @@ class WalkerStmtOnlyNode(AstNode):
 class AstImplOnlyNode(AstNode):
     """ImplOnly node type for Jac Ast."""
 
-    def __init__(self, body: SubNodeList, decl_link: Optional[AstNode]) -> None:
+    def __init__(
+        self, target: ArchRefChain, body: SubNodeList, decl_link: Optional[AstNode]
+    ) -> None:
         """Initialize impl only node."""
+        self.target = target
         self.body = body
         self.decl_link = decl_link
 
@@ -304,6 +313,10 @@ class CodeBlockStmt(AstNode):
 class NameSpec(AtomExpr, EnumBlockStmt):
     """NameSpec node type for Jac Ast."""
 
+    def __init__(self) -> None:
+        """Initialize name spec node."""
+        self.name_of: AstSymbolNode = self
+
 
 class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstDocNode, AstSemStrNode):
     """ArchSpec node type for Jac Ast."""
@@ -392,7 +405,7 @@ class Module(AstDocNode):
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
         kid: Sequence[AstNode],
-        test_mod: Optional[Module] = None,
+        stub_only: bool = False,
         registry: Optional[SemRegistry] = None,
     ) -> None:
         """Initialize whole program node."""
@@ -400,13 +413,37 @@ class Module(AstDocNode):
         self.source = source
         self.body = body
         self.is_imported = is_imported
+        self.stub_only = stub_only
         self.impl_mod: list[Module] = []
-        self.test_mod = test_mod
+        self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    @property
+    def annexable_by(self) -> Optional[str]:
+        """Get annexable by."""
+        if not self.stub_only and self.loc.mod_path.endswith("impl.jac"):
+            head_mod_name = self.name.split(".")[0]
+            potential_path = os.path.join(
+                os.path.dirname(self.loc.mod_path),
+                f"{head_mod_name}.jac",
+            )
+            if os.path.exists(potential_path):
+                return potential_path
+            if os.path.split(os.path.dirname(self.loc.mod_path))[-1].endswith(".impl"):
+                head_mod_name = os.path.split(os.path.dirname(self.loc.mod_path))[
+                    -1
+                ].split(".")[0]
+                potential_path = os.path.join(
+                    os.path.dirname(os.path.dirname(self.loc.mod_path)),
+                    f"{head_mod_name}.jac",
+                )
+                if os.path.exists(potential_path):
+                    return potential_path
+        return None
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize module node."""
         res = True
@@ -841,7 +878,6 @@ class ArchDef(ArchSpec, AstImplOnlyNode):
         decl_link: Optional[Architype] = None,
     ) -> None:
         """Initialize arch def node."""
-        self.target = target
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -851,7 +887,7 @@ class ArchDef(ArchSpec, AstImplOnlyNode):
         )
         AstDocNode.__init__(self, doc=doc)
         ArchSpec.__init__(self, decorators=decorators)
-        AstImplOnlyNode.__init__(self, body=body, decl_link=decl_link)
+        AstImplOnlyNode.__init__(self, target=target, body=body, decl_link=decl_link)
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize arch def node."""
@@ -952,7 +988,6 @@ class EnumDef(ArchSpec, AstImplOnlyNode):
         decl_link: Optional[Enum] = None,
     ) -> None:
         """Initialize arch def node."""
-        self.target = target
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -962,7 +997,7 @@ class EnumDef(ArchSpec, AstImplOnlyNode):
         )
         AstDocNode.__init__(self, doc=doc)
         ArchSpec.__init__(self, decorators=decorators)
-        AstImplOnlyNode.__init__(self, body=body, decl_link=decl_link)
+        AstImplOnlyNode.__init__(self, target=target, body=body, decl_link=decl_link)
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize enum def node."""
@@ -1002,7 +1037,7 @@ class Ability(
         is_static: bool,
         is_abstract: bool,
         access: Optional[SubTag[Token]],
-        signature: Optional[FuncSignature | EventSignature],
+        signature: FuncSignature | EventSignature,
         body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
         kid: Sequence[AstNode],
         semstr: Optional[String] = None,
@@ -1111,7 +1146,6 @@ class AbilityDef(AstSymbolNode, ElementStmt, AstImplOnlyNode, CodeBlockStmt):
         decl_link: Optional[Ability] = None,
     ) -> None:
         """Initialize ability def node."""
-        self.target = target
         self.signature = signature
         self.decorators = decorators
         AstNode.__init__(self, kid=kid)
@@ -1122,7 +1156,7 @@ class AbilityDef(AstSymbolNode, ElementStmt, AstImplOnlyNode, CodeBlockStmt):
             sym_type=SymbolType.IMPL,
         )
         AstDocNode.__init__(self, doc=doc)
-        AstImplOnlyNode.__init__(self, body=body, decl_link=decl_link)
+        AstImplOnlyNode.__init__(self, target=target, body=body, decl_link=decl_link)
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize ability def node."""
@@ -1394,7 +1428,7 @@ class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
             self,
             sym_name=name.value,
             sym_name_node=name,
-            sym_type=SymbolType.VAR,
+            sym_type=SymbolType.HAS_VAR,
         )
         AstTypedVarNode.__init__(self, type_tag=type_tag)
         AstSemStrNode.__init__(self, semstr=semstr)
@@ -3066,6 +3100,7 @@ class ArchRef(NameSpec):
             sym_name_node=name_ref,
             sym_type=SymbolType.TYPE,
         )
+        NameSpec.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize ast node."""
@@ -3103,6 +3138,7 @@ class SpecialVarRef(NameSpec):
             sym_name_node=var,
             sym_type=SymbolType.VAR,
         )
+        NameSpec.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize ast node."""
@@ -3786,6 +3822,7 @@ class Name(Token, NameSpec):
             sym_name_node=self,
             sym_type=SymbolType.VAR,
         )
+        NameSpec.__init__(self)
 
     def unparse(self) -> str:
         """Unparse name."""

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -9,7 +9,7 @@ body field.
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
-from jaclang.compiler.symtable import Symbol, SymbolTable, SymbolType
+from jaclang.compiler.symtable import Symbol, SymbolTable
 
 
 class DeclImplMatchPass(Pass):
@@ -39,11 +39,12 @@ class DeclImplMatchPass(Pass):
     def connect_def_impl(self, sym_tab: SymbolTable) -> None:
         """Connect Decls and Defs."""
         for sym in sym_tab.tab.values():
-            if sym.sym_type == SymbolType.IMPL:
+            if isinstance(sym.decl, ast.AstImplOnlyNode):
                 # currently strips the type info from impls
                 arch_refs = [x[3:] for x in sym.sym_name.split(".")]
+                name_of_links = []  # to link archref names to decls
                 lookup = sym_tab.lookup(arch_refs[0])
-                # Below may need to be a while instead of if to skip over local
+                # If below may need to be a while instead of if to skip over local
                 # import name collisions (see test: test_impl_decl_resolution_fix)
                 if lookup and not isinstance(lookup.decl, ast.AstImplNeedingNode):
                     lookup = sym_tab.parent.lookup(arch_refs[0])
@@ -52,6 +53,7 @@ class DeclImplMatchPass(Pass):
                     if len(arch_refs) == 1 and lookup
                     else lookup.defn[-1] if lookup else None
                 )
+                name_of_links.append(decl_node) if decl_node else None
                 for name in arch_refs[1:]:
                     if decl_node:
                         lookup = (
@@ -64,6 +66,7 @@ class DeclImplMatchPass(Pass):
                             if len(arch_refs) == 1 and lookup
                             else lookup.defn[-1] if lookup else None
                         )
+                        name_of_links.append(decl_node) if decl_node else None
                     else:
                         break
                 if not decl_node:
@@ -76,6 +79,9 @@ class DeclImplMatchPass(Pass):
                     continue
                 decl_node.body = sym.decl  # type: ignore
                 sym.decl.decl_link = decl_node  # type: ignore
+                for idx, a in enumerate(sym.decl.target.archs):
+                    if isinstance(a.name_ref.sym_name_node, ast.NameSpec):
+                        a.name_ref.sym_name_node.name_of = name_of_links[idx]
                 decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
         for i in sym_tab.kid:
             self.connect_def_impl(i)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -129,8 +129,10 @@ class FuseTypeInfoPass(Pass):
         if isinstance(mypy_node, MypyNodes.MemberExpr):
             if mypy_node in self.node_type_hash:
                 t = str(self.node_type_hash[mypy_node])
-                if "->" in t:
+                if "def" in t and "->" in t:
                     t = t.split("->")[1].strip()
+                elif "def" in t:
+                    t = "None"
                 node.sym_info.typ = t
             else:
                 self.__debug_print(f"{node.loc} MemberExpr type is not found")
@@ -181,6 +183,18 @@ class FuseTypeInfoPass(Pass):
         """Pass handler for name nodes."""
         self.__collect_type_from_symbol(node)
 
+        # Assign correct symbols to sym_link in case of
+        # AtomTrailer Object
+        if isinstance(node.parent, ast.AtomTrailer):
+            target_node = node.parent.target
+            if isinstance(target_node, ast.AstSymbolNode):
+                parent_symbol_table = target_node.sym_info.typ_sym_table
+                if isinstance(parent_symbol_table, ast.SymbolTable):
+                    owner = parent_symbol_table.owner
+                    if isinstance(owner, ast.AstSymbolNode):
+                        target_node.sym_link = owner.sym_link
+                        node.sym_link = parent_symbol_table.lookup(node.sym_name)
+
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Pass handler for ModulePath nodes."""
@@ -263,6 +277,11 @@ class FuseTypeInfoPass(Pass):
                 "Getting type of 'HasVar' is only supported with AssignmentStmt"
             )
 
+    def exit_has_var(self, node: ast.HasVar) -> None:
+        """Pass handler for HasVar nodes."""
+        node.sym_info.typ = node.name.sym_info.typ
+        node.sym_info.typ_sym_table = node.name.sym_info.typ_sym_table
+
     @__handle_node
     def enter_multi_string(self, node: ast.MultiString) -> None:
         """Pass handler for MultiString nodes."""

jaclang/compiler/passes/main/import_pass.py

@@ -63,6 +63,8 @@ class JacImportPass(Pass):
 
     def __annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
+        if node.stub_only:
+            return
         if not node.loc.mod_path:
             self.error("Module has no path")
         if not node.loc.mod_path.endswith(".jac"):
@@ -105,7 +107,7 @@ class JacImportPass(Pass):
             ) and cur_file.endswith(".test.jac"):
                 mod = self.import_jac_mod_from_file(cur_file)
                 if mod:
-                    node.test_mod = mod
+                    node.test_mod.append(mod)
                     node.add_kids_right([mod], pos_update=False)
                     mod.parent = node
 
@@ -167,6 +169,7 @@ class JacImportPass(Pass):
                 doc=None,
                 body=[],
                 is_imported=False,
+                stub_only=True,
                 kid=[ast.EmptyToken()],
             )
 

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -54,6 +54,13 @@ class PyastGenPass(Pass):
             )
         ]
 
+    def enter_node(self, node: ast.AstNode) -> None:
+        """Enter node."""
+        if node.gen.py_ast:
+            self.prune()
+            return
+        super().enter_node(node)
+
     def exit_node(self, node: ast.AstNode) -> None:
         """Exit node."""
         super().exit_node(node)
@@ -325,7 +332,8 @@ class PyastGenPass(Pass):
         for pbody in node.impl_mod:
             pre_body = [*pre_body, *pbody.body]
         pre_body = [*pre_body, *clean_body]
-        pre_body = [*pre_body, *node.test_mod.body] if node.test_mod else pre_body
+        for pbody in node.test_mod:
+            pre_body = [*pre_body, *pbody.body]
         body = (
             [
                 self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc),
@@ -676,9 +684,9 @@ class PyastGenPass(Pass):
             if isinstance(node.body, ast.ArchDef)
             else node.body.items if node.body else []
         ):
-            if isinstance(i, ast.Ability) and i.signature:
+            if isinstance(i, ast.Ability):
                 self.method_sigs.append(i.signature)
-        if isinstance(node.body, ast.ArchDef):
+        if isinstance(node.body, ast.AstImplOnlyNode):
             self.traverse(node.body)
 
     def exit_architype(self, node: ast.Architype) -> None:
@@ -854,7 +862,7 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        if isinstance(node.body, ast.EnumDef):
+        if isinstance(node.body, ast.AstImplOnlyNode):
             self.traverse(node.body)
 
     def exit_enum(self, node: ast.Enum) -> None:
@@ -920,7 +928,7 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        if isinstance(node.body, ast.AbilityDef):
+        if isinstance(node.body, ast.AstImplOnlyNode):
             self.traverse(node.body)
 
     def exit_ability(self, node: ast.Ability) -> None:
@@ -1096,7 +1104,7 @@ class PyastGenPass(Pass):
             action = (
                 node.semstr.gen.py_ast[0]
                 if node.semstr
-                else self.sync(ast3.Constant(value=None))
+                else self.sync(ast3.Constant(value=node.name_ref.sym_name))
             )
             return [
                 self.sync(

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -127,7 +127,6 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             is_imported=False,
             kid=valid,
         )
-        ret.gen.py_ast = [node]
         return self.nu(ret)
 
     def proc_function_def(
@@ -209,6 +208,8 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         kid = ([doc] if doc else []) + (
             [name, sig, valid_body] if sig else [name, valid_body]
         )
+        if not sig:
+            raise self.ice("Function signature not found")
         ret = ast.Ability(
             name_ref=name,
             is_async=False,

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -1,4 +1,9 @@
-"""Jac to python ast link pass."""
+"""Jac to python ast link pass.
+
+This pass is needed so cases where there are multiple Jac nodes relevant to a
+single python node can be linked. For example FuncDef doesn't have a Name node
+however Ability does.
+"""
 
 import ast as ast3
 

jaclang/compiler/passes/main/pyout_pass.py

@@ -35,7 +35,9 @@ class PyOutPass(Pass):
                 f"Unable to find module {node.loc.mod_path} or no code present.", node
             )
             return
-        mods = [node] + self.get_all_sub_nodes(node, ast.Module)
+        mods = [node] + [
+            i for i in self.get_all_sub_nodes(node, ast.Module) if not i.stub_only
+        ]
         for mod in mods:
             mod_path, out_path_py, out_path_pyc = self.get_output_targets(mod)
             if os.path.exists(out_path_pyc) and os.path.getmtime(

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

@@ -41,3 +41,11 @@ class ImportPassPassTests(TestCase):
         self.assertIn("autoimpl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
         self.assertIn("autoimpl.something.else.impl", mod_names)
+
+    def test_annexalbe_by_discovery(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("incautoimpl.jac"), JacImportPass
+        )
+        for i in state.ir.get_all_sub_nodes(ast.Module):
+            self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))

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

@@ -59,6 +59,6 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertIn("HasVar - species - Type: builtins.str", out)
         self.assertIn("myDog - Type: type_info.Dog", out)
         self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 27)
+        self.assertEqual(out.count("Type: builtins.str"), 28)
         for i in lis:
             self.assertNotIn(i, out)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -421,7 +421,10 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.emit_ln(node, i.gen.jac)
             if isinstance(i, ast.Token) and i.name == Tok.KW_BY:
-                self.emit(node, f"{i.gen.jac} ")
+                if not node.params:
+                    self.emit(node, f"{i.gen.jac} ")
+                else:
+                    self.emit(node, f" {i.gen.jac} ")
             else:
                 if (
                     line_break_needed
@@ -2402,7 +2405,16 @@ class JacFormatPass(Pass):
             and isinstance(node.parent.parent, ast.FString)
         ):
             self.emit(node, node.value)
-        self.emit(node, node.value)
+        if "\n" in node.value:
+            string_type = node.value[0:3]
+            pure_string = node.value[3:-3]
+            lines = pure_string.split("\n")
+            self.emit(node, string_type)
+            for line in lines[:-1]:
+                self.emit_ln(node, line)
+            self.emit_ln(node, f"{lines[-1]}{string_type}")
+        else:
+            self.emit(node, node.value)
 
     def enter_bool(self, node: ast.Bool) -> None:
         """Sub objects.

jaclang/compiler/passes/tool/tests/fixtures/doc_string.jac

@@ -0,0 +1,15 @@
+class foo {
+    """
+    doc string
+    """
+    can print_here() {
+        print("i'm here");
+    }
+
+    """this is a
+    multiline docstring
+    to test"""
+    can also_print() {
+        print("I'm in also");
+    }
+}

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

@@ -44,8 +44,8 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
             if diff:
                 print(f"Differences found in comparison:\n{diff}")
-                # raise AssertionError("Files differ after formatting.")
-                self.skipTest("Test failed, but skipping instead of failing.")
+                raise AssertionError("Files differ after formatting.")
+
         except FileNotFoundError:
             print(f"File not found: {original_file} or {formatted_file}")
             raise
@@ -76,6 +76,9 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         self.compare_files(
             os.path.join(self.fixture_abs_path(""), "corelib_fmt.jac"),
         )
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "doc_string.jac"),
+        )
 
     def test_compare_myca_fixtures(self) -> None:
         """Tests if files in the myca fixtures directory do not change after being formatted."""
@@ -135,14 +138,13 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             diff = "\n".join(unified_diff(before.splitlines(), after.splitlines()))
             self.assertFalse(diff, "AST structures differ after formatting.")
 
-        except Exception:
+        except Exception as e:
             print(add_line_numbers(code_gen_pure.ir.source.code))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print(add_line_numbers(code_gen_format.ir.gen.jac))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
-            self.skipTest("Test failed, but skipping instead of failing.")
-            # raise e
+            raise e
 
 
 JacFormatPassTests.self_attach_micro_tests()

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

@@ -30,7 +30,7 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
             self.assertEqual(x, y)
         except Exception as e:
             print("\n".join(unified_diff(x.splitlines(), y.splitlines())))
-            self.skipTest(f"Test failed, but skipping instead of failing: {e}")
+            raise e
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
@@ -75,7 +75,6 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
         except Exception as e:
             raise e
-            # self.skipTest(f"Test failed, but skipping instead of failing: {e}")
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/compiler/symtable.py

@@ -17,7 +17,7 @@ class SymbolType(Enum):
 
     MODULE = "module"  # LSP: Module
     MOD_VAR = "mod_var"  # LSP: Variable
-    VAR = "var"  # LSP: Variable
+    VAR = "variable"  # LSP: Variable
     IMM_VAR = "immutable"  # LSP: Constant
     ABILITY = "ability"  # LSP: Function
     OBJECT_ARCH = "object"  # LSP: Class
@@ -54,6 +54,12 @@ class SymbolInfo:
         self.acc_tag: Optional[SymbolAccess] = acc_tag
         self.typ_sym_table: Optional[SymbolTable] = None
 
+    @property
+    def clean_type(self) -> str:
+        """Get clean type."""
+        ret_type = self.typ.replace("builtins.", "").replace("NoType", "")
+        return ret_type
+
 
 class SymbolAccess(Enum):
     """Symbol types."""
@@ -101,6 +107,20 @@ class Symbol:
         """Get sym_type."""
         return self.decl.sym_type
 
+    @property
+    def sym_path_str(self) -> str:
+        """Return a full path of the symbol."""
+        out = [self.defn[0].sym_name]
+        current_tab = self.parent_tab
+        while current_tab is not None:
+            out.append(current_tab.name)
+            if current_tab.has_parent():
+                current_tab = current_tab.parent
+            else:
+                break
+        out.reverse()
+        return ".".join(out)
+
     def add_defn(self, node: ast.AstSymbolNode) -> None:
         """Add defn."""
         self.defn.append(node)