bootsnap 1.24.3 → 1.24.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31d64e50bd32368c8dffe927b63fa6e62243b697a2606ca3e2330c4694ec816b
-  data.tar.gz: 5dfc374040409d1d20e893abc6a8c6052de02cf560c15e7678a5db2084bd722c
+  metadata.gz: 9f514d9a08cf2cbfa470c7d6745fe6388bfb4800a8cf659b9939bc57c93a67e1
+  data.tar.gz: e623cc84b0ce559e15eeb5ade64617ab6faff50a5004256ecdac5e93267ac5e0
 SHA512:
-  metadata.gz: ff9e6b5b2c47d0337fa8d46c487fd6881bc567f5ae01a17f85aa3821df9b7f8416283764f8309de6207d94eb00e6cd6ee845a1307dd601659e4d26cd6abbc7ea
-  data.tar.gz: e34adc7c5162da87d94358a99a5990d0dfbc6497fb141e7407614e181328e1091bd708fac0aa96e6bce8731283a367db6a5aa6e8a2afe3b848b2d0f6b73e3ba4
+  metadata.gz: 517950fbb71bbfc7e9ecbc0220849bc4c6fba0f410edb3d08db13d7e1e55f6602cef80c0636ed656cd76eab3c100da317a40d7cf7527dbf97bb4e2b250bc820f
+  data.tar.gz: 97fdc6fee1ac2945fba9b79ec3e6b8d65f265c5e90fc9da16ced08aff3b09f6f516bcdec46aa703452666dfbfaff3db319b912282f0bb1b5ed3d355d0a24e5a0

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Unreleased
 
+# 1.24.5
+
+* No longer load the config file by default when setup is done manually. This is so cli applications like homebrew
+  don't mistakenly load another app's boostnap config.
+
+# 1.24.4
+
+* Fix several compatibility issues with Ruby `4.0.4`, particularly the `should not compile with coverage` error. See #547.
+* Fix `Bootsnap.enable_frozen_string_literal` to work even when coverage is enabled. Unfortunately only possible on Ruby `4.0.4+`.
+  On older rubies if coverage is enabled a warning will be issued and the feature won't work.
+* Reduced cache files header size from 64 to 32 bytes, and got rid of the random padding element.
+* Avoid leaking a private method in `Object` when testing for Parse.y bugs.
+
 # 1.24.3
 
 * Fix the `1.24.2` workaround to parse Ruby files with UTF-8 even when the `LANG` environment variable

data/README.md

@@ -237,14 +237,15 @@ This may look worse at a glance, but underlies a large performance difference.
 useful. [This ruby patch](https://bugs.ruby-lang.org/issues/13378) optimizes them out when coupled
 with bootsnap.)*
 
-Bootsnap writes a cache file containing a 64 byte header followed by the cache contents. The header
+Bootsnap writes a cache file containing a 32 byte header followed by the cache contents. The header
 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.
-* `compile_option`, which changes with `RubyVM::InstructionSequence.compile_option` does;
-* `ruby_revision`, A hash of `RUBY_REVISION`, the exact version of Ruby;
+* `ruby_version_digest`, a digest of:
+  * The `RUBY_DESCRIPTION` constant e.g. `"ruby 4.0.2 (2026-03-17 revision d3da9fec82) +PRISM [arm64-darwin25]"`.
+  * Bootsnap's cache version. Hardcoded in bootsnap. Essentially a schema version;
+  * The content of `RubyVM::InstructionSequence.compile_option`.
 * `size`, the size of the source file;
+* `digest`, a fnv1a_64 hash 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.
 
