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

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -3,162 +3,56 @@
 This pass checks for access to attributes in the Jac language.
 """
 
-import os
 from typing import Optional
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import SymbolAccess
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.symtable import SymbolTable
+from jaclang.compiler.symtable import Symbol
 from jaclang.settings import settings
 
 
 class AccessCheckPass(Pass):
     """Jac Ast Access Check pass."""
 
-    def after_pass(self) -> None:
-        """After pass."""
-        pass
-
-    def exit_node(self, node: ast.AstNode) -> None:
+    # NOTE: This method is a hacky way to detect if the drivied class is inherit from base class, it
+    # doesn't work if the base class was provided as an expression (ex. obj Dri :module.Base: {...}).
+    def is_class_inherited_from(
+        self, dri_class: ast.Architype, base_class: ast.Architype
+    ) -> bool:
+        """Return true if the dri_class inherited from base_class."""
+        if dri_class.base_classes is None:
+            return False
+        for expr in dri_class.base_classes.items:
+            if not isinstance(expr, ast.Name):
+                continue
+            if not isinstance(expr.name_of, ast.Architype):
+                continue  # Unlikely.
+            if expr.name_of == base_class:
+                return True
+            if self.is_class_inherited_from(expr.name_of, base_class):
+                return True
+        return False
+
+    def report_error(self, message: str, node: Optional[ast.AstNode] = None) -> None:
+        """Report error message related to illegal access of attributes and objects."""
+        self.error(message, node)
+
+    def exit_node(self, node: ast.AstNode) -> None:  # TODO: Move to debug pass
         """Exit node."""
         super().exit_node(node)
-        if settings.lsp_debug and isinstance(node, ast.NameAtom) and not node.sym:
-            self.warning(f"Name {node.sym_name} not present in symbol table")
-
-    def access_check(self, node: ast.Name) -> None:
-        """Access check."""
-        node_info = (
-            node.sym_tab.lookup(node.sym_name)
-            if isinstance(node.sym_tab, SymbolTable)
-            else None
-        )
-
-        if node.sym:
-            decl_package_path = os.path.dirname(
-                os.path.abspath(node.sym.defn[-1].loc.mod_path)
-            )
-            use_package_path = os.path.dirname(os.path.abspath(node.loc.mod_path))
-        else:
-            decl_package_path = use_package_path = ""
-
         if (
-            node_info
-            and node.sym
-            and node_info.access == SymbolAccess.PROTECTED
-            and decl_package_path != use_package_path
-        ):
-            return self.error(
-                f'Can not access protected variable "{node.sym_name}" from {decl_package_path}'
-                f" to {use_package_path}."
+            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.sym_name == "py"
+                and node.parent
+                and isinstance(node.parent.parent, ast.Import)
             )
-
-        if (
-            node_info
-            and node.sym
-            and node_info.access == SymbolAccess.PRIVATE
-            and node.sym.defn[-1].loc.mod_path != node.loc.mod_path
         ):
-            return self.error(
-                f'Can not access private variable "{node.sym_name}" from {node.sym.defn[-1].loc.mod_path}'
-                f" to {node.loc.mod_path}."
-            )
-
-    def access_register(
-        self, node: ast.AstSymbolNode, acc_tag: Optional[SymbolAccess] = None
-    ) -> None:
-        """Access register."""
-
-    def enter_global_vars(self, node: ast.GlobalVars) -> None:
-        """Sub objects.
-
-        access: Optional[SubTag[Token]],
-        assignments: SubNodeList[Assignment],
-        is_frozen: bool,
-        """
-        pass
-
-    def enter_module(self, node: ast.Module) -> None:
-        """Sub objects.
-
-        name: str,
-        doc: Token,
-        body: Optional['Elements'],
-        mod_path: str,
-        is_imported: bool,
-        """
-
-    def enter_architype(self, node: ast.Architype) -> None:
-        """Sub objects.
-
-        name: Name,
-        arch_type: Token,
-        access: Optional[SubTag[Token]],
-        base_classes: Optional[SubNodeList[Expr]],
-        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
-        decorators: Optional[SubNodeList[Expr]] = None,
-        """
-        pass
-
-    def enter_enum(self, node: ast.Enum) -> None:
-        """Sub objects.
-
-        name: Name,
-        access: Optional[SubTag[Token]],
-        base_classes: Optional[SubNodeList[Expr]],
-        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
-        decorators: Optional[SubNodeList[Expr]] = None,
-        """
-        pass
-
-    def enter_ability(self, node: ast.Ability) -> None:
-        """Sub objects.
-
-        name_ref: NameSpec,
-        is_func: bool,
-        is_async: bool,
-        is_override: bool,
-        is_static: bool,
-        is_abstract: bool,
-        access: Optional[SubTag[Token]],
-        signature: Optional[FuncSignature | EventSignature],
-        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef],
-        decorators: Optional[SubNodeList[Expr]] = None,
-        """
-        pass
-
-    def enter_sub_node_list(self, node: ast.SubNodeList) -> None:
-        """Sub objects.
-
-        items: list[T]
-        """
-
-    def enter_arch_has(self, node: ast.ArchHas) -> None:
-        """Sub objects.
-
-        is_static: bool,
-        access: Optional[SubTag[Token]],
-        vars: SubNodeList[HasVar],
-        is_frozen: bool,
-        """
-        pass
-
-    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None:
-        """Sub objects.
-
-        access: Optional[SubTag[Token]],
-        """
-        pass
-
-    def enter_func_call(self, node: ast.FuncCall) -> None:
-        """Sub objects.
-
-        target: Expr,
-        params: Optional[SubNodeList[Expr | KWPair]],
-        genai_call: Optional[FuncCall],
-        kid: Sequence[AstNode],
-        """
-        pass
+            self.warning(f"Name {node.sym_name} not present in symbol table")
 
     def enter_name(self, node: ast.Name) -> None:
         """Sub objects.
@@ -170,12 +64,67 @@ class AccessCheckPass(Pass):
         pos_start: int,
         pos_end: int,
         """
-        from jaclang.compiler.passes import Pass
+        # TODO: Enums are not considered at the moment, I'll need to test and add them bellow.
 
-        if isinstance(node.parent, ast.FuncCall):
-            self.access_check(node)
+        # If the current node is a global variable's name there is no access, it's just the declaration.
+        if Pass.find_parent_of_type(node, ast.GlobalVars) is not None:
+            return
 
-        if node.sym and Pass.find_parent_of_type(
-            node=node.sym.defn[-1], typ=ast.GlobalVars
-        ):
-            self.access_check(node)
+        # Class name, and ability name are declarations and there is no access here as well.
+        if isinstance(node.name_of, (ast.Ability, ast.Architype, ast.Enum)):
+            return
+
+        # Get the context to check the access.
+        curr_class: Optional[ast.Architype] = Pass.find_parent_of_type(
+            node, ast.Architype
+        )
+        curr_module: Optional[ast.Module] = Pass.find_parent_of_type(node, ast.Module)
+        if curr_module is None:
+            return
+
+        # Note that currently we can only check for name + symbols, because expressions are not associated with the
+        # typeinfo thus they don't have a symbol. In the future the name nodes will become expression nodes.
+        if not isinstance(node.sym, Symbol):
+            return
+
+        # Public symbols are fine.
+        if node.sym.access == SymbolAccess.PUBLIC:
+            return
+
+        # Note that from bellow the access is either private or protected.
+        is_portect = node.sym.access == SymbolAccess.PROTECTED
+        access_type = "protected" if is_portect else "private"
+
+        # The class we're currently in (None if we're not inside any).
+        sym_owner: ast.AstNode = node.sym.parent_tab.owner
+
+        # If the symbol belongs to a class, we need to check if the access used properly
+        # within the class and in it's inherited classes.
+        if isinstance(sym_owner, ast.Architype):
+
+            # Accessing a private/protected member within the top level scope illegal.
+            if curr_class is None:
+                return self.report_error(
+                    f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                    node,
+                )
+
+            if curr_class != node.sym.parent_tab.owner:
+                if not is_portect:  # private member accessed in a different class.
+                    return self.report_error(
+                        f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                        node,
+                    )
+                else:  # Accessing a protected member, check we're in an inherited class.
+                    if not self.is_class_inherited_from(curr_class, sym_owner):
+                        return self.report_error(
+                            f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                            node,
+                        )
+
+        elif isinstance(sym_owner, ast.Module) and sym_owner != curr_module:
+            # Accessing a private/public member in a different module.
+            return self.report_error(
+                f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                node,
+            )

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,7 +6,7 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
-from typing import Callable, TypeVar
+from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
@@ -29,12 +29,12 @@ class FuseTypeInfoPass(Pass):
 
     node_type_hash: dict[MypyNodes.Node | VNode, MyType] = {}
 
-    def __debug_print(self, *argv: object) -> None:
+    def __debug_print(self, msg: str) -> None:
         if settings.fuse_type_info_debug:
-            self.log_info("FuseTypeInfo::", *argv)
+            self.log_info("FuseTypeInfo::" + msg)
 
     def __call_type_handler(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.ProperType
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Type
     ) -> None:
         mypy_type_name = pascal_to_snake(mypy_type.__class__.__name__)
         type_handler_name = f"get_type_from_{mypy_type_name}"
@@ -52,6 +52,9 @@ class FuseTypeInfoPass(Pass):
         if typ[0] == "builtins":
             return
 
+        if node.sym_type == "types.ModuleType" and node.sym:
+            node.name_spec.type_sym_tab = node.sym.parent_tab.find_scope(node.sym_name)
+
         assert isinstance(self.ir, ast.Module)
 
         if typ_sym_table:
@@ -65,6 +68,35 @@ 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]
@@ -86,6 +118,7 @@ class FuseTypeInfoPass(Pass):
                 if len(node.gen.mypy_ast) == 1:
                     func(self, node)
                     self.__set_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:
@@ -101,24 +134,27 @@ class FuseTypeInfoPass(Pass):
                     # Check the number of unique mypy nodes linked
                     if len(temp) > 1:
                         self.__debug_print(
-                            jac_node_str, "has multiple mypy nodes associated to it"
+                            f"{jac_node_str} has multiple mypy nodes associated to it"
                         )
                     else:
                         self.__debug_print(
-                            jac_node_str, "has duplicate mypy nodes associated to it"
+                            f"{jac_node_str} has duplicate mypy nodes associated to it"
                         )
                         func(self, node)
                         self.__set_sym_table_link(node)
+                        self.__collect_python_dependencies(node)
 
                 # Jac node doesn't have mypy nodes linked to it
                 else:
                     self.__debug_print(
-                        jac_node_str, "doesn't have mypy node associated to it"
+                        f"{jac_node_str} doesn't have mypy node associated to it"
                     )
 
             except AttributeError as e:
+                if settings.fuse_type_info_debug:
+                    raise e
                 self.__debug_print(
-                    f'Internal error happened while parsing "{e.obj.__class__.__name__}"'
+                    f'{node.loc}: Internal error happened while parsing "{e.obj.__class__.__name__}"'
                 )
 
         return node_handler
@@ -128,12 +164,7 @@ 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 "def" in t and "->" in t:
-                    t = t.split("->")[1].strip()
-                elif "def" in t:
-                    t = "None"
-                node.name_spec.sym_type = t
+                self.__call_type_handler(node, self.node_type_hash[mypy_node])
             else:
                 self.__debug_print(f"{node.loc} MemberExpr type is not found")
 
@@ -158,8 +189,8 @@ class FuseTypeInfoPass(Pass):
 
             else:
                 self.__debug_print(
-                    f'"{node.loc}::{node.__class__.__name__}" mypy (with node attr) node isn\'t supported',
-                    type(mypy_node),
+                    f'"{node.loc}::{node.__class__.__name__}" mypy (with node attr) node isn\'t supported'
+                    f"{type(mypy_node)}"
                 )
 
         else:
@@ -174,8 +205,8 @@ class FuseTypeInfoPass(Pass):
                 self.__call_type_handler(node, mypy_node.func.type.ret_type)
             else:
                 self.__debug_print(
-                    f'"{node.loc}::{node.__class__.__name__}" mypy node isn\'t supported',
-                    type(mypy_node),
+                    f'"{node.loc}::{node.__class__.__name__}" mypy node isn\'t supported'
+                    f"{type(mypy_node)}"
                 )
 
     @__handle_node
@@ -186,12 +217,12 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Pass handler for ModulePath nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_module_item(self, node: ast.ModuleItem) -> None:
         """Pass handler for ModuleItem nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_architype(self, node: ast.Architype) -> None:
@@ -201,7 +232,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_arch_def(self, node: ast.ArchDef) -> None:
         """Pass handler for ArchDef nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_enum(self, node: ast.Enum) -> None:
@@ -211,7 +242,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_enum_def(self, node: ast.EnumDef) -> None:
         """Pass handler for EnumDef nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_ability(self, node: ast.Ability) -> None:
@@ -220,8 +251,8 @@ class FuseTypeInfoPass(Pass):
             self.__call_type_handler(node, node.gen.mypy_ast[0].type.ret_type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get type of an ability from mypy node other than Ability.",
-                type(node.gen.mypy_ast[0]),
+                f"{node.loc}: Can't get type of an ability from mypy node other than Ability. "
+                f"{type(node.gen.mypy_ast[0])}"
             )
 
     @__handle_node
@@ -231,8 +262,8 @@ class FuseTypeInfoPass(Pass):
             self.__call_type_handler(node, node.gen.mypy_ast[0].type.ret_type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get type of an AbilityDef from mypy node other than FuncDef.",
-                type(node.gen.mypy_ast[0]),
+                f"{node.loc}: Can't get type of an AbilityDef from mypy node other than FuncDef. "
+                f"{type(node.gen.mypy_ast[0])}"
             )
 
     @__handle_node
@@ -278,7 +309,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_f_string(self, node: ast.FString) -> None:
         """Pass handler for FString nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_list_val(self, node: ast.ListVal) -> None:
@@ -331,7 +362,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Pass handler for IndexSlice nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
@@ -345,8 +376,8 @@ class FuseTypeInfoPass(Pass):
             self.__call_type_handler(node, mypy_node2.type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get ArchRef value from mypyNode other than ClassDef",
-                type(node.gen.mypy_ast[0]),
+                f"{node.loc}: Can't get ArchRef value from mypyNode other than ClassDef "
+                f"type(node.gen.mypy_ast[0])"
             )
 
     @__handle_node
@@ -362,12 +393,12 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_filter_compr(self, node: ast.FilterCompr) -> None:
         """Pass handler for FilterCompr nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_assign_compr(self, node: ast.AssignCompr) -> None:
         """Pass handler for AssignCompr nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_int(self, node: ast.Int) -> None:
@@ -404,7 +435,7 @@ class FuseTypeInfoPass(Pass):
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.CallableType
     ) -> None:
         """Get type info from mypy type CallableType."""
-        node.name_spec.sym_type = str(mypy_type.ret_type)
+        self.__call_type_handler(node, mypy_type.ret_type)
 
     # TODO: Which overloaded function to get the return value from?
     def get_type_from_overloaded(
@@ -431,6 +462,12 @@ class FuseTypeInfoPass(Pass):
         """Get type info from mypy type TupleType."""
         node.name_spec.sym_type = "builtins.tuple"
 
+    def get_type_from_type_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TypeType
+    ) -> None:
+        """Get type info from mypy type TypeType."""
+        node.name_spec.sym_type = str(mypy_type.item)
+
     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
@@ -446,20 +483,85 @@ class FuseTypeInfoPass(Pass):
                 if self_obj.type_sym_tab and isinstance(right_obj, ast.AstSymbolNode):
                     self_obj.type_sym_tab.def_insert(right_obj)
 
-    def exit_name(self, node: ast.Name) -> None:
-        """Add new symbols in the symbol table in case of atom trailer."""
-        if isinstance(node.parent, ast.AtomTrailer):
-            target_node = node.parent.target
-            if isinstance(target_node, ast.AstSymbolNode):
-                parent_symbol_table = target_node.type_sym_tab
-                if isinstance(parent_symbol_table, SymbolTable):
-                    node.sym = parent_symbol_table.lookup(node.sym_name)
-
-    # def exit_in_for_stmt(self, node: ast.InForStmt):
-    #     print(node.loc.mod_path, node.loc)
-    #     print(node.target, node.target.loc)
-    #     # node.sym_tab.def_insert()
-    #     # exit()
-
-    # def after_pass(self) -> None:
-    #     exit()
+    def expand_atom_trailer(self, node_list: list[ast.AstNode]) -> list[ast.AstNode]:
+        """Expand the atom trailer object in a list of AstNode."""
+        out: list[ast.AstNode] = []
+        for i in node_list:
+            if isinstance(i, ast.AtomTrailer):
+                out.append(i.target)
+                out.append(i.right)
+            elif isinstance(i, ast.FuncCall):
+                out.append(i.target)
+            else:
+                out.append(i)
+        return out
+
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None:
+        """Adding symbol links to AtomTrailer right nodes."""
+        # This will fix adding the symbol links to nodes in atom trailer
+        # self.x.z = 5  # will add symbol links to both x and z
+
+        # This function originally used `as_attr_list` in AtomTrailer
+        # but an issue happened when doing stuff like fool_me().CONST_VALUE2
+        # The issue was due to the way `as_attr_list` implemented so the fix
+        # was to implement it again to get all items in AtomTrailer even if
+        # their type is not an AstSymbolNode
+        atom_trailer_unwind = self.expand_atom_trailer([node])
+        iteration_count = 0
+        while any(
+            isinstance(i, (ast.AtomTrailer, ast.FuncCall)) for i in atom_trailer_unwind
+        ):
+            atom_trailer_unwind = self.expand_atom_trailer(atom_trailer_unwind)
+            iteration_count += 1
+            if iteration_count > 50:
+                break
+
+        for i in range(1, len(atom_trailer_unwind)):
+            left = atom_trailer_unwind[i - 1]
+            right = atom_trailer_unwind[i]
+
+            assert isinstance(left, ast.AstSymbolNode)
+            assert isinstance(right, ast.AstSymbolNode)
+
+            if isinstance(right, ast.IndexSlice):
+                # In case of index slice, left won't have a symbol table as it's a list/dict/set
+                node_type: str = ""
+
+                # left type is a list
+                if left.sym_type.startswith("builtins.list["):
+                    node_type = left.sym_type[len("builtins.list[") : -1]
+
+                    # right index slice is a range then it's type is the same as left
+                    if right.is_range:
+                        right.name_spec.sym_type = left.sym_type
+                        continue
+
+                # left type is a dictionary
+                elif left.sym_type.startswith("builtins.dict["):
+                    node_type = (
+                        left.sym_type[len("builtins.dict[") : -1].split(",")[1].strip()
+                    )
+
+                # unsupported type
+                else:
+                    continue
+
+                right.name_spec.sym_type = node_type
+
+                # Getting the correct symbol table and link it
+                type_symtab: Optional[SymbolTable] = self.ir.sym_tab
+                assert isinstance(self.ir, ast.Module)
+                assert isinstance(type_symtab, SymbolTable)
+                for j in node_type.split("."):
+                    if j == self.ir.name:
+                        continue
+                    type_symtab = type_symtab.find_scope(j)
+                    if type_symtab is None:
+                        break
+                right.name_spec.type_sym_tab = type_symtab
+
+            else:
+                if left.type_sym_tab:
+                    right.name_spec.sym = left.type_sym_tab.lookup(right.sym_name)
+                    if right.name_spec.sym:
+                        right.name_spec.sym.add_use(right.name_spec)