forked from M-Labs/nac3
1
0
Fork 0

refactor for HM style inference...

This commit is contained in:
pca006132 2021-06-30 16:28:18 +08:00
parent 52a82e8a39
commit 2985b88351
8 changed files with 335 additions and 1025 deletions

View File

@ -0,0 +1,163 @@
use std::collections::HashMap;
use super::primitives::get_var;
use super::symbol_resolver::*;
use super::typedef::*;
use rustpython_parser::ast::Location;
/// Structure for storing top-level type definitions.
/// Used for collecting type signature from source code.
/// Can be converted to `InferenceContext` for type inference in functions.
#[derive(Clone)]
pub struct GlobalContext<'a> {
/// List of type definitions.
pub type_defs: Vec<TypeDef<'a>>,
/// List of type variable definitions.
pub var_defs: Vec<VarDef<'a>>,
}
impl<'a> GlobalContext<'a> {
pub fn new(type_defs: Vec<TypeDef<'a>>) -> GlobalContext {
GlobalContext {
type_defs,
var_defs: Vec::new(),
}
}
pub fn add_type(&mut self, def: TypeDef<'a>) -> TypeId {
self.type_defs.push(def);
TypeId(self.type_defs.len() - 1)
}
pub fn add_variable(&mut self, def: VarDef<'a>) -> VariableId {
self.var_defs.push(def);
VariableId(self.var_defs.len() - 1)
}
pub fn get_type_def_mut(&mut self, id: TypeId) -> &mut TypeDef<'a> {
self.type_defs.get_mut(id.0).unwrap()
}
pub fn get_type_def(&self, id: TypeId) -> &TypeDef {
self.type_defs.get(id.0).unwrap()
}
pub fn get_var_def(&self, id: VariableId) -> &VarDef {
self.var_defs.get(id.0).unwrap()
}
pub fn get_var_count(&self) -> usize {
self.var_defs.len()
}
}
pub struct InferenceContext<'a> {
// a: (i, x) means that a.i = x
pub fields_assignment: HashMap<VariableId, Vec<(&'a str, VariableId, Location)>>,
pub constraints: Vec<(Type, Type)>,
global: GlobalContext<'a>,
resolver: Box<dyn SymbolResolver>,
local_identifiers: HashMap<&'a str, Type>,
local_variables: Vec<VarDef<'a>>,
fresh_var_id: usize,
}
impl<'a> InferenceContext<'a> {
pub fn new(
global: GlobalContext<'a>,
resolver: Box<dyn SymbolResolver>,
) -> InferenceContext<'a> {
let id = global.get_var_count();
InferenceContext {
global,
fields_assignment: HashMap::new(),
constraints: Vec::new(),
resolver,
local_identifiers: HashMap::new(),
local_variables: Vec::new(),
fresh_var_id: id,
}
}
fn get_fresh_var(&mut self) -> VariableId {
self.local_variables.push(VarDef {
name: None,
bound: Vec::new(),
});
let id = self.fresh_var_id;
self.fresh_var_id += 1;
VariableId(id)
}
pub fn assign_identifier(&mut self, identifier: &'a str) -> Type {
if let Some(t) = self.local_identifiers.get(identifier) {
t.clone()
} else if let Some(SymbolType::Identifier(t)) = self.resolver.get_symbol_type(identifier) {
t
} else {
get_var(self.get_fresh_var())
}
}
pub fn get_identifier_type(&self, identifier: &'a str) -> Result<Type, String> {
if let Some(t) = self.local_identifiers.get(identifier) {
Ok(t.clone())
} else if let Some(SymbolType::Identifier(t)) = self.resolver.get_symbol_type(identifier) {
Ok(t)
} else {
Err("unbounded identifier".into())
}
}
pub fn get_attribute_type(
&mut self,
expr: Type,
identifier: &'a str,
location: Location,
) -> Result<Type, String> {
match expr.as_ref() {
TypeEnum::TypeVariable(id) => {
if !self.fields_assignment.contains_key(id) {
self.fields_assignment.insert(*id, Vec::new());
}
let var_id = VariableId(self.fresh_var_id);
let entry = self.fields_assignment.get_mut(&id).unwrap();
for (attr, t, _) in entry.iter() {
if *attr == identifier {
return Ok(get_var(*t));
}
}
entry.push((identifier, var_id, location));
self.local_variables.push(VarDef {
name: None,
bound: Vec::new(),
});
self.fresh_var_id += 1;
Ok(get_var(var_id))
}
TypeEnum::ClassType(id, params) => {
let type_def = self.global.get_type_def(*id);
let field = type_def
.base
.fields
.get(identifier)
.map_or_else(|| Err("no such field".to_owned()), |v| Ok(v))?;
// function and tuple can have 0 type variables but with type parameters
// we require other types have the same number of type variables and type
// parameters in order to build a mapping
assert!(type_def.params.len() == 0 || type_def.params.len() == params.len());
let map = type_def
.params
.clone()
.into_iter()
.zip(params.clone().into_iter())
.collect();
Ok(field.subst(&map))
}
}
}
pub fn get_type_def(&self, id: TypeId) -> &TypeDef {
self.global.get_type_def(id)
}
}

View File