@@ -349,6 +350,10 @@ Bootsnap::CompileCache::ISeq.compiler_selector = ->(path) do
 end
 ```
 
+*Important note*: This feature is only fully supported by Ruby `4.0.4` and newer.
+On older rubies the feature work except if the `Coverage` module is enabled, in which case a warning will be emitted
+and the default Ruby compiler will be used.
+
 ## Precompilation
 
 In development environments the bootsnap compilation cache is generated on the fly when source files are loaded.

data/ext/bootsnap/bootsnap.c

@@ -40,7 +40,7 @@
 #define MAX_CACHEPATH_SIZE 1000
 #define MAX_CACHEDIR_SIZE  981
 
-#define KEY_SIZE 64
+#define KEY_SIZE 32
 
 #define MAX_CREATE_TEMPFILE_ATTEMPT 3
 
@@ -49,34 +49,27 @@
 #endif
 
 /*
- * An instance of this key is written as the first 64 bytes of each cache file.
+ * An instance of this key is written as the first `KEY_SIZE` bytes of each cache file.
  * The mtime and size members track whether the file contents have changed, and
- * the version, ruby_platform, compile_option, and ruby_revision members track
- * changes to the environment that could invalidate compile results without
+ * the ruby_version_digest (bootsnap_cache_version + RUBY_DESCRIPTION) and compile_option
+ * members track changes to the environment that could invalidate compile results without
  * file contents having changed. The data_size member is not truly part of the
  * "key". Really, this could be called a "header" with the first six members
  * being an embedded "key" struct and an additional data_size member.
  *
  * The data_size indicates the remaining number of bytes in the cache file
  * after the header (the size of the cached artifact).
- *
- * After data_size, the struct is padded to 64 bytes.
  */
 struct bs_cache_key {
-  uint32_t version;
-  uint32_t ruby_platform;
-  uint32_t compile_option;
-  uint32_t ruby_revision;
-  uint64_t size;
+  uint64_t ruby_version_digest;
   uint64_t mtime;
-  uint64_t data_size; //
   uint64_t digest;
-  uint8_t digest_set;
-  uint8_t pad[15];
+  uint32_t size;
+  uint32_t data_size;
 } __attribute__((packed));
 
 /*
- * If the struct padding isn't correct to pad the key to 64 bytes, refuse to
+ * If the struct padding isn't correct to pad the key to `KEY_SIZE` bytes, refuse to
  * compile.
  */
 #define STATIC_ASSERT(X)            STATIC_ASSERT2(X,__LINE__)
@@ -86,15 +79,15 @@ 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 = 6;
-
-/* hash of e.g. "x86_64-darwin17", invalidating when ruby is recompiled on a
- * new OS ABI, etc. */
-static uint32_t current_ruby_platform;
-/* Invalidates cache when switching ruby versions */
-static uint32_t current_ruby_revision;
-/* Invalidates cache when RubyVM::InstructionSequence.compile_option changes */
-static uint32_t current_compile_option_crc32 = 0;
+static const uint32_t bootsnap_cache_version = 7;
+
+/* Invalidates cache when switching ruby version, platform or ABI */
+static uint64_t base_ruby_version_digest = 0;
+
+// `base_ruby_version_digest` combined with RubyVM::InstructionSequence.compile_option
+// Invalidates cache when RubyVM::InstructionSequence.compile_option changes
+static uint64_t current_ruby_version_digest = 0;
+
 /* Current umask */
 static mode_t current_umask;
 
@@ -136,8 +129,7 @@ static VALUE bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handle
 static VALUE bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler);
 static int open_current_file(const char * path, struct bs_cache_key * key, const char ** errno_provenance);
 static int fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE args, VALUE * output_data, int * exception_tag, const char ** errno_provenance);
-static uint32_t get_ruby_revision(void);
-static uint32_t get_ruby_platform(void);
+static uint64_t get_ruby_version_digest(void);
 
 /*
  * Helper functions to call ruby methods on handler object without crashing on
@@ -295,8 +287,7 @@ Init_bootsnap(void)
   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();
+  base_ruby_version_digest = get_ruby_version_digest();
 
   instrumentation_method = rb_intern("_instrument");
 
@@ -345,28 +336,10 @@ bs_revalidation_set(VALUE self, VALUE 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.
- *
- * Note that on 32-bit platforms, a CRC32 can't be represented in a Fixnum, but
- * can be represented by a uint.
- */
-static VALUE
-bs_compile_option_crc32_set(VALUE self, VALUE crc32_v)
-{
-  if (!RB_TYPE_P(crc32_v, T_BIGNUM) && !RB_TYPE_P(crc32_v, T_FIXNUM)) {
-    Check_Type(crc32_v, T_FIXNUM);
-  }
-  current_compile_option_crc32 = NUM2UINT(crc32_v);
-  return Qnil;
-}
-
 static uint64_t
-fnv1a_64_iter(uint64_t h, const VALUE str)
+fnv1a_64_iter(uint64_t h, const unsigned char *s, size_t len)
 {
-  unsigned char *s = (unsigned char *)RSTRING_PTR(str);
-  unsigned char *str_end = (unsigned char *)RSTRING_PTR(str) + RSTRING_LEN(str);
+  const unsigned char *str_end = s + len;
 
   while (s < str_end) {
     h ^= (uint64_t)*s++;
@@ -377,45 +350,43 @@ fnv1a_64_iter(uint64_t h, const VALUE str)
 }
 
 static uint64_t
-fnv1a_64(const VALUE str)
+fnv1a_64_iter_str(uint64_t h, const VALUE str)
+{
+  Check_Type(str, T_STRING);
+  return fnv1a_64_iter(h, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
+}
+
+static uint64_t
+fnv1a_64_str(const VALUE str)
 {
   uint64_t h = (uint64_t)0xcbf29ce484222325ULL;
-  return fnv1a_64_iter(h, str);
+  return fnv1a_64_iter_str(h, str);
 }
 
 /*
- * Ruby's revision may be Integer or String. CRuby 2.7 or later uses
- * Git commit ID as revision. It's String.
+ * Bootsnap's ruby code registers a hook that notifies us via this function
+ * when compile_option changes. These changes invalidate all existing caches.
+ *
+ * Note that on 32-bit platforms, a CRC32 can't be represented in a Fixnum, but
+ * can be represented by a uint.
  */
-static uint32_t
-get_ruby_revision(void)
+static VALUE
+bs_compile_option_crc32_set(VALUE self, VALUE crc32_v)
 {
-  VALUE ruby_revision;
-
-  ruby_revision = rb_const_get(rb_cObject, rb_intern("RUBY_REVISION"));
-  if (RB_TYPE_P(ruby_revision, RUBY_T_FIXNUM)) {
-    return FIX2INT(ruby_revision);
-  } else {
-    uint64_t hash;
-
-    hash = fnv1a_64(ruby_revision);
-    return (uint32_t)(hash >> 32);
+  if (!RB_TYPE_P(crc32_v, T_BIGNUM) && !RB_TYPE_P(crc32_v, T_FIXNUM)) {
+    Check_Type(crc32_v, T_FIXNUM);
   }
+  uint32_t crc32 = (uint32_t)NUM2UINT(crc32_v);
+  current_ruby_version_digest = fnv1a_64_iter(base_ruby_version_digest, (unsigned char *)&crc32, sizeof(crc32));
+  return Qnil;
 }
 
-/*
- * When ruby's version doesn't change, but it's recompiled on a different OS
- * (or OS version), we need to invalidate the cache.
- */
-static uint32_t
-get_ruby_platform(void)
+static uint64_t
+get_ruby_version_digest(void)
 {
-  uint64_t hash;
-  VALUE ruby_platform;
-
-  ruby_platform = rb_const_get(rb_cObject, rb_intern("RUBY_PLATFORM"));
-  hash = fnv1a_64(ruby_platform);
-  return (uint32_t)(hash >> 32);
+  uint64_t hash = fnv1a_64_str(rb_const_get(rb_cObject, rb_intern("RUBY_DESCRIPTION")));
+  hash = fnv1a_64_iter(hash, (unsigned char *)&bootsnap_cache_version, sizeof(bootsnap_cache_version));
+  return hash;
 }
 
 /*
@@ -443,7 +414,7 @@ bs_cache_path(VALUE cachedir_v, VALUE namespace_v, VALUE path_v, char (* cache_p
   const char * cachedir = RSTRING_PTR(cachedir_v);
   const char * namespace = NIL_P(namespace_v) ? "" : RSTRING_PTR(namespace_v);
 
-  uint64_t hash = fnv1a_64(path_v);
+  uint64_t hash = fnv1a_64_str(path_v);
   uint8_t first_byte = (hash >> (64 - 8));
   uint64_t remainder = hash & 0x00ffffffffffffff;
 
@@ -460,10 +431,8 @@ bs_cache_path(VALUE cachedir_v, VALUE namespace_v, VALUE path_v, char (* cache_p
  */
 static enum cache_status cache_key_equal_fast_path(struct bs_cache_key *k1,
                                      struct bs_cache_key *k2) {
-  if (k1->version == k2->version &&
-          k1->ruby_platform == k2->ruby_platform &&
-          k1->compile_option == k2->compile_option &&
-          k1->ruby_revision == k2->ruby_revision && k1->size == k2->size) {
+  if (k1->ruby_version_digest == k2->ruby_version_digest &&
+          k1->size == k2->size) {
       if (k1->mtime == k2->mtime) {
         return hit;
       }
@@ -507,10 +476,9 @@ static int update_cache_key(struct bs_cache_key *current_key, struct bs_cache_ke
  */
 static void bs_cache_key_digest(struct bs_cache_key *key,
                                 const VALUE input_data) {
-  if (key->digest_set)
+  if (key->digest)
     return;
-  key->digest = fnv1a_64(input_data);
-  key->digest_set = 1;
+  key->digest = fnv1a_64_str(input_data);
 }
 
 /*
@@ -587,13 +555,19 @@ open_current_file(const char * path, struct bs_cache_key * key, const char ** er
     return -1;
   }
 
-  key->version        = current_version;
-  key->ruby_platform  = current_ruby_platform;
-  key->compile_option = current_compile_option_crc32;
-  key->ruby_revision  = current_ruby_revision;
-  key->size           = (uint64_t)statbuf.st_size;
-  key->mtime          = (uint64_t)statbuf.st_mtime;
-  key->digest_set     = false;
+  key->ruby_version_digest = current_ruby_version_digest;
+
+  // We're limited to file of 4GiB or less. Hopefully that's enough for everyone.
+  if (statbuf.st_size > (uint32_t)-1) {
+    *errno_provenance = "bs_fetch:open_current_file:file_too_big";
+    close(fd);
+    errno = EFBIG;
+    return -1;
+  }
+
+  key->size = (uint32_t)statbuf.st_size;
+  key->mtime = (uint64_t)statbuf.st_mtime;
+  key->digest = 0;
 
   return fd;
 }
@@ -663,10 +637,10 @@ open_cache_file(const char * path, struct bs_cache_key * key, const char ** errn
 
 /*
  * The cache file is laid out like:
- *   0...64 : bs_cache_key
- *   64..-1 : cached artifact
+ *   0...`KEY_SIZE` : bs_cache_key
+ *   `KEY_SIZE`..-1 : cached artifact
  *
- * This function takes a file descriptor whose position is pre-set to 64, and
+ * This function takes a file descriptor whose position is pre-set to `KEY_SIZE`, and
  * the data_size (corresponding to the remaining number of bytes) listed in the
  * cache header.
  *
@@ -782,7 +756,12 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, cons
   setmode(fd, O_BINARY);
   #endif
 
-  key->data_size = RSTRING_LEN(data);
+  uint64_t data_size = RSTRING_LEN(data);
+  if (data_size > (uint32_t)-1) {
+    return 0; // Don't cache.
+  }
+
+  key->data_size = (uint32_t)data_size;
   nwrite = write(fd, key, KEY_SIZE);
   if (nwrite < 0) {
     *errno_provenance = "bs_fetch:atomic_write_cache_file:write";

data/lib/bootsnap/cli/worker_pool.rb

@@ -62,7 +62,7 @@ module Bootsnap
           # Ref: https://github.com/rails/bootsnap/issues/495
           # The second forked process will hang on some QEMU environments
           r, w = IO.pipe
-          pids = 2.times.map do
+          pids = Array.new(2) do
             ::Process.fork do
               exit!(true)
             end
@@ -161,7 +161,7 @@ module Bootsnap
       end
 
       def spawn
-        @workers = @size.times.map { Worker.new(@jobs) }
+        @workers = Array.new(@size) { Worker.new(@jobs) }
         @workers.each(&:spawn)
         @dispatcher_thread = Thread.new { dispatch_loop }
         @dispatcher_thread.abort_on_exception = true

data/lib/bootsnap/cli.rb

@@ -43,7 +43,7 @@ module Bootsnap
           yaml: yaml,
           revalidation: true,
         )
-        Bootsnap.load_config
+        Bootsnap.load_config(ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb")
 
         @work_pool = WorkerPool.create(size: jobs, jobs: {
           ruby: method(:precompile_ruby),

data/lib/bootsnap/compile_cache/iseq.rb

@@ -19,152 +19,207 @@ module Bootsnap
         end
       end
 
-      class Compiler
-        attr_reader :namespace, :compile_options
-
-        def initialize(namespace = nil, compile_options = nil)
-          @namespace = namespace
-          @compile_options = compile_options
-        end
+      if supported?
+        class Compiler
+          attr_reader :namespace
+
+          def initialize(namespace = nil, compile_options = nil)
+            @namespace = namespace
+            @options = compile_options.freeze
+            update_options
+          end
 
-        has_ruby_bug_18250 = begin # https://bugs.ruby-lang.org/issues/18250
-          if defined? RubyVM::InstructionSequence
-            RubyVM::InstructionSequence.compile("def foo(*); ->{ super }; end; def foo(**); ->{ super }; end").to_binary
+          def update_options
+            @compile_options = if @options.nil? || @options < RubyVM::InstructionSequence.compile_option
+              nil
+            else
+              RubyVM::InstructionSequence.compile_option.merge(@options).freeze
+            end
           end
-          false
-        rescue TypeError
-          true
-        end
 
-        has_ruby_bug_22023 = if defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:compile_file_prism)
-          begin
-            RubyVM::InstructionSequence.compile_file(File.expand_path("../ruby_bug_22023_canary.rb", __FILE__))
+          has_ruby_bug_18250 = RUBY_VERSION.start_with?("3.0.") && begin # https://bugs.ruby-lang.org/issues/18250
+            if defined? RubyVM::InstructionSequence
+              RubyVM::InstructionSequence.compile(<<~RUBY).to_binary
+                def foo(*); ->{ super }; end; def foo(**); ->{ super }; end
+              RUBY
+            end
             false
-          rescue SyntaxError
+          rescue TypeError
             true
           end
-        end
 
-        if has_ruby_bug_22023 && RUBY_DESCRIPTION.include?("+PRISM")
-          module PatchRubyBug22023
-            def compile_file(path, options = nil)
-              compile_file_prism(path, options)
+          has_ruby_bug_22023 = if defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:compile_file_prism)
+            begin
+              RubyVM::InstructionSequence.compile_file(File.expand_path("../ruby_bug_22023_canary.rb", __FILE__))
+              false
+            rescue SyntaxError
+              true
             end
+          end
+
+          if has_ruby_bug_22023 && RUBY_DESCRIPTION.include?("+PRISM")
+            module PatchRubyBug22023
+              def compile_file(path, options = nil)
+                compile_file_prism(path, options)
+              end
 
-            has_ruby_bug_22023_bis = !RubyVM::InstructionSequence.compile_file_prism(
-              File.expand_path("../ruby_bug_22023_canary.rb", __FILE__),
-              {frozen_string_literal: true},
-            ).eval.frozen?
+              has_ruby_bug_22023_bis = !RubyVM::InstructionSequence.compile_file_prism(
+                File.expand_path("../ruby_bug_22023_canary.rb", __FILE__),
+                {frozen_string_literal: true},
+              ).eval.frozen?
 
-            if has_ruby_bug_22023_bis
-              def compile_file_prism(path, options = nil)
-                compile_prism(::File.read(path, encoding: Encoding::UTF_8), path, path, nil, options)
+              if has_ruby_bug_22023_bis
+                def compile_file_prism(path, options = nil)
+                  compile_prism(::File.read(path, encoding: Encoding::UTF_8), path, path, nil, options)
+                end
               end
             end
+            RubyVM::InstructionSequence.singleton_class.prepend(PatchRubyBug22023)
           end
-          RubyVM::InstructionSequence.singleton_class.prepend(PatchRubyBug22023)
-        end
 
-        if has_ruby_bug_18250
-          def input_to_storage(_, path)
-            iseq = RubyVM::InstructionSequence.compile_file(path, @compile_options)
-            iseq.to_binary
-          rescue TypeError, SyntaxError # Ruby [Bug #18250] & [Bug #22023]
-            UNCOMPILABLE
+          if has_ruby_bug_18250
+            def input_to_storage(_, path)
+              iseq = RubyVM::InstructionSequence.compile_file(path, @compile_options)
+              iseq.to_binary
+            rescue TypeError, SyntaxError # Ruby [Bug #18250] & [Bug #22023]
+              UNCOMPILABLE
+            end
+          else
+            def input_to_storage(_, path)
+              RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
+            rescue SyntaxError # Ruby [Bug #22023]
+              UNCOMPILABLE
+            end
           end
-        else
-          def input_to_storage(_, path)
-            RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
-          rescue SyntaxError # Ruby [Bug #22023]
-            UNCOMPILABLE
+
+          def storage_to_output(binary, _args)
+            iseq = RubyVM::InstructionSequence.load_from_binary(binary)
+            binary.clear
+            iseq
+          rescue RuntimeError => error
+            if error.message == "broken binary format"
+              $stderr.puts("[Bootsnap::CompileCache] warning: rejecting broken binary")
+              nil
+            else
+              raise
+            end
           end
-        end
 
-        def storage_to_output(binary, _args)
-          iseq = RubyVM::InstructionSequence.load_from_binary(binary)
-          binary.clear
-          iseq
-        rescue RuntimeError => error
-          if error.message == "broken binary format"
-            $stderr.puts("[Bootsnap::CompileCache] warning: rejecting broken binary")
-            nil
-          else
-            raise
+          def input_to_output(source, path, _kwargs)
+            if @compile_options
+              if source
+                RubyVM::InstructionSequence.compile(
+                  source.force_encoding(Encoding.default_external),
+                  path,
+                  path,
+                  nil,
+                  @compile_options,
+                )
+              else
+                RubyVM::InstructionSequence.compile_file(path, @compile_options)
+              end
+            end
           end
         end
 
-        def input_to_output(source, path, _kwargs)
-          RubyVM::InstructionSequence.compile(
-            source.force_encoding(Encoding.default_external),
-            path,
-            path,
+        DEFAULT = Compiler.new
+        FROZEN_STRING_LITERAL = Compiler.new("-fstr", {frozen_string_literal: true}.freeze)
+        COVERAGE_SUPPORTED = RUBY_VERSION >= "4.0.4"
+
+        @default_compiler = DEFAULT
+        @coverage_support_warning_emitted = false
+
+        def self.fetch(path, cache_dir: ISeq.cache_dir)
+          compiler = compiler_selector&.call(path) || default_compiler
+
+          # Having coverage enabled prevents iseq dumping/loading.
+          if coverage_on?
+            return nil if compiler.equal?(DEFAULT)
+
+            if COVERAGE_SUPPORTED
+              return compiler.input_to_output(nil, path.to_s, nil)
+            elsif !@coverage_support_warning_emitted
+              @coverage_support_warning_emitted = true
+              warn(<<~MSG)
+                Using `Bootsnap.enable_frozen_string_literal` with code coverage enabled is only supported on Ruby 4.0.4+.
+                Files loaded while coverage is on, will have mutable string literals.
+              MSG
+            end
+
+            return nil
+          end
+
+          Bootsnap::CompileCache::Native.fetch(
+            cache_dir,
+            compiler.namespace,
+            path.to_s,
+            compiler,
             nil,
-            @compile_options,
           )
         end
-      end
 
-      DEFAULT = Compiler.new
-      FROZEN_STRING_LITERAL = Compiler.new("-fstr", {frozen_string_literal: true}.freeze)
-      MUTABLE_STRING_LITERAL = Compiler.new("-no-fstr", {frozen_string_literal: false}.freeze)
-      @default_compiler = DEFAULT
-
-      def self.fetch(path, cache_dir: ISeq.cache_dir)
-        compiler = compiler_selector&.call(path) || default_compiler
-        Bootsnap::CompileCache::Native.fetch(
-          cache_dir,
-          compiler.namespace,
-          path.to_s,
-          compiler,
-          nil,
-        )
-      end
+        def self.precompile(path)
+          compiler = compiler_selector&.call(path) || default_compiler
+          Bootsnap::CompileCache::Native.precompile(
+            cache_dir,
+            compiler.namespace,
+            path.to_s,
+            compiler,
+          )
+        end
 
-      def self.precompile(path)
-        compiler = compiler_selector&.call(path) || default_compiler
-        Bootsnap::CompileCache::Native.precompile(
-          cache_dir,
-          compiler.namespace,
-          path.to_s,
-          compiler,
-        )
-      end
+        if RUBY_VERSION < "3.1."
+          def self.coverage_on?
+            defined?(Coverage) && Coverage.running?
+          end
+        else
+          def self.coverage_on?
+            defined?(Coverage) && Coverage.state != :idle
+          end
+        end
 
-      module InstructionSequenceMixin
-        def load_iseq(path)
-          # Having coverage enabled prevents iseq dumping/loading.
-          return nil if defined?(Coverage) && Coverage.running?
+        module InstructionSequenceMixin
+          def load_iseq(path)
+            Bootsnap::CompileCache::ISeq.fetch(path.to_s)
+          rescue RuntimeError => error
+            if error.message.include?("unmatched platform")
+              puts("unmatched platform for file #{path}")
+            end
+            raise
+          end
 
-          Bootsnap::CompileCache::ISeq.fetch(path.to_s)
-        rescue RuntimeError => error
-          if error.message =~ /unmatched platform/
-            puts("unmatched platform for file #{path}")
+          def compile_option=(hash)
+            super
+            Bootsnap::CompileCache::ISeq.compile_option_updated
           end
-          raise
         end
 
-        def compile_option=(hash)
-          super
-          Bootsnap::CompileCache::ISeq.compile_option_updated
+        def self.compile_option_updated
+          option = RubyVM::InstructionSequence.compile_option
+          crc = Zlib.crc32(option.inspect)
+          Bootsnap::CompileCache::Native.compile_option_crc32 = crc
+          FROZEN_STRING_LITERAL.update_options
         end
-      end
+        compile_option_updated if supported?
 
-      def self.compile_option_updated
-        option = RubyVM::InstructionSequence.compile_option
-        crc = Zlib.crc32(option.inspect)
-        Bootsnap::CompileCache::Native.compile_option_crc32 = crc
-      end
-      compile_option_updated if supported?
+        def self.install!(cache_dir)
+          Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
 
-      def self.install!(cache_dir)
-        Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
+          return unless supported?
 
-        return unless supported?
+          Bootsnap::CompileCache::ISeq.compile_option_updated
 
-        Bootsnap::CompileCache::ISeq.compile_option_updated
+          class << RubyVM::InstructionSequence
+            prepend(InstructionSequenceMixin)
+          end
+        end
+      else
+        def self.install!(...)
+          # noop
+        end
 
-        class << RubyVM::InstructionSequence
-          prepend(InstructionSequenceMixin)
+        def self.precompile(...)
+          # noop
         end
       end
     end

data/lib/bootsnap/compile_cache/ruby_bug_22023_canary.rb

@@ -1,10 +1,7 @@
-# rubocop:disable Style/FrozenStringLiteralComment
-def foo(bars)
-  case bars
+_f = -> {
+  case foo
   in [one, "a" | "b" => two]
     puts "#{one} - #{two}"
   end
-end
-
+}
 _ = "test"
-# rubocop:enable Style/FrozenStringLiteralComment

data/lib/bootsnap/load_path_cache/store.rb

@@ -84,7 +84,7 @@ module Bootsnap
         rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
           default_data
         rescue ArgumentError => error
-          if error.message =~ /negative array size/
+          if error.message.include?("negative array size")
             default_data
           else
             raise

data/lib/bootsnap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.24.3"
+  VERSION = "1.24.5"
 end

data/lib/bootsnap.rb

@@ -43,13 +43,6 @@ module Bootsnap
       @instrumentation.call(event, path)
     end
 
-    def load_config
-      config_path = File.expand_path(ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb")
-      if File.exist?(config_path)
-        require(config_path)
-      end
-    end
-
     def setup(
       cache_dir:,
       development_mode: true,
@@ -59,7 +52,8 @@ module Bootsnap
       revalidation: false,
       compile_cache_iseq: true,
       compile_cache_yaml: true,
-      compile_cache_json: (compile_cache_json_unset = true)
+      compile_cache_json: (compile_cache_json_unset = true),
+      config_path: nil
     )
       unless compile_cache_json_unset
         warn("Bootsnap.setup `compile_cache_json` argument is deprecated and has no effect")
@@ -84,7 +78,16 @@ module Bootsnap
         revalidation: revalidation,
       )
 
-      load_config
+      load_config(config_path)
+    end
+
+    def load_config(config_path)
+      if config_path
+        config_path = File.expand_path(config_path)
+        if File.exist?(config_path)
+          require(config_path)
+        end
+      end
     end
 
     def enable_frozen_string_literal(app_only: false)
@@ -102,8 +105,8 @@ module Bootsnap
           end
         }
       else
-        Bootsnap::CompileCache::ISeq.compiler_selector = nil
-        Bootsnap::CompileCache::ISeq.default_compiler = Bootsnap::CompileCache::ISeq::FROZEN_STRING_LITERAL
+        options = RubyVM::InstructionSequence.compile_option.merge(frozen_string_literal: true)
+        RubyVM::InstructionSequence.compile_option = options
       end
     end
 
@@ -150,6 +153,7 @@ module Bootsnap
           readonly: bool_env("BOOTSNAP_READONLY"),
           revalidation: bool_env("BOOTSNAP_REVALIDATE"),
           ignore_directories: ignore_directories,
+          config_path: ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb",
         )
 
         if ENV["BOOTSNAP_LOG"]
@@ -160,7 +164,7 @@ module Bootsnap
       end
     end
 
-    if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+    if /mswin|mingw|cygwin/.match?(RbConfig::CONFIG["host_os"])
       def absolute_path?(path)
         path[1] == ":"
       end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.24.3
+  version: 1.24.5
 platform: ruby
 authors:
 - Burke Libbey
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -67,6 +68,7 @@ metadata:
   changelog_uri: https://github.com/rails/bootsnap/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/rails/bootsnap
   allowed_push_host: https://rubygems.org
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,7 +83,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []