bootsnap 1.9.1 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00c1b5b2c37c6a351bb7656ef17ba7f7e6143fd773ceebd6ee09d9a55e25b75a
-  data.tar.gz: d6d6d1d68d97e4f2c50c61f0b928714cf94f29ecab6604bb0092517779212738
+  metadata.gz: 1bf1eca00971c561ca1e15941903dcf193ec8fc84c68736177a3aa72558c536b
+  data.tar.gz: bcd5596d1b4b00905af82cf25693fb72e71897685e024b27311353eef6f588bf
 SHA512:
-  metadata.gz: e1ade83cee1e4a917317cecd34107493424a5174b8bf92cc74db47743d4d84931de24533979480a23aa4ddb496cae8ce1f3cf30a2fbed3996b885a68138d16f0
-  data.tar.gz: 23e4f6c77307b30526b880bfd12983b7e66c9539556acd3bc05a2fa3fd6884a142c83dfaa590846651afad243c0bf69c96d994ca8492e5539d706ba3e6cf713f
+  metadata.gz: 0d3e37e56d994647ac88a1c9b83f087f137d32acfc09bfba1e71a85ce254697b1dcf6c9e1c90b5c71728ce0f3c0a63ee86680455a8f95003d237671435042859
+  data.tar.gz: 270bf8fc609981d25441c9c4bd975348130177564f2e1a0744f18720d7f59cda3c3da24bea0c07f2498a185308647b05715e1b1dd5a6045e653600ab2f5907a1

data/CHANGELOG.md

@@ -1,5 +1,128 @@
 # Unreleased
 
+# 1.16.0
+
+* Use `RbConfig::CONFIG["rubylibdir"]` instead of `RbConfig::CONFIG["libdir"]` to check for stdlib files. See #431.
+* Fix the cached version of `YAML.load_file` being slightly more permissive than the default `Psych` one. See #434.
+  `Date` and `Time` values are now properly rejected, as well as aliases.
+  If this causes a regression in your application, it is recommended to load *trusted* YAML files with `YAML.unsafe_load_file`.
+
+# 1.15.0
+
+* Add a readonly mode, for environments in which the updated cache wouldn't be persisted. See #428 and #423.
+
+# 1.14.0
+
+* Require Ruby 2.6.
+* Add a way to skip directories during load path scanning.
+  If you have large non-ruby directories in the middle of your load path, it can severely slow down scanning.
+  Typically this is a problem with `node_modules`. See #277.
+* Fix `Bootsnap.unload_cache!`, it simply wouldn't work at all becaue of a merge mistake. See #421.
+
+# 1.13.0
+
+* Stop decorating `Kernel.load`. This used to be very useful in development because the Rails "classic" autoloader
+  was using `Kernel.load` in dev and `Kernel.require` in production. But Zeitwerk is now the default, and it doesn't
+  use `Kernel.load` at all.
+
+  People still using the classic autoloader might want to stick to `bootsnap 1.12`.
+
+* Add `Bootsnap.unload_cache!`. Applications can call it at the end of their boot sequence when they know
+  no more code will be loaded to reclaim a bit of memory.
+
+# 1.12.0
+
+* `bootsnap precompile` CLI will now also precompile `Rakefile` and `.rake` files.
+
+* Stop decorating `Module#autoload` as it was only useful for supporting Ruby 2.2 and older.
+
+* Remove `uname` and other patform specific version from the cache keys. `RUBY_PLATFORM + RUBY_REVISION` should be
+  enough to ensure bytecode compatibility. This should improve caching for alpine based setups. See #409.
+
+# 1.11.1
+
+* Fix the `can't modify frozen Hash` error on load path cache mutation. See #411.
+
+# 1.11.0
+
+* Drop dependency on `fileutils`.
+
+* Better respect `Kernel#require` duck typing. While it almost never comes up in practice, `Kernel#require`
+  follow a fairly intricate duck-typing protocol on its argument implemented as `rb_get_path(VALUE)` in MRI.
+  So when applicable we bind `rb_get_path` and use it for improved compatibility. See #396 and #406.
+
+* Get rid of the `Kernel.require_relative` decorator by resolving `$LOAD_PATH` members to their real path.
+  This way we handle symlinks in `$LOAD_PATH` much more efficiently. See #402 for the detailed explanation.
+  
+* Drop support for Ruby 2.3 (to allow getting rid of the `Kernel.require_relative` decorator).
+
+# 1.10.3
+
+* Fix Regexp and Date type support in YAML compile cache. (#400)
+
+* Improve the YAML compile cache to support `UTF-8` symbols. (#398, #399)
+  [The default `MessagePack` symbol serializer assumes all symbols are ASCII](https://github.com/msgpack/msgpack-ruby/pull/211),
+  because of this, non-ASCII compatible symbol would be restored with `ASCII_8BIT` encoding (AKA `BINARY`).
+  Bootsnap now properly cache them in `UTF-8`.
+
+  Note that the above only apply for actual YAML symbols (e..g `--- :foo`).
+  The issue is still present for string keys parsed with `YAML.load_file(..., symbolize_names: true)`, that is a bug
+  in `msgpack` that will hopefully be solved soon, see: https://github.com/msgpack/msgpack-ruby/pull/246
+
+* Entirely disable the YAML compile cache if `Encoding.default_internal` is set to an encoding not supported by `msgpack`. (#398)
+  `Psych` coerce strings to `Encoding.default_internal`, but `MessagePack` doesn't. So in this scenario we can't provide
+  YAML caching at all without returning the strings in the wrong encoding.
+  This never came up in practice but might as well be safe.
+
+# 1.10.2
+
+* Reduce the `Kernel.require` extra stack frames some more. Now bootsnap should only add one extra frame per `require` call.
+
+* Better check `freeze` option support in JSON compile cache.
+  Previously `JSON.load_file(..., freeze: true)` would be cached even when the msgpack version is missing support for it.
+
+# 1.10.1
+
+* Fix `Kernel#autoload`'s fallback path always being executed.
+
+* Consider `unlink` failing with `ENOENT` as a success.
+
+# 1.10.0
+
+* Delay requiring `FileUtils`. (#285)
+  `FileUtils` can be installed as a gem, so it's best to wait for bundler to have setup the load path before requiring it.
+
+* Improve support of Psych 4. (#392)
+  Since `1.8.0`, `YAML.load_file` was no longer cached when Psych 4 was used. This is because `load_file` loads
+  in safe mode by default, so the Bootsnap cache could defeat that safety.
+  Now when precompiling YAML files, Bootsnap first try to parse them in safe mode, and if it can't fallback to unsafe mode,
+  and the cache contains a flag that records whether it was generated in safe mode or not.
+  `YAML.unsafe_load_file` will use safe caches just fine, but `YAML.load_file` will fallback to uncached YAML parsing
+  if the cache was generated using unsafe parsing.
+
+* Minimize the Kernel.require extra stack frames. (#393)
+  This should reduce the noise generated by bootsnap on `LoadError`.
+
+# 1.9.4
+
+* Ignore absolute paths in the loaded feature index. (#385)
+  This fixes a compatibility issue with Zeitwerk when Zeitwerk is loaded before bootsnap. It also should
+  reduce the memory usage and improve load performance of Zeitwerk managed files.
+
+* Automatically invalidate the load path cache whenever the Ruby version change. (#387)
+  This is to avoid issues in case the same installation path is re-used for subsequent ruby patch releases.
+
+# 1.9.3
+
+* Only disable the compile cache for source files impacted by [Ruby 3.0.3 [Bug 18250]](https://bugs.ruby-lang.org/issues/18250).
+  This should keep the performance loss to a minimum.
+
+# 1.9.2
+
+* Disable compile cache if [Ruby 3.0.3's ISeq cache bug](https://bugs.ruby-lang.org/issues/18250) is detected.
+  AKA `iseq.rb:13 to_binary: wrong argument type false (expected Symbol)`
+* Fix `Kernel.load` behavior: before `load 'a'` would load `a.rb` (and other tried extensions) and wouldn't load `a` unless `development_mode: true`, now only `a` would be loaded and files with extensions wouldn't be.
+
 # 1.9.1
 
 * Removed a forgotten debug statement in JSON precompilation.
@@ -14,7 +137,7 @@
 
 # 1.8.0
 
-* Improve support for Pysch 4. (#368)
+* Improve support for Psych 4. (#368)
 
 # 1.7.7
 
@@ -32,8 +155,8 @@
 
 # 1.7.4
 
-* Stop raising errors when encoutering various file system errors. The cache is now best effort,
-  if somehow it can't be saved, bootsnapp will gracefully fallback to the original operation (e.g. `Kernel.require`).
+* Stop raising errors when encountering various file system errors. The cache is now best effort,
+  if somehow it can't be saved, bootsnap will gracefully fallback to the original operation (e.g. `Kernel.require`).
   (#353, #177, #262)
 
 # 1.7.3

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Shopify, Inc.
+Copyright (c) 2017-present Shopify, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -41,7 +41,7 @@ getting progressively slower, this is almost certainly the cause.**
 It's technically possible to simply specify `gem 'bootsnap', require: 'bootsnap/setup'`, but it's
 important to load Bootsnap as early as possible to get maximum performance improvement.
 
-You can see how this require works [here](https://github.com/Shopify/bootsnap/blob/master/lib/bootsnap/setup.rb).
+You can see how this require works [here](https://github.com/Shopify/bootsnap/blob/main/lib/bootsnap/setup.rb).
 
 If you are not using Rails, or if you are but want more control over things, add this to your
 application setup immediately after `require 'bundler/setup'` (i.e. as early as possible: the sooner
@@ -52,10 +52,12 @@ require 'bootsnap'
 env = ENV['RAILS_ENV'] || "development"
 Bootsnap.setup(
   cache_dir:            'tmp/cache',          # Path to your cache
+  ignore_directories:   ['node_modules'],     # Directory names to skip.
   development_mode:     env == 'development', # Current working environment, e.g. RACK_ENV, RAILS_ENV, etc
   load_path_cache:      true,                 # Optimize the LOAD_PATH with a cache
   compile_cache_iseq:   true,                 # Compile Ruby code into ISeq cache, breaks coverage reporting.
-  compile_cache_yaml:   true                  # Compile YAML into a cache
+  compile_cache_yaml:   true,                 # Compile YAML into a cache
+  readonly:             true,                 # Use the caches but don't update them on miss or stale entries.
 )
 ```
 
@@ -66,7 +68,7 @@ will help optimize boot time further if you have an extremely large `$LOAD_PATH`
 Note: Bootsnap and [Spring](https://github.com/rails/spring) are orthogonal tools. While Bootsnap
 speeds up the loading of individual source files, Spring keeps a copy of a pre-booted Rails process
 on hand to completely skip parts of the boot process the next time it's needed. The two tools work
-well together, and are both included in a newly-generated Rails applications by default.
+well together.
 
 ### Environment variables
 
@@ -76,7 +78,11 @@ well together, and are both included in a newly-generated Rails applications by
 - `DISABLE_BOOTSNAP` allows to entirely disable bootsnap.
 - `DISABLE_BOOTSNAP_LOAD_PATH_CACHE` allows to disable load path caching.
 - `DISABLE_BOOTSNAP_COMPILE_CACHE` allows to disable ISeq and YAML caches.
+- `BOOTSNAP_READONLY` configure bootsnap to not update the cache on miss or stale entries.
 - `BOOTSNAP_LOG` configure bootsnap to log all caches misses to STDERR.
+- `BOOTSNAP_IGNORE_DIRECTORIES` a comma separated list of directories that shouldn't be scanned.
+  Useful when you have large directories of non-ruby files inside `$LOAD_PATH`.
+  It defaults to ignore any directory named `node_modules`.
 
 ### Environments
 
@@ -161,7 +167,7 @@ The only directories considered "stable" are things under the Ruby install prefi
 "volatile".
 
 In addition to the [`Bootsnap::LoadPathCache::Cache`
-source](https://github.com/Shopify/bootsnap/blob/master/lib/bootsnap/load_path_cache/cache.rb),
+source](https://github.com/Shopify/bootsnap/blob/main/lib/bootsnap/load_path_cache/cache.rb),
 this diagram may help clarify how entry resolution works:
 
 ![How path searching works](https://cloud.githubusercontent.com/assets/3074765/25388270/670b5652-299b-11e7-87fb-975647f68981.png)
@@ -232,9 +238,9 @@ Bootsnap writes a cache file containing a 64 byte header followed by the cache c
 is a cache key including several fields:
 
 * `version`, hardcoded in bootsnap. Essentially a schema version;
-* `ruby_platform`, A hash of `RUBY_PLATFORM` (e.g. x86_64-linux-gnu) variable and glibc version (on Linux) or OS version (`uname -v` on BSD, macOS)
+* `ruby_platform`, A hash of `RUBY_PLATFORM` (e.g. x86_64-linux-gnu) variable.
 * `compile_option`, which changes with `RubyVM::InstructionSequence.compile_option` does;
-* `ruby_revision`, the version of Ruby this was compiled with;
+* `ruby_revision`, A hash of `RUBY_REVISION`, the exact version of Ruby;
 * `size`, the size of the source file;
 * `mtime`, the last-modification timestamp of the source file when it was compiled; and
 * `data_size`, the number of bytes following the header, which we need to read it into a buffer.

data/exe/bootsnap

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'bootsnap/cli'
+require "bootsnap/cli"
 exit Bootsnap::CLI.new(ARGV).run

data/ext/bootsnap/bootsnap.c

@@ -19,12 +19,6 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
-#ifndef _WIN32
-#include <sys/utsname.h>
-#endif
-#ifdef __GLIBC__
-#include <gnu/libc-version.h>
-#endif
 
 /* 1000 is an arbitrary limit; FNV64 plus some slashes brings the cap down to
  * 981 for the cache dir */
@@ -75,7 +69,7 @@ struct bs_cache_key {
 STATIC_ASSERT(sizeof(struct bs_cache_key) == KEY_SIZE);
 
 /* Effectively a schema version. Bumping invalidates all previous caches */
-static const uint32_t current_version = 3;
+static const uint32_t current_version = 4;
 
 /* hash of e.g. "x86_64-darwin17", invalidating when ruby is recompiled on a
  * new OS ABI, etc. */
@@ -91,15 +85,16 @@ static mode_t current_umask;
 static VALUE rb_mBootsnap;
 static VALUE rb_mBootsnap_CompileCache;
 static VALUE rb_mBootsnap_CompileCache_Native;
-static VALUE rb_eBootsnap_CompileCache_Uncompilable;
-static ID uncompilable;
+static VALUE rb_cBootsnap_CompileCache_UNCOMPILABLE;
 static ID instrumentation_method;
 static VALUE sym_miss;
 static VALUE sym_stale;
 static bool instrumentation_enabled = false;
+static bool readonly = false;
 
 /* Functions exposed as module functions on Bootsnap::CompileCache::Native */
 static VALUE bs_instrumentation_enabled_set(VALUE self, VALUE enabled);
+static VALUE bs_readonly_set(VALUE self, VALUE enabled);
 static VALUE bs_compile_option_crc32_set(VALUE self, VALUE crc32_v);
 static VALUE bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler, VALUE args);
 static VALUE bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler);
@@ -120,10 +115,8 @@ static uint32_t get_ruby_platform(void);
  * exception.
  */
 static int bs_storage_to_output(VALUE handler, VALUE args, VALUE storage_data, VALUE * output_data);
-static VALUE prot_storage_to_output(VALUE arg);
 static VALUE prot_input_to_output(VALUE arg);
 static void bs_input_to_output(VALUE handler, VALUE args, VALUE input_data, VALUE * output_data, int * exception_tag);
-static VALUE prot_input_to_storage(VALUE arg);
 static int bs_input_to_storage(VALUE handler, VALUE args, VALUE input_data, VALUE pathval, VALUE * storage_data);
 struct s2o_data;
 struct i2o_data;
@@ -138,6 +131,12 @@ bs_rb_coverage_running(VALUE self)
   return RTEST(cov) ? Qtrue : Qfalse;
 }
 
+static VALUE
+bs_rb_get_path(VALUE self, VALUE fname)
+{
+    return rb_get_path(fname);
+}
+
 /*
  * Ruby C extensions are initialized by calling Init_<extname>.
  *
@@ -149,14 +148,17 @@ void
 Init_bootsnap(void)
 {
   rb_mBootsnap = rb_define_module("Bootsnap");
+
+  rb_define_singleton_method(rb_mBootsnap, "rb_get_path", bs_rb_get_path, 1);
+
   rb_mBootsnap_CompileCache = rb_define_module_under(rb_mBootsnap, "CompileCache");
   rb_mBootsnap_CompileCache_Native = rb_define_module_under(rb_mBootsnap_CompileCache, "Native");
-  rb_eBootsnap_CompileCache_Uncompilable = rb_define_class_under(rb_mBootsnap_CompileCache, "Uncompilable", rb_eStandardError);
+  rb_cBootsnap_CompileCache_UNCOMPILABLE = rb_const_get(rb_mBootsnap_CompileCache, rb_intern("UNCOMPILABLE"));
+  rb_global_variable(&rb_cBootsnap_CompileCache_UNCOMPILABLE);
 
   current_ruby_revision = get_ruby_revision();
   current_ruby_platform = get_ruby_platform();
 
-  uncompilable = rb_intern("__bootsnap_uncompilable__");
   instrumentation_method = rb_intern("_instrument");
 
   sym_miss = ID2SYM(rb_intern("miss"));
@@ -166,6 +168,7 @@ Init_bootsnap(void)
   rb_global_variable(&sym_stale);
 
   rb_define_module_function(rb_mBootsnap, "instrumentation_enabled=", bs_instrumentation_enabled_set, 1);
+  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "readonly=", bs_readonly_set, 1);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "coverage_running?", bs_rb_coverage_running, 0);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "fetch", bs_rb_fetch, 4);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "precompile", bs_rb_precompile, 3);
@@ -182,6 +185,13 @@ bs_instrumentation_enabled_set(VALUE self, VALUE enabled)
   return enabled;
 }
 
+static VALUE
+bs_readonly_set(VALUE self, VALUE enabled)
+{
+  readonly = RTEST(enabled);
+  return enabled;
+}
+
 /*
  * Bootsnap's ruby code registers a hook that notifies us via this function
  * when compile_option changes. These changes invalidate all existing caches.
@@ -199,29 +209,6 @@ bs_compile_option_crc32_set(VALUE self, VALUE crc32_v)
   return Qnil;
 }
 
-/*
- * We use FNV1a-64 to derive cache paths. The choice is somewhat arbitrary but
- * it has several nice properties:
- *
- *   - Tiny implementation
- *   - No external dependency
- *   - Solid performance
- *   - Solid randomness
- *   - 32 bits doesn't feel collision-resistant enough; 64 is nice.
- */
-static uint64_t
-fnv1a_64_iter_cstr(uint64_t h, const char *str)
-{
-  unsigned char *s = (unsigned char *)str;
-
-  while (*s) {
-    h ^= (uint64_t)*s++;
-    h += (h << 1) + (h << 4) + (h << 5) + (h << 7) + (h << 8) + (h << 40);
-  }
-
-  return h;
-}
-
 static uint64_t
 fnv1a_64_iter(uint64_t h, const VALUE str)
 {
@@ -266,10 +253,6 @@ get_ruby_revision(void)
 /*
  * When ruby's version doesn't change, but it's recompiled on a different OS
  * (or OS version), we need to invalidate the cache.
- *
- * We actually factor in some extra information here, to be extra confident
- * that we don't try to re-use caches that will not be compatible, by factoring
- * in utsname.version.
  */
 static uint32_t
 get_ruby_platform(void)
@@ -279,22 +262,7 @@ get_ruby_platform(void)
 
   ruby_platform = rb_const_get(rb_cObject, rb_intern("RUBY_PLATFORM"));
   hash = fnv1a_64(ruby_platform);
-
-#ifdef _WIN32
-  return (uint32_t)(hash >> 32) ^ (uint32_t)GetVersion();
-#elif defined(__GLIBC__)
-  hash = fnv1a_64_iter_cstr(hash, gnu_get_libc_version());
   return (uint32_t)(hash >> 32);
-#else
-  struct utsname utsname;
-
-  /* Not worth crashing if this fails; lose extra cache invalidation potential */
-  if (uname(&utsname) >= 0) {
-    hash = fnv1a_64_iter_cstr(hash, utsname.version);
-  }
-
-  return (uint32_t)(hash >> 32);
-#endif
 }
 
 /*
@@ -426,6 +394,7 @@ open_current_file(char * path, struct bs_cache_key * key, const char ** errno_pr
 #define ERROR_WITH_ERRNO -1
 #define CACHE_MISS -2
 #define CACHE_STALE -3
+#define CACHE_UNCOMPILABLE -4
 
 /*
  * Read the cache key from the given fd, which must have position 0 (e.g.
@@ -507,14 +476,14 @@ fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE args, VALUE *
   if (data_size > 100000000000) {
     *errno_provenance = "bs_fetch:fetch_cached_data:datasize";
     errno = EINVAL; /* because wtf? */
-    ret = -1;
+    ret = ERROR_WITH_ERRNO;
     goto done;
   }
   data = ALLOC_N(char, data_size);
   nread = read(fd, data, data_size);
   if (nread < 0) {
     *errno_provenance = "bs_fetch:fetch_cached_data:read";
-    ret = -1;
+    ret = ERROR_WITH_ERRNO;
     goto done;
   }
   if (nread != data_size) {
@@ -525,6 +494,10 @@ fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE args, VALUE *
   storage_data = rb_str_new(data, data_size);
 
   *exception_tag = bs_storage_to_output(handler, args, storage_data, output_data);
+  if (*output_data == rb_cBootsnap_CompileCache_UNCOMPILABLE) {
+    ret = CACHE_UNCOMPILABLE;
+    goto done;
+  }
   ret = 0;
 done:
   if (data != NULL) xfree(data);
@@ -737,7 +710,15 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
       &output_data, &exception_tag, &errno_provenance
     );
     if (exception_tag != 0) goto raise;
-    else if (res == CACHE_MISS || res == CACHE_STALE) valid_cache = 0;
+    else if (res == CACHE_UNCOMPILABLE) {
+      /* If fetch_cached_data returned `Uncompilable` we fallback to `input_to_output`
+        This happens if we have say, an unsafe YAML cache, but try to load it in safe mode */
+      if (bs_read_contents(current_fd, current_key.size, &contents, &errno_provenance) < 0) goto fail_errno;
+      input_data = rb_str_new(contents, current_key.size);
+      bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
+      if (exception_tag != 0) goto raise;
+      goto succeed;
+    } else if (res == CACHE_MISS || res == CACHE_STALE) valid_cache = 0;
     else if (res == ERROR_WITH_ERRNO) goto fail_errno;
     else if (!NIL_P(output_data)) goto succeed; /* fast-path, goal */
   }
@@ -754,7 +735,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
   if (exception_tag != 0) goto raise;
   /* If input_to_storage raised Bootsnap::CompileCache::Uncompilable, don't try
    * to cache anything; just return input_to_output(input_data) */
-  if (storage_data == uncompilable) {
+  if (storage_data == rb_cBootsnap_CompileCache_UNCOMPILABLE) {
     bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
     if (exception_tag != 0) goto raise;
     goto succeed;
@@ -772,12 +753,20 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
   exception_tag = bs_storage_to_output(handler, args, storage_data, &output_data);
   if (exception_tag != 0) goto raise;
 
-  /* If output_data is nil, delete the cache entry and generate the output
-   * using input_to_output */
-  if (NIL_P(output_data)) {
+  if (output_data == rb_cBootsnap_CompileCache_UNCOMPILABLE) {
+    /* If storage_to_output returned `Uncompilable` we fallback to `input_to_output` */
+    bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
+    if (exception_tag != 0) goto raise;
+  } else if (NIL_P(output_data)) {
+    /* If output_data is nil, delete the cache entry and generate the output
+     * using input_to_output */
     if (unlink(cache_path) < 0) {
-      errno_provenance = "bs_fetch:unlink";
-      goto fail_errno;
+      /* If the cache was already deleted, it might be that another process did it before us.
+      * No point raising an error */
+      if (errno != ENOENT) {
+        errno_provenance = "bs_fetch:unlink";
+        goto fail_errno;
+      }
     }
     bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
     if (exception_tag != 0) goto raise;
@@ -856,7 +845,7 @@ bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler)
 
   /* If input_to_storage raised Bootsnap::CompileCache::Uncompilable, don't try
    * to cache anything; just return false */
-  if (storage_data == uncompilable) {
+  if (storage_data == rb_cBootsnap_CompileCache_UNCOMPILABLE) {
     goto fail;
   }
   /* If storage_data isn't a string, we can't cache it */
@@ -919,7 +908,7 @@ struct i2s_data {
 };
 
 static VALUE
-prot_storage_to_output(VALUE arg)
+try_storage_to_output(VALUE arg)
 {
   struct s2o_data * data = (struct s2o_data *)arg;
   return rb_funcall(data->handler, rb_intern("storage_to_output"), 2, data->storage_data, data->args);
@@ -934,7 +923,7 @@ bs_storage_to_output(VALUE handler, VALUE args, VALUE storage_data, VALUE * outp
     .args         = args,
     .storage_data = storage_data,
   };
-  *output_data = rb_protect(prot_storage_to_output, (VALUE)&s2o_data, &state);
+  *output_data = rb_protect(try_storage_to_output, (VALUE)&s2o_data, &state);
   return state;
 }
 
@@ -963,31 +952,20 @@ try_input_to_storage(VALUE arg)
   return rb_funcall(data->handler, rb_intern("input_to_storage"), 2, data->input_data, data->pathval);
 }
 
-static VALUE
-rescue_input_to_storage(VALUE arg, VALUE e)
-{
-  return uncompilable;
-}
-
-static VALUE
-prot_input_to_storage(VALUE arg)
-{
-  struct i2s_data * data = (struct i2s_data *)arg;
-  return rb_rescue2(
-      try_input_to_storage, (VALUE)data,
-      rescue_input_to_storage, Qnil,
-      rb_eBootsnap_CompileCache_Uncompilable, 0);
-}
-
 static int
 bs_input_to_storage(VALUE handler, VALUE args, VALUE input_data, VALUE pathval, VALUE * storage_data)
 {
-  int state;
-  struct i2s_data i2s_data = {
-    .handler    = handler,
-    .input_data = input_data,
-    .pathval    = pathval,
-  };
-  *storage_data = rb_protect(prot_input_to_storage, (VALUE)&i2s_data, &state);
-  return state;
+  if (readonly) {
+    *storage_data = rb_cBootsnap_CompileCache_UNCOMPILABLE;
+    return 0;
+  } else {
+    int state;
+    struct i2s_data i2s_data = {
+      .handler    = handler,
+      .input_data = input_data,
+      .pathval    = pathval,
+    };
+    *storage_data = rb_protect(try_input_to_storage, (VALUE)&i2s_data, &state);
+    return state;
+  }
 }

data/ext/bootsnap/extconf.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
+
 require("mkmf")
 
-if RUBY_ENGINE == 'ruby'
-  $CFLAGS << ' -O3 '
-  $CFLAGS << ' -std=c99'
+if RUBY_ENGINE == "ruby"
+  $CFLAGS << " -O3 "
+  $CFLAGS << " -std=c99"
 
   # ruby.h has some -Wpedantic fails in some cases
   # (e.g. https://github.com/Shopify/bootsnap/issues/15)
-  unless ['0', '', nil].include?(ENV['BOOTSNAP_PEDANTIC'])
-    $CFLAGS << ' -Wall'
-    $CFLAGS << ' -Werror'
-    $CFLAGS << ' -Wextra'
-    $CFLAGS << ' -Wpedantic'
+  unless ["0", "", nil].include?(ENV["BOOTSNAP_PEDANTIC"])
+    $CFLAGS << " -Wall"
+    $CFLAGS << " -Werror"
+    $CFLAGS << " -Wextra"
+    $CFLAGS << " -Wpedantic"
 
-    $CFLAGS << ' -Wno-unused-parameter' # VALUE self has to be there but we don't care what it is.
-    $CFLAGS << ' -Wno-keyword-macro' # hiding return
-    $CFLAGS << ' -Wno-gcc-compat' # ruby.h 2.6.0 on macos 10.14, dunno
+    $CFLAGS << " -Wno-unused-parameter" # VALUE self has to be there but we don't care what it is.
+    $CFLAGS << " -Wno-keyword-macro" # hiding return
+    $CFLAGS << " -Wno-gcc-compat" # ruby.h 2.6.0 on macos 10.14, dunno
+    $CFLAGS << " -Wno-compound-token-split-by-macro"
   end
 
   create_makefile("bootsnap/bootsnap")
 else
-  File.write("Makefile", dummy_makefile($srcdir).join(""))
+  File.write("Makefile", dummy_makefile($srcdir).join)
 end

data/lib/bootsnap/bundler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Bootsnap
   extend(self)
 

data/lib/bootsnap/cli/worker_pool.rb

@@ -63,6 +63,7 @@ module Bootsnap
           loop do
             job, *args = Marshal.load(@pipe_out)
             return if job == :exit
+
             @jobs.fetch(job).call(*args)
           end
         rescue IOError