tapioca 0.19.0 → 0.19.2

data/lib/tapioca/gem/listeners/sorbet_signatures.rb

@@ -23,8 +23,10 @@ module Tapioca
         def compile_signature(signature, parameters)
           parameter_types = signature.arg_types.to_h #: Hash[Symbol, T::Types::Base]
           parameter_types.merge!(signature.kwarg_types)
-          parameter_types[signature.rest_name] = signature.rest_type if signature.has_rest
-          parameter_types[signature.keyrest_name] = signature.keyrest_type if signature.has_keyrest
+          rest_type = signature.rest_type
+          parameter_types[signature.rest_name] = rest_type if rest_type
+          keyrest_type = signature.keyrest_type
+          parameter_types[signature.keyrest_name] = keyrest_type if keyrest_type
           parameter_types[signature.block_name] = signature.block_type if signature.block_name
 
           sig = RBI::Sig.new
@@ -40,7 +42,7 @@ module Tapioca
           sig.return_type = return_type
           @pipeline.push_symbol(return_type)
 
-          sig.type_params.concat(extract_type_parameters(parameter_types.values.map(&:to_s).push(return_type)))
+          sig.type_params.concat(extract_type_parameters(parameter_types.values.map(&:to_s).append(return_type)))
 
           case signature.mode
           when "abstract"

data/lib/tapioca/gem/listeners/sorbet_type_variables.rb

@@ -22,7 +22,7 @@ module Tapioca
           node << sclass if sclass.nodes.length > 1
         end
 
-        #: (RBI::Tree tree, T::Module[top] constant) -> void
+        #: (RBI::Tree tree, Module[top] constant) -> void
         def compile_type_variable_declarations(tree, constant)
           # Try to find the type variables defined on this constant, bail if we can't
           type_variables = Runtime::GenericTypeRegistry.lookup_type_variables(constant)

data/lib/tapioca/gem/pipeline.rb

@@ -72,29 +72,29 @@ module Tapioca
         @events << Gem::ConstantFound.new(symbol, constant)
       end
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def push_foreign_constant(symbol, constant)
         @events << Gem::ForeignConstantFound.new(symbol, constant)
       end
 
-      #: (String symbol, T::Module[top] constant, RBI::Const node) -> void
+      #: (String symbol, Module[top] constant, RBI::Const node) -> void
       def push_const(symbol, constant, node)
         @events << Gem::ConstNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
+      #: (String symbol, Module[top] constant, RBI::Scope node) -> void
       def push_scope(symbol, constant, node)
         @events << Gem::ScopeNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
+      #: (String symbol, Module[top] constant, RBI::Scope node) -> void
       def push_foreign_scope(symbol, constant, node)
         @events << Gem::ForeignScopeNodeAdded.new(symbol, constant, node)
       end
 
       #: (
       #|   String symbol,
-      #|   T::Module[top] constant,
+      #|   Module[top] constant,
       #|   UnboundMethod method,
       #|   RBI::Method node,
       #|   untyped signature,
@@ -150,7 +150,7 @@ module Tapioca
         end
       end
 
-      #: (Symbol method_name, T::Module[top] owner) -> MethodDefinitionLookupResult
+      #: (Symbol method_name, Module[top] owner) -> MethodDefinitionLookupResult
       def method_definition_in_gem(method_name, owner)
         definitions = Tapioca::Runtime::Trackers::MethodDefinition.method_definitions_for(method_name, owner)
 
@@ -176,7 +176,7 @@ module Tapioca
 
       # Helpers
 
-      #: (T::Module[top] constant) -> String?
+      #: (Module[top] constant) -> String?
       def name_of(constant)
         name = name_of_proxy_target(constant, super(class_of(constant)))
         return name if name
@@ -248,7 +248,7 @@ module Tapioca
 
       # Compiling
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def compile_foreign_constant(symbol, constant)
         return if skip_foreign_constant?(symbol, constant)
         return if seen?(symbol)
@@ -274,7 +274,7 @@ module Tapioca
         end
       end
 
