mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-22 16:30:04 +03:00
1298 lines
36 KiB
Rust
1298 lines
36 KiB
Rust
#[macro_use]
|
|
extern crate pretty_assertions;
|
|
#[macro_use]
|
|
extern crate indoc;
|
|
|
|
extern crate bumpalo;
|
|
extern crate roc_can;
|
|
extern crate roc_parse;
|
|
extern crate roc_region;
|
|
|
|
mod helpers;
|
|
|
|
#[cfg(test)]
|
|
mod test_can {
|
|
use crate::helpers::{can_expr_with, test_home, CanExprOut};
|
|
use bumpalo::Bump;
|
|
use roc_can::expr::Expr::{self, *};
|
|
use roc_can::expr::Recursive;
|
|
use roc_problem::can::{Problem, RuntimeError};
|
|
use roc_region::all::{Located, Region};
|
|
use std::{f64, i64};
|
|
|
|
fn assert_can(input: &str, expected: Expr) {
|
|
let arena = Bump::new();
|
|
let actual_out = can_expr_with(&arena, test_home(), input);
|
|
|
|
assert_eq!(actual_out.loc_expr.value, expected);
|
|
}
|
|
|
|
fn assert_can_float(input: &str, expected: f64) {
|
|
let arena = Bump::new();
|
|
let actual_out = can_expr_with(&arena, test_home(), input);
|
|
|
|
match actual_out.loc_expr.value {
|
|
Expr::Float(_, actual) => {
|
|
assert_eq!(expected, actual);
|
|
}
|
|
actual => {
|
|
panic!("Expected a Float, but got: {:?}", actual);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn assert_can_int(input: &str, expected: i64) {
|
|
let arena = Bump::new();
|
|
let actual_out = can_expr_with(&arena, test_home(), input);
|
|
|
|
match actual_out.loc_expr.value {
|
|
Expr::Int(_, actual) => {
|
|
assert_eq!(expected, actual);
|
|
}
|
|
actual => {
|
|
panic!("Expected an Int, but got: {:?}", actual);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn assert_can_num(input: &str, expected: i64) {
|
|
let arena = Bump::new();
|
|
let actual_out = can_expr_with(&arena, test_home(), input);
|
|
|
|
match actual_out.loc_expr.value {
|
|
Expr::Num(_, actual) => {
|
|
assert_eq!(expected, actual);
|
|
}
|
|
actual => {
|
|
panic!("Expected a Num, but got: {:?}", actual);
|
|
}
|
|
}
|
|
}
|
|
|
|
// NUMBER LITERALS
|
|
|
|
#[test]
|
|
fn int_too_large() {
|
|
let string = (i64::MAX as i128 + 1).to_string();
|
|
|
|
assert_can(
|
|
&string.clone(),
|
|
RuntimeError(RuntimeError::IntOutsideRange(string.into())),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn int_too_small() {
|
|
let string = (i64::MIN as i128 - 1).to_string();
|
|
|
|
assert_can(
|
|
&string.clone(),
|
|
RuntimeError(RuntimeError::IntOutsideRange(string.into())),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn float_too_large() {
|
|
let string = format!("{}1.0", f64::MAX);
|
|
|
|
assert_can(
|
|
&string.clone(),
|
|
RuntimeError(RuntimeError::FloatOutsideRange(string.into())),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn float_too_small() {
|
|
let string = format!("{}1.0", f64::MIN);
|
|
|
|
assert_can(
|
|
&string.clone(),
|
|
RuntimeError(RuntimeError::FloatOutsideRange(string.into())),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn zero() {
|
|
assert_can_num("0", 0);
|
|
}
|
|
|
|
#[test]
|
|
fn minus_zero() {
|
|
assert_can_num("-0", 0);
|
|
}
|
|
|
|
#[test]
|
|
fn zero_point_zero() {
|
|
assert_can_float("0.0", 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn minus_zero_point_zero() {
|
|
assert_can_float("-0.0", -0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn hex_zero() {
|
|
assert_can_int("0x0", 0x0);
|
|
}
|
|
|
|
#[test]
|
|
fn hex_one_b() {
|
|
assert_can_int("0x1b", 0x1b);
|
|
}
|
|
|
|
#[test]
|
|
fn minus_hex_one_b() {
|
|
assert_can_int("-0x1b", -0x1b);
|
|
}
|
|
|
|
#[test]
|
|
fn octal_zero() {
|
|
assert_can_int("0o0", 0o0);
|
|
}
|
|
|
|
#[test]
|
|
fn octal_one_two() {
|
|
assert_can_int("0o12", 0o12);
|
|
}
|
|
|
|
#[test]
|
|
fn minus_octal_one_two() {
|
|
assert_can_int("-0o12", -0o12);
|
|
}
|
|
|
|
#[test]
|
|
fn binary_zero() {
|
|
assert_can_int("0b0", 0b0);
|
|
}
|
|
|
|
#[test]
|
|
fn binary_one_one() {
|
|
assert_can_int("0b11", 0b11);
|
|
}
|
|
|
|
#[test]
|
|
fn minus_binary_one_one() {
|
|
assert_can_int("-0b11", -0b11);
|
|
}
|
|
|
|
// LOCALS
|
|
|
|
// TODO rewrite this test to check only for UnusedDef reports
|
|
// #[test]
|
|
// fn closure_args_are_not_locals() {
|
|
// // "arg" shouldn't make it into output.locals, because
|
|
// // it only exists in the closure's arguments.
|
|
// let arena = Bump::new();
|
|
// let src = indoc!(
|
|
// r#"
|
|
// func = \arg -> arg
|
|
|
|
// func 2
|
|
// "#
|
|
// );
|
|
// let (_actual, output, problems, _var_store, _vars, _constraint) =
|
|
// can_expr_with(&arena, test_home(), src);
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["func"],
|
|
// calls: vec!["func"],
|
|
// tail_call: None
|
|
// }
|
|
// .into_output(scope)
|
|
// );
|
|
// }
|
|
|
|
// TODO rewrite this test to check only for UnusedDef reports
|
|
// #[test]
|
|
// fn call_by_pointer_for_fn_args() {
|
|
// // This function will get passed in as a pointer.
|
|
// let src = indoc!(
|
|
// r#"
|
|
// apply = \f, x -> f x
|
|
|
|
// identity = \a -> a
|
|
|
|
// apply identity 5
|
|
// "#
|
|
// );
|
|
// let arena = Bump::new();
|
|
// let (_actual, output, problems, _var_store, _vars, _constraint) =
|
|
// can_expr_with(&arena, test_home(), src);
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["identity", "apply"],
|
|
// calls: vec!["f", "apply"],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
// }
|
|
|
|
fn get_closure(expr: &Expr, i: usize) -> roc_can::expr::Recursive {
|
|
match expr {
|
|
LetRec(assignments, body, _, _) => {
|
|
match &assignments.get(i).map(|def| &def.loc_expr.value) {
|
|
Some(Closure(_, _, recursion, _, _)) => recursion.clone(),
|
|
Some(other @ _) => {
|
|
panic!("assignment at {} is not a closure, but a {:?}", i, other)
|
|
}
|
|
None => {
|
|
if i > 0 {
|
|
get_closure(&body.value, i - 1)
|
|
} else {
|
|
panic!("Looking for assignment at {} but the list is too short", i)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LetNonRec(def, body, _, _) => {
|
|
if i > 0 {
|
|
// recurse in the body (not the def!)
|
|
get_closure(&body.value, i - 1)
|
|
} else {
|
|
match &def.loc_expr.value {
|
|
Closure(_, _, recursion, _, _) => recursion.clone(),
|
|
other @ _ => {
|
|
panic!("assignment at {} is not a closure, but a {:?}", i, other)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Closure(_, recursion, _, _) if i == 0 => recursion.clone(),
|
|
_ => panic!(
|
|
"expression is not a LetRec or a LetNonRec, but rather {:?}",
|
|
expr
|
|
),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn recognize_tail_calls() {
|
|
let src = indoc!(
|
|
r#"
|
|
g = \x ->
|
|
when x is
|
|
0 -> 0
|
|
_ -> g (x - 1)
|
|
|
|
# use parens to force the ordering!
|
|
(h = \x ->
|
|
when x is
|
|
0 -> 0
|
|
_ -> g (x - 1)
|
|
|
|
(p = \x ->
|
|
when x is
|
|
0 -> 0
|
|
1 -> g (x - 1)
|
|
_ -> p (x - 1)
|
|
|
|
|
|
# variables must be (indirectly) referenced in the body for analysis to work
|
|
{ x: p, y: h }
|
|
))
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
|
|
assert_eq!(problems, Vec::new());
|
|
assert!(problems.iter().all(|problem| match problem {
|
|
Problem::UnusedDef(_, _) => true,
|
|
_ => false,
|
|
}));
|
|
|
|
let actual = loc_expr.value;
|
|
|
|
let g_detected = get_closure(&actual, 0);
|
|
let h_detected = get_closure(&actual, 1);
|
|
let p_detected = get_closure(&actual, 2);
|
|
|
|
assert_eq!(g_detected, Recursive::TailRecursive);
|
|
assert_eq!(h_detected, Recursive::NotRecursive);
|
|
assert_eq!(p_detected, Recursive::TailRecursive);
|
|
}
|
|
|
|
// TODO restore this test! It should report two unused defs (h and p), but only reports 1.
|
|
// #[test]
|
|
// fn reproduce_incorrect_unused_defs() {
|
|
// let src = indoc!(
|
|
// r#"
|
|
// g = \x ->
|
|
// when x is
|
|
// 0 -> 0
|
|
// _ -> g (x - 1)
|
|
|
|
// h = \x ->
|
|
// when x is
|
|
// 0 -> 0
|
|
// _ -> g (x - 1)
|
|
|
|
// p = \x ->
|
|
// when x is
|
|
// 0 -> 0
|
|
// 1 -> g (x - 1)
|
|
// _ -> p (x - 1)
|
|
|
|
// # variables must be (indirectly) referenced in the body for analysis to work
|
|
// # { x: p, y: h }
|
|
// g
|
|
// "#
|
|
// );
|
|
// let arena = Bump::new();
|
|
// let CanExprOut {
|
|
// loc_expr, problems, ..
|
|
// } = can_expr_with(&arena, test_home(), src);
|
|
|
|
// // There should be two UnusedDef problems: one for h, and one for p
|
|
// assert_eq!(problems.len(), 2);
|
|
// assert!(problems.iter().all(|problem| match problem {
|
|
// Problem::UnusedDef(_, _) => true,
|
|
// _ => false,
|
|
// }));
|
|
|
|
// let actual = loc_expr.value;
|
|
// // NOTE: the indices associated with each of these can change!
|
|
// // They come out of a hashmap, and are not sorted.
|
|
// let g_detected = get_closure(&actual, 0);
|
|
// let h_detected = get_closure(&actual, 2);
|
|
// let p_detected = get_closure(&actual, 1);
|
|
|
|
// assert_eq!(g_detected, Recursive::TailRecursive);
|
|
// assert_eq!(h_detected, Recursive::NotRecursive);
|
|
// assert_eq!(p_detected, Recursive::TailRecursive);
|
|
// }
|
|
|
|
#[test]
|
|
fn when_tail_call() {
|
|
let src = indoc!(
|
|
r#"
|
|
g = \x ->
|
|
when x is
|
|
0 -> 0
|
|
_ -> g (x + 1)
|
|
|
|
g 0
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
assert_eq!(problems, Vec::new());
|
|
|
|
let detected = get_closure(&loc_expr.value, 0);
|
|
assert_eq!(detected, Recursive::TailRecursive);
|
|
}
|
|
|
|
#[test]
|
|
fn immediate_tail_call() {
|
|
let src = indoc!(
|
|
r#"
|
|
f = \x -> f x
|
|
|
|
f 0
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
|
|
assert_eq!(problems, Vec::new());
|
|
|
|
let detected = get_closure(&loc_expr.value, 0);
|
|
|
|
assert_eq!(detected, Recursive::TailRecursive);
|
|
}
|
|
|
|
#[test]
|
|
fn when_condition_is_no_tail_call() {
|
|
let src = indoc!(
|
|
r#"
|
|
q = \x ->
|
|
when q x is
|
|
_ -> 0
|
|
|
|
q 0
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
|
|
assert_eq!(problems, Vec::new());
|
|
let detected = get_closure(&loc_expr.value, 0);
|
|
assert_eq!(detected, Recursive::Recursive);
|
|
}
|
|
|
|
#[test]
|
|
fn good_mutual_recursion() {
|
|
let src = indoc!(
|
|
r#"
|
|
q = \x ->
|
|
when x is
|
|
0 -> 0
|
|
_ -> p (x - 1)
|
|
|
|
p = \x ->
|
|
when x is
|
|
0 -> 0
|
|
_ -> q (x - 1)
|
|
|
|
q p
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
assert_eq!(problems, Vec::new());
|
|
|
|
let actual = loc_expr.value;
|
|
let detected = get_closure(&actual, 0);
|
|
assert_eq!(detected, Recursive::Recursive);
|
|
|
|
let detected = get_closure(&actual, 1);
|
|
assert_eq!(detected, Recursive::Recursive);
|
|
}
|
|
|
|
#[test]
|
|
fn valid_self_recursion() {
|
|
let src = indoc!(
|
|
r#"
|
|
boom = \_ -> boom {}
|
|
|
|
boom
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
|
|
assert_eq!(problems, Vec::new());
|
|
|
|
let is_circular_def = if let RuntimeError(RuntimeError::CircularDef(_, _)) = loc_expr.value
|
|
{
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
assert_eq!(is_circular_def, false);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_self_recursion() {
|
|
let src = indoc!(
|
|
r#"
|
|
x = x
|
|
|
|
x
|
|
"#
|
|
);
|
|
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
|
|
let is_circular_def = if let RuntimeError(RuntimeError::CircularDef(_, _)) = loc_expr.value
|
|
{
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
let problem = Problem::RuntimeError(RuntimeError::CircularDef(
|
|
vec![Located::at(Region::new(0, 0, 0, 1), "x".into())],
|
|
vec![(Region::new(0, 0, 0, 1), Region::new(0, 0, 4, 5))],
|
|
));
|
|
|
|
assert_eq!(is_circular_def, true);
|
|
assert_eq!(problems, vec![problem]);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_mutual_recursion() {
|
|
let src = indoc!(
|
|
r#"
|
|
x = y
|
|
y = z
|
|
z = x
|
|
|
|
x
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut {
|
|
loc_expr, problems, ..
|
|
} = can_expr_with(&arena, test_home(), src);
|
|
|
|
let problem = Problem::RuntimeError(RuntimeError::CircularDef(
|
|
vec![
|
|
Located::at(Region::new(0, 0, 0, 1), "x".into()),
|
|
Located::at(Region::new(1, 1, 0, 1), "y".into()),
|
|
Located::at(Region::new(2, 2, 0, 1), "z".into()),
|
|
],
|
|
vec![
|
|
(Region::new(0, 0, 0, 1), Region::new(0, 0, 4, 5)),
|
|
(Region::new(1, 1, 0, 1), Region::new(1, 1, 4, 5)),
|
|
(Region::new(2, 2, 0, 1), Region::new(2, 2, 4, 5)),
|
|
],
|
|
));
|
|
|
|
assert_eq!(problems, vec![problem]);
|
|
|
|
match loc_expr.value {
|
|
RuntimeError(RuntimeError::CircularDef(_, _)) => (),
|
|
actual => {
|
|
panic!("Expected a CircularDef runtime error, but got {:?}", actual);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn unused_def_regression() {
|
|
let src = indoc!(
|
|
r#"
|
|
Booly : [ Yes, No, Maybe ]
|
|
|
|
y : Booly
|
|
y = No
|
|
|
|
# There was a bug where annotating a def meant that its
|
|
# references no longer got reported.
|
|
#
|
|
# https://github.com/rtfeldman/roc/issues/298
|
|
x : List Booly
|
|
x = [ y ]
|
|
|
|
x
|
|
"#
|
|
);
|
|
let arena = Bump::new();
|
|
let CanExprOut { problems, .. } = can_expr_with(&arena, test_home(), src);
|
|
|
|
assert_eq!(problems, Vec::new());
|
|
}
|
|
|
|
//#[test]
|
|
//fn closing_over_locals() {
|
|
// // "local" should be used, because the closure used it.
|
|
// // However, "unused" should be unused.
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// local = 5
|
|
// unused = 6
|
|
// func = \arg -> arg + local
|
|
|
|
// 3 + func 2
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(
|
|
// problems,
|
|
// vec![Problem::UnusedAssignment(loc((
|
|
// "unused".to_string()
|
|
// )))]
|
|
// );
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["func", "local"],
|
|
// calls: vec!["func"],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
//#[test]
|
|
//fn unused_closure() {
|
|
// // "unused" should be unused because it's in func, which is unused.
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// local = 5
|
|
// unused = 6
|
|
// func = \arg -> arg + unused
|
|
|
|
// local
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(
|
|
// problems,
|
|
// vec![
|
|
// Problem::UnusedAssignment(loc(("unused".to_string()))),
|
|
// Problem::UnusedAssignment(loc(("func".to_string()))),
|
|
// ]
|
|
// );
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["local"],
|
|
// calls: vec![],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
// // UNRECOGNIZED
|
|
|
|
// #[test]
|
|
// fn basic_unrecognized_constant() {
|
|
// let (expr, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// x
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(
|
|
// problems,
|
|
// vec![Problem::LookupNotInScope(loc(("x".to_string())))]
|
|
// );
|
|
|
|
// assert_eq!(expr, LookupNotInScope(loc(("x".to_string()))));
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec![],
|
|
// calls: vec![],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
// }
|
|
|
|
//#[test]
|
|
//fn complex_unrecognized_constant() {
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// a = 5
|
|
// b = 6
|
|
|
|
// a + b * z
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(
|
|
// problems,
|
|
// vec![Problem::LookupNotInScope(loc((
|
|
// "z".to_string()
|
|
// )))]
|
|
// );
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["a", "b"],
|
|
// calls: vec![],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
//// UNUSED
|
|
|
|
//#[test]
|
|
//fn mutual_unused_circular_vars() {
|
|
// // This should report that both a and b are unused, since the return expr never references them.
|
|
// // It should not report them as circular, since we haven't solved the halting problem here.
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// a = \arg -> if arg > 0 then b 7 else 0
|
|
// b = \arg -> if arg > 0 then a (arg - 1) else 0
|
|
// c = 5
|
|
|
|
// c
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, vec![unused("a"), unused("b")]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["c"],
|
|
// calls: vec![],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
//#[test]
|
|
//fn can_fibonacci() {
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// fibonacci = \num ->
|
|
// if num < 2 then
|
|
// num
|
|
// else
|
|
// fibonacci (num - 1) + fibonacci (num - 2)
|
|
|
|
// fibonacci 9
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["fibonacci"],
|
|
// calls: vec!["fibonacci"],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
//#[test]
|
|
//fn can_tail_call() {
|
|
// // TODO check the global params - make sure this
|
|
// // is considered a tail call, even though it only
|
|
// // calls itself from one branch!
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// factorial = \num ->
|
|
// factorialHelp num 0
|
|
|
|
// factorialHelp = \num total ->
|
|
// if num == 0 then
|
|
// total
|
|
// else
|
|
// factorialHelp (num - 1) (total * num)
|
|
|
|
// factorial 9
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["factorial", "factorialHelp"],
|
|
// calls: vec!["factorial", "factorialHelp"],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
//#[test]
|
|
//fn transitively_used_function() {
|
|
// // This should report that neither a nor b are unused,
|
|
// // since if you never call a function but do return it, that's okay!
|
|
// let (_, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// a = \_ -> 42
|
|
// b = a
|
|
|
|
// b
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, Vec::new());
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["a", "b"],
|
|
// calls: vec![],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
//}
|
|
|
|
//// ASSIGNMENT REORDERING
|
|
|
|
//#[test]
|
|
//fn reorder_assignments() {
|
|
// let (expr, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// increment = \arg -> arg + 1
|
|
// z = (increment 2) + y
|
|
// y = x + 1
|
|
// x = 9
|
|
|
|
// z * 3
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["increment", "x", "y", "z"],
|
|
// calls: vec!["increment"],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
|
|
// let symbols = assigned_symbols(expr);
|
|
|
|
// // In code gen, for everything to have been set before it gets read,
|
|
// // the following must be true about when things are assigned:
|
|
// //
|
|
// // x must be assigned before y
|
|
// // y must be assigned before z
|
|
// //
|
|
// // The order of the increment function doesn't matter.
|
|
// assert_before("x", "y", &symbols);
|
|
// assert_before("y", "z", &symbols);
|
|
//}
|
|
|
|
//#[test]
|
|
//fn reorder_closed_over_assignments() {
|
|
// let (expr, output, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// z = func1 x
|
|
// x = 9
|
|
// y = func2 3
|
|
// func1 = \arg -> func2 arg + y
|
|
// func2 = \arg -> arg + x
|
|
|
|
// z
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
|
|
// assert_eq!(
|
|
// output,
|
|
// Out {
|
|
// lookups: vec!["func1", "func2", "x", "y", "z"],
|
|
// calls: vec!["func1", "func2"],
|
|
// tail_call: None
|
|
// }
|
|
// .into()
|
|
// );
|
|
|
|
// let symbols = assigned_symbols(expr);
|
|
|
|
// // In code gen, for everything to have been set before it gets read,
|
|
// // the following must be true about when things are assigned:
|
|
// //
|
|
// // x and func2 must be assigned (in either order) before y
|
|
// // y and func1 must be assigned (in either order) before z
|
|
// assert_before("x", "y", &symbols);
|
|
// assert_before("func2", "y", &symbols);
|
|
|
|
// assert_before("func1", "z", &symbols);
|
|
// assert_before("y", "z", &symbols);
|
|
//}
|
|
|
|
//fn assert_before(before: &str, after: &str, symbols: &Vec<Symbol>) {
|
|
// assert_ne!(before, after);
|
|
|
|
// let before_symbol = sym(before);
|
|
// let after_symbol = sym(after);
|
|
// let before_index = symbols
|
|
// .iter()
|
|
// .position(|symbol| symbol == &before_symbol)
|
|
// .unwrap_or_else(|| {
|
|
// panic!(
|
|
// "error in assert_before({:?}, {:?}): {:?} could not be found in {:?}",
|
|
// before,
|
|
// after,
|
|
// sym(before),
|
|
// symbols
|
|
// )
|
|
// });
|
|
// let after_index = symbols
|
|
// .iter()
|
|
// .position(|symbol| symbol == &after_symbol)
|
|
// .unwrap_or_else(|| {
|
|
// panic!(
|
|
// "error in assert_before({:?}, {:?}): {:?} could not be found in {:?}",
|
|
// before,
|
|
// after,
|
|
// sym(after),
|
|
// symbols
|
|
// )
|
|
// });
|
|
|
|
// if before_index == after_index {
|
|
// panic!(
|
|
// "error in assert_before({:?}, {:?}): both were at index {} in {:?}",
|
|
// before, after, after_index, symbols
|
|
// );
|
|
// } else if before_index > after_index {
|
|
// panic!("error in assert_before: {:?} appeared *after* {:?} (not before, as expected) in {:?}", before, after, symbols);
|
|
// }
|
|
//}
|
|
|
|
//fn assigned_symbols(expr: Expr) -> Vec<Symbol> {
|
|
// match expr {
|
|
// Assign(assignments, _) => {
|
|
// assignments.into_iter().map(|(pattern, _)| {
|
|
// match pattern.value {
|
|
// Identifier(symbol) => {
|
|
// symbol
|
|
// },
|
|
// _ => {
|
|
// panic!("Called assigned_symbols passing an Assign expr with non-Identifier patterns!");
|
|
// }
|
|
// }
|
|
// }).collect()
|
|
// },
|
|
// _ => {
|
|
// panic!("Called assigned_symbols passing a non-Assign expr!");
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
//// CIRCULAR ASSIGNMENT
|
|
|
|
//#[test]
|
|
//fn circular_assignment() {
|
|
// let (_, _, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// c = d + 3
|
|
// b = 2 + c
|
|
// d = a + 7
|
|
// a = b + 1
|
|
|
|
// 2 + d
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(
|
|
// problems,
|
|
// vec![Problem::CircularAssignment(vec![
|
|
// // c should appear first because it's assigned first in the original expression.
|
|
// loc(unqualified("c")),
|
|
// loc(unqualified("d")),
|
|
// loc(unqualified("a")),
|
|
// loc(unqualified("b")),
|
|
// ])]
|
|
// );
|
|
//}
|
|
|
|
//#[test]
|
|
//fn always_function() {
|
|
// // There was a bug where this reported UnusedArgument("val")
|
|
// // since it was used only in the returned function only.
|
|
// let (_, _, problems, _) = can_expr(indoc!(
|
|
// r#"
|
|
// \val -> \_ -> val
|
|
// "#
|
|
// ));
|
|
|
|
// assert_eq!(problems, vec![]);
|
|
//}
|
|
|
|
//// TODO verify that Apply handles output.references.calls correctly
|
|
|
|
//// UNSUPPORTED PATTERNS
|
|
|
|
//// TODO verify that in closures and assignments, you can't assign to int/string/underscore/etc
|
|
|
|
//// OPERATOR PRECEDENCE
|
|
|
|
//// fn parse_with_precedence(input: &str) -> Result<(Expr, &str), easy::Errors<char, &str, IndentablePosition>> {
|
|
//// parse_without_loc(input)
|
|
//// .map(|(expr, remaining)| (expr::apply_precedence_and_associativity(loc(expr)).unwrap().value, remaining))
|
|
//// }
|
|
|
|
//// #[test]
|
|
//// fn two_operator_precedence() {
|
|
//// assert_eq!(
|
|
//// parse_with_precedence("x + y * 5"),
|
|
//// Ok((BinOp(
|
|
//// loc_box(var("x")),
|
|
//// loc(Plus),
|
|
//// loc_box(
|
|
//// BinOp(
|
|
//// loc_box(var("y")),
|
|
//// loc(Star),
|
|
//// loc_box(Int(5))
|
|
//// )
|
|
//// ),
|
|
//// ),
|
|
//// ""))
|
|
//// );
|
|
|
|
//// assert_eq!(
|
|
//// parse_with_precedence("x * y + 5"),
|
|
//// Ok((BinOp(
|
|
//// loc_box(
|
|
//// BinOp(
|
|
//// loc_box(var("x")),
|
|
//// loc(Star),
|
|
//// loc_box(var("y")),
|
|
//// )
|
|
//// ),
|
|
//// loc(Plus),
|
|
//// loc_box(Int(5))
|
|
//// ),
|
|
//// ""))
|
|
//// );
|
|
//// }
|
|
|
|
//// #[test]
|
|
//// fn compare_and() {
|
|
//// assert_eq!(
|
|
//// parse_with_precedence("x > 1 || True"),
|
|
//// Ok((BinOp(
|
|
//// loc_box(
|
|
//// BinOp(
|
|
//// loc_box(var("x")),
|
|
//// loc(GreaterThan),
|
|
//// loc_box(Int(1))
|
|
//// )
|
|
//// ),
|
|
//// loc(Or),
|
|
//// loc_box(ApplyVariant(vname("True"), None))
|
|
//// ),
|
|
//// ""))
|
|
//// );
|
|
//// }
|
|
|
|
//// HELPERS
|
|
|
|
//#[test]
|
|
//fn sort_cyclic_idents() {
|
|
// let assigned_idents = unqualifieds(vec!["blah", "c", "b", "d", "a"]);
|
|
|
|
// assert_eq!(
|
|
// can::sort_cyclic_idents(
|
|
// loc_unqualifieds(vec!["a", "b", "c", "d"]),
|
|
// &mut assigned_idents.iter()
|
|
// ),
|
|
// loc_unqualifieds(vec!["c", "d", "a", "b"])
|
|
// );
|
|
//}
|
|
//
|
|
//
|
|
//// STRING LITERALS
|
|
|
|
//
|
|
// #[test]
|
|
// fn string_with_valid_unicode_escapes() {
|
|
// expect_parsed_str("x\u{00A0}x", r#""x\u{00A0}x""#);
|
|
// expect_parsed_str("x\u{101010}x", r#""x\u{101010}x""#);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_too_large_unicode_escape() {
|
|
// // Should be too big - max size should be 10FFFF.
|
|
// // (Rust has this restriction. I assume it's a good idea.)
|
|
// assert_malformed_str(
|
|
// r#""abc\u{110000}def""#,
|
|
// vec![Located::new(0, 7, 0, 12, Problem::UnicodeCodePointTooLarge)],
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_no_unicode_digits() {
|
|
// // No digits specified
|
|
// assert_malformed_str(
|
|
// r#""blah\u{}foo""#,
|
|
// vec![Located::new(0, 5, 0, 8, Problem::NoUnicodeDigits)],
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_no_unicode_opening_brace() {
|
|
// // No opening curly brace. It can't be sure if the closing brace
|
|
// // was intended to be a closing brace for the unicode escape, so
|
|
// // report that there were no digits specified.
|
|
// assert_malformed_str(
|
|
// r#""abc\u00A0}def""#,
|
|
// vec![Located::new(0, 4, 0, 5, Problem::NoUnicodeDigits)],
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_no_unicode_closing_brace() {
|
|
// // No closing curly brace
|
|
// assert_malformed_str(
|
|
// r#""blah\u{stuff""#,
|
|
// vec![Located::new(0, 5, 0, 12, Problem::MalformedEscapedUnicode)],
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_no_unicode_braces() {
|
|
// // No curly braces
|
|
// assert_malformed_str(
|
|
// r#""zzzz\uzzzzz""#,
|
|
// vec![Located::new(0, 5, 0, 6, Problem::NoUnicodeDigits)],
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_interpolation_at_start() {
|
|
// let input = indoc!(
|
|
// r#"
|
|
// "\(abc)defg"
|
|
// "#
|
|
// );
|
|
// let (args, ret) = (vec![("", Located::new(0, 2, 0, 4, Var("abc")))], "defg");
|
|
// let arena = Bump::new();
|
|
// let actual = parse_with(&arena, input);
|
|
|
|
// assert_eq!(
|
|
// Ok(InterpolatedStr(&(arena.alloc_slice_clone(&args), ret))),
|
|
// actual
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_interpolation_at_end() {
|
|
// let input = indoc!(
|
|
// r#"
|
|
// "abcd\(efg)"
|
|
// "#
|
|
// );
|
|
// let (args, ret) = (vec![("abcd", Located::new(0, 6, 0, 8, Var("efg")))], "");
|
|
// let arena = Bump::new();
|
|
// let actual = parse_with(&arena, input);
|
|
|
|
// assert_eq!(
|
|
// Ok(InterpolatedStr(&(arena.alloc_slice_clone(&args), ret))),
|
|
// actual
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_interpolation_in_middle() {
|
|
// let input = indoc!(
|
|
// r#"
|
|
// "abc\(defg)hij"
|
|
// "#
|
|
// );
|
|
// let (args, ret) = (vec![("abc", Located::new(0, 5, 0, 8, Var("defg")))], "hij");
|
|
// let arena = Bump::new();
|
|
// let actual = parse_with(&arena, input);
|
|
|
|
// assert_eq!(
|
|
// Ok(InterpolatedStr(&(arena.alloc_slice_clone(&args), ret))),
|
|
// actual
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_two_interpolations_in_middle() {
|
|
// let input = indoc!(
|
|
// r#"
|
|
// "abc\(defg)hi\(jkl)mn"
|
|
// "#
|
|
// );
|
|
// let (args, ret) = (
|
|
// vec![
|
|
// ("abc", Located::new(0, 5, 0, 8, Var("defg"))),
|
|
// ("hi", Located::new(0, 14, 0, 16, Var("jkl"))),
|
|
// ],
|
|
// "mn",
|
|
// );
|
|
// let arena = Bump::new();
|
|
// let actual = parse_with(&arena, input);
|
|
|
|
// assert_eq!(
|
|
// Ok(InterpolatedStr(&(arena.alloc_slice_clone(&args), ret))),
|
|
// actual
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_four_interpolations() {
|
|
// let input = indoc!(
|
|
// r#"
|
|
// "\(abc)def\(ghi)jkl\(mno)pqrs\(tuv)"
|
|
// "#
|
|
// );
|
|
// let (args, ret) = (
|
|
// vec![
|
|
// ("", Located::new(0, 2, 0, 4, Var("abc"))),
|
|
// ("def", Located::new(0, 11, 0, 13, Var("ghi"))),
|
|
// ("jkl", Located::new(0, 20, 0, 22, Var("mno"))),
|
|
// ("pqrs", Located::new(0, 30, 0, 32, Var("tuv"))),
|
|
// ],
|
|
// "",
|
|
// );
|
|
// let arena = Bump::new();
|
|
// let actual = parse_with(&arena, input);
|
|
|
|
// assert_eq!(
|
|
// Ok(InterpolatedStr(&(arena.alloc_slice_clone(&args), ret))),
|
|
// actual
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_escaped_interpolation() {
|
|
// assert_parses_to(
|
|
// // This should NOT be string interpolation, because of the \\
|
|
// indoc!(
|
|
// r#"
|
|
// "abcd\\(efg)hij"
|
|
// "#
|
|
// ),
|
|
// Str(r#"abcd\(efg)hij"#.into()),
|
|
// );
|
|
// }
|
|
//
|
|
|
|
// #[test]
|
|
// fn string_without_escape() {
|
|
// expect_parsed_str("a", r#""a""#);
|
|
// expect_parsed_str("ab", r#""ab""#);
|
|
// expect_parsed_str("abc", r#""abc""#);
|
|
// expect_parsed_str("123", r#""123""#);
|
|
// expect_parsed_str("abc123", r#""abc123""#);
|
|
// expect_parsed_str("123abc", r#""123abc""#);
|
|
// expect_parsed_str("123 abc 456 def", r#""123 abc 456 def""#);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn string_with_special_escapes() {
|
|
// expect_parsed_str(r#"x\x"#, r#""x\\x""#);
|
|
// expect_parsed_str(r#"x"x"#, r#""x\"x""#);
|
|
// expect_parsed_str("x\tx", r#""x\tx""#);
|
|
// expect_parsed_str("x\rx", r#""x\rx""#);
|
|
// expect_parsed_str("x\nx", r#""x\nx""#);
|
|
// }
|
|
|
|
// fn assert_malformed_str<'a>(input: &'a str, expected_probs: Vec<Located<Problem>>) {
|
|
// let arena = Bump::new();
|
|
// let actual = parse_with(&arena, input);
|
|
|
|
// assert_eq!(
|
|
// Ok(Expr::MalformedStr(expected_probs.into_boxed_slice())),
|
|
// actual
|
|
// );
|
|
// }
|
|
//
|
|
// TODO test what happens when interpolated strings contain 1+ malformed idents
|
|
//
|
|
// TODO test hex/oct/binary conversion to numbers
|
|
//
|
|
// TODO test for \t \r and \n in string literals *outside* unicode escape sequence!
|
|
}
|