tapioca 0.18.0 → 0.19.1

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

@@ -13,6 +13,7 @@ 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/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
@@ -41,7 +42,7 @@ require "shellwords"
 require "tempfile"
 require "thor"
 require "yaml"
-require "yard-sorbet"
+require "rubydex"
 require "prism"
 
 require "tapioca/helpers/gem_helper"

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
@@ -77,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")
+        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/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

@@ -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 = {} #: 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
@@ -52,7 +52,7 @@ module Tapioca
         # 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]"`
@@ -72,7 +72,7 @@ module Tapioca
           @generic_instances.values.any? { |generic_type| generic_type === instance }
         end
 
-        #: (T::Module[top] constant) -> Array[TypeVariableModule]?
+        #: (Module[top] constant) -> Array[TypeVariableModule]?
         def lookup_type_variables(constant)
           @type_variables[constant]
         end
@@ -95,7 +95,7 @@ module Tapioca
 
         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
@@ -164,7 +164,7 @@ module Tapioca
           end
         end
 
-        #: (T::Module[top] constant) -> Array[TypeVariableModule]
+        #: (Module[top] constant) -> Array[TypeVariableModule]
         def lookup_or_initialize_type_variables(constant)
           @type_variables[constant] ||= []
         end

data/lib/tapioca/runtime/reflection.rb

@@ -20,7 +20,7 @@ module Tapioca
       PROTECTED_INSTANCE_METHODS_METHOD = Module.instance_method(:protected_instance_methods) #: UnboundMethod
       PRIVATE_INSTANCE_METHODS_METHOD = Module.instance_method(:private_instance_methods) #: UnboundMethod
       METHOD_METHOD = Kernel.instance_method(:method) #: UnboundMethod
-      UNDEFINED_CONSTANT = Module.new.freeze #: T::Module[top]
+      UNDEFINED_CONSTANT = Module.new.freeze #: Module[top]
 
       REQUIRED_FROM_LABELS = ["<top (required)>", "<main>", "<compiled>"].freeze #: Array[String]
 
@@ -31,7 +31,7 @@ module Tapioca
       end
 
       # @without_runtime
-      #: (String symbol, ?inherit: bool, ?namespace: T::Module[top]) -> BasicObject
+      #: (String symbol, ?inherit: bool, ?namespace: Module[top]) -> BasicObject
       def constantize(symbol, inherit: false, namespace: Object)
         namespace.const_get(symbol, inherit)
       rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
@@ -43,23 +43,23 @@ module Tapioca
         CLASS_METHOD.bind_call(object)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def constants_of(constant)
         CONSTANTS_METHOD.bind_call(constant, false)
       end
 
-      #: (T::Module[top] constant) -> String?
+      #: (Module[top] constant) -> String?
       def name_of(constant)
         name = NAME_METHOD.bind_call(constant)
         name&.start_with?("#<") ? nil : name
       end
 
-      #: (T::Module[top] constant) -> Class[top]
+      #: (Module[top] constant) -> Class[top]
       def singleton_class_of(constant)
         SINGLETON_CLASS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[T::Module[top]]
+      #: (Module[top] constant) -> Array[Module[top]]
       def ancestors_of(constant)
         ANCESTORS_METHOD.bind_call(constant)
       end
@@ -69,7 +69,7 @@ module Tapioca
         SUPERCLASS_METHOD.bind_call(constant)
       end
 
-      #: (Class[top] singleton_class) -> T::Module[top]?
+      #: (Class[top] singleton_class) -> Module[top]?
       def attached_class_of(singleton_class)
         result = singleton_class.attached_object
         Module === result ? result : nil
@@ -85,22 +85,22 @@ module Tapioca
         EQUAL_METHOD.bind_call(object, other)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def public_instance_methods_of(constant)
         PUBLIC_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def protected_instance_methods_of(constant)
         PROTECTED_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def private_instance_methods_of(constant)
         PRIVATE_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[T::Module[top]]
+      #: (Module[top] constant) -> Array[Module[top]]
       def inherited_ancestors_of(constant)
         if Class === constant
           ancestors_of(superclass_of(constant) || Object)
@@ -109,7 +109,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] constant) -> String?
+      #: (Module[top] constant) -> String?
       def qualified_name_of(constant)
         name = name_of(constant)
         return if name.nil?