@ -1,109 +0,0 @@
use super::super::typedef::*;
use std::collections::HashMap;
use std::rc::Rc;
/// Structure for storing top-level type definitions.
/// Used for collecting type signature from source code.
/// Can be converted to `InferenceContext` for type inference in functions.
pub struct GlobalContext<'a> {
/// List of primitive definitions.
pub(super) primitive_defs: Vec<TypeDef<'a>>,
/// List of class definitions.
pub(super) class_defs: Vec<ClassDef<'a>>,
/// List of parametric type definitions.
pub(super) parametric_defs: Vec<ParametricDef<'a>>,
/// List of type variable definitions.
pub(super) var_defs: Vec<VarDef<'a>>,
/// Function name to signature mapping.
pub(super) fn_table: HashMap<&'a str, FnDef>,
primitives: Vec<Type>,
variables: Vec<Type>,
}
impl<'a> GlobalContext<'a> {
pub fn new(primitive_defs: Vec<TypeDef<'a>>) -> GlobalContext {
let mut primitives = Vec::new();
for (i, t) in primitive_defs.iter().enumerate() {
primitives.push(TypeEnum::PrimitiveType(PrimitiveId(i)).into());
}
GlobalContext {
primitive_defs,
class_defs: Vec::new(),
parametric_defs: Vec::new(),
var_defs: Vec::new(),
fn_table: HashMap::new(),
primitives,
variables: Vec::new(),
}
}
pub fn add_class(&mut self, def: ClassDef<'a>) -> ClassId {
self.class_defs.push(def);
ClassId(self.class_defs.len() - 1)
}
pub fn add_parametric(&mut self, def: ParametricDef<'a>) -> ParamId {
self.parametric_defs.push(def);
ParamId(self.parametric_defs.len() - 1)
}
pub fn add_variable(&mut self, def: VarDef<'a>) -> VariableId {
self.add_variable_private(def)
}
pub fn add_variable_private(&mut self, def: VarDef<'a>) -> VariableId {
self.var_defs.push(def);
self.variables
.push(TypeEnum::TypeVariable(VariableId(self.var_defs.len() - 1)).into());
VariableId(self.var_defs.len() - 1)
}
pub fn add_fn(&mut self, name: &'a str, def: FnDef) {
self.fn_table.insert(name, def);
}
pub fn get_fn_def(&self, name: &str) -> Option<&FnDef> {
self.fn_table.get(name)
}
pub fn get_primitive_def_mut(&mut self, id: PrimitiveId) -> &mut TypeDef<'a> {
self.primitive_defs.get_mut(id.0).unwrap()
}
pub fn get_primitive_def(&self, id: PrimitiveId) -> &TypeDef {
self.primitive_defs.get(id.0).unwrap()
}
pub fn get_class_def_mut(&mut self, id: ClassId) -> &mut ClassDef<'a> {
self.class_defs.get_mut(id.0).unwrap()
}
pub fn get_class_def(&self, id: ClassId) -> &ClassDef {
self.class_defs.get(id.0).unwrap()
}
pub fn get_parametric_def_mut(&mut self, id: ParamId) -> &mut ParametricDef<'a> {
self.parametric_defs.get_mut(id.0).unwrap()
}
pub fn get_parametric_def(&self, id: ParamId) -> &ParametricDef {
self.parametric_defs.get(id.0).unwrap()
}
pub fn get_variable_def_mut(&mut self, id: VariableId) -> &mut VarDef<'a> {
self.var_defs.get_mut(id.0).unwrap()
}
pub fn get_variable_def(&self, id: VariableId) -> &VarDef {
self.var_defs.get(id.0).unwrap()
}
pub fn get_primitive(&self, id: PrimitiveId) -> Type {
self.primitives.get(id.0).unwrap().clone()
}
pub fn get_variable(&self, id: VariableId) -> Type {
self.variables.get(id.0).unwrap().clone()
}
}

View File

