mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-22 00:09:33 +03:00
359 lines
12 KiB
Rust
359 lines
12 KiB
Rust
#[macro_use]
|
|
extern crate pretty_assertions;
|
|
#[macro_use]
|
|
extern crate maplit;
|
|
|
|
extern crate bumpalo;
|
|
extern crate inkwell;
|
|
extern crate roc;
|
|
extern crate roc_collections;
|
|
extern crate roc_module;
|
|
|
|
mod helpers;
|
|
|
|
#[cfg(test)]
|
|
mod test_uniqueness_load {
|
|
use crate::helpers::fixtures_dir;
|
|
use inlinable_string::InlinableString;
|
|
use roc::load::{load, LoadedModule};
|
|
use roc_builtins::unique;
|
|
use roc_can::def::Declaration::*;
|
|
use roc_can::def::Def;
|
|
use roc_collections::all::MutMap;
|
|
use roc_module::symbol::{Interns, ModuleId};
|
|
use roc_solve::solve::SubsByModule;
|
|
use roc_types::pretty_print::{content_to_string, name_all_type_vars};
|
|
use roc_types::subs::Subs;
|
|
use std::collections::HashMap;
|
|
|
|
// HELPERS
|
|
|
|
fn test_async<F: std::future::Future>(future: F) -> F::Output {
|
|
use tokio::runtime::Runtime;
|
|
|
|
// Create the runtime
|
|
let mut rt = Runtime::new().expect("Error initializing Tokio runtime.");
|
|
|
|
// Spawn the root task
|
|
rt.block_on(future)
|
|
}
|
|
|
|
async fn load_fixture(
|
|
dir_name: &str,
|
|
module_name: &str,
|
|
subs_by_module: SubsByModule,
|
|
) -> LoadedModule {
|
|
let src_dir = fixtures_dir().join(dir_name);
|
|
let filename = src_dir.join(format!("{}.roc", module_name));
|
|
let loaded = load(
|
|
&unique::uniqueness_stdlib(),
|
|
src_dir,
|
|
filename,
|
|
subs_by_module,
|
|
)
|
|
.await;
|
|
let loaded_module = loaded.expect("Test module failed to load");
|
|
|
|
assert_eq!(loaded_module.can_problems, Vec::new());
|
|
assert_eq!(loaded_module.type_problems, Vec::new());
|
|
|
|
let expected_name = loaded_module
|
|
.interns
|
|
.module_ids
|
|
.get_name(loaded_module.module_id)
|
|
.expect("Test ModuleID not found in module_ids");
|
|
|
|
assert_eq!(expected_name, &InlinableString::from(module_name));
|
|
|
|
loaded_module
|
|
}
|
|
|
|
fn expect_def(
|
|
interns: &Interns,
|
|
subs: &mut Subs,
|
|
home: ModuleId,
|
|
def: &Def,
|
|
expected_types: &HashMap<&str, &str>,
|
|
) {
|
|
for (symbol, expr_var) in &def.pattern_vars {
|
|
let content = subs.get(*expr_var).content;
|
|
|
|
name_all_type_vars(*expr_var, subs);
|
|
|
|
let actual_str = content_to_string(content, subs, home, &interns);
|
|
let fully_qualified = symbol.fully_qualified(&interns, home).to_string();
|
|
let expected_type = expected_types
|
|
.get(fully_qualified.as_str())
|
|
.unwrap_or_else(|| {
|
|
panic!("Defs included an unexpected symbol: {:?}", fully_qualified)
|
|
});
|
|
|
|
assert_eq!((&symbol, expected_type), (&symbol, &actual_str.as_str()));
|
|
}
|
|
}
|
|
|
|
fn expect_types(loaded_module: LoadedModule, expected_types: HashMap<&str, &str>) {
|
|
let home = loaded_module.module_id;
|
|
let mut subs = loaded_module.solved.into_inner();
|
|
|
|
assert_eq!(loaded_module.can_problems, Vec::new());
|
|
assert_eq!(loaded_module.type_problems, Vec::new());
|
|
|
|
let num_decls = loaded_module.declarations.len();
|
|
|
|
for decl in loaded_module.declarations {
|
|
match decl {
|
|
Declare(def) => expect_def(
|
|
&loaded_module.interns,
|
|
&mut subs,
|
|
home,
|
|
&def,
|
|
&expected_types,
|
|
),
|
|
DeclareRec(defs) => {
|
|
for def in defs {
|
|
expect_def(
|
|
&loaded_module.interns,
|
|
&mut subs,
|
|
home,
|
|
&def,
|
|
&expected_types,
|
|
);
|
|
}
|
|
}
|
|
cycle @ InvalidCycle(_, _) => {
|
|
panic!("Unexpected cyclic def in module declarations: {:?}", cycle);
|
|
}
|
|
};
|
|
}
|
|
|
|
assert_eq!(expected_types.len(), num_decls);
|
|
}
|
|
|
|
// TESTS
|
|
|
|
#[test]
|
|
fn interface_with_deps() {
|
|
let subs_by_module = MutMap::default();
|
|
let src_dir = fixtures_dir().join("interface_with_deps");
|
|
let filename = src_dir.join("Primary.roc");
|
|
|
|
test_async(async {
|
|
let loaded = load(
|
|
&roc_builtins::std::standard_stdlib(),
|
|
src_dir,
|
|
filename,
|
|
subs_by_module,
|
|
)
|
|
.await;
|
|
let loaded_module = loaded.expect("Test module failed to load");
|
|
|
|
assert_eq!(loaded_module.can_problems, Vec::new());
|
|
assert_eq!(loaded_module.type_problems, Vec::new());
|
|
|
|
let def_count: usize = loaded_module
|
|
.declarations
|
|
.iter()
|
|
.map(|decl| decl.def_count())
|
|
.sum();
|
|
|
|
let expected_name = loaded_module
|
|
.interns
|
|
.module_ids
|
|
.get_name(loaded_module.module_id)
|
|
.expect("Test ModuleID not found in module_ids");
|
|
|
|
assert_eq!(expected_name, &InlinableString::from("Primary"));
|
|
assert_eq!(def_count, 10);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn load_unit() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module = load_fixture("no_deps", "Unit", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"unit" => "Attr * Unit",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn import_alias() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module =
|
|
load_fixture("interface_with_deps", "ImportAlias", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"unit" => "Attr * Dep1.Unit",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn load_and_typecheck() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module =
|
|
load_fixture("interface_with_deps", "WithBuiltins", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"floatTest" => "Attr Shared Float",
|
|
"divisionFn" => "Attr Shared (Attr * Float, Attr * Float -> Attr * Float)",
|
|
"divisionTest" => "Attr * Float",
|
|
"intTest" => "Attr * Int",
|
|
"x" => "Attr * Float",
|
|
"constantInt" => "Attr * Int",
|
|
"divDep1ByDep2" => "Attr * Float",
|
|
"fromDep2" => "Attr * Float",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn load_and_typecheck_quicksort() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module =
|
|
load_fixture("interface_with_deps", "Quicksort", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"swap" => "Attr * (Attr Shared Int, Attr Shared Int, Attr * (List (Attr Shared a)) -> Attr * (List (Attr Shared a)))",
|
|
"partition" => "Attr * (Attr Shared Int, Attr Shared Int, Attr b (List (Attr Shared (Num (Attr c a)))) -> Attr * [ Pair (Attr * Int) (Attr b (List (Attr Shared (Num (Attr c a))))) ])",
|
|
"quicksort" => "Attr Shared (Attr b (List (Attr Shared (Num (Attr c a)))), Attr Shared Int, Attr Shared Int -> Attr b (List (Attr Shared (Num (Attr c a)))))",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn load_principal_types() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module = load_fixture("no_deps", "Principal", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"intVal" => "Attr * Str",
|
|
"identity" => "Attr * (a -> a)",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn load_dep_types() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module =
|
|
load_fixture("interface_with_deps", "Primary", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"blah2" => "Attr * Float",
|
|
"blah3" => "Attr * Str",
|
|
"str" => "Attr * Str",
|
|
"alwaysThree" => "Attr * (* -> Attr * Str)",
|
|
"identity" => "Attr * (a -> a)",
|
|
"z" => "Attr * Dep1.Unit",
|
|
"w" => "Attr * (Dep1.Identity (Attr * {}))",
|
|
"succeed" => "Attr * (Attr b a -> Attr * (Dep1.Identity (Attr b a)))",
|
|
"yay" => "Attr * (Res.Res (Attr * {}) (Attr * err))",
|
|
"withDefault" => "Attr * (Attr * (Res.Res (Attr a b) (Attr * *)), Attr a b -> Attr a b)",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn imported_dep_regression() {
|
|
test_async(async {
|
|
let subs_by_module = MutMap::default();
|
|
let loaded_module = load_fixture("interface_with_deps", "OneDep", subs_by_module).await;
|
|
|
|
expect_types(
|
|
loaded_module,
|
|
hashmap! {
|
|
"str" => "Attr * Str",
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
// #[test]
|
|
// fn load_records() {
|
|
// test_async(async {
|
|
// use roc::types::{ErrorType, Mismatch, Problem, TypeExt};
|
|
|
|
// let subs_by_module = MutMap::default();
|
|
// let loaded_module =
|
|
// load_fixture("interface_with_deps", "Records", subs_by_module).await;
|
|
|
|
// // NOTE: `a` here is unconstrained, so unifies with <type error>
|
|
// let expected_types = hashmap! {
|
|
// "Records.intVal" => "a",
|
|
// };
|
|
|
|
// let a = ErrorType::FlexVar("a".into());
|
|
|
|
// let mut record = SendMap::default();
|
|
// record.insert("x".into(), a);
|
|
|
|
// let problem = Problem::Mismatch(
|
|
// Mismatch::TypeMismatch,
|
|
// ErrorType::Record(SendMap::default(), TypeExt::Closed),
|
|
// ErrorType::Record(record, TypeExt::FlexOpen("b".into())),
|
|
// );
|
|
|
|
// assert_eq!(loaded_module.problems, vec![problem]);
|
|
// assert_eq!(expected_types.len(), loaded_module.declarations.len());
|
|
|
|
// let mut subs = loaded_module.solved.into_inner();
|
|
|
|
// for decl in loaded_module.declarations {
|
|
// let def = match decl {
|
|
// Declare(def) => def,
|
|
// rec_decl @ DeclareRec(_) => {
|
|
// panic!(
|
|
// "Unexpected recursive def in module declarations: {:?}",
|
|
// rec_decl
|
|
// );
|
|
// }
|
|
// cycle @ InvalidCycle(_, _) => {
|
|
// panic!("Unexpected cyclic def in module declarations: {:?}", cycle);
|
|
// }
|
|
// };
|
|
|
|
// for (symbol, expr_var) in def.pattern_vars {
|
|
// let content = subs.get(expr_var).content;
|
|
|
|
// name_all_type_vars(expr_var, &mut subs);
|
|
|
|
// let actual_str = content_to_string(content, &mut subs);
|
|
// let expected_type = expected_types.get(symbol.as_str()).unwrap_or_else(|| {
|
|
// panic!("Defs included an unexpected symbol: {:?}", symbol)
|
|
// });
|
|
|
|
// assert_eq!((&symbol, expected_type), (&symbol, &actual_str.as_str()));
|
|
// }
|
|
// }
|
|
// });
|
|
// }
|
|
}
|