rigortype 0.3.9 → 0.4.0

data/lib/rigor/environment.rb

@@ -16,6 +16,7 @@ require_relative "environment/lockfile_resolver"
 require_relative "environment/installed_gem_set"
 require_relative "environment/rbs_collection_discovery"
 require_relative "plugin/isolation"
+require_relative "cache/engine_source"
 require_relative "environment/rbs_coverage_report"
 require_relative "inference/synthetic_method_index"
 require_relative "inference/project_patched_methods"
@@ -273,7 +274,7 @@ module Rigor
                       bundler_lockfile: nil,
                       rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
                       synthetic_method_index: nil, project_patched_methods: nil,
-                      source_files: [])
+                      source_files: [], locked_gems: nil)
         resolved_paths = signature_paths || default_signature_paths(root)
         # O4 MVP — append per-gem `sig/` directories discovered under the target project's bundler install
         # root. Empty array when neither an explicit path nor auto-detection finds a bundle. Order: user
@@ -284,7 +285,10 @@ module Rigor
         # to the project root), use the locked gem set to filter the discovered `sig/` directories. Stale
         # gems in the bundle install tree (out-of-band installs, version drift after a `bundle update`) are
         # silently dropped so only gems the project actually declares contribute RBS.
-        locked = LockfileResolver.locked_gems(
+        #
+        # #1064 — `locked_gems:` is that same map resolved by the caller. The Ractor pool passes it because
+        # Bundler's parser cannot run in a non-main Ractor; every other caller leaves it nil and resolves here.
+        locked = locked_gems || LockfileResolver.locked_gems(
           lockfile_path: bundler_lockfile,
           project_root: root,
           auto_detect: bundler_auto_detect
@@ -358,13 +362,14 @@ module Rigor
           # the bundle walk and `rbs collection install` all stay authoritative.
           deferred_signature_paths: plugin_sig_paths
         )
-        # Issue #824 / ADR-32 WD13 — one `:info` per inline member the loader stood down against the
-        # project's own `sig/`. Recorded HERE because this is where the reporter is: the run's
-        # `source_rbs_synthesis` stream already carries WD12's "parsed but not honoured" rows, drains out of
-        # pool workers, and is regenerated (never cached) on every run, so the member-level stand-down needs
-        # no plumbing of its own. Costs nothing for a project with no inline RBS: the loader's reader
-        # short-circuits on an empty `virtual_rbs`.
-        record_inline_member_standdowns(loader, source_rbs_synthesis_reporter, root)
+        # Issues #824 / #1075 — the rows ADR-112 WD5's consistency rule reports for members the project's
+        # own `sig/` and an inline source both declare: an error per contradiction (or per refinement that
+        # exceeds its own declared type), an `:info` per inline member dropped undecided. Recorded HERE
+        # because this is where the reporter is: the run's `source_rbs_synthesis` stream already carries
+        # WD12's "parsed but not honoured" rows, drains out of pool workers, and is regenerated (never cached)
+        # on every run, so the member-level outcome needs no plumbing of its own. Costs nothing for a project
+        # with no inline RBS: the loader's reader short-circuits on an empty `virtual_rbs`.
+        record_member_consistency(loader, source_rbs_synthesis_reporter, root)
         # ADR-20 slice 2c + 2e — seed hkt_registry with the bundled builtins. The Environment's
         # `#hkt_registry` getter then LAZILY merges in the RBS env scan on first call so fast paths that
         # don't consult HKT (e.g. `rigor check --cache-stats --no-stats`) don't pay the eager env-build cost
@@ -492,7 +497,10 @@ module Rigor
       #
       # WD5 — when `cache_store` is supplied, each (file, plugin) synthesizer call is memoised through
       # `Cache::Store`. The cache key composes the file's content SHA with the plugin's `PluginEntry` (id +
-      # version + config_hash) so a config change or content change invalidates the entry automatically.
+      # version + config_hash) so a config change or content change invalidates the entry automatically, and
+      # with the engine's source identity (issue #1009): a plugin's manifest version does not move when a
+      # checkout edits its synthesizer, and a stale string here also keeps the `rbs.virtual_rbs` env key warm,
+      # so the new build's rules would read the old build's RBS.
       def collect_virtual_rbs(plugin_registry, source_files, cache_store, reporter)
         return [] if plugin_registry.nil?
 
@@ -523,6 +531,8 @@ module Rigor
         return invoke_synthesizer_safely(callable, path) unless File.file?(path)
 
         descriptor = build_synthesizer_cache_descriptor(plugin, path)
+        return invoke_synthesizer_safely(callable, path) if descriptor.nil?
+
         cache_store.fetch_or_compute(
           producer_id: SYNTHESIZER_CACHE_PRODUCER_ID,
           params: {},
@@ -565,29 +575,78 @@ module Rigor
         reporter&.record(plugin_id: plugin.manifest.id, path: path, message: message.to_s, kind: kind)
       end
 
-      # ADR-32 WD13 — turn each {Environment::RbsLoader#inline_member_standdowns} record into a WD12
-      # `:not_honoured` entry, so the run's `plugin.rbs-inline.source-rbs-annotation-not-honoured` row names
-      # BOTH sources and which one won. WD12's rule is what makes this necessary rather than optional: an
-      # annotation Rigor parses and does not honour is reported, never swallowed — and a silent per-member
-      # strip is exactly the shape that rule forbids.
+      # ADR-112 WD5 / issue #1075 — turn each reported {MemberConsistency::Record} into a row on the
+      # synthesis stream. A contradiction, or a refinement outside its own declared type, is a `:contradiction`
+      # entry ({Analysis::CheckRules::RULE_CONTRADICTING_SIGNATURE}, an error), positioned at the `.rbs`
+      # member when there is one: that file is real and its line is exact, where the inline member's position
+      # lives in the synthesized RBS buffer, a document nobody has. An undecided pair keeps ADR-32 WD12's
+      # `:not_honoured` row at the annotated `.rb` (line 1, as every entry on that stream is): the inline
+      # signature was parsed and dropped, and WD12 forbids swallowing that. The silent outcomes — equal, or
+      # merged to the more precise side — record nothing.
       #
-      # The row is positioned at the annotated `.rb` (line 1, as every entry on this stream is): the member's
-      # own position lives in the synthesized RBS buffer, which describes a document nobody has, and the
-      # ADR-54 environment cache drops positions anyway, so a line read off it would differ warm and cold.
-      def record_inline_member_standdowns(loader, reporter, root)
+      # The records are derived with a {MemberConsistency::RbsProof}, so a contradiction is proven from the
+      # RBS hierarchy of core and stdlib classes, never from the analyzer process's loaded constants.
+      def record_member_consistency(loader, reporter, root)
         return if reporter.nil?
 
-        loader.inline_member_standdowns.each do |class_name, method_name, kind, signature_path, virtual_name|
-          plugin_id, path = split_virtual_source_name(virtual_name)
-          next if path.nil?
-
-          reporter.record(
-            plugin_id: plugin_id, path: path, kind: :not_honoured,
-            message: inline_member_standdown_message(class_name, method_name, kind, signature_path, root)
-          )
+        proof = MemberConsistency::RbsProof.new(loader)
+        loader.member_consistency(proof: proof).each do |record|
+          case record.outcome
+          when :contradiction then record_member_contradiction(reporter, record, root)
+          when :refinement then record_refinement_contradiction(reporter, record, root)
+          when :undecided then record_member_undecided(reporter, record, root)
+          end
         end
       end
 
+      def record_member_contradiction(reporter, record, root)
+        plugin_id, path = split_virtual_source_name(record.virtual_name)
+        return if path.nil?
+
+        reporter.record(
+          plugin_id: plugin_id, path: path_relative_to(record.signature_path, root), line: record.signature_line,
+          kind: :contradiction,
+          message: "`#{member_label(record)}` is declared here and by an inline annotation in " \
+                   "`#{path_relative_to(path, root)}`, and the two contradict: #{record.detail}. Rigor reads " \
+                   "this `.rbs` declaration. Regenerate the signature, or fix the annotation, so that one " \
+                   "of the two refines the other."
+        )
+      end
+
+      def record_refinement_contradiction(reporter, record, root)
+        plugin_id, path = split_virtual_source_name(record.virtual_name)
+        path = record.signature_path if path.nil?
+        return if path.nil?
+
+        reporter.record(
+          plugin_id: plugin_id.to_s, path: path_relative_to(path, root), line: record.signature_line,
+          kind: :contradiction,
+          message: "`#{member_label(record)}` refines its own signature to a type outside it: " \
+                   "#{record.detail}. A `rigor:v1:` refinement may narrow the ordinary RBS contract, never " \
+                   "contradict it, so one of the two is wrong."
+        )
+      end
+
+      def record_member_undecided(reporter, record, root)
+        plugin_id, path = split_virtual_source_name(record.virtual_name)
+        return if path.nil?
+
+        reporter.record(
+          plugin_id: plugin_id, path: path, kind: :not_honoured,
+          message: "`#{member_label(record)}` is also declared in " \
+                   "`#{path_relative_to(record.signature_path, root)}`, and Rigor cannot tell which of the two " \
+                   "is the more precise (#{record.detail}), so the `.rbs` declaration binds and the inline " \
+                   "signature was dropped. Left to collide the two would fail the class's definition build, " \
+                   "and every call on it — real methods and typos alike — would read `Dynamic[top]`. Make " \
+                   "one of the two a refinement of the other, or remove one, to settle which binds."
+        )
+      end
+
+      def member_label(record)
+        separator = record.kind == :singleton ? "." : "#"
+        "#{record.class_name}#{separator}#{record.method_name}"
+      end
+
       # Splits a virtual buffer name back into the pair {.collect_virtual_rbs} composed it from
       # (`virtual:<plugin id>:<source path>`). Limited to three fields so a path carrying a colon survives.
       # Returns `[nil, nil]` for a name in any other shape — a synthesizer channel this method does not own.
@@ -598,16 +657,6 @@ module Rigor
         [plugin_id, path]
       end
 
-      def inline_member_standdown_message(class_name, method_name, kind, signature_path, root)
-        separator = kind == :singleton ? "." : "#"
-        "`#{class_name}#{separator}#{method_name}` is also declared in " \
-          "`#{path_relative_to(signature_path, root)}`, and an explicit `.rbs` declaration wins over an " \
-          "inline annotation for the same member, so the inline signature was dropped. Left to collide the " \
-          "two would fail the class's definition build, and every call on it — real methods and typos " \
-          "alike — would read `Dynamic[top]`. Remove one of the two declarations to make the inline " \
-          "annotation bind."
-      end
-
       def path_relative_to(path, root)
         prefix = "#{root}#{File::SEPARATOR}"
         path.to_s.start_with?(prefix) ? path.to_s.delete_prefix(prefix) : path.to_s
@@ -631,8 +680,13 @@ module Rigor
             comparator: :digest,
             value: synthesizer_input_digest(path)
           )],
-          plugins: [plugin.plugin_entry]
+          plugins: [plugin.plugin_entry],
+          configs: Cache::EngineSource.key_config_entries
         )
+      rescue Cache::EngineSource::Unavailable
+        # An engine that cannot be identified must not be keyed by its inputs alone (issue #1009): nil runs the
+        # synthesizer uncached rather than serving an entry another build may have written.
+        nil
       end
 
       def synthesizer_input_digest(path)
@@ -696,6 +750,17 @@ module Rigor
       end
     end
 
+    # Issue #1362 — the translated type of the RBS declaration of the global variable `name` (`$stdout: IO` answers
+    # `Nominal[IO]`), or nil when no signature declares it or the environment carries no RBS loader. With
+    # `builtin: true` it answers only for a declaration in Ruby's own core or stdlib signatures, a global the
+    # interpreter sets; a project's or a gem's declaration then answers nil.
+    def global_for_name(name, builtin: false)
+      return nil if rbs_loader.nil?
+      return nil if builtin && !rbs_loader.core_or_stdlib_global?(name)
+
+      rbs_loader.global_type(name)
+    end
+
     # Returns true when the constant name is known to either the static registry or the RBS loader. Useful
     # for callers that only need a presence check without materialising a type carrier.
     def class_known?(name)

