forked from M-Labs/nac3
added expression tests
This commit is contained in:
parent
e625bd4ad2
commit
8fd164bda2
|
|
@ -383,3 +383,641 @@ fn infer_list_comprehension(
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
use crate::typedef::*;
|
||||
use rustpython_parser::parser::parse_expression;
|
||||
|
||||
#[test]
|
||||
fn test_constants() {
|
||||
let ctx = basic_ctx();
|
||||
let sym_table = HashMap::new();
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("123").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("2147483647").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("2147483648").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT64_TYPE).into());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("9223372036854775807").unwrap(),
|
||||
);
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT64_TYPE).into());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("9223372036854775808").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("integer out of range".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("123.456").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(FLOAT_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("True").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("False").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_identifier() {
|
||||
let ctx = basic_ctx();
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("abc", Rc::new(PrimitiveType(INT32_TYPE)));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("abc").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("ab").unwrap());
|
||||
assert_eq!(result, Err("unbounded variable".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_list() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"foo",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("abc", Rc::new(PrimitiveType(INT32_TYPE)));
|
||||
// def is reserved...
|
||||
sym_table.insert("efg", Rc::new(PrimitiveType(INT32_TYPE)));
|
||||
sym_table.insert("xyz", Rc::new(PrimitiveType(FLOAT_TYPE)));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[]").unwrap());
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(LIST_TYPE, vec![BotType.into()]).into()
|
||||
);
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[abc]").unwrap());
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into()
|
||||
);
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[abc, efg]").unwrap());
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into()
|
||||
);
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[abc, efg, xyz]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("inhomogeneous list is not allowed".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[foo()]").unwrap());
|
||||
assert_eq!(result, Err("list elements must have some type".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tuple() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"foo",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("abc", Rc::new(PrimitiveType(INT32_TYPE)));
|
||||
sym_table.insert("efg", Rc::new(PrimitiveType(FLOAT_TYPE)));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("(abc, efg)").unwrap());
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(
|
||||
TUPLE_TYPE,
|
||||
vec![
|
||||
PrimitiveType(INT32_TYPE).into(),
|
||||
PrimitiveType(FLOAT_TYPE).into()
|
||||
]
|
||||
)
|
||||
.into()
|
||||
);
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("(abc, efg, foo())").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("tuple elements must have some type".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_attribute() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"none",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
|
||||
let foo = ctx.add_class(ClassDef {
|
||||
base: TypeDef {
|
||||
name: "Foo",
|
||||
fields: HashMap::new(),
|
||||
methods: HashMap::new(),
|
||||
},
|
||||
parents: vec![],
|
||||
});
|
||||
let foo_def = ctx.get_class_mut(foo);
|
||||
foo_def
|
||||
.base
|
||||
.fields
|
||||
.insert("a", PrimitiveType(INT32_TYPE).into());
|
||||
foo_def.base.fields.insert("b", ClassType(foo).into());
|
||||
foo_def
|
||||
.base
|
||||
.fields
|
||||
.insert("c", PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let bar = ctx.add_class(ClassDef {
|
||||
base: TypeDef {
|
||||
name: "Bar",
|
||||
fields: HashMap::new(),
|
||||
methods: HashMap::new(),
|
||||
},
|
||||
parents: vec![],
|
||||
});
|
||||
let bar_def = ctx.get_class_mut(bar);
|
||||
bar_def
|
||||
.base
|
||||
.fields
|
||||
.insert("a", PrimitiveType(INT32_TYPE).into());
|
||||
bar_def.base.fields.insert("b", ClassType(bar).into());
|
||||
bar_def
|
||||
.base
|
||||
.fields
|
||||
.insert("c", PrimitiveType(FLOAT_TYPE).into());
|
||||
|
||||
let v0 = ctx.add_variable(VarDef {
|
||||
name: "v0",
|
||||
bound: vec![],
|
||||
});
|
||||
|
||||
let v1 = ctx.add_variable(VarDef {
|
||||
name: "v1",
|
||||
bound: vec![ClassType(foo).into(), ClassType(bar).into()],
|
||||
});
|
||||
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("foo", Rc::new(ClassType(foo)));
|
||||
sym_table.insert("bar", Rc::new(ClassType(bar)));
|
||||
sym_table.insert("foobar", Rc::new(VirtualClassType(foo)));
|
||||
sym_table.insert("v0", Rc::new(TypeVariable(v0)));
|
||||
sym_table.insert("v1", Rc::new(TypeVariable(v1)));
|
||||
sym_table.insert("bot", Rc::new(BotType));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("foo.a").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("foo.d").unwrap());
|
||||
assert_eq!(result, Err("no such field".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("foobar.a").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v0.a").unwrap());
|
||||
assert_eq!(result, Err("no fields on unbounded type variable".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.a").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
// shall we support this?
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.b").unwrap());
|
||||
assert_eq!(
|
||||
result,
|
||||
Err("unknown field (type mismatch between variants)".into())
|
||||
);
|
||||
// assert_eq!(result.unwrap().unwrap(), TypeVariable(v1).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.c").unwrap());
|
||||
assert_eq!(
|
||||
result,
|
||||
Err("unknown field (type mismatch between variants)".into())
|
||||
);
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.d").unwrap());
|
||||
assert_eq!(result, Err("unknown field".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("none().a").unwrap());
|
||||
assert_eq!(result, Err("no value".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("bot.a").unwrap());
|
||||
assert_eq!(result, Err("this object has no fields".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bool_ops() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"none",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
let sym_table = HashMap::new();
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("True and False").unwrap(),
|
||||
);
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("True and none()").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("no value".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("True and 123").unwrap());
|
||||
assert_eq!(result, Err("bool operands must be bool".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bin_ops() {
|
||||
let mut ctx = basic_ctx();
|
||||
let v0 = ctx.add_variable(VarDef {
|
||||
name: "v0",
|
||||
bound: vec![
|
||||
PrimitiveType(INT32_TYPE).into(),
|
||||
PrimitiveType(INT64_TYPE).into(),
|
||||
],
|
||||
});
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("a", TypeVariable(v0).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("1 + 2 + 3").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("a + a + a").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), TypeVariable(v0).into());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_unary_ops() {
|
||||
let mut ctx = basic_ctx();
|
||||
let v0 = ctx.add_variable(VarDef {
|
||||
name: "v0",
|
||||
bound: vec![
|
||||
PrimitiveType(INT32_TYPE).into(),
|
||||
PrimitiveType(INT64_TYPE).into(),
|
||||
],
|
||||
});
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("a", TypeVariable(v0).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("-(123)").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("-a").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), TypeVariable(v0).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("not True").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("not (1)").unwrap());
|
||||
assert_eq!(result, Err("logical not must be applied to bool".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_compare() {
|
||||
let mut ctx = basic_ctx();
|
||||
let v0 = ctx.add_variable(VarDef {
|
||||
name: "v0",
|
||||
bound: vec![
|
||||
PrimitiveType(INT32_TYPE).into(),
|
||||
PrimitiveType(INT64_TYPE).into(),
|
||||
],
|
||||
});
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("a", TypeVariable(v0).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("a == a == a").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("a == a == 1").unwrap());
|
||||
assert_eq!(result, Err("not equal".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("True > False").unwrap());
|
||||
assert_eq!(result, Err("no such function".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("True in False").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("unsupported comparison".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_call() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"none",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
|
||||
let foo = ctx.add_class(ClassDef {
|
||||
base: TypeDef {
|
||||
name: "Foo",
|
||||
fields: HashMap::new(),
|
||||
methods: HashMap::new(),
|
||||
},
|
||||
parents: vec![],
|
||||
});
|
||||
let foo_def = ctx.get_class_mut(foo);
|
||||
foo_def.base.methods.insert(
|
||||
"a",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: Some(Rc::new(ClassType(foo))),
|
||||
},
|
||||
);
|
||||
|
||||
let bar = ctx.add_class(ClassDef {
|
||||
base: TypeDef {
|
||||
name: "Bar",
|
||||
fields: HashMap::new(),
|
||||
methods: HashMap::new(),
|
||||
},
|
||||
parents: vec![],
|
||||
});
|
||||
let bar_def = ctx.get_class_mut(bar);
|
||||
bar_def.base.methods.insert(
|
||||
"a",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: Some(Rc::new(ClassType(bar))),
|
||||
},
|
||||
);
|
||||
|
||||
let v0 = ctx.add_variable(VarDef {
|
||||
name: "v0",
|
||||
bound: vec![],
|
||||
});
|
||||
let v1 = ctx.add_variable(VarDef {
|
||||
name: "v1",
|
||||
bound: vec![ClassType(foo).into(), ClassType(bar).into()],
|
||||
});
|
||||
let v2 = ctx.add_variable(VarDef {
|
||||
name: "v2",
|
||||
bound: vec![
|
||||
ClassType(foo).into(),
|
||||
ClassType(bar).into(),
|
||||
PrimitiveType(INT32_TYPE).into(),
|
||||
],
|
||||
});
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("foo", Rc::new(ClassType(foo)));
|
||||
sym_table.insert("bar", Rc::new(ClassType(bar)));
|
||||
sym_table.insert("foobar", Rc::new(VirtualClassType(foo)));
|
||||
sym_table.insert("v0", Rc::new(TypeVariable(v0)));
|
||||
sym_table.insert("v1", Rc::new(TypeVariable(v1)));
|
||||
sym_table.insert("v2", Rc::new(TypeVariable(v2)));
|
||||
sym_table.insert("bot", Rc::new(BotType));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("foo.a()").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), ClassType(foo).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.a()").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), TypeVariable(v1).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("foobar.a()").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), ClassType(foo).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("none().a()").unwrap());
|
||||
assert_eq!(result, Err("no value".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("bot.a()").unwrap());
|
||||
assert_eq!(result, Err("not supported".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[][0].a()").unwrap());
|
||||
assert_eq!(result, Err("not supported".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v0.a()").unwrap());
|
||||
assert_eq!(result, Err("unbounded type var".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("v2.a()").unwrap());
|
||||
assert_eq!(result, Err("no such function".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn infer_subscript() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"none",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
let sym_table = HashMap::new();
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[1, 2, 3][0]").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("[[1]][0][0]").unwrap());
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[1, 2, 3][1:2]").unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into()
|
||||
);
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[1, 2, 3][1:2:2]").unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into()
|
||||
);
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[1, 2, 3][1:1.2]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("slice must be int32 type".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[1, 2, 3][1:none()]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("slice must have type".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[1, 2, 3][1.2]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("index must be either slice or int32".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[1, 2, 3][none()]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("no value".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("none()[1.2]").unwrap());
|
||||
assert_eq!(result, Err("no value".into()));
|
||||
|
||||
let result = infer_expr(&ctx, &sym_table, &parse_expression("123[1]").unwrap());
|
||||
assert_eq!(
|
||||
result,
|
||||
Err("subscript is not supported for types other than list".into())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_if_expr() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"none",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
let sym_table = HashMap::new();
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("1 if True else 0").unwrap(),
|
||||
);
|
||||
assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("none() if True else none()").unwrap(),
|
||||
);
|
||||
assert_eq!(result.unwrap(), None);
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("none() if 1 else none()").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("test should be bool".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("1 if True else none()").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("divergent type".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_list_comp() {
|
||||
let mut ctx = basic_ctx();
|
||||
ctx.add_fn(
|
||||
"none",
|
||||
FnDef {
|
||||
args: vec![],
|
||||
result: None,
|
||||
},
|
||||
);
|
||||
let int32 = Rc::new(PrimitiveType(INT32_TYPE));
|
||||
let mut sym_table = HashMap::new();
|
||||
sym_table.insert("z", int32.clone());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[x for x in [(1, 2), (2, 3), (3, 4)]][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
result.unwrap().unwrap(),
|
||||
ParametricType(TUPLE_TYPE, vec![int32.clone(), int32.clone()]).into()
|
||||
);
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[x for (x, y) in [(1, 2), (2, 3), (3, 4)]][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(result.unwrap().unwrap(), int32.clone());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[x for (x, y) in [(1, 2), (2, 3), (3, 4)] if x > 0][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(result.unwrap().unwrap(), int32.clone());
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[x for (x, y) in [(1, 2), (2, 3), (3, 4)] if x][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("test must be bool".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[y for x in []][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("unbounded variable".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[none() for x in []][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("no value".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[z for z in []][0]").unwrap(),
|
||||
);
|
||||
assert_eq!(result, Err("duplicated naming".into()));
|
||||
|
||||
let result = infer_expr(
|
||||
&ctx,
|
||||
&sym_table,
|
||||
&parse_expression("[x for x in [] for y in []]").unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
result,
|
||||
Err("only 1 generator statement is supported".into())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue