Ensure env modules dependencies are properly handled.

We figure out dependencies by looking at 'use' definition in parsed
  modules. However, in the case of environment modules, we must consider
  all of them when seeing "use env". Without that, the env modules are
  simply compiled in parallel and may not yet have been compiled when
  they are needed as actual dependencies.

crates/aiken-lang/src/ast.rs

@@ -69,16 +69,18 @@ impl<Info, Definitions> Module<Info, Definitions> {
 }
 
 impl UntypedModule {
-    pub fn dependencies(&self) -> Vec<(String, Span)> {
+    pub fn dependencies(&self, env_modules: &[String]) -> Vec<String> {
         self.definitions()
             .flat_map(|def| {
-                if let Definition::Use(Use {
+                if let Definition::Use(Use { module, .. }) = def {
-                    location, module, ..
+                    let name = module.join("/");
-                }) = def
+                    if name == ENV_MODULE {
-                {
+                        env_modules.to_vec()
-                    Some((module.join("/"), *location))
                     } else {
-                    None
+                        vec![name]
+                    }
+                } else {
+                    Vec::new()
                 }
             })
             .collect()

crates/aiken-project/src/module.rs

@@ -32,16 +32,9 @@ pub struct ParsedModule {
 }
 
 impl ParsedModule {
-    pub fn deps_for_graph(&self) -> (String, Vec<String>) {
+    pub fn deps_for_graph(&self, env_modules: &[String]) -> (String, Vec<String>) {
         let name = self.name.clone();
-
+        let deps: Vec<_> = self.ast.dependencies(env_modules);
-        let deps: Vec<_> = self
-            .ast
-            .dependencies()
-            .into_iter()
-            .map(|(dep, _span)| dep)
-            .collect();
-
         (name, deps)
     }
 
@@ -124,10 +117,19 @@ impl ParsedModules {
     }
 
     pub fn sequence(&self, our_modules: &BTreeSet<String>) -> Result<Vec<String>, Error> {
+        let env_modules = self
+            .0
+            .values()
+            .filter_map(|m| match m.kind {
+                ModuleKind::Env => Some(m.name.clone()),
+                ModuleKind::Lib | ModuleKind::Validator => None,
+            })
+            .collect::<Vec<String>>();
+
         let inputs = self
             .0
             .values()
-            .map(|m| m.deps_for_graph())
+            .map(|m| m.deps_for_graph(&env_modules))
             .collect::<Vec<(String, Vec<String>)>>();
 
         let capacity = inputs.len();