pca006132/nac3
1
0
Fork 0
forked from M-Labs/nac3
Code Issues Pull Requests Releases Wiki Activity

implemented inference

Browse Source 
rc nightmare...
This commit is contained in:
pca006132 2020-12-28 11:06:32 +08:00 committed by pca006132
parent fa02dc8271
commit fd3e1d4923
2 changed files with 101 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
nac3type/src/inference.rs
View File

@ -46,7 +46,7 @@ fn find_subst(
}
(TypeVariable(id_a), _) => {
let v_a = ctx.get_variable(*id_a);
if v_a.bound.len() == 1 && &v_a.bound[0] == b.as_ref() {
if v_a.bound.len() == 1 && v_a.bound[0].as_ref() == b.as_ref() {
Ok(())
} else {
Err("different domain".to_string())
@ -83,7 +83,7 @@ fn find_subst(
parents.extend_from_slice(&c.parents);
}
Err("not subtype".to_string())
},
}
(ParametricType(id_a, param_a), ParametricType(id_b, param_b)) => {
if id_a != id_b || param_a.len() != param_b.len() {
Err("different parametric types".to_string())
@ -93,7 +93,7 @@ fn find_subst(
}
Ok(())
}
},
}
(_, _) => {
if a == b {
Ok(())
@ -104,4 +104,68 @@ fn find_subst(
}
}
pub fn resolve_call(
ctx: &GlobalContext,
obj: Option<Rc<Type>>,
func: &str,
args: Rc<Type>,
assumptions: &mut HashMap<VariableId, Rc<Type>>,
) -> Result<Option<Rc<Type>>, String> {
let obj = obj.as_ref().map(|v| Rc::new(v.subst(assumptions)));
let mut subst = obj
.as_ref()
.map(|v| v.get_subst(ctx))
.unwrap_or(HashMap::new());
let fun = match &obj {
Some(obj) => {
let base = match obj.as_ref() {
TypeVariable(id) => {
let v = ctx.get_variable(*id);
if v.bound.len() == 0 {
return Err("unbounded type var".to_string());
}
let results: Result<Vec<_>, String> = v
.bound
.iter()
.map(|ins| {
assumptions.insert(*id, ins.clone());
resolve_call(ctx, Some(obj.clone()), func, args.clone(), assumptions)
})
.collect();
let results = results?;
if results.iter().all(|v| v == &results[0]) {
return Ok(results[0].clone());
}
let mut results = results.iter().zip(v.bound.iter()).map(|(r, ins)| {
r.as_ref()
.map(|v| v.inv_subst(&[(ins.clone(), obj.clone().into())]))
});
let first = results.next().unwrap();
if results.all(|v| v == first) {
return Ok(first);
} else {
return Err("divergent type after substitution".to_string());
}
},
PrimitiveType(id) => &ctx.get_primitive(*id),
ClassType(id) | VirtualClassType(id) => &ctx.get_class(*id).base,
ParametricType(id, _) => &ctx.get_parametric(*id).base,
_ => return Err("not supported".to_string()),
};
base.methods.get(func)
},
None => ctx.get_fn(func),
}
.ok_or("no such function".to_string())?;
find_subst(ctx, assumptions, &mut subst, args, fun.args.clone())?;
let result = fun.result.as_ref().map(|v| v.subst(&subst));
Ok(result.map(|result| {
if let SelfType = result {
obj.unwrap()
} else {
result.into()
}
}))
}

49
nac3type/src/types.rs
View File

@ -1,19 +1,19 @@
use std::collections::HashMap;
use std::rc::Rc;
#[derive(PartialEq, Eq, Copy, Clone, Hash)]
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct PrimitiveId(usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash)]
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct ClassId(usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash)]
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct ParamId(usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash)]
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct VariableId(usize);
#[derive(PartialEq, Eq, Clone, Hash)]
#[derive(PartialEq, Eq, Clone, Hash, Debug)]
pub enum Type {
BotType,
SelfType,
@ -25,8 +25,8 @@ pub enum Type {
}
pub struct FnDef {
pub args: Vec<Type>,
pub result: Option<Type>,
pub args: Rc<Type>,
pub result: Option<Rc<Type>>,
}
pub struct TypeDef<'a> {
@ -47,15 +47,22 @@ pub struct ParametricDef<'a> {
pub struct VarDef<'a> {
pub name: &'a str,
pub bound: Vec<Type>,
pub bound: Vec<Rc<Type>>,
}
pub const TUPLE_TYPE: ParamId = ParamId(0);
pub const LIST_TYPE: ParamId = ParamId(1);
pub const BOOL_TYPE: PrimitiveId = PrimitiveId(0);
pub const INT32_TYPE: PrimitiveId = PrimitiveId(1);
pub struct GlobalContext<'a> {
primitive_defs: Vec<TypeDef<'a>>,
class_defs: Vec<ClassDef<'a>>,
parametric_defs: Vec<ParametricDef<'a>>,
var_defs: Vec<VarDef<'a>>,
sym_table: HashMap<&'a str, Type>,
fn_table: HashMap<&'a str, FnDef>,
}
impl<'a> GlobalContext<'a> {
@ -69,6 +76,7 @@ impl<'a> GlobalContext<'a> {
class_defs: Vec::new(),
parametric_defs: Vec::new(),
var_defs: Vec::new(),
fn_table: HashMap::new(),
sym_table,
};
}
@ -80,11 +88,12 @@ impl<'a> GlobalContext<'a> {
);
self.class_defs.push(def);
}
pub fn add_parametric(&mut self, def: ParametricDef<'a>) {
let params = def
.params
.iter()
.map(|&v| Type::TypeVariable(v).into())
.map(|&v| Rc::new(Type::TypeVariable(v)))
.collect();
self.sym_table.insert(
def.base.name,
@ -105,6 +114,14 @@ impl<'a> GlobalContext<'a> {
self.var_defs.push(def);
}
pub fn add_fn(&'a mut self, name: &'a str, def: FnDef) {
self.fn_table.insert(name, def);
}
pub fn get_fn(&self, name: &str) -> Option<&FnDef> {
self.fn_table.get(name)
}
pub fn get_primitive_mut(&mut self, id: PrimitiveId) -> &mut TypeDef<'a> {
self.primitive_defs.get_mut(id.0).unwrap()
}
@ -144,9 +161,9 @@ impl<'a> GlobalContext<'a> {
}
impl Type {
pub fn subst(&self, map: &HashMap<VariableId, Type>) -> Type {
pub fn subst(&self, map: &HashMap<VariableId, Rc<Type>>) -> Type {
match self {
Type::TypeVariable(id) => map.get(id).unwrap_or(self).clone(),
Type::TypeVariable(id) => map.get(id).map(|v| v.as_ref()).unwrap_or(self).clone(),
Type::ParametricType(id, params) => Type::ParametricType(
*id,
params
@ -158,9 +175,9 @@ impl Type {
}
}
pub fn inv_subst(&self, map: &Vec<(Type, Type)>) -> Type {
pub fn inv_subst(&self, map: &[(Rc<Type>, Rc<Type>)]) -> Rc<Type> {
for (from, to) in map.iter() {
if self == from {
if self == from.as_ref() {
return to.clone();
}
}
@ -173,16 +190,16 @@ impl Type {
.collect(),
),
_ => self.clone(),
}
}.into()
}
pub fn get_subst(&self, ctx: &GlobalContext) -> HashMap<VariableId, Type> {
pub fn get_subst(&self, ctx: &GlobalContext) -> HashMap<VariableId, Rc<Type>> {
match self {
Type::ParametricType(id, params) => {
let vars = &ctx.get_parametric(*id).params;
vars.iter()
.zip(params)
.map(|(v, p)| (*v, p.as_ref().clone()))
.map(|(v, p)| (*v, p.as_ref().clone().into()))
.collect()
}
// if this proves to be slow, we can use option type