@@ -142,7 +142,7 @@ module Tapioca
         type.to_s
       end
 
-      #: (T::Module[top] constant, Symbol method) -> Method
+      #: (Module[top] constant, Symbol method) -> Method
       def method_of(constant, method)
         METHOD_METHOD.bind_call(constant, method)
       end
@@ -211,32 +211,39 @@ module Tapioca
         SourceLocation.from_loc([file, resolved_loc.lineno])
       end
 
-      #: (T::Module[top] constant) -> Set[String]
+      #: (Module[top] constant) -> Set[String]
       def file_candidates_for(constant)
-        relevant_methods_for(constant).filter_map do |method|
+        # Grab all source files for (relevant) methods defined on the constant
+        candidates = relevant_methods_for(constant).filter_map do |method|
           method.source_location&.first
         end.to_set
+
+        # Add the source file for the constant definition itself, if available.
+        source_location_candidate = const_source_location(name_of(constant).to_s)&.file
+        candidates.add(source_location_candidate) if source_location_candidate
+
+        candidates
       end
 
-      #: (T::Module[top] constant) -> untyped
+      #: (Module[top] constant) -> untyped
       def abstract_type_of(constant)
         T::Private::Abstract::Data.get(constant, :abstract_type) ||
           T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
       end
 
-      #: (T::Module[top] constant) -> bool
+      #: (Module[top] constant) -> bool
       def final_module?(constant)
         T::Private::Final.final_module?(constant)
       end
 
-      #: (T::Module[top] constant) -> bool
+      #: (Module[top] constant) -> bool
       def sealed_module?(constant)
         T::Private::Sealed.sealed_module?(constant)
       end
 
       private
 
-      #: (T::Module[top] constant) -> Array[UnboundMethod]
+      #: (Module[top] constant) -> Array[UnboundMethod]
       def relevant_methods_for(constant)
         methods = methods_for(constant).select(&:source_location)
           .reject { |x| method_defined_by_forwardable_module?(x) }
@@ -252,7 +259,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] constant) -> Array[UnboundMethod]
+      #: (Module[top] constant) -> Array[UnboundMethod]
       def methods_for(constant)
         modules = [constant, singleton_class_of(constant)]
         method_list_methods = [
@@ -266,7 +273,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] parent, String name) -> T::Module[top]?
+      #: (Module[top] parent, String name) -> Module[top]?
       def child_module_for_parent_with_name(parent, name)
         return if parent.autoload?(name)
 

data/lib/tapioca/runtime/trackers/constant_definition.rb

@@ -12,7 +12,7 @@ module Tapioca
         extend Tracker
         extend Reflection
 
-        @class_files = {}.compare_by_identity #: Hash[T::Module[top], Set[SourceLocation]]
+        @class_files = {}.compare_by_identity #: Hash[Module[top], Set[SourceLocation]]
 
         # Immediately activated upon load. Observes class/module definition.
         @class_tracepoint = TracePoint.trace(:class) do |tp|
@@ -83,12 +83,12 @@ module Tapioca
           # Returns the files in which this class or module was opened. Doesn't know
           # about situations where the class was opened prior to +require+ing,
           # or where metaprogramming was used via +eval+, etc.
-          #: (T::Module[top] klass) -> Set[String]
+          #: (Module[top] klass) -> Set[String]
           def files_for(klass)
             locations_for(klass).map(&:file).to_set
           end
 
-          #: (T::Module[top] klass) -> Set[SourceLocation]
+          #: (Module[top] klass) -> Set[SourceLocation]
           def locations_for(klass)
             @class_files.fetch(klass, Set.new)
           end

data/lib/tapioca/runtime/trackers/method_definition.rb

@@ -7,10 +7,10 @@ module Tapioca
       module MethodDefinition
         extend Tracker
 
-        @method_definitions = {}.compare_by_identity #: Hash[T::Module[top], Hash[Symbol, Array[SourceLocation]]]
+        @method_definitions = {}.compare_by_identity #: Hash[Module[top], Hash[Symbol, Array[SourceLocation]]]
 
         class << self
-          #: (Symbol method_name, T::Module[top] owner, Array[Thread::Backtrace::Location] locations) -> void
+          #: (Symbol method_name, Module[top] owner, Array[Thread::Backtrace::Location] locations) -> void
           def register(method_name, owner, locations)
             return unless enabled?
             # If Sorbet runtime is redefining a method, it sets this to true.
@@ -24,7 +24,7 @@ module Tapioca
             registrations_for(method_name, owner) << loc
           end
 
-          #: (Symbol method_name, T::Module[top] owner) -> Array[SourceLocation]
+          #: (Symbol method_name, Module[top] owner) -> Array[SourceLocation]
           def method_definitions_for(method_name, owner)
             definitions = registrations_for(method_name, owner)
 
@@ -38,7 +38,7 @@ module Tapioca
 
           private
 
-          #: (Symbol method_name, T::Module[top] owner) -> Array[SourceLocation]
+          #: (Symbol method_name, Module[top] owner) -> Array[SourceLocation]
           def registrations_for(method_name, owner)
             owner_lookup = (@method_definitions[owner] ||= {})
             owner_lookup[method_name] ||= []

data/lib/tapioca/runtime/trackers/mixin.rb

@@ -24,7 +24,7 @@ module Tapioca
             with_disabled_tracker(&block)
           end
 
-          #: (T::Module[top] constant, T::Module[top] mixin, Type mixin_type) -> void
+          #: (Module[top] constant, Module[top] mixin, Type mixin_type) -> void
           def register(constant, mixin, mixin_type)
             return unless enabled?
 
@@ -46,19 +46,19 @@ module Tapioca
             attached_class
           end
 
-          #: (T::Module[top] mixin) -> Hash[Type, Hash[T::Module[top], String]]
+          #: (Module[top] mixin) -> Hash[Type, Hash[Module[top], String]]
           def constants_with_mixin(mixin)
             find_or_initialize_mixin_lookup(mixin)
           end
 
-          #: (T::Module[top] mixin, Type mixin_type, T::Module[top] constant) -> String?
+          #: (Module[top] mixin, Type mixin_type, Module[top] constant) -> String?
           def mixin_location(mixin, mixin_type, constant)
             find_or_initialize_mixin_lookup(mixin).dig(mixin_type, constant)
           end
 
           private
 
-          #: (T::Module[top] constant, T::Module[top] mixin, Type mixin_type, String location) -> void
+          #: (Module[top] constant, Module[top] mixin, Type mixin_type, String location) -> void
           def register_with_location(constant, mixin, mixin_type, location)
             return unless @enabled
 
@@ -66,7 +66,7 @@ module Tapioca
             constants.fetch(mixin_type).store(constant, location)
           end
 
-          #: (T::Module[top] mixin) -> Hash[Type, Hash[T::Module[top], String]]
+          #: (Module[top] mixin) -> Hash[Type, Hash[Module[top], String]]
           def find_or_initialize_mixin_lookup(mixin)
             @mixins_to_constants[mixin] ||= {
               Type::Prepend => {}.compare_by_identity,

data/lib/tapioca/runtime/trackers/required_ancestor.rb

@@ -17,12 +17,12 @@ module Tapioca
             ancestors << block
           end
 
-          #: (T::Module[top] mod) -> Array[^-> void]
+          #: (Module[top] mod) -> Array[^-> void]
           def required_ancestors_blocks_by(mod)
             @required_ancestors_map[mod] || []
           end
 
-          #: (T::Module[top] mod) -> Array[untyped]
+          #: (Module[top] mod) -> Array[untyped]
           def required_ancestors_by(mod)
             blocks = required_ancestors_blocks_by(mod)
             blocks.map do |block|

data/lib/tapioca/runtime/trackers/tracker.rb

@@ -7,7 +7,7 @@ module Tapioca
       # @abstract
       module Tracker
         class << self
-          #: ((Tracker & T::Module[top]) base) -> void
+          #: ((Tracker & Module[top]) base) -> void
           def extended(base)
             Trackers.register_tracker(base)
             base.instance_exec do

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -133,7 +133,7 @@ module Tapioca
     #: Type
     attr_reader :type
 
-    #: (T::Module[top] context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
+    #: (Module[top] context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
     def initialize(context, type, variance, bounds_proc)
       @context = context
       @type = type

data/lib/tapioca/sorbet_ext/void_patch.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+# If Signature has `effective_return_type`, then `return_type` always returns the correct type.
+# Ref: https://github.com/sorbet/sorbet/pull/10121
+return if T::Private::Methods::Signature.method_defined?(:effective_return_type)
+
+module T
+  module Private
+    module Methods
+      module DeclBuilderPatch
+        def void
+          super.tap do
+            @_real_returns_is_void = true
+          end
+        end
+
+        def finalize!
+          super.tap do
+            #: self as untyped
+            decl.returns = T::Private::Types::Void::Private::INSTANCE if @_real_returns_is_void
+          end
+        end
+      end
+
+      DeclBuilder.prepend(DeclBuilderPatch)
+    end
+  end
+end

data/lib/tapioca/static/symbol_loader.rb

@@ -18,6 +18,19 @@ module Tapioca
           T.must(@payload_symbols)
         end
 
+        #: (Array[Pathname] paths) -> Rubydex::Graph
+        def graph_from_paths(paths)
+          graph = Rubydex::Graph.new
+          graph.index_all(paths.map(&:to_s))
+          graph.resolve
+          graph
+        end
+
+        #: (Gemfile::GemSpec gem) -> Set[String]
+        def gem_symbols(gem)
+          symbols_from_paths(gem.files)
+        end
+
         #: (Gemfile::GemSpec gem) -> Set[String]
         def engine_symbols(gem)
           gem_engine = engines.find do |engine|
@@ -43,11 +56,6 @@ module Tapioca
           Set.new
         end
 
-        #: (Gemfile::GemSpec gem) -> Set[String]
-        def gem_symbols(gem)
-          symbols_from_paths(gem.files)
-        end
-
         #: (Array[Pathname] paths) -> Set[String]
         def symbols_from_paths(paths)
           return Set.new if paths.empty?
@@ -79,7 +87,25 @@ module Tapioca
 
         #: (String input, ?table_type: String) -> String
         def symbol_table_json_from(input, table_type: "symbol-table-json")
-          sorbet("--no-config", "--quiet", "--print=#{table_type}", input).out
+          supported_values = ["symbol-table-json", "symbol-table-full-json"]
+          unless supported_values.include?(table_type)
+            raise NotImplementedError, <<~MSG
+              Got an unsupported value for `table_type` (#{table_type.inspect}).
+              The only supported values are:
+                #{supported_values.map { |v| "- #{v}" }.join("\n")}
+
+              This is because we use `--stop-after=namer` as a performance optimization. Other print formats
+              may require running later stages of Sorbet's pipeline. Please adjust the `stop-after` accordingly.
+            MSG
+          end
+
+          sorbet(
+            "--no-config",
+            "--quiet",
+            "--print=#{table_type}",
+            "--stop-after=namer",
+            input,
+          ).out
         end
       end
     end

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.1
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -83,47 +83,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.2.2
 - !ruby/object:Gem::Dependency
-  name: sorbet-static-and-runtime
+  name: rubydex
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.11087
+        version: 0.1.0.beta10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.11087
+        version: 0.1.0.beta10
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: sorbet-static-and-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 0.6.12698
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 0.6.12698
 - !ruby/object:Gem::Dependency
-  name: yard-sorbet
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: rbi
   requirement: !ruby/object:Gem::Requirement
@@ -253,6 +253,7 @@ files:
 - lib/tapioca/gem/events.rb
 - lib/tapioca/gem/listeners.rb
 - lib/tapioca/gem/listeners/base.rb
+- lib/tapioca/gem/listeners/documentation.rb
 - lib/tapioca/gem/listeners/dynamic_mixins.rb
 - lib/tapioca/gem/listeners/foreign_constants.rb
 - lib/tapioca/gem/listeners/methods.rb
@@ -266,7 +267,6 @@ files:
 - lib/tapioca/gem/listeners/sorbet_type_variables.rb
 - lib/tapioca/gem/listeners/source_location.rb
 - lib/tapioca/gem/listeners/subconstants.rb
-- lib/tapioca/gem/listeners/yard_doc.rb
 - lib/tapioca/gem/pipeline.rb
 - lib/tapioca/gem_info.rb
 - lib/tapioca/gemfile.rb
@@ -307,6 +307,7 @@ files:
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
 - lib/tapioca/sorbet_ext/proc_bind_patch.rb
+- lib/tapioca/sorbet_ext/void_patch.rb
 - lib/tapioca/static/requires_compiler.rb
 - lib/tapioca/static/symbol_loader.rb
 - lib/tapioca/static/symbol_table_parser.rb
@@ -330,7 +331,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard
   library