refactor: use workspace olean dirs in module targets and print-paths

Lake/Build/Binary.lean

@@ -46,8 +46,7 @@ protected def Package.sharedLibTarget (self : Package) : FileTarget :=
   Target.mk self.sharedLibFile do
     let depTargets ← self.buildDepTargets buildOleanAndCTargetWithDepTargets
     let depTarget ← self.buildDepTargetWith depTargets
-    let moreOleanDirs := packageTargetsToOleanDirs depTargets
-    let build := self.recBuildModuleOleanAndCTargetWithLocalImports moreOleanDirs depTarget
+    let build := self.recBuildModuleOleanAndCTargetWithLocalImports depTarget
     let pkgTarget ← self.buildTarget build
     let linkTargets :=
       pkgTarget.oFileTargets ++ self.moreLibTargets ++
@@ -64,8 +63,7 @@ protected def Package.binTarget (self : Package) : FileTarget :=
   Target.mk self.binFile do
     let depTargets ← self.buildDepTargets buildOleanAndCTargetWithDepTargets
     let depTarget ← self.buildDepTargetWith depTargets
-    let moreOleanDirs := packageTargetsToOleanDirs depTargets
-    let build := self.recBuildModuleOleanAndCTargetWithLocalImports moreOleanDirs depTarget
+    let build := self.recBuildModuleOleanAndCTargetWithLocalImports depTarget
     let pkgTarget ← self.buildModuleDAGTarget self.binRoot build
     let linkTargets :=
       pkgTarget.oFileTargets ++ self.moreLibTargets ++

Lake/Build/Module.lean

@@ -109,37 +109,33 @@ def moduleTarget [CheckExists i] [GetMTime i] [ComputeHash i] (info : i)
 
 def moduleOleanAndCTarget
 (leanFile cFile oleanFile traceFile : FilePath)
