language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-30 23:31: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);
}
}