From 32773c14e0d0b03790d3b5d068c7d4517b3ad282 Mon Sep 17 00:00:00 2001 From: ychenfo Date: Tue, 24 Aug 2021 17:14:34 +0800 Subject: [PATCH] move top level related things to a separate module --- nac3core/src/codegen/expr.rs | 2 +- nac3core/src/codegen/mod.rs | 2 +- nac3core/src/codegen/test.rs | 2 +- nac3core/src/lib.rs | 2 +- nac3core/src/symbol_resolver.rs | 2 +- .../src/{top_level.rs => toplevel/mod.rs} | 334 +----------------- nac3core/src/toplevel/type_annotation.rs | 310 ++++++++++++++++ nac3core/src/typecheck/type_inferencer/mod.rs | 2 +- .../src/typecheck/type_inferencer/test.rs | 3 +- nac3core/src/typecheck/typedef/mod.rs | 2 +- nac3standalone/src/basic_symbol_resolver.rs | 2 +- nac3standalone/src/main.rs | 2 +- 12 files changed, 324 insertions(+), 341 deletions(-) rename nac3core/src/{top_level.rs => toplevel/mod.rs} (73%) create mode 100644 nac3core/src/toplevel/type_annotation.rs diff --git a/nac3core/src/codegen/expr.rs b/nac3core/src/codegen/expr.rs index 4c3ffe4a..a267e86f 100644 --- a/nac3core/src/codegen/expr.rs +++ b/nac3core/src/codegen/expr.rs @@ -3,7 +3,7 @@ use std::{collections::HashMap, convert::TryInto, iter::once}; use super::{get_llvm_type, CodeGenContext}; use crate::{ symbol_resolver::SymbolValue, - top_level::{DefinitionId, TopLevelDef}, + toplevel::{DefinitionId, TopLevelDef}, typecheck::typedef::{FunSignature, Type, TypeEnum}, }; use inkwell::{ diff --git a/nac3core/src/codegen/mod.rs b/nac3core/src/codegen/mod.rs index b3c59e7f..09082b1d 100644 --- a/nac3core/src/codegen/mod.rs +++ b/nac3core/src/codegen/mod.rs @@ -1,6 +1,6 @@ use crate::{ symbol_resolver::SymbolResolver, - top_level::{TopLevelContext, TopLevelDef}, + toplevel::{TopLevelContext, TopLevelDef}, typecheck::{ type_inferencer::{CodeLocation, PrimitiveStore}, typedef::{CallId, FunSignature, Type, TypeEnum, Unifier}, diff --git a/nac3core/src/codegen/test.rs b/nac3core/src/codegen/test.rs index 2b11d195..29798a67 100644 --- a/nac3core/src/codegen/test.rs +++ b/nac3core/src/codegen/test.rs @@ -3,7 +3,7 @@ use crate::{ codegen::WithCall, location::Location, symbol_resolver::{SymbolResolver, SymbolValue}, - top_level::{DefinitionId, TopLevelContext}, + toplevel::{DefinitionId, TopLevelContext}, typecheck::{ magic_methods::set_primitives_magic_methods, type_inferencer::{CodeLocation, FunctionData, Inferencer, PrimitiveStore}, diff --git a/nac3core/src/lib.rs b/nac3core/src/lib.rs index ad1725b4..10e1d257 100644 --- a/nac3core/src/lib.rs +++ b/nac3core/src/lib.rs @@ -4,5 +4,5 @@ pub mod codegen; pub mod location; pub mod symbol_resolver; -pub mod top_level; +pub mod toplevel; pub mod typecheck; diff --git a/nac3core/src/symbol_resolver.rs b/nac3core/src/symbol_resolver.rs index bb37e60f..3e628bd5 100644 --- a/nac3core/src/symbol_resolver.rs +++ b/nac3core/src/symbol_resolver.rs @@ -1,7 +1,7 @@ use std::collections::HashMap; use std::{cell::RefCell, sync::Arc}; -use crate::top_level::{DefinitionId, TopLevelDef}; +use crate::toplevel::{DefinitionId, TopLevelDef}; use crate::typecheck::{ type_inferencer::PrimitiveStore, typedef::{Type, Unifier}, diff --git a/nac3core/src/top_level.rs b/nac3core/src/toplevel/mod.rs similarity index 73% rename from nac3core/src/top_level.rs rename to nac3core/src/toplevel/mod.rs index 2f576cf0..6656e3d4 100644 --- a/nac3core/src/top_level.rs +++ b/nac3core/src/toplevel/mod.rs @@ -2,7 +2,6 @@ use std::borrow::BorrowMut; use std::ops::{Deref, DerefMut}; use std::{collections::HashMap, collections::HashSet, sync::Arc}; -use self::top_level_type_annotation_info::*; use super::typecheck::type_inferencer::PrimitiveStore; use super::typecheck::typedef::{SharedUnifier, Type, TypeEnum, Unifier}; use crate::symbol_resolver::SymbolResolver; @@ -11,338 +10,13 @@ use itertools::{izip, Itertools}; use parking_lot::{Mutex, RwLock}; use rustpython_parser::ast::{self, Stmt}; + + #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)] pub struct DefinitionId(pub usize); -pub mod top_level_type_annotation_info { - use super::*; - use crate::typecheck::typedef::TypeVarMeta; - - #[derive(Clone)] - pub enum TypeAnnotation { - PrimitiveKind(Type), - ConcretizedCustomClassKind { - id: DefinitionId, - // can not be type var, others are all fine - // TODO: can also be type var? - params: Vec, - }, - // can only be ConcretizedCustomClassKind - VirtualKind(Box), - // the first u32 refers to the var_id of the - // TVar returned by the symbol resolver, - // this is used to handle type vars - // associated with class/functions - // since when associating we create a copy of type vars - TypeVarKind(u32, Type), - SelfTypeKind(DefinitionId), - } - - pub fn parse_ast_to_type_annotation_kinds( - resolver: &dyn SymbolResolver, - top_level_defs: &[Arc>], - unifier: &mut Unifier, - primitives: &PrimitiveStore, - expr: &ast::Expr, - ) -> Result { - let results = vec![ - parse_ast_to_concrete_primitive_kind( - resolver, - top_level_defs, - unifier, - primitives, - expr, - ), - parse_ast_to_concretized_custom_class_kind( - resolver, - top_level_defs, - unifier, - primitives, - expr, - ), - parse_ast_to_type_variable_kind(resolver, top_level_defs, unifier, primitives, expr), - parse_ast_to_virtual_kind(resolver, top_level_defs, unifier, primitives, expr), - ]; - let results = results.iter().filter(|x| x.is_ok()).collect_vec(); - - if results.len() == 1 { - results[0].clone() - } else { - Err("cannot parsed the type annotation without ambiguity".into()) - } - } - - pub fn get_type_from_type_annotation_kinds( - top_level_defs: &[Arc>], - unifier: &mut Unifier, - primitives: &PrimitiveStore, - ann: &TypeAnnotation, - ) -> Result { - match ann { - TypeAnnotation::ConcretizedCustomClassKind { id, params } => { - let class_def = top_level_defs[id.0].read(); - if let TopLevelDef::Class { fields, methods, type_vars, .. } = &*class_def { - if type_vars.len() != params.len() { - Err(format!( - "unexpected number of type parameters: expected {} but got {}", - type_vars.len(), - params.len() - )) - } else { - let param_ty = params - .iter() - .map(|x| { - get_type_from_type_annotation_kinds( - top_level_defs, - unifier, - primitives, - x, - ) - }) - .collect::, _>>()?; - - let subst = type_vars - .iter() - .map(|x| { - if let TypeEnum::TVar { id, .. } = unifier.get_ty(x.1).as_ref() { - // this is for the class generic application, - // we only need the information for the copied type var - // associated with the class - *id - } else { - unreachable!() - } - }) - .zip(param_ty.into_iter()) - .collect::>(); - - let mut tobj_fields = methods - .iter() - .map(|(name, ty, _)| { - let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty); - (name.clone(), subst_ty) - }) - .collect::>(); - tobj_fields.extend(fields.iter().map(|(name, ty)| { - let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty); - (name.clone(), subst_ty) - })); - - Ok(unifier.add_ty(TypeEnum::TObj { - obj_id: *id, - fields: tobj_fields.into(), - params: subst.into(), - })) - } - } else { - unreachable!("should be class def here") - } - } - TypeAnnotation::SelfTypeKind(obj_id) => { - let class_def = top_level_defs[obj_id.0].read(); - if let TopLevelDef::Class { fields, methods, type_vars, .. } = &*class_def { - let subst = type_vars - .iter() - .map(|x| { - if let TypeEnum::TVar { id, .. } = unifier.get_ty(x.1).as_ref() { - (*id, x.1) - } else { - unreachable!() - } - }) - .collect::>(); - - let mut tobj_fields = methods - .iter() - .map(|(name, ty, _)| (name.clone(), *ty)) - .collect::>(); - tobj_fields.extend(fields.clone().into_iter()); - - Ok(unifier.add_ty(TypeEnum::TObj { - obj_id: *obj_id, - fields: tobj_fields.into(), - params: subst.into(), - })) - } else { - unreachable!("should be class def here") - } - } - TypeAnnotation::PrimitiveKind(ty) => Ok(*ty), - TypeAnnotation::TypeVarKind(_, ty) => Ok(*ty), - TypeAnnotation::VirtualKind(ty) => { - let ty = get_type_from_type_annotation_kinds( - top_level_defs, - unifier, - primitives, - ty.as_ref(), - )?; - Ok(unifier.add_ty(TypeEnum::TVirtual { ty })) - } - } - } - - fn parse_ast_to_concrete_primitive_kind( - _resolver: &dyn SymbolResolver, - _top_level_defs: &[Arc>], - _unifier: &mut Unifier, - primitives: &PrimitiveStore, - expr: &ast::Expr, - ) -> Result { - match &expr.node { - ast::ExprKind::Name { id, .. } => match id.as_str() { - "int32" => Ok(TypeAnnotation::PrimitiveKind(primitives.int32)), - "int64" => Ok(TypeAnnotation::PrimitiveKind(primitives.int64)), - "float" => Ok(TypeAnnotation::PrimitiveKind(primitives.float)), - "bool" => Ok(TypeAnnotation::PrimitiveKind(primitives.bool)), - "None" => Ok(TypeAnnotation::PrimitiveKind(primitives.none)), - _ => Err("not primitive".into()), - }, - - _ => Err("not primitive".into()), - } - } - - pub fn parse_ast_to_concretized_custom_class_kind( - resolver: &dyn SymbolResolver, - top_level_defs: &[Arc>], - unifier: &mut Unifier, - primitives: &PrimitiveStore, - expr: &ast::Expr, - ) -> Result { - match &expr.node { - ast::ExprKind::Name { id, .. } => match id.as_str() { - "int32" | "int64" | "float" | "bool" | "None" => { - Err("expect custom class instead of primitives here".into()) - } - x => { - let obj_id = resolver - .get_identifier_def(x) - .ok_or_else(|| "unknown class name".to_string())?; - let def = top_level_defs[obj_id.0].read(); - if let TopLevelDef::Class { .. } = &*def { - Ok(TypeAnnotation::ConcretizedCustomClassKind { - id: obj_id, - params: vec![], - }) - } else { - Err("function cannot be used as a type".into()) - } - } - }, - - ast::ExprKind::Subscript { value, slice, .. } => { - if let ast::ExprKind::Name { id, .. } = &value.node { - if vec!["virtual", "Generic"].contains(&id.as_str()) { - return Err("keywords cannot be class name".into()); - } - let obj_id = resolver - .get_identifier_def(id) - .ok_or_else(|| "unknown class name".to_string())?; - let def = top_level_defs[obj_id.0].read(); - if let TopLevelDef::Class { .. } = &*def { - let param_type_infos = - if let ast::ExprKind::Tuple { elts, .. } = &slice.node { - elts.iter() - .map(|v| { - parse_ast_to_type_annotation_kinds( - resolver, - top_level_defs, - unifier, - primitives, - v, - ) - }) - .collect::, _>>()? - } else { - vec![parse_ast_to_type_annotation_kinds( - resolver, - top_level_defs, - unifier, - primitives, - slice, - )?] - }; - // TODO: allow type var in class generic application list - // if param_type_infos - // .iter() - // .any(|x| matches!(x, TypeAnnotation::TypeVarKind(..))) - // { - // return Err( - // "cannot apply type variable to class generic parameters".into() - // ); - // } - Ok(TypeAnnotation::ConcretizedCustomClassKind { - id: obj_id, - params: param_type_infos, - }) - } else { - Err("function cannot be used as a type".into()) - } - } else { - Err("unsupported expression type for class name".into()) - } - } - - _ => Err("unsupported expression type for concretized class".into()), - } - } - - pub fn parse_ast_to_virtual_kind( - resolver: &dyn SymbolResolver, - top_level_defs: &[Arc>], - unifier: &mut Unifier, - primitives: &PrimitiveStore, - expr: &ast::Expr, - ) -> Result { - match &expr.node { - ast::ExprKind::Subscript { value, slice, .. } - if { matches!(&value.node, ast::ExprKind::Name { id, .. } if id == "virtual") } => - { - let def = parse_ast_to_concretized_custom_class_kind( - resolver, - top_level_defs, - unifier, - primitives, - slice.as_ref(), - )?; - if !matches!(def, TypeAnnotation::ConcretizedCustomClassKind { .. }) { - unreachable!("must be concretized custom class kind in the virtual") - } - Ok(TypeAnnotation::VirtualKind(def.into())) - } - - _ => Err("virtual type annotation must be like `virtual[ .. ]`".into()), - } - } - - pub fn parse_ast_to_type_variable_kind( - resolver: &dyn SymbolResolver, - _top_level_defs: &[Arc>], - unifier: &mut Unifier, - primitives: &PrimitiveStore, - expr: &ast::Expr, - ) -> Result { - if let ast::ExprKind::Name { id, .. } = &expr.node { - let ty = resolver - .get_symbol_type(unifier, primitives, id) - .ok_or_else(|| "unknown type variable name".to_string())?; - if let TypeEnum::TVar { id, meta: TypeVarMeta::Generic, range } = - unifier.get_ty(ty).as_ref() - { - // NOTE: always create a new one here - // and later unify if needed - // but record the var_id of the original type var returned by symbol resolver - let range = range.borrow(); - let range = range.as_slice(); - Ok(TypeAnnotation::TypeVarKind(*id, unifier.get_fresh_var_with_range(range).0)) - } else { - Err("not a type variable identifier".into()) - } - } else { - Err("unsupported expression for type variable".into()) - } - } -} +mod type_annotation; +use type_annotation::*; pub enum TopLevelDef { Class { diff --git a/nac3core/src/toplevel/type_annotation.rs b/nac3core/src/toplevel/type_annotation.rs new file mode 100644 index 00000000..37251933 --- /dev/null +++ b/nac3core/src/toplevel/type_annotation.rs @@ -0,0 +1,310 @@ +use super::*; +use crate::typecheck::typedef::TypeVarMeta; +#[derive(Clone)] +pub enum TypeAnnotation { + PrimitiveKind(Type), + ConcretizedCustomClassKind { + id: DefinitionId, + // can not be type var, others are all fine + // TODO: can also be type var? + params: Vec, + }, + // can only be ConcretizedCustomClassKind + VirtualKind(Box), + // the first u32 refers to the var_id of the + // TVar returned by the symbol resolver, + // this is used to handle type vars + // associated with class/functions + // since when associating we create a copy of type vars + TypeVarKind(u32, Type), + SelfTypeKind(DefinitionId), +} +pub fn parse_ast_to_type_annotation_kinds( + resolver: &dyn SymbolResolver, + top_level_defs: &[Arc>], + unifier: &mut Unifier, + primitives: &PrimitiveStore, + expr: &ast::Expr, +) -> Result { + let results = vec![ + parse_ast_to_concrete_primitive_kind( + resolver, + top_level_defs, + unifier, + primitives, + expr, + ), + parse_ast_to_concretized_custom_class_kind( + resolver, + top_level_defs, + unifier, + primitives, + expr, + ), + parse_ast_to_type_variable_kind(resolver, top_level_defs, unifier, primitives, expr), + parse_ast_to_virtual_kind(resolver, top_level_defs, unifier, primitives, expr), + ]; + let results = results.iter().filter(|x| x.is_ok()).collect_vec(); + if results.len() == 1 { + results[0].clone() + } else { + Err("cannot parsed the type annotation without ambiguity".into()) + } +} +pub fn get_type_from_type_annotation_kinds( + top_level_defs: &[Arc>], + unifier: &mut Unifier, + primitives: &PrimitiveStore, + ann: &TypeAnnotation, +) -> Result { + match ann { + TypeAnnotation::ConcretizedCustomClassKind { id, params } => { + let class_def = top_level_defs[id.0].read(); + if let TopLevelDef::Class { fields, methods, type_vars, .. } = &*class_def { + if type_vars.len() != params.len() { + Err(format!( + "unexpected number of type parameters: expected {} but got {}", + type_vars.len(), + params.len() + )) + } else { + let param_ty = params + .iter() + .map(|x| { + get_type_from_type_annotation_kinds( + top_level_defs, + unifier, + primitives, + x, + ) + }) + .collect::, _>>()?; + let subst = type_vars + .iter() + .map(|x| { + if let TypeEnum::TVar { id, .. } = unifier.get_ty(x.1).as_ref() { + // this is for the class generic application, + // we only need the information for the copied type var + // associated with the class + *id + } else { + unreachable!() + } + }) + .zip(param_ty.into_iter()) + .collect::>(); + let mut tobj_fields = methods + .iter() + .map(|(name, ty, _)| { + let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty); + (name.clone(), subst_ty) + }) + .collect::>(); + tobj_fields.extend(fields.iter().map(|(name, ty)| { + let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty); + (name.clone(), subst_ty) + })); + Ok(unifier.add_ty(TypeEnum::TObj { + obj_id: *id, + fields: tobj_fields.into(), + params: subst.into(), + })) + } + } else { + unreachable!("should be class def here") + } + } + TypeAnnotation::SelfTypeKind(obj_id) => { + let class_def = top_level_defs[obj_id.0].read(); + if let TopLevelDef::Class { fields, methods, type_vars, .. } = &*class_def { + let subst = type_vars + .iter() + .map(|x| { + if let TypeEnum::TVar { id, .. } = unifier.get_ty(x.1).as_ref() { + (*id, x.1) + } else { + unreachable!() + } + }) + .collect::>(); + let mut tobj_fields = methods + .iter() + .map(|(name, ty, _)| (name.clone(), *ty)) + .collect::>(); + tobj_fields.extend(fields.clone().into_iter()); + Ok(unifier.add_ty(TypeEnum::TObj { + obj_id: *obj_id, + fields: tobj_fields.into(), + params: subst.into(), + })) + } else { + unreachable!("should be class def here") + } + } + TypeAnnotation::PrimitiveKind(ty) => Ok(*ty), + TypeAnnotation::TypeVarKind(_, ty) => Ok(*ty), + TypeAnnotation::VirtualKind(ty) => { + let ty = get_type_from_type_annotation_kinds( + top_level_defs, + unifier, + primitives, + ty.as_ref(), + )?; + Ok(unifier.add_ty(TypeEnum::TVirtual { ty })) + } + } +} +fn parse_ast_to_concrete_primitive_kind( + _resolver: &dyn SymbolResolver, + _top_level_defs: &[Arc>], + _unifier: &mut Unifier, + primitives: &PrimitiveStore, + expr: &ast::Expr, +) -> Result { + match &expr.node { + ast::ExprKind::Name { id, .. } => match id.as_str() { + "int32" => Ok(TypeAnnotation::PrimitiveKind(primitives.int32)), + "int64" => Ok(TypeAnnotation::PrimitiveKind(primitives.int64)), + "float" => Ok(TypeAnnotation::PrimitiveKind(primitives.float)), + "bool" => Ok(TypeAnnotation::PrimitiveKind(primitives.bool)), + "None" => Ok(TypeAnnotation::PrimitiveKind(primitives.none)), + _ => Err("not primitive".into()), + }, + _ => Err("not primitive".into()), + } +} +pub fn parse_ast_to_concretized_custom_class_kind( + resolver: &dyn SymbolResolver, + top_level_defs: &[Arc>], + unifier: &mut Unifier, + primitives: &PrimitiveStore, + expr: &ast::Expr, +) -> Result { + match &expr.node { + ast::ExprKind::Name { id, .. } => match id.as_str() { + "int32" | "int64" | "float" | "bool" | "None" => { + Err("expect custom class instead of primitives here".into()) + } + x => { + let obj_id = resolver + .get_identifier_def(x) + .ok_or_else(|| "unknown class name".to_string())?; + let def = top_level_defs[obj_id.0].read(); + if let TopLevelDef::Class { .. } = &*def { + Ok(TypeAnnotation::ConcretizedCustomClassKind { + id: obj_id, + params: vec![], + }) + } else { + Err("function cannot be used as a type".into()) + } + } + }, + ast::ExprKind::Subscript { value, slice, .. } => { + if let ast::ExprKind::Name { id, .. } = &value.node { + if vec!["virtual", "Generic"].contains(&id.as_str()) { + return Err("keywords cannot be class name".into()); + } + let obj_id = resolver + .get_identifier_def(id) + .ok_or_else(|| "unknown class name".to_string())?; + let def = top_level_defs[obj_id.0].read(); + if let TopLevelDef::Class { .. } = &*def { + let param_type_infos = + if let ast::ExprKind::Tuple { elts, .. } = &slice.node { + elts.iter() + .map(|v| { + parse_ast_to_type_annotation_kinds( + resolver, + top_level_defs, + unifier, + primitives, + v, + ) + }) + .collect::, _>>()? + } else { + vec![parse_ast_to_type_annotation_kinds( + resolver, + top_level_defs, + unifier, + primitives, + slice, + )?] + }; + // TODO: allow type var in class generic application list + // if param_type_infos + // .iter() + // .any(|x| matches!(x, TypeAnnotation::TypeVarKind(..))) + // { + // return Err( + // "cannot apply type variable to class generic parameters".into() + // ); + // } + Ok(TypeAnnotation::ConcretizedCustomClassKind { + id: obj_id, + params: param_type_infos, + }) + } else { + Err("function cannot be used as a type".into()) + } + } else { + Err("unsupported expression type for class name".into()) + } + } + _ => Err("unsupported expression type for concretized class".into()), + } +} +pub fn parse_ast_to_virtual_kind( + resolver: &dyn SymbolResolver, + top_level_defs: &[Arc>], + unifier: &mut Unifier, + primitives: &PrimitiveStore, + expr: &ast::Expr, +) -> Result { + match &expr.node { + ast::ExprKind::Subscript { value, slice, .. } + if { matches!(&value.node, ast::ExprKind::Name { id, .. } if id == "virtual") } => + { + let def = parse_ast_to_concretized_custom_class_kind( + resolver, + top_level_defs, + unifier, + primitives, + slice.as_ref(), + )?; + if !matches!(def, TypeAnnotation::ConcretizedCustomClassKind { .. }) { + unreachable!("must be concretized custom class kind in the virtual") + } + Ok(TypeAnnotation::VirtualKind(def.into())) + } + _ => Err("virtual type annotation must be like `virtual[ .. ]`".into()), + } +} +pub fn parse_ast_to_type_variable_kind( + resolver: &dyn SymbolResolver, + _top_level_defs: &[Arc>], + unifier: &mut Unifier, + primitives: &PrimitiveStore, + expr: &ast::Expr, +) -> Result { + if let ast::ExprKind::Name { id, .. } = &expr.node { + let ty = resolver + .get_symbol_type(unifier, primitives, id) + .ok_or_else(|| "unknown type variable name".to_string())?; + if let TypeEnum::TVar { id, meta: TypeVarMeta::Generic, range } = + unifier.get_ty(ty).as_ref() + { + // NOTE: always create a new one here + // and later unify if needed + // but record the var_id of the original type var returned by symbol resolver + let range = range.borrow(); + let range = range.as_slice(); + Ok(TypeAnnotation::TypeVarKind(*id, unifier.get_fresh_var_with_range(range).0)) + } else { + Err("not a type variable identifier".into()) + } + } else { + Err("unsupported expression for type variable".into()) + } +} \ No newline at end of file diff --git a/nac3core/src/typecheck/type_inferencer/mod.rs b/nac3core/src/typecheck/type_inferencer/mod.rs index d6989c5d..e81a7473 100644 --- a/nac3core/src/typecheck/type_inferencer/mod.rs +++ b/nac3core/src/typecheck/type_inferencer/mod.rs @@ -5,7 +5,7 @@ use std::{cell::RefCell, sync::Arc}; use super::typedef::{Call, FunSignature, FuncArg, Type, TypeEnum, Unifier}; use super::{magic_methods::*, typedef::CallId}; -use crate::{symbol_resolver::SymbolResolver, top_level::TopLevelContext}; +use crate::{symbol_resolver::SymbolResolver, toplevel::TopLevelContext}; use itertools::izip; use rustpython_parser::ast::{ self, diff --git a/nac3core/src/typecheck/type_inferencer/test.rs b/nac3core/src/typecheck/type_inferencer/test.rs index 73acd287..7216a112 100644 --- a/nac3core/src/typecheck/type_inferencer/test.rs +++ b/nac3core/src/typecheck/type_inferencer/test.rs @@ -1,8 +1,7 @@ use super::super::typedef::*; use super::*; use crate::symbol_resolver::*; -use crate::top_level::DefinitionId; -use crate::{location::Location, top_level::TopLevelDef}; +use crate::{location::Location, toplevel::{DefinitionId, TopLevelDef}}; use indoc::indoc; use itertools::zip; use parking_lot::RwLock; diff --git a/nac3core/src/typecheck/typedef/mod.rs b/nac3core/src/typecheck/typedef/mod.rs index 709d1742..318615f2 100644 --- a/nac3core/src/typecheck/typedef/mod.rs +++ b/nac3core/src/typecheck/typedef/mod.rs @@ -8,7 +8,7 @@ use std::sync::{Arc, Mutex}; use super::unification_table::{UnificationKey, UnificationTable}; use crate::symbol_resolver::SymbolValue; -use crate::top_level::{DefinitionId, TopLevelContext, TopLevelDef}; +use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef}; #[cfg(test)] mod test; diff --git a/nac3standalone/src/basic_symbol_resolver.rs b/nac3standalone/src/basic_symbol_resolver.rs index 8e36afe7..8b0a16d2 100644 --- a/nac3standalone/src/basic_symbol_resolver.rs +++ b/nac3standalone/src/basic_symbol_resolver.rs @@ -1,7 +1,7 @@ use nac3core::{ location::Location, symbol_resolver::{SymbolResolver, SymbolValue}, - top_level::DefinitionId, + toplevel::DefinitionId, typecheck::{ type_inferencer::PrimitiveStore, typedef::{Type, Unifier}, diff --git a/nac3standalone/src/main.rs b/nac3standalone/src/main.rs index 666b9a74..64cd7c8e 100644 --- a/nac3standalone/src/main.rs +++ b/nac3standalone/src/main.rs @@ -10,7 +10,7 @@ use std::{cell::RefCell, collections::HashMap, path::Path, sync::Arc}; use nac3core::{ codegen::{CodeGenTask, WithCall, WorkerRegistry}, - top_level::{DefinitionId, TopLevelComposer, TopLevelContext, TopLevelDef}, + toplevel::{DefinitionId, TopLevelComposer, TopLevelContext, TopLevelDef}, typecheck::{ type_inferencer::{FunctionData, Inferencer}, typedef::{FunSignature, FuncArg, TypeEnum},