tapioca 0.18.0 → 0.19.1

data/lib/tapioca/dsl/compilers/state_machines.rb

@@ -109,7 +109,7 @@ module Tapioca
       #   end
       # end
       # ~~~
-      #: [ConstantType = (T::Module[top] & ::StateMachines::ClassMethods)]
+      #: [ConstantType = (Module[top] & ::StateMachines::ClassMethods)]
       class StateMachines < Compiler
         # @override
         #: -> void
@@ -154,7 +154,7 @@ module Tapioca
 
         class << self
           # @override
-          #: -> Enumerable[T::Module[top]]
+          #: -> Enumerable[Module[top]]
           def gather_constants
             all_classes.select { |mod| ::StateMachines::InstanceMethods > mod }
           end

data/lib/tapioca/dsl/compilers/url_helpers.rb

@@ -78,7 +78,7 @@ module Tapioca
       #   include GeneratedUrlHelpersModule
       # end
       # ~~~
-      #: [ConstantType = T::Module[top]]
+      #: [ConstantType = Module[top]]
       class UrlHelpers < Compiler
         # @override
         #: -> void
@@ -96,7 +96,7 @@ module Tapioca
 
         class << self
           # @override
-          #: -> Enumerable[T::Module[top]]
+          #: -> Enumerable[Module[top]]
           def gather_constants
             return [] unless defined?(Rails.application) && Rails.application
 
@@ -128,7 +128,7 @@ module Tapioca
             constants.concat(NON_DISCOVERABLE_INCLUDERS).push(GeneratedUrlHelpersModule, GeneratedPathHelpersModule)
           end
 
-          #: -> Array[T::Module[top]]
+          #: -> Array[Module[top]]
           def gather_non_discoverable_includers
             [].tap do |includers|
               if defined?(ActionController::TemplateAssertions) && defined?(ActionDispatch::IntegrationTest)
@@ -143,7 +143,7 @@ module Tapioca
 
           # Returns `true` if `mod` "directly" includes `helper`.
           # For classes, this method will return false if the `helper` is included only by a superclass
-          #: (T::Module[top] mod, T::Module[top] helper) -> bool
+          #: (Module[top] mod, Module[top] helper) -> bool
           private def includes_helper?(mod, helper)
             ancestors = ancestors_of(mod)
 
@@ -158,11 +158,11 @@ module Tapioca
           end
         end
 
-        NON_DISCOVERABLE_INCLUDERS = gather_non_discoverable_includers #: Array[T::Module[top]]
+        NON_DISCOVERABLE_INCLUDERS = gather_non_discoverable_includers #: Array[Module[top]]
 
         private
 
-        #: (RBI::Tree root, T::Module[top] constant) -> void
+        #: (RBI::Tree root, Module[top] constant) -> void
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -178,7 +178,7 @@ module Tapioca
           end
         end
 
-        #: (RBI::Scope mod, T::Module[top] helper_module) -> void
+        #: (RBI::Scope mod, Module[top] helper_module) -> void
         def create_mixins_for(mod, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/dsl/helpers/graphql_type_helper.rb

@@ -110,7 +110,7 @@ module Tapioca
 
         private
 
-        #: (T::Module[top] constant) -> String
+        #: (Module[top] constant) -> String
         def type_for_constant(constant)
           if constant.instance_methods.include?(:prepare)
             prepare_method = constant.instance_method(:prepare)

data/lib/tapioca/dsl/pipeline.rb

@@ -7,13 +7,13 @@ module Tapioca
       #: Enumerable[singleton(Compiler)]
       attr_reader :active_compilers
 
-      #: Array[T::Module[top]]
+      #: Array[Module[top]]
       attr_reader :requested_constants
 
       #: Array[Pathname]
       attr_reader :requested_paths
 
-      #: Array[T::Module[top]]
+      #: Array[Module[top]]
       attr_reader :skipped_constants
 
       #: ^(String error) -> void
@@ -23,12 +23,12 @@ module Tapioca
       attr_reader :errors
 
       #: (
-      #|   requested_constants: Array[T::Module[top]],
+      #|   requested_constants: Array[Module[top]],
       #|   ?requested_paths: Array[Pathname],
       #|   ?requested_compilers: Array[singleton(Compiler)],
       #|   ?excluded_compilers: Array[singleton(Compiler)],
       #|   ?error_handler: ^(String error) -> void,
-      #|   ?skipped_constants: Array[T::Module[top]],
+      #|   ?skipped_constants: Array[Module[top]],
       #|   ?number_of_workers: Integer?,
       #|   ?compiler_options: Hash[String, untyped],
       #|   ?lsp_addon: bool
@@ -56,7 +56,7 @@ module Tapioca
         @errors = [] #: Array[String]
       end
 
-      #: [R] { (T::Module[top] constant, RBI::File rbi) -> R } -> Array[R]
+      #: [R] { (Module[top] constant, RBI::File rbi) -> R } -> Array[R]
       def run(&blk)
         constants_to_process = gather_constants(requested_constants, requested_paths, skipped_constants)
           .select { |c| Module === c } # Filter value constants out
@@ -128,10 +128,10 @@ module Tapioca
       end
 
       #: (
-      #|   Array[T::Module[top]] requested_constants,
+      #|   Array[Module[top]] requested_constants,
       #|   Array[Pathname] requested_paths,
-      #|   Array[T::Module[top]] skipped_constants
-      #| ) -> Set[T::Module[top]]
+      #|   Array[Module[top]] skipped_constants
+      #| ) -> Set[Module[top]]
       def gather_constants(requested_constants, requested_paths, skipped_constants)
         Compiler.requested_constants = requested_constants
         constants = Set.new.compare_by_identity
@@ -153,7 +153,7 @@ module Tapioca
         constants
       end
 
-      #: (Set[T::Module[top]] constants) -> Set[T::Module[top]]
+      #: (Set[Module[top]] constants) -> Set[Module[top]]
       def filter_anonymous_and_reloaded_constants(constants)
         # Group constants by their names
         constants_by_name = constants
@@ -182,7 +182,7 @@ module Tapioca
         Set.new.compare_by_identity.merge(filtered_constants)
       end
 
-      #: (T::Module[top] constant) -> RBI::File?
+      #: (Module[top] constant) -> RBI::File?
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 

data/lib/tapioca/gem/events.rb

@@ -37,12 +37,12 @@ module Tapioca
 
     class ForeignConstantFound < ConstantFound
       # @override
-      #: -> T::Module[top]
+      #: -> Module[top]
       def constant
         T.cast(@constant, T::Module[T.anything])
       end
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def initialize(symbol, constant)
         super
       end
@@ -53,10 +53,10 @@ module Tapioca
       #: String
       attr_reader :symbol
 
-      #: T::Module[top]
+      #: Module[top]
       attr_reader :constant
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def initialize(symbol, constant)
         super()
         @symbol = symbol
@@ -68,7 +68,7 @@ module Tapioca
       #: RBI::Const
       attr_reader :node
 
-      #: (String symbol, T::Module[top] constant, RBI::Const node) -> void
+      #: (String symbol, Module[top] constant, RBI::Const node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -79,7 +79,7 @@ module Tapioca
       #: RBI::Scope
       attr_reader :node
 
-      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
+      #: (String symbol, Module[top] constant, RBI::Scope node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -103,7 +103,7 @@ module Tapioca
 
       #: (
       #|   String symbol,
-      #|   T::Module[top] constant,
+      #|   Module[top] constant,
       #|   UnboundMethod method,
       #|   RBI::Method node,
       #|   untyped signature,

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

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Documentation < Base
+        IGNORED_COMMENTS = [
+          ":doc:",
+          ":nodoc:",
+          "typed:",
+          "frozen_string_literal:",
+          "encoding:",
+          "warn_indent:",
+          "shareable_constant_value:",
+          "rubocop:",
+          "@requires_ancestor:",
+        ] #: Array[String]
+
+        #: (Pipeline pipeline, Rubydex::Graph gem_graph) -> void
+        def initialize(pipeline, gem_graph)
+          super(pipeline)
+
+          @gem_graph = gem_graph
+        end
+
+        private
+
+        #: (String line) -> bool
+        def rbs_comment?(line)
+          line.start_with?(": ", "| ")
+        end
+
+        # @override
+        #: (ConstNodeAdded event) -> void
+        def on_const(event)
+          event.node.comments = documentation_comments(event.symbol)
+        end
+
+        # @override
+        #: (ScopeNodeAdded event) -> void
+        def on_scope(event)
+          event.node.comments = documentation_comments(event.symbol)
+        end
+
+        # @override
+        #: (MethodNodeAdded event) -> void
+        def on_method(event)
+          name = if event.constant.singleton_class?
+            "#{event.symbol}::<#{event.symbol.split("::").last}>##{event.node.name}()"
+          else
+            "#{event.symbol}##{event.node.name}()"
+          end
+          event.node.comments = documentation_comments(name, sigs: event.node.sigs)
+        end
+
+        #: (String name, ?sigs: Array[RBI::Sig]) -> Array[RBI::Comment]
+        def documentation_comments(name, sigs: [])
+          declaration = @gem_graph[name]
+          # For attr_writer methods (name ending in =), fall back to reader docs
+          if declaration.nil? && name.end_with?("=()")
+            declaration = @gem_graph[name.delete_suffix("=()") + "()"]
+          end
+          # For singleton methods (Class::<Class>#method()), fall back to instance method docs.
+          # This handles module_function and extend self methods which Rubydex indexes
+          # only under the instance method name.
+          if declaration.nil? && name.include?("::<")
+            declaration = @gem_graph[name.sub(/::<[^>]+>#/, "#")]
+          end
+          return [] unless declaration
+
+          comments = declaration.definitions.flat_map(&:comments)
+          comments.uniq!
+          return [] if comments.empty?
+
+          lines = comments
+            .map { |comment| comment.string.gsub(/^#+ ?/, "") }
+            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } || rbs_comment?(line) }
+
+          # Strip leading and trailing blank lines, matching YARD's behavior
+          lines = lines.reverse_each.drop_while(&:empty?).reverse_each.drop_while(&:empty?)
+
+          lines.map! { |line| RBI::Comment.new(line) }
+        end
+
+        # @override
+        #: (NodeAdded event) -> bool
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
+      end
+    end
+  end
+end

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

@@ -25,9 +25,9 @@ module Tapioca
         #: (
         #|   RBI::Tree tree,
         #|   String module_name,
-        #|   T::Module[top] mod,
+        #|   Module[top] mod,
         #|   ?Array[Symbol] for_visibility,
-        #|   ?attached_class: T::Module[top]?
+        #|   ?attached_class: Module[top]?
         #| ) -> void
         def compile_directly_owned_methods(
           tree,
@@ -59,7 +59,7 @@ module Tapioca
         #: (
         #|   RBI::Tree tree,
         #|   String symbol_name,
-        #|   T::Module[top] constant,
+        #|   Module[top] constant,
         #|   UnboundMethod? method,
         #|   ?RBI::Visibility visibility
         #| ) -> void
@@ -169,7 +169,7 @@ module Tapioca
         # This method implements a better way of checking whether a constant defines a method.
         # It walks up the ancestor tree via the `super_method` method; if any of the super
         # methods are owned by the constant, it means that the constant declares the method.
-        #: (UnboundMethod method, T::Module[top] constant) -> bool
+        #: (UnboundMethod method, Module[top] constant) -> bool
         def method_owned_by_constant?(method, constant)
           # Widen the type of `method` to be nilable
           method = method #: UnboundMethod?
@@ -183,7 +183,7 @@ module Tapioca
           false
         end
 
-        #: (T::Module[top] mod) -> Hash[Symbol, Array[Symbol]]
+        #: (Module[top] mod) -> Hash[Symbol, Array[Symbol]]
         def method_names_by_visibility(mod)
           {
             public: public_instance_methods_of(mod),
@@ -192,7 +192,7 @@ module Tapioca
           }
         end
 
-        #: (T::Module[top] constant, String method_name) -> bool
+        #: (Module[top] constant, String method_name) -> bool
         def struct_method?(constant, method_name)
           return false unless T::Props::ClassMethods === constant
 
@@ -202,7 +202,7 @@ module Tapioca
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
-        #: (T::Module[top]? attached_class, Symbol method_name) -> bool?
+        #: (Module[top]? attached_class, Symbol method_name) -> bool?
         def method_new_in_abstract_class?(attached_class, method_name)
           attached_class &&
             method_name == :new &&
@@ -210,7 +210,7 @@ module Tapioca
             Class === attached_class.singleton_class
         end
 
-        #: (T::Module[top] constant) -> UnboundMethod?
+        #: (Module[top] constant) -> UnboundMethod?
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue

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

@@ -30,7 +30,7 @@ module Tapioca
           add_mixins(node, constant, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
         end
 
-        #: (RBI::Tree tree, T::Module[top] constant, Array[T::Module[top]] mods, Runtime::Trackers::Mixin::Type mixin_type) -> void
+        #: (RBI::Tree tree, Module[top] constant, Array[Module[top]] mods, Runtime::Trackers::Mixin::Type mixin_type) -> void
         def add_mixins(tree, constant, mods, mixin_type)
           mods
             .select do |mod|
@@ -57,7 +57,7 @@ module Tapioca
             end
         end
 
-        #: (T::Module[top] constant, T::Module[top] mixin, Runtime::Trackers::Mixin::Type mixin_type) -> bool
+        #: (Module[top] constant, Module[top] mixin, Runtime::Trackers::Mixin::Type mixin_type) -> bool
         def mixed_in_by_gem?(constant, mixin, mixin_type)
           mixin_location = Runtime::Trackers::Mixin.mixin_location(mixin, mixin_type, constant)
 
@@ -73,7 +73,7 @@ module Tapioca
           mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
         end
 
-        #: (T::Module[top] constant) -> Array[T::Module[top]]
+        #: (Module[top] constant) -> Array[Module[top]]
         def interesting_ancestors_of(constant)
           inherited_ancestors = Set.new.compare_by_identity.merge(inherited_ancestors_of(constant))
 

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

@@ -8,8 +8,6 @@ module Tapioca
         include Runtime::Reflection
         include RBIHelper
 
-        TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
-
         private
 
         # @override
@@ -25,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
@@ -42,9 +42,7 @@ module Tapioca
           sig.return_type = return_type
           @pipeline.push_symbol(return_type)
 
-          parameter_types.values.join(", ").scan(TYPE_PARAMETER_MATCHER).flatten.uniq.each do |k, _|
-            sig.type_params << k
-          end
+          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/listeners.rb

@@ -14,5 +14,5 @@ require "tapioca/gem/listeners/sorbet_signatures"
 require "tapioca/gem/listeners/sorbet_type_variables"
 require "tapioca/gem/listeners/subconstants"
 require "tapioca/gem/listeners/foreign_constants"
-require "tapioca/gem/listeners/yard_doc"
+require "tapioca/gem/listeners/documentation"
 require "tapioca/gem/listeners/source_location"

data/lib/tapioca/gem/pipeline.rb

@@ -32,6 +32,7 @@ module Tapioca
 
         @payload_symbols = Static::SymbolLoader.payload_symbols #: Set[String]
         @bootstrap_symbols = load_bootstrap_symbols(@gem) #: Set[String]
+        gem_graph = Static::SymbolLoader.graph_from_paths(@gem.files) if include_doc
 
         @bootstrap_symbols.each { |symbol| push_symbol(symbol) }
 
@@ -46,7 +47,7 @@ module Tapioca
         @node_listeners << Gem::Listeners::SorbetRequiredAncestors.new(self)
         @node_listeners << Gem::Listeners::SorbetSignatures.new(self)
         @node_listeners << Gem::Listeners::Subconstants.new(self)
-        @node_listeners << Gem::Listeners::YardDoc.new(self) if include_doc
+        @node_listeners << Gem::Listeners::Documentation.new(self, gem_graph) if include_doc
         @node_listeners << Gem::Listeners::ForeignConstants.new(self)
         @node_listeners << Gem::Listeners::SourceLocation.new(self) if include_loc
         @node_listeners << Gem::Listeners::RemoveEmptyPayloadScopes.new(self)
@@ -71,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,
@@ -149,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)
 
@@ -175,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
@@ -247,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)
@@ -273,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)
 
@@ -328,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)
@@ -339,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)
@@ -422,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)
@@ -440,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
@@ -453,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))
@@ -465,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
@@ -496,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 =~ /\[.*\]$/
@@ -512,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/gemfile.rb

@@ -177,22 +177,6 @@ module Tapioca
         end
       end
 
-      #: -> void
-      def parse_yard_docs
-        files.each do |path|
-          YARD.parse(path.to_s, [], Logger::Severity::FATAL)
-        rescue RangeError
-          # In some circumstances, YARD will raise an error when parsing a file
-          # that is actually valid Ruby. We don't want tapioca to halt in these
-          # cases, so we'll rescue the error, pretend like there was no
-          # documentation, and move on.
-          #
-          # This can be removed when https://github.com/lsegal/yard/issues/1536
-          # is resolved and released.
-          []
-        end
-      end
-
       #: -> Array[String]
       def exported_rbi_files
         @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi").sort

data/lib/tapioca/helpers/rbi_helper.rb

@@ -94,6 +94,13 @@ module Tapioca
       end
     end
 
+    TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
+
+    #: (Array[String] type_strings) -> Array[String]
+    def extract_type_parameters(type_strings)
+      type_strings.join(", ").scan(TYPE_PARAMETER_MATCHER).flatten.uniq
+    end
+
     #: (String name) -> bool
     def valid_method_name?(name)
       Prism.parse_success?("def self.#{name}(a); end")

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)