-      #: (String name, T::Module[top] constant) -> void
+      #: (String name, Module[top] constant) -> void
       def compile_alias(name, constant)
         return if seen?(name)
 
@@ -329,7 +329,7 @@ module Tapioca
         @root << node
       end
 
-      #: (String name, T::Module[top] constant) -> void
+      #: (String name, Module[top] constant) -> void
       def compile_module(name, constant)
         return if skip_module?(name, constant)
         return if seen?(name)
@@ -340,7 +340,7 @@ module Tapioca
         push_scope(name, constant, scope)
       end
 
-      #: (String name, T::Module[top] constant) -> RBI::Scope
+      #: (String name, Module[top] constant) -> RBI::Scope
       def compile_scope(name, constant)
         scope = if constant.is_a?(Class)
           superclass = compile_superclass(constant)
@@ -423,7 +423,7 @@ module Tapioca
         false
       end
 
-      #: (String name, T::Module[top] constant) -> bool
+      #: (String name, Module[top] constant) -> bool
       def skip_alias?(name, constant)
         return true if symbol_in_payload?(name)
         return true unless constant_in_gem?(name)
@@ -441,12 +441,12 @@ module Tapioca
         false
       end
 
-      #: (String name, T::Module[top] constant) -> bool
+      #: (String name, Module[top] constant) -> bool
       def skip_foreign_constant?(name, constant)
         Tapioca::TypeVariableModule === constant
       end
 
-      #: (String name, T::Module[top] constant) -> bool
+      #: (String name, Module[top] constant) -> bool
       def skip_module?(name, constant)
         return true unless defined_in_gem?(constant, strict: false)
         return true if Tapioca::TypeVariableModule === constant
@@ -454,7 +454,7 @@ module Tapioca
         false
       end
 
-      #: (T::Module[top] constant, ?strict: bool) -> bool
+      #: (Module[top] constant, ?strict: bool) -> bool
       def defined_in_gem?(constant, strict: true)
         files = get_file_candidates(constant)
           .merge(Runtime::Trackers::ConstantDefinition.files_for(constant))
@@ -466,7 +466,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] constant) -> Set[String]
+      #: (Module[top] constant) -> Set[String]
       def get_file_candidates(constant)
         file_candidates_for(constant)
       rescue ArgumentError, NameError
@@ -497,7 +497,7 @@ module Tapioca
 
       # Helpers
 
-      #: ((T::Module[top] & T::Generic) constant) -> String
+      #: ((Module[top] & T::Generic) constant) -> String
       def generic_name_of(constant)
         type_name = T.must(constant.name)
         return type_name if type_name =~ /\[.*\]$/
@@ -513,7 +513,7 @@ module Tapioca
         "#{type_name}[#{type_variable_names}]"
       end
 
-      #: (T::Module[top] constant, String? class_name) -> String?
+      #: (Module[top] constant, String? class_name) -> String?
       def name_of_proxy_target(constant, class_name)
         return unless class_name == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
 

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -22,6 +22,25 @@ module Tapioca
       SPOOM_CONTEXT.srb(sorbet_args.join(" "), sorbet_bin: sorbet_path)
     end
 
+    #: (String, rbi_mode: bool) { (String stderr) -> void } -> void
+    def sorbet_syntax_check!(source, rbi_mode:, &on_failure)
+      quoted_source = "\"#{source}\""
+
+      result = if rbi_mode
+        # --e-rbi cannot be used on its own, so we pass a dummy value like `-e ""`
+        sorbet("--no-config", "--stop-after=parser", "-e", '""', "--e-rbi", quoted_source)
+      else
+        sorbet("--no-config", "--stop-after=parser", "-e", quoted_source)
+      end
+
+      unless result.status
+        stderr = result.err #: as !nil
+        on_failure.call(stderr)
+      end
+
+      nil
+    end
+
     #: -> String
     def sorbet_path
       sorbet_path = ENV.fetch(SORBET_EXE_PATH_ENV_VAR, SORBET_BIN)

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -94,21 +94,14 @@ module Tapioca
             compiler.decorate
 
             rbi = Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)