@ -1,202 +0,0 @@
use super::super::location::{FileID, Location};
use super::super::symbol_resolver::*;
use super::super::typedef::*;
use super::GlobalContext;
use rustpython_parser::ast;
use std::boxed::Box;
use std::collections::HashMap;
struct ContextStack<'a> {
/// stack level, starts from 0
level: u32,
/// stack of symbol definitions containing (name, level) where `level` is the smallest level
/// where the name is assigned a value
sym_def: Vec<(&'a str, u32)>,
}
pub struct InferenceContext<'a> {
/// global context
global: GlobalContext<'a>,
/// per source symbol resolver
resolver: Box<dyn SymbolResolver>,
/// File ID
file: FileID,
/// identifier to (type, readable) mapping.
/// an identifier might be defined earlier but has no value (for some code path), thus not
/// readable.
sym_table: HashMap<&'a str, (Type, bool, Location)>,
/// stack
stack: ContextStack<'a>,
}
// non-trivial implementations here
impl<'a> InferenceContext<'a> {
pub fn new(
global: GlobalContext,
resolver: Box<dyn SymbolResolver>,
file: FileID,
) -> InferenceContext {
InferenceContext {
global,
resolver,
file,
sym_table: HashMap::new(),
stack: ContextStack {
level: 0,
sym_def: Vec::new(),
},
}
}
/// execute the function with new scope.
/// variable assignment would be limited within the scope (not readable outside), and type
/// returns the list of variables assigned within the scope, and the result of the function
pub fn with_scope<F, R>(&mut self, f: F) -> (Vec<(&'a str, Type, Location)>, R)
where
F: FnOnce(&mut Self) -> R,
{
self.stack.level += 1;
let result = f(self);
self.stack.level -= 1;
let mut poped_names = Vec::new();
while !self.stack.sym_def.is_empty() {
let (_, level) = self.stack.sym_def.last().unwrap();
if *level > self.stack.level {
let (name, _) = self.stack.sym_def.pop().unwrap();
let (t, b, l) = self.sym_table.get_mut(name).unwrap();
// set it to be unreadable
*b = false;
poped_names.push((name, t.clone(), *l));
} else {
break;
}
}
(poped_names, result)
}
/// assign a type to an identifier.
/// may return error if the identifier was defined but with different type
pub fn assign(&mut self, name: &'a str, ty: Type, loc: ast::Location) -> Result<Type, String> {
if let Some((t, x, _)) = self.sym_table.get_mut(name) {
if t == &ty {
if !*x {
self.stack.sym_def.push((name, self.stack.level));
}
*x = true;
Ok(ty)
} else {
Err("different types".into())
}
} else {
self.stack.sym_def.push((name, self.stack.level));
self.sym_table.insert(
name,
(ty.clone(), true, Location::CodeRange(self.file, loc)),
);
Ok(ty)
}
}
/// get the type of an identifier
/// may return error if the identifier is not defined, and cannot be resolved with the
/// resolution function.
pub fn resolve(&self, name: &str) -> Result<Type, String> {
if let Some((t, x, _)) = self.sym_table.get(name) {
if *x {
Ok(t.clone())
} else {
Err("may not be defined".into())
}
} else {
match self.resolver.get_symbol_type(name) {
Some(SymbolType::Identifier(t)) => Ok(t),
Some(SymbolType::TypeName(_)) => Err("is not a value".into()),
_ => Err("unbounded identifier".into()),
}
}
}
pub fn get_location(&self, name: &str) -> Option<Location> {
if let Some((_, _, l)) = self.sym_table.get(name) {
Some(*l)
} else {
self.resolver.get_symbol_location(name)
}
}
}
// trivial getters:
impl<'a> InferenceContext<'a> {
pub fn get_primitive(&self, id: PrimitiveId) -> Type {
TypeEnum::PrimitiveType(id).into()
}
pub fn get_variable(&self, id: VariableId) -> Type {
TypeEnum::TypeVariable(id).into()
}
pub fn get_fn_def(&self, name: &str) -> Option<&FnDef> {
self.global.fn_table.get(name)
}
pub fn get_primitive_def(&self, id: PrimitiveId) -> &TypeDef {
self.global.primitive_defs.get(id.0).unwrap()
}
pub fn get_class_def(&self, id: ClassId) -> &ClassDef {
self.global.class_defs.get(id.0).unwrap()
}
pub fn get_parametric_def(&self, id: ParamId) -> &ParametricDef {
self.global.parametric_defs.get(id.0).unwrap()
}
pub fn get_variable_def(&self, id: VariableId) -> &VarDef {
self.global.var_defs.get(id.0).unwrap()
}
pub fn get_type(&self, name: &str) -> Result<Type, String> {
match self.resolver.get_symbol_type(name) {
Some(SymbolType::TypeName(t)) => Ok(t),
Some(SymbolType::Identifier(_)) => Err("not a type".into()),
_ => Err("unbounded identifier".into()),
}
}
}
impl TypeEnum {
pub fn subst(&self, map: &HashMap<VariableId, Type>) -> TypeEnum {
match self {
TypeEnum::TypeVariable(id) => map.get(id).map(|v| v.as_ref()).unwrap_or(self).clone(),
TypeEnum::ParametricType(id, params) => TypeEnum::ParametricType(
*id,
params
.iter()
.map(|v| v.as_ref().subst(map).into())
.collect(),
),
_ => self.clone(),
}
}
pub fn get_subst(&self, ctx: &InferenceContext) -> HashMap<VariableId, Type> {
match self {
TypeEnum::ParametricType(id, params) => {
let vars = &ctx.get_parametric_def(*id).params;
vars.iter()
.zip(params)
.map(|(v, p)| (*v, p.as_ref().clone().into()))
.collect()
}
// if this proves to be slow, we can use option type
_ => HashMap::new(),
}
}
pub fn get_base<'b: 'a, 'a>(&'a self, ctx: &'b InferenceContext) -> Option<&'b TypeDef> {
match self {
TypeEnum::PrimitiveType(id) => Some(ctx.get_primitive_def(*id)),
TypeEnum::ClassType(id) | TypeEnum::VirtualClassType(id) => {
Some(&ctx.get_class_def(*id).base)
}
TypeEnum::ParametricType(id, _) => Some(&ctx.get_parametric_def(*id).base),
_ => None,
}
}
}

View File

@ -1,4 +0,0 @@
mod inference_context;
mod global_context;
pub use inference_context::InferenceContext;
pub use global_context::GlobalContext;

View File

@ -1,525 +0,0 @@
use super::context::InferenceContext;
use super::typedef::{TypeEnum::*, *};
use std::collections::HashMap;
fn find_subst(
ctx: &InferenceContext,
valuation: &Option<(VariableId, Type)>,
sub: &mut HashMap<VariableId, Type>,
mut a: Type,
mut b: Type,
) -> Result<(), String> {
// TODO: fix error messages later
if let TypeVariable(id) = a.as_ref() {
if let Some((assumption_id, t)) = valuation {
if assumption_id == id {
a = t.clone();
}
}
}
let mut substituted = false;
if let TypeVariable(id) = b.as_ref() {
if let Some(c) = sub.get(&id) {
b = c.clone();
substituted = true;
}
}
match (a.as_ref(), b.as_ref()) {
(BotType, _) => Ok(()),
(TypeVariable(id_a), TypeVariable(id_b)) => {
if substituted {
return if id_a == id_b {
Ok(())
} else {
Err("different variables".to_string())
};
}
let v_a = ctx.get_variable_def(*id_a);
let v_b = ctx.get_variable_def(*id_b);
if !v_b.bound.is_empty() {
if v_a.bound.is_empty() {
return Err("unbounded a".to_string());
} else {
let diff: Vec<_> = v_a
.bound
.iter()
.filter(|x| !v_b.bound.contains(x))
.collect();
if !diff.is_empty() {
return Err("different domain".to_string());
}
}
}
sub.insert(*id_b, a.clone());
Ok(())
}
(TypeVariable(id_a), _) => {
let v_a = ctx.get_variable_def(*id_a);
if v_a.bound.len() == 1 && v_a.bound[0].as_ref() == b.as_ref() {
Ok(())
} else {
Err("different domain".to_string())
}
}
(_, TypeVariable(id_b)) => {
let v_b = ctx.get_variable_def(*id_b);
if v_b.bound.is_empty() || v_b.bound.contains(&a) {
sub.insert(*id_b, a.clone());
Ok(())
} else {
Err("different domain".to_string())
}
}
(_, VirtualClassType(id_b)) => {
let mut parents;
match a.as_ref() {
ClassType(id_a) => {
parents = [*id_a].to_vec();
}
VirtualClassType(id_a) => {
parents = [*id_a].to_vec();
}
_ => {
return Err("cannot substitute non-class type into virtual class".to_string());
}
};
while !parents.is_empty() {
if *id_b == parents[0] {
return Ok(());
}
let c = ctx.get_class_def(parents.remove(0));
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())
} else {
for (x, y) in param_a.iter().zip(param_b.iter()) {
find_subst(ctx, valuation, sub, x.clone(), y.clone())?;
}
Ok(())
}
}
(_, _) => {
if a == b {
Ok(())
} else {
Err("not equal".to_string())
}
}
}
}
fn resolve_call_rec(
ctx: &InferenceContext,
valuation: &Option<(VariableId, Type)>,
obj: Option<Type>,
func: &str,
args: &[Type],
) -> Result<Option<Type>, String> {
let mut subst = obj
.as_ref()
.map(|v| v.get_subst(ctx))
.unwrap_or_else(HashMap::new);
let fun = match &obj {
Some(obj) => {
let base = match obj.as_ref() {
PrimitiveType(id) => &ctx.get_primitive_def(*id),
ClassType(id) | VirtualClassType(id) => &ctx.get_class_def(*id).base,
ParametricType(id, _) => &ctx.get_parametric_def(*id).base,
_ => return Err("not supported".to_string()),
};
base.methods.get(func)
}
None => ctx.get_fn_def(func),
}
.ok_or_else(|| "no such function".to_string())?;
if args.len() != fun.args.len() {
return Err("incorrect parameter number".to_string());
}
for (a, b) in args.iter().zip(fun.args.iter()) {
find_subst(ctx, valuation, &mut subst, a.clone(), b.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()
}
}))
}
pub fn resolve_call(
ctx: &InferenceContext,
obj: Option<Type>,
func: &str,
args: &[Type],
) -> Result<Option<Type>, String> {
resolve_call_rec(ctx, &None, obj, func, args)
}
#[cfg(test)]
mod tests {
use super::*;
use super::super::context::GlobalContext;
use super::super::primitives::*;
use std::rc::Rc;
fn get_inference_context(ctx: GlobalContext) -> InferenceContext {
InferenceContext::new(ctx, Box::new(|_| Err("unbounded identifier".into())))
}
#[test]
fn test_simple_generic() {
let mut ctx = basic_ctx();
let v1 = ctx.add_variable(VarDef {
name: "V1",
bound: vec![ctx.get_primitive(INT32_TYPE), ctx.get_primitive(FLOAT_TYPE)],
});
let v1 = ctx.get_variable(v1);
let v2 = ctx.add_variable(VarDef {
name: "V2",
bound: vec![
ctx.get_primitive(BOOL_TYPE),
ctx.get_primitive(INT32_TYPE),
ctx.get_primitive(FLOAT_TYPE),
],
});
let v2 = ctx.get_variable(v2);
let ctx = get_inference_context(ctx);
assert_eq!(
resolve_call(&ctx, None, "int32", &[ctx.get_primitive(FLOAT_TYPE)]),
Ok(Some(ctx.get_primitive(INT32_TYPE)))
);
assert_eq!(
resolve_call(&ctx, None, "int32", &[ctx.get_primitive(INT32_TYPE)],),
Ok(Some(ctx.get_primitive(INT32_TYPE)))
);
assert_eq!(
resolve_call(&ctx, None, "float", &[ctx.get_primitive(INT32_TYPE)]),
Ok(Some(ctx.get_primitive(FLOAT_TYPE)))
);
assert_eq!(
resolve_call(&ctx, None, "float", &[ctx.get_primitive(BOOL_TYPE)]),
Err("different domain".to_string())
);
assert_eq!(
resolve_call(&ctx, None, "float", &[]),
Err("incorrect parameter number".to_string())
);
assert_eq!(
resolve_call(&ctx, None, "float", &[v1]),
Ok(Some(ctx.get_primitive(FLOAT_TYPE)))
);
assert_eq!(
resolve_call(&ctx, None, "float", &[v2]),
Err("different domain".to_string())
);
}
#[test]
fn test_methods() {
let mut ctx = basic_ctx();
let v0 = ctx.add_variable(VarDef {
name: "V0",
bound: vec![],
});
let v0 = ctx.get_variable(v0);
let int32 = ctx.get_primitive(INT32_TYPE);
let int64 = ctx.get_primitive(INT64_TYPE);
let ctx = get_inference_context(ctx);
// simple cases
assert_eq!(
resolve_call(&ctx, Some(int32.clone()), "__add__", &[int32.clone()]),
Ok(Some(int32.clone()))
);
assert_ne!(
resolve_call(&ctx, Some(int32.clone()), "__add__", &[int32.clone()]),
Ok(Some(int64.clone()))
);
assert_eq!(
resolve_call(&ctx, Some(int32), "__add__", &[int64]),
Err("not equal".to_string())
);
// with type variables
assert_eq!(
resolve_call(&ctx, Some(v0.clone()), "__add__", &[v0.clone()]),
Err("not supported".into())
);
}
#[test]
fn test_multi_generic() {
let mut ctx = basic_ctx();
let v0 = ctx.add_variable(VarDef {
name: "V0",
bound: vec![],
});
let v0 = ctx.get_variable(v0);
let v1 = ctx.add_variable(VarDef {
name: "V1",
bound: vec![],
});
let v1 = ctx.get_variable(v1);
let v2 = ctx.add_variable(VarDef {
name: "V2",
bound: vec![],
});
let v2 = ctx.get_variable(v2);
let v3 = ctx.add_variable(VarDef {
name: "V3",
bound: vec![],
});
let v3 = ctx.get_variable(v3);
ctx.add_fn(
"foo",
FnDef {
args: vec![v0.clone(), v0.clone(), v1.clone()],
result: Some(v0.clone()),
},
);
ctx.add_fn(
"foo1",
FnDef {
args: vec![ParametricType(TUPLE_TYPE, vec![v0.clone(), v0.clone(), v1]).into()],
result: Some(v0),
},
);
let ctx = get_inference_context(ctx);
assert_eq!(
resolve_call(&ctx, None, "foo", &[v2.clone(), v2.clone(), v2.clone()]),
Ok(Some(v2.clone()))
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[v2.clone(), v2.clone(), v3.clone()]),
Ok(Some(v2.clone()))
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[v2.clone(), v3.clone(), v3.clone()]),
Err("different variables".to_string())
);
assert_eq!(
resolve_call(
&ctx,
None,
"foo1",
&[ParametricType(TUPLE_TYPE, vec![v2.clone(), v2.clone(), v2.clone()]).into()]
),
Ok(Some(v2.clone()))
);
assert_eq!(
resolve_call(
&ctx,
None,
"foo1",
&[ParametricType(TUPLE_TYPE, vec![v2.clone(), v2.clone(), v3.clone()]).into()]
),
Ok(Some(v2.clone()))
);
assert_eq!(
resolve_call(
&ctx,
None,
"foo1",
&[ParametricType(TUPLE_TYPE, vec![v2, v3.clone(), v3]).into()]
),
Err("different variables".to_string())
);
}
#[test]
fn test_class_generics() {
let mut ctx = basic_ctx();
let list = ctx.get_parametric_def_mut(LIST_TYPE);
let t = Rc::new(TypeVariable(list.params[0]));
list.base.methods.insert(
"head",
FnDef {
args: vec![],
result: Some(t.clone()),
},
);
list.base.methods.insert(
"append",
FnDef {
args: vec![t],
result: None,
},
);
let v0 = ctx.add_variable(VarDef {
name: "V0",
bound: vec![],
});
let v0 = ctx.get_variable(v0);
let v1 = ctx.add_variable(VarDef {
name: "V1",
bound: vec![],
});
let v1 = ctx.get_variable(v1);
let ctx = get_inference_context(ctx);
assert_eq!(
resolve_call(
&ctx,
Some(ParametricType(LIST_TYPE, vec![v0.clone()]).into()),
"head",
&[]
),
Ok(Some(v0.clone()))
);
assert_eq!(
resolve_call(
&ctx,
Some(ParametricType(LIST_TYPE, vec![v0.clone()]).into()),
"append",
&[v0.clone()]
),
Ok(None)
);
assert_eq!(
resolve_call(
&ctx,
Some(ParametricType(LIST_TYPE, vec![v0]).into()),
"append",
&[v1]
),
Err("different variables".to_string())
);
}
#[test]
fn test_virtual_class() {
let mut ctx = basic_ctx();
let foo = ctx.add_class(ClassDef {
base: TypeDef {
name: "Foo",
methods: HashMap::new(),
fields: HashMap::new(),
},
parents: vec![],
});
let foo1 = ctx.add_class(ClassDef {
base: TypeDef {
name: "Foo1",
methods: HashMap::new(),
fields: HashMap::new(),
},
parents: vec![foo],
});
let foo2 = ctx.add_class(ClassDef {
base: TypeDef {
name: "Foo2",
methods: HashMap::new(),
fields: HashMap::new(),
},
parents: vec![foo1],
});
let bar = ctx.add_class(ClassDef {
base: TypeDef {
name: "bar",
methods: HashMap::new(),
fields: HashMap::new(),
},
parents: vec![],
});
ctx.add_fn(
"foo",
FnDef {
args: vec![VirtualClassType(foo).into()],
result: None,
},
);
ctx.add_fn(
"foo1",
FnDef {
args: vec![VirtualClassType(foo1).into()],
result: None,
},
);
let ctx = get_inference_context(ctx);
assert_eq!(
resolve_call(&ctx, None, "foo", &[ClassType(foo).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[ClassType(foo1).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[ClassType(foo2).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[ClassType(bar).into()]),
Err("not subtype".to_string())
);
assert_eq!(
resolve_call(&ctx, None, "foo1", &[ClassType(foo1).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo1", &[ClassType(foo2).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo1", &[ClassType(foo).into()]),
Err("not subtype".to_string())
);
// virtual class substitution
assert_eq!(
resolve_call(&ctx, None, "foo", &[VirtualClassType(foo).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[VirtualClassType(foo1).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[VirtualClassType(foo2).into()]),
Ok(None)
);
assert_eq!(
resolve_call(&ctx, None, "foo", &[VirtualClassType(bar).into()]),
Err("not subtype".to_string())
);
}
}

View File

@ -1,7 +1,6 @@
pub mod context; mod context;
pub mod inference_core;
pub mod location; pub mod location;
pub mod magic_methods; mod magic_methods;
pub mod primitives; mod primitives;
pub mod symbol_resolver; pub mod symbol_resolver;
pub mod typedef; pub mod typedef;

View File

@ -1,184 +1,168 @@
use super::typedef::{TypeEnum::*, *};
use super::context::*; use super::context::*;
use super::typedef::{TypeEnum::*, *};
use std::collections::HashMap; use std::collections::HashMap;
use std::rc::Rc;
pub const TUPLE_TYPE: ParamId = ParamId(0); pub const FUNC_TYPE: TypeId = TypeId(0);
pub const LIST_TYPE: ParamId = ParamId(1); pub const TUPLE_TYPE: TypeId = TypeId(1);
pub const LIST_TYPE: TypeId = TypeId(2);
pub const VIRTUAL_TYPE: TypeId = TypeId(3);
pub const NONE_TYPE: TypeId = TypeId(4);
pub const BOOL_TYPE: PrimitiveId = PrimitiveId(0); pub const BOOL_TYPE: TypeId = TypeId(5);
pub const INT32_TYPE: PrimitiveId = PrimitiveId(1); pub const INT32_TYPE: TypeId = TypeId(6);
pub const INT64_TYPE: PrimitiveId = PrimitiveId(2); pub const INT64_TYPE: TypeId = TypeId(7);
pub const FLOAT_TYPE: PrimitiveId = PrimitiveId(3); pub const FLOAT_TYPE: TypeId = TypeId(8);
fn impl_math(def: &mut TypeDef, ty: &Type) { fn primitive(base: BaseDef) -> TypeDef {
let result = Some(ty.clone()); TypeDef {
let fun = FnDef { base,
args: vec![ty.clone()], parents: vec![],
result: result.clone(), params: vec![],
}; }
def.methods.insert("__add__", fun.clone());
def.methods.insert("__sub__", fun.clone());
def.methods.insert("__mul__", fun.clone());
def.methods.insert(
"__neg__",
FnDef {
args: vec![],
result,
},
);
def.methods.insert(
"__truediv__",
FnDef {
args: vec![ty.clone()],
result: Some(PrimitiveType(FLOAT_TYPE).into()),
},
);
def.methods.insert("__floordiv__", fun.clone());
def.methods.insert("__mod__", fun.clone());
def.methods.insert("__pow__", fun);
} }
fn impl_bits(def: &mut TypeDef, ty: &Type) { pub fn get_fn(from: Type, to: Type) -> Type {
let result = Some(ty.clone()); Rc::new(ClassType(FUNC_TYPE, vec![from, to]))
let fun = FnDef {
args: vec![PrimitiveType(INT32_TYPE).into()],
result,
};
def.methods.insert("__lshift__", fun.clone());
def.methods.insert("__rshift__", fun);
def.methods.insert(
"__xor__",
FnDef {
args: vec![ty.clone()],
result: Some(ty.clone()),
},
);
} }
fn impl_eq(def: &mut TypeDef, ty: &Type) { pub fn get_tuple(types: &[Type]) -> Type {
let fun = FnDef { Rc::new(ClassType(TUPLE_TYPE, types.to_vec()))
args: vec![ty.clone()],
result: Some(PrimitiveType(BOOL_TYPE).into()),
};
def.methods.insert("__eq__", fun.clone());
def.methods.insert("__ne__", fun);
} }
fn impl_order(def: &mut TypeDef, ty: &Type) { pub fn get_list(t: Type) -> Type {
let fun = FnDef { Rc::new(ClassType(LIST_TYPE, vec![t]))
args: vec![ty.clone()], }
result: Some(PrimitiveType(BOOL_TYPE).into()),
};
def.methods.insert("__lt__", fun.clone()); pub fn get_virtual(t: Type) -> Type {
def.methods.insert("__gt__", fun.clone()); Rc::new(ClassType(VIRTUAL_TYPE, vec![t]))
def.methods.insert("__le__", fun.clone()); }
def.methods.insert("__ge__", fun);
pub fn get_none() -> Type {
Rc::new(ClassType(NONE_TYPE, Vec::new()))
}
pub fn get_bool() -> Type {
Rc::new(ClassType(BOOL_TYPE, Vec::new()))
}
pub fn get_int32() -> Type {
Rc::new(ClassType(INT32_TYPE, Vec::new()))
}
pub fn get_int64() -> Type {
Rc::new(ClassType(INT64_TYPE, Vec::new()))
}
pub fn get_float() -> Type {
Rc::new(ClassType(FLOAT_TYPE, Vec::new()))
}
pub fn get_var(id: VariableId) -> Type {
Rc::new(TypeVariable(id))
}
fn impl_math(def: &mut BaseDef, ty: &Type) {
let fun = get_fn(ty.clone(), ty.clone());
def.fields.insert("__add__", fun.clone());
def.fields.insert("__sub__", fun.clone());
def.fields.insert("__mul__", fun.clone());
def.fields.insert("__neg__", get_fn(get_none(), ty.clone()));
def.fields
.insert("__truediv__", get_fn(ty.clone(), get_float()));
def.fields.insert("__floordiv__", fun.clone());
def.fields.insert("__mod__", fun.clone());
def.fields.insert("__pow__", fun);
}
fn impl_bits(def: &mut BaseDef, ty: &Type) {
let fun = get_fn(get_int32(), ty.clone());
def.fields.insert("__lshift__", fun.clone());
def.fields.insert("__rshift__", fun);
def.fields.insert("__xor__", get_fn(ty.clone(), ty.clone()));
}
fn impl_eq(def: &mut BaseDef, ty: &Type) {
let fun = get_fn(ty.clone(), get_bool());
def.fields.insert("__eq__", fun.clone());
def.fields.insert("__ne__", fun);
}
fn impl_order(def: &mut BaseDef, ty: &Type) {
let fun = get_fn(ty.clone(), get_bool());
def.fields.insert("__lt__", fun.clone());
def.fields.insert("__gt__", fun.clone());
def.fields.insert("__le__", fun.clone());
def.fields.insert("__ge__", fun);
} }
pub fn basic_ctx() -> GlobalContext<'static> { pub fn basic_ctx() -> GlobalContext<'static> {
let primitives = [ let mut ctx = GlobalContext::new(vec![
TypeDef { primitive(BaseDef {
name: "function",
fields: HashMap::new(),
}),
primitive(BaseDef {
name: "tuple",
fields: HashMap::new(),
}),
primitive(BaseDef {
name: "list",
fields: HashMap::new(),
}),
primitive(BaseDef {
name: "virtual",
fields: HashMap::new(),
}),
primitive(BaseDef {
name: "None",
fields: HashMap::new(),
}),
primitive(BaseDef {
name: "bool", name: "bool",
fields: HashMap::new(), fields: HashMap::new(),
methods: HashMap::new(), }),
}, primitive(BaseDef {
TypeDef {
name: "int32", name: "int32",
fields: HashMap::new(), fields: HashMap::new(),
methods: HashMap::new(), }),
}, primitive(BaseDef {
TypeDef {
name: "int64", name: "int64",
fields: HashMap::new(), fields: HashMap::new(),
methods: HashMap::new(), }),
}, primitive(BaseDef {
TypeDef {
name: "float", name: "float",
fields: HashMap::new(), fields: HashMap::new(),
methods: HashMap::new(), }),
}, ]);
]
.to_vec();
let mut ctx = GlobalContext::new(primitives);
let b = ctx.get_primitive(BOOL_TYPE); let t = ctx.add_variable(VarDef {
let b_def = ctx.get_primitive_def_mut(BOOL_TYPE); name: Some("T"),
impl_eq(b_def, &b); bound: vec![],
let int32 = ctx.get_primitive(INT32_TYPE); });
let int32_def = ctx.get_primitive_def_mut(INT32_TYPE); ctx.get_type_def_mut(LIST_TYPE).params.push(t);
let b_def = ctx.get_type_def_mut(BOOL_TYPE);
impl_eq(&mut b_def.base, &get_bool());
let int32 = get_int32();
let int32_def = &mut ctx.get_type_def_mut(INT32_TYPE).base;
impl_math(int32_def, &int32); impl_math(int32_def, &int32);
impl_bits(int32_def, &int32); impl_bits(int32_def, &int32);
impl_order(int32_def, &int32); impl_order(int32_def, &int32);
impl_eq(int32_def, &int32); impl_eq(int32_def, &int32);
let int64 = ctx.get_primitive(INT64_TYPE); let int64 = get_int64();
let int64_def = ctx.get_primitive_def_mut(INT64_TYPE); let int64_def = &mut ctx.get_type_def_mut(INT64_TYPE).base;
impl_math(int64_def, &int64); impl_math(int64_def, &int64);
impl_bits(int64_def, &int64); impl_bits(int64_def, &int64);
impl_order(int64_def, &int64); impl_order(int64_def, &int64);
impl_eq(int64_def, &int64); impl_eq(int64_def, &int64);
let float = ctx.get_primitive(FLOAT_TYPE); let float = get_float();
let float_def = ctx.get_primitive_def_mut(FLOAT_TYPE); let float_def = &mut ctx.get_type_def_mut(FLOAT_TYPE).base;
impl_math(float_def, &float); impl_math(float_def, &float);
impl_order(float_def, &float); impl_order(float_def, &float);
impl_eq(float_def, &float); impl_eq(float_def, &float);
let t = ctx.add_variable_private(VarDef {
name: "T",
bound: vec![],
});
ctx.add_parametric(ParametricDef {
base: TypeDef {
name: "tuple",
fields: HashMap::new(),
methods: HashMap::new(),
},
// we have nothing for tuple, so no param def
params: vec![],
});
ctx.add_parametric(ParametricDef {
base: TypeDef {
name: "list",
fields: HashMap::new(),
methods: HashMap::new(),
},
params: vec![t],
});
let i = ctx.add_variable_private(VarDef {
name: "I",
bound: vec![
PrimitiveType(INT32_TYPE).into(),
PrimitiveType(INT64_TYPE).into(),
PrimitiveType(FLOAT_TYPE).into(),
],
});
let args = vec![TypeVariable(i).into()];
ctx.add_fn(
"int32",
FnDef {
args: args.clone(),
result: Some(PrimitiveType(INT32_TYPE).into()),
},
);
ctx.add_fn(
"int64",
FnDef {
args: args.clone(),
result: Some(PrimitiveType(INT64_TYPE).into()),
},
);
ctx.add_fn(
"float",
FnDef {
args,
result: Some(PrimitiveType(FLOAT_TYPE).into()),
},
);
ctx ctx
} }

View File

@ -1,60 +1,64 @@
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::HashSet;
use std::rc::Rc; use std::rc::Rc;
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct PrimitiveId(pub(crate) usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct ClassId(pub(crate) usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct ParamId(pub(crate) usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)] #[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct VariableId(pub(crate) usize); pub struct VariableId(pub(crate) usize);
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
pub struct TypeId(pub(crate) usize);
#[derive(PartialEq, Eq, Clone, Hash, Debug)] #[derive(PartialEq, Eq, Clone, Hash, Debug)]
pub enum TypeEnum { pub enum TypeEnum {
BotType, ClassType(TypeId, Vec<Rc<TypeEnum>>),
SelfType,
PrimitiveType(PrimitiveId),
ClassType(ClassId),
VirtualClassType(ClassId),
ParametricType(ParamId, Vec<Rc<TypeEnum>>),
TypeVariable(VariableId), TypeVariable(VariableId),
} }
pub type Type = Rc<TypeEnum>; pub type Type = Rc<TypeEnum>;
#[derive(Clone)] #[derive(Clone)]
pub struct FnDef { pub struct BaseDef<'a> {
// we assume methods first argument to be SelfType, pub name: &'a str,
// so the first argument is not contained here pub fields: HashMap<&'a str, Type>,
pub args: Vec<Type>,
pub result: Option<Type>,
} }
#[derive(Clone)] #[derive(Clone)]
pub struct TypeDef<'a> { pub struct TypeDef<'a> {
pub name: &'a str, pub base: BaseDef<'a>,
pub fields: HashMap<&'a str, Type>, pub parents: Vec<TypeId>,
pub methods: HashMap<&'a str, FnDef>,
}
#[derive(Clone)]
pub struct ClassDef<'a> {
pub base: TypeDef<'a>,
pub parents: Vec<ClassId>,
}
#[derive(Clone)]
pub struct ParametricDef<'a> {
pub base: TypeDef<'a>,
pub params: Vec<VariableId>, pub params: Vec<VariableId>,
} }
#[derive(Clone)] #[derive(Clone)]
pub struct VarDef<'a> { pub struct VarDef<'a> {
pub name: &'a str, pub name: Option<&'a str>,
pub bound: Vec<Type>, pub bound: Vec<Type>,
} }
impl TypeEnum {
pub fn get_vars(&self, vars: &mut HashSet<VariableId>) {
match self {
TypeEnum::TypeVariable(id) => {
vars.insert(*id);
}
TypeEnum::ClassType(_, params) => {
for t in params.iter() {
t.get_vars(vars)
}
}
}
}
pub fn subst(&self, map: &HashMap<VariableId, Type>) -> Type {
match self {
TypeEnum::TypeVariable(id) => map
.get(id)
.cloned()
.unwrap_or_else(|| Rc::new(self.clone())),
TypeEnum::ClassType(id, params) => Rc::new(TypeEnum::ClassType(
*id,
params.iter().map(|t| t.subst(map)).collect(),
)),
}
}
}