data/lib/rigor/hashing/xxh3.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Hashing
+    # Pure-Ruby XXH3-64 (seed 0, default secret) — the content hash for the `rigor lens` anchors of
+    # ADR-113 WD6, landed ahead of `rigor lens` itself (#1083). A port of the upstream xxHash scalar
+    # path (`xxhash.h`'s `XXH3_64bits` with `XXH3_kSecret`), pinned by the upstream sanity-check
+    # vectors and cross-checked against lisplens's `xxhash-rust` output; see
+    # `spec/rigor/hashing/xxh3_spec.rb`.
+    #
+    # Pure Ruby per ADR-31: a native `xxhash` gem is a supply-chain addition to hash a few hundred
+    # bytes per call. Only the seedless/default-secret variant is implemented — the `rigor lens`
+    # anchors are the sole consumer, and they match lisplens ADR-0008's form exactly:
+    #
+    # - {.anchor_hash} is `xxh3_64 & 0xffff` printed as 4 lowercase hex digits (a per-row anchor).
+    # - {.file_hash} is the full 64-bit value printed as 16 lowercase hex digits (a file-level guard).
+    #
+    # Every arithmetic op below is modulo 2^64; `& MASK64` marks the spots where the C code wraps.
+    module XXH3
+      # Constant and helper names keep upstream's `xxhash.h` identifiers (PRIME64_1, accumulate_512,
+      # …) so the port stays diffable against the reference scalar path.
+      # rubocop:disable Naming/VariableNumber
+      MASK64 = (1 << 64) - 1
+      MASK32 = (1 << 32) - 1
+
+      PRIME32_1 = 0x9E3779B1
+      PRIME32_2 = 0x85EBCA77
+      PRIME32_3 = 0xC2B2AE3D
+      PRIME64_1 = 0x9E3779B185EBCA87
+      PRIME64_2 = 0xC2B2AE3D27D4EB4F
+      PRIME64_3 = 0x165667B19E3779F9
+      PRIME64_4 = 0x85EBCA77C2B2AE63
+      PRIME64_5 = 0x27D4EB2F165667C5
+      PRIME_MX1 = 0x165667919E3779F9
+      PRIME_MX2 = 0x9FB21C651E98DF25
+
+      STRIPE_LEN = 64
+      SECRET_CONSUME_RATE = 8
+      ACC_NB = STRIPE_LEN / 8
+      MIDSIZE_MAX = 240
+      SECRET_SIZE_MIN = 136
+      MIDSIZE_STARTOFFSET = 3
+      MIDSIZE_LASTOFFSET = 17
+      SECRET_LASTACC_START = 7
+      SECRET_MERGEACCS_START = 11
+
+      # `XXH3_kSecret` — the 192-byte default secret taken from FARSH, verbatim from `xxhash.h`
+      # (one hex pair per upstream byte literal).
+      SECRET = [
+        "b8fe6c3923a44bbe7c01812cf721ad1cded46de9839097db7240a4a4b7b3671f" \
+        "cb79e64eccc0e578825ad07dccff7221b8084674f743248ee03590e6813a264c" \
+        "3c2852bb91c300cb88d0658b1b532ea371644897a20df94e3819ef46a9deacd8" \
+        "a8fa763fe39c343ff9dcbbc7c70b4f1d8a51e04bcdb45931c89f7ec9d9787364" \
+        "eac5ac8334d3ebc3c581a0fffa1363eb170ddd51b7f0da49d316552629d4689e" \
+        "2b16be587d47a1fc8ff8b8d17ad031ce45cb3a8f95160428afd7fbcabb4b407e"
+      ].pack("H*").freeze
+
+      # XXH3_INIT_ACC
+      INIT_ACC = [PRIME32_3, PRIME64_1, PRIME64_2, PRIME64_3, PRIME64_4, PRIME32_2, PRIME64_5, PRIME32_1].freeze
+
+      private_constant :MASK64, :MASK32, :PRIME32_1, :PRIME32_2, :PRIME32_3, :PRIME64_1, :PRIME64_2, :PRIME64_3,
+                       :PRIME64_4, :PRIME64_5, :PRIME_MX1, :PRIME_MX2, :STRIPE_LEN, :SECRET_CONSUME_RATE,
+                       :ACC_NB, :MIDSIZE_MAX, :SECRET_SIZE_MIN, :MIDSIZE_STARTOFFSET, :MIDSIZE_LASTOFFSET,
+                       :SECRET_LASTACC_START, :SECRET_MERGEACCS_START, :SECRET, :INIT_ACC
+
+      class << self
+        # XXH3_64bits of `bytes`, hashed as raw bytes — the string's encoding is ignored.
+        def digest64(bytes)
+          len = bytes.bytesize
+          if len <= 16 then len_0to16(bytes, len)
+          elsif len <= 128 then len_17to128(bytes, len)
+          elsif len <= MIDSIZE_MAX then len_129to240(bytes, len)
+          else hash_long(bytes, len)
+          end
+        end
+
+        # lisplens ADR-0008's `anchor_hash`: the low 16 bits of the digest as 4 lowercase hex digits.
+        def anchor_hash(bytes)
+          format("%04x", digest64(bytes) & 0xffff)
+        end
+
+        # lisplens ADR-0008's `file_hash`: the full digest as 16 lowercase hex digits.
+        def file_hash(bytes)
+          format("%016x", digest64(bytes))
+        end
+
+        private
+
+        # --- short keys: len <= 16 ---
+
+        def len_0to16(bytes, len)
+          if len > 8 then len_9to16(bytes, len)
+          elsif len >= 4 then len_4to8(bytes, len)
+          elsif len.positive? then len_1to3(bytes, len)
+          else
+            xxh64_avalanche(u64(SECRET, 56) ^ u64(SECRET, 64))
+          end
+        end
+
+        def len_1to3(bytes, len)
+          c1 = bytes.getbyte(0)
+          c2 = bytes.getbyte(len >> 1)
+          c3 = bytes.getbyte(len - 1)
+          combined = (c1 << 16) | (c2 << 24) | c3 | (len << 8)
+          bitflip = u32(SECRET, 0) ^ u32(SECRET, 4)
+          xxh64_avalanche(combined ^ bitflip)
+        end
+
+        def len_4to8(bytes, len)
+          input1 = u32(bytes, 0)
+          input2 = u32(bytes, len - 4)
+          bitflip = u64(SECRET, 8) ^ u64(SECRET, 16)
+          keyed = (input2 + (input1 << 32)) ^ bitflip
+          rrmxmx(keyed, len)
+        end
+
+        def len_9to16(bytes, len)
+          bitflip1 = u64(SECRET, 24) ^ u64(SECRET, 32)
+          bitflip2 = u64(SECRET, 40) ^ u64(SECRET, 48)
+          input_lo = u64(bytes, 0) ^ bitflip1
+          input_hi = u64(bytes, len - 8) ^ bitflip2
+          acc = (len + swap64(input_lo) + input_hi + mul128_fold64(input_lo, input_hi)) & MASK64
+          xxh3_avalanche(acc)
+        end
+
+        # --- mid-size keys: 17 <= len <= 240 (mum-hash on 16-byte chunks) ---
+
+        def mix16b(bytes, in_off, sec_off)
+          input_lo = u64(bytes, in_off)
+          input_hi = u64(bytes, in_off + 8)
+          mul128_fold64(input_lo ^ u64(SECRET, sec_off), input_hi ^ u64(SECRET, sec_off + 8))
+        end
+
+        def len_17to128(bytes, len)
+          acc = len * PRIME64_1
+          if len > 32
+            if len > 64
+              if len > 96
+                acc += mix16b(bytes, 48, 96)
+                acc += mix16b(bytes, len - 64, 112)
+              end
+              acc += mix16b(bytes, 32, 64)
+              acc += mix16b(bytes, len - 48, 80)
+            end
+            acc += mix16b(bytes, 16, 32)
+            acc += mix16b(bytes, len - 32, 48)
+          end
+          acc += mix16b(bytes, 0, 0)
+          acc += mix16b(bytes, len - 16, 16)
+          xxh3_avalanche(acc & MASK64)
+        end
+
+        def len_129to240(bytes, len)
+          acc = len * PRIME64_1
+          nb_rounds = len / 16
+          8.times { |i| acc += mix16b(bytes, 16 * i, 16 * i) }
+          acc_end = mix16b(bytes, len - 16, SECRET_SIZE_MIN - MIDSIZE_LASTOFFSET)
+          acc = xxh3_avalanche(acc & MASK64)
+          (8...nb_rounds).each do |i|
+            acc_end += mix16b(bytes, 16 * i, (16 * (i - 8)) + MIDSIZE_STARTOFFSET)
+          end
+          xxh3_avalanche((acc + acc_end) & MASK64)
+        end
+
+        # --- long keys: len > 240 (striped accumulate + scramble, then merge) ---
+
+        def hash_long(bytes, len)
+          acc = INIT_ACC.dup
+          secret_size = SECRET.bytesize
+          nb_stripes_per_block = (secret_size - STRIPE_LEN) / SECRET_CONSUME_RATE
+          block_len = STRIPE_LEN * nb_stripes_per_block
+          nb_blocks = (len - 1) / block_len
+
+          nb_blocks.times do |n|
+            accumulate_stripes(acc, bytes, n * block_len, nb_stripes_per_block)
+            scramble(acc, secret_size - STRIPE_LEN)
+          end
+
+          last_off = nb_blocks * block_len
+          accumulate_stripes(acc, bytes, last_off, (len - 1 - last_off) / STRIPE_LEN)
+          accumulate_512(acc, bytes, len - STRIPE_LEN, secret_size - STRIPE_LEN - SECRET_LASTACC_START)
+
+          merge_accs(acc, len * PRIME64_1)
+        end
+
+        def accumulate_stripes(acc, bytes, base_off, nb_stripes)
+          nb_stripes.times do |s|
+            accumulate_512(acc, bytes, base_off + (s * STRIPE_LEN), s * SECRET_CONSUME_RATE)
+          end
+        end
+
+        # XXH3_accumulate_512_scalar: each 64-byte stripe folds into the 8-lane accumulator — the
+        # data value is added to the swapped adjacent lane, and the secret-keyed value contributes a
+        # 32x32->64 product to its own lane.
+        def accumulate_512(acc, bytes, in_off, sec_off)
+          ACC_NB.times do |i|
+            data_val = u64(bytes, in_off + (8 * i))
+            data_key = data_val ^ u64(SECRET, sec_off + (8 * i))
+            acc[i ^ 1] = (acc[i ^ 1] + data_val) & MASK64
+            acc[i] = (acc[i] + ((data_key & MASK32) * (data_key >> 32))) & MASK64
+          end
+        end
+
+        # XXH3_scrambleAcc_scalar
+        def scramble(acc, sec_off)
+          ACC_NB.times do |i|
+            acc[i] = ((acc[i] ^ (acc[i] >> 47) ^ u64(SECRET, sec_off + (8 * i))) * PRIME32_1) & MASK64
+          end
+        end
+
+        # XXH3_mergeAccs over the default secret, at SECRET_MERGEACCS_START.
+        def merge_accs(acc, start)
+          result = start
+          4.times do |i|
+            result += mul128_fold64(acc[2 * i] ^ u64(SECRET, SECRET_MERGEACCS_START + (16 * i)),
+                                    acc[(2 * i) + 1] ^ u64(SECRET, SECRET_MERGEACCS_START + (16 * i) + 8))
+          end
+          xxh3_avalanche(result & MASK64)
+        end
+
+        # --- primitives ---
+
+        def u32(bytes, off) = bytes.unpack1("L<", offset: off)
+
+        def u64(bytes, off) = bytes.unpack1("Q<", offset: off)
+
+        def swap64(value) = [value].pack("Q>").unpack1("Q<")
+
+        def rotl64(value, shift) = ((value << shift) | (value >> (64 - shift))) & MASK64
+
+        def mul128_fold64(lhs, rhs)
+          product = lhs * rhs
+          (product & MASK64) ^ (product >> 64)
+        end
+
+        # XXH3_avalanche — the fast finalizer used when the input is already partially mixed.
+        def xxh3_avalanche(hash)
+          hash = (hash ^ (hash >> 37)) & MASK64
+          hash = (hash * PRIME_MX1) & MASK64
+          hash ^ (hash >> 32)
+        end
+
+        # XXH64_avalanche — the stronger finalizer for the shortest keys.
+        def xxh64_avalanche(hash)
+          hash ^= hash >> 33
+          hash = (hash * PRIME64_2) & MASK64
+          hash ^= hash >> 29
+          hash = (hash * PRIME64_3) & MASK64
+          hash ^ (hash >> 32)
+        end
+
+        # XXH3_rrmxmx — the len 4-8 finalizer (Pelle Evensen's mix).
+        def rrmxmx(hash, len)
+          hash = (hash ^ rotl64(hash, 49) ^ rotl64(hash, 24)) & MASK64
+          hash = (hash * PRIME_MX2) & MASK64
+          hash ^= (hash >> 35) + len
+          hash = (hash * PRIME_MX2) & MASK64
+          hash ^ (hash >> 28)
+        end
+      end
+      # rubocop:enable Naming/VariableNumber
+    end
+  end
+end