Detect ccache and use when building for Android and Apple

Author: kraenhansen

.changeset/tall-snakes-beg.md

@@ -0,0 +1,5 @@
+---
+"cmake-rn": minor
+---
+
+Detect ccache and use when building for Android and Apple

packages/cmake-rn/src/ccache.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert";
+import cp from "node:child_process";
+
+export function getCcachePath(): string | null {
+  const result = cp.spawnSync("which", ["ccache"]);
+  if (result.status === 0) {
+    return result.stdout.toString().trim();
+  } else {
+    return null;
+  }
+}
+
+export function getCmakeVersion(ccachePath: string): string {
+  const result = cp.spawnSync(ccachePath, ["--print-version"]);
+  assert.equal(result.status, 0, "Failed to get ccache version");
+  return result.stdout.toString().trim();
+}

packages/cmake-rn/src/cli.ts

@@ -20,12 +20,11 @@ import {
   platformHasTriplet,
 } from "./platforms.js";
 import { Platform } from "./platforms/types.js";
+import { getCcachePath, getCmakeVersion } from "./ccache.js";
 
 // We're attaching a lot of listeners when spawning in parallel
 EventEmitter.defaultMaxListeners = 100;
 
-// TODO: Add automatic ccache support
-
 const verboseOption = new Option(
   "--verbose",
   "Print more output during the build",
@@ -125,6 +124,11 @@ const cmakeJsOption = new Option(
   "Define CMAKE_JS_* variables used for compatibility with cmake-js",
 ).default(false);
 
+const ccachePathOption = new Option(
+  "--ccache-path <path>",
+  "Specify the path to the ccache executable",
+).default(getCcachePath());
+
 let program = new Command("cmake-rn")
   .description("Build React Native Node API modules with CMake")
   .addOption(tripletOption)
@@ -139,7 +143,8 @@ let program = new Command("cmake-rn")
   .addOption(stripOption)
   .addOption(noAutoLinkOption)
   .addOption(noWeakNodeApiLinkageOption)
-  .addOption(cmakeJsOption);
+  .addOption(cmakeJsOption)
+  .addOption(ccachePathOption);
 
 for (const platform of platforms) {
   const allOption = new Option(
@@ -169,7 +174,14 @@ program = program.action(
       process.cwd(),
       expandTemplate(baseOptions.out, baseOptions),
     );
-    const { verbose, clean, source, out, build: buildPath } = baseOptions;
+    const {
+      verbose,
+      clean,
+      source,
+      out,
+      build: buildPath,
+      ccachePath,
+    } = baseOptions;
 
     assertFixable(
       fs.existsSync(path.join(source, "CMakeLists.txt")),
@@ -179,6 +191,11 @@ program = program.action(
       },
     );
 
+    if (ccachePath) {
+      const cmakeVersion = getCmakeVersion(ccachePath);
+      console.log("♻️ Using ccache version", cmakeVersion);
+    }
+
     if (clean) {
       await fs.promises.rm(buildPath, { recursive: true, force: true });
     }

packages/cmake-rn/src/helpers.ts

@@ -1,8 +1,9 @@
-export function toDefineArguments(declarations: Array<Record<string, string>>) {
+export function toDefineArguments(
+  declarations: Array<Record<string, string | undefined>>,
+) {
   return declarations.flatMap((values) =>
-    Object.entries(values).flatMap(([key, definition]) => [
-      "-D",
-      `${key}=${definition}`,
-    ]),
+    Object.entries(values)
+      .filter(([_, definition]) => definition)
+      .flatMap(([key, definition]) => ["-D", `${key}=${definition}`]),
   );
 }

packages/cmake-rn/src/platforms/android.ts

@@ -133,6 +133,7 @@ export const platform: Platform<Triplet[], AndroidOpts> = {
       build,
       weakNodeApiLinkage,
       cmakeJs,
+      ccachePath,
     },
   ) {
     const ndkPath = getNdkPath(ndkVersion);
@@ -145,16 +146,18 @@ export const platform: Platform<Triplet[], AndroidOpts> = {
         CMAKE_SYSTEM_NAME: "Android",
         // "CMAKE_INSTALL_PREFIX": installPath,
         CMAKE_MAKE_PROGRAM: "ninja",
-        // "-D",
-        // "CMAKE_C_COMPILER_LAUNCHER=ccache",
-        // "-D",
-        // "CMAKE_CXX_COMPILER_LAUNCHER=ccache",
         ANDROID_NDK: ndkPath,
         ANDROID_TOOLCHAIN: "clang",
         ANDROID_PLATFORM: androidSdkVersion,
         // TODO: Make this configurable
         ANDROID_STL: "c++_shared",
       },
+      ccachePath
+        ? {
+            CMAKE_C_COMPILER_LAUNCHER: ccachePath,
+            CMAKE_CXX_COMPILER_LAUNCHER: ccachePath,
+          }
+        : {},
     ];
 
     await Promise.all(

packages/cmake-rn/src/platforms/apple.ts

@@ -193,6 +193,17 @@ async function readCmakeSharedLibraryTarget(
   return sharedLibrary;
 }
 
+async function getCompilerPath(
+  name: "clang" | "clang++",
+  { buildBinPath, ccachePath }: { buildBinPath: string; ccachePath: string },
+) {
+  const result = path.join(buildBinPath, name);
+  if (!fs.existsSync(result)) {
+    await fs.promises.symlink(ccachePath, result);
+  }
+  return result;
+}
+
 export const platform: Platform<Triplet[], AppleOpts> = {
   id: "apple",
   name: "Apple",
@@ -245,16 +256,40 @@ export const platform: Platform<Triplet[], AppleOpts> = {
   },
   async configure(
     triplets,
-    { source, build, define, weakNodeApiLinkage, cmakeJs },
-    spawn,
+    { source, build, define, weakNodeApiLinkage, cmakeJs, ccachePath },
   ) {
+    // When using ccache, we're creating symlinks for the clang and clang++ binaries to the ccache binary
+    // This is needed for ccache to understand it's being invoked as clang and clang++ respectively.
+    const buildBinPath = path.join(build, "bin");
+    await fs.promises.mkdir(buildBinPath, { recursive: true });
+    const compilerDefinitions = ccachePath
+      ? {
+          CMAKE_XCODE_ATTRIBUTE_CC: await getCompilerPath("clang", {
+            buildBinPath,
+            ccachePath,
+          }),
+          CMAKE_XCODE_ATTRIBUTE_CXX: await getCompilerPath("clang++", {
+            buildBinPath,
+            ccachePath,
+          }),
+          CMAKE_XCODE_ATTRIBUTE_LD: await getCompilerPath("clang", {
+            buildBinPath,
+            ccachePath,
+          }),
+          CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS: await getCompilerPath("clang++", {
+            buildBinPath,
+            ccachePath,
+          }),
+        }
+      : {};
+
     // Ideally, we would generate a single Xcode project supporting all architectures / platforms
     // However, CMake's Xcode generator does not support that well, so we generate one project per triplet
     // Specifically, the linking of weak-node-api breaks, since the sdk / arch specific framework
     // from the xcframework is picked at configure time, not at build time.
     // See https://gitlab.kitware.com/cmake/cmake/-/issues/21752#note_1717047 for more information.
     await Promise.all(
-      triplets.map(async ({ triplet }) => {
+      triplets.map(async ({ triplet, spawn }) => {
         const buildPath = getBuildPath(build, triplet);
         // We want to use the CMake File API to query information later
         // TODO: Or do we?
@@ -272,16 +307,15 @@ export const platform: Platform<Triplet[], AppleOpts> = {
           "Xcode",
           ...toDefineArguments([
             ...define,
-            ...(weakNodeApiLinkage ? [getWeakNodeApiVariables("apple")] : []),
-            ...(cmakeJs ? [getCmakeJSVariables("apple")] : []),
+            weakNodeApiLinkage ? getWeakNodeApiVariables("apple") : {},
+            cmakeJs ? getCmakeJSVariables("apple") : {},
+            compilerDefinitions,
             {
               CMAKE_SYSTEM_NAME: CMAKE_SYSTEM_NAMES[triplet],
               CMAKE_OSX_SYSROOT: XCODE_SDK_NAMES[triplet],
               CMAKE_OSX_ARCHITECTURES: APPLE_ARCHITECTURES[triplet],
               // Passing a linker flag to increase the header pad size to allow renaming the install name when linking it into the app.
               CMAKE_SHARED_LINKER_FLAGS: "-Wl,-headerpad_max_install_names",
-            },
-            {
               // Setting the output directories works around an issue with Xcode generator
               // where an unexpanded variable would emitted in the artifact paths.
               // This is okay, since we're generating per triplet build directories anyway.