Use inheritence to better signal what the return value of method_definition_in_gem will be

Author: paracycle

lib/tapioca/gem/listeners/methods.rb

@@ -77,13 +77,13 @@ def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public
             method = T.let(signature.method, UnboundMethod) if signature
 
             case @pipeline.method_definition_in_gem(method.name, constant)
-            when nil
+            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 false
+            when Pipeline::MethodNotInGem
               # Do not process this method, if it is not defined by the current gem
               return
             end

lib/tapioca/gem/listeners/source_location.rb

@@ -35,9 +35,7 @@ def on_scope(event)
         def on_method(event)
           definition = @pipeline.method_definition_in_gem(event.method.name, event.constant)
 
-          case definition
-          when NilClass, FalseClass, TrueClass
-          else
+          if Pipeline::MethodInGemWithLocation === definition
             loc = definition.location
             add_source_location_comment(event.node, loc.file, loc.line)
           end

lib/tapioca/gem/pipeline.rb

@@ -136,12 +136,45 @@ def constant_in_gem?(name)
         gem.contains_path?(loc.file)
       end
 
-      sig { params(method_name: Symbol, owner: Module).returns(T.any([String, Integer], NilClass, T::Boolean)) }
+      class MethodDefinitionLookupResult
+        extend T::Helpers
+        abstract!
+      end
+
+      # The method doesn't seem to exist
+      class MethodUnknown < MethodDefinitionLookupResult; end
+
+      # The method is not defined in the gem
+      class MethodNotInGem < MethodDefinitionLookupResult; end
+
+      # The method probably defined in the gem but doesn't have a source location
+      class MethodInGemWithoutLocation < MethodDefinitionLookupResult; end
+
+      # The method defined in gem and has a source location
+      class MethodInGemWithLocation < MethodDefinitionLookupResult
+        extend T::Sig
+
+        sig { returns(Runtime::SourceLocation) }
+        attr_reader :location
+
+        sig { params(location: Runtime::SourceLocation).void }
+        def initialize(location)
+          @location = location
+          super()
+        end
+      end
+
+      sig do
+        params(
+          method_name: Symbol,
+          owner: Module,
+        ).returns(MethodDefinitionLookupResult)
+      end
       def method_definition_in_gem(method_name, owner)
         definitions = Tapioca::Runtime::Trackers::MethodDefinition.method_definitions_for(method_name, owner)
 
         # If the source location of the method isn't available, signal that by returning nil.
-        return if definitions.empty?
+        return MethodUnknown.new if definitions.empty?
 
         # Look up the first entry that matches a file in the gem.
         found = definitions.find { |loc| @gem.contains_path?(loc.file) }
@@ -151,13 +184,13 @@ def method_definition_in_gem(method_name, owner)
           found = definitions.find { |loc| loc.file == "(eval)" }
           # However, we can just return true to signal that the method should be included.
           # We can't provide a source location for it, but we want it to be included in the gem RBI.
-          return true if found
+          return MethodInGemWithoutLocation.new if found
         end
 
         # If we searched but couldn't find a source location in the gem, return false to signal that.
-        return false unless found
+        return MethodNotInGem.new unless found
 
-        found
+        MethodInGemWithLocation.new(found)
       end
 
       # Helpers