bootsnap 1.24.3 → 1.24.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31d64e50bd32368c8dffe927b63fa6e62243b697a2606ca3e2330c4694ec816b
-  data.tar.gz: 5dfc374040409d1d20e893abc6a8c6052de02cf560c15e7678a5db2084bd722c
+  metadata.gz: 64eaf08501294e6e0fd98b67a54eadfff566f5480a0722e2fb852611a28bd1f8
+  data.tar.gz: 8e28bc6d5714952cf5abd837453be6774309dd4b45559c3cd31684ef6658490f
 SHA512:
-  metadata.gz: ff9e6b5b2c47d0337fa8d46c487fd6881bc567f5ae01a17f85aa3821df9b7f8416283764f8309de6207d94eb00e6cd6ee845a1307dd601659e4d26cd6abbc7ea
-  data.tar.gz: e34adc7c5162da87d94358a99a5990d0dfbc6497fb141e7407614e181328e1091bd708fac0aa96e6bce8731283a367db6a5aa6e8a2afe3b848b2d0f6b73e3ba4
+  metadata.gz: c92cf4fc73d5241a876647a67e9ff70ee63b2816a6f048f3b9f408de8c460e1f97f00162c883bbcc62b01a90d4f753126e3c3be885aee41d042fa166aad812af
+  data.tar.gz: 3db013dee453d69e531d4c6cc1a0e763aeadce36a3d5254febb449957447bf801c06e06544a4f571b5a103e75d397b60d51d364eede8de5bfce63abd79dc0ddf

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Unreleased
 
+# 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/compile_cache/iseq.rb

@@ -27,7 +27,7 @@ module Bootsnap
           @compile_options = compile_options
         end
 
-        has_ruby_bug_18250 = begin # https://bugs.ruby-lang.org/issues/18250
+        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("def foo(*); ->{ super }; end; def foo(**); ->{ super }; end").to_binary
           end
@@ -94,23 +94,44 @@ module Bootsnap
         end
 
         def input_to_output(source, path, _kwargs)
-          RubyVM::InstructionSequence.compile(
-            source.force_encoding(Encoding.default_external),
-            path,
-            path,
-            nil,
-            @compile_options,
-          )
+          if @compile_options
+            RubyVM::InstructionSequence.compile(
+              source.force_encoding(Encoding.default_external),
+              path,
+              path,
+              nil,
+              @compile_options,
+            )
+          end
         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)
+      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(File.read(path.to_s), 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,
@@ -130,14 +151,21 @@ module Bootsnap
         )
       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?
-
           Bootsnap::CompileCache::ISeq.fetch(path.to_s)
         rescue RuntimeError => error
-          if error.message =~ /unmatched platform/
+          if error.message.include?("unmatched platform")
             puts("unmatched platform for file #{path}")
           end
           raise

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.4"
 end

data/lib/bootsnap.rb

@@ -160,7 +160,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.24.3
+  version: 1.24.4
 platform: ruby
 authors:
 - Burke Libbey
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []