M-Labs/nac3
M-Labs
/
nac3
8
0
Fork 10
Code Issues 98 Pull Requests 20 Releases Wiki Activity

remove self kind and extra primitive info in the return of top level composer constructor, adding some helper function for type annotation

This commit is contained in:
ychenfo 2021-08-25 13:39:55 +08:00
parent e2b11c3fee
commit 862d205f67
3 changed files with 132 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
nac3core/src/toplevel/mod.rs
View File

@ -1,6 +1,4 @@
use std::borrow::BorrowMut;
use std::ops::{Deref, DerefMut};
use std::{collections::HashMap, collections::HashSet, sync::Arc};
use std::{collections::{HashMap, HashSet}, sync::Arc, ops::{Deref, DerefMut}, borrow::BorrowMut};
use super::typecheck::type_inferencer::PrimitiveStore;
use super::typecheck::typedef::{FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier};
@ -87,6 +85,12 @@ pub struct TopLevelComposer {
pub keyword_list: Vec<String>,
}
impl Default for TopLevelComposer {
fn default() -> Self {
Self::new()
}
}
impl TopLevelComposer {
pub fn make_top_level_context(self) -> TopLevelContext {
TopLevelContext {
@ -134,7 +138,7 @@ impl TopLevelComposer {
/// return a composer and things to make a "primitive" symbol resolver, so that the symbol
/// resolver can later figure out primitive type definitions when passed a primitive type name
// TODO: add list and tuples?
pub fn new() -> (Vec<(String, DefinitionId, Type)>, Self) {
pub fn new() -> Self {
let primitives = Self::make_primitives();
let top_level_def_list = vec![
@ -147,7 +151,7 @@ impl TopLevelComposer {
let ast_list: Vec<Option<ast::Stmt<()>>> = vec![None, None, None, None, None];
let composer = TopLevelComposer {
TopLevelComposer {
definition_ast_list: izip!(top_level_def_list, ast_list).collect_vec(),
primitives_ty: primitives.0,
unifier: primitives.1,
@ -165,17 +169,7 @@ impl TopLevelComposer {
"none".into(),
"None".into(),
],
};
(
vec![
("int32".into(), DefinitionId(0), composer.primitives_ty.int32),
("int64".into(), DefinitionId(1), composer.primitives_ty.int64),
("float".into(), DefinitionId(2), composer.primitives_ty.float),
("bool".into(), DefinitionId(3), composer.primitives_ty.bool),
("none".into(), DefinitionId(4), composer.primitives_ty.none),
],
composer,
)
}
}
/// already include the definition_id of itself inside the ancestors vector
@ -191,7 +185,7 @@ impl TopLevelComposer {
type_vars: Default::default(),
fields: Default::default(),
methods: Default::default(),
ancestors: vec![TypeAnnotation::SelfTypeKind(DefinitionId(index))],
ancestors: Default::default(),
resolver,
}
}
@ -265,6 +259,8 @@ impl TopLevelComposer {
DefinitionId,
Type,
)> = Vec::new();
// we do not push anything to the def list, so we keep track of the index
// and then push in the correct order after the for loop
let mut class_method_index_offset = 0;
for b in body {
if let ast::StmtKind::FunctionDef { name: method_name, .. } = &b.node {
@ -274,6 +270,7 @@ impl TopLevelComposer {
return Err("duplicate class method definition".into());
}
let method_def_id = self.definition_ast_list.len() + {
// plus 1 here since we already have the class def
class_method_index_offset += 1;
class_method_index_offset
};
@ -388,7 +385,10 @@ impl TopLevelComposer {
// should update the TopLevelDef::Class.typevars and the TypeEnum::TObj.params
ast::ExprKind::Subscript { value, slice, .. }
if {
matches!(&value.node, ast::ExprKind::Name { id, .. } if id == "Generic")
matches!(
&value.node,
ast::ExprKind::Name { id, .. } if id == "Generic"
)
} =>
{
if !is_generic {
@ -437,14 +437,9 @@ impl TopLevelComposer {
let type_vars = type_vars
.into_iter()
.map(|x| {
let range = unifier.get_ty(x);
if let TypeEnum::TVar { id, range, .. } = range.as_ref() {
let range = &*range.borrow();
let range = range.as_slice();
(*id, unifier.get_fresh_var_with_range(range).0)
} else {
unreachable!("must be type var here after previous check");
}
// must be type var here after previous check
let dup = duplicate_type_var(unifier, x);
(dup.1, (dup.0).0)
})
.collect_vec();
@ -465,13 +460,13 @@ impl TopLevelComposer {
let temp_def_list = self.extract_def_list();
for (class_def, class_ast) in self.definition_ast_list.iter_mut() {
let mut class_def = class_def.write();
let (class_bases, class_ancestors, class_resolver) = {
if let TopLevelDef::Class { ancestors, resolver, .. } = class_def.deref_mut() {
let (class_bases, class_ancestors, class_resolver, class_id) = {
if let TopLevelDef::Class { ancestors, resolver, object_id, .. } = class_def.deref_mut() {
if let Some(ast::Located {
node: ast::StmtKind::ClassDef { bases, .. }, ..
}) = class_ast
{
(bases, ancestors, resolver)
(bases, ancestors, resolver, *object_id)
} else {
unreachable!("must be both class")
}
@ -511,7 +506,7 @@ impl TopLevelComposer {
b,
)?;
if let TypeAnnotation::ConcretizedCustomClassKind { .. } = &base_ty {
if let TypeAnnotation::CustomClassKind { .. } = &base_ty {
// TODO: check to prevent cyclic base class
class_ancestors.push(base_ty);
} else {
@ -520,6 +515,11 @@ impl TopLevelComposer {
);
}
}
// push self to the ancestors
class_ancestors.push(
make_self_type_annotation(&temp_def_list, class_id, self.unifier.borrow_mut())?
)
}
Ok(())
}
@ -611,7 +611,7 @@ impl TopLevelComposer {
primitives_store,
annotation,
)?;
if let TypeEnum::TVar { id, range, .. } =
if let TypeEnum::TVar { id, .. } =
unifier.get_ty(ty).as_ref()
{
if let Some(occured_ty) = occured_type_var.get(id) {
@ -619,19 +619,16 @@ impl TopLevelComposer {
ty = *occured_ty;
} else {
// if not, create a duplicate
let range = range.borrow();
let range = range.as_slice();
let ty_copy = unifier.get_fresh_var_with_range(range);
ty = ty_copy.0;
let ty_copy = duplicate_type_var(unifier, ty);
ty = ty_copy.0.0;
occured_type_var.insert(*id, ty);
function_var_map.insert(ty_copy.1, ty_copy.0);
function_var_map.insert(ty_copy.1, ty_copy.0.0);
}
}
Ok(FuncArg {
name: x.node.arg.clone(),
ty,
// TODO: function type var
default_value: Default::default(),
})
})
@ -779,7 +776,7 @@ impl TopLevelComposer {
unifier.unify(*ty, associated[0].1)?;
}
_ => {
unreachable!("should not be duplicate type var");
unreachable!("there should not be duplicate type var");
}
}
@ -813,7 +810,10 @@ impl TopLevelComposer {
default_value: None,
};
type_var_to_concrete_def
.insert(dummy_func_arg.ty, TypeAnnotation::SelfTypeKind(*class_id));
.insert(
dummy_func_arg.ty,
make_self_type_annotation(temp_def_list, *class_id, unifier)?
);
result.push(dummy_func_arg);
}
}
@ -839,7 +839,10 @@ impl TopLevelComposer {
// if is the "__init__" function, the return type is self
let dummy_return_type = unifier.get_fresh_var().0;
type_var_to_concrete_def
.insert(dummy_return_type, TypeAnnotation::SelfTypeKind(*class_id));
.insert(
dummy_return_type,
make_self_type_annotation(temp_def_list, *class_id, unifier)?
);
dummy_return_type
}
};
@ -855,7 +858,7 @@ impl TopLevelComposer {
if name == "__init__" {
for b in body {
let mut defined_fields: HashSet<String> = HashSet::new();
// TODO: check the type of value, field instantiation check
// TODO: check the type of value, field instantiation check?
if let ast::StmtKind::AnnAssign { annotation, target, value: _, .. } =
&b.node
{

129
nac3core/src/toplevel/type_annotation.rs
View File

@ -1,15 +1,17 @@
use super::*;
use crate::typecheck::typedef::TypeVarMeta;
#[derive(Clone)]
pub enum TypeAnnotation {
PrimitiveKind(Type),
ConcretizedCustomClassKind {
// we use type vars kind at
// params to represent self type
CustomClassKind {
id: DefinitionId,
// can not be type var, others are all fine
// TODO: can also be type var?
params: Vec<TypeAnnotation>,
},
// can only be ConcretizedCustomClassKind
// can only be CustomClassKind
VirtualKind(Box<TypeAnnotation>),
// the first u32 refers to the var_id of the
// TVar returned by the symbol resolver,
@ -17,7 +19,6 @@ pub enum TypeAnnotation {
// 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<T>(
@ -38,7 +39,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
if let Some(obj_id) = resolver.get_identifier_def(x) {
let def = top_level_defs[obj_id.0].read();
if let TopLevelDef::Class { .. } = &*def {
Ok(TypeAnnotation::ConcretizedCustomClassKind {
Ok(TypeAnnotation::CustomClassKind {
id: obj_id,
params: vec![],
})
@ -46,17 +47,16 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
Err("function cannot be used as a type".into())
}
} else if let Some(ty) = resolver.get_symbol_type(unifier, primitives, id) {
if let TypeEnum::TVar { id, meta: TypeVarMeta::Generic, range } =
unifier.get_ty(ty).as_ref()
if let TypeEnum::TVar { id, .. } = 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();
// but record the var_id of the original type var
// returned by symbol resolver
Ok(TypeAnnotation::TypeVarKind(
*id,
unifier.get_fresh_var_with_range(range).0,
// TODO: maybe not duplicate will also be fine here?
duplicate_type_var(unifier, ty).0.0
))
} else {
Err("not a type variable identifier".into())
@ -67,7 +67,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
}
},
// TODO: subscript or call
// TODO: subscript or call?
ast::ExprKind::Subscript { value, slice, .. }
if { matches!(&value.node, ast::ExprKind::Name { id, .. } if id == "virtual") } =>
{
@ -78,7 +78,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
primitives,
slice.as_ref(),
)?;
if !matches!(def, TypeAnnotation::ConcretizedCustomClassKind { .. }) {
if !matches!(def, TypeAnnotation::CustomClassKind { .. }) {
unreachable!("must be concretized custom class kind in the virtual")
}
Ok(TypeAnnotation::VirtualKind(def.into()))
@ -116,7 +116,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
)?]
};
// NOTE: allow type var in class generic application list
Ok(TypeAnnotation::ConcretizedCustomClassKind {
Ok(TypeAnnotation::CustomClassKind {
id: obj_id,
params: param_type_infos,
})
@ -139,7 +139,7 @@ pub fn get_type_from_type_annotation_kinds(
ann: &TypeAnnotation,
) -> Result<Type, String> {
match ann {
TypeAnnotation::ConcretizedCustomClassKind { id, params } => {
TypeAnnotation::CustomClassKind { 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() {
@ -160,6 +160,7 @@ pub fn get_type_from_type_annotation_kinds(
)
})
.collect::<Result<Vec<_>, _>>()?;
// FIXME: TODO: cannot directy subst type var here? need to subst types in fields/methods
let subst = type_vars
.iter()
.map(|x| {
@ -195,33 +196,6 @@ pub fn get_type_from_type_annotation_kinds(
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::<HashMap<u32, Type>>();
let mut tobj_fields = methods
.iter()
.map(|(name, ty, _)| (name.clone(), *ty))
.collect::<HashMap<String, Type>>();
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) => {
@ -235,3 +209,74 @@ pub fn get_type_from_type_annotation_kinds(
}
}
}
/// the first return is the duplicated type \
/// the second return is the var_id of the duplicated type \
/// the third return is the var_id of the original type
#[inline]
pub fn duplicate_type_var(
unifier: &mut Unifier,
type_var: Type
) -> ((Type, u32), u32) {
let ty = unifier.get_ty(type_var);
if let TypeEnum::TVar { id, range, .. } = ty.as_ref() {
let range = range.borrow();
let range = range.as_slice();
(unifier.get_fresh_var_with_range(range), *id)
} else {
unreachable!("must be type var here to be duplicated");
}
}
/// given an def id, return a type annotation of self \
/// ```python
/// class A(Generic[T, V]):
/// def fun(self):
/// ```
/// the type of `self` should be equivalent to `A[T, V]`, where `T`, `V`
/// considered to be type variables associated with the class
pub fn make_self_type_annotation(
top_level_defs: &[Arc<RwLock<TopLevelDef>>],
def_id: DefinitionId,
unifier: &mut Unifier,
) -> Result<TypeAnnotation, String> {
let obj_def = top_level_defs
.get(def_id.0)
.ok_or_else(|| "invalid definition id".to_string())?;
let obj_def = obj_def.read();
let obj_def = obj_def.deref();
if let TopLevelDef::Class { type_vars, .. } = obj_def {
Ok(TypeAnnotation::CustomClassKind {
id: def_id,
params: type_vars
.iter()
.map(|(var_id, ty)| TypeAnnotation::TypeVarKind(
*var_id,
duplicate_type_var(unifier, *ty).0.0
))
.collect_vec()
})
} else {
unreachable!("must be top level class def here")
}
}
/// get all the occurences of type vars contained in a type annotation
/// e.g. `A[int, B[T], V]` => [T, V]
pub fn get_type_var_contained_in_type_annotation(ann: &TypeAnnotation) -> Vec<TypeAnnotation> {
let mut result: Vec<TypeAnnotation> = Vec::new();
match ann {
TypeAnnotation::TypeVarKind( .. ) => result.push(ann.clone()),
TypeAnnotation::VirtualKind(ann) => result.extend(
get_type_var_contained_in_type_annotation(ann.as_ref())
),
TypeAnnotation::CustomClassKind { params, .. } => {
for p in params {
result.extend(get_type_var_contained_in_type_annotation(p));
}
},
_ => { }
}
result
}

2
nac3standalone/src/main.rs
View File

@ -51,7 +51,7 @@ fn main() {
}
};
let (_, composer) = TopLevelComposer::new();
let composer = TopLevelComposer::new();
let mut unifier = composer.unifier.clone();
let primitives = composer.primitives_ty;
let top_level = Arc::new(composer.make_top_level_context());