nac3core/src/symbol_resolver.rs

@@ -1,6 +1,6 @@
 use crate::location::Location;
-use crate::typecheck::typedef::Type;
 use crate::top_level::DefinitionId;
+use crate::typecheck::typedef::Type;
 use rustpython_parser::ast::Expr;
 
 #[derive(Clone, PartialEq)]
@@ -21,5 +21,5 @@ pub trait SymbolResolver {
     fn get_symbol_value(&self, str: &str) -> Option<SymbolValue>;
     fn get_symbol_location(&self, str: &str) -> Option<Location>;
     fn get_module_resolver(&self, module_name: &str) -> Option<&dyn SymbolResolver>; // NOTE: for getting imported modules' symbol resolver?
-    // handle function call etc.
+                                                                                     // handle function call etc.
 }

nac3core/src/top_level.rs

@@ -1,3 +1,4 @@
+use std::borrow::Borrow;
 use std::{collections::HashMap, sync::Arc};
 
 use super::typecheck::type_inferencer::PrimitiveStore;
@@ -22,6 +23,8 @@ pub enum TopLevelDef {
         methods: Vec<(String, Type, DefinitionId)>,
         // ancestor classes, including itself.
         ancestors: Vec<DefinitionId>,
+        // symbol resolver of the module defined the class, none if it is built-in type
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
     },
     Function {
         // prefix for symbol, should be unique globally, and not ending with numbers
@@ -40,6 +43,8 @@ pub enum TopLevelDef {
         /// Value: AST annotated with types together with a unification table index. Could contain
         /// rigid type variables that would be substituted when the function is instantiated.
         instance_to_stmt: HashMap<String, (Stmt<Option<Type>>, usize)>,
+        // symbol resolver of the module defined the class
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
     },
     Initializer {
         class_id: DefinitionId,
@@ -52,22 +57,28 @@ pub struct TopLevelContext {
     pub conetexts: Arc<RwLock<Vec<Mutex<Context>>>>,
 }
 
-pub struct TopLevelDefInfo<'a> {
+pub fn name_mangling(mut class_name: String, method_name: &str) -> String {
-    // like adding some info on top of the TopLevelDef for later parsing the class bases, method,
+    // need to further extend to more name mangling like instantiations of typevar
-    // and function sigatures
+    class_name.push_str(method_name);
-    def: TopLevelDef,                         // the definition entry
+    class_name
-    ty: Type,                                 // the entry in the top_level unifier
-    ast: Option<ast::Stmt<()>>,               // the ast submitted by applications
-    resolver: Option<&'a dyn SymbolResolver>, // the resolver
 }
 
-pub struct TopLevelComposer<'a> {
+pub struct TopLevelDefInfo {
-    pub definition_list: Vec<TopLevelDefInfo<'a>>,
+    // like adding some info on top of the TopLevelDef for later parsing the class bases, method,
+    // and function sigatures
+    def: TopLevelDef, // the definition entry
+    ty: Type,         // the entry in the top_level unifier
+    ast: Option<ast::Stmt<()>>, // the ast submitted by applications, primitives and class methods will have None value here
+                                //  resolver: Option<&'a dyn SymbolResolver> // the resolver
+}
+
+pub struct TopLevelComposer {
+    pub definition_list: Vec<TopLevelDefInfo>,
     pub primitives: PrimitiveStore,
     pub unifier: Unifier,
 }
 
-impl<'a> TopLevelComposer<'a> {
+impl TopLevelComposer {
     pub fn make_primitives() -> (PrimitiveStore, Unifier) {
         let mut unifier = Unifier::new();
         let int32 = unifier.add_ty(TypeEnum::TObj {
@@ -102,101 +113,145 @@ impl<'a> TopLevelComposer<'a> {
 
     pub fn new() -> Self {
         let primitives = Self::make_primitives();
-        let definition_list: Vec<TopLevelDefInfo<'a>> = vec![
+        let definition_list: Vec<TopLevelDefInfo> = vec![
             TopLevelDefInfo {
-                def: Self::make_top_level_class_def(0),
+                def: Self::make_top_level_class_def(0, None),
                 ast: None,
-                resolver: None,
                 ty: primitives.0.int32,
             },
             TopLevelDefInfo {
-                def: Self::make_top_level_class_def(1),
+                def: Self::make_top_level_class_def(1, None),
                 ast: None,
-                resolver: None,
                 ty: primitives.0.int64,
             },
             TopLevelDefInfo {
-                def: Self::make_top_level_class_def(2),
+                def: Self::make_top_level_class_def(2, None),
                 ast: None,
-                resolver: None,
                 ty: primitives.0.float,
             },
             TopLevelDefInfo {
-                def: Self::make_top_level_class_def(3),
+                def: Self::make_top_level_class_def(3, None),
                 ast: None,
-                resolver: None,
                 ty: primitives.0.bool,
             },
             TopLevelDefInfo {
-                def: Self::make_top_level_class_def(4),
+                def: Self::make_top_level_class_def(4, None),
                 ast: None,
-                resolver: None,
                 ty: primitives.0.none,
             },
         ]; // the entries for primitive types
         TopLevelComposer { definition_list, primitives: primitives.0, unifier: primitives.1 }
     }
 
-    pub fn make_top_level_class_def(index: usize) -> TopLevelDef {
+    /// already include the definition_id of itself inside the ancestors vector
+    pub fn make_top_level_class_def(
+        index: usize,
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
+    ) -> TopLevelDef {
         TopLevelDef::Class {
             object_id: DefinitionId(index),
             type_vars: Default::default(),
             fields: Default::default(),
             methods: Default::default(),
-            ancestors: Default::default(),
+            ancestors: vec![DefinitionId(index)],
+            resolver,
         }
     }
-    pub fn make_top_level_function_def(name: String, ty: Type) -> TopLevelDef {
+
+    pub fn make_top_level_function_def(
+        name: String,
+        ty: Type,
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
+    ) -> TopLevelDef {
         TopLevelDef::Function {
             name,
             signature: ty,
             instance_to_symbol: Default::default(),
             instance_to_stmt: Default::default(),
+            resolver,
         }
     }
 
-    // like to make and return a "primitive" symbol resolver? so that the symbol resolver can later
+    // like to make and return a "primitive" symbol resolver? so that the symbol resolver
-    // figure out primitive type definitions when passed a primitive type name
+    // can later figure out primitive type definitions when passed a primitive type name
     pub fn get_primitives_definition(&self) -> Vec<(String, DefinitionId, Type)> {
         vec![
             ("int32".into(), DefinitionId(0), self.primitives.int32),
-            ("int64".into(), DefinitionId(0), self.primitives.int32),
+            ("int64".into(), DefinitionId(1), self.primitives.int64),
-            ("float".into(), DefinitionId(0), self.primitives.int32),
+            ("float".into(), DefinitionId(2), self.primitives.float),
-            ("bool".into(), DefinitionId(0), self.primitives.int32),
+            ("bool".into(), DefinitionId(3), self.primitives.bool),
-            ("none".into(), DefinitionId(0), self.primitives.int32),
+            ("none".into(), DefinitionId(4), self.primitives.none),
         ]
     }
 
     pub fn register_top_level(
         &mut self,
         ast: ast::Stmt<()>,
-        resolver: &'a dyn SymbolResolver,
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
     ) -> Result<Vec<(String, DefinitionId, Type)>, String> {
         match &ast.node {
             ast::StmtKind::ClassDef { name, body, .. } => {
                 let class_name = name.to_string();
-                let def_id = self.definition_list.len();
+                let class_def_id = self.definition_list.len();
+
                 // add the class to the unifier
                 let ty = self.unifier.add_ty(TypeEnum::TObj {
-                    obj_id: DefinitionId(def_id),
+                    obj_id: DefinitionId(class_def_id),
                     fields: Default::default(),
                     params: Default::default(),
                 });
+
+                let mut ret_vector: Vec<(String, DefinitionId, Type)> =
+                    vec![(class_name.clone(), DefinitionId(class_def_id), ty)];
+                // parse class def body and register class methods into the def list
+                // NOTE: module's symbol resolver would not know the name of the class methods,
+                // thus cannot return their definition_id? so we have to manage it ourselves?
+                // or do we return the class method list of (method_name, def_id, type) to
+                // application to be used to build symbol resolver? <- current implementation
+                // FIXME: better do not return and let symbol resolver to manage the mangled name
+                for b in body {
+                    if let ast::StmtKind::FunctionDef { name, .. } = &b.node {
+                        let fun_name = name_mangling(class_name.clone(), name);
+                        let def_id = self.definition_list.len();
+                        // add to unifier
+                        let ty = self.unifier.add_ty(TypeEnum::TFunc(
+                            crate::typecheck::typedef::FunSignature {
+                                args: Default::default(),
+                                ret: self.primitives.none,
+                                vars: Default::default(),
+                            },
+                        ));
+                        // add to the definition list
+                        self.definition_list.push(TopLevelDefInfo {
+                            def: Self::make_top_level_function_def(fun_name.clone(), ty, None), // FIXME:
+                            ty,
+                            ast: None, // since it is inside the class def body statments
+                        });
+                        ret_vector.push((fun_name, DefinitionId(def_id), ty));
+
+                        // if it is the contructor, special handling is needed. In the above
+                        // handling, we still add __init__ function to the class method
+                        if name == "__init__" {
+                            self.definition_list.push(TopLevelDefInfo {
+                                def: TopLevelDef::Initializer {
+                                    class_id: DefinitionId(class_def_id),
+                                },
+                                ty: self.primitives.none, // arbitary picked one
+                                ast: None, // it is inside the class def body statments
+                            })
+                            // FIXME: should we return this to the symbol resolver?, should be yes
+                        }
+                    } else {
+                    } // else do nothing
+                }
                 // add to the definition list
                 self.definition_list.push(TopLevelDefInfo {
-                    def: Self::make_top_level_class_def(def_id),
+                    def: Self::make_top_level_class_def(class_def_id, resolver),
-                    resolver: Some(resolver),
                     ast: Some(ast),
                     ty,
                 });
 
-                // TODO: parse class def body and register class methods into the def list?
+                Ok(ret_vector)
-                // FIXME: module's symbol resolver would not know the name of the class methods,
-                // thus cannot return their definition_id? so we have to manage it ourselves?  or
-                // do we return the class method list of (method_name, def_id, type) to application
-                // to be used to build symbol resolver? <- current implementation
-
-                Ok(vec![(class_name, DefinitionId(def_id), ty)]) // FIXME: need to add class method def
             }
 
             ast::StmtKind::FunctionDef { name, .. } => {
@@ -206,16 +261,16 @@ impl<'a> TopLevelComposer<'a> {
                 let ty =
                     self.unifier.add_ty(TypeEnum::TFunc(crate::typecheck::typedef::FunSignature {
                         args: Default::default(),
-                        ret: self.primitives.none, // NOTE: this needs to be changed later
+                        ret: self.primitives.none,
                         vars: Default::default(),
                     }));
                 // add to the definition list
                 self.definition_list.push(TopLevelDefInfo {
                     def: Self::make_top_level_function_def(
                         name.into(),
-                        self.primitives.none, // NOTE: this needs to be changed later
+                        self.primitives.none,
+                        resolver,
                     ),
-                    resolver: Some(resolver),
                     ast: Some(ast),
                     ty,
                 });
@@ -230,53 +285,143 @@ impl<'a> TopLevelComposer<'a> {
     /// this should be called after all top level classes are registered, and will actually fill in those fields of the previous dummy one
     pub fn analyze_top_level(&mut self) -> Result<(), String> {
         for mut d in &mut self.definition_list {
-            if let (Some(ast), Some(resolver)) = (&d.ast, d.resolver) {
+            if let Some(ast) = &d.ast {
                 match &ast.node {
                     ast::StmtKind::ClassDef {
-                        name,
                         bases,
                         body,
                         ..
                     } => {
+                        // get the mutable reference of the entry in the definition list, get the `TopLevelDef`
+                        let (_,
+                            ancestors,
+                            fields,
+                            methods,
+                            type_vars,
+                            // resolver,
+                        ) = if let TopLevelDef::Class {
+                            object_id,
+                            ancestors,
+                            fields,
+                            methods,
+                            type_vars,
+                            resolver
+                        } = &mut d.def {
+                            (object_id, ancestors, fields, methods, type_vars) // FIXME: this unwrap is not safe
+                        } else { unreachable!() };
+
+                        // try to get mutable reference of the entry in the unification table, get the `TypeEnum`
+                        let (params,
+                            fields
+                        ) = if let TypeEnum::TObj {
+                            params, // FIXME: this params is immutable, even if this is mutable, what should the key be, get the original typevar's var_id?
+                            fields,
+                            ..
+                        } = self.unifier.get_ty(d.ty).borrow() {
+                            (params, fields)
+                        } else { unreachable!() };
+
                         // ancestors and typevars associate with the class are analyzed by looking
                         // into the `bases` ast node
                         for b in bases {
                             match &b.node {
-                                // base class, name directly available inside the module, can use
+                                // typevars bounded to the class, things like `class A(Generic[T, V, ImportedModule.T])`
-                                // this module's symbol resolver
+                                // should update the TopLevelDef::Class.typevars and the TypeEnum::TObj.params
-                                ast::ExprKind::Name {id, ..} => {
+                                ast::ExprKind::Subscript {value, slice, ..} if {
-                                    let def_id = resolver.get_identifier_def(id);
-                                    unimplemented!()
-                                },
-                                // things can be like `class A(BaseModule.Base)`, here we have to
-                                // get the symbol resolver of the module `BaseModule`?
-                                ast::ExprKind::Attribute {value, attr, ..} => {
-                                    // need to change symbol resolver in order to get the symbol
-                                    // resolver of the imported module
-                                    unimplemented!()
-                                },
-                                // typevars bounded to the class, things like
-                                // `class A(Generic[T, V])`
-                                ast::ExprKind::Subscript {value, slice, ..} => {
                                     if let ast::ExprKind::Name {id, ..} = &value.node {
-                                        if id == "Generic" {
+                                        id == "Generic"
-                                            // TODO: get typevars
+                                    } else { false }
+                                } => {
+                                    match &slice.node {
+                                        // `class Foo(Generic[T, V, P, ImportedModule.T]):`
+                                        ast::ExprKind::Tuple {elts, ..} => {
+                                            for e in elts {
+                                                // TODO: I'd better parse the node to get the Type of the type vars(can have things like: A.B.C.typevar?)
+                                                match &e.node {
+                                                    ast::ExprKind::Name {id, ..} => {
+                                                        // the def_list
+                                                        // type_vars.push(resolver.get_symbol_type(id).ok_or_else(|| "unknown type variable".to_string())?); FIXME:
+
+                                                        // the TypeEnum of the class
+                                                        // FIXME: the `params` destructed above is not mutable, even if this is mutable, what should the key be?
+                                                        unimplemented!()
+                                                    },
+
+                                                    _ => unimplemented!()
+                                                }
+                                            }
+                                        },
+
+                                        // `class Foo(Generic[T]):`
+                                        ast::ExprKind::Name {id, ..} => {
+                                            // the def_list
+                                            // type_vars.push(resolver.get_symbol_type(id).ok_or_else(|| "unknown type variable".to_string())?); FIXME:
+
+                                            // the TypeEnum of the class
+                                            // FIXME: the `params` destructed above is not mutable, even if this is mutable, what should the key be?
                                             unimplemented!()
-                                        } else {
+                                        },
-                                            return Err("unknown type var".into())
+
-                                        }
+                                        // `class Foo(Generic[ImportedModule.T])`
-                                    }
+                                        ast::ExprKind::Attribute {value, attr, ..} => {
+                                            // TODO:
+                                            unimplemented!()
+                                        },
+
+                                        _ => return Err("not supported".into()) // NOTE: it is really all the supported cases?
+                                    };
+                                },
+
+                                // base class, name directly available inside the
+                                // module, can use this module's symbol resolver
+                                ast::ExprKind::Name {id, ..} => {
+                                    // let def_id = resolver.get_identifier_def(id); FIXME:
+                                    // the definition list
+                                    // ancestors.push(def_id);
+                                },
+
+                                // base class, things can be like `class A(BaseModule.Base)`, here we have to get the
+                                // symbol resolver of the module `BaseModule`?
+                                ast::ExprKind::Attribute {value, attr, ..} => {
+                                    if let ast::ExprKind::Name {id, ..} = &value.node {
+                                        // if let Some(base_module_resolver) = resolver.get_module_resolver(id) {
+                                        //     let def_id = base_module_resolver.get_identifier_def(attr);
+                                        //     // the definition list
+                                        //     ancestors.push(def_id);
+                                        // } else { return Err("unkown imported module".into()) } FIXME:
+                                    } else { return Err("unkown imported module".into()) }
+                                },
+
+                                // `class Foo(ImportedModule.A[int, bool])`, A is a class with associated type variables
+                                ast::ExprKind::Subscript {value, slice, ..} => {
+                                    unimplemented!()
                                 },
                                 _ => return Err("not supported".into())
                             }
                         }
 
-                        // class method and field are analyzed by looking into the class body ast node
+                        // class method and field are analyzed by
+                        // looking into the class body ast node
                         for stmt in body {
-                            unimplemented!()
+                            if let ast::StmtKind::FunctionDef {
+                                    name,
+                                    args,
+                                    body,
+                                    returns,
+                                    ..
+                            } = &stmt.node {
+
+                            } else {  }
+                            // do nothing. we do not care about things like this?
+                            // class A:
+                            //     a = 3
+                            //     b = [2, 3]
+
+
                         }
                     },
 
+                    // top level function definition
                     ast::StmtKind::FunctionDef {
                         name,
                         args,
@@ -294,3 +439,38 @@ impl<'a> TopLevelComposer<'a> {
         Ok(())
     }
 }
+
+pub fn parse_type_var<T>(
+    input: &ast::Expr<T>,
+    resolver: &dyn SymbolResolver,
+) -> Result<Type, String> {
+    match &input.node {
+        ast::ExprKind::Name { id, .. } => resolver
+            .get_symbol_type(id)
+            .ok_or_else(|| "unknown type variable identifer".to_string()),
+
+        ast::ExprKind::Attribute { value, attr, .. } => {
+            if let ast::ExprKind::Name { id, .. } = &value.node {
+                let next_resolver = resolver
+                    .get_module_resolver(id)
+                    .ok_or_else(|| "unknown imported module".to_string())?;
+                next_resolver
+                    .get_symbol_type(attr)
+                    .ok_or_else(|| "unknown type variable identifer".to_string())
+            } else {
+                unimplemented!()
+                // recursively resolve attr thing, FIXME: new problem: how do we handle this?
+                // # A.py
+                // class A:
+                //     T = TypeVar('T', int, bool)
+                //     pass
+                // # B.py
+                // import A
+                // class B(Generic[A.A.T]):
+                //     pass
+            }
+        }
+
+        _ => Err("not supported".into()),
+    }
+}

nac3core/src/typecheck/magic_methods.rs

@@ -1,8 +1,11 @@
+use crate::typecheck::{
+    type_inferencer::*,
+    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier},
+};
+use rustpython_parser::ast;
+use rustpython_parser::ast::{Cmpop, Operator, Unaryop};
 use std::borrow::Borrow;
 use std::collections::HashMap;
-use rustpython_parser::ast::{Cmpop, Operator, Unaryop};
-use crate::typecheck::{type_inferencer::*, typedef::{FunSignature, FuncArg, TypeEnum, Unifier, Type}};
-use rustpython_parser::ast;
 
 pub fn binop_name(op: &Operator) -> &'static str {
     match op {
@@ -42,206 +45,218 @@ pub fn binop_assign_name(op: &Operator) -> &'static str {
 
 pub fn unaryop_name(op: &Unaryop) -> &'static str {
     match op {
-        Unaryop::UAdd   => "__pos__",
+        Unaryop::UAdd => "__pos__",
-        Unaryop::USub   => "__neg__",
+        Unaryop::USub => "__neg__",
-        Unaryop::Not    => "__not__",
+        Unaryop::Not => "__not__",
         Unaryop::Invert => "__inv__",
     }
 }
 
 pub fn comparison_name(op: &Cmpop) -> Option<&'static str> {
     match op {
-        Cmpop::Lt    => Some("__lt__"),
+        Cmpop::Lt => Some("__lt__"),
-        Cmpop::LtE   => Some("__le__"),
+        Cmpop::LtE => Some("__le__"),
-        Cmpop::Gt    => Some("__gt__"),
+        Cmpop::Gt => Some("__gt__"),
-        Cmpop::GtE   => Some("__ge__"),
+        Cmpop::GtE => Some("__ge__"),
-        Cmpop::Eq    => Some("__eq__"),
+        Cmpop::Eq => Some("__eq__"),
         Cmpop::NotEq => Some("__ne__"),
         _ => None,
     }
 }
 
-pub fn impl_binop(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, other_ty: &[Type], ret_ty: Type, ops: &[ast::Operator]) {
+pub fn impl_binop(
-    if let TypeEnum::TObj {fields, ..} = unifier.get_ty(ty).borrow() {
+    unifier: &mut Unifier,
+    _store: &PrimitiveStore,
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Type,
+    ops: &[ast::Operator],
+) {
+    if let TypeEnum::TObj { fields, .. } = unifier.get_ty(ty).borrow() {
         for op in ops {
-            fields.borrow_mut().insert(
+            fields.borrow_mut().insert(binop_name(op).into(), {
-                binop_name(op).into(),
+                let other = if other_ty.len() == 1 {
-                {
+                    other_ty[0]
-                    let other = if other_ty.len() == 1 {
+                } else {
-                        other_ty[0]
+                    unifier.get_fresh_var_with_range(other_ty).0
-                    } else {
+                };
-                        unifier.get_fresh_var_with_range(other_ty).0
+                unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                    };
+                    ret: ret_ty,
-                    unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                    vars: HashMap::new(),
-                        ret: ret_ty,
+                    args: vec![FuncArg { ty: other, default_value: None, name: "other".into() }],
-                        vars: HashMap::new(),
+                }))
-                        args: vec![FuncArg {
+            });
-                            ty: other,
-                            default_value: None,
-                            name: "other".into()
-                        }]
-                    }))
-                }
-            );
 
-            fields.borrow_mut().insert(
+            fields.borrow_mut().insert(binop_assign_name(op).into(), {
-                binop_assign_name(op).into(),
+                let other = if other_ty.len() == 1 {
-                {
+                    other_ty[0]
-                    let other = if other_ty.len() == 1 {
+                } else {
-                        other_ty[0]
+                    unifier.get_fresh_var_with_range(other_ty).0
-                    } else {
+                };
-                        unifier.get_fresh_var_with_range(other_ty).0
+                unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                    };
+                    ret: ret_ty,
-                    unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                    vars: HashMap::new(),
-                        ret: ret_ty,
+                    args: vec![FuncArg { ty: other, default_value: None, name: "other".into() }],
-                        vars: HashMap::new(),
+                }))
-                        args: vec![FuncArg {
+            });
-                            ty: other,
-                            default_value: None,
-                            name: "other".into()
-                        }]
-                    }))
-                }
-            );
         }
-    } else { unreachable!("") }
+    } else {
+        unreachable!("")
+    }
 }
 
-pub fn impl_unaryop(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, ret_ty: Type, ops: &[ast::Unaryop]) {
+pub fn impl_unaryop(
-    if let TypeEnum::TObj {fields, ..} = unifier.get_ty(ty).borrow() {
+    unifier: &mut Unifier,
+    _store: &PrimitiveStore,
+    ty: Type,
+    ret_ty: Type,
+    ops: &[ast::Unaryop],
+) {
+    if let TypeEnum::TObj { fields, .. } = unifier.get_ty(ty).borrow() {
         for op in ops {
             fields.borrow_mut().insert(
                 unaryop_name(op).into(),
                 unifier.add_ty(TypeEnum::TFunc(FunSignature {
                     ret: ret_ty,
                     vars: HashMap::new(),
-                    args: vec![]
+                    args: vec![],
-                }))
+                })),
             );
         }
-    } else { unreachable!() }
+    } else {
+        unreachable!()
+    }
 }
 
-pub fn impl_cmpop(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: Type, ops: &[ast::Cmpop]) {
+pub fn impl_cmpop(
-    if let TypeEnum::TObj {fields, ..} = unifier.get_ty(ty).borrow() {
+    unifier: &mut Unifier,
+    store: &PrimitiveStore,
+    ty: Type,
+    other_ty: Type,
+    ops: &[ast::Cmpop],
+) {
+    if let TypeEnum::TObj { fields, .. } = unifier.get_ty(ty).borrow() {
         for op in ops {
             fields.borrow_mut().insert(
                 comparison_name(op).unwrap().into(),
                 unifier.add_ty(TypeEnum::TFunc(FunSignature {
                     ret: store.bool,
                     vars: HashMap::new(),
-                    args: vec![FuncArg {
+                    args: vec![FuncArg { ty: other_ty, default_value: None, name: "other".into() }],
-                        ty: other_ty,
+                })),
-                        default_value: None,
-                        name: "other".into()
-                    }]
-                }))
             );
         }
-    } else { unreachable!() }
+    } else {
+        unreachable!()
+    }
 }
 
 /// Add, Sub, Mult, Pow
-pub fn impl_basic_arithmetic(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: &[Type], ret_ty: Type) {
+pub fn impl_basic_arithmetic(
-    impl_binop(unifier, store, ty, other_ty, ret_ty, &[
+    unifier: &mut Unifier,
-        ast::Operator::Add,
+    store: &PrimitiveStore,
-        ast::Operator::Sub,
+    ty: Type,
-        ast::Operator::Mult,
+    other_ty: &[Type],
-    ])
+    ret_ty: Type,
+) {
+    impl_binop(
+        unifier,
+        store,
+        ty,
+        other_ty,
+        ret_ty,
+        &[ast::Operator::Add, ast::Operator::Sub, ast::Operator::Mult],
+    )
 }
 
-pub fn impl_pow(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: &[Type], ret_ty: Type) {
+pub fn impl_pow(
-    impl_binop(unifier, store, ty, other_ty, ret_ty, &[
+    unifier: &mut Unifier,
-        ast::Operator::Pow,
+    store: &PrimitiveStore,
-    ])
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Type,
+) {
+    impl_binop(unifier, store, ty, other_ty, ret_ty, &[ast::Operator::Pow])
 }
 
 /// BitOr, BitXor, BitAnd
 pub fn impl_bitwise_arithmetic(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_binop(unifier, store, ty, &[ty], ty, &[
+    impl_binop(
-        ast::Operator::BitAnd,
+        unifier,
-        ast::Operator::BitOr,
+        store,
-        ast::Operator::BitXor,
+        ty,
-    ])
+        &[ty],
+        ty,
+        &[ast::Operator::BitAnd, ast::Operator::BitOr, ast::Operator::BitXor],
+    )
 }
 
 /// LShift, RShift
 pub fn impl_bitwise_shift(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_binop(unifier, store, ty, &[ty], ty, &[
+    impl_binop(unifier, store, ty, &[ty], ty, &[ast::Operator::LShift, ast::Operator::RShift])
-        ast::Operator::LShift,
-        ast::Operator::RShift,
-    ])
 }
 
 /// Div
 pub fn impl_div(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: &[Type]) {
-    impl_binop(unifier, store, ty, other_ty, store.float, &[
+    impl_binop(unifier, store, ty, other_ty, store.float, &[ast::Operator::Div])
-        ast::Operator::Div,
-    ])
 }
 
 /// FloorDiv
-pub fn impl_floordiv(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: &[Type], ret_ty: Type) {
+pub fn impl_floordiv(
-    impl_binop(unifier, store, ty, other_ty, ret_ty, &[
+    unifier: &mut Unifier,
-        ast::Operator::FloorDiv,
+    store: &PrimitiveStore,
-    ])
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Type,
+) {
+    impl_binop(unifier, store, ty, other_ty, ret_ty, &[ast::Operator::FloorDiv])
 }
 
 /// Mod
-pub fn impl_mod(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: &[Type], ret_ty: Type) {
+pub fn impl_mod(
-    impl_binop(unifier, store, ty, other_ty, ret_ty, &[
+    unifier: &mut Unifier,
-        ast::Operator::Mod,
+    store: &PrimitiveStore,
-    ])
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Type,
+) {
+    impl_binop(unifier, store, ty, other_ty, ret_ty, &[ast::Operator::Mod])
 }
 
 /// UAdd, USub
 pub fn impl_sign(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_unaryop(unifier, store, ty, ty, &[
+    impl_unaryop(unifier, store, ty, ty, &[ast::Unaryop::UAdd, ast::Unaryop::USub])
-        ast::Unaryop::UAdd,
-        ast::Unaryop::USub,
-    ])
 }
 
 /// Invert
 pub fn impl_invert(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_unaryop(unifier, store, ty, ty, &[
+    impl_unaryop(unifier, store, ty, ty, &[ast::Unaryop::Invert])
-        ast::Unaryop::Invert,
-    ])
 }
 
 /// Not
 pub fn impl_not(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_unaryop(unifier, store, ty, store.bool, &[
+    impl_unaryop(unifier, store, ty, store.bool, &[ast::Unaryop::Not])
-        ast::Unaryop::Not,
-    ])
 }
 
 /// Lt, LtE, Gt, GtE
 pub fn impl_comparison(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: Type) {
-    impl_cmpop(unifier, store, ty, other_ty, &[
+    impl_cmpop(
-        ast::Cmpop::Lt,
+        unifier,
-        ast::Cmpop::Gt,
+        store,
-        ast::Cmpop::LtE,
+        ty,
-        ast::Cmpop::GtE,
+        other_ty,
-    ])
+        &[ast::Cmpop::Lt, ast::Cmpop::Gt, ast::Cmpop::LtE, ast::Cmpop::GtE],
+    )
 }
 
 /// Eq, NotEq
 pub fn impl_eq(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_cmpop(unifier, store, ty, ty, &[
+    impl_cmpop(unifier, store, ty, ty, &[ast::Cmpop::Eq, ast::Cmpop::NotEq])
-        ast::Cmpop::Eq,
-        ast::Cmpop::NotEq,
-    ])
 }
 
 pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifier) {
-    let PrimitiveStore {
+    let PrimitiveStore { int32: int32_t, int64: int64_t, float: float_t, bool: bool_t, .. } =
-        int32: int32_t,
+        *store;
-        int64: int64_t,
-        float: float_t,
-        bool: bool_t,
-        ..
-    } = *store;
     /* int32 ======== */
     impl_basic_arithmetic(unifier, store, int32_t, &[int32_t], int32_t);
     impl_pow(unifier, store, int32_t, &[int32_t], int32_t);

nac3core/src/typecheck/type_inferencer/mod.rs

@@ -38,7 +38,7 @@ pub struct PrimitiveStore {
 }
 
 pub struct FunctionData {
-    pub resolver: Box<dyn SymbolResolver>,
+    pub resolver: Arc<dyn SymbolResolver>,
     pub return_type: Option<Type>,
     pub bound_variables: Vec<Type>,
 }

nac3core/src/typecheck/type_inferencer/test.rs

@@ -100,10 +100,10 @@ impl TestEnvironment {
         let mut identifier_mapping = HashMap::new();
         identifier_mapping.insert("None".into(), none);
 
-        let resolver = Box::new(Resolver {
+        let resolver = Arc::new(Resolver {
             identifier_mapping: identifier_mapping.clone(),
             class_names: Default::default(),
-        }) as Box<dyn SymbolResolver>;
+        }) as Arc<dyn SymbolResolver>;
 
         TestEnvironment {
             unifier,
@@ -226,8 +226,8 @@ impl TestEnvironment {
         .collect();
 
         let resolver =
-            Box::new(Resolver { identifier_mapping: identifier_mapping.clone(), class_names })
+            Arc::new(Resolver { identifier_mapping: identifier_mapping.clone(), class_names })
-                as Box<dyn SymbolResolver>;
+                as Arc<dyn SymbolResolver>;
 
         TestEnvironment {
             unifier,