language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-30 15:21:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merging in remote

Browse source
This commit is contained in:
Chad Stearns 2020-06-07 23:50:20 -04:00
commit 5ad05efa39
13 changed files with 122 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

82
compiler/can/src/builtins.rs
View file

@ -1,7 +1,5 @@
use crate::def::Def;
use crate::expr::Expr;
use crate::expr::Recursive;
use roc_collections::all::SendMap;
use crate::expr::{Expr, Recursive};
use roc_collections::all::MutMap;
use roc_module::ident::TagName;
use roc_module::operator::CalledVia;
use roc_module::symbol::Symbol;
@ -25,27 +23,27 @@ use roc_types::subs::{VarStore, Variable};
/// delegates to the compiler-internal List.getUnsafe function to do the actual
/// lookup (if the bounds check passed). That internal function is hardcoded in code gen,
/// which works fine because it doesn't involve any open tag unions.
pub fn builtin_defs(var_store: &VarStore) -> Vec<Def> {
vec![
list_get(var_store),
list_first(var_store),
int_div(var_store),
int_abs(var_store),
int_rem(var_store),
int_is_odd(var_store),
int_is_even(var_store),
int_is_zero(var_store),
int_is_positive(var_store),
int_is_negative(var_store),
float_is_positive(var_store),
float_is_negative(var_store),
float_is_zero(var_store),
float_tan(var_store),
]
pub fn builtin_defs(var_store: &VarStore) -> MutMap<Symbol, Expr> {
mut_map! {
Symbol::LIST_GET => list_get(var_store),
Symbol::LIST_FIRST => list_first(var_store),
Symbol::INT_DIV => int_div(var_store),
Symbol::INT_ABS => int_abs(var_store),
Symbol::INT_REM => int_rem(var_store),
Symbol::INT_IS_ODD => int_is_odd(var_store),
Symbol::INT_IS_EVEN => int_is_even(var_store),
Symbol::INT_IS_ZERO => int_is_zero(var_store),
Symbol::INT_IS_POSITIVE => int_is_positive(var_store),
Symbol::INT_IS_NEGATIVE => int_is_negative(var_store),
Symbol::FLOAT_IS_POSITIVE => float_is_positive(var_store),
Symbol::FLOAT_IS_NEGATIVE => float_is_negative(var_store),
Symbol::FLOAT_IS_ZERO => float_is_zero(var_store),
Symbol::FLOAT_TAN => float_tan(var_store),
}
}
/// Float.tan : Float -> Float
fn float_tan(var_store: &VarStore) -> Def {
fn float_tan(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -72,7 +70,7 @@ fn float_tan(var_store: &VarStore) -> Def {
}
/// Float.isZero : Float -> Bool
fn float_is_zero(var_store: &VarStore) -> Def {
fn float_is_zero(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -91,7 +89,7 @@ fn float_is_zero(var_store: &VarStore) -> Def {
}
/// Float.isNegative : Float -> Bool
fn float_is_negative(var_store: &VarStore) -> Def {
fn float_is_negative(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -110,7 +108,7 @@ fn float_is_negative(var_store: &VarStore) -> Def {
}
/// Float.isPositive : Float -> Bool
fn float_is_positive(var_store: &VarStore) -> Def {
fn float_is_positive(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -129,7 +127,7 @@ fn float_is_positive(var_store: &VarStore) -> Def {
}
/// Int.isNegative : Int -> Bool
fn int_is_negative(var_store: &VarStore) -> Def {
fn int_is_negative(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -145,7 +143,7 @@ fn int_is_negative(var_store: &VarStore) -> Def {
}
/// Int.isPositive : Int -> Bool
fn int_is_positive(var_store: &VarStore) -> Def {
fn int_is_positive(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -161,7 +159,7 @@ fn int_is_positive(var_store: &VarStore) -> Def {
}
/// Int.isZero : Int -> Bool
fn int_is_zero(var_store: &VarStore) -> Def {
fn int_is_zero(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -177,7 +175,7 @@ fn int_is_zero(var_store: &VarStore) -> Def {
}
/// Int.isOdd : Int -> Bool
fn int_is_odd(var_store: &VarStore) -> Def {
fn int_is_odd(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -200,7 +198,7 @@ fn int_is_odd(var_store: &VarStore) -> Def {
}
/// Int.isEven : Int -> Bool
fn int_is_even(var_store: &VarStore) -> Def {
fn int_is_even(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -223,7 +221,7 @@ fn int_is_even(var_store: &VarStore) -> Def {
}
/// List.get : List elem, Int -> Result elem [ OutOfBounds ]*
fn list_get(var_store: &VarStore) -> Def {
fn list_get(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -294,7 +292,7 @@ fn list_get(var_store: &VarStore) -> Def {
}
/// Int.rem : Int, Int -> Int
fn int_rem(var_store: &VarStore) -> Def {
fn int_rem(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -341,7 +339,7 @@ fn int_rem(var_store: &VarStore) -> Def {
}
/// Int.abs : Int -> Int
fn int_abs(var_store: &VarStore) -> Def {
fn int_abs(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -378,7 +376,7 @@ fn int_abs(var_store: &VarStore) -> Def {
}
/// Int.div : Int, Int -> Result Int [ DivByZero ]*
fn int_div(var_store: &VarStore) -> Def {
fn int_div(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -437,7 +435,7 @@ fn int_div(var_store: &VarStore) -> Def {
}
/// List.first : List elem -> Result elem [ ListWasEmpty ]*
fn list_first(var_store: &VarStore) -> Def {
fn list_first(var_store: &VarStore) -> Expr {
use crate::expr::Expr::*;
defn(
@ -529,7 +527,7 @@ fn call(symbol: Symbol, args: Vec<Expr>, var_store: &VarStore) -> Expr {
}
#[inline(always)]
fn defn(fn_name: Symbol, args: Vec<Symbol>, var_store: &VarStore, body: Expr) -> Def {
fn defn(fn_name: Symbol, args: Vec<Symbol>, var_store: &VarStore, body: Expr) -> Expr {
use crate::expr::Expr::*;
use crate::pattern::Pattern::*;
@ -538,19 +536,11 @@ fn defn(fn_name: Symbol, args: Vec<Symbol>, var_store: &VarStore, body: Expr) ->
.map(|symbol| (var_store.fresh(), no_region(Identifier(symbol))))
.collect();
let expr = Closure(
Closure(
var_store.fresh(),
fn_name,
Recursive::NotRecursive,
closure_args,
Box::new((no_region(body), var_store.fresh())),
);
Def {
loc_pattern: no_region(Identifier(fn_name)),
loc_expr: no_region(expr),
expr_var: var_store.fresh(),
pattern_vars: SendMap::default(),
annotation: None,
}
)
}

30
compiler/can/src/def.rs
View file

@ -358,8 +358,8 @@ pub fn sort_can_defs(
let mut defined_symbols_set: ImSet<Symbol> = ImSet::default();
for symbol in can_defs_by_symbol.keys().into_iter() {
defined_symbols.push(symbol.clone());
defined_symbols_set.insert(symbol.clone());
defined_symbols.push(*symbol);
defined_symbols_set.insert(*symbol);
}
// Use topological sort to reorder the defs based on their dependencies to one another.
@ -688,7 +688,7 @@ fn pattern_to_vars_by_symbol(
use Pattern::*;
match pattern {
Identifier(symbol) => {
vars_by_symbol.insert(symbol.clone(), expr_var);
vars_by_symbol.insert(*symbol, expr_var);
}
AppliedTag { arguments, .. } => {
@ -699,7 +699,7 @@ fn pattern_to_vars_by_symbol(
RecordDestructure { destructs, .. } => {
for destruct in destructs {
vars_by_symbol.insert(destruct.value.symbol.clone(), destruct.value.var);
vars_by_symbol.insert(destruct.value.symbol, destruct.value.var);
}
}
@ -947,7 +947,7 @@ fn canonicalize_pending_def<'a>(
) = (
&loc_pattern.value,
&loc_can_pattern.value,
&loc_can_expr.value.clone(),
&loc_can_expr.value,
) {
is_closure = true;
@ -964,7 +964,7 @@ fn canonicalize_pending_def<'a>(
// closures don't have a name, and therefore pick a fresh symbol. But in this
// case, the closure has a proper name (e.g. `foo` in `foo = \x y -> ...`
// and we want to reference it by that name.
env.closures.insert(defined_symbol.clone(), references);
env.closures.insert(*defined_symbol, references);
// The closure is self tail recursive iff it tail calls itself (by defined name).
let is_recursive = match can_output.tail_call {
@ -975,7 +975,7 @@ fn canonicalize_pending_def<'a>(
// Recursion doesn't count as referencing. (If it did, all recursive functions
// would result in circular def errors!)
refs_by_symbol
.entry(defined_symbol.clone())
.entry(*defined_symbol)
.and_modify(|(_, refs)| {
refs.lookups = refs.lookups.without(defined_symbol);
});
@ -1008,7 +1008,7 @@ fn canonicalize_pending_def<'a>(
};
refs_by_symbol.insert(
symbol.clone(),
*symbol,
(
Located {
value: ident.clone(),
@ -1055,7 +1055,7 @@ fn canonicalize_pending_def<'a>(
env.tailcallable_symbol = Some(*defined_symbol);
// TODO isn't types_by_symbol enough? Do we need vars_by_symbol too?
vars_by_symbol.insert(defined_symbol.clone(), expr_var);
vars_by_symbol.insert(*defined_symbol, expr_var);
};
let (mut loc_can_expr, can_output) =
@ -1080,7 +1080,7 @@ fn canonicalize_pending_def<'a>(
) = (
&loc_pattern.value,
&loc_can_pattern.value,
&loc_can_expr.value.clone(),
&loc_can_expr.value,
) {
is_closure = true;
@ -1097,7 +1097,7 @@ fn canonicalize_pending_def<'a>(
// closures don't have a name, and therefore pick a fresh symbol. But in this
// case, the closure has a proper name (e.g. `foo` in `foo = \x y -> ...`
// and we want to reference it by that name.
env.closures.insert(defined_symbol.clone(), references);
env.closures.insert(*defined_symbol, references);
// The closure is self tail recursive iff it tail calls itself (by defined name).
let is_recursive = match can_output.tail_call {
@ -1108,7 +1108,7 @@ fn canonicalize_pending_def<'a>(
// Recursion doesn't count as referencing. (If it did, all recursive functions
// would result in circular def errors!)
refs_by_symbol
.entry(defined_symbol.clone())
.entry(*defined_symbol)
.and_modify(|(_, refs)| {
refs.lookups = refs.lookups.without(defined_symbol);
});
@ -1145,7 +1145,7 @@ fn canonicalize_pending_def<'a>(
});
refs_by_symbol.insert(
symbol.clone(),
symbol,
(
Located {
value: ident.clone().into(),
@ -1259,7 +1259,7 @@ fn closure_recursivity(symbol: Symbol, closures: &MutMap<Symbol, References>) ->
if let Some(references) = closures.get(&symbol) {
for v in &references.calls {
stack.push(v.clone());
stack.push(*v);
}
// while there are symbols left to visit
@ -1275,7 +1275,7 @@ fn closure_recursivity(symbol: Symbol, closures: &MutMap<Symbol, References>) ->
if let Some(nested_references) = closures.get(&nested_symbol) {
// add its called to the stack
for v in &nested_references.calls {
stack.push(v.clone());
stack.push(*v);
}
}
visited.insert(nested_symbol);

8
compiler/can/src/expr.rs
View file

@ -450,7 +450,7 @@ pub fn canonicalize_expr<'a>(
}
}
env.register_closure(symbol.clone(), output.references.clone());
env.register_closure(symbol, output.references.clone());
(
Closure(
@ -818,7 +818,7 @@ where
answer = answer.union(other_refs);
}
answer.lookups.insert(local.clone());
answer.lookups.insert(*local);
}
for call in refs.calls.iter() {
@ -828,7 +828,7 @@ where
answer = answer.union(other_refs);
}
answer.calls.insert(call.clone());
answer.calls.insert(*call);
}
answer
@ -860,7 +860,7 @@ where
answer = answer.union(other_refs);
}
answer.lookups.insert(closed_over_local.clone());
answer.lookups.insert(*closed_over_local);
}
for call in references.calls.iter() {

3
compiler/can/src/lib.rs
View file

@ -24,3 +24,6 @@ pub mod pattern;
pub mod procedure;
pub mod scope;
pub mod string;
#[macro_use]
extern crate roc_collections;

4
compiler/can/src/pattern.rs
View file

@ -57,7 +57,7 @@ pub fn symbols_from_pattern_help(pattern: &Pattern, symbols: &mut Vec<Symbol>) {
match pattern {
Identifier(symbol) => {
symbols.push(symbol.clone());
symbols.push(*symbol);
}
AppliedTag { arguments, .. } => {
@ -67,7 +67,7 @@ pub fn symbols_from_pattern_help(pattern: &Pattern, symbols: &mut Vec<Symbol>) {
}
RecordDestructure { destructs, .. } => {
for destruct in destructs {
symbols.push(destruct.value.symbol.clone());
symbols.push(destruct.value.symbol);
}
}

18
compiler/collections/src/all.rs
View file

@ -134,3 +134,21 @@ fn int_to_ordinal(number: usize) -> std::string::String {
format!("{}{}", number, ending)
}
#[macro_export]
macro_rules! mut_map {
(@single $($x:tt)*) => (());
(@count $($rest:expr),*) => (<[()]>::len(&[$(mut_map!(@single $rest)),*]));
($($key:expr => $value:expr,)+) => { mut_map!($($key => $value),+) };
($($key:expr => $value:expr),*) => {
{
let _cap = mut_map!(@count $($key),*);
let mut _map = ::std::collections::HashMap::with_capacity_and_hasher(_cap, $crate::all::default_hasher());
$(
let _ = _map.insert($key, $value);
)*
_map
}
};
}

8
compiler/constrain/src/pattern.rs
View file

@ -47,7 +47,7 @@ fn headers_from_annotation_help(
) -> bool {
match pattern {
Identifier(symbol) => {
headers.insert(symbol.clone(), annotation.clone());
headers.insert(*symbol, annotation.clone());
true
}
Underscore
@ -64,7 +64,7 @@ fn headers_from_annotation_help(
// NOTE ignores the .guard field.
if let Some(field_type) = fields.get(&destruct.value.label) {
headers.insert(
destruct.value.symbol.clone(),
destruct.value.symbol,
Located::at(annotation.region, field_type.clone()),
);
} else {
@ -123,7 +123,7 @@ pub fn constrain_pattern(
Identifier(symbol) => {
state.headers.insert(
symbol.clone(),
*symbol,
Located {
region,
value: expected.get_type(),
@ -197,7 +197,7 @@ pub fn constrain_pattern(
if !state.headers.contains_key(&symbol) {
state
.headers
.insert(symbol.clone(), Located::at(region, pat_type.clone()));
.insert(*symbol, Located::at(region, pat_type.clone()));
}
field_types.insert(label.clone(), pat_type.clone());

11
compiler/constrain/src/uniq.rs
View file

@ -148,7 +148,7 @@ fn constrain_pattern(
match &pattern.value {
Identifier(symbol) => {
state.headers.insert(
symbol.clone(),
*symbol,
Located {
region: pattern.region,
value: expected.get_type(),
@ -223,10 +223,9 @@ fn constrain_pattern(
let expected = PExpected::NoExpectation(pat_type.clone());
if !state.headers.contains_key(&symbol) {
state.headers.insert(
symbol.clone(),
Located::at(pattern.region, pat_type.clone()),
);
state
.headers
.insert(*symbol, Located::at(pattern.region, pat_type.clone()));
}
field_types.insert(label.clone(), pat_type.clone());
@ -1391,7 +1390,7 @@ fn constrain_var(
Lookup(symbol_for_lookup, expected, region)
}
Some(Usage::Access(_, _, _)) | Some(Usage::Update(_, _, _)) => {
applied_usage_constraint.insert(symbol_for_lookup.clone());
applied_usage_constraint.insert(symbol_for_lookup);
let mut variables = Vec::new();
let (free, rest, inner_type) =

37
compiler/gen/tests/helpers/mod.rs
View file

@ -6,10 +6,12 @@ pub mod eval;
use self::bumpalo::Bump;
use roc_builtins::unique::uniq_stdlib;
use roc_can::constraint::Constraint;
use roc_can::def::Def;
use roc_can::env::Env;
use roc_can::expected::Expected;
use roc_can::expr::{canonicalize_expr, Expr, Output};
use roc_can::operator;
use roc_can::pattern::Pattern;
use roc_can::scope::Scope;
use roc_collections::all::{ImMap, ImSet, MutMap, SendMap, SendSet};
use roc_constrain::expr::constrain_expr;
@ -245,16 +247,31 @@ pub fn can_expr_with(arena: &Bump, home: ModuleId, expr_str: &str) -> CanExprOut
// since we aren't using modules here.
let builtin_defs = roc_can::builtins::builtin_defs(&var_store);
for def in builtin_defs {
with_builtins = Expr::LetNonRec(
Box::new(def),
Box::new(Located {
region: Region::zero(),
value: with_builtins,
}),
var_store.fresh(),
SendMap::default(),
);
for (symbol, expr) in builtin_defs {
if output.references.lookups.contains(&symbol) || output.references.calls.contains(&symbol)
{
with_builtins = Expr::LetNonRec(
Box::new(Def {
loc_pattern: Located {
region: Region::zero(),
value: Pattern::Identifier(symbol),
},
loc_expr: Located {
region: Region::zero(),
value: expr,
},
expr_var: var_store.fresh(),
pattern_vars: SendMap::default(),
annotation: None,
}),
Box::new(Located {
region: Region::zero(),
value: with_builtins,
}),
var_store.fresh(),
SendMap::default(),
);
}
}
let loc_expr = Located {

2
compiler/reporting/src/error/canonicalize.rs
View file

@ -280,7 +280,7 @@ fn pretty_runtime_error<'b>(
if idents.is_empty() {
alloc
.reflow("The ")
.append(alloc.ident(first.value.clone()))
.append(alloc.ident(first.value))
.append(alloc.reflow(
" value is defined directly in terms of itself, causing an infinite loop.",
))

8
compiler/solve/src/solve.rs
View file

@ -333,7 +333,7 @@ fn solve(
let var = type_to_var(subs, rank, pools, cached_aliases, &loc_type.value);
local_def_vars.insert(
symbol.clone(),
*symbol,
Located {
value: var,
region: loc_type.region,
@ -344,7 +344,7 @@ fn solve(
let mut new_env = env.clone();
for (symbol, loc_var) in local_def_vars.iter() {
if !new_env.vars_by_symbol.contains_key(&symbol) {
new_env.vars_by_symbol.insert(symbol.clone(), loc_var.value);
new_env.vars_by_symbol.insert(*symbol, loc_var.value);
}
}
@ -398,7 +398,7 @@ fn solve(
type_to_var(subs, next_rank, next_pools, cached_aliases, &def_type);
local_def_vars.insert(
symbol.clone(),
*symbol,
Located {
value: var,
region: loc_type.region,
@ -469,7 +469,7 @@ fn solve(
for (symbol, loc_var) in local_def_vars.iter() {
if !new_env.vars_by_symbol.contains_key(&symbol) {
new_env.vars_by_symbol.insert(symbol.clone(), loc_var.value);
new_env.vars_by_symbol.insert(*symbol, loc_var.value);
}
}

4
compiler/types/src/boolean_algebra.rs
View file

@ -74,7 +74,7 @@ impl Bool {
for atom in &self.1 {
if let Variable(v) = atom {
result.insert(v.clone());
result.insert(*v);
}
}
@ -152,7 +152,7 @@ impl Bool {
if let Variable(v) = atom {
new_bound.insert(Variable(f(*v)));
} else {
new_bound.insert(atom.clone());
new_bound.insert(*atom);
}
}
Bool(new_free, new_bound)

2
compiler/uniq/src/sharing.rs
View file

@ -416,7 +416,7 @@ impl Composable for VarUsage {
}
};
self.usage.insert(symbol.clone(), value);
self.usage.insert(*symbol, value);
}
}
}