tapioca 0.16.11 → 0.17.1

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

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Tapioca
@@ -13,12 +13,13 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def forking_env?
             !ENV["NO_FORK"] && Process.respond_to?(:fork)
           end
         end
 
+        #: -> Object
         def run
           serialized = T.unsafe(self).run_in_isolation do
             super
@@ -33,7 +34,7 @@ module Tapioca
 
           requires_ancestor { Kernel }
 
-          sig { params(_blk: T.untyped).returns(String) }
+          #: ?{ (?) -> untyped } -> String
           def run_in_isolation(&_blk)
             read, write = IO.pipe
             read.binmode
@@ -67,8 +68,8 @@ module Tapioca
             result = read.read
             read.close
 
-            Process.wait2(T.must(pid))
-            T.must(result).unpack1("m")
+            Process.wait2(pid)
+            result.unpack1("m")
           end
         end
 
@@ -78,11 +79,11 @@ module Tapioca
 
           requires_ancestor { Kernel }
 
-          ORIG_ARGV = T.let(ARGV.dup, T::Array[T.untyped]) unless defined?(ORIG_ARGV)
+          ORIG_ARGV = ARGV.dup #: Array[String]
 
           # Crazy H4X to get this working in windows / jruby with
           # no forking.
-          sig { params(_blk: T.untyped).returns(String) }
+          #: ?{ (?) -> untyped } -> String
           def run_in_isolation(&_blk)
             this = T.cast(self, Minitest::Test)
             require "tempfile"

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

@@ -10,21 +10,19 @@ module Tapioca
 
         requires_ancestor { Kernel }
 
-        ERB_SUPPORTS_KVARGS = T.let(
-          ::ERB.instance_method(:initialize).parameters.assoc(:key), T.nilable([Symbol, Symbol])
-        )
+        ERB_SUPPORTS_KVARGS = ::ERB.instance_method(:initialize).parameters.assoc(:key) #: [Symbol, Symbol]?
 
-        sig { params(selector: String).returns(T::Boolean) }
+        #: (String selector) -> bool
         def ruby_version(selector)
           ::Gem::Requirement.new(selector).satisfied_by?(::Gem::Version.new(RUBY_VERSION))
         end
 
-        sig { params(selector: String).returns(T::Boolean) }
+        #: (String selector) -> bool
         def rails_version(selector)
           ::Gem::Requirement.new(selector).satisfied_by?(ActiveSupport.gem_version)
         end
 
-        sig { params(src: String, trim_mode: String).returns(String) }
+        #: (String src, ?trim_mode: String) -> String
         def template(src, trim_mode: ">")
           erb = if ERB_SUPPORTS_KVARGS
             ::ERB.new(src, trim_mode: trim_mode)
@@ -35,7 +33,7 @@ module Tapioca
           erb.result(binding)
         end
 
-        sig { params(str: String, indent: Integer).returns(String) }
+        #: (String str, Integer indent) -> String
         def indented(str, indent)
           str.lines.map! do |line|
             next line if line.chomp.empty?

data/lib/tapioca/internal.rb

@@ -7,6 +7,18 @@ require "tapioca"
 require "tapioca/runtime/reflection"
 require "tapioca/runtime/trackers"
 
+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/proc_bind_patch"
+require "tapioca/runtime/generic_type_registry"
+
+# The rewriter needs to be loaded very early so RBS comments within Tapioca itself are rewritten
+require "spoom"
+require "tapioca/rbs/rewriter"
+# ^ Do not change the order of these requires
+
 require "benchmark"
 require "bundler"
 require "erb"
@@ -25,14 +37,6 @@ require "yaml"
 require "yard-sorbet"
 require "prism"
 
-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/proc_bind_patch"
-require "tapioca/runtime/generic_type_registry"
-
-require "spoom"
 require "tapioca/helpers/gem_helper"
 require "tapioca/helpers/git_attributes"
 require "tapioca/helpers/sorbet_helper"

data/lib/tapioca/loaders/dsl.rb

@@ -9,14 +9,7 @@ module Tapioca
       class << self
         extend T::Sig
 