-(oleanDirs : List FilePath) (contents : String)  (depTarget : BuildTarget x)
+(contents : String)  (depTarget : BuildTarget x)
 (rootDir : FilePath := ".") (leanArgs : Array String := #[]) : OleanAndCTarget :=
   moduleTarget (OleanAndC.mk oleanFile cFile) leanFile traceFile contents depTarget do
-    compileOleanAndC leanFile oleanFile cFile oleanDirs rootDir leanArgs (← getLean)
+    compileOleanAndC leanFile oleanFile cFile  (← getOleanDirs) rootDir leanArgs (← getLean)
 
 def moduleOleanTarget
 (leanFile oleanFile traceFile : FilePath)
-(oleanDirs : List FilePath) (contents : String) (depTarget : BuildTarget x)
+(contents : String) (depTarget : BuildTarget x)
 (rootDir : FilePath := ".") (leanArgs : Array String := #[]) : FileTarget :=
   let target := moduleTarget oleanFile leanFile traceFile contents depTarget do
-    compileOlean leanFile oleanFile oleanDirs rootDir leanArgs (← getLean)
+    compileOlean leanFile oleanFile (← getOleanDirs) rootDir leanArgs (← getLean)
   target.withTask do target.mapAsync fun oleanFile depTrace => do
     return mixTrace (← computeTrace oleanFile) depTrace
 
-protected def Package.moduleOleanAndCTargetOnly
-(self : Package) (moreOleanDirs : List FilePath) (mod : Name)
-(leanFile : FilePath) (contents : String) (depTarget : BuildTarget x) :=
+protected def Package.moduleOleanAndCTargetOnly (self : Package)
+(mod : Name) (leanFile : FilePath) (contents : String) (depTarget : BuildTarget x) :=
   let cFile := self.modToC mod
   let oleanFile := self.modToOlean mod
   let traceFile := self.modToTraceFile mod
-  let oleanDirs :=  self.oleanDir :: moreOleanDirs
-  moduleOleanAndCTarget leanFile cFile oleanFile traceFile oleanDirs contents
+  moduleOleanAndCTarget leanFile cFile oleanFile traceFile contents
     depTarget self.rootDir self.moreLeanArgs
 
-protected def Package.moduleOleanTargetOnly
-(self : Package) (moreOleanDirs : List FilePath) (mod : Name)
-(leanFile : FilePath) (contents : String) (depTarget : BuildTarget x) :=
+protected def Package.moduleOleanTargetOnly (self : Package)
+(mod : Name) (leanFile : FilePath) (contents : String) (depTarget : BuildTarget x) :=
   let oleanFile := self.modToOlean mod
   let traceFile := self.modToTraceFile mod
-  let oleanDirs := self.oleanDir :: moreOleanDirs
-  moduleOleanTarget leanFile oleanFile traceFile oleanDirs contents depTarget
+  moduleOleanTarget leanFile oleanFile traceFile contents depTarget
     self.rootDir self.moreLeanArgs
 
 -- # Recursive Building
@@ -164,20 +160,20 @@ def recBuildModuleWithLocalImports (pkg : Package)
   build mod leanFile contents importTargets
 
 def Package.recBuildModuleOleanAndCTargetWithLocalImports [Monad m] [MonadLiftT BuildM m]
-(self : Package) (moreOleanDirs : List FilePath) (depTarget : ActiveBuildTarget x)
+(self : Package) (depTarget : ActiveBuildTarget x)
 : RecBuild Name ActiveOleanAndCTarget m :=
   recBuildModuleWithLocalImports self fun mod leanFile contents importTargets => do
     let importTarget ← ActiveTarget.collectOpaqueList <| importTargets.map (·.oleanTarget)
     let allDepsTarget := Target.active <| ← depTarget.mixOpaqueAsync importTarget
-    self.moduleOleanAndCTargetOnly moreOleanDirs mod leanFile contents allDepsTarget |>.run'
+    self.moduleOleanAndCTargetOnly mod leanFile contents allDepsTarget |>.run'
 
 def Package.recBuildModuleOleanTargetWithLocalImports [Monad m] [MonadLiftT BuildM m]
-(self : Package) (moreOleanDirs : List FilePath) (depTarget : ActiveBuildTarget x)
+(self : Package) (depTarget : ActiveBuildTarget x)
 : RecBuild Name ActiveFileTarget m :=
   recBuildModuleWithLocalImports self fun mod leanFile contents importTargets => do
     let importTarget ← ActiveTarget.collectOpaqueList importTargets
     let allDepsTarget := Target.active <| ← depTarget.mixOpaqueAsync importTarget
-    self.moduleOleanTargetOnly moreOleanDirs mod leanFile contents allDepsTarget |>.run
+    self.moduleOleanTargetOnly mod leanFile contents allDepsTarget |>.run
 
 -- ## Definitions
 

Lake/Build/Monad.lean

@@ -30,8 +30,11 @@ def getWorkspace : BuildM Workspace :=
 def getBuildDir : BuildM FilePath :=
   (·.buildDir) <$> getPackage
 
-def getOleanDir : BuildM FilePath :=
-  (·.oleanDir) <$> getPackage
+def getOleanDirs : BuildM (List FilePath) :=
+  (·.oleanDirs) <$> getWorkspace
+
+def getOleanPath : BuildM SearchPath :=
+  (·.oleanPath) <$> getWorkspace
 
 def getLeanInstall : BuildM LeanInstall :=
   (·.leanInstall) <$> read

Lake/Build/Package.lean

@@ -143,8 +143,7 @@ def Package.buildOleanTargetWithDepTargets
 (depTargets : Array (ActivePackageTarget x)) (self : Package)
 : BuildM (ActivePackageTarget FilePath) := do
   let depTarget ← self.buildDepTargetWith depTargets
-  let moreOleanDirs := packageTargetsToOleanDirs depTargets
-  self.buildTarget <| self.recBuildModuleOleanTargetWithLocalImports moreOleanDirs depTarget
+  self.buildTarget <| self.recBuildModuleOleanTargetWithLocalImports depTarget
 
 /-- Build the `.olean` and files of package and its dependencies' modules. -/
 def Package.buildOleanTarget (self : Package) : BuildM (ActivePackageTarget FilePath) := do
@@ -154,8 +153,7 @@ def Package.buildOleanAndCTargetWithDepTargets
 (depTargets : Array (ActivePackageTarget x)) (self : Package)
 : BuildM (ActivePackageTarget ActiveOleanAndCTargets) := do
   let depTarget ← self.buildDepTargetWith depTargets
-  let moreOleanDirs := packageTargetsToOleanDirs depTargets
-  self.buildTarget <| self.recBuildModuleOleanAndCTargetWithLocalImports moreOleanDirs depTarget
+  self.buildTarget <| self.recBuildModuleOleanAndCTargetWithLocalImports depTarget
 
 /-- Build the `.olean` and `.c` files of package and its dependencies' modules. -/
 def Package.buildOleanAndCTarget (self : Package) : BuildM (ActivePackageTarget ActiveOleanAndCTargets) := do
@@ -177,16 +175,14 @@ def Package.moduleOleanTarget (mod : Name) (self : Package) : FileTarget :=
   Target.mk (self.modToOlean mod) do
     let depTargets ← self.buildDepTargets buildOleanTargetWithDepTargets
     let depTarget ← self.buildDepTargetWith depTargets
-    let moreOleanDirs := packageTargetsToOleanDirs depTargets
-    let build := self.recBuildModuleOleanTargetWithLocalImports moreOleanDirs depTarget
+    let build := self.recBuildModuleOleanTargetWithLocalImports depTarget
     return (← buildModule mod build).task
 
 def Package.moduleOleanAndCTarget (mod : Name) (self : Package) : OleanAndCTarget :=
   Target.mk ⟨self.modToOlean mod, self.modToC mod⟩ do
     let depTargets ← self.buildDepTargets buildOleanAndCTargetWithDepTargets
     let depTarget ← self.buildDepTargetWith depTargets
-    let moreOleanDirs := packageTargetsToOleanDirs depTargets
-    let build := self.recBuildModuleOleanAndCTargetWithLocalImports moreOleanDirs depTarget
+    let build := self.recBuildModuleOleanAndCTargetWithLocalImports depTarget
     return (← buildModule mod build).task
 
 -- # Build Imports
@@ -217,31 +213,27 @@ def Package.buildDefaultDepTargets
     depTargets.map (·.withOnlyPackageInfo)
 
 /--
-Build the package's dependencies and a list of imports,
-returning the list of packages built.
+Build the package's dependencies and a list of imports.
 
 Builds only module `.olean` files if the default package facet is
 just `oleans`. Otherwise, builds both `.olean` and `.c` files.
 -/
 def Package.buildImportsAndDeps
-(imports : List String := []) (self : Package) : BuildM (List Package) := do
+(imports : List String := []) (self : Package) : BuildM PUnit := do
   -- resolve and build deps
   let depTargets ← self.buildDefaultDepTargets
   let depTarget ← self.buildDepTargetWith depTargets
-  let depPkgs := depTargets.map (·.info) |>.foldl (flip List.cons) []
   if imports.isEmpty then
     -- wait for deps to finish building
-    discard depTarget.materialize
+    depTarget.build
   else
      -- build local imports from list
-    let moreOleanDirs := depPkgs.map (·.oleanDir)
     let localImports := self.filterLocalImports imports
     if self.defaultFacet == PackageFacet.oleans then
-      let build := self.recBuildModuleOleanTargetWithLocalImports moreOleanDirs depTarget
+      let build := self.recBuildModuleOleanTargetWithLocalImports depTarget
       let targets ← buildModules localImports build
-      targets.forM (discard ·.materialize)
+      targets.forM (·.build)
     else
-      let build := self.recBuildModuleOleanAndCTargetWithLocalImports moreOleanDirs depTarget
+      let build := self.recBuildModuleOleanAndCTargetWithLocalImports depTarget
       let targets ← buildModules localImports build
-      targets.forM (discard ·.materialize)
-  return self :: depPkgs
+      targets.forM (·.build)

Lake/Build/Target.lean

@@ -58,6 +58,9 @@ def materializeAsync [Pure m] (self : ActiveTarget i k t) : m (k t) :=
 def materialize [Await k m'] [MonadLiftT m' m] (self : ActiveTarget i k t) : m t :=
   liftM <| await self.task
 
+def build [Await k m'] [MonadLiftT m' m] [Functor m] (self : ActiveTarget i k t) : m PUnit :=
+  discard <| self.materialize
+
 def mixOpaqueAsync
 [MixTrace t] [SeqMapAsync n k] [MonadLiftT n m] [Monad m]
 (t1 : ActiveTarget α k t) (t2 : ActiveTarget β k t) : m (ActiveTarget PUnit k t) := do

Lake/CLI/Main.lean

@@ -3,7 +3,7 @@ Copyright (c) 2021 Mac Malone. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mac Malone
 -/
-import Lean.Util.Paths
+
 import Lake.Config.Load
 import Lake.Config.SearchPath
 import Lake.Config.InstallPath
@@ -17,7 +17,7 @@ import Lake.CLI.Help
 import Lake.CLI.Build
 
 open System
-open Lean (Name LeanPaths Json toJson)
+open Lean (Name Json toJson)
 
 namespace Lake
 
@@ -232,11 +232,8 @@ def printPaths (imports : List String := []) : CliM PUnit := do
   if (← configFile.pathExists) then
     let (ws, pkg) ← loadConfig (← getSubArgs)
     let ctx ← mkBuildContext ws pkg leanInstall lakeInstall
-    let pkgs ← pkg.buildImportsAndDeps imports |>.run LogMethods.eio ctx
-    IO.println <| Json.compress <| toJson {
-      oleanPath := pkgs.map (·.oleanDir),
-      srcPath := pkgs.map (·.srcDir) : LeanPaths
-    }
+    pkg.buildImportsAndDeps imports |>.run LogMethods.eio ctx
+    IO.println <| Json.compress <| toJson ws.leanPaths
   else
     exit noConfigFileCode
 

Lake/Config/Workspace.lean

@@ -3,12 +3,13 @@ Copyright (c) 2021 Mac Malone. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mac Malone
 -/
+import Lean.Util.Paths
 import Lake.Config.Opaque
 import Lake.Config.WorkspaceConfig
 import Lake.Config.Package
 
 open System
-open Lean (Name NameMap)
+open Lean (Name NameMap LeanPaths)
 
 namespace Lake
 
@@ -62,6 +63,19 @@ def addPackage (pkg : Package) (self : Workspace) : Workspace :=
 def getPackage? (pkg : Name) (self : Workspace) : Option Package :=
   self.packageMap.find? pkg
 
+/-- The `.olean` directories of the workspace. -/
+def oleanDirs (self : Workspace) : List FilePath :=
+  self.packageMap.toList.map (·.2.oleanDir)
+
 /-- The `LEAN_PATH` of the workspace. -/
 def oleanPath (self : Workspace) : SearchPath :=
   self.packageMap.toList.map (·.2.oleanDir)
+
+/-- The `LEAN_SRC_PATH` of the workspace. -/
+def srcPath (self : Workspace) : SearchPath :=
+  self.packageMap.toList.map (·.2.srcDir)
+
+/-- The `LeanPaths` of the workspace. -/
+def leanPaths (self : Workspace) : LeanPaths :=
+  let pkgs := self.packageMap.toList
+  LeanPaths.mk (pkgs.map (·.2.oleanDir)) (pkgs.map (·.2.srcDir))