tapioca 0.16.9 → 0.17.7

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

@@ -4,18 +4,15 @@
 module Tapioca
   module Gem
     module Listeners
+      # @abstract
       class Base
         extend T::Sig
-        extend T::Helpers
-
-        abstract!
-
-        sig { params(pipeline: Pipeline).void }
+        #: (Pipeline pipeline) -> void
         def initialize(pipeline)
           @pipeline = pipeline
         end
 
-        sig { params(event: NodeAdded).void }
+        #: (NodeAdded event) -> void
         def dispatch(event)
           return if ignore?(event)
 
@@ -33,19 +30,19 @@ module Tapioca
 
         private
 
-        sig { params(event: ConstNodeAdded).void }
+        #: (ConstNodeAdded event) -> void
         def on_const(event)
         end
 
-        sig { params(event: ScopeNodeAdded).void }
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
         end
 
-        sig { params(event: MethodNodeAdded).void }
+        #: (MethodNodeAdded event) -> void
         def on_method(event)
         end
 
-        sig { params(event: NodeAdded).returns(T::Boolean) }
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           # Some listeners do not have to take any action on certain events. For example,
           # almost every listener should skip ForeignScopeNodeAdded events in order not to generate

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           return if constant.is_a?(Class)
@@ -27,7 +28,8 @@ module Tapioca
           end
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           mixin = event.constant
           return if Class === mixin # Classes can't be mixed into other constants
@@ -47,16 +48,13 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            location: String,
-          ).returns(T::Boolean)
-        end
+        #: (String location) -> bool
         def mixed_in_by_gem?(location)
           @pipeline.gem.contains_path?(location)
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -12,7 +12,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           symbol = event.symbol
           constant = event.constant
@@ -23,15 +24,7 @@ module Tapioca
           compile_directly_owned_methods(node, symbol, singleton_class_of(constant), attached_class: constant)
         end
 
-        sig do
-          params(
-            tree: RBI::Tree,
-            module_name: String,
-            mod: Module,
-            for_visibility: T::Array[Symbol],
-            attached_class: T.nilable(Module),
-          ).void
-        end
+        #: (RBI::Tree tree, String module_name, Module mod, ?Array[Symbol] for_visibility, ?attached_class: Module?) -> void
         def compile_directly_owned_methods(
           tree,
           module_name,
@@ -59,29 +52,41 @@ module Tapioca
             end
         end
 
-        sig do
-          params(
-            tree: RBI::Tree,
-            symbol_name: String,
-            constant: Module,
-            method: T.nilable(UnboundMethod),
-            visibility: RBI::Visibility,
-          ).void
-        end
+        #: (RBI::Tree tree, String symbol_name, Module constant, UnboundMethod? method, ?RBI::Visibility visibility) -> void
         def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
           return unless method
           return unless method_owned_by_constant?(method, constant)
-          return if @pipeline.symbol_in_payload?(symbol_name) && !@pipeline.method_in_gem?(method)
 
-          signature = lookup_signature_of(method)
-          method = T.let(signature.method, UnboundMethod) if signature
+          begin
+            signature = signature_of!(method)
+            method = signature.method if signature #: UnboundMethod
+
+            case @pipeline.method_definition_in_gem(method.name, constant)
+            when Pipeline::MethodUnknown
+              # This means that this is a C-method. Thus, we want to
+              # skip it only if the constant is an ignored one, since
+              # that probably means that we've hit a C-method for a
+              # core type.
+              return if @pipeline.symbol_in_payload?(symbol_name)
+            when Pipeline::MethodNotInGem
+              # Do not process this method, if it is not defined by the current gem
+              return
+            end
+          rescue SignatureBlockError => error
+            @pipeline.error_handler.call(<<~MSG)
+              Unable to compile signature for method: #{method.owner}##{method.name}
+                Exception raised when loading signature: #{error.cause.inspect}
+            MSG
+
+            signature = nil
+          end
 
           method_name = method.name.to_s
           return unless valid_method_name?(method_name)
           return if struct_method?(constant, method_name)
           return if method_name.start_with?("__t_props_generated_")
 
-          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+          parameters = method.parameters #: Array[[Symbol, Symbol?]]
 
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
@@ -154,10 +159,10 @@ 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.
-        sig { params(method: UnboundMethod, constant: Module).returns(T::Boolean) }
+        #: (UnboundMethod method, Module constant) -> bool
         def method_owned_by_constant?(method, constant)
           # Widen the type of `method` to be nilable
-          method = T.let(method, T.nilable(UnboundMethod))
+          method = method #: UnboundMethod?
 
           while method
             return true if method.owner == constant
@@ -168,7 +173,7 @@ module Tapioca
           false
         end
 
-        sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+        #: (Module mod) -> Hash[Symbol, Array[Symbol]]
         def method_names_by_visibility(mod)
           {
             public: public_instance_methods_of(mod),
@@ -177,7 +182,7 @@ module Tapioca
           }
         end
 
-        sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+        #: (Module constant, String method_name) -> bool
         def struct_method?(constant, method_name)
           return false unless T::Props::ClassMethods === constant
 
@@ -187,12 +192,7 @@ module Tapioca
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
-        sig do
-          params(
-            attached_class: T.nilable(Module),
-            method_name: Symbol,
-          ).returns(T.nilable(T::Boolean))
-        end
+        #: (Module? attached_class, Symbol method_name) -> bool?
         def method_new_in_abstract_class?(attached_class, method_name)
           attached_class &&
             method_name == :new &&
@@ -200,29 +200,18 @@ module Tapioca
             Class === attached_class.singleton_class
         end
 
-        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
+        #: (Module constant) -> UnboundMethod?
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue
           nil
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end
-
-        sig { params(method: UnboundMethod).returns(T.untyped) }
-        def lookup_signature_of(method)
-          signature_of!(method)
-        rescue LoadError, StandardError => error
-          @pipeline.error_handler.call(<<~MSG)
-            Unable to compile signature for method: #{method.owner}##{method.name}
-              Exception raised when loading signature: #{error.inspect}
-          MSG
-
-          nil
-        end
       end
     end
   end

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           singleton_class = singleton_class_of(constant)
@@ -31,14 +32,7 @@ module Tapioca
           add_mixins(node, constant, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
         end
 
-        sig do
-          params(
-            tree: RBI::Tree,
-            constant: Module,
-            mods: T::Array[Module],
-            mixin_type: Runtime::Trackers::Mixin::Type,
-          ).void
-        end
+        #: (RBI::Tree tree, Module constant, Array[Module] mods, Runtime::Trackers::Mixin::Type mixin_type) -> void
         def add_mixins(tree, constant, mods, mixin_type)
           mods
             .select do |mod|
@@ -65,13 +59,7 @@ module Tapioca
             end
         end
 
-        sig do
-          params(
-            constant: Module,
-            mixin: Module,
-            mixin_type: Runtime::Trackers::Mixin::Type,
-          ).returns(T::Boolean)
-        end
+        #: (Module constant, Module 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)
 
@@ -80,14 +68,14 @@ module Tapioca
           @pipeline.gem.contains_path?(mixin_location)
         end
 
-        sig { params(mixin_name: String).returns(T::Boolean) }
+        #: (String mixin_name) -> bool
         def filtered_mixin?(mixin_name)
           # filter T:: namespace mixins that aren't T::Props
           # T::Props and subconstants have semantic value
           mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
         end
 
-        sig { params(constant: Module).returns(T::Array[Module]) }
+        #: (Module constant) -> Array[Module]
         def interesting_ancestors_of(constant)
           inherited_ancestors = Set.new.compare_by_identity.merge(inherited_ancestors_of(constant))
 

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

@@ -11,12 +11,14 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           event.node.detach if @pipeline.symbol_in_payload?(event.symbol) && event.node.empty?
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -9,7 +9,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           return unless T::Enum > event.constant # rubocop:disable Style/InvertibleUnlessCondition
@@ -24,7 +25,8 @@ module Tapioca
           event.node << enum_block
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           node = event.node
@@ -23,7 +24,8 @@ module Tapioca
           node << RBI::Helper.new("sealed") if sealed_module?(constant)
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -10,7 +10,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           node = event.node
@@ -29,7 +30,8 @@ module Tapioca
           end
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -9,7 +9,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           ancestors = Runtime::Trackers::RequiredAncestor.required_ancestors_by(event.constant)
           ancestors.each do |ancestor|
@@ -19,7 +20,8 @@ module Tapioca
           end
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -14,7 +14,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: MethodNodeAdded).void }
+        # @override
+        #: (MethodNodeAdded event) -> void
         def on_method(event)
           signature = event.signature
           return unless signature