-        sig do
-          params(
-            tapioca_path: String,
-            eager_load: T::Boolean,
-            app_root: String,
-            halt_upon_load_error: T::Boolean,
-          ).void
-        end
+        #: (tapioca_path: String, ?eager_load: bool, ?app_root: String, ?halt_upon_load_error: bool) -> void
         def load_application(
           tapioca_path:,
           eager_load: true,
@@ -32,20 +25,21 @@ module Tapioca
         end
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def load
         load_dsl_extensions
         load_application
         load_dsl_compilers
       end
 
-      sig { void }
+      #: -> void
       def load_dsl_extensions_and_compilers
         load_dsl_extensions
         load_dsl_compilers
       end
 
-      sig { void }
+      #: -> void
       def reload_custom_compilers
         # Remove all loaded custom compilers
         ::Tapioca::Dsl::Compiler.descendants.each do |compiler|
@@ -68,9 +62,7 @@ module Tapioca
 
       protected
 
-      sig do
-        params(tapioca_path: String, eager_load: T::Boolean, app_root: String, halt_upon_load_error: T::Boolean).void
-      end
+      #: (tapioca_path: String, ?eager_load: bool, ?app_root: String, ?halt_upon_load_error: bool) -> void
       def initialize(tapioca_path:, eager_load: true, app_root: ".", halt_upon_load_error: true)
         super()
 
@@ -78,10 +70,10 @@ module Tapioca
         @eager_load = eager_load
         @app_root = app_root
         @halt_upon_load_error = halt_upon_load_error
-        @custom_compiler_paths = T.let([], T::Array[String])
+        @custom_compiler_paths = [] #: Array[String]
       end
 
-      sig { void }
+      #: -> void
       def load_dsl_extensions
         say("Loading DSL extension classes... ")
 
@@ -96,7 +88,7 @@ module Tapioca
         say("Done", :green)
       end
 
-      sig { void }
+      #: -> void
       def load_dsl_compilers
         say("Loading DSL compiler classes... ")
 
@@ -116,7 +108,7 @@ module Tapioca
         say("Done", :green)
       end
 
-      sig { void }
+      #: -> void
       def load_application
         say("Loading Rails application... ")
 
@@ -132,7 +124,7 @@ module Tapioca
 
       private
 
-      sig { void }
+      #: -> void
       def load_custom_dsl_compilers
         @custom_compiler_paths = Dir.glob([
           "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later

data/lib/tapioca/loaders/gem.rb

@@ -9,15 +9,7 @@ module Tapioca
       class << self
         extend T::Sig
 
-        sig do
-          params(
-            bundle: Gemfile,
-            prerequire: T.nilable(String),
-            postrequire: String,
-            default_command: String,
-            halt_upon_load_error: T::Boolean,
-          ).void
-        end
+        #: (bundle: Gemfile, prerequire: String?, postrequire: String, default_command: String, halt_upon_load_error: bool) -> void
         def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:)
           loader = new(
             bundle: bundle,
@@ -30,22 +22,15 @@ module Tapioca
         end
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def load
         require_gem_file
       end
 
       protected
 
-      sig do
-        params(
-          bundle: Gemfile,
-          prerequire: T.nilable(String),
-          postrequire: String,
-          default_command: String,
-          halt_upon_load_error: T::Boolean,
-        ).void
-      end
+      #: (bundle: Gemfile, prerequire: String?, postrequire: String, default_command: String, halt_upon_load_error: bool) -> void
       def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:)
         super()
 
@@ -56,7 +41,7 @@ module Tapioca
         @halt_upon_load_error = halt_upon_load_error
       end
 
-      sig { void }
+      #: -> void
       def require_gem_file
         say("Requiring all gems to prepare for compiling... ")
         begin
@@ -76,7 +61,7 @@ module Tapioca
         puts
       end
 
-      sig { params(file: String, error: LoadError).void }
+      #: (String file, LoadError error) -> void
       def explain_failed_require(file, error)
         say_error("\n\nLoadError: #{error}", :bold, :red)
         say_error("\nTapioca could not load all the gems required by your application.", :yellow)

data/lib/tapioca/loaders/loader.rb

@@ -18,14 +18,7 @@ module Tapioca
 
       private
 
-      sig do
-        params(
-          gemfile: Tapioca::Gemfile,
-          initialize_file: T.nilable(String),
-          require_file: T.nilable(String),
-          halt_upon_load_error: T::Boolean,
-        ).void
-      end
+      #: (Tapioca::Gemfile gemfile, String? initialize_file, String? require_file, bool halt_upon_load_error) -> void
       def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error)
         require_helper(initialize_file)
 
@@ -38,14 +31,7 @@ module Tapioca
         load_rails_engines
       end
 
-      sig do
-        params(
-          environment_load: T::Boolean,
-          eager_load: T::Boolean,
-          app_root: String,
-          halt_upon_load_error: T::Boolean,
-        ).void
-      end
+      #: (?environment_load: bool, ?eager_load: bool, ?app_root: String, ?halt_upon_load_error: bool) -> void
       def load_rails_application(environment_load: false, eager_load: false, app_root: ".", halt_upon_load_error: true)
         return unless File.exist?(File.expand_path("config/application.rb", app_root))
 
@@ -85,7 +71,7 @@ module Tapioca
         say("Continuing RBI generation without loading the Rails application.")
       end
 
-      sig { void }
+      #: -> void
       def load_rails_engines
         return if engines.empty?
 
@@ -110,29 +96,25 @@ module Tapioca
         end
       end
 
-      sig { void }
+      #: -> void
       def load_engines_in_zeitwerk_mode
-        # Collect all the directories that are already managed by all existing Zeitwerk loaders.
-        managed_dirs = Zeitwerk::Registry.loaders.flat_map(&:dirs).to_set
         # We use a fresh loader to load the engine directories, so that we don't interfere with
         # any of the existing loaders.
         autoloader = Zeitwerk::Loader.new
 
         engines.each do |engine|
           eager_load_paths(engine).each do |path|
-            # Zeitwerk only accepts existing directories in `push_dir`.
-            next unless File.directory?(path)
-            # We should not add directories that are already managed by a Zeitwerk loader.
-            next if managed_dirs.member?(path)
-
             autoloader.push_dir(path)
+          rescue Zeitwerk::Error
+            # The path is not an existing directory, or it is managed by
+            # some other loader, ..., it is fine, just skip it.
           end
         end
 
         autoloader.setup
       end
 
-      sig { void }
+      #: -> void
       def load_engines_in_classic_mode
         # This is code adapted from `Rails::Engine#eager_load!` in
         # https://github.com/rails/rails/blob/d9e188dbab81b412f73dfb7763318d52f360af49/railties/lib/rails/engine.rb#L489-L495
@@ -150,14 +132,14 @@ module Tapioca
         end
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def zeitwerk_mode?
         Rails.respond_to?(:autoloaders) &&
           Rails.autoloaders.respond_to?(:zeitwerk_enabled?) &&
           Rails.autoloaders.zeitwerk_enabled?
       end
 
-      sig { params(blk: T.proc.void).void }
+      #: { -> void } -> void
       def with_rails_application(&blk)
         # Store the current Rails.application object so that we can restore it
         rails_application = T.unsafe(Rails.application)
@@ -174,7 +156,8 @@ module Tapioca
         Rails.app_class = Rails.application = rails_application
       end
 
-      T::Sig::WithoutRuntime.sig { returns(T::Array[T.class_of(Rails::Engine)]) }
+      # @without_runtime
+      #: -> Array[singleton(Rails::Engine)]
       def engines
         return [] unless defined?(Rails::Engine)
 
@@ -188,14 +171,14 @@ module Tapioca
           .reject { |engine| gem_in_app_dir?(project_path, engine.config.root.to_path) }
       end
 
-      sig { params(path: String).void }
+      #: (String path) -> void
       def safe_require(path)
         require path
       rescue LoadError
         nil
       end
 
-      sig { void }
+      #: -> void
       def eager_load_rails_app
         application = Rails.application
 
@@ -216,7 +199,7 @@ module Tapioca
         end
       end
 
-      sig { params(file: T.nilable(String)).void }
+      #: (String? file) -> void
       def require_helper(file)
         return unless file
 
@@ -230,7 +213,8 @@ module Tapioca
       # The `eager_load_paths` method still exists, but doesn't return all paths anymore and causes Tapioca to miss some
       # engine paths. The following commit is the change:
       # https://github.com/rails/rails/commit/ebfca905db14020589c22e6937382e6f8f687664
-      T::Sig::WithoutRuntime.sig { params(engine: T.class_of(Rails::Engine)).returns(T::Array[String]) }
+      # @without_runtime
+      #: (singleton(Rails::Engine) engine) -> Array[String]
       def eager_load_paths(engine)
         config = engine.config
 

data/lib/tapioca/rbi_ext/model.rb

@@ -5,7 +5,7 @@ module RBI
   class Tree
     extend T::Sig
 
-    sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: Scope).void)).returns(Scope) }
+    #: (::Module 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
@@ -21,72 +21,47 @@ module RBI
       end
     end
 
-    sig { params(name: String, block: T.nilable(T.proc.params(scope: Scope).void)).returns(Scope) }
+    #: (String name) ?{ (Scope scope) -> void } -> Scope
     def create_module(name, &block)
       T.cast(create_node(RBI::Module.new(name)), RBI::Scope).tap do |node|
         block&.call(node)
       end
     end
 
-    sig do
-      params(
-        name: String,
-        superclass_name: T.nilable(String),
-        block: T.nilable(T.proc.params(scope: RBI::Scope).void),
-      ).returns(Scope)
-    end
+    #: (String name, ?superclass_name: String?) ?{ (RBI::Scope scope) -> void } -> Scope
     def create_class(name, superclass_name: nil, &block)
       T.cast(create_node(RBI::Class.new(name, superclass_name: superclass_name)), RBI::Scope).tap do |node|
         block&.call(node)
       end
     end
 
-    sig { params(name: String, value: String).void }
+    #: (String name, value: String) -> void
     def create_constant(name, value:)
       create_node(RBI::Const.new(name, value))
     end
 
-    sig { params(name: String).void }
+    #: (String name) -> void
     def create_include(name)
       create_node(RBI::Include.new(name))
     end
 
-    sig { params(name: String).void }
+    #: (String name) -> void
     def create_extend(name)
       create_node(RBI::Extend.new(name))
     end
 
-    sig { params(name: String).void }
+    #: (String name) -> void
     def create_mixes_in_class_methods(name)
       create_node(RBI::MixesInClassMethods.new(name))
     end
 
-    sig do
-      params(
-        name: String,
-        type: String,
-        variance: Symbol,
-        fixed: T.nilable(String),
-        upper: T.nilable(String),
-        lower: T.nilable(String),
-      ).void
-    end
+    #: (String name, type: String, ?variance: Symbol, ?fixed: String?, ?upper: String?, ?lower: String?) -> void
     def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: nil, lower: nil)
       value = Tapioca::RBIHelper.serialize_type_variable(type, variance, fixed, upper, lower)
       create_node(RBI::TypeMember.new(name, value))
     end
 
-    sig do
-      params(
-        name: String,
-        parameters: T::Array[TypedParam],
-        return_type: T.nilable(String),
-        class_method: T::Boolean,
-        visibility: RBI::Visibility,
-        comments: T::Array[RBI::Comment],
-        block: T.nilable(T.proc.params(node: RBI::Method).void),
-      ).void
-    end
+    #: (String name, ?parameters: Array[TypedParam], ?return_type: String?, ?class_method: bool, ?visibility: RBI::Visibility, ?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: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)
@@ -114,12 +89,12 @@ module RBI
 
     private
 
-    sig { returns(T::Hash[String, RBI::Node]) }
+    #: -> Hash[String, RBI::Node]
     def nodes_cache
-      @nodes_cache ||= T.let({}, T.nilable(T::Hash[String, Node]))
+      @nodes_cache ||= {} #: Hash[String, Node]?
     end
 
-    sig { params(node: RBI::Node).returns(RBI::Node) }
+    #: (RBI::Node node) -> RBI::Node
     def create_node(node)
       cached = nodes_cache[node.to_s]
       return cached if cached

data/lib/tapioca/rbi_formatter.rb

@@ -5,13 +5,7 @@ module Tapioca
   class RBIFormatter < RBI::Formatter
     extend T::Sig
 
-    sig do
-      params(
-        file: RBI::File,
-        command: String,
-        reason: T.nilable(String),
-      ).void
-    end
+    #: (RBI::File file, String command, ?reason: String?) -> void
     def write_header!(file, command, reason: nil)
       file.comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
       file.comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
@@ -20,7 +14,7 @@ module Tapioca
       file.comments << RBI::BlankLine.new
     end
 
-    sig { params(file: RBI::File).void }
+    #: (RBI::File file) -> void
     def write_empty_body_comment!(file)
       file.comments << RBI::BlankLine.new unless file.comments.empty?
       file.comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
@@ -28,15 +22,12 @@ module Tapioca
     end
   end
 
-  DEFAULT_RBI_FORMATTER = T.let(
-    RBIFormatter.new(
-      add_sig_templates: false,
-      group_nodes: true,
-      max_line_length: nil,
-      nest_singleton_methods: true,
-      nest_non_public_members: true,
-      sort_nodes: true,
-    ),
-    RBIFormatter,
-  )
+  DEFAULT_RBI_FORMATTER = RBIFormatter.new(
+    add_sig_templates: false,
+    group_nodes: true,
+    max_line_length: nil,
+    nest_singleton_methods: true,
+    nest_non_public_members: true,
+    sort_nodes: true,
+  ) #: RBIFormatter
 end

data/lib/tapioca/rbs/rewriter.rb

@@ -0,0 +1,55 @@
+# 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
+          end
+        end
+      end
+    end
+  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
+# are unlikely to include `T::Sig` in their own classes.
+Module.include(T::Sig)
+
+# Trigger the source transformation for each Ruby file being loaded.
+RequireHooks.source_transform(patterns: ["**/*.rb"]) do |path, source|
+  # The source is most likely nil since no `source_transform` hook was triggered before this one.
+  source ||= File.read(path)
+
+  # 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)
+  end
+rescue RBI::RBS::MethodTypeTranslator::Error
+  # If we can't translate the RBS comments back into Sorbet's signatures, we just skip the file.
+  source
+end

data/lib/tapioca/repo_index.rb

@@ -9,12 +9,12 @@ module Tapioca
     class << self
       extend T::Sig
 
-      sig { params(json: String).returns(RepoIndex) }
+      #: (String json) -> RepoIndex
       def from_json(json)
         RepoIndex.from_hash(JSON.parse(json))
       end
 
-      sig { params(hash: T::Hash[String, T::Hash[T.untyped, T.untyped]]).returns(RepoIndex) }
+      #: (Hash[String, Hash[untyped, untyped]] hash) -> RepoIndex
       def from_hash(hash)
         hash.each_with_object(RepoIndex.new) do |(name, _), index|
           index << name
@@ -22,22 +22,22 @@ module Tapioca
       end
     end
 
-    sig { void }
+    #: -> void
     def initialize
-      @entries = T.let(Set.new, T::Set[String])
+      @entries = Set.new #: Set[String]
     end
 
-    sig { params(gem_name: String).void }
+    #: (String gem_name) -> void
     def <<(gem_name)
       @entries.add(gem_name)
     end
 
-    sig { returns(T::Enumerable[String]) }
+    #: -> T::Enumerable[String]
     def gems
       @entries.sort
     end
 
-    sig { params(gem_name: String).returns(T::Boolean) }
+    #: (String gem_name) -> bool
     def has_gem?(gem_name)
       @entries.include?(gem_name)
     end

data/lib/tapioca/runtime/attached_class_of_32.rb

@@ -10,7 +10,7 @@ module Tapioca
     module AttachedClassOf
       extend T::Sig
 
-      sig { params(singleton_class: Class).returns(T.nilable(Module)) }
+      #: (Class singleton_class) -> Module?
       def attached_class_of(singleton_class)
         result = singleton_class.attached_object
         Module === result ? result : nil