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

hm-inference #6

Merged
sb10q merged 136 commits from hm-inference into master 2021-08-19 11:46:50 +08:00
Conversation 1 Commits 136 Files Changed 29 +80 -70
1 changed files with 80 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit a73ab922e2 - Show all commits

114
nac3core/src/top_level.rs
View File

@ -1,14 +1,14 @@
use std::{collections::HashMap, sync::Arc}; use std::{collections::HashMap, sync::Arc};
use super::typecheck::type_inferencer::PrimitiveStore; use super::typecheck::type_inferencer::PrimitiveStore;
use super::typecheck::typedef::{SharedUnifier, Type, Unifier, TypeEnum}; use super::typecheck::typedef::{SharedUnifier, Type, TypeEnum, Unifier};
use crate::symbol_resolver::SymbolResolver; use crate::symbol_resolver::SymbolResolver;
use inkwell::{ use inkwell::{
basic_block::BasicBlock, builder::Builder, context::Context, module::Module, basic_block::BasicBlock, builder::Builder, context::Context, module::Module,
types::BasicTypeEnum, values::PointerValue, types::BasicTypeEnum, values::PointerValue,
}; };
use parking_lot::RwLock; use parking_lot::RwLock;
use rustpython_parser::ast::Stmt; use rustpython_parser::ast::{self, Stmt};
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)] #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub struct DefinitionId(pub usize); pub struct DefinitionId(pub usize);
@ -45,8 +45,8 @@ pub enum TopLevelDef {
instance_to_stmt: HashMap<String, (Stmt<Option<Type>>, usize)>, instance_to_stmt: HashMap<String, (Stmt<Option<Type>>, usize)>,
}, },
Initializer { Initializer {
class_id: Option<DefinitionId>, class_id: DefinitionId,
} },
} }
pub struct CodeGenTask { pub struct CodeGenTask {
@ -78,15 +78,15 @@ pub struct CodeGenContext<'ctx> {
pub loop_bb: Option<(BasicBlock<'ctx>, BasicBlock<'ctx>)>, pub loop_bb: Option<(BasicBlock<'ctx>, BasicBlock<'ctx>)>,
} }
pub struct TopLevelDefInfo<'a> {
// like adding some info on top of the TopLevelDef for later parsing the class bases, method,
use rustpython_parser::ast; // and function sigatures
pub struct TopLevelDefInfo<'a> { // 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 ast: Option<ast::Stmt<()>>, // the ast submitted by applications
resolver: Option<&'a dyn SymbolResolver> // the resolver resolver: Option<&'a dyn SymbolResolver>, // the resolver
} }
pub struct TopLevelComposer<'a> { pub struct TopLevelComposer<'a> {
pub definition_list: Vec<TopLevelDefInfo<'a>>, pub definition_list: Vec<TopLevelDefInfo<'a>>,
pub primitives: PrimitiveStore, pub primitives: PrimitiveStore,
@ -97,27 +97,27 @@ impl<'a> TopLevelComposer<'a> {
pub fn make_primitives() -> (PrimitiveStore, Unifier) { pub fn make_primitives() -> (PrimitiveStore, Unifier) {
let mut unifier = Unifier::new(); let mut unifier = Unifier::new();
let int32 = unifier.add_ty(TypeEnum::TObj { let int32 = unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(0), // 0 should be fine obj_id: DefinitionId(0),
fields: HashMap::new().into(), fields: HashMap::new().into(),
params: HashMap::new(), params: HashMap::new(),
}); });
let int64 = unifier.add_ty(TypeEnum::TObj { let int64 = unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(1), // 0 should be fine obj_id: DefinitionId(1),
fields: HashMap::new().into(), fields: HashMap::new().into(),
params: HashMap::new(), params: HashMap::new(),
}); });
let float = unifier.add_ty(TypeEnum::TObj { let float = unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(2), // 0 should be fine obj_id: DefinitionId(2),
fields: HashMap::new().into(), fields: HashMap::new().into(),
params: HashMap::new(), params: HashMap::new(),
}); });
let bool = unifier.add_ty(TypeEnum::TObj { let bool = unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(3), // 0 should be fine obj_id: DefinitionId(3),
fields: HashMap::new().into(), fields: HashMap::new().into(),
params: HashMap::new(), params: HashMap::new(),
}); });
let none = unifier.add_ty(TypeEnum::TObj { let none = unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(4), // 0 should be fine obj_id: DefinitionId(4),
fields: HashMap::new().into(), fields: HashMap::new().into(),
params: HashMap::new(), params: HashMap::new(),
}); });
@ -125,6 +125,7 @@ impl<'a> TopLevelComposer<'a> {
crate::typecheck::magic_methods::set_primitives_magic_methods(&primitives, &mut unifier); crate::typecheck::magic_methods::set_primitives_magic_methods(&primitives, &mut unifier);
(primitives, unifier) (primitives, unifier)
} }
pub fn new() -> Self { pub fn new() -> Self {
let primitives = Self::make_primitives(); let primitives = Self::make_primitives();
let definition_list: Vec<TopLevelDefInfo<'a>> = vec![ let definition_list: Vec<TopLevelDefInfo<'a>> = vec![
@ -132,38 +133,34 @@ impl<'a> TopLevelComposer<'a> {
def: Self::make_top_level_class_def(0), def: Self::make_top_level_class_def(0),
ast: None, ast: None,
resolver: None, resolver: None,
ty: primitives.0.int32 // just arbitary picked one... ty: primitives.0.int32,
}, },
TopLevelDefInfo { TopLevelDefInfo {
def: Self::make_top_level_class_def(1), def: Self::make_top_level_class_def(1),
ast: None, ast: None,
resolver: None, resolver: None,
ty: primitives.0.int64 // just arbitary picked one... ty: primitives.0.int64,
}, },
TopLevelDefInfo { TopLevelDefInfo {
def: Self::make_top_level_class_def(2), def: Self::make_top_level_class_def(2),
ast: None, ast: None,
resolver: None, resolver: None,
ty: primitives.0.float // just arbitary picked one... ty: primitives.0.float,
}, },
TopLevelDefInfo { TopLevelDefInfo {
def: Self::make_top_level_class_def(3), def: Self::make_top_level_class_def(3),
ast: None, ast: None,
resolver: None, resolver: None,
ty: primitives.0.bool // just arbitary picked one... ty: primitives.0.bool,
}, },
TopLevelDefInfo { TopLevelDefInfo {
def: Self::make_top_level_class_def(4), def: Self::make_top_level_class_def(4),
ast: None, ast: None,
resolver: None, resolver: None,
ty: primitives.0.none // just arbitary picked one... ty: primitives.0.none,
}, },
]; // the entries for primitive types ]; // the entries for primitive types
TopLevelComposer { TopLevelComposer { definition_list, primitives: primitives.0, unifier: primitives.1 }
definition_list,
primitives: primitives.0,
unifier: primitives.1
}
} }
pub fn make_top_level_class_def(index: usize) -> TopLevelDef { pub fn make_top_level_class_def(index: usize) -> TopLevelDef {
@ -180,11 +177,12 @@ impl<'a> TopLevelComposer<'a> {
name, name,
signature: ty, signature: ty,
instance_to_symbol: Default::default(), instance_to_symbol: Default::default(),
instance_to_stmt: Default::default() instance_to_stmt: Default::default(),
} }
} }
// 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 // 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)> { pub fn get_primitives_definition(&self) -> Vec<(String, DefinitionId, Type)> {
vec![ vec![
("int32".into(), DefinitionId(0), self.primitives.int32), ("int32".into(), DefinitionId(0), self.primitives.int32),
@ -195,60 +193,63 @@ impl<'a> TopLevelComposer<'a> {
] ]
} }
pub fn register_top_level(&mut self, ast: ast::Stmt<()>, resolver: &'a dyn SymbolResolver) -> Result<Vec<(String, DefinitionId, Type)>, String> { pub fn register_top_level(
&mut self,
ast: ast::Stmt<()>,
resolver: &'a dyn SymbolResolver,
) -> Result<Vec<(String, DefinitionId, Type)>, String> {
match &ast.node { match &ast.node {
ast::StmtKind::ClassDef {name, body, ..} => { ast::StmtKind::ClassDef { name, body, .. } => {
let class_name = name.to_string(); let class_name = name.to_string();
let def_id = self.definition_list.len(); let def_id = self.definition_list.len();
// add the class to the unifier // add the class to the unifier
let ty = self.unifier.add_ty(TypeEnum::TObj { let ty = self.unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(def_id), obj_id: DefinitionId(def_id),
fields: Default::default(), fields: Default::default(),
params: Default::default() params: Default::default(),
}); });
// add to the definition list // add to the definition list
self.definition_list.push( self.definition_list.push(TopLevelDefInfo {
TopLevelDefInfo {
def: Self::make_top_level_class_def(def_id), def: Self::make_top_level_class_def(def_id),
resolver: Some(resolver), resolver: Some(resolver),
ast: Some(ast), ast: Some(ast),
ty, ty,
} });
);
// TODO: parse class def body and register class methods into the def list? // TODO: parse class def body and register class methods into the def list?
// FIXME: 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? // FIXME: module's symbol resolver would not know the name of the class methods,
// 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 // 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 application
// to be used to build symbol resolver? <- current implementation
Ok(vec![(class_name, DefinitionId(def_id), ty)]) // FIXME: need to add class method def Ok(vec![(class_name, DefinitionId(def_id), ty)]) // FIXME: need to add class method def
}, }
ast::StmtKind::FunctionDef {name, ..} => { ast::StmtKind::FunctionDef { name, .. } => {
let fun_name = name.to_string(); let fun_name = name.to_string();
let def_id = self.definition_list.len(); let def_id = self.definition_list.len();
// add to the unifier // add to the 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(), args: Default::default(),
ret: self.primitives.none, // NOTE: this needs to be changed later ret: self.primitives.none, // NOTE: this needs to be changed later
vars: Default::default() vars: Default::default(),
})); }));
// add to the definition list // add to the definition list
self.definition_list.push( self.definition_list.push(TopLevelDefInfo {
TopLevelDefInfo {
def: Self::make_top_level_function_def( def: Self::make_top_level_function_def(
name.into(), name.into(),
self.primitives.none // NOTE: this needs to be changed later self.primitives.none, // NOTE: this needs to be changed later
), ),
resolver: Some(resolver), resolver: Some(resolver),
ast: Some(ast), ast: Some(ast),
ty, ty,
} });
);
Ok(vec![(fun_name, DefinitionId(def_id), ty)]) Ok(vec![(fun_name, DefinitionId(def_id), ty)])
}, }
_ => Err("only registrations of top level classes/functions are supprted".into()) _ => Err("only registrations of top level classes/functions are supprted".into()),
} }
} }
@ -263,17 +264,26 @@ impl<'a> TopLevelComposer<'a> {
body, body,
.. ..
} => { } => {
// ancestors and typevars associate with the class are analyzed by looking into the `bases` ast node // ancestors and typevars associate with the class are analyzed by looking
// into the `bases` ast node
for b in bases { for b in bases {
match &b.node { match &b.node {
ast::ExprKind::Name {id, ..} => { // base class, name directly available inside the module, can use this module's symbol resolver // base class, name directly available inside the module, can use
// this module's symbol resolver
ast::ExprKind::Name {id, ..} => {
let def_id = resolver.get_identifier_def(id); let def_id = resolver.get_identifier_def(id);
unimplemented!() unimplemented!()
}, },
ast::ExprKind::Attribute {value, attr, ..} => { // things can be like `class A(BaseModule.Base)`, here we have to get the symbol resolver of the module `BaseModule`? // things can be like `class A(BaseModule.Base)`, here we have to
unimplemented!() // need to change symbol resolver in order to get the symbol resolver of the imported module // get the symbol resolver of the module `BaseModule`?
ast::ExprKind::Attribute {value, attr, ..} => {
// need to change symbol resolver in order to get the symbol
// resolver of the imported module
unimplemented!()
}, },
ast::ExprKind::Subscript {value, slice, ..} => { // typevars bounded to the class, things like `class A(Generic[T, V])` // typevars bounded to the class, things like
// `class A(Generic[T, V])`
ast::ExprKind::Subscript {value, slice, ..} => {
if let ast::ExprKind::Name {id, ..} = &value.node { if let ast::ExprKind::Name {id, ..} = &value.node {
if id == "Generic" { if id == "Generic" {
// TODO: get typevars // TODO: get typevars
@ -306,7 +316,7 @@ impl<'a> TopLevelComposer<'a> {
_ => return Err("only expect function and class definitions to be submitted here to be analyzed".into()) _ => return Err("only expect function and class definitions to be submitted here to be analyzed".into())
} }
} }
}; }
Ok(()) Ok(())
} }
} }