tapioca 0.19.1 → 0.20.0

data/lib/tapioca/rbi_ext/model.rb

@@ -76,11 +76,10 @@ module RBI
       if !block || !parameters.empty? || return_type
         # If there is no block, and the params and return type have not been supplied, then
         # we create a single signature with the given parameters and return type
-        params = parameters.map { |param| RBI::SigParam.new(param.param.name.to_s, param.type) }
         return_type ||= "T.untyped"
         type_params = Tapioca::RBIHelper.extract_type_parameters(parameters.map(&:type).append(return_type))
 
-        sig = RBI::Sig.new(params: params, return_type: return_type, type_params: type_params)
+        sig = RBI::Sig.new(params: parameters.map(&:to_sig_param), return_type: return_type, type_params: type_params)
         sigs << sig
       end
 
@@ -117,5 +116,20 @@ module RBI
   class TypedParam < T::Struct
     const :param, RBI::Param
     const :type, String
+
+    #: -> RBI::SigParam
+    def to_sig_param
+      name = case param
+      when RestParam
+        param.anonymous? ? "*".inspect : param.name.to_s
+      when KwRestParam
+        param.anonymous? ? "**".inspect : param.name.to_s
+      when BlockParam
+        param.anonymous? ? "&".inspect : param.name.to_s
+      else
+        param.name.to_s
+      end
+      RBI::SigParam.new(name, type)
+    end
   end
 end

data/lib/tapioca/rbs/bootsnap_cache.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "bundler"
+require "digest"
+require "fileutils"
+
+module Tapioca
+  module RBS
+    # Prepares the Bootsnap iseq cache used for RBS rewrite output.
+    #
+    # RBS rewrite output can change when the lockfile changes, even if the
+    # source files are unchanged.
+    # To account for this, we store the current Gemfile.lock SHA256 in a
+    # `.gemfile-lock-digest` file.
+    # A digest mismatch deletes Bootsnap's cache payload and records the new
+    # digest, so this run rebuilds the cache from scratch.
+    module BootsnapCache
+      DIGEST_FILE = ".gemfile-lock-digest" #: String
+
+      class << self
+        #: (String) -> void
+        def prepare_for_setup(cache_dir)
+          digest = gemfile_lock_digest
+          return if digest_matches?(cache_dir, digest)
+
+          FileUtils.rm_rf(File.join(cache_dir, "bootsnap"))
+          FileUtils.mkdir_p(cache_dir)
+          File.write(digest_path(cache_dir), digest)
+        end
+
+        private
+
+        #: -> String
+        def gemfile_lock_digest
+          Digest::SHA256.file(Bundler.default_lockfile).hexdigest
+        end
+
+        #: (String, String) -> bool
+        def digest_matches?(cache_dir, digest)
+          path = digest_path(cache_dir)
+          File.file?(path) && File.read(path).chomp == digest
+        end
+
+        #: (String) -> String
+        def digest_path(cache_dir)
+          File.join(cache_dir, DIGEST_FILE)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/rbs/rewriter.rb

@@ -1,39 +1,104 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "require-hooks/setup"
-
 # This code rewrites RBS comments back into Sorbet's signatures as the files are being loaded.
 # This will allow `sorbet-runtime` to wrap the methods as if they were originally written with the `sig{}` blocks.
 # This will in turn allow Tapioca to use this signatures to generate typed RBI files.
 
-begin
-  # When in a `bootsnap` environment, files are loaded from the cache and won't trigger the `source_transform` method.
-  # The `require-hooks` gem comes with a `bootsnap` mode that will disable the `bootsnap/compile_cache/iseq` caching.
-  # Sadly, we're way to early in the boot process to use it as bootsnap won't be loaded yet and the `require-hooks`
-  # setup won't pick it up.
-  #
-  # As a workaround, if we can preemptively require `bootsnap` and `bootsnap/compile_cache/iseq` we manually override
-  # the `load_iseq` method to disable the caching mechanism.
-  #
-  # This will make the Rails app load slower but allows us to trigger the RBS -> RBI source transform.
-  require "bootsnap"
-  require "bootsnap/compile_cache/iseq"
-
-  module Bootsnap
-    module CompileCache
-      module ISeq
-        module InstructionSequenceMixin
-          #: (String) -> RubyVM::InstructionSequence
-          def load_iseq(path)
-            super if defined?(super)
+module Tapioca
+  module RBS
+    class HostBootsnapSetupError < StandardError; end
+
+    # Raises when the host calls `Bootsnap.setup` after tapioca's setup. Host's call
+    # would overwrite tapioca's cache directory, so rewritten iseqs would end up in
+    # the host's regular cache.
+    module BootsnapGuard
+      extend T::Sig
+
+      sig { params(_kwargs: T.untyped).void }
+      def setup(**_kwargs)
+        Kernel.raise HostBootsnapSetupError, <<~MSG
+          Bootsnap.setup was called while TAPIOCA_RBS_CACHE=1 is set. Tapioca already
+          configured bootsnap with a dedicated cache directory; re-running setup
+          would overwrite that config and start writing rewritten iseqs into your
+          host's cache.
+
+          Gate your host's Bootsnap.setup on the env var, e.g. in config/boot.rb:
+
+            require "bootsnap/setup" unless ENV["TAPIOCA_RBS_CACHE"] == "1"
+        MSG
+      end
+    end
+
+    module BootsnapIntegration
+      class << self
+        extend T::Sig
+
+        sig { void }
+        def setup
+          require "bootsnap"
+          require "tapioca/rbs/bootsnap_cache"
+
+          cache_dir = ENV.fetch("TAPIOCA_BOOTSNAP_CACHE_DIR", File.join(Dir.pwd, "tmp/cache/bootsnap-tapioca-rbs"))
+          Tapioca::RBS::BootsnapCache.prepare_for_setup(cache_dir)
+
+          Bootsnap.setup(
+            cache_dir: cache_dir,
+            development_mode: true,
+            load_path_cache: true,
+            compile_cache_iseq: true,
+            compile_cache_yaml: true,
+            readonly: false,
+            revalidation: true,
+          )
+          Bootsnap.log_stats!
+
+          Bootsnap.singleton_class.prepend(Tapioca::RBS::BootsnapGuard)
+        end
+      end
+    end
+  end
+end
+
+# When TAPIOCA_RBS_CACHE=1, use a dedicated Bootsnap cache directory for
+# RBS-rewritten iseqs. After setup, BootsnapGuard is prepended so the host
+# application cannot replace Tapioca's cache directory.
+if ENV["TAPIOCA_RBS_CACHE"] == "1"
+  begin
+    Tapioca::RBS::BootsnapIntegration.setup
+  rescue LoadError
+    # Bootsnap is not in the bundle, skip iseq caching.
+  end
+
+  require "require-hooks/setup"
+else
+  require "require-hooks/setup"
+
+  begin
+    # Disable Bootsnap's iseq cache unless TAPIOCA_RBS_CACHE=1 enabled the separate cache above.
+    #
+    # This is necessary because host apps can call Bootsnap.setup after tapioca loads this file. When that happens,
+    # Bootsnap installs `load_iseq` and serves files from its cache, which bypasses RequireHooks.source_transform.
+    # Preloading bootsnap's iseq support lets us override `load_iseq` before setup installs it, preserving the default
+    # RBS rewrite behavior at the cost of slower app boot.
+    require "bootsnap"
+    require "bootsnap/compile_cache/iseq"
+
+    module Bootsnap
+      module CompileCache
+        module ISeq
+          module InstructionSequenceMixin
+            #: (String) -> RubyVM::InstructionSequence
+            def load_iseq(path)
+              super if defined?(super) # Disable Bootsnap's hook, but trigger any others.
+            end
           end
         end
       end
     end
+  rescue LoadError
+    # Bootsnap is not in the bundle, we don't need to do anything.
   end
-rescue LoadError
-  # Bootsnap is not in the bundle, we don't need to do anything.
 end
 
 # We need to include `T::Sig` very early to make sure that the `sig` method is available since gems using RBS comments
@@ -47,7 +112,8 @@ RequireHooks.source_transform(patterns: ["**/*.rb"]) do |path, source|
 
   # For performance reasons, we only rewrite files that use Sorbet.
   if source =~ /^\s*#\s*typed: (ignore|false|true|strict|strong|__STDLIB_INTERNAL)/
-    Spoom::Sorbet::Translate.rbs_comments_to_sorbet_sigs(source, file: path)
+    # Sorbet runtime only supports one signature per method, so keep the last overload.
+    Spoom::Sorbet::Translate.rbs_comments_to_sorbet_sigs(source, file: path, overloads_strategy: :translate_last)
   end
 rescue Spoom::Sorbet::Translate::Error
   # If we can't translate the RBS comments back into Sorbet's signatures, we just skip the file.

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -53,7 +53,7 @@ module Tapioca
                 mixins_from_modules[mod] = (after - before).reverse!
               end
             end
-          rescue Exception # rubocop:disable Lint/RescueException
+          rescue Exception
             # this is a best effort, bail if we can't perform this
           end
 
@@ -85,7 +85,6 @@ module Tapioca
             super(*attrs, **kwargs) if defined?(super)
           end
 
-          # rubocop:disable Style/MissingRespondToMissing
           T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
           def method_missing(symbol, *args)
             # We need this here so that we can handle any random instance

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -6,7 +6,7 @@ module Tapioca
     # This class is responsible for storing and looking up information related to generic types.
     #
     # The class stores 2 different kinds of data, in two separate lookup tables:
-    #   1. a lookup of generic type instances by name: `@generic_instances`
+    #   1. a lookup of generic type instances by constant and name: `@generic_instances`
     #   2. a lookup of type variable serializer by constant and type variable
     #      instance: `@type_variables`
     #
@@ -21,15 +21,22 @@ module Tapioca
     # variable to type variable serializers. This allows us to associate type variables
     # to the constant names that represent them, easily.
     module GenericTypeRegistry
-      @generic_instances = {} #: Hash[String, Module[top]]
+      @generic_instances = {}.compare_by_identity #: Hash[Module[top], Hash[String, Module[top]]]
 
       @type_variables = {}.compare_by_identity #: Hash[Module[top], Array[TypeVariableModule]]
 
-      class GenericType < T::Types::Simple
+      # Subclasses `T::Types::Base` rather than `T::Types::Simple` so that all
+      # validation goes through the `valid?` override below. `Simple` fast paths
+      # check `raw_type` directly, which for us is the clone, not the underlying type.
+      class GenericType < T::Types::Base
+        #: Module[top]
+        attr_reader :raw_type
+
         #: (Module[top] raw_type, Module[top] underlying_type) -> void
         def initialize(raw_type, underlying_type)
-          super(raw_type)
+          super()
 
+          @raw_type = raw_type
           @underlying_type = underlying_type #: Module[top]
         end
 
@@ -38,6 +45,24 @@ module Tapioca
         def valid?(obj)
           obj.is_a?(@underlying_type)
         end
+
+        # @override
+        #: -> String
+        def name
+          T.must(@raw_type.name)
+        end
+
+        # @override
+        #: -> nil
+        def build_type
+          nil
+        end
+
+        # Matches the always-true `<=` we define on the clone in `create_generic_type`.
+        #: (T::Types::Base type) -> bool
+        private def subtype_of_single?(type)
+          true
+        end
       end
 
       class << self
@@ -45,8 +70,9 @@ module Tapioca
         # and cloning the given constant so that we can return a type that is the same
         # as the current type but is a different instance and has a different name method.
         #
-        # We cache those cloned instances by their name in `@generic_instances`, so that
-        # we don't keep instantiating a new type every single time it is referenced.
+        # We cache those cloned instances by their original constant and their name in
+        # `@generic_instances`, so that we don't keep instantiating a new type every single
+        # time it is referenced.
         # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
         # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
         # 2 hash lookups (for the other two `Foo[Integer]`s).
@@ -64,12 +90,15 @@ module Tapioca
           #
           # Also, we try to memoize the generic type based on the name, so that
           # we don't have to keep recreating them all the time.
-          @generic_instances[name] ||= create_generic_type(constant, name)
+          generic_instances = @generic_instances[constant] ||= {}
+          generic_instances[name] ||= create_generic_type(constant, name)
         end
 
         #: (Object instance) -> bool
         def generic_type_instance?(instance)
-          @generic_instances.values.any? { |generic_type| generic_type === instance }
+          @generic_instances.values.any? do |generic_instances|
+            generic_instances.values.any? { |generic_type| generic_type === instance }
+          end
         end
 
         #: (Module[top] constant) -> Array[TypeVariableModule]?
@@ -88,7 +117,7 @@ module Tapioca
         # can return it from the original methods as well.
         #: (untyped constant, TypeVariableModule type_variable) -> void
         def register_type_variable(constant, type_variable)
-          type_variables = lookup_or_initialize_type_variables(constant)
+          type_variables = @type_variables[constant] ||= []
 
           type_variables << type_variable
         end
@@ -163,11 +192,6 @@ module Tapioca
             owner.send(:define_method, :inherited, inherited_method)
           end
         end
-
-        #: (Module[top] constant) -> Array[TypeVariableModule]
-        def lookup_or_initialize_type_variables(constant)
-          @type_variables[constant] ||= []
-        end
       end
     end
   end

data/lib/tapioca/runtime/reflection.rb

@@ -125,7 +125,24 @@ module Tapioca
 
       #: ((UnboundMethod | Method) method) -> untyped
       def signature_of!(method)
-        T::Utils.signature_for_method(method)
+        signature = T::Utils.signature_for_method(method)
+        return signature if signature
+
+        # Walk the super method chain to evaluate pending signatures that may have been hidden by `prepend`.
+        # During that walk, Sorbet may register a signature on the requested wrapper, so check it again.
+        # See https://github.com/Shopify/tapioca/issues/2710 for details.
+        current_method = method.super_method #: (UnboundMethod | Method)?
+        while current_method
+          # force evaluation of the signature
+          _ = T::Utils.signature_for_method(current_method)
+
+          evaluated_signature = T::Utils.signature_for_method(method)
+          return evaluated_signature if evaluated_signature
+
+          current_method = current_method.super_method
+        end
+
+        nil
       rescue LoadError, StandardError
         Kernel.raise SignatureBlockError
       end

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -82,26 +82,6 @@ module T
       prepend GenericPatch
     end
   end
-
-  module Utils
-    module Private
-      module PrivateCoercePatch
-        def coerce_and_check_module_types(val, check_val, check_module_type)
-          if val.is_a?(Tapioca::TypeVariableModule)
-            val.coerce_to_type_variable
-          elsif val.respond_to?(:__tapioca_override_type)
-            val.__tapioca_override_type
-          else
-            super
-          end
-        end
-      end
-
-      class << self
-        prepend(PrivateCoercePatch)
-      end
-    end
-  end
 end
 
 module Tapioca

data/lib/tapioca/sorbet_ext/generic_type_patch.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module T
+  module Utils
+    module Private
+      # Preserve Tapioca's generic type variables and instantiated generic
+      # names when Sorbet coerces them into runtime types.
+      module TapiocaGenericTypeCoercePatch
+        def coerce_and_check_module_types(val, check_val, check_module_type)
+          if val.is_a?(Tapioca::TypeVariableModule)
+            val.coerce_to_type_variable
+          elsif val.respond_to?(:__tapioca_override_type)
+            val.__tapioca_override_type
+          else
+            super
+          end
+        end
+      end
+
+      class << self
+        prepend(TapiocaGenericTypeCoercePatch)
+      end
+    end
+  end
+
+  module Private
+    module Casts
+      module TapiocaGenericTypeCastPatch
+        # https://github.com/sorbet/sorbet/commit/b8d64c7fd9a08e2b9159b5d592bc2de6d586b44a
+        # inlines the Module fast path in `T.let`, `T.cast`, `T.bind`, and
+        # `T.assert_type!`, so generic module clones can reach this cast path
+        # without going through `T::Utils::Private::TapiocaGenericTypeCoercePatch`.
+        def cast(value, type, cast_method)
+          if type.respond_to?(:__tapioca_override_type)
+            type = type.__tapioca_override_type
+          end
+
+          super(value, type, cast_method)
+        end
+      end
+
+      class << self
+        prepend(TapiocaGenericTypeCastPatch)
+      end
+    end
+  end
+end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.19.1"
+  VERSION = "0.20.0"
 end

data/lib/tapioca.rb

@@ -11,18 +11,18 @@ module Tapioca
 
   LIB_ROOT_DIR = T.must(__dir__) #: String
   SORBET_DIR = "sorbet" #: String
-  SORBET_CONFIG_FILE = "#{SORBET_DIR}/config" #: String
-  TAPIOCA_DIR = "#{SORBET_DIR}/tapioca" #: String
-  TAPIOCA_CONFIG_FILE = "#{TAPIOCA_DIR}/config.yml" #: String
+  SORBET_CONFIG_FILE = "#{SORBET_DIR}/config".freeze #: String
+  TAPIOCA_DIR = "#{SORBET_DIR}/tapioca".freeze #: String
+  TAPIOCA_CONFIG_FILE = "#{TAPIOCA_DIR}/config.yml".freeze #: String
 
   BINARY_FILE = "bin/tapioca" #: String
-  DEFAULT_POSTREQUIRE_FILE = "#{TAPIOCA_DIR}/require.rb" #: String
-  DEFAULT_RBI_DIR = "#{SORBET_DIR}/rbi" #: String
-  DEFAULT_DSL_DIR = "#{DEFAULT_RBI_DIR}/dsl" #: String
-  DEFAULT_GEM_DIR = "#{DEFAULT_RBI_DIR}/gems" #: String
-  DEFAULT_SHIM_DIR = "#{DEFAULT_RBI_DIR}/shims" #: String
-  DEFAULT_TODO_FILE = "#{DEFAULT_RBI_DIR}/todo.rbi" #: String
-  DEFAULT_ANNOTATIONS_DIR = "#{DEFAULT_RBI_DIR}/annotations" #: String
+  DEFAULT_POSTREQUIRE_FILE = "#{TAPIOCA_DIR}/require.rb".freeze #: String
+  DEFAULT_RBI_DIR = "#{SORBET_DIR}/rbi".freeze #: String
+  DEFAULT_DSL_DIR = "#{DEFAULT_RBI_DIR}/dsl".freeze #: String
+  DEFAULT_GEM_DIR = "#{DEFAULT_RBI_DIR}/gems".freeze #: String
+  DEFAULT_SHIM_DIR = "#{DEFAULT_RBI_DIR}/shims".freeze #: String
+  DEFAULT_TODO_FILE = "#{DEFAULT_RBI_DIR}/todo.rbi".freeze #: String
+  DEFAULT_ANNOTATIONS_DIR = "#{DEFAULT_RBI_DIR}/annotations".freeze #: String
 
   DEFAULT_OVERRIDES = {
     # ActiveSupport overrides some core methods with different signatures
@@ -32,6 +32,7 @@ module Tapioca
 
   DEFAULT_RBI_MAX_LINE_LENGTH = 120
   DEFAULT_ENVIRONMENT = "development"
+  DEFAULT_MAX_DIFF_LINES = 250
 
   CENTRAL_REPO_ROOT_URI = "https://raw.githubusercontent.com/Shopify/rbi-central/main"
   CENTRAL_REPO_INDEX_PATH = "index.json"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -130,28 +130,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.7
+        version: 0.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.7
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.9
+        version: 1.7.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.9
+        version: 1.7.16
 - !ruby/object:Gem::Dependency
   name: tsort
   requirement: !ruby/object:Gem::Requirement
@@ -273,6 +273,7 @@ files:
 - lib/tapioca/helpers/cli_helper.rb
 - lib/tapioca/helpers/config_helper.rb
 - lib/tapioca/helpers/env_helper.rb
+- lib/tapioca/helpers/file_helper.rb
 - lib/tapioca/helpers/gem_helper.rb
 - lib/tapioca/helpers/git_attributes.rb
 - lib/tapioca/helpers/package_url.rb
@@ -289,6 +290,7 @@ files:
 - lib/tapioca/loaders/loader.rb
 - lib/tapioca/rbi_ext/model.rb
 - lib/tapioca/rbi_formatter.rb
+- lib/tapioca/rbs/bootsnap_cache.rb
 - lib/tapioca/rbs/rewriter.rb
 - lib/tapioca/repo_index.rb
 - lib/tapioca/runtime/dynamic_mixin_compiler.rb
@@ -305,6 +307,7 @@ files:
 - lib/tapioca/runtime/trackers/tracker.rb
 - lib/tapioca/sorbet_ext/backcompat_patches.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
+- lib/tapioca/sorbet_ext/generic_type_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
 - lib/tapioca/sorbet_ext/proc_bind_patch.rb
 - lib/tapioca/sorbet_ext/void_patch.rb
@@ -324,7 +327,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="