build: use async version

src/build/build.ts

@@ -1,27 +1,27 @@
 export interface PackageTask {
     name: string;
-    patchPhase?: (task: PackageTask) => void;
+    patchPhase?: (task: PackageTask) => Promise<void>;
-    configurePhase?: (task: PackageTask) => void;
+    configurePhase?: (task: PackageTask) => Promise<void>;
-    buildPhase?: (task: PackageTask) => void;
+    buildPhase?: (task: PackageTask) => Promise<void>;
-    installPhase?: (task: PackageTask) => void;
+    installPhase?: (task: PackageTask) => Promise<void>;
     [key: string]: any;
 }
 
-export function buildPackage(task: PackageTask) {
+export async function buildPackage(task: PackageTask) {
     if (task.patchPhase) {
         console.log(`${task.name}/patchPhase`);
-        task.patchPhase(task);
+        await task.patchPhase(task);
     }
     if (task.configurePhase) {
         console.log(`${task.name}/configurePhase`);
-        task.configurePhase(task);
+        await task.configurePhase(task);
     }
     if (task.buildPhase) {
         console.log(`${task.name}/buildPhase`);
-        task.buildPhase(task);
+        await task.buildPhase(task);
     }
     if (task.installPhase) {
         console.log(`${task.name}/installPhase`);
-        task.installPhase(task);
+        await task.installPhase(task);
     }
 }

src/build/llvmPackages.ts

@@ -2,7 +2,7 @@ import path from "path";
 import { GeneralVariable, LLVMVariable, command, variable } from "lyc/commands/cmake";
 import { SYSROOT_PREFIX, projectRoot } from "lyc/environment";
 import { PackageTask, buildPackage } from "./build";
-import { checkedSpawnSync } from "lyc/cli";
+import { promisifySpawn } from "lyc/cli";
 import os from "os";
 import { SpawnOptions, spawn } from "child_process";
 
@@ -39,29 +39,29 @@ export function llvmPackages(src: string, installPrefix: string): PackageTask[]
         cwd: src,
     };
 
-    const mkBuildPhase = (build: string) => {
+    const mkBuildPhase = (build: string) => (async () => {
-        checkedSpawnSync(cmake, ["--build", build], spawnOptions);
+        await promisifySpawn(spawn(cmake, ["--build", build], spawnOptions));
-    };
+    });
 
-    const mkInstallPhase = (build: string) => {
+    const mkInstallPhase = (build: string) => (async () => {
-        checkedSpawnSync(cmake, ["--build", build, "--target", "install"], spawnOptions);
+        await promisifySpawn(spawn(cmake, ["--build", build, "--target", "install"], spawnOptions));
-    };
+    });
 
     function mkLLVMPackage(): PackageTask {
         const build = path.join(LLVM_BUILD, "llvm");
         return {
             name: "llvm",
-            patchPhase: () => {
+            patchPhase: async () => {
                 // Apply llvm omp patch
-                checkedSpawnSync("git",
+                await promisifySpawn(spawn("git",
                     [
                         "apply",
                         path.resolve(projectRoot, "assets", "omp.diff"),
-                    ], spawnOptions);
+                    ], spawnOptions));
             },
-            configurePhase: () => {
+            configurePhase: async () => {
                 // Configure
-                checkedSpawnSync(cmake, command({
+                await promisifySpawn(spawn(cmake, command({
                     definitions: variable({
                         ...llvmVar,
                         ...general,
@@ -70,10 +70,10 @@ export function llvmPackages(src: string, installPrefix: string): PackageTask[]
                     // LLVM cmake root is under /llvm directory
                     pathToSource: path.join(src, "llvm"),
                     pathToBuild: build,
-                }), spawnOptions);
+                }), spawnOptions));
             },
-            buildPhase: () => mkBuildPhase(build),
+            buildPhase: mkBuildPhase(build),
-            installPhase: () => mkInstallPhase(build),
+            installPhase: mkInstallPhase(build),
         };
     }
 
@@ -81,11 +81,11 @@ export function llvmPackages(src: string, installPrefix: string): PackageTask[]
         const build = path.join(LLVM_BUILD, "libpgmath");
         return {
             name: "libpgmath",
-            configurePhase: () => {
+            configurePhase: async () => {
-                checkedSpawnSync(rm, ["-rf", build], spawnOptions);
+                await promisifySpawn(spawn(rm, ["-rf", build], spawnOptions));
 
                 // Configure libpgmath.
-                checkedSpawnSync(cmake, command({
+                await promisifySpawn(spawn(cmake, command({
                     definitions: variable({
                         ...general,
                         ...{
@@ -98,10 +98,10 @@ export function llvmPackages(src: string, installPrefix: string): PackageTask[]
                     generator: "Ninja",
                     pathToSource: path.join(src, "cflang", "runtime", "libpgmath"),
                     pathToBuild: build,
-                }), spawnOptions);
+                }), spawnOptions));
             },
-            buildPhase: () => mkBuildPhase(build),
+            buildPhase: mkBuildPhase(build),
-            installPhase: () => mkInstallPhase(build),
+            installPhase: mkInstallPhase(build),
         };
     }
 
@@ -109,11 +109,11 @@ export function llvmPackages(src: string, installPrefix: string): PackageTask[]
         const build = path.join(LLVM_BUILD, "cflang");
         return {
             name: "cflang",
-            configurePhase: () => {
+            configurePhase: async () => {
-                checkedSpawnSync(rm, ["-rf", build], spawnOptions);
+                await promisifySpawn(spawn(rm, ["-rf", build], spawnOptions));
 
                 // Configure cflang.
-                checkedSpawnSync(cmake, command({
+                await promisifySpawn(spawn(cmake, command({
                     definitions: variable({
                         ...llvmVar,
                         ...general,
@@ -132,23 +132,29 @@ export function llvmPackages(src: string, installPrefix: string): PackageTask[]
                     generator: "Unix Makefiles",
                     pathToSource: path.join(src, "cflang"),
                     pathToBuild: build,
-                }), spawnOptions);
+                }), spawnOptions));
             },
-            buildPhase: () => mkBuildPhase(build),
+            buildPhase: mkBuildPhase(build),
-            installPhase: () => mkInstallPhase(build),
+            installPhase: mkInstallPhase(build),
         };
     }
 
     return [mkLLVMPackage(), mkLibpgmathPackage(), mkCflangPackage()];
 
+}
 
-} export function buildLLVMHash(src: string, rev: string) {
+export async function buildLLVMHash(src: string, rev: string) {
     // Checkout a git rev in some git repo.
-    checkedSpawnSync("git", ["checkout", rev], { stdio: "inherit", cwd: src });
+    await promisifySpawn(spawn("git", ["checkout", rev], { stdio: "inherit", cwd: src }));
-    checkedSpawnSync("git", ["reset", "--hard", "HEAD"], { stdio: "inherit", cwd: src });
+    await promisifySpawn(spawn("git", ["reset", "--hard", "HEAD"], { stdio: "inherit", cwd: src }));
 
     const llvmInstall = path.join(src, "local", "installed");
 
-    llvmPackages(src, path.join(llvmInstall, rev))
+
-        .forEach(buildPackage);
+    const packages = llvmPackages(src, path.join(llvmInstall, rev));
+
+    // Packages must be built in-order.
+    for (const pkg of packages) {
+        await buildPackage(pkg);
+    }
 }