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

@@ -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,20 +83,19 @@ 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);
     class_name
 }
 
-pub struct TopLevelDefInfo { 
+pub struct TopLevelDefInfo {
     // like adding some info on top of the TopLevelDef for later parsing the class bases, method,
     // and function sigatures
-    def: TopLevelDef,                        // the definition entry
+    def: TopLevelDef, // the definition entry
-    ty: Type,                                // the entry in the top_level unifier
+    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
+    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 
+                                //  resolver: Option<&'a dyn SymbolResolver> // the resolver
 }
 
 pub struct TopLevelComposer {
@@ -171,28 +170,35 @@ 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,
         }
     }
 
-    // like to make and return a "primitive" symbol resolver? so that the symbol resolver 
+    // like to make and return a "primitive" symbol resolver? so that the symbol resolver
     // can later figure out primitive type definitions when passed a primitive type name
     pub fn get_primitives_definition(&self) -> Vec<(String, DefinitionId, Type)> {
         vec![
@@ -207,13 +213,13 @@ 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, .. } => {
                 let class_name = name.to_string();
                 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(class_def_id),
@@ -221,60 +227,58 @@ 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, 
+                // 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? 
+                // 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 
+                // 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 {
+                    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(
-                            args: Default::default(),
+                            crate::typecheck::typedef::FunSignature {
-                            ret: self.primitives.none,
+                                args: Default::default(),
-                            vars: Default::default()
+                                ret: self.primitives.none,
-                        }));
+                                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:
-                                def: Self::make_top_level_function_def(fun_name.clone(), ty, None), // FIXME:
+                            ty,
-                                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 {
-                                    def: TopLevelDef::Initializer {
+                                    class_id: DefinitionId(class_def_id),
-                                        class_id: DefinitionId(class_def_id)
+                                },
-                                    },
+                                ty: self.primitives.none, // arbitary picked one
-                                    ty: self.primitives.none, // arbitary picked one
+                                ast: None, // it is inside the class def body statments
-                                    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),
-                        def: Self::make_top_level_class_def(class_def_id, resolver),
+                    ast: Some(ast),
-                        ast: Some(ast),
+                    ty,
-                        ty,
+                });
-                    }
+
-                );
-                
                 Ok(ret_vector)
-            },
+            }
 
             ast::StmtKind::FunctionDef { name, .. } => {
                 let fun_name = name.to_string();
@@ -283,18 +287,18 @@ impl TopLevelComposer {
                 let ty =
                     self.unifier.add_ty(TypeEnum::TFunc(crate::typecheck::typedef::FunSignature {
                         args: Default::default(),
-                        ret: self.primitives.none, 
+                        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(
+                    def: Self::make_top_level_function_def(
-                            name.into(), 
+                        name.into(),
-                            self.primitives.none,
+                        self.primitives.none,
-                            resolver
+                        resolver,
-                        ),
+                    ),
-                        ast: Some(ast),
+                    ast: Some(ast),
-                        ty,
+                    ty,
                 });
 
                 Ok(vec![(fun_name, DefinitionId(def_id), ty)])
@@ -462,20 +466,25 @@ 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!() 
+                unimplemented!()
                 // recursively resolve attr thing, FIXME: new problem: how do we handle this?
                 // # A.py
                 // class A:
@@ -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 {
@@ -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);