nac3core: clean up and format

nac3core/src/codegen/expr.rs

@@ -609,8 +609,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
             ExprKind::Call { func, args, keywords } => {
                 if let ExprKind::Name { id, .. } = &func.as_ref().node {
                     // TODO: handle primitive casts and function pointers
-                    let fun =
+                    let fun = self.resolver.get_identifier_def(&id).expect("Unknown identifier");
-                        self.resolver.get_identifier_def(&id).expect("Unknown identifier");
                     let mut params =
                         args.iter().map(|arg| (None, self.gen_expr(arg).unwrap())).collect_vec();
                     let kw_iter = keywords.iter().map(|kw| {

nac3core/src/codegen/mod.rs

@@ -305,9 +305,8 @@ pub fn gen_func<'ctx>(
     };
 
     let symbol = &task.symbol_name;
-    let fn_val = module
+    let fn_val =
-        .get_function(symbol)
+        module.get_function(symbol).unwrap_or_else(|| module.add_function(symbol, fn_type, None));
-        .unwrap_or_else(|| module.add_function(symbol, fn_type, None));
 
     let init_bb = context.append_basic_block(fn_val, "init");
     builder.position_at_end(init_bb);

nac3core/src/codegen/test.rs

@@ -9,7 +9,7 @@ use crate::{
     },
 };
 use indoc::indoc;
-use parking_lot::{Mutex, RwLock};
+use parking_lot::RwLock;
 use rustpython_parser::{ast::fold::Fold, parser::parse_program};
 use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};

nac3core/src/toplevel/mod.rs

@@ -1,4 +1,11 @@
-use std::{borrow::BorrowMut, collections::{HashMap, HashSet}, fmt::Debug, iter::FromIterator, ops::{Deref, DerefMut}, sync::Arc};
+use std::{
+    borrow::BorrowMut,
+    collections::{HashMap, HashSet},
+    fmt::Debug,
+    iter::FromIterator,
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
 
 use super::typecheck::type_inferencer::PrimitiveStore;
 use super::typecheck::typedef::{FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier};
@@ -7,7 +14,7 @@ use crate::{
     typecheck::{type_inferencer::CodeLocation, typedef::CallId},
 };
 use itertools::{izip, Itertools};
-use parking_lot::{Mutex, RwLock};
+use parking_lot::RwLock;
 use rustpython_parser::ast::{self, Stmt};
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Debug)]
@@ -588,7 +595,7 @@ impl TopLevelComposer {
             println!(
                 "{:?}_{} -> {:?}\n",
                 ty,
-                unifier.stringify(ty, 
+                unifier.stringify(ty,
                     &mut |id| format!("class{}", id),
                     &mut |id| format!("tvar{}", id)
                 ),
@@ -599,17 +606,17 @@ impl TopLevelComposer {
             unifier.unify(ty, target_ty)?;
             ddddd.push((ty, target_ty));
         }
-        
+
         for (ty, tar_ty) in ddddd {
             println!(
                 "{:?}_{} -> {:?}_{}",
                 ty,
-                unifier.stringify(ty, 
+                unifier.stringify(ty,
                     &mut |id| format!("class{}", id),
                     &mut |id| format!("tvar{}", id)
                 ),
                 tar_ty,
-                unifier.stringify(tar_ty, 
+                unifier.stringify(tar_ty,
                     &mut |id| format!("class{}", id),
                     &mut |id| format!("tvar{}", id)
                 ),

nac3core/src/toplevel/test.rs

@@ -45,7 +45,6 @@ impl SymbolResolver for Resolver {
     fn get_identifier_def(&self, id: &str) -> Option<DefinitionId> {
         self.0.id_to_def.lock().get(id).cloned()
     }
-
 }
 
 #[test_case(
@@ -126,7 +125,9 @@ fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&s
         id_to_type: Default::default(),
         class_names: Default::default(),
     });
-    let resolver = Arc::new(Box::new(Resolver(internal_resolver.clone())) as Box<dyn SymbolResolver + Send + Sync>);
+    let resolver = Arc::new(
+        Box::new(Resolver(internal_resolver.clone())) as Box<dyn SymbolResolver + Send + Sync>
+    );
 
     for s in source {
         let ast = parse_program(s).unwrap();
@@ -279,12 +280,14 @@ fn test_simple_class_analyze(source: Vec<&str>, res: Vec<&str>) {
 
     let internal_resolver = Arc::new(ResolverInternal {
         id_to_def: Default::default(),
-        id_to_type: Mutex::new(vec![("T".to_string(), tvar_t.0), ("V".to_string(), tvar_v.0)]
+        id_to_type: Mutex::new(
-        .into_iter()
+            vec![("T".to_string(), tvar_t.0), ("V".to_string(), tvar_v.0)].into_iter().collect(),
-        .collect()),
+        ),
         class_names: Default::default(),
     });
-    let resolver = Arc::new(Box::new(Resolver(internal_resolver.clone())) as Box<dyn SymbolResolver + Send + Sync>);
+    let resolver = Arc::new(
+        Box::new(Resolver(internal_resolver.clone())) as Box<dyn SymbolResolver + Send + Sync>
+    );
 
     for s in source {
         let ast = parse_program(s).unwrap();

nac3core/src/toplevel/type_annotation.rs

@@ -35,12 +35,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
             "bool" => Ok(TypeAnnotation::PrimitiveKind(primitives.bool)),
             "None" => Ok(TypeAnnotation::PrimitiveKind(primitives.none)),
             x => {
-                if let Some(obj_id) = {
+                if let Some(obj_id) = resolver.get_identifier_def(x) {
-                    // write this way because the lock in the if/let construct lives
-                    // for the whole if let construct
-                    let id = resolver.get_identifier_def(x);
-                    id
-                } {
                     let def = top_level_defs[obj_id.0].read();
                     if let TopLevelDef::Class { type_vars, .. } = &*def {
                         // also check param number here
@@ -54,10 +49,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                     } else {
                         Err("function cannot be used as a type".into())
                     }
-                } else if let Some(ty) = {
+                } else if let Some(ty) = resolver.get_symbol_type(unifier, primitives, id) {
-                    let ty = resolver.get_symbol_type(unifier, primitives, id);
-                    ty
-                } {
                     if let TypeEnum::TVar { .. } = unifier.get_ty(ty).as_ref() {
                         Ok(TypeAnnotation::TypeVarKind(ty))
                     } else {
@@ -240,15 +232,16 @@ pub fn get_type_from_type_annotation_kinds(
                     }));
 
                     println!("tobj_fields: {:?}", tobj_fields);
-                    println!("{:?}: {}\n", 
+                    println!(
+                        "{:?}: {}\n",
                         tobj_fields.get("__init__").unwrap(),
                         unifier.stringify(
-                            *tobj_fields.get("__init__").unwrap(), 
+                            *tobj_fields.get("__init__").unwrap(),
                             &mut |id| format!("class{}", id),
                             &mut |id| format!("tvar{}", id)
                         )
                     );
-                    
+
                     Ok(unifier.add_ty(TypeEnum::TObj {
                         obj_id: *id,
                         //fields: RefCell::new(tobj_fields),

nac3core/src/typecheck/type_inferencer/mod.rs

@@ -7,7 +7,6 @@ use super::typedef::{Call, FunSignature, FuncArg, Type, TypeEnum, Unifier};
 use super::{magic_methods::*, typedef::CallId};
 use crate::{symbol_resolver::SymbolResolver, toplevel::TopLevelContext};
 use itertools::izip;
-use parking_lot::Mutex;
 use rustpython_parser::ast::{
     self,
     fold::{self, Fold},
@@ -164,8 +163,7 @@ impl<'a> fold::Fold<()> for Inferencer<'a> {
             ast::ExprKind::Constant { value, .. } => Some(self.infer_constant(value)?),
             ast::ExprKind::Name { id, .. } => {
                 if !self.defined_identifiers.contains(id) {
-                    if self.function_data.resolver.get_identifier_def(id.as_str()).is_some()
+                    if self.function_data.resolver.get_identifier_def(id.as_str()).is_some() {
-                    {
                         self.defined_identifiers.insert(id.clone());
                     } else {
                         return Err(format!(
@@ -485,11 +483,15 @@ impl<'a> Inferencer<'a> {
         } else {
             let variable_mapping = &mut self.variable_mapping;
             let unifier = &mut self.unifier;
-            Ok(self.function_data.resolver.get_symbol_type(unifier, self.primitives, id).unwrap_or_else(|| {
+            Ok(self
-                let ty = unifier.get_fresh_var().0;
+                .function_data
-                variable_mapping.insert(id.to_string(), ty);
+                .resolver
-                ty
+                .get_symbol_type(unifier, self.primitives, id)
-            }))
+                .unwrap_or_else(|| {
+                    let ty = unifier.get_fresh_var().0;
+                    variable_mapping.insert(id.to_string(), ty);
+                    ty
+                }))
         }
     }