-            result = sorbet(
-              "--no-config",
-              "--stop-after",
-              "parser",
-              "-e",
-              "\"#{rbi}\"",
-            )
 
-            unless result.status
+            sorbet_syntax_check!(rbi, rbi_mode: true) do |stderr|
               raise(SyntaxError, <<~MSG)
                 Expected generated RBI file for `#{constant_name}` to not have any parsing errors.
 
                 Got these parsing errors:
 
-                #{result.err}
+                #{stderr}
               MSG
             end
 

data/lib/tapioca/internal.rb

@@ -12,7 +12,9 @@ require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/sorbet_ext/backcompat_patches"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"
+require "tapioca/sorbet_ext/generic_type_patch"
 require "tapioca/sorbet_ext/proc_bind_patch"
+require "tapioca/sorbet_ext/void_patch"
 require "tapioca/runtime/generic_type_registry"
 
 # The rewriter needs to be loaded very early so RBS comments within Tapioca itself are rewritten

data/lib/tapioca/rbi_ext/model.rb

@@ -3,7 +3,7 @@
 
 module RBI
   class Tree
-    #: (T::Module[top] constant) ?{ (Scope scope) -> void } -> Scope
+    #: (Module[top] constant) ?{ (Scope scope) -> void } -> Scope
     def create_path(constant, &block)
       constant_name = Tapioca::Runtime::Reflection.name_of(constant)
       raise "given constant does not have a name" unless constant_name
@@ -65,11 +65,10 @@ module RBI
     #|   ?return_type: String?,
     #|   ?class_method: bool,
     #|   ?visibility: RBI::Visibility,
-    #|   ?comments: Array[RBI::Comment],
-    #|   ?type_params: Array[String]
+    #|   ?comments: Array[RBI::Comment]
     #| ) ?{ (RBI::Method node) -> void } -> void
     def create_method(name, parameters: [], return_type: nil, class_method: false, visibility: RBI::Public.new,
-      comments: [], type_params: [], &block)
+      comments: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sigs = []
@@ -78,7 +77,11 @@ module RBI
         # 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) }
-        sigs << RBI::Sig.new(params: params, return_type: return_type || "T.untyped", type_params: type_params)
+        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)
+        sigs << sig
       end
 
       method = RBI::Method.new(

data/lib/tapioca/rbs/rewriter.rb

@@ -1,39 +1,93 @@
 # 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
+  end
+end
+
+# When TAPIOCA_RBS_CACHE=1, set up bootsnap with a dedicated cache directory
+# and load require-hooks so the RBS-rewritten iseqs get cached. Subsequent
+# runs read the rewritten iseq directly and skip the rewrite.
+#
+# After our setup, BootsnapGuard is prepended so the host application can't
+# replace our cache directory.
+if ENV["TAPIOCA_RBS_CACHE"] == "1"
+  begin
+    require "bootsnap"
+    # Respect BOOTSNAP_READONLY for consumers reading a pre-populated cache
+    # (e.g. a CI prime step).
+    readonly = !["0", "false", false].include?(ENV.fetch("BOOTSNAP_READONLY") { false })
+    Bootsnap.setup(
+      cache_dir: ENV.fetch("TAPIOCA_BOOTSNAP_CACHE_DIR", File.join(Dir.pwd, "tmp/cache/bootsnap-tapioca-rbs")),
+      development_mode: true,
+      load_path_cache: true,
+      compile_cache_iseq: true,
+      compile_cache_yaml: true,
+      readonly: readonly,
+      revalidation: true,
+    )
+    Bootsnap.log_stats!
+    Bootsnap.singleton_class.prepend(Tapioca::RBS::BootsnapGuard)
+  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 +101,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

@@ -6,7 +6,7 @@ module Tapioca
     class DynamicMixinCompiler
       include Runtime::Reflection
 
-      #: Array[T::Module[top]]
+      #: Array[Module[top]]
       attr_reader :dynamic_extends, :dynamic_includes
 
       #: Array[Symbol]
@@ -15,7 +15,7 @@ module Tapioca
       #: Array[Symbol]
       attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
 
-      #: (T::Module[top] constant) -> void
+      #: (Module[top] constant) -> void
       def initialize(constant)
         @constant = constant
         mixins_from_modules = {}.compare_by_identity
@@ -109,12 +109,12 @@ module Tapioca
         # is the list of all dynamically extended modules because of that
         # constant. We grab that value by deleting the key for the original
         # constant.
-        @dynamic_extends = mixins_from_modules.delete(constant) || [] #: Array[T::Module[top]]
+        @dynamic_extends = mixins_from_modules.delete(constant) || [] #: Array[Module[top]]
 
         # Since we deleted the original constant from the list of keys, all
         # the keys that remain are the ones that are dynamically included modules
         # during the include of the original constant.
-        @dynamic_includes = mixins_from_modules.keys #: Array[T::Module[top]]
+        @dynamic_includes = mixins_from_modules.keys #: Array[Module[top]]
 
         @class_attribute_readers = class_attribute_readers #: Array[Symbol]
         @class_attribute_writers = class_attribute_writers #: Array[Symbol]
@@ -173,7 +173,7 @@ module Tapioca
         tree << RBI::Include.new("GeneratedInstanceMethods")
       end
 
-      #: (RBI::Tree tree) -> [Array[T::Module[top]], Array[T::Module[top]]]
+      #: (RBI::Tree tree) -> [Array[Module[top]], Array[Module[top]]]
       def compile_mixes_in_class_methods(tree)
         includes = dynamic_includes.filter_map do |mod|
           qname = qualified_name_of(mod)
@@ -208,7 +208,7 @@ module Tapioca
         [[], []] # silence errors
       end
 
-      #: (T::Module[top] mod, Array[T::Module[top]] dynamic_extends) -> bool
+      #: (Module[top] mod, Array[Module[top]] dynamic_extends) -> bool
       def module_included_by_another_dynamic_extend?(mod, dynamic_extends)
         dynamic_extends.any? do |dynamic_extend|
           mod != dynamic_extend && ancestors_of(dynamic_extend).include?(mod)

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,16 +21,16 @@ 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, T::Module[top]]
+      @generic_instances = {}.compare_by_identity #: Hash[Module[top], Hash[String, Module[top]]]
 
-      @type_variables = {}.compare_by_identity #: Hash[T::Module[top], Array[TypeVariableModule]]
+      @type_variables = {}.compare_by_identity #: Hash[Module[top], Array[TypeVariableModule]]
 
       class GenericType < T::Types::Simple
-        #: (T::Module[top] raw_type, T::Module[top] underlying_type) -> void
+        #: (Module[top] raw_type, Module[top] underlying_type) -> void
         def initialize(raw_type, underlying_type)
           super(raw_type)
 
-          @underlying_type = underlying_type #: T::Module[top]
+          @underlying_type = underlying_type #: Module[top]
         end
 
         # @override
@@ -45,14 +45,15 @@ 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).
         #
         # This method returns the created or cached clone of the constant.
-        #: (untyped constant, untyped types) -> T::Module[top]
+        #: (untyped constant, untyped types) -> Module[top]
         def register_type(constant, types)
           # Build the name of the instantiated generic type,
           # something like `"Foo[X, Y, Z]"`
@@ -64,15 +65,18 @@ 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
 
-        #: (T::Module[top] constant) -> Array[TypeVariableModule]?
+        #: (Module[top] constant) -> Array[TypeVariableModule]?
         def lookup_type_variables(constant)
           @type_variables[constant]
         end
@@ -88,14 +92,14 @@ 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
 
         private
 
-        #: (T::Module[top] constant, String name) -> T::Module[top]
+        #: (Module[top] constant, String name) -> Module[top]
         def create_generic_type(constant, name)
           generic_type = case constant
           when Class
@@ -163,11 +167,6 @@ module Tapioca
             owner.send(:define_method, :inherited, inherited_method)
           end
         end
-
-        #: (T::Module[top] constant) -> Array[TypeVariableModule]
-        def lookup_or_initialize_type_variables(constant)
-          @type_variables[constant] ||= []
-        end
       end
     end
   end