@@ -22,9 +23,9 @@ module Tapioca
           event.node.sigs << compile_signature(signature, event.parameters)
         end
 
-        sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(RBI::Sig) }
+        #: (untyped signature, Array[[Symbol, String]] parameters) -> RBI::Sig
         def compile_signature(signature, parameters)
-          parameter_types = T.let(signature.arg_types.to_h, T::Hash[Symbol, T::Types::Base])
+          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
@@ -64,7 +65,7 @@ module Tapioca
           sig
         end
 
-        sig { params(signature: T.untyped).returns(T::Boolean) }
+        #: (untyped signature) -> bool
         def signature_final?(signature)
           modules_with_final = T::Private::Methods.instance_variable_get(:@modules_with_final)
           # In https://github.com/sorbet/sorbet/pull/7531, Sorbet changed internal hashes to be compared by identity,
@@ -75,7 +76,8 @@ module Tapioca
           final_methods.include?(signature.method_name)
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           node = event.node
@@ -23,7 +24,7 @@ module Tapioca
           node << sclass if sclass.nodes.length > 1
         end
 
-        sig { params(tree: RBI::Tree, constant: Module).void }
+        #: (RBI::Tree tree, Module 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)
@@ -46,7 +47,7 @@ module Tapioca
           tree << RBI::Extend.new("T::Generic")
         end
 
-        sig { params(type_variable: Tapioca::TypeVariableModule).returns(T.nilable(RBI::Node)) }
+        #: (Tapioca::TypeVariableModule type_variable) -> RBI::Node?
         def node_from_type_variable(type_variable)
           case type_variable.type
           when Tapioca::TypeVariableModule::Type::HasAttachedClass
@@ -59,7 +60,8 @@ module Tapioca
           end
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -9,35 +9,42 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ConstNodeAdded).void }
+        # @override
+        #: (ConstNodeAdded event) -> void
         def on_const(event)
           file, line = Object.const_source_location(event.symbol)
           add_source_location_comment(event.node, file, line)
         end
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           # Instead of using `const_source_location`, which always reports the first place where a constant is defined,
           # we filter the locations tracked by ConstantDefinition. This allows us to provide the correct location for
           # constants that are defined by multiple gems.
           locations = Runtime::Trackers::ConstantDefinition.locations_for(event.constant)
           location = locations.find do |loc|
-            Pathname.new(loc.path).realpath.to_s.include?(@pipeline.gem.full_gem_path)
+            Pathname.new(loc.file).realpath.to_s.include?(@pipeline.gem.full_gem_path)
           end
 
           # The location may still be nil in some situations, like constant aliases (e.g.: MyAlias = OtherConst). These
           # are quite difficult to attribute a correct location, given that the source location points to the original
           # constants and not the alias
-          add_source_location_comment(event.node, location.path, location.lineno) unless location.nil?
+          add_source_location_comment(event.node, location.file, location.line) unless location.nil?
         end
 
