moved all crates into seperate folder + related path fixes

crates/compiler/can/src/env.rs

@@ -0,0 +1,172 @@
+use crate::procedure::References;
+use crate::scope::Scope;
+use bumpalo::Bump;
+use roc_collections::{MutMap, VecSet};
+use roc_module::ident::{Ident, Lowercase, ModuleName};
+use roc_module::symbol::{IdentIdsByModule, ModuleId, ModuleIds, Symbol};
+use roc_problem::can::{Problem, RuntimeError};
+use roc_region::all::{Loc, Region};
+
+/// The canonicalization environment for a particular module.
+pub struct Env<'a> {
+    /// The module's path. Opaques and unqualified references to identifiers
+    /// are assumed to be relative to this path.
+    pub home: ModuleId,
+
+    pub dep_idents: &'a IdentIdsByModule,
+
+    pub module_ids: &'a ModuleIds,
+
+    /// Problems we've encountered along the way, which will be reported to the user at the end.
+    pub problems: Vec<Problem>,
+
+    /// Closures
+    pub closures: MutMap<Symbol, References>,
+
+    /// current tail-callable symbol
+    pub tailcallable_symbol: Option<Symbol>,
+
+    /// Symbols of values/functions which were referenced by qualified lookups.
+    pub qualified_value_lookups: VecSet<Symbol>,
+
+    /// Symbols of types which were referenced by qualified lookups.
+    pub qualified_type_lookups: VecSet<Symbol>,
+
+    pub top_level_symbols: VecSet<Symbol>,
+
+    pub arena: &'a Bump,
+}
+
+impl<'a> Env<'a> {
+    pub fn new(
+        arena: &'a Bump,
+        home: ModuleId,
+        dep_idents: &'a IdentIdsByModule,
+        module_ids: &'a ModuleIds,
+    ) -> Env<'a> {
+        Env {
+            arena,
+            home,
+            dep_idents,
+            module_ids,
+            problems: Vec::new(),
+            closures: MutMap::default(),
+            qualified_value_lookups: VecSet::default(),
+            qualified_type_lookups: VecSet::default(),
+            tailcallable_symbol: None,
+            top_level_symbols: VecSet::default(),
+        }
+    }
+
+    /// Returns Err if the symbol resolved, but it was not exposed by the given module
+    pub fn qualified_lookup(
+        &mut self,
+        scope: &Scope,
+        module_name_str: &str,
+        ident: &str,
+        region: Region,
+    ) -> Result<Symbol, RuntimeError> {
+        debug_assert!(
+            !module_name_str.is_empty(),
+            "Called env.qualified_lookup with an unqualified ident: {:?}",
+            ident
+        );
+
+        let is_type_name = ident.starts_with(|c: char| c.is_uppercase());
+
+        let module_name = ModuleName::from(module_name_str);
+
+        match self.module_ids.get_id(&module_name) {
+            Some(module_id) => {
+                // You can do qualified lookups on your own module, e.g.
+                // if I'm in the Foo module, I can do a `Foo.bar` lookup.
+                if module_id == self.home {
+                    match scope.locals.ident_ids.get_id(ident) {
+                        Some(ident_id) => {
+                            let symbol = Symbol::new(module_id, ident_id);
+
+                            if is_type_name {
+                                self.qualified_type_lookups.insert(symbol);
+                            } else {
+                                self.qualified_value_lookups.insert(symbol);
+                            }
+
+                            Ok(symbol)
+                        }
+                        None => {
+                            let error = RuntimeError::LookupNotInScope(
+                                Loc {
+                                    value: Ident::from(ident),
+                                    region,
+                                },
+                                scope
+                                    .locals
+                                    .ident_ids
+                                    .ident_strs()
+                                    .map(|(_, string)| string.into())
+                                    .collect(),
+                            );
+                            Err(error)
+                        }
+                    }
+                } else {
+                    match self.dep_idents.get(&module_id) {
+                        Some(exposed_ids) => match exposed_ids.get_id(ident) {
+                            Some(ident_id) => {
+                                let symbol = Symbol::new(module_id, ident_id);
+
+                                if is_type_name {
+                                    self.qualified_type_lookups.insert(symbol);
+                                } else {
+                                    self.qualified_value_lookups.insert(symbol);
+                                }
+
+                                Ok(symbol)
+                            }
+                            None => {
+                                let exposed_values = exposed_ids
+                                    .ident_strs()
+                                    .filter(|(_, ident)| {
+                                        ident.starts_with(|c: char| c.is_lowercase())
+                                    })
+                                    .map(|(_, ident)| Lowercase::from(ident))
+                                    .collect();
+                                Err(RuntimeError::ValueNotExposed {
+                                    module_name,
+                                    ident: Ident::from(ident),
+                                    region,
+                                    exposed_values,
+                                })
+                            }
+                        },
+                        None => Err(RuntimeError::ModuleNotImported {
+                            module_name,
+                            imported_modules: self
+                                .dep_idents
+                                .keys()
+                                .filter_map(|module_id| self.module_ids.get_name(*module_id))
+                                .map(|module_name| module_name.as_ref().into())
+                                .collect(),
+                            region,
+                            module_exists: true,
+                        }),
+                    }
+                }
+            }
+            None => Err(RuntimeError::ModuleNotImported {
+                module_name,
+                imported_modules: self
+                    .module_ids
+                    .available_modules()
+                    .map(|string| string.as_ref().into())
+                    .collect(),
+                region,
+                module_exists: false,
+            }),
+        }
+    }
+
+    pub fn problem(&mut self, problem: Problem) {
+        self.problems.push(problem)
+    }
+}