Revert "wip canonical builtins in modules"

This reverts commit e1935a1e9f0c7ea1ffefe5f2f4f07f2c7666363b.

cli/src/main.rs

@@ -307,15 +307,12 @@ fn gen(
     let loc_expr = main_expr.unwrap_or_else(|| {
         panic!("TODO gracefully handle the case where `main` was declared but not exposed")
     });
-
     let mut subs = loaded.solved.into_inner();
     let content = match main_var {
         Some(var) => subs.get_without_compacting(var).content,
         None => todo!("TODO gracefully handle the case where `main` was declared but not exposed"),
     };
 
-    todo!("step 1. mono-module, step 2. actually have main here use the loaded builtin modules!");
-
     // Generate the binary
 
     let context = Context::create();

compiler/can/src/builtins.rs

@@ -1,27 +1,13 @@
-use crate::def::{Declaration, Def};
+use crate::def::Def;
-use crate::expr::{Expr, Recursive};
+use crate::expr::Expr;
-use roc_collections::all::{MutMap, MutSet, SendMap};
+use crate::expr::Recursive;
+use roc_collections::all::SendMap;
 use roc_module::ident::TagName;
-use roc_module::symbol::{ModuleId, Symbol};
+use roc_module::symbol::Symbol;
 use roc_parse::operator::CalledVia;
 use roc_region::all::{Located, Region};
 use roc_types::subs::{VarStore, Variable};
 
-fn exposed_symbols() -> MutMap<ModuleId, MutSet<Symbol>> {
-    let mut all = MutMap::default(); // TODO use with_capacity_and_hasher here
-
-    all.insert(ModuleId::LIST, {
-        let mut set = MutSet::default(); // TODO use with_capacity_and_hasher here
-
-        set.insert(Symbol::LIST_GET);
-        set.insert(Symbol::LIST_FIRST);
-
-        set
-    });
-
-    all
-}
-
 /// Some builtins cannot be constructed in code gen alone, and need to be defined
 /// as separate Roc defs. For example, List.get has this type:
 ///
@@ -39,24 +25,16 @@ fn exposed_symbols() -> MutMap<ModuleId, MutSet<Symbol>> {
 /// 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 declarations_by_id() -> MutMap<ModuleId, Vec<Declaration>> {
+pub fn builtin_defs(var_store: &VarStore) -> Vec<Def> {
-    let var_store = VarStore::default();
+    vec![
-    let mut decls = MutMap::default(); // TODO use with_capacity_and_hasher here
+        list_get(var_store),
-
+        list_first(var_store),
-    decls.insert(
+        int_div(var_store),
-        ModuleId::LIST,
+    ]
-        vec![
-            list_get(&var_store),
-            list_first(&var_store),
-            int_div(&var_store),
-        ],
-    );
-
-    decls
 }
 
 /// List.get : List elem, Int -> Result elem [ OutOfBounds ]*
-fn list_get(var_store: &VarStore) -> Declaration {
+fn list_get(var_store: &VarStore) -> Def {
     use crate::expr::Expr::*;
 
     defn(
@@ -127,7 +105,7 @@ fn list_get(var_store: &VarStore) -> Declaration {
 }
 
 /// Int.div : Int, Int -> Result Int [ DivByZero ]*
-fn int_div(var_store: &VarStore) -> Declaration {
+fn int_div(var_store: &VarStore) -> Def {
     use crate::expr::Expr::*;
     use crate::pattern::Pattern::*;
 
@@ -196,17 +174,17 @@ fn int_div(var_store: &VarStore) -> Declaration {
         Box::new((no_region(body), var_store.fresh())),
     );
 
-    Declare(Def {
+    Def {
         loc_pattern: no_region(Identifier(Symbol::INT_DIV)),
         loc_expr: no_region(expr),
         expr_var: var_store.fresh(),
         pattern_vars: SendMap::default(),
         annotation: None,
-    })
+    }
 }
 
 /// List.first : List elem -> Result elem [ ListWasEmpty ]*
-fn list_first(var_store: &VarStore) -> Declaration {
+fn list_first(var_store: &VarStore) -> Def {
     use crate::expr::Expr::*;
 
     defn(
@@ -298,7 +276,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) -> Declaration {
+fn defn(fn_name: Symbol, args: Vec<Symbol>, var_store: &VarStore, body: Expr) -> Def {
     use crate::expr::Expr::*;
     use crate::pattern::Pattern::*;
 
@@ -315,11 +293,11 @@ fn defn(fn_name: Symbol, args: Vec<Symbol>, var_store: &VarStore, body: Expr) ->
         Box::new((no_region(body), var_store.fresh())),
     );
 
-    Declaration::Declare(Def {
+    Def {
         loc_pattern: no_region(Identifier(fn_name)),
         loc_expr: no_region(expr),
         expr_var: var_store.fresh(),
         pattern_vars: SendMap::default(),
         annotation: None,
-    })
+    }
 }

compiler/load/src/file.rs

@@ -193,7 +193,8 @@ pub async fn load<'a>(
     loading_started.insert(root_id);
 
     // The declarations we'll ultimately be returning
-    let mut declarations_by_id: MutMap<ModuleId, Vec<Declaration>> = roc_can::builtins::declarations_by_id();
+    let mut declarations_by_id: MutMap<ModuleId, Vec<Declaration>> = MutMap::default();
+
     let mut exposed_symbols_by_module: MutMap<ModuleId, MutSet<Symbol>> = MutMap::default();
 
     // Modules which are waiting for certain headers to be parsed
@@ -468,11 +469,8 @@ pub async fn load<'a>(
                                     stdlib,
                                 );
 
-                                for unused_module_id in unused_modules.iter() {
+                                for _unused_module_id in unused_modules.iter() {
-                                    // Never report builtin modules as unused
+                                    panic!("TODO gracefully report unused imports for {:?}, namely {:?}", home, unused_modules);
-                                    if !unused_module_id.is_builtin() {
-                                        todo!("TODO gracefully report unused imports for {:?}, namely {:?}", home, unused_modules);
-                                    }
                                 }
                             }
                         }
@@ -583,7 +581,7 @@ fn send_header<'a>(
     // If it isn't, report a problem!
 
     let mut imported: Vec<(ModuleName, Vec<Ident>, Region)> = Vec::with_capacity(imports.len());
-    let mut imported_modules: MutSet<ModuleId> = ModuleId::default_imports();
+    let mut imported_modules: MutSet<ModuleId> = MutSet::default();
     let mut scope_size = 0;
 
     for loc_entry in imports {

compiler/module/src/symbol.rs

@@ -1,8 +1,8 @@
 use crate::ident::Ident;
 use inlinable_string::InlinableString;
-use roc_collections::all::{default_hasher, ImMap, MutMap, MutSet};
+use roc_collections::all::{default_hasher, ImMap, MutMap};
 use roc_region::all::Region;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::{fmt, u32};
 
 // TODO: benchmark this as { ident_id: u32, module_id: u32 } and see if perf stays the same
@@ -496,16 +496,6 @@ macro_rules! define_builtins {
                 self.0 < $total
             }
 
-            pub fn default_imports() -> MutSet<ModuleId> {
-                let mut all = HashSet::with_capacity_and_hasher($total, default_hasher());
-
-                $(
-                    all.insert(ModuleId($module_id));
-                )+
-
-                all
-            }
-
             $(
                 pub const $module_const: ModuleId = ModuleId($module_id);
             )+