formatted

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)]

nac3core/src/top_level.rs

@@ -27,7 +27,7 @@ pub enum TopLevelDef {
         // 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>>>
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
     },
     Function {
         // prefix for symbol, should be unique globally, and not ending with numbers
@@ -47,7 +47,7 @@ pub enum TopLevelDef {
         /// 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>>>
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
     },
     Initializer {
         class_id: DefinitionId,
@@ -83,7 +83,6 @@ pub struct CodeGenContext<'ctx> {
     pub loop_bb: Option<(BasicBlock<'ctx>, BasicBlock<'ctx>)>,
 }
 
-
 pub fn name_mangling(mut class_name: String, method_name: &str) -> String {
     // need to further extend to more name mangling like instantiations of typevar
     class_name.push_str(method_name);
@@ -171,24 +170,31 @@ impl TopLevelComposer {
     }
 
     /// 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 {
+    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: vec![DefinitionId(index)],
-            resolver
+            resolver,
         }
     }
 
-    pub fn make_top_level_function_def(name: String, ty: Type, resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>) -> 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
+            resolver,
         }
     }
 
@@ -207,7 +213,7 @@ impl TopLevelComposer {
     pub fn register_top_level(
         &mut self,
         ast: ast::Stmt<()>,
-        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>
+        resolver: Option<Arc<Mutex<dyn SymbolResolver + Send>>>,
     ) -> Result<Vec<(String, DefinitionId, Type)>, String> {
         match &ast.node {
             ast::StmtKind::ClassDef { name, body, .. } => {
@@ -221,7 +227,8 @@ impl TopLevelComposer {
                     params: Default::default(),
                 });
 
-                let mut ret_vector: Vec<(String, DefinitionId, Type)> = vec![(class_name.clone(), DefinitionId(class_def_id), ty)];
+                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?
@@ -229,52 +236,49 @@ impl TopLevelComposer {
                 // 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 {
+                    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 {
+                        let ty = self.unifier.add_ty(TypeEnum::TFunc(
+                            crate::typecheck::typedef::FunSignature {
                                 args: Default::default(),
                                 ret: self.primitives.none,
-                            vars: Default::default()
+                                vars: Default::default(),
-                        }));
+                            },
+                        ));
                         // add to the definition list
-                        self.definition_list.push(
+                        self.definition_list.push(TopLevelDefInfo {
-                            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
+                            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(
+                            self.definition_list.push(TopLevelDefInfo {
-                                TopLevelDefInfo {
                                 def: TopLevelDef::Initializer {
-                                        class_id: DefinitionId(class_def_id)
+                                    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
+                    } else {
+                    } // else do nothing
                 }
                 // add to the definition list
-                self.definition_list.push(
+                self.definition_list.push(TopLevelDefInfo {
-                    TopLevelDefInfo {
                     def: Self::make_top_level_class_def(class_def_id, resolver),
                     ast: Some(ast),
                     ty,
-                    }
+                });
-                );
 
                 Ok(ret_vector)
-            },
+            }
 
             ast::StmtKind::FunctionDef { name, .. } => {
                 let fun_name = name.to_string();
@@ -284,14 +288,14 @@ impl TopLevelComposer {
                     self.unifier.add_ty(TypeEnum::TFunc(crate::typecheck::typedef::FunSignature {
                         args: Default::default(),
                         ret: self.primitives.none,
-                        vars: Default::default()
+                        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,
-                            resolver
+                        resolver,
                     ),
                     ast: Some(ast),
                     ty,
@@ -462,18 +466,23 @@ impl TopLevelComposer {
     }
 }
 
-
+pub fn parse_type_var<T>(
-
+    input: &ast::Expr<T>,
-pub fn parse_type_var<T>(input: &ast::Expr<T>, resolver: &dyn SymbolResolver) -> Result<Type, String> {
+    resolver: &dyn SymbolResolver,
+) -> Result<Type, String> {
     match &input.node {
-        ast::ExprKind::Name {id, ..} => {
+        ast::ExprKind::Name { id, .. } => resolver
-            resolver.get_symbol_type(id).ok_or_else(|| "unknown type variable identifer".to_string())
+            .get_symbol_type(id)
-        },
+            .ok_or_else(|| "unknown type variable identifer".to_string()),
 
-        ast::ExprKind::Attribute {value, attr, ..} => {
+        ast::ExprKind::Attribute { value, attr, .. } => {
-            if let ast::ExprKind::Name {id, ..} = &value.node {
+            if let ast::ExprKind::Name { id, .. } = &value.node {
-                let next_resolver = resolver.get_module_resolver(id).ok_or_else(|| "unknown imported module".to_string())?;
+                let next_resolver = resolver
-                next_resolver.get_symbol_type(attr).ok_or_else(|| "unknown type variable identifer".to_string())
+                    .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?
@@ -486,8 +495,8 @@ pub fn parse_type_var<T>(input: &ast::Expr<T>, resolver: &dyn SymbolResolver) ->
                 // class B(Generic[A.A.T]):
                 //     pass
             }
-        },
+        }
 
-        _ => Err("not supported".into())
+        _ => 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 {
@@ -61,12 +64,17 @@ pub fn comparison_name(op: &Cmpop) -> Option<&'static str> {
     }
 }
 
-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]
                 } else {
@@ -75,18 +83,11 @@ pub fn impl_binop(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, othe
                 unifier.add_ty(TypeEnum::TFunc(FunSignature {
                     ret: ret_ty,
                     vars: HashMap::new(),
-                        args: vec![FuncArg {
+                    args: vec![FuncArg { ty: other, default_value: None, name: "other".into() }],
-                            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]
                 } else {
@@ -95,153 +96,167 @@ pub fn impl_binop(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, othe
                 unifier.add_ty(TypeEnum::TFunc(FunSignature {
                     ret: ret_ty,
                     vars: HashMap::new(),
-                        args: vec![FuncArg {
+                    args: vec![FuncArg { ty: other, default_value: None, name: "other".into() }],
-                            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);