jaclang 0.7.25__tar.gz → 0.7.30__tar.gz

{jaclang-0.7.25 → jaclang-0.7.30}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: jaclang
-Version: 0.7.25
+Version: 0.7.30
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
-Home-page: https://jaseci.org
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
@@ -19,6 +18,7 @@ Provides-Extra: all
 Provides-Extra: llm
 Provides-Extra: streamlit
 Project-URL: Documentation, https://jac-lang.org
+Project-URL: Homepage, https://jaseci.org
 Project-URL: Repository, https://github.com/Jaseci-Labs/jaclang
 Description-Content-Type: text/markdown
 

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/cli/cli.py

@@ -307,6 +307,7 @@ def enter(
 @cmd_registry.register
 def test(
     filepath: str,
+    test_name: str = "",
     filter: str = "",
     xit: bool = False,
     maxfail: int = None,  # type:ignore
@@ -316,6 +317,7 @@ def test(
     """Run the test suite in the specified .jac file.
 
     :param filepath: Path/to/file.jac
+    :param test_name: Run a specific test.
     :param filter: Filter the files using Unix shell style conventions.
     :param xit(exit): Stop(exit) running tests as soon as finds an error.
     :param maxfail: Stop running tests after n failures.
@@ -328,6 +330,7 @@ def test(
 
     failcount = Jac.run_test(
         filepath=filepath,
+        func_name=("test_" + test_name) if test_name else None,
         filter=filter,
         xit=xit,
         maxfail=maxfail,

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/__init__.py

@@ -55,7 +55,7 @@ TOKEN_MAP.update(
         "CARROW_L": "<++", "CARROW_R": "++>", "GLOBAL_OP": ":global:",
         "NONLOCAL_OP": ":nonlocal:", "WALKER_OP": ":walker:", "NODE_OP": ":node:",
         "EDGE_OP": ":edge:", "CLASS_OP": ":class:", "OBJECT_OP": ":obj:",
-        "TYPE_OP": "`", "ABILITY_OP": ":can:", "ELVIS_OP": "?:", "NULL_OK": "?",
+        "TYPE_OP": "`", "ABILITY_OP": ":can:", "NULL_OK": "?",
         "KW_OR": "|", "ARROW_BI": "<-->", "ARROW_L": "<--",
         "ARROW_R": "-->", "ARROW_L_P1": "<-:", "ARROW_R_P2": ":->",
         "ARROW_L_P2": ":-", "ARROW_R_P1": "-:", "CARROW_BI": "<++>",

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/absyntree.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as ast3
 import builtins
 import os
+from dataclasses import dataclass
 from hashlib import md5
 from types import EllipsisType
 from typing import (
@@ -29,6 +30,7 @@ from jaclang.compiler.constant import (
     SymbolType,
 )
 from jaclang.compiler.constant import DELIM_MAP, SymbolAccess, Tokens as Tok
+from jaclang.compiler.py_info import PyInfo
 from jaclang.compiler.semtable import SemRegistry
 from jaclang.utils.treeprinter import dotgen_ast_tree, print_ast_tree
 
@@ -635,11 +637,10 @@ class Module(AstDocNode):
         self.impl_mod: list[Module] = []
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
-        self.py_mod_dep_map: dict[str, str] = {}
-        self.py_raise_map: dict[str, str] = {}
         self.registry = registry
         self.terminals: list[Token] = terminals
-        self.is_raised_from_py: bool = False
+        self.py_info: PyInfo = PyInfo()
+
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -692,6 +693,21 @@ class Module(AstDocNode):
         super().unparse()
         return self.format()
 
+    @staticmethod
+    def get_href_path(node: AstNode) -> str:
+        """Return the full path of the module that contains this node."""
+        parent = node.find_parent_of_type(Module)
+        mod_list: list[Module | Architype] = []
+        if isinstance(node, (Module, Architype)):
+            mod_list.append(node)
+        while parent is not None:
+            mod_list.append(parent)
+            parent = parent.find_parent_of_type(Module)
+        mod_list.reverse()
+        return ".".join(
+            p.name if isinstance(p, Module) else p.name.sym_name for p in mod_list
+        )
+
 
 class GlobalVars(ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""
@@ -997,8 +1013,9 @@ class ModulePath(AstSymbolNode):
         target = self.dot_path_str
         if target_item:
             target += f".{target_item}"
-        base_path = os.path.dirname(self.loc.mod_path)
-        base_path = base_path if base_path else os.getcwd()
+        base_path = (
+            os.getenv("JACPATH") or os.path.dirname(self.loc.mod_path) or os.getcwd()
+        )
         parts = target.split(".")
         traversal_levels = self.level - 1 if self.level > 0 else 0
         actual_parts = parts[traversal_levels:]
@@ -1010,6 +1027,15 @@ class ModulePath(AstSymbolNode):
             if os.path.exists(relative_path + ".jac")
             else relative_path
         )
+        jacpath = os.getenv("JACPATH")
+        if not os.path.exists(relative_path) and jacpath:
+            name_to_find = actual_parts[-1] + ".jac"
+
+            # Walk through the single path in JACPATH
+            for root, _, files in os.walk(jacpath):
+                if name_to_find in files:
+                    relative_path = os.path.join(root, name_to_find)
+                    break
         return relative_path
 
     def normalize(self, deep: bool = False) -> bool:
@@ -3401,18 +3427,22 @@ class FuncCall(Expr):
 class IndexSlice(AtomExpr):
     """IndexSlice node type for Jac Ast."""
 
+    @dataclass
+    class Slice:
+        """Slice node for index slice."""
+
+        start: Optional[Expr]
+        stop: Optional[Expr]
+        step: Optional[Expr]
+
     def __init__(
         self,
-        start: Optional[Expr],
-        stop: Optional[Expr],
-        step: Optional[Expr],
+        slices: list[Slice],
         is_range: bool,
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize index slice expression node."""
-        self.start = start
-        self.stop = stop
-        self.step = step
+        self.slices = slices
         self.is_range = is_range
         AstNode.__init__(self, kid=kid)
         Expr.__init__(self)
@@ -3422,22 +3452,26 @@ class IndexSlice(AtomExpr):
         """Normalize ast node."""
         res = True
         if deep:
-            res = self.start.normalize(deep) if self.start else res
-            res = res and self.stop.normalize(deep) if self.stop else res
-            res = res and self.step.normalize(deep) if self.step else res
+            for slice in self.slices:
+                res = slice.start.normalize(deep) if slice.start else res
+                res = res and slice.stop.normalize(deep) if slice.stop else res
+                res = res and slice.step.normalize(deep) if slice.step else res
         new_kid: list[AstNode] = []
         new_kid.append(self.gen_token(Tok.LSQUARE))
         if self.is_range:
-            if self.start:
-                new_kid.append(self.start)
-            if self.stop:
+            for i, slice in enumerate(self.slices):
+                if i > 0:
+                    new_kid.append(self.gen_token(Tok.COMMA))
+                if slice.start:
+                    new_kid.append(slice.start)
                 new_kid.append(self.gen_token(Tok.COLON))
-                new_kid.append(self.stop)
-            if self.step:
-                new_kid.append(self.gen_token(Tok.COLON))
-                new_kid.append(self.step)
-        elif self.start:
-            new_kid.append(self.start)
+                if slice.stop:
+                    new_kid.append(slice.stop)
+                if slice.step:
+                    new_kid.append(self.gen_token(Tok.COLON))
+                    new_kid.append(slice.step)
+        elif len(self.slices) == 1 and self.slices[0].start:
+            new_kid.append(self.slices[0].start)
         else:
             res = False
         new_kid.append(self.gen_token(Tok.RSQUARE))

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/compile.py

@@ -31,7 +31,7 @@ def jac_file_to_pass(
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
-    with open(file_path) as file:
+    with open(file_path, "r", encoding="utf-8") as file:
         return jac_str_to_pass(
             jac_str=file.read(),
             file_path=file_path,

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/constant.py

@@ -315,7 +315,6 @@ class Tokens(str, Enum):
     ABILITY_OP = "ABILITY_OP"
     A_PIPE_FWD = "A_PIPE_FWD"
     A_PIPE_BKWD = "A_PIPE_BKWD"
-    ELVIS_OP = "ELVIS_OP"
     RETURN_HINT = "RETURN_HINT"
     NULL_OK = "NULL_OK"
     DECOR_OP = "DECOR_OP"

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/jac.lark

@@ -298,10 +298,7 @@ lambda_expr: KW_WITH func_decl_params? (RETURN_HINT expression)? KW_CAN expressi
 pipe: (pipe PIPE_FWD)? pipe_back
 
 // Pipe back expressions
-pipe_back: (pipe_back PIPE_BKWD)? elvis_check
-
-// Elvis expressions
-elvis_check: (elvis_check ELVIS_OP)? bitwise_or
+pipe_back: (pipe_back PIPE_BKWD)? bitwise_or
 
 // Bitwise expressions
 bitwise_or: (bitwise_or BW_OR)? bitwise_xor
@@ -358,7 +355,10 @@ atomic_chain: atomic_chain NULL_OK? (filter_compr | assign_compr | index_slice)
             | atomic_chain NULL_OK? (DOT_BKWD | DOT_FWD | DOT) named_ref
             | (atomic_call | atom | edge_ref_chain)
 
-index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
+index_slice: LSQUARE                                                             \
+                     expression? COLON expression? (COLON expression?)?          \
+                     (COMMA expression? COLON expression? (COLON expression?)?)* \
+              RSQUARE
            | list_val
 
 // Function calls
@@ -596,7 +596,6 @@ PIPE_BKWD: /<\|/
 DOT_FWD: /\.>/
 DOT_BKWD: /<\./
 RETURN_HINT: /->/
-ELVIS_OP: /\?:/
 NULL_OK: /\?/
 MATMUL_EQ: /@=/
 DECOR_OP: /@/

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/parser.py

@@ -2037,16 +2037,8 @@ class JacParser(Pass):
         def pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            pipe_back: elvis_check PIPE_BKWD pipe_back
-                     | elvis_check
-            """
-            return self.binary_expr_unwind(kid)
-
-        def elvis_check(self, kid: list[ast.AstNode]) -> ast.Expr:
-            """Grammar rule.
-
-            elvis_check: bitwise_or ELVIS_OP elvis_check
-                       | bitwise_or
+            pipe_back: bitwise_or PIPE_BKWD pipe_back
+                     | bitwise_or
             """
             return self.binary_expr_unwind(kid)
 
@@ -2436,8 +2428,11 @@ class JacParser(Pass):
         def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice:
             """Grammar rule.
 
-            index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
-                    | list_val
+            index_slice: LSQUARE                                                        \
+                            expression? COLON expression? (COLON expression?)?          \
+                            (COMMA expression? COLON expression? (COLON expression?)?)* \
+                         RSQUARE
+                        | list_val
             """
             if len(kid) == 1:
                 index = kid[0]
@@ -2454,9 +2449,9 @@ class JacParser(Pass):
                         kid = [expr]
                     return self.nu(
                         ast.IndexSlice(
-                            start=expr,
-                            stop=None,
-                            step=None,
+                            slices=[
+                                ast.IndexSlice.Slice(start=expr, stop=None, step=None)
+                            ],
                             is_range=False,
                             kid=kid,
                         )
@@ -2464,25 +2459,39 @@ class JacParser(Pass):
                 else:
                     raise self.ice()
             else:
-                expr1 = expr2 = expr3 = None
+                slices: list[ast.IndexSlice.Slice] = []
                 chomp = kid[1:]
-                if isinstance(chomp[0], ast.Expr):
-                    expr1 = chomp[0]
-                    chomp = chomp[1:]
-                chomp = chomp[1:]
-                if isinstance(chomp[0], ast.Expr):
-                    expr2 = chomp[0]
-                    chomp = chomp[1:]
-                if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COLON:
-                    chomp = chomp[1:]
+
+                while not (
+                    isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.RSQUARE
+                ):
+                    expr1 = expr2 = expr3 = None
+
                     if isinstance(chomp[0], ast.Expr):
-                        expr3 = chomp[0]
-                        chomp = chomp[1:]
+                        expr1 = chomp[0]
+                        chomp.pop(0)
+                    chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Expr):
+                        expr2 = chomp[0]
+                        chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COLON:
+                        chomp.pop(0)
+                        if isinstance(chomp[0], ast.Expr):
+                            expr3 = chomp[0]
+                            chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COMMA:
+                        chomp.pop(0)
+
+                    slices.append(
+                        ast.IndexSlice.Slice(start=expr1, stop=expr2, step=expr3)
+                    )
+
                 return self.nu(
                     ast.IndexSlice(
-                        start=expr1,
-                        stop=expr2,
-                        step=expr3,
+                        slices=slices,
                         is_range=True,
                         kid=kid,
                     )

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/passes/main/access_modifier_pass.py

@@ -45,7 +45,7 @@ class AccessCheckPass(Pass):
             settings.lsp_debug
             and isinstance(node, ast.NameAtom)
             and not node.sym
-            and not node.parent_of_type(ast.Module).is_raised_from_py
+            and not node.parent_of_type(ast.Module).py_info.is_raised_from_py
             and not (
                 node.sym_name == "py"
                 and node.parent

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -7,6 +7,7 @@ body field.
 """
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.compiler.symtable import Symbol, SymbolTable
@@ -129,19 +130,55 @@ class DeclImplMatchPass(Pass):
                         valid_decl.name_spec,
                     )
                 else:
+                    # Copy the parameter names from the declaration to the definition.
                     for idx in range(len(params_defn.items)):
-                        # Check if all the parameter names are matched.
-                        # TODO: This shouldn't be an issue however if the names are not matched, it doesn't
-                        # work as expected like in C++, for now I'm adding this validation, however this
-                        # needs to be fixed to have a C++ style.
-                        param_name_decl = params_decl.items[idx].name.value
-                        param_name_defn = params_defn.items[idx].name.value
-                        if param_name_defn != param_name_decl:
-                            self.error(
-                                f"Parameter name mismatch for ability {sym.sym_name}.",
-                                params_defn.items[idx].name,
-                            )
+                        params_decl.items[idx] = params_defn.items[idx]
+                    for idx in range(len(params_defn.kid)):
+                        params_decl.kid[idx] = params_defn.kid[idx]
+
+    def exit_architype(self, node: ast.Architype) -> None:
+        """Exit Architype."""
+        if node.arch_type.name == Tok.KW_OBJECT and isinstance(
+            node.body, ast.SubNodeList
+        ):
+
+            found_default_init = False
+            for stmnt in node.body.items:
+                if not isinstance(stmnt, ast.ArchHas):
+                    continue
+                for var in stmnt.vars.items:
+                    if (var.value is not None) or (var.defer):
+                        found_default_init = True
+                    else:
+                        if found_default_init:
                             self.error(
-                                f"From the declaration of {valid_decl.name_spec.sym_name}.",
-                                params_decl.items[idx].name,
+                                f"Non default attribute '{var.name.value}' follows default attribute",
+                                node_override=var.name,
                             )
+                            break
+
+            post_init_vars: list[ast.HasVar] = []
+            postinit_method: ast.Ability | None = None
+
+            for item in node.body.items:
+
+                if isinstance(item, ast.ArchHas):
+                    for var in item.vars.items:
+                        if var.defer:
+                            post_init_vars.append(var)
+
+                elif isinstance(item, ast.Ability):
+                    if item.is_abstract:
+                        continue
+                    if (
+                        isinstance(item.name_ref, ast.SpecialVarRef)
+                        and item.name_ref.name == "KW_POST_INIT"
+                    ):
+                        postinit_method = item
+
+            # Check if postinit needed and not provided.
+            if len(post_init_vars) != 0 and (postinit_method is None):
+                self.error(
+                    'Missing "postinit" method required by un initialized attribute(s).',
+                    node_override=post_init_vars[0].name_spec,
+                )  # We show the error on the first uninitialized var.

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/passes/main/def_use_pass.py

@@ -156,8 +156,7 @@ class DefUsePass(Pass):
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
+        slices: list[Slice],
         is_range: bool,
         """
 

{jaclang-0.7.25 → jaclang-0.7.30}/jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -10,6 +10,7 @@ import re
 from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import Constants, Tokens
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
 from jaclang.settings import settings
@@ -76,35 +77,6 @@ class FuseTypeInfoPass(Pass):
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
 
-    def __collect_python_dependencies(self, node: ast.AstNode) -> None:
-        assert isinstance(node, ast.AstSymbolNode)
-        assert isinstance(self.ir, ast.Module)
-
-        mypy_node = node.gen.mypy_ast[0]
-
-        if isinstance(mypy_node, MypyNodes.RefExpr) and mypy_node.node:
-            node_full_name = mypy_node.node.fullname
-            if "." in node_full_name:
-                mod_name = node_full_name[: node_full_name.rindex(".")]
-            else:
-                mod_name = node_full_name
-
-            if mod_name not in self.ir.py_mod_dep_map:
-                self.__debug_print(
-                    f"Can't find a python file associated with {type(node)}::{node.loc}"
-                )
-                return
-
-            mode_path = self.ir.py_mod_dep_map[mod_name]
-            if mode_path.endswith(".jac"):
-                return
-
-            self.ir.py_raise_map[mod_name] = mode_path
-        else:
-            self.__debug_print(
-                f"Collect python dependencies is not supported in {type(node)}::{node.loc}"
-            )
-
     @staticmethod
     def __handle_node(
         func: Callable[[FuseTypeInfoPass, T], None]
@@ -126,7 +98,6 @@ class FuseTypeInfoPass(Pass):
                 if len(node.gen.mypy_ast) == 1:
                     func(self, node)
                     self.__set_type_sym_table_link(node)
-                    self.__collect_python_dependencies(node)
 
                 # Jac node has multiple mypy nodes linked to it
                 elif len(node.gen.mypy_ast) > 1:
@@ -150,7 +121,6 @@ class FuseTypeInfoPass(Pass):
                         )
                         func(self, node)
                         self.__set_type_sym_table_link(node)
-                        self.__collect_python_dependencies(node)
 
                 # Special handing for BuiltinType
                 elif isinstance(node, ast.BuiltinType):
@@ -266,6 +236,43 @@ class FuseTypeInfoPass(Pass):
         if len(node.gen.mypy_ast) == 0:
             return
 
+        # No need to run this handling in case of a previous type
+        # was set during the pass, if not then we hope that the
+        # mypy node has a type associated to it
+        if node.expr_type != "NoType":
+            return
+
+        # Check if the expression is a data spatial expression
+        # Support disconnectOp
+        if isinstance(node, ast.BinaryExpr):
+            if isinstance(node.op, ast.DisconnectOp):
+                node.expr_type = "builtins.bool"
+                return
+
+            # Support spwan and connectOp
+            elif (
+                isinstance(node.op, ast.ConnectOp)
+                or node.op.name == Tokens.KW_SPAWN.value
+            ):
+                if node.gen.mypy_ast[-1] in self.node_type_hash:
+                    node.expr_type = (
+                        self.__call_type_handler(
+                            self.node_type_hash[node.gen.mypy_ast[-1]]
+                        )
+                        or node.expr_type
+                    )
+                return
+
+        if isinstance(node, ast.EdgeRefTrailer) and any(
+            isinstance(k, ast.FilterCompr) for k in node.kid
+        ):
+            if node.gen.mypy_ast[-1] in self.node_type_hash:
+                node.expr_type = (
+                    self.__call_type_handler(self.node_type_hash[node.gen.mypy_ast[-1]])
+                    or node.expr_type
+                )
+            return
+
         # If the corrosponding mypy ast node type has stored here, get the values.
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
@@ -427,7 +434,14 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None:
         """Pass handler for SpecialVarRef nodes."""
-        return self.enter_name(node)
+        if node.py_resolve_name() == Constants.ROOT:
+            if node.gen.mypy_ast[-1] in self.node_type_hash:
+                node.name_spec.expr_type = (
+                    self.__call_type_handler(self.node_type_hash[node.gen.mypy_ast[-1]])
+                    or node.name_spec.expr_type
+                )
+        else:
+            self.enter_name(node)
 
     @__handle_node
     def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
@@ -491,7 +505,7 @@ class FuseTypeInfoPass(Pass):
         self, mypy_type: MypyTypes.Overloaded
     ) -> Optional[str]:
         """Get type info from mypy type Overloaded."""
-        return self.__call_type_handler(mypy_type.items[0])
+        return self.__call_type_handler(mypy_type.items[-1])
 
     def get_type_from_none_type(self, mypy_type: MypyTypes.NoneType) -> Optional[str]:
         """Get type info from mypy type NoneType."""
@@ -509,6 +523,12 @@ class FuseTypeInfoPass(Pass):
         """Get type info from mypy type TypeType."""
         return str(mypy_type.item)
 
+    def get_type_from_type_var_type(
+        self, mypy_type: MypyTypes.TypeVarType
+    ) -> Optional[str]:
+        """Get type info from mypy type TypeType."""
+        return str(mypy_type.name)
+
     def exit_assignment(self, node: ast.Assignment) -> None:
         """Add new symbols in the symbol table in case of self."""
         # This will fix adding new items to the class through self
@@ -590,6 +610,7 @@ class FuseTypeInfoPass(Pass):
                     # right index slice is a range then it's type is the same as left
                     if right.is_range:
                         right.expr_type = left.expr_type
+                        right.parent_of_type(ast.AtomTrailer).expr_type = node_type
                         continue
 
                 # left type is a dictionary
@@ -603,6 +624,7 @@ class FuseTypeInfoPass(Pass):
                     continue
 
                 right.expr_type = node_type
+                right.parent_of_type(ast.AtomTrailer).expr_type = node_type
 
                 # Getting the correct symbol table and link it
                 type_symtab: Optional[SymbolTable] = self.ir.sym_tab
@@ -621,6 +643,13 @@ class FuseTypeInfoPass(Pass):
                 right.type_sym_tab = type_symtab
 
             else:
+                # Fix the symbolTable linking in case of type annotations
+                if left.type_sym_tab is None and isinstance(node.parent, ast.SubTag):
+                    assert isinstance(left, ast.AstSymbolNode)
+                    left.name_spec.type_sym_tab = self.ir.sym_tab.find_scope(
+                        left.sym_name
+                    )
+
                 if left.type_sym_tab:
                     right.name_spec.sym = left.type_sym_tab.lookup(right.sym_name)
                     if right.name_spec.sym: