jaclang 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

jaclang/compiler/type_system/type_evaluator.jac

@@ -15,7 +15,7 @@ import from typing { Callable, TYPE_CHECKING, cast }
 
 import jaclang.compiler.unitree as uni;
 import from jaclang.compiler { TOKEN_MAP }
-import from jaclang.compiler.constant { Tokens as Tok }
+import from jaclang.compiler.constant { SymbolType, Tokens as Tok }
 import from jaclang.compiler.passes.main.pyast_load_pass { PyastBuildPass }
 import from jaclang.compiler.passes.main.sym_tab_build_pass { SymTabBuildPass }
 import from jaclang.compiler.type_system { types }
@@ -112,9 +112,11 @@ class TypeEvaluator {
     def __init__(self: TypeEvaluator, program: "JacProgram") -> None {
         self.program = program;
         self.symbol_resolution_stack: list[SymbolResolutionStackEntry] = [];
+        self.prefetch: PrefetchedTypes | None = None;
         self.builtins_module = self._load_builtins_stub_module();
-        self.prefetch = self._prefetch_types();
         self.diagnostic_callback: DiagnosticCallback | None = None;
+
+        self._prefetch_types();
     }
 
     """Load and return the builtins stub module."""
@@ -147,7 +149,7 @@ class TypeEvaluator {
 
     """Return the prefetched types for the type evaluator."""
     def _prefetch_types(self: TypeEvaluator) -> "PrefetchedTypes" {
-        return PrefetchedTypes(
+        self.prefetch = PrefetchedTypes(
             # TODO: Pyright first try load NoneType from typeshed and if it cannot
             # then it set to unknown type.
             none_type_class=types.UnknownType(),
@@ -267,23 +269,41 @@ class TypeEvaluator {
 
     """Return the effective type of the module."""
     def get_type_of_module(self: TypeEvaluator, node_: uni.ModulePath) -> types.TypeBase {
-        if node_.name_spec.type is not None {
-            return cast(types.ModuleType, node_.name_spec.type);
-        }
-        if not Path(node_.resolve_relative_path()).exists() {
-            node_.name_spec.type = types.UnknownType();
-            return node_.name_spec.type;
-        }
+        if node_.path {
+            # If the type is already computed, return it.
+            if node_.path[-1].type {
+                return node_.path[-1].type;
+            }
 
-        mod: uni.Module = self._import_module_from_path(node_.resolve_relative_path());
-        mod_type = types.ModuleType(
-            mod_name=node_.name_spec.sym_name,
-            file_uri=Path(node_.resolve_relative_path()).resolve(),
-            symbol_table=mod,
-        );
+            for (idx, npath) in enumerate(node_.path) {
+                mod_path = node_.resolve_relative_path_list()[idx];
+
+                # If the path doesn't exist, return unknown type.
+                # eg: import from ..mod { item }  # <-- Here ..mod might not exist.
+                if not Path(mod_path).exists() {
+                    npath.type = types.UnknownType();
+                    npath._sym_category = SymbolType.MODULE;
+                    self.add_diagnostic(npath, 'Module not found', warning=True);
+                    return npath.type;
+                }
+
+                mod: uni.Module = self._import_module_from_path(mod_path);
+                mod_type = types.ModuleType(
+                    mod_name=npath.value,
+                    file_uri=Path(mod_path).resolve(),
+                    symbol_table=mod
+                );
+                npath.type = mod_type;
+                npath._sym_category = SymbolType.MODULE;
+            }
+            if node_.alias {
+                node_.alias.type = node_.path[-1].type;
+                node_.alias._sym_category = SymbolType.MODULE;
+            }
+            return node_.path[-1].type;
+        }
+        return types.UnknownType();
 
-        node_.name_spec.type = mod_type;
-        return mod_type;
     }
 
     """Return the effective type of the module item."""
@@ -291,12 +311,13 @@ class TypeEvaluator {
         # Module item can be both a module or a member of a module.
         # import from .. { mod }   # <-- Here mod is not a member but a module itself.
         # import from mod { item } # <-- Here item is not a module but a member of mod.
-        if node_.name_spec.type is not None {
-            return node_.name_spec.type;
+        if node_.name.type is not None {
+            return node_.name.type;
         }
 
         import_node = node_.parent_of_type(uni.Import);
-        if import_node.from_loc {
+        assert import_node.from_loc is not None;
+        if isinstance(self.get_type_of_module(import_node.from_loc), types.ModuleType){
 
             from_path = Path(import_node.from_loc.resolve_relative_path());
             is_dir = from_path.is_dir() or (from_path.stem == "__init__");
@@ -309,12 +330,12 @@ class TypeEvaluator {
                     if (path := (mod_dir / (node_.name.value + ext)).resolve()).exists() {
                         mod = self._import_module_from_path(str(path));
                         mod_type = types.ModuleType(
-                            mod_name=node_.name_spec.sym_name,
+                            mod_name=node_.name.sym_name,
                             file_uri=path,
                             symbol_table=mod,
                         );
                         # Cache the type.
-                        node_.name_spec.type = mod_type;
+                        node_.name.type = mod_type;
 
                         # FIXME: goto definition works on imported symbol by checking if it's a MODULE
                         # type and in that case it'll call resolve_relative_path on the parent node of
@@ -323,8 +344,8 @@ class TypeEvaluator {
                         # below should work but because of the above assumption (should be a mod path)
                         # it won't, This needs to be discussed.
                         #
-                        # node.name_spec._sym_category = uni.SymbolType.MODULE
-                        return node_.name_spec.type;
+                        node_.name._sym_category = SymbolType.MODULE;
+                        return mod_type;
                     }
                 }
             }
@@ -333,18 +354,18 @@ class TypeEvaluator {
             else {
                 mod_type = self.get_type_of_module(import_node.from_loc);
                 if not isinstance(mod_type, types.ModuleType) {
-                    node_.name_spec.type = types.UnknownType();
+                    node_.name.type = types.UnknownType();
                     # TODO: Add diagnostic that from_loc is not accessible.
                     # Eg: 'Import "scipy" could not be resolved'
-                    return node_.name_spec.type;
+                    return node_.name.type;
                 }
                 if sym := mod_type.symbol_table.lookup(node_.name.value, deep=True) {
                     node_.name.sym = sym;
                     if node_.alias {
                         node_.alias.sym = sym;
                     }
-                    node_.name_spec.type = self.get_type_of_symbol(sym);
-                    return node_.name_spec.type;
+                    node_.name.type = self.get_type_of_symbol(sym);
+                    return node_.name.type;
                 }
             }
         }
@@ -366,12 +387,18 @@ class TypeEvaluator {
         }
         is_builtin_class = node_.find_parent_of_type(uni.Module) == self.builtins_module;
 
+        # NOTE: obj, walker, node, edge are dataclass with symbol type as such but
+        # other classes are with symbol type TYPE.
+        # TODO: We need to handle @dataclass decorator as well.
+        is_data_class = node_.sym_category != SymbolType.TYPE;
+
         cls_type = types.ClassType(
             types.ClassType.ClassDetailsShared(
                 class_name=node_.name_spec.sym_name,
                 symbol_table=node_,
                 base_classes=base_classes,
                 is_builtin_class=is_builtin_class,
+                is_data_class=is_data_class,
             ),
             flags=types.TypeFlags.Instantiable,
         );
@@ -600,12 +627,6 @@ class TypeEvaluator {
     def _get_type_of_symbol(self: TypeEvaluator, symbol: uni.Symbol) -> TypeBase {
         node_ = symbol.decl.name_of;
         match node_ {
-            case uni.ModulePath():
-                return self.get_type_of_module(node_);
-
-            case uni.ModuleItem():
-                return self.get_type_of_module_item(node_);
-
             case uni.Archetype():
                 return self.get_type_of_class(node_);
 
@@ -635,6 +656,12 @@ class TypeEvaluator {
                         }
                     }
                 }
+                if isinstance(node_.parent, uni.ModulePath) {
+                    return self.get_type_of_module(node_.parent);
+                }
+                if isinstance(node_.parent, uni.ModuleItem) {
+                    return self.get_type_of_module_item(node_.parent);
+                }
 
             case uni.HasVar():
                 if node_.type_tag is not None {
@@ -657,14 +684,30 @@ class TypeEvaluator {
     def _get_type_of_expression_core(self: TypeEvaluator, expr: uni.Expr) -> TypeBase {
         match expr {
 
+            # ----------------------------------------------------------------------
+            # Prefetched types: These types may not have prefetched and we need to
+            # check if they are available, if the're not, we're inside builtins or
+            # typeshed module itself and in that case we can just return unknown type.
+            # ----------------------------------------------------------------------
+
             case uni.String() | uni.MultiString():
-                return self._convert_to_instance(self.get_type_of_string(expr));
+                if self.prefetch {
+                    return self._convert_to_instance(self.get_type_of_string(expr));
+                }
 
             case uni.Int():
-                return self._convert_to_instance(self.get_type_of_int(expr));
+                if self.prefetch {
+                    return self._convert_to_instance(self.get_type_of_int(expr));
+                }
 
             case uni.Float():
-                return self._convert_to_instance(self.get_type_of_float(expr));
+                if self.prefetch {
+                    return self._convert_to_instance(self.get_type_of_float(expr));
+                }
+
+            # ----------------------------------------------------------------------
+            # End of prefetched types
+            # ----------------------------------------------------------------------
 
             case uni.AtomTrailer():
                 # NOTE: Pyright is using CFG to figure out the member type by narrowing the base
@@ -679,8 +722,7 @@ class TypeEvaluator {
                         if sym := base_type.symbol_table.lookup(
                             expr.right.value, deep=True
                         ) {
-                            expr.right.sym = sym;
-                            return self.get_type_of_symbol(sym);
+                            return self._set_symbol_to_expr(expr.right, sym);
                         }
                         return types.UnknownType();
                     }
@@ -690,8 +732,7 @@ class TypeEvaluator {
                         if member := self._lookup_class_member(
                             base_type, expr.right.value
                         ) {
-                            expr.right.sym = member.symbol;
-                            return self.get_type_of_symbol(member.symbol);
+                            return self._set_symbol_to_expr(expr.right, member.symbol);
                         }
                         return types.UnknownType();
                     }
@@ -701,8 +742,7 @@ class TypeEvaluator {
                         if member := self._lookup_object_member(
                             base_type, expr.right.value
                         ) {
-                            expr.right.sym = member.symbol;
-                            return self.get_type_of_symbol(member.symbol);
+                            return self._set_symbol_to_expr(expr.right, member.symbol);
                         }
                         return types.UnknownType();
                     }
@@ -734,7 +774,7 @@ class TypeEvaluator {
                 }
 
                 if symbol := expr.sym_tab.lookup(expr.value, deep=True) {
-                    expr.sym = symbol;
+                    expr.sym = self.resolve_imported_symbols(symbol);
                     return self.get_type_of_symbol(symbol);
                 }
         }
@@ -747,6 +787,26 @@ class TypeEvaluator {
     # Helper functions
     # -----------------------------------------------------------------------------
 
+    """Resolve the imported symbols to the actual symbol."""
+    def resolve_imported_symbols(self: TypeEvaluator, sym: uni.Symbol) -> uni.Symbol {
+        if (
+            isinstance(sym.decl, uni.Name) and sym.decl.find_parent_of_type(uni.ModuleItem)
+        ) {
+            # If the symbol is from a module item, we need to resolve it to the actual symbol.
+            mod_item = sym.decl.find_parent_of_type(uni.ModuleItem);
+            assert (mod_item is not None);
+            self.get_type_of_module(mod_item.from_mod_path);
+            return (mod_item.name.sym or sym);
+        }
+        return sym;
+    }
+
+    def _set_symbol_to_expr(self: TypeEvaluator, expr: uni.Expr, sym: uni.Symbol) -> TypeBase {
+        expr.sym = sym;
+        expr.type = self.get_type_of_symbol(sym);
+        return expr.type;
+    }
+
     """Check if the expression is Name that is 'self' and in the method context."""
     def _is_expr_self(self: TypeEvaluator, expr: uni.Expr) -> bool {
         if (
@@ -812,7 +872,6 @@ class TypeEvaluator {
 
     """Lookup the class member type."""
     def _lookup_class_member(self: TypeEvaluator, base_type: types.ClassType, member: str) -> type_utils.ClassMember | None {
-        assert self.prefetch.int_class is not None;
         # FIXME: Pyright's way: Implement class member iterator (based on mro and the multiple inheritance)
         # return the first found member from the iterator.
 
@@ -908,6 +967,8 @@ class TypeEvaluator {
     """
     def validate_call_args(self: TypeEvaluator, expr: uni.FuncCall) -> TypeBase {
         caller_type = self.get_type_of_expression(expr.target);
+
+        # 1. Call to a function.
         if isinstance(caller_type, types.FunctionType) {
             arg_param_match = self.match_args_to_params(expr, caller_type);
             if not arg_param_match.argument_errors {
@@ -916,14 +977,34 @@ class TypeEvaluator {
             return caller_type.return_type or types.UnknownType();
         }
 
-        if (
-            isinstance(caller_type, types.ClassType)
-            and caller_type.is_instantiable_class()
-        ) {
+        # 2. Call to an instantiable class.
+        if (isinstance(caller_type, types.ClassType) and caller_type.is_instantiable_class()) {
             # TODO: validate args for __init__()
+
+            # If it has __init__ method, try to call it.
+            if init_method := self._lookup_class_member(caller_type, "__init__") {
+                init_fn_type = self.get_type_of_symbol(init_method.symbol);
+                if isinstance(init_fn_type, types.FunctionType) {
+                    arg_param_match = self.match_args_to_params(expr, init_fn_type);
+                    if not arg_param_match.argument_errors {
+                        self.validate_arg_types(arg_param_match);
+                    }
+                }
+            }
+
+            # If it's a data class, create the __init__ method and validate.
+            elif caller_type.is_data_class() {
+                init_fn_type = self._create_dataclass_init_method(caller_type);
+                arg_param_match = self.match_args_to_params(expr, init_fn_type);
+                if not arg_param_match.argument_errors {
+                    self.validate_arg_types(arg_param_match);
+                }
+            }
+
             return caller_type.clone_as_instance();
         }
 
+        # 3. Call to a callable object (__call__).
         if caller_type.is_class_instance() {
             # TODO: validate args.
             magic_call_ret = self.get_type_of_magic_method_call(caller_type, "__call__");
@@ -956,4 +1037,42 @@ class TypeEvaluator {
         }
     }
 
+    def _create_dataclass_init_method(self: TypeEvaluator, class_type: types.ClassType) -> types.FunctionType {
+
+        parameters: list[types.Parameter] = [];
+
+        # Iterate over the has vars and create parameters.
+        for has_var in class_type.shared.symbol_table.get_has_vars() {
+
+            # Get parameter type.
+            param_type: TypeBase | None = None;
+            if has_var.type_tag {
+                var_type_expr = has_var.type_tag.tag;
+                type_cls = self.get_type_of_expression(var_type_expr);
+                param_type = self._convert_to_instance(type_cls);
+            }
+
+            # Create parameter.
+            parameters.append(
+                types.Parameter(
+                    name=has_var.name.value,
+                    category=types.ParameterCategory.Positional,
+                    param_type=param_type,
+                    default_value=has_var.value,
+                    is_self=False,
+                    param_kind=types.ParamKind.NORMAL,
+                )
+            );
+        }
+
+        # Create and return the __init__ method type.
+        return types.FunctionType(
+            func_name="__init__",
+            return_type=types.UnknownType(),
+            parameters=parameters,
+        );
+
+    }
+
+
 }

jaclang/compiler/type_system/type_utils.py

@@ -167,7 +167,7 @@ class ParamAssignmentTracker:
         if self.curr_param_idx == -1:
             return self.varargs
 
-        if isinstance(arg, uni.UnaryExpr) and arg.op.value == Tok.STAR_MUL:
+        if isinstance(arg, uni.UnaryExpr) and arg.op.name == Tok.STAR_MUL:
             self._mark_all_positional_params_as_matched()
             return None
         else:

jaclang/compiler/type_system/types.py

@@ -164,6 +164,7 @@ class ClassType(TypeBase):
             symbol_table: SymbolTable,
             base_classes: list[TypeBase] | None = None,
             is_builtin_class: bool = False,
+            is_data_class: bool = False,
         ) -> None:
             """Initialize obviously."""
             self.class_name = class_name
@@ -182,6 +183,7 @@ class ClassType(TypeBase):
             #   ...
             #
             self.is_builtin_class = is_builtin_class
+            self.is_data_class = is_data_class
 
     def __init__(
         self,
@@ -226,6 +228,10 @@ class ClassType(TypeBase):
             return self.shared.class_name == class_name
         return True
 
+    def is_data_class(self) -> bool:
+        """Return true if this class is a data class."""
+        return self.shared.is_data_class
+
 
 class ParamKind(IntEnum):
     """Enumeration of parameter kinds."""