forked from M-Labs/nac3
1
0
Fork 0

expression partially done, need review

This commit is contained in:
CrescentonC 2021-07-06 12:23:30 +08:00
parent 52a82e8a39
commit b161c026bc
3 changed files with 254 additions and 1 deletions

View File

@ -22,7 +22,7 @@ pub struct InferenceContext<'a> {
/// File ID /// File ID
file: FileID, file: FileID,
/// identifier to (type, readable) mapping. /// identifier to (type, readable, location) mapping.
/// an identifier might be defined earlier but has no value (for some code path), thus not /// an identifier might be defined earlier but has no value (for some code path), thus not
/// readable. /// readable.
sym_table: HashMap<&'a str, (Type, bool, Location)>, sym_table: HashMap<&'a str, (Type, bool, Location)>,

View File

@ -0,0 +1,252 @@
use std::convert::TryInto;
use crate::typecheck::context::InferenceContext;
use crate::typecheck::typedef::{Type, TypeEnum};
use crate::typecheck::primitives;
use rustpython_parser::ast;
pub struct ExpressionTypeInferencer<'a> {
ctx: InferenceContext<'a>
}
impl<'a> ExpressionTypeInferencer<'a>{ // NOTE: add location here in the function parameter for better error message?
fn infer_constant_val(&mut self, constant: &ast::Constant) -> Result<Option<Type>, String> {
match constant {
ast::Constant::Bool(_) =>
Ok(Some(self.ctx.get_primitive(primitives::BOOL_TYPE))),
ast::Constant::Int(val) => {
let int32: Result<i32, _> = val.try_into();
let int64: Result<i64, _> = val.try_into();
if int32.is_ok() {
Ok(Some(self.ctx.get_primitive(primitives::INT32_TYPE)))
} else if int64.is_ok() {
Ok(Some(self.ctx.get_primitive(primitives::INT64_TYPE)))
} else {
Err("Integer out of bound".into())
}
},
ast::Constant::Float(_) =>
Ok(Some(self.ctx.get_primitive(primitives::FLOAT_TYPE))),
ast::Constant::Tuple(vals) => {
let result = vals
.into_iter()
.map(|x| self.infer_constant_val(x))
.collect::<Vec<_>>();
if result.iter().all(|x| x.is_ok()) {
Ok(Some(TypeEnum::ParametricType(
primitives::TUPLE_TYPE,
result
.into_iter()
.map(|x| x.unwrap().unwrap())
.collect::<Vec<_>>(),
).into()))
} else {
Err("Some elements in tuple cannot be typed".into())
}
}
_ => Err("not supported".into())
}
}
fn infer_list_val(&mut self, elts: &Vec<ast::Expr<Option<Type>>>) -> Result<Option<Type>, String> {
if elts.is_empty() {
Ok(Some(TypeEnum::ParametricType(primitives::LIST_TYPE, vec![TypeEnum::BotType.into()]).into()))
} else {
let types = elts
.into_iter()
.map(|x| &x.custom)
.collect::<Vec<_>>();
if types.iter().all(|x| x.is_some()) {
let head = types.iter().next().unwrap(); // here unwrap alone should be fine after the previous check
if types.iter().all(|x| x.eq(head)) {
Ok(Some(TypeEnum::ParametricType(primitives::LIST_TYPE, vec![(*head).clone().unwrap()]).into()))
} else {
Err("inhomogeneous list is not allowed".into())
}
} else {
Err("list elements must have some type".into())
}
}
}
}
// REVIEW: field custom: from None to Option<Type> or just Option<Type> ?
impl<'a> ast::fold::Fold<Option<Type>> for ExpressionTypeInferencer<'a> {
type TargetU = Option<Type>;
type Error = String;
fn map_user(&mut self, user: Option<Type>) -> Result<Self::TargetU, Self::Error> {
Ok(user)
}
fn fold_expr(&mut self, expr: ast::Expr<Option<Type>>) -> Result<ast::Expr<Self::TargetU>, Self::Error> {
let ast::Expr {location, custom: cus, node} = expr;
match node {
ast::ExprKind::Constant {value, kind} =>
Ok(ast::Expr {
location,
custom: self.infer_constant_val(&value)?,
node: ast::ExprKind::Constant {value, kind}
}),
ast::ExprKind::Name {id, ctx} =>
Ok(ast::Expr {
location,
custom: Some(self.ctx.resolve(&*id)?), // REVIEW: the conversion from String to &str is not sure
node: ast::ExprKind::Name {id, ctx}
}),
ast::ExprKind::List {elts, ctx} => {
let elts= elts
.into_iter()
.map(|x| self.fold_expr(x))
.collect::<Result<Vec<ast::Expr<Option<Type>>>, _>>()?; // elements inside the vector should now have type info
Ok(ast::Expr {
location,
custom: self.infer_list_val(&elts)?,
node: ast::ExprKind::List {elts, ctx}
})
}
_ =>
Ok(ast::Expr {location, custom: cus, node: node})
}
}
}
mod test {
use crate::typecheck::{symbol_resolver::SymbolResolver, typedef::*, symbol_resolver::*, location::*};
use rustpython_parser::ast::{self, Expr, fold::Fold};
use super::*;
fn new_ctx<'a>() -> ExpressionTypeInferencer<'a>{
struct S;
impl SymbolResolver for S {
fn get_symbol_location(&self, _str: &str) -> Option<Location> {
None
}
fn get_symbol_type(&self, _str: &str) -> Option<SymbolType> {
None
}
fn get_symbol_value(&self, _str: &str) -> Option<SymbolValue> {
None
}
}
ExpressionTypeInferencer {
ctx: InferenceContext::new(primitives::basic_ctx(), Box::new(S{}), FileID(3)),
}
}
#[test]
fn test_i64() {
let mut inferencer = new_ctx();
let location = ast::Location::new(0, 0);
let num: i64 = 99999999999;
let ast: Expr<Option<Type>> = Expr {
location: location,
custom: None,
node: ast::ExprKind::Constant {
value: ast::Constant::Int(num.into()),
kind: None,
}
};
let new_ast = inferencer.fold_expr(ast).unwrap();
assert_eq!(
new_ast,
Expr {
location: location,
custom: Some(inferencer.ctx.get_primitive(primitives::INT64_TYPE)),
node: ast::ExprKind::Constant {
value: ast::Constant::Int(num.into()),
kind: None,
}
}
);
}
#[test]
fn test_list() {
let mut inferencer = new_ctx();
let location = ast::Location::new(0, 0);
let ast: Expr<Option<Type>> = Expr {
location,
custom: None,
node: ast::ExprKind::List {
ctx: ast::ExprContext::Load,
elts: vec![
Expr {
location,
custom: None,
node: ast::ExprKind::Constant {
value: ast::Constant::Int(1.into()),
kind: None,
},
},
Expr {
location,
custom: None,
node: ast::ExprKind::Constant {
value: ast::Constant::Int(2.into()),
kind: None,
},
},
],
}
};
let new_ast = inferencer.fold_expr(ast).unwrap();
assert_eq!(
new_ast,
Expr {
location,
custom: Some(TypeEnum::ParametricType(primitives::LIST_TYPE, vec![inferencer.ctx.get_primitive(primitives::INT32_TYPE).into()]).into()),
node: ast::ExprKind::List {
ctx: ast::ExprContext::Load,
elts: vec![
Expr {
location,
custom: Some(inferencer.ctx.get_primitive(primitives::INT32_TYPE)),
node: ast::ExprKind::Constant {
value: ast::Constant::Int(1.into()),
kind: None,
},
},
Expr {
location,
custom: Some(inferencer.ctx.get_primitive(primitives::INT32_TYPE)),
node: ast::ExprKind::Constant {
value: ast::Constant::Int(2.into()),
kind: None,
},
},
],
}
}
);
}
}

View File

@ -5,3 +5,4 @@ pub mod magic_methods;
pub mod primitives; pub mod primitives;
pub mod symbol_resolver; pub mod symbol_resolver;
pub mod typedef; pub mod typedef;
pub mod expression_inference;