-        sig { override.params(event: MethodNodeAdded).void }
+        # @override
+        #: (MethodNodeAdded event) -> void
         def on_method(event)
-          file, line = event.method.source_location
-          add_source_location_comment(event.node, file, line)
+          definition = @pipeline.method_definition_in_gem(event.method.name, event.constant)
+
+          if Pipeline::MethodInGemWithLocation === definition
+            loc = definition.location
+            add_source_location_comment(event.node, loc.file, loc.line)
+          end
         end
 
-        sig { params(node: RBI::NodeWithComments, file: T.nilable(String), line: T.nilable(Integer)).void }
+        #: (RBI::NodeWithComments node, String? file, Integer? line) -> void
         def add_source_location_comment(node, file, line)
           return unless file && line
 

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

@@ -11,14 +11,14 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           symbol = event.symbol
-          return if @pipeline.symbol_in_payload?(symbol) && event.node.empty?
+          constant = event.constant
 
           prefix = symbol == "Object" ? "" : symbol
 
-          constant = event.constant
           constants_of(constant).sort.uniq.map do |constant_name|
             name = "#{prefix}::#{constant_name}"
             subconstant = constantize(name)
@@ -32,7 +32,8 @@ module Tapioca
           end
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -7,23 +7,21 @@ module Tapioca
       class YardDoc < Base
         extend T::Sig
 
-        IGNORED_COMMENTS = T.let(
-          [
-            ":doc:",
-            ":nodoc:",
-            "typed:",
-            "frozen_string_literal:",
-            "encoding:",
-            "warn_indent:",
-            "shareable_constant_value:",
-            "rubocop:",
-          ],
-          T::Array[String],
-        )
-
-        IGNORED_SIG_TAGS = T.let(["param", "return"], T::Array[String])
-
-        sig { params(pipeline: Pipeline).void }
+        IGNORED_COMMENTS = [
+          ":doc:",
+          ":nodoc:",
+          "typed:",
+          "frozen_string_literal:",
+          "encoding:",
+          "warn_indent:",
+          "shareable_constant_value:",
+          "rubocop:",
+          "@requires_ancestor:",
+        ] #: Array[String]
+
+        IGNORED_SIG_TAGS = ["param", "return"] #: Array[String]
+
+        #: (Pipeline pipeline) -> void
         def initialize(pipeline)
           YARD::Registry.clear
           super(pipeline)
@@ -32,17 +30,25 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ConstNodeAdded).void }
+        #: (String line) -> bool
+        def rbs_comment?(line)
+          line.strip.start_with?(": ", "| ")
+        end
+
+        # @override
+        #: (ConstNodeAdded event) -> void
         def on_const(event)
           event.node.comments = documentation_comments(event.symbol)
         end
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           event.node.comments = documentation_comments(event.symbol)
         end
 
-        sig { override.params(event: MethodNodeAdded).void }
+        # @override
+        #: (MethodNodeAdded event) -> void
         def on_method(event)
           separator = event.constant.singleton_class? ? "." : "#"
           event.node.comments = documentation_comments(
@@ -51,7 +57,7 @@ module Tapioca
           )
         end
 
-        sig { params(name: String, sigs: T::Array[RBI::Sig]).returns(T::Array[RBI::Comment]) }
+        #: (String name, ?sigs: Array[RBI::Sig]) -> Array[RBI::Comment]
         def documentation_comments(name, sigs: [])
           yard_docs = YARD::Registry.at(name)
           return [] unless yard_docs
@@ -60,7 +66,7 @@ module Tapioca
           return [] if /(copyright|license)/i.match?(docstring)
 
           comments = docstring.lines
-            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } }
+            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } || rbs_comment?(line) }
             .map! { |line| RBI::Comment.new(line) }
 
           tags = yard_docs.tags
@@ -95,7 +101,8 @@ module Tapioca
           comments
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end