roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-11-13 09:49:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/trunk' into array-wrappers

Browse Source
This commit is contained in:
Richard Feldman 2020-03-13 22:19:23 -04:00
commit 8d4331f903
41 changed files with 2057 additions and 723 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
compiler/can/src/def.rs
View File

@ -674,7 +674,12 @@ fn pattern_to_vars_by_symbol(
}
}
IntLiteral(_) | FloatLiteral(_) | StrLiteral(_) | Underscore | UnsupportedPattern(_) => {}
NumLiteral(_, _)
| IntLiteral(_)
| FloatLiteral(_)
| StrLiteral(_)
| Underscore
| UnsupportedPattern(_) => {}
Shadowed(_, _) => {}
}
@ -1321,7 +1326,7 @@ fn to_pending_def<'a>(
}
}
Err(_err) => panic!("TODO gracefully handle shadowing of type alias"),
Err(err) => panic!("TODO gracefully handle shadowing of type alias {:?}", err),
}
}

12
compiler/can/src/expr.rs
View File

@ -3,7 +3,7 @@ use crate::def::{can_defs_with_return, Def};
use crate::env::Env;
use crate::num::{
finish_parsing_base, finish_parsing_float, finish_parsing_int, float_expr_from_result,
int_expr_from_result,
int_expr_from_result, num_expr_from_result,
};
use crate::pattern::{canonicalize_pattern, Pattern};
use crate::procedure::References;
@ -33,6 +33,12 @@ pub struct Output {
#[derive(Clone, Debug, PartialEq)]
pub enum Expr {
// Literals
// Num stores the `a` variable in `Num a`. Not the same as the variable
// stored in Int and Float below, which is strictly for better error messages
Num(Variable, i64),
// Int and Float store a variable to generate better error messages
Int(Variable, i64),
Float(Variable, f64),
Str(Box<str>),
@ -144,8 +150,8 @@ pub fn canonicalize_expr<'a>(
use Expr::*;
let (expr, output) = match expr {
ast::Expr::Int(string) => {
let answer = int_expr_from_result(var_store, finish_parsing_int(*string), env);
ast::Expr::Num(string) => {
let answer = num_expr_from_result(var_store, finish_parsing_int(*string), env);
(answer, Output::default())
}

23
compiler/can/src/num.rs
View File

@ -6,12 +6,34 @@ use roc_problem::can::RuntimeError::*;
use roc_types::subs::VarStore;
use std::i64;
#[inline(always)]
pub fn num_expr_from_result(
var_store: &VarStore,
result: Result<i64, &str>,
env: &mut Env,
) -> Expr {
match result {
Ok(int) => Expr::Num(var_store.fresh(), int),
Err(raw) => {
// (Num *) compiles to Int if it doesn't
// get specialized to something else first,
// so use int's overflow bounds here.
let runtime_error = IntOutsideRange(raw.into());
env.problem(Problem::RuntimeError(runtime_error.clone()));
Expr::RuntimeError(runtime_error)
}
}
}
#[inline(always)]
pub fn int_expr_from_result(
var_store: &VarStore,
result: Result<i64, &str>,
env: &mut Env,
) -> Expr {
// Int stores a variable to generate better error messages
match result {
Ok(int) => Expr::Int(var_store.fresh(), int),
Err(raw) => {
@ -30,6 +52,7 @@ pub fn float_expr_from_result(
result: Result<f64, &str>,
env: &mut Env,
) -> Expr {
// Float stores a variable to generate better error messages
match result {
Ok(float) => Expr::Float(var_store.fresh(), float),
Err(raw) => {

4
compiler/can/src/operator.rs
View File

@ -62,8 +62,8 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Located<Expr<'a>>) -> &'a
match &loc_expr.value {
Float(_)
| Nested(Float(_))
| Int(_)
| Nested(Int(_))
| Num(_)
| Nested(Num(_))
| NonBase10Int { .. }
| Nested(NonBase10Int { .. })
| Str(_)

15
compiler/can/src/pattern.rs
View File

@ -16,6 +16,7 @@ pub enum Pattern {
Identifier(Symbol),
AppliedTag(Variable, TagName, Vec<(Variable, Located<Pattern>)>),
IntLiteral(i64),
NumLiteral(Variable, i64),
FloatLiteral(f64),
StrLiteral(Box<str>),
RecordDestructure(Variable, Vec<Located<RecordDestruct>>),
@ -61,7 +62,12 @@ pub fn symbols_from_pattern_help(pattern: &Pattern, symbols: &mut Vec<Symbol>) {
}
}
IntLiteral(_) | FloatLiteral(_) | StrLiteral(_) | Underscore | UnsupportedPattern(_) => {}
NumLiteral(_, _)
| IntLiteral(_)
| FloatLiteral(_)
| StrLiteral(_)
| Underscore
| UnsupportedPattern(_) => {}
Shadowed(_, _) => {}
}
@ -155,12 +161,12 @@ pub fn canonicalize_pattern<'a>(
ptype @ DefExpr | ptype @ TopLevelDef => unsupported_pattern(env, ptype, region),
},
IntLiteral(string) => match pattern_type {
NumLiteral(string) => match pattern_type {
WhenBranch => {
let int = finish_parsing_int(string)
.unwrap_or_else(|_| panic!("TODO handle malformed int pattern"));
Pattern::IntLiteral(int)
Pattern::NumLiteral(var_store.fresh(), int)
}
ptype @ DefExpr | ptype @ TopLevelDef | ptype @ FunctionArg => {
unsupported_pattern(env, ptype, region)
@ -353,7 +359,8 @@ fn add_bindings_from_patterns(
answer.push((*symbol, *region));
}
}
IntLiteral(_)
NumLiteral(_, _)
| IntLiteral(_)
| FloatLiteral(_)
| StrLiteral(_)
| Underscore

19
compiler/can/tests/test_canonicalize.rs
View File

@ -40,6 +40,7 @@ mod test_canonicalize {
}
}
}
fn assert_can_int(input: &str, expected: i64) {
let arena = Bump::new();
let actual_out = can_expr_with(&arena, test_home(), input);
@ -54,6 +55,20 @@ mod test_canonicalize {
}
}
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]
@ -98,12 +113,12 @@ mod test_canonicalize {
#[test]
fn zero() {
assert_can_int("0", 0);
assert_can_num("0", 0);
}
#[test]
fn minus_zero() {
assert_can_int("-0", 0);
assert_can_num("-0", 0);
}
#[test]

19
compiler/constrain/src/expr.rs
View File

@ -10,7 +10,7 @@ use roc_can::expr::Expr::{self, *};
use roc_can::expr::Field;
use roc_can::pattern::Pattern;
use roc_collections::all::{ImMap, SendMap};
use roc_module::ident::{Lowercase, TagName};
use roc_module::ident::Lowercase;
use roc_module::symbol::{ModuleId, Symbol};
use roc_region::all::{Located, Region};
use roc_types::subs::Variable;
@ -80,6 +80,14 @@ pub fn constrain_expr(
) -> Constraint {
match expr {
Int(var, _) => int_literal(*var, expected, region),
Num(var, _) => exists(
vec![*var],
Eq(
Type::Apply(Symbol::NUM_NUM, vec![Type::Variable(*var)]),
expected,
region,
),
),
Float(var, _) => float_literal(*var, expected, region),
EmptyRecord => constrain_empty_record(region, expected),
Expr::Record(stored_var, fields) => {
@ -318,14 +326,7 @@ pub fn constrain_expr(
branches,
final_else,
} => {
// TODO use Bool alias here, so we don't allocate this type every time
let bool_type = Type::TagUnion(
vec![
(TagName::Global("True".into()), vec![]),
(TagName::Global("False".into()), vec![]),
],
Box::new(Type::EmptyTagUnion),
);
let bool_type = Type::Variable(Variable::BOOL);
let expect_bool = Expected::ForReason(Reason::IfCondition, bool_type, region);
let mut branch_cons = Vec::with_capacity(2 * branches.len() + 2);

15
compiler/constrain/src/pattern.rs
View File

@ -53,6 +53,7 @@ fn headers_from_annotation_help(
Underscore
| Shadowed(_, _)
| UnsupportedPattern(_)
| NumLiteral(_, _)
| IntLiteral(_)
| FloatLiteral(_)
| StrLiteral(_) => true,
@ -124,10 +125,22 @@ pub fn constrain_pattern(
},
);
}
NumLiteral(var, _) => {
state.vars.push(*var);
state.constraints.push(Constraint::Pattern(
region,
PatternCategory::Num,
builtins::builtin_type(Symbol::NUM_NUM, vec![Type::Variable(*var)]),
expected,
));
}
IntLiteral(_) => {
state.constraints.push(Constraint::Pattern(
region,
PatternCategory::Int,
PatternCategory::Float,
builtins::builtin_type(Symbol::INT_INT, vec![]),
expected,
));

52
compiler/constrain/src/uniq.rs
View File

@ -7,7 +7,7 @@ use roc_can::expected::{Expected, PExpected};
use roc_can::expr::{Expr, Field};
use roc_can::pattern::{Pattern, RecordDestruct};
use roc_collections::all::{ImMap, ImSet, SendMap};
use roc_module::ident::{Ident, Lowercase, TagName};
use roc_module::ident::{Ident, Lowercase};
use roc_module::symbol::{ModuleId, Symbol};
use roc_region::all::{Located, Region};
use roc_types::boolean_algebra::{Atom, Bool};
@ -154,6 +154,14 @@ fn constrain_pattern(
);
}
NumLiteral(inner_var, _) => {
let (num_uvar, val_uvar, num_type, num_var) = unique_unbound_num(*inner_var, var_store);
state.constraints.push(exists(
vec![val_uvar, num_uvar, num_var, *inner_var],
Constraint::Pattern(pattern.region, PatternCategory::Num, num_type, expected),
));
}
IntLiteral(_) => {
let (num_uvar, int_uvar, num_type) = unique_int(var_store);
state.constraints.push(exists(
@ -306,6 +314,23 @@ fn constrain_pattern(
}
}
fn unique_unbound_num(
inner_var: Variable,
var_store: &VarStore,
) -> (Variable, Variable, Type, Variable) {
let num_var = var_store.fresh();
let num_uvar = var_store.fresh();
let val_uvar = var_store.fresh();
let val_type = Type::Variable(inner_var);
let val_utype = attr_type(Bool::variable(val_uvar), val_type);
let num_utype = Type::Apply(Symbol::NUM_NUM, vec![val_utype]);
let num_type = attr_type(Bool::variable(num_uvar), num_utype);
(num_uvar, val_uvar, num_type, num_var)
}
fn unique_num(var_store: &VarStore, symbol: Symbol) -> (Variable, Variable, Type) {
let num_uvar = var_store.fresh();
let val_uvar = var_store.fresh();
@ -339,6 +364,22 @@ pub fn constrain_expr(
pub use roc_can::expr::Expr::*;
match expr {
Num(inner_var, _) => {
let var = var_store.fresh();
let (num_uvar, val_uvar, num_type, num_var) = unique_unbound_num(*inner_var, var_store);
exists(
vec![var, *inner_var, val_uvar, num_uvar, num_var],
And(vec![
Eq(
Type::Variable(var),
Expected::ForReason(Reason::NumLiteral, num_type, region),
region,
),
Eq(Type::Variable(var), expected, region),
]),
)
}
Int(var, _) => {
let (num_uvar, int_uvar, num_type) = unique_int(var_store);
@ -761,14 +802,7 @@ pub fn constrain_expr(
final_else,
} => {
// TODO use Bool alias here, so we don't allocate this type every time
let bool_type = Type::TagUnion(
vec![
(TagName::Global("True".into()), vec![]),
(TagName::Global("False".into()), vec![]),
],
Box::new(Type::EmptyTagUnion),
);
let bool_type = Type::Variable(Variable::BOOL);
let mut branch_cons = Vec::with_capacity(2 * branches.len() + 2);
let mut cond_uniq_vars = Vec::with_capacity(branches.len() + 2);

6
compiler/fmt/src/expr.rs
View File

@ -89,7 +89,7 @@ pub fn fmt_expr<'a>(
}
buf.push_str("\"\"\"");
}
Int(string) | Float(string) | GlobalTag(string) | PrivateTag(string) => {
Num(string) | Float(string) | GlobalTag(string) | PrivateTag(string) => {
buf.push_str(string)
}
NonBase10Int {
@ -432,7 +432,7 @@ pub fn is_multiline_pattern<'a>(pattern: &'a Pattern<'a>) -> bool {
| Pattern::Apply(_, _)
| Pattern::RecordDestructure(_)
| Pattern::RecordField(_, _)
| Pattern::IntLiteral(_)
| Pattern::NumLiteral(_)
| Pattern::NonBase10Literal { .. }
| Pattern::FloatLiteral(_)
| Pattern::StrLiteral(_)
@ -456,7 +456,7 @@ pub fn is_multiline_expr<'a>(expr: &'a Expr<'a>) -> bool {
// These expressions never have newlines
Float(_)
| Int(_)
| Num(_)
| NonBase10Int { .. }
| Str(_)
| Access(_, _)

2
compiler/fmt/src/pattern.rs
View File

@ -56,7 +56,7 @@ pub fn fmt_pattern<'a>(
fmt_pattern(buf, &loc_pattern.value, indent, true, only_comments);
}
IntLiteral(string) => buf.push_str(string),
NumLiteral(string) => buf.push_str(string),
NonBase10Literal {
base,
string,

88
compiler/gen/src/crane/build.rs
View File

@ -120,9 +120,7 @@ pub fn build_expr<'a, B: Backend>(
let fn_id = match scope.get(name) {
Some(ScopeEntry::Func{ func_id, .. }) => *func_id,
other => panic!(
"FunctionPointer could not find function named {:?} in scope; instead, found {:?} in scope {:?}",
name, other, scope
),
"FunctionPointer could not find function named {:?} declared in scope (and it was not special-cased in crane::build as a builtin); instead, found {:?} in scope {:?}", name, other, scope),
};
let func_ref = module.declare_func_in_func(fn_id, &mut builder.func);
@ -161,7 +159,10 @@ pub fn build_expr<'a, B: Backend>(
Some(ScopeEntry::Func { .. }) => {
panic!("TODO I don't yet know how to return fn pointers")
}
None => panic!("Could not find a var for {:?} in scope {:?}", name, scope),
None => panic!(
"Could not resolve lookup for {:?} because no ScopeEntry was found for {:?} in scope {:?}",
name, name, scope
),
},
Struct { layout, fields } => {
let cfg = env.cfg;
@ -194,16 +195,59 @@ pub fn build_expr<'a, B: Backend>(
builder.ins().stack_store(val, slot, Offset32::new(offset));
}
let ir_type = type_from_layout(cfg, layout);
builder.ins().stack_addr(ir_type, slot, Offset32::new(0))
builder
.ins()
.stack_addr(cfg.pointer_type(), slot, Offset32::new(0))
}
Access {
label,
field_layout,
struct_layout: Layout::Struct(fields),
record,
} => {
let cfg = env.cfg;
// Reconstruct the struct to determine the combined layout
// TODO get rid of clones
let mut reconstructed_struct_layout =
Vec::with_capacity_in(fields.len() + 1, env.arena);
for field in fields.iter() {
reconstructed_struct_layout.push(field.clone());
}
reconstructed_struct_layout.push((label.clone(), field_layout.clone()));
reconstructed_struct_layout.sort_by(|a, b| {
a.0.partial_cmp(&b.0)
.expect("TODO: failed to sort struct fields in crane access")
});
// Find the offset we are trying to access
let mut offset = 0;
for (local_label, layout) in reconstructed_struct_layout.iter() {
if local_label == label {
break;
}
let field_size = match layout {
Layout::Builtin(Builtin::Int64) => std::mem::size_of::<i64>(),
_ => panic!(
"Missing struct field size in offset calculation for struct access for {:?}",
layout
),
};
offset += field_size;
}
let offset = i32::try_from(offset)
.expect("TODO gracefully handle usize -> i32 conversion in struct access");
let mem_flags = MemFlags::new();
let record = build_expr(env, scope, module, builder, record, procs);
builder
.ins()
.load(cfg.pointer_type(), mem_flags, record, Offset32::new(offset))
}
// Access {
// label,
// field_layout,
// struct_layout,
// } => {
// panic!("I don't yet know how to crane build {:?}", expr);
// }
Str(str_literal) => {
if str_literal.is_empty() {
panic!("TODO build an empty string in Crane");
@ -572,20 +616,34 @@ fn call_by_name<'a, B: Backend>(
procs: &Procs<'a>,
) -> Value {
match symbol {
Symbol::NUM_ADD => {
Symbol::INT_ADD | Symbol::NUM_ADD => {
debug_assert!(args.len() == 2);
let a = build_arg(&args[0], env, scope, module, builder, procs);
let b = build_arg(&args[1], env, scope, module, builder, procs);
builder.ins().iadd(a, b)
}
Symbol::NUM_SUB => {
Symbol::FLOAT_ADD => {
debug_assert!(args.len() == 2);
let a = build_arg(&args[0], env, scope, module, builder, procs);
let b = build_arg(&args[1], env, scope, module, builder, procs);
builder.ins().fadd(a, b)
}
Symbol::INT_SUB | Symbol::NUM_SUB => {
debug_assert!(args.len() == 2);
let a = build_arg(&args[0], env, scope, module, builder, procs);
let b = build_arg(&args[1], env, scope, module, builder, procs);
builder.ins().isub(a, b)
}
Symbol::FLOAT_SUB => {
debug_assert!(args.len() == 2);
let a = build_arg(&args[0], env, scope, module, builder, procs);
let b = build_arg(&args[1], env, scope, module, builder, procs);
builder.ins().fsub(a, b)
}
Symbol::NUM_MUL => {
debug_assert!(args.len() == 2);
let a = build_arg(&args[0], env, scope, module, builder, procs);

17
compiler/gen/src/crane/convert.rs
View File

@ -10,23 +10,12 @@ pub fn type_from_layout(cfg: TargetFrontendConfig, layout: &Layout<'_>) -> Type
use roc_mono::layout::Layout::*;
match layout {
Pointer(_) | FunctionPointer(_, _) => cfg.pointer_type(),
Struct(fields) => {
// This will change as we add more fields and field types to the tests
let naive_all_ints = fields.iter().all(|ref field| match field.1 {
Builtin(Int64) => true,
_ => false,
});
if naive_all_ints && fields.len() == 3 {
types::I64.by(4).unwrap()
} else {
panic!("TODO layout_to_crane_type for Struct");
}
}
Pointer(_) | FunctionPointer(_, _) | Struct(_) => cfg.pointer_type(),
Builtin(builtin) => match builtin {
Int64 => types::I64,
Float64 => types::F64,
Bool(_, _) => types::B1,
Byte(_) => types::I8,
Str | EmptyStr | Map(_, _) | EmptyMap | Set(_) | EmptySet | List(_) | EmptyList => {
cfg.pointer_type()
}

108
compiler/gen/src/llvm/build.rs
View File

@ -284,6 +284,80 @@ pub fn build_expr<'a, 'ctx, 'env>(
BasicValueEnum::StructValue(struct_val.into_struct_value())
}
}
Struct { fields, .. } => {
let ctx = env.context;
let builder = env.builder;
// Sort the fields
let mut sorted_fields = Vec::with_capacity_in(fields.len(), env.arena);
for field in fields.iter() {
sorted_fields.push(field);
}
sorted_fields.sort_by_key(|k| &k.0);
// Determine types
let mut field_types = Vec::with_capacity_in(fields.len(), env.arena);
let mut field_vals = Vec::with_capacity_in(fields.len(), env.arena);
for (_, ref inner_expr) in sorted_fields.iter() {
let val = build_expr(env, &scope, parent, inner_expr, procs);
let field_type = match inner_expr {
Int(_) => BasicTypeEnum::IntType(ctx.i64_type()),
_ => panic!("I don't yet know how to get Inkwell type for {:?}", val),
};
field_types.push(field_type);
field_vals.push(val);
}
// Create the struct_type
let struct_type = ctx.struct_type(field_types.into_bump_slice(), false);
let mut struct_val = struct_type.const_zero().into();
// Insert field exprs into struct_val
for (index, field_val) in field_vals.into_iter().enumerate() {
struct_val = builder
.build_insert_value(struct_val, field_val, index as u32, "insert_field")
.unwrap();
}
BasicValueEnum::StructValue(struct_val.into_struct_value())
}
Access {
label,
field_layout,
struct_layout: Layout::Struct(fields),
record,
} => {
let builder = env.builder;
// Reconstruct struct layout
let mut reconstructed_struct_layout =
Vec::with_capacity_in(fields.len() + 1, env.arena);
for field in fields.iter() {
reconstructed_struct_layout.push(field.clone());
}
reconstructed_struct_layout.push((label.clone(), field_layout.clone()));
reconstructed_struct_layout.sort_by(|a, b| {
a.0.partial_cmp(&b.0)
.expect("TODO: failed to sort struct fields in crane access")
});
// Get index
let index = reconstructed_struct_layout
.iter()
.position(|(local_label, _)| local_label == label)
.unwrap() as u32; // TODO
// Get Struct val
let struct_val = build_expr(env, &scope, parent, record, procs).into_struct_value();
builder
.build_extract_value(struct_val, index, "field_access")
.unwrap()
}
_ => {
panic!("I don't yet know how to LLVM build {:?}", expr);
}
@ -576,35 +650,57 @@ fn call_with_args<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
) -> BasicValueEnum<'ctx> {
match symbol {
Symbol::NUM_ADD => {
Symbol::INT_ADD | Symbol::NUM_ADD => {
debug_assert!(args.len() == 2);
let int_val = env.builder.build_int_add(
args[0].into_int_value(),
args[1].into_int_value(),
"ADD_I64",
"add_i64",
);
BasicValueEnum::IntValue(int_val)
}
Symbol::NUM_SUB => {
Symbol::FLOAT_ADD => {
debug_assert!(args.len() == 2);
let float_val = env.builder.build_float_add(
args[0].into_float_value(),
args[1].into_float_value(),
"add_f64",
);
BasicValueEnum::FloatValue(float_val)
}
Symbol::INT_SUB | Symbol::NUM_SUB => {
debug_assert!(args.len() == 2);
let int_val = env.builder.build_int_sub(
args[0].into_int_value(),
args[1].into_int_value(),
"SUB_I64",
"sub_I64",
);
BasicValueEnum::IntValue(int_val)
}
Symbol::FLOAT_SUB => {
debug_assert!(args.len() == 2);
let float_val = env.builder.build_float_sub(
args[0].into_float_value(),
args[1].into_float_value(),
"sub_f64",
);
BasicValueEnum::FloatValue(float_val)
}
Symbol::NUM_MUL => {
debug_assert!(args.len() == 2);
let int_val = env.builder.build_int_mul(
args[0].into_int_value(),
args[1].into_int_value(),
"MUL_I64",
"mul_i64",
);
BasicValueEnum::IntValue(int_val)
@ -614,7 +710,7 @@ fn call_with_args<'a, 'ctx, 'env>(
let int_val = env
.builder
.build_int_neg(args[0].into_int_value(), "NEGATE_I64");
.build_int_neg(args[0].into_int_value(), "negate_i64");
BasicValueEnum::IntValue(int_val)
}

2
compiler/gen/src/llvm/convert.rs
View File

@ -62,6 +62,8 @@ pub fn basic_type_from_layout<'ctx>(
Builtin(builtin) => match builtin {
Int64 => context.i64_type().as_basic_type_enum(),
Float64 => context.f64_type().as_basic_type_enum(),
Bool(_, _) => context.bool_type().as_basic_type_enum(),
Byte(_) => context.i8_type().as_basic_type_enum(),
Str | EmptyStr => context
.i8_type()
.ptr_type(AddressSpace::Generic)

150
compiler/gen/tests/test_gen.rs
View File

@ -24,26 +24,29 @@ mod test_gen {
use inkwell::passes::PassManager;
use inkwell::types::BasicType;
use inkwell::OptimizationLevel;
use roc_collections::all::{ImMap, MutMap};
use roc_collections::all::ImMap;
use roc_gen::crane::build::{declare_proc, define_proc_body, ScopeEntry};
use roc_gen::crane::convert::type_from_layout;
use roc_gen::crane::imports::define_malloc;
use roc_gen::llvm::build::{build_proc, build_proc_header};
use roc_gen::llvm::convert::basic_type_from_layout;
use roc_mono::expr::Expr;
use roc_mono::expr::{Expr, Procs};
use roc_mono::layout::Layout;
use roc_types::subs::Subs;
use std::ffi::{CStr, CString};
use std::mem;
use std::os::raw::c_char;
// Pointer size on 64-bit platforms
const POINTER_SIZE: u32 = std::mem::size_of::<u64>() as u32;
macro_rules! assert_crane_evals_to {
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
let arena = Bump::new();
let CanExprOut { loc_expr, var_store, var, constraint, home, interns, .. } = can_expr($src);
let subs = Subs::new(var_store.into());
let mut unify_problems = Vec::new();
let (content, subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let shared_builder = settings::builder();
let shared_flags = settings::Flags::new(shared_builder);
let mut module: Module<SimpleJITBackend> =
@ -57,12 +60,12 @@ mod test_gen {
let main_fn_name = "$Test.main";
// Compute main_fn_ret_type before moving subs to Env
let layout = Layout::from_content(&arena, content, &subs)
let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
.unwrap_or_else(|err| panic!("Code gen error in test: could not convert content to layout. Err was {:?} and Subs were {:?}", err, subs));
let main_ret_type = type_from_layout(cfg, &layout);
// Compile and add all the Procs before adding main
let mut procs = MutMap::default();
let mut procs = Procs::default();
let mut env = roc_gen::crane::build::Env {
arena: &arena,
interns,
@ -72,7 +75,7 @@ mod test_gen {
let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
// Populate Procs and Subs, and get the low-level Expr from the canonical Expr
let mono_expr = Expr::new(&arena, &subs, loc_expr.value, &mut procs, home, &mut ident_ids);
let mono_expr = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
// Put this module's ident_ids back in the interns
env.interns.all_ident_ids.insert(home, ident_ids);
@ -82,9 +85,9 @@ mod test_gen {
// Declare all the Procs, then insert them into scope so their bodies
// can look up their Funcs in scope later when calling each other by value.
for (name, opt_proc) in procs.iter() {
for (name, opt_proc) in procs.as_map().into_iter() {
if let Some(proc) = opt_proc {
let (func_id, sig) = declare_proc(&env, &mut module, name.clone(), proc);
let (func_id, sig) = declare_proc(&env, &mut module, name, &proc);
declared.push((proc.clone(), sig.clone(), func_id));
@ -171,7 +174,7 @@ mod test_gen {
let CanExprOut { loc_expr, var_store, var, constraint, home, interns, .. } = can_expr($src);
let subs = Subs::new(var_store.into());
let mut unify_problems = Vec::new();
let (content, subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let context = Context::create();
let module = context.create_module("app");
@ -195,7 +198,7 @@ mod test_gen {
fpm.initialize();
// Compute main_fn_type before moving subs to Env
let layout = Layout::from_content(&arena, content, &subs)
let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
.unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
let main_fn_type = basic_type_from_layout(&context, &layout)
.fn_type(&[], false);
@ -217,11 +220,11 @@ mod test_gen {
module: arena.alloc(module),
pointer_bytes
};
let mut procs = MutMap::default();
let mut procs = Procs::default();
let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
// Populate Procs and get the low-level Expr from the canonical Expr
let main_body = Expr::new(&arena, &subs, loc_expr.value, &mut procs, home, &mut ident_ids);
let main_body = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
// Put this module's ident_ids back in the interns, so we can use them in Env.
env.interns.all_ident_ids.insert(home, ident_ids);
@ -231,7 +234,7 @@ mod test_gen {
// Add all the Proc headers to the module.
// We have to do this in a separate pass first,
// because their bodies may reference each other.
for (symbol, opt_proc) in procs.clone().into_iter() {
for (symbol, opt_proc) in procs.as_map().into_iter() {
if let Some(proc) = opt_proc {
let (fn_val, arg_basic_types) = build_proc_header(&env, symbol, &proc);
@ -268,7 +271,7 @@ mod test_gen {
&ImMap::default(),
main_fn,
&main_body,
&mut MutMap::default(),
&mut Procs::default(),
);
builder.build_return(Some(&ret));
@ -306,7 +309,7 @@ mod test_gen {
let (loc_expr, _output, _problems, subs, var, constraint, home, interns) = uniq_expr($src);
let mut unify_problems = Vec::new();
let (content, subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let context = Context::create();
let module = context.create_module("app");
@ -330,7 +333,7 @@ mod test_gen {
fpm.initialize();
// Compute main_fn_type before moving subs to Env
let layout = Layout::from_content(&arena, content, &subs)
let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
.unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
let main_fn_type = basic_type_from_layout(&context, &layout)
.fn_type(&[], false);
@ -352,11 +355,11 @@ mod test_gen {
module: arena.alloc(module),
pointer_bytes
};
let mut procs = MutMap::default();
let mut procs = Procs::default();
let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
// Populate Procs and get the low-level Expr from the canonical Expr
let main_body = Expr::new(&arena, &subs, loc_expr.value, &mut procs, home, &mut ident_ids);
let main_body = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
// Put this module's ident_ids back in the interns, so we can use them in Env.
env.interns.all_ident_ids.insert(home, ident_ids);
@ -366,12 +369,13 @@ mod test_gen {
// Add all the Proc headers to the module.
// We have to do this in a separate pass first,
// because their bodies may reference each other.
for (symbol, opt_proc) in procs.clone().into_iter() {
for (symbol, opt_proc) in procs.as_map().into_iter() {
if let Some(proc) = opt_proc {
let (fn_val, arg_basic_types) = build_proc_header(&env, symbol, &proc);
headers.push((proc, fn_val, arg_basic_types));
}
}
// Build each proc using its header info.
@ -403,7 +407,7 @@ mod test_gen {
&ImMap::default(),
main_fn,
&main_body,
&mut MutMap::default(),
&mut Procs::default(),
);
builder.build_return(Some(&ret));
@ -832,6 +836,21 @@ mod test_gen {
);
}
#[test]
fn apply_identity_() {
assert_evals_to!(
indoc!(
r#"
identity = \a -> a
identity 5
"#
),
5,
i64
);
}
#[test]
fn apply_unnamed_fn() {
assert_evals_to!(
@ -845,6 +864,19 @@ mod test_gen {
);
}
#[test]
fn gen_add_f64() {
assert_evals_to!(
indoc!(
r#"
1.1 + 2.4 + 3
"#
),
6.5,
f64
);
}
#[test]
fn gen_add_i64() {
assert_evals_to!(
@ -858,6 +890,19 @@ mod test_gen {
);
}
#[test]
fn gen_sub_f64() {
assert_evals_to!(
indoc!(
r#"
1.5 - 2.4 - 3
"#
),
-3.9,
f64
);
}
#[test]
fn gen_sub_i64() {
assert_evals_to!(
@ -914,41 +959,36 @@ mod test_gen {
);
}
// #[test]
// fn basic_record() {
// assert_evals_to!(
// indoc!(
// r#"
// point = { x: 15, y: 17, z: 19 }
#[test]
fn basic_record() {
assert_evals_to!(
indoc!(
r#"
{ y: 17, x: 15, z: 19 }.x
"#
),
15,
i64
);
// point.x
// "#
// ),
// 15,
// i64
// );
assert_evals_to!(
indoc!(
r#"
{ x: 15, y: 17, z: 19 }.y
"#
),
17,
i64
);
// assert_evals_to!(
// indoc!(
// r#"
// point = { x: 15, y: 17, z: 19 }
// point.y
// "#
// ),
// 17,
// i64
// );
// assert_evals_to!(
// indoc!(
// r#"
// point = { x: 15, y: 17, z: 19 }
// point.z
// "#
// ),
// 19,
// i64
// );
// }
assert_evals_to!(
indoc!(
r#"
{ x: 15, y: 17, z: 19 }.z
"#
),
19,
i64
);
}
}

7
compiler/load/src/file.rs
View File

@ -1048,8 +1048,11 @@ fn parse_and_constrain(
(module, ident_ids, constraint, problems)
}
Err(_runtime_error) => {
panic!("TODO gracefully handle module canonicalization error");
Err(runtime_error) => {
panic!(
"TODO gracefully handle module canonicalization error {:?}",
runtime_error
);
}
};

10
compiler/load/tests/fixtures/build/interface_with_deps/WithBuiltins.roc vendored
View File

@ -1,19 +1,19 @@
interface WithBuiltins
exposes [ floatTest, divisionFn, divisionTest, intTest, constantInt, fromDep2, divDep1ByDep2 ]
exposes [ floatTest, divisionFn, divisionTest, intTest, constantNum, fromDep2, divDep1ByDep2 ]
imports [ Dep1, Dep2.{ two } ]
floatTest = Float.highest
divisionFn = Float.div
x = 5.0
divisionTest = Float.highest / x
divisionTest = Float.highest / x
intTest = Int.highest
constantInt = 5
constantNum = 5
fromDep2 = Dep2.two
divDep1ByDep2 = Dep1.three / fromDep2

2
compiler/load/tests/test_load.rs
View File

@ -213,7 +213,7 @@ mod test_load {
"divisionTest" => "Float",
"intTest" => "Int",
"x" => "Float",
"constantInt" => "Int",
"constantNum" => "Num *",
"divDep1ByDep2" => "Float",
"fromDep2" => "Float",
},

2
compiler/load/tests/test_uniq_load.rs
View File

@ -208,7 +208,7 @@ mod test_uniq_load {
"divisionTest" => "Attr * Float",
"intTest" => "Attr * Int",
"x" => "Attr * Float",
"constantInt" => "Attr * Int",
"constantNum" => "Attr * (Num (Attr * *))",
"divDep1ByDep2" => "Attr * Float",
"fromDep2" => "Attr * Float",
},

56
compiler/module/src/symbol.rs
View File

@ -9,6 +9,14 @@ use std::{fmt, u32};
#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Symbol(u64);
// When this is `true` (which it normally should be), Symbol's Debug::fmt implementation
// attempts to pretty print debug symbols using interns recorded using
// register_debug_idents calls (which should be made in debug mode).
// Set it to false if you want to see the raw ModuleId and IdentId ints,
// but please set it back to true before checking in the result!
#[cfg(debug_assertions)]
const PRETTY_PRINT_DEBUG_SYMBOLS: bool = true;
/// In Debug builds only, Symbol has a name() method that lets
/// you look up its name in a global intern table. This table is
/// behind a mutex, so it is neither populated nor available in release builds.
@ -101,26 +109,30 @@ impl Symbol {
impl fmt::Debug for Symbol {
#[cfg(debug_assertions)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let module_id = self.module_id();
let ident_id = self.ident_id();
if PRETTY_PRINT_DEBUG_SYMBOLS {
let module_id = self.module_id();
let ident_id = self.ident_id();
match DEBUG_IDENT_IDS_BY_MODULE_ID.lock() {
Ok(names) => match &names.get(&module_id.0) {
Some(ident_ids) => match ident_ids.get_name(ident_id) {
Some(ident_str) => write!(f, "`{:?}.{}`", module_id, ident_str),
match DEBUG_IDENT_IDS_BY_MODULE_ID.lock() {
Ok(names) => match &names.get(&module_id.0) {
Some(ident_ids) => match ident_ids.get_name(ident_id) {
Some(ident_str) => write!(f, "`{:?}.{}`", module_id, ident_str),
None => fallback_debug_fmt(*self, f),
},
None => fallback_debug_fmt(*self, f),
},
None => fallback_debug_fmt(*self, f),
},
Err(err) => {
// Print and return Err rather than panicking, because this
// might be used in a panic error message, and if we panick
// while we're already panicking it'll kill the process
// without printing any of the errors!
println!("DEBUG INFO: Failed to acquire lock for Debug reading from DEBUG_IDENT_IDS_BY_MODULE_ID, presumably because a thread panicked: {:?}", err);
Err(err) => {
// Print and return Err rather than panicking, because this
// might be used in a panic error message, and if we panick
// while we're already panicking it'll kill the process
// without printing any of the errors!
println!("DEBUG INFO: Failed to acquire lock for Debug reading from DEBUG_IDENT_IDS_BY_MODULE_ID, presumably because a thread panicked: {:?}", err);
fallback_debug_fmt(*self, f)
fallback_debug_fmt(*self, f)
}
}
} else {
fallback_debug_fmt(*self, f)
}
}
@ -547,11 +559,13 @@ macro_rules! define_builtins {
};
}
// NOTE: Some of these builtins have a # at the beginning of their names.
// This is because they are for compiler use only, and should not cause
// namespace conflicts with userspace!
define_builtins! {
0 ATTR: "Attr" => {
0 ATTR: "#Attr" => {
0 UNDERSCORE: "_" // the _ used in pattern matches. This is Symbol 0.
1 ATTR_ATTR: "Attr" // the Attr.Attr type alias, used in uniqueness types
2 ATTR_AT_ATTR: "@Attr" // the Attr.@Attr private tag
1 ATTR_ATTR: "Attr" // the #Attr.Attr type alias, used in uniqueness types.
}
1 NUM: "Num" => {
0 NUM_NUM: "Num" imported // the Num.Num type alias
@ -575,6 +589,8 @@ define_builtins! {
4 INT_MOD: "mod"
5 INT_HIGHEST: "highest"
6 INT_LOWEST: "lowest"
7 INT_ADD: "#add"
8 INT_SUB: "#sub"
}
3 FLOAT: "Float" => {
0 FLOAT_FLOAT: "Float" imported // the Float.Float type alias
@ -585,6 +601,8 @@ define_builtins! {
5 FLOAT_SQRT: "sqrt"
6 FLOAT_HIGHEST: "highest"
7 FLOAT_LOWEST: "lowest"
8 FLOAT_ADD: "#add"
9 FLOAT_SUB: "#sub"
}
4 BOOL: "Bool" => {
0 BOOL_BOOL: "Bool" imported // the Bool.Bool type alias
@ -606,7 +624,7 @@ define_builtins! {
2 LIST_IS_EMPTY: "isEmpty"
3 LIST_GET: "get"
4 LIST_SET: "set"
5 LIST_SET_IN_PLACE: "set_in_place"
5 LIST_SET_IN_PLACE: "#setInPlace"
6 LIST_PUSH: "push"
7 LIST_MAP: "map"
8 LIST_LEN: "len"

629
compiler/mono/src/expr.rs
View File

@ -3,16 +3,95 @@ use bumpalo::collections::Vec;
use bumpalo::Bump;
use roc_can;
use roc_can::pattern::Pattern;
use roc_collections::all::MutMap;
use roc_collections::all::{MutMap, MutSet};
use roc_module::ident::{Lowercase, TagName};
use roc_module::symbol::{IdentIds, ModuleId, Symbol};
use roc_region::all::Located;
use roc_types::subs::{Content, FlatType, Subs, Variable};
use roc_types::subs::{Content, ContentHash, FlatType, Subs, Variable};
pub type Procs<'a> = MutMap<Symbol, Option<Proc<'a>>>;
#[derive(Clone, Debug, PartialEq, Default)]
pub struct Procs<'a> {
user_defined: MutMap<Symbol, PartialProc<'a>>,
anonymous: MutMap<Symbol, Option<Proc<'a>>>,
builtin: MutSet<Symbol>,
}
impl<'a> Procs<'a> {
fn insert_user_defined(&mut self, symbol: Symbol, partial_proc: PartialProc<'a>) {
self.user_defined.insert(symbol, partial_proc);
}
fn insert_anonymous(&mut self, symbol: Symbol, proc: Option<Proc<'a>>) {
self.anonymous.insert(symbol, proc);
}
fn insert_specialization(
&mut self,
symbol: Symbol,
hash: ContentHash,
spec_name: Symbol,
proc: Option<Proc<'a>>,
) {
self.user_defined
.get_mut(&symbol)
.map(|partial_proc| partial_proc.specializations.insert(hash, (spec_name, proc)));
}
fn get_user_defined(&self, symbol: Symbol) -> Option<&PartialProc<'a>> {
self.user_defined.get(&symbol)
}
pub fn len(&self) -> usize {
let anonymous: usize = self.anonymous.len();
let user_defined: usize = self
.user_defined
.values()
.map(|v| v.specializations.len())
.sum();
anonymous + user_defined
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
fn insert_builtin(&mut self, symbol: Symbol) {
self.builtin.insert(symbol);
}
pub fn as_map(&self) -> MutMap<Symbol, Option<Proc<'a>>> {
let mut result = MutMap::default();
for partial_proc in self.user_defined.values() {
for (_, (symbol, opt_proc)) in partial_proc.specializations.clone().into_iter() {
result.insert(symbol, opt_proc);
}
}
for (symbol, proc) in self.anonymous.clone().into_iter() {
result.insert(symbol, proc);
}
for symbol in self.builtin.iter() {
result.insert(*symbol, None);
}
result
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct PartialProc<'a> {
pub annotation: Variable,
pub patterns: Vec<'a, Symbol>,
pub body: roc_can::expr::Expr,
pub specializations: MutMap<ContentHash, (Symbol, Option<Proc<'a>>)>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Proc<'a> {
pub name: Symbol,
pub args: &'a [(Layout<'a>, Symbol)],
pub body: Expr<'a>,
pub closes_over: Layout<'a>,
@ -21,9 +100,24 @@ pub struct Proc<'a> {
struct Env<'a, 'i> {
pub arena: &'a Bump,
pub subs: &'a Subs,
pub subs: &'a mut Subs,
pub home: ModuleId,
pub ident_ids: &'i mut IdentIds,
pub pointer_size: u32,
symbol_counter: usize,
}
impl<'a, 'i> Env<'a, 'i> {
pub fn fresh_symbol(&mut self) -> Symbol {
let ident_id = self
.ident_ids
.add(format!("_{}", self.symbol_counter).into());
self.symbol_counter += 1;
self.home.register_debug_idents(&self.ident_ids);
Symbol::new(self.home, ident_id)
}
}
#[derive(Clone, Debug, PartialEq)]
@ -89,7 +183,6 @@ pub enum Expr<'a> {
},
Tag {
tag_layout: Layout<'a>,
ext_layout: Layout<'a>,
name: TagName,
arguments: &'a [Expr<'a>],
},
@ -101,6 +194,7 @@ pub enum Expr<'a> {
label: Lowercase,
field_layout: Layout<'a>,
struct_layout: Layout<'a>,
record: &'a Expr<'a>,
},
Array {
@ -114,23 +208,156 @@ pub enum Expr<'a> {
impl<'a> Expr<'a> {
pub fn new(
arena: &'a Bump,
subs: &'a Subs,
subs: &'a mut Subs,
can_expr: roc_can::expr::Expr,
procs: &mut Procs<'a>,
home: ModuleId,
ident_ids: &mut IdentIds,
pointer_size: u32,
) -> Self {
let mut env = Env {
arena,
subs,
home,
ident_ids,
pointer_size,
symbol_counter: 0,
};
from_can(&mut env, can_expr, procs, None)
}
}
enum IntOrFloat {
IntType,
FloatType,
}
fn to_int_or_float(subs: &Subs, var: Variable) -> IntOrFloat {
match subs.get_without_compacting(var).content {
Content::Alias(Symbol::INT_INTEGER, args, _) => {
debug_assert!(args.is_empty());
IntOrFloat::IntType
}
Content::FlexVar(_) => {
// If this was still a (Num *), assume compiling it to an Int
IntOrFloat::IntType
}
Content::Alias(Symbol::FLOAT_FLOATINGPOINT, args, _) => {
debug_assert!(args.is_empty());
IntOrFloat::FloatType
}
Content::Alias(Symbol::NUM_NUM, args, _) => {
debug_assert!(args.len() == 1);
match subs.get_without_compacting(args[0].1).content {
Content::Alias(Symbol::INT_INTEGER, args, _) => {
debug_assert!(args.is_empty());
IntOrFloat::IntType
}
Content::FlexVar(_) => {
// If this was still a (Num *), assume compiling it to an Int
IntOrFloat::IntType
}
Content::Alias(Symbol::FLOAT_FLOATINGPOINT, args, _) => {
debug_assert!(args.is_empty());
IntOrFloat::FloatType
}
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, attr_args)) => {
debug_assert!(attr_args.len() == 2);
// Recurse on the second argument
to_int_or_float(subs, attr_args[1])
}
other => panic!(
"Unrecognized Num.Num alias type argument Content: {:?}",
other
),
}
}
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, attr_args)) => {
debug_assert!(attr_args.len() == 2);
// Recurse on the second argument
to_int_or_float(subs, attr_args[1])
}
other => panic!("Unrecognized Num type argument Content: {:?}", other),
}
}
fn patterns_to_when<'a>(
env: &mut Env<'a, '_>,
patterns: std::vec::Vec<(Variable, Located<roc_can::pattern::Pattern>)>,
body_var: Variable,
mut body: Located<roc_can::expr::Expr>,
) -> (
Vec<'a, Variable>,
Vec<'a, Symbol>,
Located<roc_can::expr::Expr>,
) {
let mut arg_vars = Vec::with_capacity_in(patterns.len(), env.arena);
let mut symbols = Vec::with_capacity_in(patterns.len(), env.arena);
for (pattern_var, pattern) in patterns.into_iter().rev() {
let (new_symbol, new_body) = pattern_to_when(env, pattern_var, pattern, body_var, body);
body = new_body;
symbols.push(new_symbol);
arg_vars.push(pattern_var);
}
(arg_vars, symbols, body)
}
/// turn irrefutable patterns into when. For example
///
/// foo = \{ x } -> body
///
/// Assuming the above program typechecks, the pattern match cannot fail
/// (it is irrefutable). It becomes
///
/// foo = \r ->
/// when r is
/// { x } -> body
///
/// conversion of one-pattern when expressions will do the most optimal thing
fn pattern_to_when<'a>(
env: &mut Env<'a, '_>,
pattern_var: Variable,
pattern: Located<roc_can::pattern::Pattern>,
body_var: Variable,
body: Located<roc_can::expr::Expr>,
) -> (Symbol, Located<roc_can::expr::Expr>) {
use roc_can::expr::Expr::*;
use roc_can::pattern::Pattern::*;
match &pattern.value {
Identifier(symbol) => (*symbol, body),
Underscore => {
// for underscore we generate a dummy Symbol
(env.fresh_symbol(), body)
}
AppliedTag(_, _, _) | RecordDestructure(_, _) | Shadowed(_, _) | UnsupportedPattern(_) => {
let symbol = env.fresh_symbol();
let wrapped_body = When {
cond_var: pattern_var,
expr_var: body_var,
loc_cond: Box::new(Located::at_zero(Var(symbol))),
branches: vec![(pattern, body)],
};
(symbol, Located::at_zero(wrapped_body))
}
// These patters are refutable, and thus should never occur outside a `when` expression
IntLiteral(_) | NumLiteral(_,_) | FloatLiteral(_) | StrLiteral(_) => {
unreachable!("refutable pattern {:?} where irrefutable pattern is expected. This should never happen!", pattern.value)
}
}
}
fn from_can<'a>(
env: &mut Env<'a, '_>,
can_expr: roc_can::expr::Expr,
@ -141,8 +368,12 @@ fn from_can<'a>(
use roc_can::pattern::Pattern::*;
match can_expr {
Int(_, val) => Expr::Int(val),
Float(_, val) => Expr::Float(val),
Num(var, num) => match to_int_or_float(env.subs, var) {
IntOrFloat::IntType => Expr::Int(num),
IntOrFloat::FloatType => Expr::Float(num as f64),
},
Int(_, num) => Expr::Int(num),
Float(_, num) => Expr::Float(num),
Str(string) | BlockStr(string) => Expr::Str(env.arena.alloc(string)),
Var(symbol) => Expr::Load(symbol),
LetNonRec(def, ret_expr, _, _) => {
@ -192,22 +423,88 @@ fn from_can<'a>(
Expr::Store(stored.into_bump_slice(), arena.alloc(ret))
}
Closure(_, _, _, loc_args, boxed_body) => {
Closure(annotation, _, _, loc_args, boxed_body) => {
let (loc_body, ret_var) = *boxed_body;
let symbol =
name.unwrap_or_else(|| gen_closure_name(procs, &mut env.ident_ids, env.home));
add_closure(env, symbol, loc_body.value, ret_var, &loc_args, procs)
// turn record/tag patterns into a when expression, e.g.
//
// foo = \{ x } -> body
//
// becomes
//
// foo = \r -> when r is { x } -> body
//
// conversion of one-pattern when expressions will do the most optimal thing
let (arg_vars, arg_symbols, body) = patterns_to_when(env, loc_args, ret_var, loc_body);
let symbol = match name {
Some(symbol) => {
// a named closure
procs.insert_user_defined(
symbol,
PartialProc {
annotation,
patterns: arg_symbols,
body: body.value,
specializations: MutMap::default(),
},
);
symbol
}
None => {
// an anonymous closure. These will always be specialized already
// by the surrounding context
let symbol = env.fresh_symbol();
// Has the side-effect of monomorphizing record types
// turning the ext_var into EmptyRecord or EmptyTagUnion
let _ = ContentHash::from_var(annotation, env.subs);
let opt_proc = specialize_proc_body(
env,
procs,
annotation,
ret_var,
symbol,
&arg_vars,
&arg_symbols,
annotation,
body.value,
);
procs.insert_anonymous(symbol, opt_proc);
symbol
}
};
Expr::FunctionPointer(symbol)
}
Call(boxed, loc_args, _) => {
let (fn_var, loc_expr, _) = *boxed;
use IntOrFloat::*;
let (fn_var, loc_expr, ret_var) = *boxed;
let specialize_builtin_functions = {
|symbol, subs: &Subs| match symbol {
Symbol::NUM_ADD => match to_int_or_float(subs, ret_var) {
FloatType => Symbol::FLOAT_ADD,
IntType => Symbol::INT_ADD,
},
Symbol::NUM_SUB => match to_int_or_float(subs, ret_var) {
FloatType => Symbol::FLOAT_SUB,
IntType => Symbol::INT_SUB,
},
_ => symbol,
}
};
match from_can(env, loc_expr.value, procs, None) {
Expr::Load(proc_name) => {
// Some functions can potentially mutate in-place.
// If we have one of those, switch to the in-place version if appropriate.
match proc_name {
match specialize_builtin_functions(proc_name, &env.subs) {
Symbol::LIST_SET => {
let subs = &env.subs;
// The first arg is the one with the List in it.
@ -234,12 +531,19 @@ fn from_can<'a>(
Symbol::LIST_SET
};
call_by_name(env, procs, new_name, loc_args)
call_by_name(env, procs, fn_var, ret_var, new_name, loc_args)
}
_ => call_by_name(env, procs, proc_name, loc_args),
_ => call_by_name(env, procs, fn_var, ret_var, proc_name, loc_args),
}
}
_ => call_by_name(env, procs, proc_name, loc_args),
specialized_proc_symbol => call_by_name(
env,
procs,
fn_var,
ret_var,
specialized_proc_symbol,
loc_args,
),
}
}
ptr => {
@ -256,8 +560,8 @@ fn from_can<'a>(
args.push(from_can(env, loc_arg.value, procs, None));
}
let layout =
Layout::from_var(env.arena, fn_var, env.subs).unwrap_or_else(|err| {
let layout = Layout::from_var(env.arena, fn_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| {
panic!("TODO turn fn_var into a RuntimeError {:?}", err)
});
Expr::CallByPointer(&*env.arena.alloc(ptr), args.into_bump_slice(), layout)
@ -273,7 +577,6 @@ fn from_can<'a>(
} => from_can_when(env, cond_var, expr_var, *loc_cond, branches, procs),
Record(ext_var, fields) => {
let subs = env.subs;
let arena = env.arena;
let mut field_bodies = Vec::with_capacity_in(fields.len(), arena);
@ -283,7 +586,7 @@ fn from_can<'a>(
field_bodies.push((label, expr));
}
let struct_layout = match Layout::from_var(arena, ext_var, subs) {
let struct_layout = match Layout::from_var(arena, ext_var, env.subs, env.pointer_size) {
Ok(layout) => layout,
Err(()) => {
// Invalid field!
@ -297,16 +600,49 @@ fn from_can<'a>(
}
}
Tag {
variant_var,
name,
arguments: args,
..
} => {
let arena = env.arena;
match Layout::from_var(arena, variant_var, &env.subs, env.pointer_size) {
Ok(Layout::Builtin(Builtin::Bool(_smaller, larger))) => Expr::Bool(name == larger),
Ok(Layout::Builtin(Builtin::Byte(tags))) => match tags.get(&name) {
Some(v) => Expr::Byte(*v),
None => panic!("Tag name is not part of the type"),
},
Ok(layout) => {
let mut arguments = Vec::with_capacity_in(args.len(), arena);
for (_, arg) in args {
arguments.push(from_can(env, arg.value, procs, None));
}
Expr::Tag {
tag_layout: layout,
name,
arguments: arguments.into_bump_slice(),
}
}
Err(()) => {
// Invalid field!
panic!("TODO gracefully handle Access with invalid struct_layout");
}
}
}
Access {
ext_var,
field_var,
field,
..
loc_expr,
} => {
let subs = env.subs;
let arena = env.arena;
let struct_layout = match Layout::from_var(arena, ext_var, subs) {
let struct_layout = match Layout::from_var(arena, ext_var, env.subs, env.pointer_size) {
Ok(layout) => layout,
Err(()) => {
// Invalid field!
@ -314,7 +650,8 @@ fn from_can<'a>(
}
};
let field_layout = match Layout::from_var(arena, field_var, subs) {
let field_layout = match Layout::from_var(arena, field_var, env.subs, env.pointer_size)
{
Ok(layout) => layout,
Err(()) => {
// Invalid field!
@ -322,10 +659,13 @@ fn from_can<'a>(
}
};
let record = arena.alloc(from_can(env, loc_expr.value, procs, None));
Expr::Access {
label: field,
field_layout,
struct_layout,
record,
}
}
@ -333,9 +673,8 @@ fn from_can<'a>(
elem_var,
loc_elems,
} => {
let subs = env.subs;
let arena = env.arena;
let elem_layout = match Layout::from_var(arena, elem_var, subs) {
let elem_layout = match Layout::from_var(arena, elem_var, env.subs, env.pointer_size) {
Ok(layout) => layout,
Err(()) => {
panic!("TODO gracefully handle List with invalid element layout");
@ -353,58 +692,10 @@ fn from_can<'a>(
elems: elems.into_bump_slice(),
}
}
other => panic!("TODO convert canonicalized {:?} to ll::Expr", other),
other => panic!("TODO convert canonicalized {:?} to mono::Expr", other),
}
}
fn add_closure<'a>(
env: &mut Env<'a, '_>,
symbol: Symbol,
can_body: roc_can::expr::Expr,
ret_var: Variable,
loc_args: &[(Variable, Located<Pattern>)],
procs: &mut Procs<'a>,
) -> Expr<'a> {
let subs = &env.subs;
let arena = env.arena;
let mut proc_args = Vec::with_capacity_in(loc_args.len(), arena);
for (arg_var, loc_arg) in loc_args.iter() {
let layout = match Layout::from_var(arena, *arg_var, subs) {
Ok(layout) => layout,
Err(()) => {
// Invalid closure!
procs.insert(symbol, None);
return Expr::FunctionPointer(symbol);
}
};
let arg_name: Symbol = match &loc_arg.value {
Pattern::Identifier(symbol) => *symbol,
_ => {
panic!("TODO determine arg_name for pattern {:?}", loc_arg.value);
}
};
proc_args.push((layout, arg_name));
}
let ret_layout = Layout::from_var(arena, ret_var, subs)
.unwrap_or_else(|err| panic!("TODO handle invalid function {:?}", err));
let proc = Proc {
args: proc_args.into_bump_slice(),
body: from_can(env, can_body, procs, None),
closes_over: Layout::Struct(&[]),
ret_layout,
};
procs.insert(symbol, Some(proc));
Expr::FunctionPointer(symbol)
}
fn store_pattern<'a>(
env: &mut Env<'a, '_>,
can_pat: Pattern,
@ -415,7 +706,7 @@ fn store_pattern<'a>(
) {
use roc_can::pattern::Pattern::*;
let layout = match Layout::from_var(env.arena, var, env.subs) {
let layout = match Layout::from_var(env.arena, var, env.subs, env.pointer_size) {
Ok(layout) => layout,
Err(()) => {
panic!("TODO gen a runtime error here");
@ -451,12 +742,6 @@ fn store_pattern<'a>(
}
}
fn gen_closure_name(procs: &Procs<'_>, ident_ids: &mut IdentIds, home: ModuleId) -> Symbol {
let ident_id = ident_ids.add(format!("_{}", procs.len()).into());
Symbol::new(home, ident_id)
}
fn from_can_when<'a>(
env: &mut Env<'a, '_>,
cond_var: Variable,
@ -504,13 +789,37 @@ fn from_can_when<'a>(
let (loc_when_pat2, loc_else) = iter.next().unwrap();
match (&loc_when_pat1.value, &loc_when_pat2.value) {
(NumLiteral(var, num), NumLiteral(_, _)) | (NumLiteral(var, num), Underscore) => {
let cond_lhs = arena.alloc(from_can(env, loc_cond.value, procs, None));
let (builtin, cond_rhs_expr) = match to_int_or_float(env.subs, *var) {
IntOrFloat::IntType => (Builtin::Int64, Expr::Int(*num)),
IntOrFloat::FloatType => (Builtin::Float64, Expr::Float(*num as f64)),
};
let cond_rhs = arena.alloc(cond_rhs_expr);
let pass = arena.alloc(from_can(env, loc_then.value, procs, None));
let fail = arena.alloc(from_can(env, loc_else.value, procs, None));
let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| {
panic!("TODO turn this into a RuntimeError {:?}", err)
});
Expr::Cond {
cond_layout: Layout::Builtin(builtin),
cond_lhs,
cond_rhs,
pass,
fail,
ret_layout,
}
}
(IntLiteral(int), IntLiteral(_)) | (IntLiteral(int), Underscore) => {
let cond_lhs = arena.alloc(from_can(env, loc_cond.value, procs, None));
let cond_rhs = arena.alloc(Expr::Int(*int));
let pass = arena.alloc(from_can(env, loc_then.value, procs, None));
let fail = arena.alloc(from_can(env, loc_else.value, procs, None));
let ret_layout =
Layout::from_var(arena, expr_var, env.subs).unwrap_or_else(|err| {
let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| {
panic!("TODO turn this into a RuntimeError {:?}", err)
});
@ -528,8 +837,8 @@ fn from_can_when<'a>(
let cond_rhs = arena.alloc(Expr::Float(*float));
let pass = arena.alloc(from_can(env, loc_then.value, procs, None));
let fail = arena.alloc(from_can(env, loc_else.value, procs, None));
let ret_layout =
Layout::from_var(arena, expr_var, env.subs).unwrap_or_else(|err| {
let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| {
panic!("TODO turn this into a RuntimeError {:?}", err)
});
@ -552,7 +861,7 @@ fn from_can_when<'a>(
let arena = env.arena;
let cond = from_can(env, loc_cond.value, procs, None);
let subs = &env.subs;
let layout = Layout::from_var(arena, cond_var, subs)
let layout = Layout::from_var(arena, cond_var, subs, env.pointer_size)
.unwrap_or_else(|_| panic!("TODO generate a runtime error in from_can_when here!"));
// We can Switch on integers and tags, because they both have
@ -579,6 +888,22 @@ fn from_can_when<'a>(
let mono_expr = from_can(env, loc_expr.value, procs, None);
match &loc_when_pat.value {
NumLiteral(var, num) => {
// This is jumpable iff it's an int
match to_int_or_float(env.subs, *var) {
IntOrFloat::IntType => {
jumpable_branches.push((*num as u64, mono_expr));
}
IntOrFloat::FloatType => {
// The type checker should have converted these mismatches into RuntimeErrors already!
if cfg!(debug_assertions) {
panic!("A type mismatch in a pattern was not converted to a runtime error: {:?}", loc_when_pat);
} else {
unreachable!();
}
}
};
}
IntLiteral(int) => {
// Switch only compares the condition to the
// alternatives based on their bit patterns,
@ -633,12 +958,12 @@ fn from_can_when<'a>(
debug_assert!(opt_default_branch.is_some());
let default_branch = opt_default_branch.unwrap();
let cond_layout =
Layout::from_var(arena, cond_var, env.subs).unwrap_or_else(|err| {
let cond_layout = Layout::from_var(arena, cond_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| {
panic!("TODO turn cond_layout into a RuntimeError {:?}", err)
});
let ret_layout =
Layout::from_var(arena, expr_var, env.subs).unwrap_or_else(|err| {
let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| {
panic!("TODO turn ret_layout into a RuntimeError {:?}", err)
});
@ -670,19 +995,131 @@ fn from_can_when<'a>(
fn call_by_name<'a>(
env: &mut Env<'a, '_>,
procs: &mut Procs<'a>,
fn_var: Variable,
ret_var: Variable,
proc_name: Symbol,
loc_args: std::vec::Vec<(Variable, Located<roc_can::expr::Expr>)>,
) -> Expr<'a> {
// create specialized procedure to call
// If we need to specialize the body, this will get populated with the info
// we need to do that. This is defined outside the procs.get_user_defined(...) call
// because if we tried to specialize the body inside that match, we would
// get a borrow checker error about trying to borrow `procs` as mutable
// while there is still an active immutable borrow.
#[allow(clippy::type_complexity)]
let opt_specialize_body: Option<(
ContentHash,
Variable,
roc_can::expr::Expr,
Vec<'a, Symbol>,
)>;
let specialized_proc_name = if let Some(partial_proc) = procs.get_user_defined(proc_name) {
let content_hash = ContentHash::from_var(fn_var, env.subs);
if let Some(specialization) = partial_proc.specializations.get(&content_hash) {
opt_specialize_body = None;
// a specialization with this type hash already exists, use its symbol
specialization.0
} else {
opt_specialize_body = Some((
content_hash,
partial_proc.annotation,
partial_proc.body.clone(),
partial_proc.patterns.clone(),
));
// generate a symbol for this specialization
env.fresh_symbol()
}
} else {
opt_specialize_body = None;
// This happens for built-in symbols (they are never defined as a Closure)
procs.insert_builtin(proc_name);
proc_name
};
if let Some((content_hash, annotation, body, loc_patterns)) = opt_specialize_body {
// register proc, so specialization doesn't loop infinitely
procs.insert_specialization(proc_name, content_hash, specialized_proc_name, None);
let arg_vars = loc_args.iter().map(|v| v.0).collect::<std::vec::Vec<_>>();
let proc = specialize_proc_body(
env,
procs,
fn_var,
ret_var,
specialized_proc_name,
&arg_vars,
&loc_patterns,
annotation,
body,
);
procs.insert_specialization(proc_name, content_hash, specialized_proc_name, proc);
}
// generate actual call
let mut args = Vec::with_capacity_in(loc_args.len(), env.arena);
let subs = env.subs;
let arena = env.arena;
for (var, loc_arg) in loc_args {
let layout = Layout::from_var(arena, var, subs)
let layout = Layout::from_var(&env.arena, var, &env.subs, env.pointer_size)
.unwrap_or_else(|err| panic!("TODO gracefully handle bad layout: {:?}", err));
args.push((from_can(env, loc_arg.value, procs, None), layout));
}
Expr::CallByName(proc_name, args.into_bump_slice())
Expr::CallByName(specialized_proc_name, args.into_bump_slice())
}
#[allow(clippy::too_many_arguments)]
fn specialize_proc_body<'a>(
env: &mut Env<'a, '_>,
procs: &mut Procs<'a>,
fn_var: Variable,
ret_var: Variable,
proc_name: Symbol,
loc_args: &[Variable],
pattern_symbols: &[Symbol],
annotation: Variable,
body: roc_can::expr::Expr,
) -> Option<Proc<'a>> {
// unify the called function with the specialized signature, then specialize the function body
let snapshot = env.subs.snapshot();
let unified = roc_unify::unify::unify(env.subs, annotation, fn_var);
debug_assert!(unified.mismatches.is_empty());
let specialized_body = from_can(env, body, procs, None);
// reset subs, so we don't get type errors when specializing for a different signature
env.subs.rollback_to(snapshot);
let mut proc_args = Vec::with_capacity_in(loc_args.len(), &env.arena);
for (arg_var, arg_name) in loc_args.iter().zip(pattern_symbols.iter()) {
let layout = match Layout::from_var(&env.arena, *arg_var, env.subs, env.pointer_size) {
Ok(layout) => layout,
Err(()) => {
// Invalid closure!
return None;
}
};
proc_args.push((layout, *arg_name));
}
let ret_layout = Layout::from_var(&env.arena, ret_var, env.subs, env.pointer_size)
.unwrap_or_else(|err| panic!("TODO handle invalid function {:?}", err));
let proc = Proc {
name: proc_name,
args: proc_args.into_bump_slice(),
body: specialized_body,
closes_over: Layout::Struct(&[]),
ret_layout,
};
Some(proc)
}

119
compiler/mono/src/layout.rs
View File

@ -19,6 +19,8 @@ pub enum Layout<'a> {
pub enum Builtin<'a> {
Int64,
Float64,
Bool(TagName, TagName),
Byte(MutMap<TagName, u8>),
Str,
Map(&'a Layout<'a>, &'a Layout<'a>),
Set(&'a Layout<'a>),
@ -33,20 +35,30 @@ impl<'a> Layout<'a> {
/// Returns Err(()) if given an error, or Ok(Layout) if given a non-erroneous Structure.
/// Panics if given a FlexVar or RigidVar, since those should have been
/// monomorphized away already!
pub fn from_var(arena: &'a Bump, var: Variable, subs: &Subs) -> Result<Self, ()> {
pub fn from_var(
arena: &'a Bump,
var: Variable,
subs: &Subs,
pointer_size: u32,
) -> Result<Self, ()> {
let content = subs.get_without_compacting(var).content;
Self::from_content(arena, content, subs)
Self::from_content(arena, content, subs, pointer_size)
}
pub fn from_content(arena: &'a Bump, content: Content, subs: &Subs) -> Result<Self, ()> {
pub fn from_content(
arena: &'a Bump,
content: Content,
subs: &Subs,
pointer_size: u32,
) -> Result<Self, ()> {
use roc_types::subs::Content::*;
match content {
var @ FlexVar(_) | var @ RigidVar(_) => {
panic!("Layout::from_content encountered an unresolved {:?}", var);
}
Structure(flat_type) => layout_from_flat_type(arena, flat_type, subs),
Structure(flat_type) => layout_from_flat_type(arena, flat_type, subs, pointer_size),
Alias(Symbol::INT_INT, args, _) => {
debug_assert!(args.is_empty());
@ -56,9 +68,12 @@ impl<'a> Layout<'a> {
debug_assert!(args.is_empty());
Ok(Layout::Builtin(Builtin::Float64))
}
Alias(_, _, var) => {
Self::from_content(arena, subs.get_without_compacting(var).content, subs)
}
Alias(_, _, var) => Self::from_content(
arena,
subs.get_without_compacting(var).content,
subs,
pointer_size,
),
Error => Err(()),
}
}
@ -85,6 +100,8 @@ impl<'a> Layout<'a> {
impl<'a> Builtin<'a> {
const I64_SIZE: u32 = std::mem::size_of::<i64>() as u32;
const F64_SIZE: u32 = std::mem::size_of::<f64>() as u32;
const BOOL_SIZE: u32 = std::mem::size_of::<bool>() as u32;
const BYTE_SIZE: u32 = std::mem::size_of::<u8>() as u32;
/// Number of machine words in an empty one of these
const STR_WORDS: u32 = 3;
@ -103,6 +120,8 @@ impl<'a> Builtin<'a> {
match self {
Int64 => Builtin::I64_SIZE,
Float64 => Builtin::F64_SIZE,
Bool(_, _) => Builtin::BOOL_SIZE,
Byte(_) => Builtin::BYTE_SIZE,
Str | EmptyStr => Builtin::STR_WORDS * pointer_size,
Map(_, _) | EmptyMap => Builtin::MAP_WORDS * pointer_size,
Set(_) | EmptySet => Builtin::SET_WORDS * pointer_size,
@ -115,6 +134,7 @@ fn layout_from_flat_type<'a>(
arena: &'a Bump,
flat_type: FlatType,
subs: &Subs,
pointer_size: u32,
) -> Result<Layout<'a>, ()> {
use roc_types::subs::FlatType::*;
@ -145,7 +165,8 @@ fn layout_from_flat_type<'a>(
match subs.get_without_compacting(args[0]).content {
FlexVar(_) | RigidVar(_) => Ok(Layout::Builtin(Builtin::EmptyList)),
content => {
let elem_layout = Layout::from_content(arena, content, subs)?;
let elem_layout =
Layout::from_content(arena, content, subs, pointer_size)?;
Ok(Layout::Builtin(Builtin::List(arena.alloc(elem_layout))))
}
@ -161,7 +182,7 @@ fn layout_from_flat_type<'a>(
// For now, layout is unaffected by uniqueness.
// (Incorporating refcounting may change this.)
// Unwrap and continue
Layout::from_var(arena, wrapped_var, subs)
Layout::from_var(arena, wrapped_var, subs, pointer_size)
}
_ => {
panic!("TODO layout_from_flat_type for {:?}", Apply(symbol, args));
@ -174,11 +195,16 @@ fn layout_from_flat_type<'a>(
for arg_var in args {
let arg_content = subs.get_without_compacting(arg_var).content;
fn_args.push(Layout::from_content(arena, arg_content, subs)?);
fn_args.push(Layout::from_content(
arena,
arg_content,
subs,
pointer_size,
)?);
}
let ret_content = subs.get_without_compacting(ret_var).content;
let ret = Layout::from_content(arena, ret_content, subs)?;
let ret = Layout::from_content(arena, ret_content, subs, pointer_size)?;
Ok(Layout::FunctionPointer(
fn_args.into_bump_slice(),
@ -188,7 +214,7 @@ fn layout_from_flat_type<'a>(
Record(mut fields, ext_var) => {
flatten_record(&mut fields, ext_var, subs);
let ext_content = subs.get_without_compacting(ext_var).content;
let ext_layout = match Layout::from_content(arena, ext_content, subs) {
let ext_layout = match Layout::from_content(arena, ext_content, subs, pointer_size) {
Ok(layout) => layout,
Err(()) => {
// Invalid record!
@ -216,13 +242,14 @@ fn layout_from_flat_type<'a>(
for (label, field_var) in fields {
let field_content = subs.get_without_compacting(field_var).content;
let field_layout = match Layout::from_content(arena, field_content, subs) {
Ok(layout) => layout,
Err(()) => {
// Invalid field!
panic!("TODO gracefully handle record with invalid field.var");
}
};
let field_layout =
match Layout::from_content(arena, field_content, subs, pointer_size) {
Ok(layout) => layout,
Err(()) => {
// Invalid field!
panic!("TODO gracefully handle record with invalid field.var");
}
};
field_layouts.push((label.clone(), field_layout));
}
@ -259,7 +286,50 @@ fn layout_from_flat_type<'a>(
}
}
_ => {
panic!("TODO handle a tag union with mutliple tags: {:?}", tags);
// Check if we can turn this tag union into an enum
// The arguments of all tags must have size 0.
// That is trivially the case when there are no arguments
//
// [ Orange, Apple, Banana ]
//
// But when one-tag tag unions are optimized away, we can also use an enum for
//
// [ Foo [ Unit ], Bar [ Unit ] ]
let arguments_have_size_0 = || {
tags.iter().all(|(_, args)| {
args.iter().all(|var| {
Layout::from_var(arena, *var, subs, pointer_size)
.map(|v| v.stack_size(pointer_size))
== Ok(0)
})
})
};
// up to 256 enum keys can be stored in a byte
if tags.len() <= std::u8::MAX as usize + 1 && arguments_have_size_0() {
if tags.len() <= 2 {
// Up to 2 enum tags can be stored (in theory) in one bit
let mut it = tags.keys();
let a: TagName = it.next().unwrap().clone();
let b: TagName = it.next().unwrap().clone();
if a < b {
Ok(Layout::Builtin(Builtin::Bool(a, b)))
} else {
Ok(Layout::Builtin(Builtin::Bool(b, a)))
}
} else {
// up to 256 enum tags can be stored in a byte
let mut tag_to_u8 = MutMap::default();
for (counter, (name, _)) in tags.into_iter().enumerate() {
tag_to_u8.insert(name, counter as u8);
}
Ok(Layout::Builtin(Builtin::Byte(tag_to_u8)))
}
} else {
panic!("TODO handle a tag union with mutliple tags: {:?}", tags);
}
}
}
}
@ -317,13 +387,15 @@ fn flatten_union(
match subs.get_without_compacting(ext_var).content {
Structure(EmptyTagUnion) => (),
Structure(TagUnion(new_tags, new_ext_var)) => {
Structure(TagUnion(new_tags, new_ext_var))
| Structure(RecursiveTagUnion(_, new_tags, new_ext_var)) => {
for (tag_name, vars) in new_tags {
tags.insert(tag_name, vars);
}
flatten_union(tags, new_ext_var, subs)
}
Alias(_, _, actual) => flatten_union(tags, actual, subs),
invalid => {
panic!("Compiler error: flatten_union got an ext_var in a tag union that wasn't itself a tag union; instead, it was: {:?}", invalid);
}
@ -345,6 +417,7 @@ fn flatten_record(fields: &mut MutMap<Lowercase, Variable>, ext_var: Variable, s
flatten_record(fields, new_ext_var, subs)
}
Alias(_, _, actual) => flatten_record(fields, actual, subs),
invalid => {
panic!("Compiler error: flatten_record encountered an ext_var in a record that wasn't itself a record; instead, it was: {:?}", invalid);
}
@ -373,6 +446,10 @@ fn unwrap_num_tag<'a>(subs: &Subs, var: Variable) -> Result<Layout<'a>, ()> {
debug_assert!(args.is_empty());
Ok(Layout::Builtin(Builtin::Float64))
}
Content::FlexVar(_) => {
// If this was still a (Num *) then default to compiling it to i64
Ok(Layout::Builtin(Builtin::Int64))
}
other => {
panic!("TODO non structure Num.@Num flat_type {:?}", other);
}

308
compiler/mono/tests/test_mono.rs
View File

@ -11,17 +11,26 @@ mod helpers;
// Test monomorphization
#[cfg(test)]
mod test_mono {
use crate::helpers::{can_expr, infer_expr, CanExprOut};
use crate::helpers::{can_expr, infer_expr, test_home, CanExprOut};
use bumpalo::Bump;
use roc_collections::all::MutMap;
use roc_module::symbol::Symbol;
use roc_module::ident::TagName::*;
use roc_module::symbol::{Interns, Symbol};
use roc_mono::expr::Expr::{self, *};
use roc_mono::expr::Procs;
use roc_mono::layout::{Builtin, Layout};
use roc_types::subs::Subs;
// HELPERS
fn compiles_to(src: &str, expected: Expr<'_>) {
compiles_to_with_interns(src, |_| expected)
}
fn compiles_to_with_interns<'a, F>(src: &str, get_expected: F)
where
F: FnOnce(Interns) -> Expr<'a>,
{
let arena = Bump::new();
let CanExprOut {
loc_expr,
@ -34,23 +43,32 @@ mod test_mono {
} = can_expr(src);
let subs = Subs::new(var_store.into());
let mut unify_problems = Vec::new();
let (_content, subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let (_content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
// Compile and add all the Procs before adding main
let mut procs = MutMap::default();
let mut procs = Procs::default();
let mut ident_ids = interns.all_ident_ids.remove(&home).unwrap();
// assume 64-bit pointers
let pointer_size = std::mem::size_of::<u64>() as u32;
// Populate Procs and Subs, and get the low-level Expr from the canonical Expr
let mono_expr = Expr::new(
&arena,
&subs,
&mut subs,
loc_expr.value,
&mut procs,
home,
&mut ident_ids,
pointer_size,
);
assert_eq!(mono_expr, expected);
dbg!(&procs);
// Put this module's ident_ids back in the interns
interns.all_ident_ids.insert(home, ident_ids);
assert_eq!(mono_expr, get_expected(interns));
}
#[test]
@ -64,9 +82,279 @@ mod test_mono {
}
#[test]
fn set_unique_int_list() {
fn float_addition() {
compiles_to(
"List.getUnsafe (List.set [ 12, 9, 7, 3 ] 1 42) 1",
"3.0 + 4",
CallByName(
Symbol::FLOAT_ADD,
&[
(Float(3.0), Layout::Builtin(Builtin::Float64)),
(Float(4.0), Layout::Builtin(Builtin::Float64)),
],
),
);
}
#[test]
fn int_addition() {
compiles_to(
"0xDEADBEEF + 4",
CallByName(
Symbol::INT_ADD,
&[
(Int(3735928559), Layout::Builtin(Builtin::Int64)),
(Int(4), Layout::Builtin(Builtin::Int64)),
],
),
);
}
#[test]
fn num_addition() {
// Default to Int for `Num *`
compiles_to(
"3 + 5",
CallByName(
Symbol::INT_ADD,
&[
(Int(3), Layout::Builtin(Builtin::Int64)),
(Int(5), Layout::Builtin(Builtin::Int64)),
],
),
);
}
#[test]
fn specialize_closure() {
compiles_to(
r#"
f = \x -> x + 5
{ x: f 0x4, y: f 3.14 }
"#,
{
use self::Builtin::*;
use Layout::Builtin;
let home = test_home();
let gen_symbol_3 = Interns::from_index(home, 3);
let gen_symbol_4 = Interns::from_index(home, 4);
Struct {
fields: &[
(
"x".into(),
CallByName(gen_symbol_3, &[(Int(4), Builtin(Int64))]),
),
(
"y".into(),
CallByName(gen_symbol_4, &[(Float(3.14), Builtin(Float64))]),
),
],
layout: Layout::Struct(&[
("x".into(), Builtin(Int64)),
("y".into(), Builtin(Float64)),
]),
}
},
)
}
// #[test]
// fn record_pattern() {
// compiles_to(
// r#"
// \{ x } -> x + 0x5
// "#,
// { Float(3.45) },
// )
// }
//
// #[test]
// fn tag_pattern() {
// compiles_to(
// r#"
// \Foo x -> x + 0x5
// "#,
// { Float(3.45) },
// )
// }
#[test]
fn polymorphic_identity() {
compiles_to(
r#"
id = \x -> x
id { x: id 0x4 }
"#,
{
use self::Builtin::*;
use Layout::Builtin;
let home = test_home();
let gen_symbol_3 = Interns::from_index(home, 3);
let gen_symbol_4 = Interns::from_index(home, 4);
CallByName(
gen_symbol_3,
&[(
Struct {
fields: &[(
"x".into(),
CallByName(gen_symbol_4, &[(Int(4), Builtin(Int64))]),
)],
layout: Layout::Struct(&[("x".into(), Builtin(Int64))]),
},
Layout::Struct(&[("x".into(), Builtin(Int64))]),
)],
)
},
)
}
// needs LetRec to be converted to mono
// #[test]
// fn polymorphic_recursive() {
// compiles_to(
// r#"
// f = \x ->
// when x < 10 is
// True -> f (x + 1)
// False -> x
//
// { x: f 0x4, y: f 3.14 }
// "#,
// {
// use self::Builtin::*;
// use Layout::Builtin;
// let home = test_home();
//
// let gen_symbol_3 = Interns::from_index(home, 3);
// let gen_symbol_4 = Interns::from_index(home, 4);
//
// Float(3.4)
//
// },
// )
// }
// needs layout for non-empty tag union
// #[test]
// fn is_nil() {
// let arena = Bump::new();
//
// compiles_to_with_interns(
// r#"
// LinkedList a : [ Cons a (LinkedList a), Nil ]
//
// isNil : LinkedList a -> Bool
// isNil = \list ->
// when list is
// Nil -> True
// Cons _ _ -> False
//
// listInt : LinkedList Int
// listInt = Nil
//
// isNil listInt
// "#,
// |interns| {
// let home = test_home();
// let var_is_nil = interns.symbol(home, "isNil".into());
// },
// );
// }
#[test]
fn bool_literal() {
let arena = Bump::new();
compiles_to_with_interns(
r#"
x : Bool
x = True
x
"#,
|interns| {
let home = test_home();
let var_x = interns.symbol(home, "x".into());
let stores = [(
var_x,
Layout::Builtin(Builtin::Bool(Global("False".into()), Global("True".into()))),
Bool(true),
)];
let load = Load(var_x);
Store(arena.alloc(stores), arena.alloc(load))
},
);
}
#[test]
fn two_element_enum() {
let arena = Bump::new();
compiles_to_with_interns(
r#"
x : [ Yes, No ]
x = No
x
"#,
|interns| {
let home = test_home();
let var_x = interns.symbol(home, "x".into());
let stores = [(
var_x,
Layout::Builtin(Builtin::Bool(Global("No".into()), Global("Yes".into()))),
Bool(false),
)];
let load = Load(var_x);
Store(arena.alloc(stores), arena.alloc(load))
},
);
}
#[test]
fn three_element_enum() {
let arena = Bump::new();
compiles_to_with_interns(
r#"
# this test is brought to you by fruits.com!
x : [ Apple, Orange, Banana ]
x = Orange
x
"#,
|interns| {
let home = test_home();
let var_x = interns.symbol(home, "x".into());
let mut fruits = MutMap::default();
fruits.insert(Global("Banana".into()), 0);
fruits.insert(Global("Orange".into()), 1);
fruits.insert(Global("Apple".into()), 2);
let stores = [(var_x, Layout::Builtin(Builtin::Byte(fruits)), Byte(1))];
let load = Load(var_x);
Store(arena.alloc(stores), arena.alloc(load))
},
);
}
#[test]
fn set_unique_int_list() {
compiles_to("List.getUnsafe (List.set [ 12, 9, 7, 3 ] 1 42) 1", {
CallByName(
Symbol::LIST_GET_UNSAFE,
&vec![
@ -91,7 +379,7 @@ mod test_mono {
),
(Int(1), Layout::Builtin(Builtin::Int64)),
],
),
);
)
});
}
}

12
compiler/mono/tests/test_opt.rs
View File

@ -13,9 +13,9 @@ mod helpers;
mod test_opt {
use crate::helpers::{infer_expr, uniq_expr};
use bumpalo::Bump;
use roc_collections::all::MutMap;
use roc_module::symbol::Symbol;
use roc_mono::expr::Expr::{self, *};
use roc_mono::expr::Procs;
use roc_mono::layout::{Builtin, Layout};
// HELPERS
@ -25,20 +25,24 @@ mod test_opt {
let (loc_expr, _, _problems, subs, var, constraint, home, mut interns) = uniq_expr(src);
let mut unify_problems = Vec::new();
let (_content, subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
let (_content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
// Compile and add all the Procs before adding main
let mut procs = MutMap::default();
let mut procs = Procs::default();
let mut ident_ids = interns.all_ident_ids.remove(&home).unwrap();
// assume 64-bit pointers
let pointer_size = std::mem::size_of::<u64>() as u32;
// Populate Procs and Subs, and get the low-level Expr from the canonical Expr
let mono_expr = Expr::new(
&arena,
&subs,
&mut subs,
loc_expr.value,
&mut procs,
home,
&mut ident_ids,
pointer_size,
);
assert_eq!(mono_expr, expected);

6
compiler/parse/src/ast.rs
View File

@ -93,7 +93,7 @@ pub struct WhenPattern<'a> {
pub enum Expr<'a> {
// Number Literals
Float(&'a str),
Int(&'a str),
Num(&'a str),
NonBase10Int {
string: &'a str,
base: Base,
@ -324,7 +324,7 @@ pub enum Pattern<'a> {
Nested(&'a Pattern<'a>),
// Literal
IntLiteral(&'a str),
NumLiteral(&'a str),
NonBase10Literal {
string: &'a str,
base: Base,
@ -425,7 +425,7 @@ impl<'a> Pattern<'a> {
(Nested(x), Nested(y)) => x.equivalent(y),
// Literal
(IntLiteral(x), IntLiteral(y)) => x == y,
(NumLiteral(x), NumLiteral(y)) => x == y,
(
NonBase10Literal {
string: string_x,

11
compiler/parse/src/expr.rs
View File

@ -299,7 +299,7 @@ fn expr_to_pattern<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<'a>,
}
Expr::Float(string) => Ok(Pattern::FloatLiteral(string)),
Expr::Int(string) => Ok(Pattern::IntLiteral(string)),
Expr::Num(string) => Ok(Pattern::NumLiteral(string)),
Expr::NonBase10Int {
string,
base,
@ -551,7 +551,7 @@ fn annotation_or_alias<'a>(
QualifiedIdentifier { .. } => {
panic!("TODO gracefully handle trying to annotate a qualified identifier, e.g. `Foo.bar : ...`");
}
IntLiteral(_)
NumLiteral(_)
| NonBase10Literal { .. }
| FloatLiteral(_)
| StrLiteral(_)
@ -1310,8 +1310,11 @@ pub fn ident_etc<'a>(min_indent: u16) -> impl Parser<'a, Expr<'a>> {
region: loc_arg.region,
});
}
Err(_malformed) => {
panic!("TODO early return malformed pattern");
Err(malformed) => {
panic!(
"TODO early return malformed pattern {:?}",
malformed
);
}
}
}

10
compiler/parse/src/number_literal.rs
View File

@ -36,7 +36,7 @@ where
{
use self::LiteralType::*;
let mut typ = Int;
let mut typ = Num;
// We already parsed 1 character (which may have been a minus sign).
let mut bytes_parsed = 1;
@ -71,8 +71,8 @@ where
} else {
return err_unexpected();
}
} else if next_ch == 'b' && typ == Int {
// We have to check for typ == Int because otherwise we get a false
} else if next_ch == 'b' && typ == Num {
// We have to check for typ == Num because otherwise we get a false
// positive here when parsing a hex literal that happens to have
// a 'b' in it, e.g. 0xbbbb
if is_potentially_non_base10() {
@ -129,7 +129,7 @@ where
// If the number is malformed (outside the supported range),
// we'll succeed with an appropriate Expr which records that.
let expr = match typ {
Int => Expr::Int(&state.input[0..bytes_parsed]),
Num => Expr::Num(&state.input[0..bytes_parsed]),
Float => Expr::Float(&state.input[0..bytes_parsed]),
// For these we trim off the 0x/0o/0b part
Hex => from_base(Base::Hex),
@ -144,7 +144,7 @@ where
#[derive(Debug, PartialEq, Eq)]
enum LiteralType {
Int,
Num,
Float,
Hex,
Octal,

202
compiler/parse/tests/test_parse.rs
View File

@ -147,26 +147,26 @@ mod test_parse {
#[test]
fn zero_int() {
assert_parses_to("0", Int("0"));
assert_parses_to("0", Num("0"));
}
#[test]
fn positive_int() {
assert_parses_to("1", Int("1"));
assert_parses_to("42", Int("42"));
assert_parses_to("1", Num("1"));
assert_parses_to("42", Num("42"));
}
#[test]
fn negative_int() {
assert_parses_to("-1", Int("-1"));
assert_parses_to("-42", Int("-42"));
assert_parses_to("-1", Num("-1"));
assert_parses_to("-42", Num("-42"));
}
#[test]
fn highest_int() {
assert_parses_to(
i64::MAX.to_string().as_str(),
Int(i64::MAX.to_string().as_str()),
Num(i64::MAX.to_string().as_str()),
);
}
@ -174,24 +174,24 @@ mod test_parse {
fn lowest_int() {
assert_parses_to(
i64::MIN.to_string().as_str(),
Int(i64::MIN.to_string().as_str()),
Num(i64::MIN.to_string().as_str()),
);
}
#[test]
fn int_with_underscore() {
assert_parses_to("1_2_34_567", Int("1_2_34_567"));
assert_parses_to("-1_2_34_567", Int("-1_2_34_567"));
assert_parses_to("1_2_34_567", Num("1_2_34_567"));
assert_parses_to("-1_2_34_567", Num("-1_2_34_567"));
// The following cases are silly. They aren't supported on purpose,
// but there would be a performance cost to explicitly disallowing them,
// which doesn't seem like it would benefit anyone.
assert_parses_to("1_", Int("1_"));
assert_parses_to("1__23", Int("1__23"));
assert_parses_to("1_", Num("1_"));
assert_parses_to("1__23", Num("1__23"));
}
#[quickcheck]
fn all_i64_values_parse(num: i64) {
assert_parses_to(num.to_string().as_str(), Int(num.to_string().as_str()));
assert_parses_to(num.to_string().as_str(), Num(num.to_string().as_str()));
}
// FLOAT LITERALS
@ -262,12 +262,12 @@ mod test_parse {
let label1 = LabeledValue(
Located::new(0, 0, 16, 17, "x"),
&[],
arena.alloc(Located::new(0, 0, 19, 20, Int("5"))),
arena.alloc(Located::new(0, 0, 19, 20, Num("5"))),
);
let label2 = LabeledValue(
Located::new(0, 0, 22, 23, "y"),
&[],
arena.alloc(Located::new(0, 0, 25, 26, Int("0"))),
arena.alloc(Located::new(0, 0, 25, 26, Num("0"))),
);
let fields = bumpalo::vec![in &arena;
Located::new(0, 0, 16, 20, label1),
@ -293,9 +293,9 @@ mod test_parse {
fn one_plus_two() {
let arena = Bump::new();
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, Int("1")),
Located::new(0, 0, 0, 1, Num("1")),
Located::new(0, 0, 1, 2, Plus),
Located::new(0, 0, 2, 3, Int("2")),
Located::new(0, 0, 2, 3, Num("2")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "1+2");
@ -307,9 +307,9 @@ mod test_parse {
fn one_minus_two() {
let arena = Bump::new();
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, Int("1")),
Located::new(0, 0, 0, 1, Num("1")),
Located::new(0, 0, 1, 2, Minus),
Located::new(0, 0, 2, 3, Int("2")),
Located::new(0, 0, 2, 3, Num("2")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "1-2");
@ -321,9 +321,9 @@ mod test_parse {
fn add_with_spaces() {
let arena = Bump::new();
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, Int("1")),
Located::new(0, 0, 0, 1, Num("1")),
Located::new(0, 0, 3, 4, Plus),
Located::new(0, 0, 7, 8, Int("2")),
Located::new(0, 0, 7, 8, Num("2")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "1 + 2");
@ -335,9 +335,9 @@ mod test_parse {
fn sub_with_spaces() {
let arena = Bump::new();
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, Int("1")),
Located::new(0, 0, 0, 1, Num("1")),
Located::new(0, 0, 3, 4, Minus),
Located::new(0, 0, 7, 8, Int("2")),
Located::new(0, 0, 7, 8, Num("2")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "1 - 2");
@ -360,7 +360,7 @@ mod test_parse {
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, var),
Located::new(0, 0, 2, 3, Plus),
Located::new(0, 0, 4, 5, Int("2")),
Located::new(0, 0, 4, 5, Num("2")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "x + 2");
@ -382,7 +382,7 @@ mod test_parse {
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, var),
Located::new(0, 0, 2, 3, Minus),
Located::new(0, 0, 4, 5, Int("2")),
Located::new(0, 0, 4, 5, Num("2")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "x - 2");
@ -394,13 +394,13 @@ mod test_parse {
fn newline_before_add() {
let arena = Bump::new();
let spaced_int = Expr::SpaceAfter(
arena.alloc(Int("3")),
arena.alloc(Num("3")),
bumpalo::vec![in &arena; Newline].into_bump_slice(),
);
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, spaced_int),
Located::new(1, 1, 0, 1, Plus),
Located::new(1, 1, 2, 3, Int("4")),
Located::new(1, 1, 2, 3, Num("4")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "3 \n+ 4");
@ -412,13 +412,13 @@ mod test_parse {
fn newline_before_sub() {
let arena = Bump::new();
let spaced_int = Expr::SpaceAfter(
arena.alloc(Int("3")),
arena.alloc(Num("3")),
bumpalo::vec![in &arena; Newline].into_bump_slice(),
);
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, spaced_int),
Located::new(1, 1, 0, 1, Minus),
Located::new(1, 1, 2, 3, Int("4")),
Located::new(1, 1, 2, 3, Num("4")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "3 \n- 4");
@ -430,10 +430,10 @@ mod test_parse {
fn newline_after_mul() {
let arena = Bump::new();
let spaced_int = arena
.alloc(Int("4"))
.alloc(Num("4"))
.before(bumpalo::vec![in &arena; Newline].into_bump_slice());
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, Int("3")),
Located::new(0, 0, 0, 1, Num("3")),
Located::new(0, 0, 3, 4, Star),
Located::new(1, 1, 2, 3, spaced_int),
));
@ -447,10 +447,10 @@ mod test_parse {
fn newline_after_sub() {
let arena = Bump::new();
let spaced_int = arena
.alloc(Int("4"))
.alloc(Num("4"))
.before(bumpalo::vec![in &arena; Newline].into_bump_slice());
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, Int("3")),
Located::new(0, 0, 0, 1, Num("3")),
Located::new(0, 0, 3, 4, Minus),
Located::new(1, 1, 2, 3, spaced_int),
));
@ -464,12 +464,12 @@ mod test_parse {
fn comment_with_unicode() {
let arena = Bump::new();
let spaced_int = arena
.alloc(Int("3"))
.alloc(Num("3"))
.after(bumpalo::vec![in &arena; LineComment(" 2 × 2")].into_bump_slice());
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, spaced_int),
Located::new(1, 1, 0, 1, Plus),
Located::new(1, 1, 2, 3, Int("4")),
Located::new(1, 1, 2, 3, Num("4")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "3 # 2 × 2\n+ 4");
@ -481,12 +481,12 @@ mod test_parse {
fn comment_before_op() {
let arena = Bump::new();
let spaced_int = arena
.alloc(Int("3"))
.alloc(Num("3"))
.after(bumpalo::vec![in &arena; LineComment(" test!")].into_bump_slice());
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, spaced_int),
Located::new(1, 1, 0, 1, Plus),
Located::new(1, 1, 2, 3, Int("4")),
Located::new(1, 1, 2, 3, Num("4")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "3 # test!\n+ 4");
@ -498,10 +498,10 @@ mod test_parse {
fn comment_after_op() {
let arena = Bump::new();
let spaced_int = arena
.alloc(Int("92"))
.alloc(Num("92"))
.before(bumpalo::vec![in &arena; LineComment(" test!")].into_bump_slice());
let tuple = arena.alloc((
Located::new(0, 0, 0, 2, Int("12")),
Located::new(0, 0, 0, 2, Num("12")),
Located::new(0, 0, 4, 5, Star),
Located::new(1, 1, 1, 3, spaced_int),
));
@ -515,10 +515,10 @@ mod test_parse {
fn ops_with_newlines() {
let arena = Bump::new();
let spaced_int1 = arena
.alloc(Int("3"))
.alloc(Num("3"))
.after(bumpalo::vec![in &arena; Newline].into_bump_slice());
let spaced_int2 = arena
.alloc(Int("4"))
.alloc(Num("4"))
.before(bumpalo::vec![in &arena; Newline, Newline].into_bump_slice());
let tuple = arena.alloc((
Located::new(0, 0, 0, 1, spaced_int1),
@ -559,9 +559,9 @@ mod test_parse {
fn minus_twelve_minus_five() {
let arena = Bump::new();
let tuple = arena.alloc((
Located::new(0, 0, 0, 3, Int("-12")),
Located::new(0, 0, 0, 3, Num("-12")),
Located::new(0, 0, 3, 4, Minus),
Located::new(0, 0, 4, 5, Int("5")),
Located::new(0, 0, 4, 5, Num("5")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "-12-5");
@ -573,9 +573,9 @@ mod test_parse {
fn ten_times_eleven() {
let arena = Bump::new();
let tuple = arena.alloc((
Located::new(0, 0, 0, 2, Int("10")),
Located::new(0, 0, 0, 2, Num("10")),
Located::new(0, 0, 2, 3, Star),
Located::new(0, 0, 3, 5, Int("11")),
Located::new(0, 0, 3, 5, Num("11")),
));
let expected = BinOp(tuple);
let actual = parse_with(&arena, "10*11");
@ -587,12 +587,12 @@ mod test_parse {
fn multiple_operators() {
let arena = Bump::new();
let inner = arena.alloc((
Located::new(0, 0, 3, 5, Int("42")),
Located::new(0, 0, 3, 5, Num("42")),
Located::new(0, 0, 5, 6, Plus),
Located::new(0, 0, 6, 9, Int("534")),
Located::new(0, 0, 6, 9, Num("534")),
));
let outer = arena.alloc((
Located::new(0, 0, 0, 2, Int("31")),
Located::new(0, 0, 0, 2, Num("31")),
Located::new(0, 0, 2, 3, Star),
Located::new(0, 0, 3, 9, BinOp(inner)),
));
@ -707,8 +707,8 @@ mod test_parse {
#[test]
fn apply_private_tag() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, Int("12")));
let arg2 = arena.alloc(Located::new(0, 0, 9, 11, Int("34")));
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, Num("12")));
let arg2 = arena.alloc(Located::new(0, 0, 9, 11, Num("34")));
let args = bumpalo::vec![in &arena; &*arg1, &*arg2];
let expected = Expr::Apply(
arena.alloc(Located::new(0, 0, 0, 5, Expr::PrivateTag("@Whee"))),
@ -723,8 +723,8 @@ mod test_parse {
#[test]
fn apply_global_tag() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 5, 7, Int("12")));
let arg2 = arena.alloc(Located::new(0, 0, 8, 10, Int("34")));
let arg1 = arena.alloc(Located::new(0, 0, 5, 7, Num("12")));
let arg2 = arena.alloc(Located::new(0, 0, 8, 10, Num("34")));
let args = bumpalo::vec![in &arena; &*arg1, &*arg2];
let expected = Expr::Apply(
arena.alloc(Located::new(0, 0, 0, 4, Expr::GlobalTag("Whee"))),
@ -739,8 +739,8 @@ mod test_parse {
#[test]
fn apply_parenthetical_global_tag_args() {
let arena = Bump::new();
let int1 = ParensAround(arena.alloc(Int("12")));
let int2 = ParensAround(arena.alloc(Int("34")));
let int1 = ParensAround(arena.alloc(Num("12")));
let int2 = ParensAround(arena.alloc(Num("34")));
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, int1));
let arg2 = arena.alloc(Located::new(0, 0, 11, 13, int2));
let args = bumpalo::vec![in &arena; &*arg1, &*arg2];
@ -780,7 +780,7 @@ mod test_parse {
let patterns = bumpalo::vec![in &arena; pattern];
let expected = Closure(
arena.alloc(patterns),
arena.alloc(Located::new(0, 0, 10, 12, Int("42"))),
arena.alloc(Located::new(0, 0, 10, 12, Num("42"))),
);
let actual = parse_with(&arena, "\\Thing -> 42");
@ -822,7 +822,7 @@ mod test_parse {
#[test]
fn packed_singleton_list() {
let arena = Bump::new();
let elems = bumpalo::vec![in &arena; &*arena.alloc(Located::new(0, 0, 1, 2, Int("1")))];
let elems = bumpalo::vec![in &arena; &*arena.alloc(Located::new(0, 0, 1, 2, Num("1")))];
let expected = List(elems);
let actual = parse_with(&arena, "[1]");
@ -832,7 +832,7 @@ mod test_parse {
#[test]
fn spaced_singleton_list() {
let arena = Bump::new();
let elems = bumpalo::vec![in &arena; &*arena.alloc(Located::new(0, 0, 2, 3, Int("1")))];
let elems = bumpalo::vec![in &arena; &*arena.alloc(Located::new(0, 0, 2, 3, Num("1")))];
let expected = List(elems);
let actual = parse_with(&arena, "[ 1 ]");
@ -917,7 +917,7 @@ mod test_parse {
#[test]
fn basic_apply() {
let arena = Bump::new();
let arg = arena.alloc(Located::new(0, 0, 5, 6, Int("1")));
let arg = arena.alloc(Located::new(0, 0, 5, 6, Num("1")));
let args = bumpalo::vec![in &arena; &*arg];
let expected = Expr::Apply(
arena.alloc(Located::new(
@ -941,8 +941,8 @@ mod test_parse {
#[test]
fn apply_two_args() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, Int("12")));
let arg2 = arena.alloc(Located::new(0, 0, 10, 12, Int("34")));
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, Num("12")));
let arg2 = arena.alloc(Located::new(0, 0, 10, 12, Num("34")));
let args = bumpalo::vec![in &arena; &*arg1, &*arg2];
let expected = Expr::Apply(
arena.alloc(Located::new(
@ -1019,7 +1019,7 @@ mod test_parse {
#[test]
fn parenthetical_apply() {
let arena = Bump::new();
let arg = arena.alloc(Located::new(0, 0, 7, 8, Int("1")));
let arg = arena.alloc(Located::new(0, 0, 7, 8, Num("1")));
let args = bumpalo::vec![in &arena; &*arg];
let parens_var = Expr::ParensAround(arena.alloc(Var {
module_name: "",
@ -1080,7 +1080,7 @@ mod test_parse {
#[test]
fn apply_unary_negation() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 7, 9, Int("12")));
let arg1 = arena.alloc(Located::new(0, 0, 7, 9, Num("12")));
let loc_op = Located::new(0, 0, 0, 1, UnaryOp::Negate);
let arg2 = arena.alloc(Located::new(
0,
@ -1116,7 +1116,7 @@ mod test_parse {
#[test]
fn apply_unary_not() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 7, 9, Int("12")));
let arg1 = arena.alloc(Located::new(0, 0, 7, 9, Num("12")));
let loc_op = Located::new(0, 0, 0, 1, UnaryOp::Not);
let arg2 = arena.alloc(Located::new(
0,
@ -1152,7 +1152,7 @@ mod test_parse {
#[test]
fn unary_negation_with_parens() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 8, 10, Int("12")));
let arg1 = arena.alloc(Located::new(0, 0, 8, 10, Num("12")));
let loc_op = Located::new(0, 0, 0, 1, UnaryOp::Negate);
let arg2 = arena.alloc(Located::new(
0,
@ -1188,7 +1188,7 @@ mod test_parse {
#[test]
fn unary_not_with_parens() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 8, 10, Int("12")));
let arg1 = arena.alloc(Located::new(0, 0, 8, 10, Num("12")));
let loc_op = Located::new(0, 0, 0, 1, UnaryOp::Not);
let arg2 = arena.alloc(Located::new(
0,
@ -1224,7 +1224,7 @@ mod test_parse {
#[test]
fn unary_negation_arg() {
let arena = Bump::new();
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, Int("12")));
let arg1 = arena.alloc(Located::new(0, 0, 6, 8, Num("12")));
let loc_op = Located::new(0, 0, 9, 10, UnaryOp::Negate);
let var1 = Var {
module_name: "",
@ -1257,7 +1257,7 @@ mod test_parse {
let patterns = bumpalo::vec![in &arena; pattern];
let expected = Closure(
arena.alloc(patterns),
arena.alloc(Located::new(0, 0, 6, 8, Int("42"))),
arena.alloc(Located::new(0, 0, 6, 8, Num("42"))),
);
let actual = parse_with(&arena, "\\a -> 42");
@ -1271,7 +1271,7 @@ mod test_parse {
let patterns = bumpalo::vec![in &arena; pattern];
let expected = Closure(
arena.alloc(patterns),
arena.alloc(Located::new(0, 0, 6, 8, Int("42"))),
arena.alloc(Located::new(0, 0, 6, 8, Num("42"))),
);
let actual = parse_with(&arena, "\\_ -> 42");
@ -1297,7 +1297,7 @@ mod test_parse {
let patterns = bumpalo::vec![in &arena; arg1, arg2];
let expected = Closure(
arena.alloc(patterns),
arena.alloc(Located::new(0, 0, 9, 11, Int("42"))),
arena.alloc(Located::new(0, 0, 9, 11, Num("42"))),
);
let actual = parse_with(&arena, "\\a, b -> 42");
@ -1313,7 +1313,7 @@ mod test_parse {
let patterns = bumpalo::vec![in &arena; arg1, arg2, arg3];
let expected = Closure(
arena.alloc(patterns),
arena.alloc(Located::new(0, 0, 12, 14, Int("42"))),
arena.alloc(Located::new(0, 0, 12, 14, Num("42"))),
);
let actual = parse_with(&arena, "\\a, b, c -> 42");
@ -1328,7 +1328,7 @@ mod test_parse {
let patterns = bumpalo::vec![in &arena; underscore1, underscore2];
let expected = Closure(
arena.alloc(patterns),
arena.alloc(Located::new(0, 0, 9, 11, Int("42"))),
arena.alloc(Located::new(0, 0, 9, 11, Num("42"))),
);
let actual = parse_with(&arena, "\\_, _ -> 42");
@ -1343,11 +1343,11 @@ mod test_parse {
let newlines = bumpalo::vec![in &arena; Newline, Newline];
let def = Def::Body(
arena.alloc(Located::new(1, 1, 0, 1, Identifier("x"))),
arena.alloc(Located::new(1, 1, 2, 3, Int("5"))),
arena.alloc(Located::new(1, 1, 2, 3, Num("5"))),
);
let loc_def = &*arena.alloc(Located::new(1, 1, 0, 1, def));
let defs = bumpalo::vec![in &arena; loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let reset_indentation = bumpalo::vec![in &arena; LineComment(" leading comment")];
let expected = Expr::SpaceBefore(
@ -1373,11 +1373,11 @@ mod test_parse {
let newlines = bumpalo::vec![in &arena; Newline, Newline];
let def = Def::Body(
arena.alloc(Located::new(1, 1, 0, 1, Identifier("x"))),
arena.alloc(Located::new(1, 1, 4, 5, Int("5"))),
arena.alloc(Located::new(1, 1, 4, 5, Num("5"))),
);
let loc_def = &*arena.alloc(Located::new(1, 1, 0, 1, def));
let defs = bumpalo::vec![in &arena; loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let reset_indentation = bumpalo::vec![in &arena; LineComment(" leading comment")];
let expected = Expr::SpaceBefore(
@ -1404,13 +1404,13 @@ mod test_parse {
let newline = bumpalo::vec![in &arena; Newline];
let def1 = Def::Body(
arena.alloc(Located::new(1, 1, 0, 1, Identifier("x"))),
arena.alloc(Located::new(1, 1, 4, 5, Int("5"))),
arena.alloc(Located::new(1, 1, 4, 5, Num("5"))),
);
let loc_def1 = &*arena.alloc(Located::new(1, 1, 0, 1, def1));
let def2 = Def::SpaceBefore(
&*arena.alloc(Def::Body(
arena.alloc(Located::new(2, 2, 0, 1, Identifier("y"))),
arena.alloc(Located::new(2, 2, 4, 5, Int("6"))),
arena.alloc(Located::new(2, 2, 4, 5, Num("6"))),
)),
newline.into_bump_slice(),
);
@ -1419,7 +1419,7 @@ mod test_parse {
// gets added by .push(), since that's more efficient and since
// canonicalization is going to re-sort these all anyway.)
let defs = bumpalo::vec![in &arena; loc_def2, loc_def1];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(4, 4, 0, 2, ret);
let reset_indentation = bumpalo::vec![in &arena; LineComment(" leading comment")];
let expected = Expr::SpaceBefore(
@ -1457,13 +1457,13 @@ mod test_parse {
8,
RecordDestructure(fields.into_bump_slice()),
)),
arena.alloc(Located::new(1, 1, 11, 12, Int("5"))),
arena.alloc(Located::new(1, 1, 11, 12, Num("5"))),
);
let loc_def1 = &*arena.alloc(Located::new(1, 1, 1, 8, def1));
let def2 = Def::SpaceBefore(
&*arena.alloc(Def::Body(
arena.alloc(Located::new(2, 2, 0, 1, Identifier("y"))),
arena.alloc(Located::new(2, 2, 4, 5, Int("6"))),
arena.alloc(Located::new(2, 2, 4, 5, Num("6"))),
)),
newline.into_bump_slice(),
);
@ -1472,7 +1472,7 @@ mod test_parse {
// gets added by .push(), since that's more efficient and since
// canonicalization is going to re-sort these all anyway.)
let defs = bumpalo::vec![in &arena; loc_def2, loc_def1];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(4, 4, 0, 2, ret);
let reset_indentation = bumpalo::vec![in &arena; LineComment(" leading comment")];
let expected = Expr::SpaceBefore(
@ -1505,14 +1505,14 @@ mod test_parse {
);
let def = Def::Body(
arena.alloc(Located::new(1, 1, 0, 3, Identifier("foo"))),
arena.alloc(Located::new(1, 1, 6, 7, Int("4"))),
arena.alloc(Located::new(1, 1, 6, 7, Num("4"))),
);
let spaced_def = Def::SpaceBefore(arena.alloc(def), newline.into_bump_slice());
let loc_def = &*arena.alloc(Located::new(1, 1, 0, 7, spaced_def));
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann, loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1552,7 +1552,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(2, 2, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1588,7 +1588,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 4, signature));
let defs = bumpalo::vec![in &arena; loc_ann];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(2, 2, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1630,7 +1630,7 @@ mod test_parse {
Located::new(1,1,7,8, Identifier("x")),
Located::new(1,1,10,11, Underscore)
];
let body = Located::new(1, 1, 15, 17, Int("42"));
let body = Located::new(1, 1, 15, 17, Num("42"));
let closure = Expr::Closure(&args, &body);
@ -1643,7 +1643,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann, loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1698,7 +1698,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann, loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1751,7 +1751,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann, loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1805,7 +1805,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann, loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1858,7 +1858,7 @@ mod test_parse {
let loc_ann = &*arena.alloc(Located::new(0, 0, 0, 3, signature));
let defs = bumpalo::vec![in &arena; loc_ann, loc_def];
let ret = Expr::SpaceBefore(arena.alloc(Int("42")), newlines.into_bump_slice());
let ret = Expr::SpaceBefore(arena.alloc(Num("42")), newlines.into_bump_slice());
let loc_ret = Located::new(3, 3, 0, 2, ret);
let expected = Defs(defs, arena.alloc(loc_ret));
@ -1884,7 +1884,7 @@ mod test_parse {
let pattern1 =
Pattern::SpaceBefore(arena.alloc(StrLiteral("blah")), newlines.into_bump_slice());
let loc_pattern1 = Located::new(1, 1, 1, 7, pattern1);
let expr1 = Int("1");
let expr1 = Num("1");
let loc_expr1 = Located::new(1, 1, 11, 12, expr1);
let branch1 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern1],
@ -1895,7 +1895,7 @@ mod test_parse {
let pattern2 =
Pattern::SpaceBefore(arena.alloc(StrLiteral("mise")), newlines.into_bump_slice());
let loc_pattern2 = Located::new(2, 2, 1, 7, pattern2);
let expr2 = Int("2");
let expr2 = Num("2");
let loc_expr2 = Located::new(2, 2, 11, 12, expr2);
let branch2 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern2 ],
@ -1928,9 +1928,9 @@ mod test_parse {
let arena = Bump::new();
let newlines = bumpalo::vec![in &arena; Newline];
let pattern1 =
Pattern::SpaceBefore(arena.alloc(IntLiteral("1")), newlines.into_bump_slice());
Pattern::SpaceBefore(arena.alloc(NumLiteral("1")), newlines.into_bump_slice());
let loc_pattern1 = Located::new(1, 1, 1, 2, pattern1);
let expr1 = Int("2");
let expr1 = Num("2");
let loc_expr1 = Located::new(1, 1, 6, 7, expr1);
let branch1 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern1],
@ -1939,9 +1939,9 @@ mod test_parse {
});
let newlines = bumpalo::vec![in &arena; Newline];
let pattern2 =
Pattern::SpaceBefore(arena.alloc(IntLiteral("3")), newlines.into_bump_slice());
Pattern::SpaceBefore(arena.alloc(NumLiteral("3")), newlines.into_bump_slice());
let loc_pattern2 = Located::new(2, 2, 1, 2, pattern2);
let expr2 = Int("4");
let expr2 = Num("4");
let loc_expr2 = Located::new(2, 2, 6, 7, expr2);
let branch2 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern2],
@ -1979,7 +1979,7 @@ mod test_parse {
newlines.into_bump_slice(),
);
let loc_pattern1 = Located::new(1, 1, 1, 6, pattern1);
let expr1 = Int("2");
let expr1 = Num("2");
let loc_expr1 = Located::new(1, 1, 10, 11, expr1);
let branch1 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern1 ],
@ -1993,7 +1993,7 @@ mod test_parse {
newlines.into_bump_slice(),
);
let loc_pattern2 = Located::new(2, 2, 1, 9, pattern2);
let expr2 = Int("4");
let expr2 = Num("4");
let loc_expr2 = Located::new(2, 2, 13, 14, expr2);
let branch2 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern2 ],
@ -2030,7 +2030,7 @@ mod test_parse {
let pattern1_alt = StrLiteral("blop");
let loc_pattern1 = Located::new(1, 1, 1, 7, pattern1);
let loc_pattern1_alt = Located::new(1, 1, 10, 16, pattern1_alt);
let expr1 = Int("1");
let expr1 = Num("1");
let loc_expr1 = Located::new(1, 1, 20, 21, expr1);
let branch1 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern1, loc_pattern1_alt],
@ -2045,7 +2045,7 @@ mod test_parse {
Pattern::SpaceBefore(arena.alloc(StrLiteral("bar")), newlines.into_bump_slice());
let loc_pattern2 = Located::new(2, 2, 1, 6, pattern2);
let loc_pattern2_alt = Located::new(3, 3, 1, 6, pattern2_alt);
let expr2 = Int("2");
let expr2 = Num("2");
let loc_expr2 = Located::new(3, 3, 10, 11, expr2);
let branch2 = &*arena.alloc(WhenBranch {
patterns: bumpalo::vec![in &arena;loc_pattern2, loc_pattern2_alt],
@ -2148,7 +2148,7 @@ mod test_parse {
let def1 = SpaceAfter(
arena.alloc(Body(
arena.alloc(Located::new(0, 0, 0, 3, pattern1)),
arena.alloc(Located::new(0, 0, 6, 7, Int("1"))),
arena.alloc(Located::new(0, 0, 6, 7, Num("1"))),
)),
newlines1.into_bump_slice(),
);

5
compiler/region/src/all.rs
View File

@ -89,6 +89,11 @@ impl<T> Located<T> {
pub fn at(region: Region, value: T) -> Located<T> {
Located { value, region }
}
pub fn at_zero(value: T) -> Located<T> {
let region = Region::zero();
Located { value, region }
}
}
impl<T> Located<T> {

107
compiler/reporting/tests/helpers/mod.rs
View File

@ -8,7 +8,7 @@ use roc_can::expected::Expected;
use roc_can::expr::{canonicalize_expr, Expr, Output};
use roc_can::operator;
use roc_can::scope::Scope;
use roc_collections::all::{ImMap, ImSet, MutMap, SendMap, SendSet};
use roc_collections::all::{ImMap, MutMap, SendMap, SendSet};
use roc_constrain::expr::constrain_expr;
use roc_constrain::module::{constrain_imported_values, load_builtin_aliases, Import};
use roc_module::ident::Ident;
@ -350,108 +350,3 @@ pub fn fixtures_dir<'a>() -> PathBuf {
pub fn builtins_dir<'a>() -> PathBuf {
PathBuf::new().join("builtins")
}
// Check constraints
//
// Keep track of the used (in types or expectations) variables, and the declared variables (in
// flex_vars or rigid_vars fields of LetConstraint. These roc_collections should match: no duplicates
// and no variables that are used but not declared are allowed.
//
// There is one exception: the initial variable (that stores the type of the whole expression) is
// never declared, but is used.
#[allow(dead_code)]
pub fn assert_correct_variable_usage(constraint: &Constraint) {
// variables declared in constraint (flex_vars or rigid_vars)
// and variables actually used in constraints
let (declared, used) = variable_usage(constraint);
let used: ImSet<Variable> = used.clone().into();
let mut decl: ImSet<Variable> = declared.rigid_vars.clone().into();
for var in declared.flex_vars.clone() {
decl.insert(var);
}
let diff = used.clone().relative_complement(decl);
// NOTE: this checks whether we're using variables that are not declared. For recursive type
// definitions, their rigid types are declared twice, which is correct!
if !diff.is_empty() {
println!("VARIABLE USAGE PROBLEM");
println!("used: {:?}", &used);
println!("rigids: {:?}", &declared.rigid_vars);
println!("flexs: {:?}", &declared.flex_vars);
println!("difference: {:?}", &diff);
panic!("variable usage problem (see stdout for details)");
}
}
#[derive(Default)]
pub struct SeenVariables {
pub rigid_vars: Vec<Variable>,
pub flex_vars: Vec<Variable>,
}
pub fn variable_usage(con: &Constraint) -> (SeenVariables, Vec<Variable>) {
let mut declared = SeenVariables::default();
let mut used = ImSet::default();
variable_usage_help(con, &mut declared, &mut used);
used.remove(unsafe { &Variable::unsafe_test_debug_variable(1) });
used.remove(unsafe { &Variable::unsafe_test_debug_variable(2) });
used.remove(unsafe { &Variable::unsafe_test_debug_variable(3) });
let mut used_vec: Vec<Variable> = used.into_iter().collect();
used_vec.sort();
declared.rigid_vars.sort();
declared.flex_vars.sort();
(declared, used_vec)
}
fn variable_usage_help(con: &Constraint, declared: &mut SeenVariables, used: &mut ImSet<Variable>) {
use Constraint::*;
match con {
True | SaveTheEnvironment => (),
Eq(tipe, expectation, _) => {
for v in tipe.variables() {
used.insert(v);
}
for v in expectation.get_type_ref().variables() {
used.insert(v);
}
}
Lookup(_, expectation, _) => {
for v in expectation.get_type_ref().variables() {
used.insert(v);
}
}
Pattern(_, _, tipe, pexpectation) => {
for v in tipe.variables() {
used.insert(v);
}
for v in pexpectation.get_type_ref().variables() {
used.insert(v);
}
}
Let(letcon) => {
declared.rigid_vars.extend(letcon.rigid_vars.clone());
declared.flex_vars.extend(letcon.flex_vars.clone());
variable_usage_help(&letcon.defs_constraint, declared, used);
variable_usage_help(&letcon.ret_constraint, declared, used);
}
And(constraints) => {
for sub in constraints {
variable_usage_help(sub, declared, used);
}
}
}
}

4
compiler/reporting/tests/test_reporting.rs
View File

@ -17,7 +17,7 @@ mod test_report {
use roc_types::types;
use std::path::PathBuf;
// use roc_region::all;
use crate::helpers::{assert_correct_variable_usage, can_expr, infer_expr, CanExprOut};
use crate::helpers::{can_expr, infer_expr, CanExprOut};
use roc_reporting::report::ReportText::{EmText, Plain, Region, Type, Url, Value};
use roc_types::subs::Content::{FlexVar, RigidVar, Structure};
use roc_types::subs::FlatType::EmptyRecord;
@ -53,8 +53,6 @@ mod test_report {
} = can_expr(expr_src);
let mut subs = Subs::new(var_store.into());
assert_correct_variable_usage(&constraint);
for (var, name) in output.introduced_variables.name_by_var {
subs.rigid_var(var, name);
}

2
compiler/solve/src/solve.rs
View File

@ -546,6 +546,7 @@ fn type_to_variable(
register(subs, rank, pools, content)
}
Alias(Symbol::BOOL_BOOL, _, _) => Variable::BOOL,
Alias(symbol, args, alias_type) => {
// Cache aliases without type arguments. Commonly used aliases like `Int` would otherwise get O(n)
// different variables (once for each occurence). The recursion restriction is required
@ -560,6 +561,7 @@ fn type_to_variable(
//
// This `u` variable can be different between lists, so giving just one variable to
// this type is incorrect.
// TODO does caching work at all with uniqueness types? even Int then hides a uniqueness variable
let is_recursive = alias_type.is_recursive();
let no_args = args.is_empty();
if no_args && !is_recursive {

7
compiler/solve/tests/helpers/mod.rs
View File

@ -400,9 +400,10 @@ pub fn variable_usage(con: &Constraint) -> (SeenVariables, Vec<Variable>) {
let mut used = ImSet::default();
variable_usage_help(con, &mut declared, &mut used);
used.remove(unsafe { &Variable::unsafe_test_debug_variable(1) });
used.remove(unsafe { &Variable::unsafe_test_debug_variable(2) });
used.remove(unsafe { &Variable::unsafe_test_debug_variable(3) });
// ..= because there is an extra undeclared variable that contains the type of the full expression
for i in 0..=Variable::RESERVED {
used.remove(unsafe { &Variable::unsafe_test_debug_variable(i as u32) });
}
let mut used_vec: Vec<Variable> = used.into_iter().collect();
used_vec.sort();

151
compiler/solve/tests/test_solve.rs
View File

@ -69,7 +69,7 @@ mod test_solve {
#[test]
fn int_literal() {
infer_eq("5", "Int");
infer_eq("5", "Num *");
}
#[test]
@ -188,7 +188,7 @@ mod test_solve {
[42]
"#
),
"List Int",
"List (Num *)",
);
}
@ -200,7 +200,7 @@ mod test_solve {
[[[ 5 ]]]
"#
),
"List (List (List Int))",
"List (List (List (Num *)))",
);
}
@ -212,7 +212,7 @@ mod test_solve {
[ 1, 2, 3 ]
"#
),
"List Int",
"List (Num *)",
);
}
@ -224,7 +224,7 @@ mod test_solve {
[ [ 1 ], [ 2, 3 ] ]
"#
),
"List (List Int)",
"List (List (Num *))",
);
}
@ -340,7 +340,7 @@ mod test_solve {
\_, _ -> 42
"#
),
"*, * -> Int",
"*, * -> Num *",
);
}
@ -410,7 +410,7 @@ mod test_solve {
func
"#
),
"*, * -> Int",
"*, * -> Num *",
);
}
@ -474,7 +474,7 @@ mod test_solve {
c
"#
),
"Int",
"Num *",
);
}
@ -509,7 +509,7 @@ mod test_solve {
alwaysFive "stuff"
"#
),
"Int",
"Num *",
);
}
@ -556,7 +556,7 @@ mod test_solve {
x
"#
),
"Int",
"Num *",
);
}
@ -570,7 +570,7 @@ mod test_solve {
enlist 5
"#
),
"List Int",
"List (Num *)",
);
}
@ -597,7 +597,7 @@ mod test_solve {
1 |> (\a -> a)
"#
),
"Int",
"Num *",
);
}
@ -611,7 +611,7 @@ mod test_solve {
1 |> always "foo"
"#
),
"Int",
"Num *",
);
}
@ -676,7 +676,7 @@ mod test_solve {
apply identity 5
"#
),
"Int",
"Num *",
);
}
@ -705,7 +705,7 @@ mod test_solve {
// flip neverendingInt
// "#
// ),
// "(Int, (a -> a)) -> Int",
// "(Num *, (a -> a)) -> Num *",
// );
// }
@ -779,7 +779,7 @@ mod test_solve {
// 1 // 2
// "#
// ),
// "Int",
// "Num *",
// );
// }
@ -791,7 +791,7 @@ mod test_solve {
// 1 + 2
// "#
// ),
// "Int",
// "Num *",
// );
// }
@ -835,12 +835,12 @@ mod test_solve {
infer_eq(
indoc!(
r#"
alwaysFive = \_ -> 5
alwaysFive = \_ -> 5
[ alwaysFive "foo", alwaysFive [] ]
"#
[ alwaysFive "foo", alwaysFive [] ]
"#
),
"List Int",
"List (Num *)",
);
}
@ -855,7 +855,7 @@ mod test_solve {
24
"#
),
"Int",
"Num *",
);
}
@ -869,7 +869,7 @@ mod test_solve {
3 -> 4
"#
),
"Int",
"Num *",
);
}
@ -882,17 +882,17 @@ mod test_solve {
#[test]
fn one_field_record() {
infer_eq("{ x: 5 }", "{ x : Int }");
infer_eq("{ x: 5 }", "{ x : Num * }");
}
#[test]
fn two_field_record() {
infer_eq("{ x: 5, y : 3.14 }", "{ x : Int, y : Float }");
infer_eq("{ x: 5, y : 3.14 }", "{ x : Num *, y : Float }");
}
#[test]
fn record_literal_accessor() {
infer_eq("{ x: 5, y : 3.14 }.x", "Int");
infer_eq("{ x: 5, y : 3.14 }.x", "Num *");
}
#[test]
@ -951,7 +951,7 @@ mod test_solve {
infer_eq(
indoc!(
r#"
foo : Int -> custom
foo : Num * -> custom
foo 2
"#
@ -1017,9 +1017,9 @@ mod test_solve {
infer_eq(
indoc!(
r#"
user = { year: "foo", name: "Sam" }
user = { year: "foo", name: "Sam" }
{ user & year: "foo" }
{ user & year: "foo" }
"#
),
"{ name : Str, year : Str }",
@ -1030,7 +1030,8 @@ mod test_solve {
fn bare_tag() {
infer_eq(
indoc!(
r#"Foo
r#"
Foo
"#
),
"[ Foo ]*",
@ -1041,10 +1042,11 @@ mod test_solve {
fn single_tag_pattern() {
infer_eq(
indoc!(
r#"\Foo -> 42
r#"
\Foo -> 42
"#
),
"[ Foo ]* -> Int",
"[ Foo ]* -> Num *",
);
}
@ -1052,10 +1054,11 @@ mod test_solve {
fn single_private_tag_pattern() {
infer_eq(
indoc!(
r#"\@Foo -> 42
r#"
\@Foo -> 42
"#
),
"[ @Foo ]* -> Int",
"[ @Foo ]* -> Num *",
);
}
@ -1063,13 +1066,14 @@ mod test_solve {
fn two_tag_pattern() {
infer_eq(
indoc!(
r#"\x ->
when x is
True -> 1
False -> 0
r#"
\x ->
when x is
True -> 1
False -> 0
"#
),
"[ False, True ]* -> Int",
"[ False, True ]* -> Num *",
);
}
@ -1077,10 +1081,11 @@ mod test_solve {
fn tag_application() {
infer_eq(
indoc!(
r#"Foo "happy" 2020
r#"
Foo "happy" 2020
"#
),
"[ Foo Str Int ]*",
"[ Foo Str (Num *) ]*",
);
}
@ -1088,10 +1093,11 @@ mod test_solve {
fn private_tag_application() {
infer_eq(
indoc!(
r#"@Foo "happy" 2020
r#"
@Foo "happy" 2020
"#
),
"[ @Foo Str Int ]*",
"[ @Foo Str (Num *) ]*",
);
}
@ -1120,7 +1126,7 @@ mod test_solve {
{ x: 4 } -> x
"#
),
"Int",
"Num *",
);
}
@ -1129,7 +1135,7 @@ mod test_solve {
infer_eq(
indoc!(
r#"
\Foo x -> Foo x
\Foo x -> Foo x
"#
),
"[ Foo a ]* -> [ Foo a ]*",
@ -1141,7 +1147,7 @@ mod test_solve {
infer_eq(
indoc!(
r#"
\Foo x _ -> Foo x "y"
\Foo x _ -> Foo x "y"
"#
),
"[ Foo a * ]* -> [ Foo a Str ]*",
@ -1464,9 +1470,9 @@ mod test_solve {
y = numIdentity 3.14
{ numIdentity, x : numIdentity 42, y }
"#
"#
),
"{ numIdentity : Num a -> Num a, x : Int, y : Float }",
"{ numIdentity : Num a -> Num a, x : Num a, y : Float }",
);
}
@ -1482,7 +1488,7 @@ mod test_solve {
_ -> 5
x
"#
"#
),
"Int",
);
@ -1494,15 +1500,15 @@ mod test_solve {
infer_eq_without_problem(
indoc!(
r#"
f = \n ->
when n is
0 -> 0
_ -> f n
f = \n ->
when n is
0 -> 0
_ -> f n
f
"#
f
"#
),
"Int -> Int",
"Num * -> Num *",
);
}
@ -1511,12 +1517,12 @@ mod test_solve {
infer_eq_without_problem(
indoc!(
r#"
map : (a -> b), [ Identity a ] -> [ Identity b ]
map = \f, identity ->
when identity is
Identity v -> Identity (f v)
map
"#
map : (a -> b), [ Identity a ] -> [ Identity b ]
map = \f, identity ->
when identity is
Identity v -> Identity (f v)
map
"#
),
"(a -> b), [ Identity a ] -> [ Identity b ]",
);
@ -1527,16 +1533,15 @@ mod test_solve {
infer_eq_without_problem(
indoc!(
r#"
# toBit : [ False, True ] -> Num.Num Int.Integer
toBit = \bool ->
when bool is
True -> 1
False -> 0
toBit
"#
"#
),
"[ False, True ]* -> Int",
"[ False, True ]* -> Num *",
);
}
@ -1571,9 +1576,9 @@ mod test_solve {
_ -> True
fromBit
"#
"#
),
"Int -> [ False, True ]*",
"Num * -> [ False, True ]*",
);
}
@ -1589,7 +1594,7 @@ mod test_solve {
Err e -> Err e
map
"#
"#
),
"(a -> b), [ Err e, Ok a ] -> [ Err e, Ok b ]",
);
@ -1620,12 +1625,12 @@ mod test_solve {
infer_eq_without_problem(
indoc!(
r#"
foo = \{ x } -> x
foo = \{ x } -> x
foo { x: 5 }
foo { x: 5 }
"#
),
"Int",
"Num *",
);
}
@ -2288,7 +2293,7 @@ mod test_solve {
List.get [ 10, 9, 8, 7 ] 1
"#
),
"Result Int [ IndexOutOfBounds ]*",
"Result (Num *) [ IndexOutOfBounds ]*",
);
}
@ -2370,7 +2375,7 @@ mod test_solve {
f
"#
),
"{ p : *, q : * }* -> Int",
"{ p : *, q : * }* -> Num *",
);
}

213
compiler/solve/tests/test_uniq_solve.rs
View File

@ -57,7 +57,7 @@ mod test_uniq_solve {
#[test]
fn int_literal() {
infer_eq("5", "Attr * Int");
infer_eq("5", "Attr * (Num (Attr * *))");
}
#[test]
@ -176,7 +176,7 @@ mod test_uniq_solve {
[42]
"#
),
"Attr * (List (Attr * Int))",
"Attr * (List (Attr * (Num (Attr * *))))",
);
}
@ -188,7 +188,7 @@ mod test_uniq_solve {
[[[ 5 ]]]
"#
),
"Attr * (List (Attr * (List (Attr * (List (Attr * Int))))))",
"Attr * (List (Attr * (List (Attr * (List (Attr * (Num (Attr * *))))))))",
);
}
@ -200,7 +200,7 @@ mod test_uniq_solve {
[ 1, 2, 3 ]
"#
),
"Attr * (List (Attr * Int))",
"Attr * (List (Attr * (Num (Attr * *))))",
);
}
@ -212,7 +212,7 @@ mod test_uniq_solve {
[ [ 1 ], [ 2, 3 ] ]
"#
),
"Attr * (List (Attr * (List (Attr * Int))))",
"Attr * (List (Attr * (List (Attr * (Num (Attr * *))))))",
);
}
@ -328,7 +328,7 @@ mod test_uniq_solve {
\_, _ -> 42
"#
),
"Attr * (*, * -> Attr * Int)",
"Attr * (*, * -> Attr * (Num (Attr * *)))",
);
}
@ -398,7 +398,7 @@ mod test_uniq_solve {
func
"#
),
"Attr * (*, * -> Attr * Int)",
"Attr * (*, * -> Attr * (Num (Attr * *)))",
);
}
@ -462,7 +462,7 @@ mod test_uniq_solve {
c
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -498,7 +498,7 @@ mod test_uniq_solve {
alwaysFive "stuff"
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -546,7 +546,7 @@ mod test_uniq_solve {
),
// TODO investigate why is this not shared?
// maybe because y is not used it is dropped?
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -560,7 +560,7 @@ mod test_uniq_solve {
enlist 5
"#
),
"Attr * (List (Attr * Int))",
"Attr * (List (Attr * (Num (Attr * *))))",
);
}
@ -587,7 +587,7 @@ mod test_uniq_solve {
1 |> (\a -> a)
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -599,7 +599,7 @@ mod test_uniq_solve {
(\a -> a) 1
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -613,7 +613,7 @@ mod test_uniq_solve {
1 |> always "foo"
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -679,7 +679,7 @@ mod test_uniq_solve {
apply identity 5
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -702,13 +702,13 @@ mod test_uniq_solve {
// indoc!(
// r#"
// flip = \f -> (\a b -> f b a)
// neverendingInt = \f int -> f int
// x = neverendingInt (\a -> a) 5
// neverendingNum = \f int -> f int
// x = neverendingNum (\a -> a) 5
// flip neverendingInt
// flip neverendingNum
// "#
// ),
// "(Int, (a -> a)) -> Int",
// "((Num (Attr * *)), (a -> a)) -> (Num (Attr * *))",
// );
// }
@ -782,7 +782,7 @@ mod test_uniq_solve {
// 1 // 2
// "#
// ),
// "Int",
// "(Num (Attr * *))",
// );
// }
@ -794,7 +794,7 @@ mod test_uniq_solve {
// 1 + 2
// "#
// ),
// "Int",
// "(Num (Attr * *))",
// );
// }
@ -843,7 +843,7 @@ mod test_uniq_solve {
[ alwaysFive "foo", alwaysFive [] ]
"#
),
"Attr * (List (Attr * Int))",
"Attr * (List (Attr * (Num (Attr * *))))",
);
}
@ -858,7 +858,7 @@ mod test_uniq_solve {
24
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -872,18 +872,18 @@ mod test_uniq_solve {
3 -> 4
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
#[test]
fn record() {
infer_eq("{ foo: 42 }", "Attr * { foo : (Attr * Int) }");
infer_eq("{ foo: 42 }", "Attr * { foo : (Attr * (Num (Attr * *))) }");
}
#[test]
fn record_access() {
infer_eq("{ foo: 42 }.foo", "Attr * Int");
infer_eq("{ foo: 42 }.foo", "Attr * (Num (Attr * *))");
}
#[test]
@ -937,7 +937,7 @@ mod test_uniq_solve {
\Foo -> 42
"#
),
"Attr * (Attr * [ Foo ]* -> Attr * Int)",
"Attr * (Attr * [ Foo ]* -> Attr * (Num (Attr * *)))",
);
}
@ -949,7 +949,7 @@ mod test_uniq_solve {
\@Foo -> 42
"#
),
"Attr * (Attr * [ @Foo ]* -> Attr * Int)",
"Attr * (Attr * [ @Foo ]* -> Attr * (Num (Attr * *)))",
);
}
@ -964,7 +964,7 @@ mod test_uniq_solve {
False -> 0
"#
),
"Attr * (Attr * [ False, True ]* -> Attr * Int)",
"Attr * (Attr * [ False, True ]* -> Attr * (Num (Attr * *)))",
);
}
@ -976,7 +976,7 @@ mod test_uniq_solve {
Foo "happy" 2020
"#
),
"Attr * [ Foo (Attr * Str) (Attr * Int) ]*",
"Attr * [ Foo (Attr * Str) (Attr * (Num (Attr * *))) ]*",
);
}
@ -988,7 +988,7 @@ mod test_uniq_solve {
@Foo "happy" 2020
"#
),
"Attr * [ @Foo (Attr * Str) (Attr * Int) ]*",
"Attr * [ @Foo (Attr * Str) (Attr * (Num (Attr * *))) ]*",
);
}
@ -1037,7 +1037,7 @@ mod test_uniq_solve {
{ x: 4 } -> x
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -1079,7 +1079,7 @@ mod test_uniq_solve {
Foo x -> x
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -1092,7 +1092,7 @@ mod test_uniq_solve {
@Foo x -> x
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -1194,7 +1194,7 @@ mod test_uniq_solve {
{ numIdentity, p, q }
"#
),
"Attr * { numIdentity : (Attr Shared (Attr a (Num (Attr b p)) -> Attr a (Num (Attr b p)))), p : (Attr * Int), q : (Attr * Float) }"
"Attr * { numIdentity : (Attr Shared (Attr a (Num (Attr b p)) -> Attr a (Num (Attr b p)))), p : (Attr * (Num (Attr * p))), q : (Attr * Float) }"
);
}
@ -1380,7 +1380,7 @@ mod test_uniq_solve {
factorial
"#
),
"Attr Shared (Attr * Int -> Attr * Int)",
"Attr Shared (Attr * (Num (Attr * *)) -> Attr * (Num (Attr * *)))",
);
}
@ -1479,7 +1479,7 @@ mod test_uniq_solve {
s.left
"#
),
"Attr Shared Int",
"Attr Shared (Num (Attr * *))",
);
}
@ -1498,7 +1498,7 @@ mod test_uniq_solve {
{ y: s.left }
"#
),
"Attr * { y : (Attr Shared Int) }",
"Attr * { y : (Attr Shared (Num (Attr * *))) }",
);
}
@ -1549,7 +1549,7 @@ mod test_uniq_solve {
"#
),
// it's fine that the inner fields are not shared: only shared extraction is possible
"Attr * { left : (Attr Shared { left : (Attr * Int), right : (Attr * Int) }), right : (Attr Shared { left : (Attr * Int), right : (Attr * Int) }) }",
"Attr * { left : (Attr Shared { left : (Attr * (Num (Attr * *))), right : (Attr * (Num (Attr * *))) }), right : (Attr Shared { left : (Attr * (Num (Attr * *))), right : (Attr * (Num (Attr * *))) }) }",
);
}
@ -1869,7 +1869,7 @@ mod test_uniq_solve {
4 + 4
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -1882,7 +1882,7 @@ mod test_uniq_solve {
|> List.get 2
"#
),
"Attr * (Result (Attr * Int) (Attr * [ IndexOutOfBounds ]*))",
"Attr * (Result (Attr * (Num (Attr * *))) (Attr * [ IndexOutOfBounds ]*))",
);
}
@ -1988,7 +1988,7 @@ mod test_uniq_solve {
list
"#
),
"Attr * (Attr a (List (Attr Shared Int)) -> Attr a (List (Attr Shared Int)))",
"Attr * (Attr a (List (Attr Shared (Num (Attr b c)))) -> Attr a (List (Attr Shared (Num (Attr b c)))))",
);
}
@ -2004,7 +2004,7 @@ mod test_uniq_solve {
List.set list 0 42
"#
),
"Attr * (Attr (a | b) (List (Attr b Int)) -> Attr (a | b) (List (Attr b Int)))",
"Attr * (Attr (a | b) (List (Attr b (Num (Attr c d)))) -> Attr (a | b) (List (Attr b (Num (Attr c d)))))",
);
}
@ -2047,7 +2047,7 @@ mod test_uniq_solve {
sum
"#
),
"Attr * (Attr * (List (Attr * Int)) -> Attr * Int)",
"Attr * (Attr * (List (Attr * (Num (Attr a b)))) -> Attr * (Num (Attr a b)))",
);
}
@ -2095,7 +2095,7 @@ mod test_uniq_solve {
List.getUnsafe (List.set [ 12, 9, 7, 3 ] 1 42) 1
"#
),
"Attr * Int",
"Attr * (Num (Attr * *))",
);
}
@ -2113,7 +2113,8 @@ mod test_uniq_solve {
f
"#
),
"Attr * (Attr (* | a | b) { p : (Attr b *), q : (Attr a *) }* -> Attr * Int)",
"Attr * (Attr (* | a | b) { p : (Attr a *), q : (Attr b *) }* -> Attr * (Num (Attr * *)))",
//"Attr * (Attr (* | a | b) { p : (Attr b *), q : (Attr a *) }* -> Attr * (Num (Attr * *)))"
);
}
@ -2234,26 +2235,26 @@ mod test_uniq_solve {
infer_eq(
indoc!(
r#"
Model position : { evaluated : Set position
, openSet : Set position
, costs : Map.Map position Float
, cameFrom : Map.Map position position
}
Model position : { evaluated : Set position
, openSet : Set position
, costs : Map.Map position Float
, cameFrom : Map.Map position position
}
initialModel : position -> Model position
initialModel = \start ->
{ evaluated : Set.empty
, openSet : Set.singleton start
, costs : Map.singleton start 0.0
, cameFrom : Map.empty
}
initialModel : position -> Model position
initialModel = \start ->
{ evaluated : Set.empty
, openSet : Set.singleton start
, costs : Map.singleton start 0.0
, cameFrom : Map.empty
}
cheapestOpen : (position -> Float), Model position -> Result position [ KeyNotFound ]*
cheapestOpen = \costFunction, model ->
cheapestOpen : (position -> Float), Model position -> Result position [ KeyNotFound ]*
cheapestOpen = \costFunction, model ->
folder = \position, resSmallestSoFar ->
folder = \position, resSmallestSoFar ->
when Map.get model.costs position is
Err e ->
Err e
@ -2270,74 +2271,76 @@ mod test_uniq_solve {
else
Ok smallestSoFar
Set.foldl model.openSet folder (Err KeyNotFound)
|> Result.map (\x -> x.position)
Set.foldl model.openSet folder (Err KeyNotFound)
|> Result.map (\x -> x.position)
reconstructPath : Map position position, position -> List position
reconstructPath = \cameFrom, goal ->
when Map.get cameFrom goal is
Err KeyNotFound ->
[]
reconstructPath : Map position position, position -> List position
reconstructPath = \cameFrom, goal ->
when Map.get cameFrom goal is
Err KeyNotFound ->
[]
Ok next ->
List.push (reconstructPath cameFrom next) goal
Ok next ->
List.push (reconstructPath cameFrom next) goal
updateCost : position, position, Model position -> Model position
updateCost = \current, neighbour, model ->
newCameFrom = Map.insert model.cameFrom neighbour current
updateCost : position, position, Model position -> Model position
updateCost = \current, neighbour, model ->
newCameFrom = Map.insert model.cameFrom neighbour current
newCosts = Map.insert model.costs neighbour distanceTo
newCosts = Map.insert model.costs neighbour distanceTo
distanceTo = reconstructPath newCameFrom neighbour
|> List.len
|> Num.toFloat
distanceTo =
reconstructPath newCameFrom neighbour
|> List.length
|> Num.toFloat
newModel = { model & costs : newCosts , cameFrom : newCameFrom }
newModel = { model & costs : newCosts , cameFrom : newCameFrom }
when Map.get model.costs neighbour is
Err KeyNotFound ->
newModel
Ok previousDistance ->
if distanceTo < previousDistance then
when Map.get model.costs neighbour is
Err KeyNotFound ->
newModel
else
model
Ok previousDistance ->
if distanceTo < previousDistance then
newModel
else
model
findPath : { costFunction: (position, position -> Float), moveFunction: (position -> Set position), start : position, end : position } -> Result (List position) [ KeyNotFound ]*
findPath = \{ costFunction, moveFunction, start, end } ->
astar costFunction moveFunction end (initialModel start)
findPath : { costFunction: (position, position -> Float), moveFunction: (position -> Set position), start : position, end : position } -> Result (List position) [ KeyNotFound ]*
findPath = \{ costFunction, moveFunction, start, end } ->
astar costFunction moveFunction end (initialModel start)
astar : (position, position -> Float), (position -> Set position), position, Model position -> [ Err [ KeyNotFound ]*, Ok (List position) ]*
astar = \costFn, moveFn, goal, model ->
when cheapestOpen (\position -> costFn goal position) model is
Err _ ->
Err KeyNotFound
astar : (position, position -> Float), (position -> Set position), position, Model position -> [ Err [ KeyNotFound ]*, Ok (List position) ]*
astar = \costFn, moveFn, goal, model ->
when cheapestOpen (\position -> costFn goal position) model is
Err _ ->
Err KeyNotFound
Ok current ->
if current == goal then
Ok (reconstructPath model.cameFrom goal)
Ok current ->
if current == goal then
Ok (reconstructPath model.cameFrom goal)
else
else
modelPopped = { model & openSet : Set.remove model.openSet current, evaluated : Set.insert model.evaluated current }
modelPopped = { model & openSet : Set.remove model.openSet current, evaluated : Set.insert model.evaluated current }
neighbours = moveFn current
neighbours = moveFn current
newNeighbours = Set.diff neighbours modelPopped.evaluated
newNeighbours = Set.diff neighbours modelPopped.evaluated
modelWithNeighbours = { modelPopped & openSet : Set.union modelPopped.openSet newNeighbours }
modelWithNeighbours = { modelPopped & openSet : Set.union modelPopped.openSet newNeighbours }
modelWithCosts = Set.foldl newNeighbours (\nb, md -> updateCost current nb md) modelWithNeighbours
modelWithCosts = Set.foldl newNeighbours (\nb, md -> updateCost current nb md) modelWithNeighbours
astar costFn moveFn goal modelWithCosts
astar costFn moveFn goal modelWithCosts
findPath
findPath
"#
),
"Attr * (Attr * { costFunction : (Attr Shared (Attr Shared position, Attr Shared position -> Attr Shared Float)), end : (Attr Shared position), moveFunction : (Attr Shared (Attr Shared position -> Attr * (Set (Attr Shared position)))), start : (Attr Shared position) } -> Attr * (Result (Attr * (List (Attr Shared position))) (Attr * [ KeyNotFound ]*)))"

39
compiler/types/src/pretty_print.rs
View File

@ -436,7 +436,7 @@ fn write_flat_type(
buf.push_str(" ]");
if let Some(content) = ext_content {
if let Err(content) = ext_content {
// This is an open tag union, so print the variable
// right after the ']'
//
@ -483,7 +483,7 @@ fn write_flat_type(
buf.push_str(" ]");
if let Some(content) = ext_content {
if let Err(content) = ext_content {
// This is an open tag union, so print the variable
// right after the ']'
//
@ -504,14 +504,14 @@ fn write_flat_type(
}
}
fn chase_ext_tag_union(
subs: &mut Subs,
pub fn chase_ext_tag_union(
subs: &Subs,
var: Variable,
fields: &mut Vec<(TagName, Vec<Variable>)>,
) -> Option<Content> {
) -> Result<(), Content> {
use FlatType::*;
match subs.get(var).content {
Content::Structure(EmptyTagUnion) => None,
match subs.get_without_compacting(var).content {
Content::Structure(EmptyTagUnion) => Ok(()),
Content::Structure(TagUnion(tags, ext_var))
| Content::Structure(RecursiveTagUnion(_, tags, ext_var)) => {
for (label, vars) in tags {
@ -521,7 +521,30 @@ fn chase_ext_tag_union(
chase_ext_tag_union(subs, ext_var, fields)
}
content => Some(content),
content => Err(content),
}
}
pub fn chase_ext_record(
subs: &Subs,
var: Variable,
fields: &mut MutMap<Lowercase, Variable>,
) -> Result<(), Content> {
use crate::subs::Content::*;
use crate::subs::FlatType::*;
match subs.get_without_compacting(var).content {
Structure(Record(sub_fields, sub_ext)) => {
fields.extend(sub_fields.into_iter());
chase_ext_record(subs, sub_ext, fields)
}
Structure(EmptyRecord) => Ok(()),
Alias(_, _, var) => chase_ext_record(subs, var, fields),
content => Err(content),
}
}

284
compiler/types/src/subs.rs
View File

@ -6,7 +6,7 @@ use roc_module::symbol::Symbol;
use std::fmt;
use std::iter::{once, Iterator};
use std::sync::atomic::{AtomicU32, Ordering};
use ven_ena::unify::{InPlace, UnificationTable, UnifyKey};
use ven_ena::unify::{InPlace, Snapshot, UnificationTable, UnifyKey};
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub struct Mark(i32);
@ -42,7 +42,7 @@ struct NameState {
normals: u32,
}
#[derive(Default)]
#[derive(Default, Clone)]
pub struct Subs {
utable: UnificationTable<InPlace<Variable>>,
}
@ -151,9 +151,11 @@ impl Variable {
pub const EMPTY_RECORD: Variable = Variable(1);
pub const EMPTY_TAG_UNION: Variable = Variable(2);
const BOOL_ENUM: Variable = Variable(3);
pub const BOOL: Variable = Variable(4);
pub const RESERVED: usize = 5;
// variables 1 and 2 are reserved for EmptyRecord and EmptyTagUnion
const FIRST_USER_SPACE_VAR: Variable = Variable(3);
const FIRST_USER_SPACE_VAR: Variable = Variable(Self::RESERVED as u32);
/// # Safety
///
@ -228,8 +230,26 @@ impl Subs {
subs.utable.new_key(flex_var_descriptor());
}
subs.set_content(Variable(1), Content::Structure(FlatType::EmptyRecord));
subs.set_content(Variable(2), Content::Structure(FlatType::EmptyTagUnion));
subs.set_content(
Variable::EMPTY_RECORD,
Content::Structure(FlatType::EmptyRecord),
);
subs.set_content(
Variable::EMPTY_TAG_UNION,
Content::Structure(FlatType::EmptyTagUnion),
);
subs.set_content(Variable::BOOL_ENUM, {
let mut tags = MutMap::default();
tags.insert(TagName::Global("False".into()), vec![]);
tags.insert(TagName::Global("True".into()), vec![]);
Content::Structure(FlatType::TagUnion(tags, Variable::EMPTY_TAG_UNION))
});
subs.set_content(Variable::BOOL, {
Content::Alias(Symbol::BOOL_BOOL, vec![], Variable::BOOL_ENUM)
});
subs
}
@ -382,6 +402,14 @@ impl Subs {
pub fn is_empty(&self) -> bool {
self.utable.is_empty()
}
pub fn snapshot(&mut self) -> Snapshot<InPlace<Variable>> {
self.utable.snapshot()
}
pub fn rollback_to(&mut self, snapshot: Snapshot<InPlace<Variable>>) {
self.utable.rollback_to(snapshot)
}
}
#[inline(always)]
@ -522,6 +550,250 @@ pub enum FlatType {
Boolean(boolean_algebra::Bool),
}
#[derive(Clone, Debug, Hash, PartialEq, Eq, Copy)]
pub struct ContentHash(u64);
impl ContentHash {
pub fn from_var(var: Variable, subs: &mut Subs) -> Self {
use std::hash::Hasher;
let mut hasher = std::collections::hash_map::DefaultHasher::new();
Self::from_var_help(var, subs, &mut hasher);
ContentHash(hasher.finish())
}
pub fn from_var_help<T>(var: Variable, subs: &mut Subs, hasher: &mut T)
where
T: std::hash::Hasher,
{
Self::from_content_help(var, &subs.get_without_compacting(var).content, subs, hasher)
}
pub fn from_content_help<T>(var: Variable, content: &Content, subs: &mut Subs, hasher: &mut T)
where
T: std::hash::Hasher,
{
match content {
Content::Alias(_, _, actual) => {
// ensure an alias has the same hash as just the body of the alias
Self::from_var_help(*actual, subs, hasher)
}
Content::Structure(flat_type) => {
hasher.write_u8(0x10);
Self::from_flat_type_help(var, flat_type, subs, hasher)
}
Content::FlexVar(_) | Content::RigidVar(_) => {
hasher.write_u8(0x11);
}
Content::Error => {
hasher.write_u8(0x12);
}
}
}
pub fn from_flat_type_help<T>(
flat_type_var: Variable,
flat_type: &FlatType,
subs: &mut Subs,
hasher: &mut T,
) where
T: std::hash::Hasher,
{
use std::hash::Hash;
match flat_type {
FlatType::Func(arguments, ret) => {
hasher.write_u8(0);
for var in arguments {
Self::from_var_help(*var, subs, hasher);
}
Self::from_var_help(*ret, subs, hasher);
}
FlatType::Apply(symbol, arguments) => {
hasher.write_u8(1);
symbol.hash(hasher);
for var in arguments {
Self::from_var_help(*var, subs, hasher);
}
}
FlatType::EmptyRecord => {
hasher.write_u8(2);
}
FlatType::Record(record_fields, ext) => {
hasher.write_u8(3);
// NOTE: This function will modify the subs, putting all fields from the ext_var
// into the record itself, then setting the ext_var to EMPTY_RECORD
let mut fields = Vec::with_capacity(record_fields.len());
let mut extracted_fields_from_ext = false;
if *ext != Variable::EMPTY_RECORD {
let mut fields_map = MutMap::default();
match crate::pretty_print::chase_ext_record(subs, *ext, &mut fields_map) {
Err(Content::FlexVar(_)) | Ok(()) => {
if !fields_map.is_empty() {
extracted_fields_from_ext = true;
fields.extend(fields_map.into_iter());
}
}
Err(content) => panic!("Record with unexpected ext_var: {:?}", content),
}
}
fields.extend(record_fields.clone().into_iter());
fields.sort();
for (name, argument) in &fields {
name.hash(hasher);
Self::from_var_help(*argument, subs, hasher);
}
if *ext != Variable::EMPTY_RECORD {
// unify ext with empty record
let desc = subs.get(Variable::EMPTY_RECORD);
subs.union(Variable::EMPTY_RECORD, *ext, desc);
}
if extracted_fields_from_ext {
let fields_map = fields.into_iter().collect();
subs.set_content(
flat_type_var,
Content::Structure(FlatType::Record(fields_map, Variable::EMPTY_RECORD)),
);
}
}
FlatType::EmptyTagUnion => {
hasher.write_u8(4);
}
FlatType::TagUnion(tags, ext) => {
hasher.write_u8(5);
// NOTE: This function will modify the subs, putting all tags from the ext_var
// into the tag union itself, then setting the ext_var to EMPTY_TAG_UNION
let mut tag_vec = Vec::with_capacity(tags.len());
let mut extracted_fields_from_ext = false;
if *ext != Variable::EMPTY_TAG_UNION {
match crate::pretty_print::chase_ext_tag_union(subs, *ext, &mut tag_vec) {
Err(Content::FlexVar(_)) | Ok(()) => {
extracted_fields_from_ext = !tag_vec.is_empty();
}
Err(content) => panic!("TagUnion with unexpected ext_var: {:?}", content),
}
}
tag_vec.extend(tags.clone().into_iter());
tag_vec.sort();
for (name, arguments) in &tag_vec {
name.hash(hasher);
for var in arguments {
Self::from_var_help(*var, subs, hasher);
}
}
if *ext != Variable::EMPTY_TAG_UNION {
// unify ext with empty record
let desc = subs.get(Variable::EMPTY_TAG_UNION);
subs.union(Variable::EMPTY_TAG_UNION, *ext, desc);
}
if extracted_fields_from_ext {
let fields_map = tag_vec.into_iter().collect();
subs.set_content(
flat_type_var,
Content::Structure(FlatType::TagUnion(
fields_map,
Variable::EMPTY_TAG_UNION,
)),
);
}
}
FlatType::RecursiveTagUnion(rec, tags, ext) => {
// NOTE: rec is not hashed in. If all the tags and their arguments are the same,
// then the recursive tag unions are the same
hasher.write_u8(6);
// NOTE: This function will modify the subs, putting all tags from the ext_var
// into the tag union itself, then setting the ext_var to EMPTY_TAG_UNION
let mut tag_vec = Vec::with_capacity(tags.len());
let mut extracted_fields_from_ext = false;
if *ext != Variable::EMPTY_TAG_UNION {
match crate::pretty_print::chase_ext_tag_union(subs, *ext, &mut tag_vec) {
Err(Content::FlexVar(_)) | Ok(()) => {
extracted_fields_from_ext = !tag_vec.is_empty();
}
Err(content) => {
panic!("RecursiveTagUnion with unexpected ext_var: {:?}", content)
}
}
}
tag_vec.extend(tags.clone().into_iter());
tag_vec.sort();
for (name, arguments) in &tag_vec {
name.hash(hasher);
for var in arguments {
Self::from_var_help(*var, subs, hasher);
}
}
if *ext != Variable::EMPTY_TAG_UNION {
// unify ext with empty record
let desc = subs.get(Variable::EMPTY_TAG_UNION);
subs.union(Variable::EMPTY_TAG_UNION, *ext, desc);
}
if extracted_fields_from_ext {
let fields_map = tag_vec.into_iter().collect();
subs.set_content(
flat_type_var,
Content::Structure(FlatType::RecursiveTagUnion(
*rec,
fields_map,
Variable::EMPTY_TAG_UNION,
)),
);
}
}
FlatType::Boolean(boolean) => {
hasher.write_u8(7);
match boolean.simplify(subs) {
Ok(_variables) => hasher.write_u8(1),
Err(crate::boolean_algebra::Atom::One) => hasher.write_u8(1),
Err(crate::boolean_algebra::Atom::Zero) => hasher.write_u8(0),
Err(crate::boolean_algebra::Atom::Variable(_)) => unreachable!(),
}
}
FlatType::Erroneous(_problem) => {
hasher.write_u8(8);
//TODO hash the problem?
}
}
}
}
#[derive(PartialEq, Eq, Debug, Clone, Copy)]
pub enum Builtin {
Str,

8
compiler/types/src/types.rs
View File

@ -621,6 +621,7 @@ pub enum Reason {
BinOpRet(BinOp),
FloatLiteral,
IntLiteral,
NumLiteral,
InterpolatedStringVar,
WhenBranch { index: usize },
IfCondition,
@ -638,8 +639,9 @@ pub enum PatternCategory {
Set,
Map,
Ctor(TagName),
Int,
Str,
Num,
Int,
Float,
}
@ -726,14 +728,14 @@ pub fn name_type_var(letters_used: u32, taken: &mut MutSet<Lowercase>) -> (Lower
}
pub fn gather_fields(
subs: &mut Subs,
subs: &Subs,
fields: MutMap<Lowercase, Variable>,
var: Variable,
) -> RecordStructure {
use crate::subs::Content::*;
use crate::subs::FlatType::*;
match subs.get(var).content {
match subs.get_without_compacting(var).content {
Structure(Record(sub_fields, sub_ext)) => {
gather_fields(subs, union(fields, &sub_fields), sub_ext)
}

1
compiler/uniq/src/sharing.rs
View File

@ -515,6 +515,7 @@ pub fn annotate_usage(expr: &Expr, usage: &mut VarUsage) {
match expr {
RuntimeError(_)
| Num(_, _)
| Int(_, _)
| Float(_, _)
| Str(_)

44
roc-for-elm-programmers.md
View File

@ -694,24 +694,6 @@ Any operation which would result in one of these (such as `sqrt` or `/`) will
result in a runtime exception. Similarly to overflow, you can opt into handling these
a different way, such as `Float.trySqrt` which returns a `Result`.
Also like Elm, number literals with decimal points are `Float`. However, number
literals *without* a decimal point are always `Int`. So `x / 2` will never
compile in Roc; it would have to be `x / 2.0`, like in Python. Also [like Python](https://www.python.org/dev/peps/pep-0515/)
Roc permits underscores in number literals for readability purposes, and supports hexadecimal (`0x01`), octal (`0o01`), and binary (`0b01`) `Int` literals.
If you put these into a hypothetical Roc REPL, here's what you'd see:
```elm
> 1_024 + 1_024
2048 : Int
> 1.0 + 2.14
3.14 : Float
> 1 + 2.14
<type mismatch>
```
The way `+` works here is also a bit different than in Elm. Imagine if Elm's
`(+)` operator had this type:
@ -736,6 +718,32 @@ These don't exist in Roc.
* `comparable` is used for comparison operators (like `<` and such), plus `List.sort`, `Dict`, and `Set`. Roc's `List.sort` accepts a `Sorter` argument which specifies how to sort the elements. Roc's comparison operators (like `<`) only accept numbers; `"foo" < "bar"` is valid Elm, but will not compile in Roc. Roc's dictionaries and sets are hashmaps behind the scenes (rather than ordered trees), and their keys have no visible type restrictions.
* `number` is replaced by `Num`, as described earlier.
Like in Elm, number literals with decimal points are `Float`. However, number
literals *without* a decimal point are `Num *` instead of `number`.
Also [like Python](https://www.python.org/dev/peps/pep-0515/)
Roc permits underscores in number literals for readability purposes. Roc also supports
hexadecimal (`0x01`), octal (`0o01`), and binary (`0b01`) integer literals; these
literals all have type `Int` instead of `Num *`.
If you put these into a hypothetical Roc REPL, here's what you'd see:
```elm
> 1_024 + 1_024
2048 : Num *
> 1 + 2.14
3.14 : Float
> 1.0 + 1
2.0 : Float
> 1.1 + 0x11
<type mismatch between 1.1 : Float and 0x11 : Int>
> 11 + 0x11
28 : Int
```
## Operators
In Elm, operators are functions. In Roc, all operators are syntax sugar.