clean

src/Juvix/Compiler/Pipeline/Driver.hs

@@ -230,7 +230,7 @@ processModuleCacheMissDecide entryIx = do
     unless (info ^. Store.moduleInfoSHA256 == sha256) (throw RecompileSourceChanged)
     unless (info ^. Store.moduleInfoOptions == opts) (throw RecompileSourceChanged)
     unless (info ^. Store.moduleInfoFieldSize == entry ^. entryPointFieldSize) (throw RecompileFieldSizeChanged)
-    CompileResult {..} <- runReader entry (processImports (entryIx ^. entryIxImportNode . importNodeAbsFile) (info ^. Store.moduleInfoImports))
+    CompileResult {..} <- runReader entry (processImports (info ^. Store.moduleInfoImports))
     if
         | _compileResultChanged -> throw RecompileImportsChanged
         | otherwise ->
@@ -326,30 +326,17 @@ processRecursiveUpToTyped = do
 processImport ::
   forall r.
   (Members '[ModuleInfoCache, Reader EntryPoint, Error JuvixError, Files, PathResolver] r) =>
-  Path Abs File ->
   TopModulePath ->
   Sem r (PipelineResult Store.ModuleInfo)
-processImport importingModule p = withPathFile p getCachedImport
+processImport p = withPathFile p getCachedImport
   where
     getCachedImport :: ImportNode -> Sem r (PipelineResult Store.ModuleInfo)
     getCachedImport node = do
       hasParallelSupport <- supportsParallel
       eix <- mkEntryIndex node
       if
-          | hasParallelSupport -> do
-              res <- cacheLookup eix
-              return $ fromMaybe err res
+          | hasParallelSupport -> cacheGet eix
           | otherwise -> processModule eix
-      where
-        err :: forall a. a
-        err =
-          impossibleError
-            ( "While compiling\n"
-                <> prettyText importingModule
-                <> "\nexpected the module:\n"
-                <> prettyText (node ^. importNodeAbsFile)
-                <> "\nto be already compiled"
-            )
 
 processFileUpToParsing ::
   forall r.
@@ -359,7 +346,7 @@ processFileUpToParsing ::
 processFileUpToParsing entry = do
   res <- runReader entry upToParsing
   let imports :: [Import 'Parsed] = res ^. Parser.resultParserState . Parser.parserStateImports
-  mtab <- (^. compileResultModuleTable) <$> processImports (fromJust (entry ^. entryPointModulePath)) (map (^. importModulePath) imports)
+  mtab <- (^. compileResultModuleTable) <$> processImports (map (^. importModulePath) imports)
   return
     PipelineResult
       { _pipelineResult = res,
@@ -387,11 +374,10 @@ processFileUpTo a = do
 processImports ::
   forall r.
   (Members '[Reader EntryPoint, ModuleInfoCache, Error JuvixError, Files, PathResolver] r) =>
-  Path Abs File ->
   [TopModulePath] ->
   Sem r CompileResult
-processImports importingModule imports = do
-  ms :: [PipelineResult Store.ModuleInfo] <- forM imports (processImport importingModule)
+processImports imports = do
+  ms :: [PipelineResult Store.ModuleInfo] <- forM imports processImport
   let mtab =
         Store.mkModuleTable (map (^. pipelineResult) ms)
           <> mconcatMap (^. pipelineResultImports) ms

src/Juvix/Compiler/Pipeline/Loader/PathResolver/ImportTree.hs

@@ -78,12 +78,12 @@ mkImportTree mentrypointModulePath =
       ) =>
       ImportNode ->
       Sem r' ()
-    scanNode fromNode = withImportNode fromNode $ do
+    scanNode fromNode = withResolverRoot (fromNode ^. importNodePackageRoot) . withImportNode fromNode $ do
       scans <- toList <$> getNodeImports fromNode
       imports :: [ImportNode] <- mapM resolveImportScan scans
       forM_ (zipExact scans imports) $ \(importscan, toNode) -> do
         importTreeAddEdge importscan toNode
-        withResolverRoot (toNode ^. importNodePackageRoot) (visit toNode)
+        visit toNode
 
     resolveImportScan :: forall r'. (Members '[PathResolver] r') => ImportScan -> Sem r' ImportNode
     resolveImportScan s = do

src/Juvix/Compiler/Pipeline/Repl.hs

@@ -122,7 +122,7 @@ registerImport ::
   Import 'Parsed ->
   Sem r ()
 registerImport i = do
-  PipelineResult {..} <- processImport $(mkAbsFile "/<repl>") (i ^. importModulePath)
+  PipelineResult {..} <- processImport (i ^. importModulePath)
   let mtab' = Store.insertModule (i ^. importModulePath) _pipelineResult _pipelineResultImports
   modify' (appendArtifactsModuleTable mtab')
   scopeTable <- gets (^. artifactScopeTable)