make builtin applies importable

compiler/builtins/src/std.rs

@@ -1,4 +1,4 @@
-use roc_collections::all::{default_hasher, MutMap};
+use roc_collections::all::{default_hasher, MutMap, MutSet};
 use roc_module::ident::TagName;
 use roc_module::symbol::Symbol;
 use roc_region::all::{Located, Region};
@@ -16,6 +16,7 @@ pub struct StdLib {
     pub mode: Mode,
     pub types: MutMap<Symbol, (SolvedType, Region)>,
     pub aliases: MutMap<Symbol, BuiltinAlias>,
+    pub applies: MutSet<Symbol>,
 }
 
 pub fn standard_stdlib() -> StdLib {
@@ -23,6 +24,14 @@ pub fn standard_stdlib() -> StdLib {
         mode: Mode::Standard,
         types: types(),
         aliases: aliases(),
+        applies: vec![
+            Symbol::LIST_LIST,
+            Symbol::SET_SET,
+            Symbol::MAP_MAP,
+            Symbol::STR_STR,
+        ]
+        .into_iter()
+        .collect(),
     }
 }
 

compiler/builtins/src/unique.rs

@@ -105,6 +105,15 @@ pub fn uniq_stdlib() -> StdLib {
         mode: Mode::Uniqueness,
         types,
         aliases,
+        applies: vec![
+            Symbol::ATTR_ATTR,
+            Symbol::LIST_LIST,
+            Symbol::SET_SET,
+            Symbol::MAP_MAP,
+            Symbol::STR_STR,
+        ]
+        .into_iter()
+        .collect(),
     }
 }
 

compiler/load/src/file.rs

@@ -17,7 +17,7 @@ use roc_parse::module::module_defs;
 use roc_parse::parser::{Fail, Parser, State};
 use roc_region::all::{Located, Region};
 use roc_solve::solve::{self, ExposedModuleTypes, SubsByModule};
-use roc_types::solved_types::{BuiltinAlias, Solved, SolvedType};
+use roc_types::solved_types::{Solved, SolvedType};
 use roc_types::subs::{Subs, VarStore, Variable};
 use roc_types::types::{self, Alias};
 use std::collections::{HashMap, HashSet};
@@ -779,24 +779,22 @@ fn solve_module(
                         solved_type,
                     });
                 }
-                // This wasn't a builtin value; maybe it was a builtin alias.
+                None => {
-                None => match stdlib.aliases.get(&symbol) {
+                    if stdlib.applies.contains(&symbol) {
-                    Some(BuiltinAlias { region, typ, .. }) => {
+                        // do nothing
-                        let loc_symbol = Located {
+                    } else {
-                            value: symbol,
+                        // This wasn't a builtin value or Apply; maybe it was a builtin alias.
-                            region: *region,
+                        match stdlib.aliases.get(&symbol) {
-                        };
+                            Some(_) => {
-
+                                // do nothing
-                        imported_symbols.push(Import {
+                            }
-                            loc_symbol,
+                            None => panic!(
-                            solved_type: typ,
+                                "Could not find {:?} in builtin types {:?} or aliases {:?}",
-                        });
+                                symbol, stdlib.types, stdlib.aliases
+                            ),
+                        }
                     }
-                    None => panic!(
+                }
-                        "Could not find {:?} in builtin types {:?} or aliases {:?}",
-                        symbol, stdlib.types, stdlib.aliases
-                    ),
-                },
             }
         } else if module_id != home {
             // We already have constraints for our own symbols.