tapioca 0.17.1 → 0.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8f3834c7af239f3ba9c26395de29e0abb2b6345d10cc2c18418d9ac3eebb7a4
-  data.tar.gz: ca86a67b0d22cfc65a25e185cc93184e9ee9c94fd8dbb082973978feaf566cb4
+  metadata.gz: 01200af75555809c4d8c6d4fd32cc61bebdfc11e6f4aec27a99f8d13bd51fa66
+  data.tar.gz: b329558753d7784f88bb7afe1f0030c9424d9907c4b0fcc53b669b8caab6ec2a
 SHA512:
-  metadata.gz: 19cd7a29877ae6abbd68d19d6375b3654339fd8b3f5605d0b242db29713401a403cf16c516dfee65e6cbf65b0141d96b3514337d28b0fd612e204524e9a7f3f4
-  data.tar.gz: ab450b1fa72023fdd7daab0df32aa3e435637cceb608545d67c0b98ed9e114b1c56232fac9ba51305c7ddbe300910370d7085cf8bfebf286cd031fcb444bafcb
+  metadata.gz: 77841967e1d02af13ed5a1f2215818f4b63b605c359c26b437f0b6129be1d70dc554666a7aea8710acae812bec4ef422ffc0cd7ae797df87eecb2287f6591352
+  data.tar.gz: 7ad4ccd1a11c2a2abcdaa3b1597dd87b124b5da1d800b61736dbe663d1d5c32219de6f491941139441e790834700e64ac6ded2cedcf0d49e91badfd66d9fe76b

data/README.md

@@ -52,6 +52,9 @@ Tapioca makes it easy to work with [Sorbet](https://sorbet.org) in your codebase
     * [Writing custom DSL extensions](#writing-custom-dsl-extensions)
   * [RBI files for missing constants and methods](#rbi-files-for-missing-constants-and-methods)
   * [Configuration](#configuration)
+* [Editor Integration](#editor-integration)
+  * [Setup](#setup)
+  * [Features](#features)
 * [Contributing](#contributing)
   * [DSL compilers](#dsl-compilers)
 * [License](#license)
@@ -395,6 +398,12 @@ Tapioca also supports pulling annotations from multiple sources:
 $ bin/tapioca annotations --sources https://raw.githubusercontent.com/$USER/$REPO1/$BRANCH https://raw.githubusercontent.com/$USER/$REPO2/$BRANCH
 ```
 
+You can also specify a local directory path to pull annotations from
+
+```shell
+$ bin/tapioca annotations --sources path/to/folder
+```
+
 #### Basic authentication
 
 Private repositories can be used as sources by passing the option `--auth` with an authentication string. For Github, this string is `token $TOKEN` where `$TOKEN` is a [personal access token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token):
@@ -993,6 +1002,18 @@ annotations:
 ```
 <!-- END_CONFIG_TEMPLATE -->
 
+## Editor Integration
+
+### Setup
+
+Tapioca supports generating RBIs upon file changes through the [Ruby LSP's add-on system](https://shopify.github.io/ruby-lsp/#add-ons). It's enabled by default on VS Code using [Ruby LSP](https://shopify.github.io/ruby-lsp/#usage), and you can enable it for other editors by supplying the `enabledFeatureFlags` option in LSP configuration with a hash value of `"tapiocaAddon": true`.
+
+If you'd like to disable the Tapioca add-on you can set `tapiocaAddon` to `false` in your LSP configuration. For VS Code this looks like `"rubyLsp.featureFlags": { "tapiocaAddon": false }` in your `settings.json`.
+
+### Features
+- DSL RBI generation: When editing a Ruby file, Tapioca will execute `bin/tapioca dsl` with the constants found in your file, e.g. `bin/tapioca dsl MyClass`
+- Gem RBI generation: When changes are made to `Gemfile.lock`, Tapioca will execute `bin/tapioca gem` with the updated gem names, e.g. `bin/tapioca gem my_gem`
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/tapioca. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://github.com/Shopify/tapioca/blob/main/CODE_OF_CONDUCT.md) code of conduct.

data/lib/ruby_lsp/tapioca/addon.rb

@@ -18,8 +18,6 @@ require "ruby_lsp/tapioca/run_gem_rbi_check"
 module RubyLsp
   module Tapioca
     class Addon < ::RubyLsp::Addon
-      extend T::Sig
-
       #: -> void
       def initialize
         super
@@ -44,7 +42,7 @@ module RubyLsp
           # Get a handle to the Rails add-on's runtime client. The call to `rails_runner_client` will block this thread
           # until the server has finished booting, but it will not block the main LSP. This has to happen inside of a
           # thread
-          addon = T.cast(::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.4.0", "< 0.5"), ::RubyLsp::Rails::Addon)
+          addon = ::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.4.0", "< 0.5") #: as ::RubyLsp::Rails::Addon
           @rails_runner_client = addon.rails_runner_client
           @outgoing_queue << Notification.window_log_message("Activating Tapioca add-on v#{version}")
           @rails_runner_client.register_server_addon(File.expand_path("server_addon.rb", __dir__))
@@ -93,10 +91,11 @@ module RubyLsp
         has_route_change = false #: bool
         has_fixtures_change = false #: bool
         needs_compiler_reload = false #: bool
+        index = @index #: as !nil
 
         constants = changes.flat_map do |change|
-          path = URI(change[:uri]).to_standardized_path
-          next unless file_updated?(change, path)
+          path = URI(change[:uri]).to_standardized_path #: String?
+          next unless path && file_updated?(change, path)
 
           if File.fnmatch("**/fixtures/**/*.yml{,.erb}", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
             has_fixtures_change = true
@@ -115,7 +114,7 @@ module RubyLsp
             next
           end
 
-          entries = T.must(@index).entries_for(change[:uri])
+          entries = index.entries_for(change[:uri])
           next unless entries
 
           entries.filter_map do |entry|
@@ -178,6 +177,8 @@ module RubyLsp
 
       #: (Hash[Symbol, untyped] change, String path) -> bool
       def file_updated?(change, path)
+        queue = @outgoing_queue #: as !nil
+
         case change[:type]
         when Constant::FileChangeType::CREATED
           @file_checksums[path] = Zlib.crc32(File.read(path)).to_s
@@ -185,7 +186,7 @@ module RubyLsp
         when Constant::FileChangeType::CHANGED
           current_checksum = Zlib.crc32(File.read(path)).to_s
           if @file_checksums[path] == current_checksum
-            T.must(@outgoing_queue) << Notification.window_log_message(
+            queue << Notification.window_log_message(
               "File has not changed. Skipping #{path}",
               type: Constant::MessageType::INFO,
             )
@@ -196,7 +197,7 @@ module RubyLsp
         when Constant::FileChangeType::DELETED
           @file_checksums.delete(path)
         else
-          T.must(@outgoing_queue) << Notification.window_log_message(
+          queue << Notification.window_log_message(
             "Unexpected file change type: #{change[:type]}",
             type: Constant::MessageType::WARNING,
           )
@@ -207,16 +208,16 @@ module RubyLsp
 
       #: -> void
       def run_gem_rbi_check
-        gem_rbi_check = RunGemRbiCheck.new(T.must(@global_state).workspace_path)
+        state = @global_state #: as !nil
+        gem_rbi_check = RunGemRbiCheck.new(state.workspace_path)
         gem_rbi_check.run
 
-        T.must(@outgoing_queue) << Notification.window_log_message(
-          gem_rbi_check.stdout,
-        ) unless gem_rbi_check.stdout.empty?
-        T.must(@outgoing_queue) << Notification.window_log_message(
-          gem_rbi_check.stderr,
-          type: Constant::MessageType::WARNING,
-        ) unless gem_rbi_check.stderr.empty?
+        queue = @outgoing_queue #: as !nil
+        queue << Notification.window_log_message(gem_rbi_check.stdout) unless gem_rbi_check.stdout.empty?
+
+        unless gem_rbi_check.stderr.empty?
+          queue << Notification.window_log_message(gem_rbi_check.stderr, type: Constant::MessageType::WARNING)
+        end
       end
     end
   end

data/lib/ruby_lsp/tapioca/run_gem_rbi_check.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "open3"
@@ -7,10 +7,10 @@ require "ruby_lsp/tapioca/lockfile_diff_parser"
 module RubyLsp
   module Tapioca
     class RunGemRbiCheck
-      extend T::Sig
+      #: String
+      attr_reader :stdout, :stderr
 
-      attr_reader :stdout
-      attr_reader :stderr
+      #: Process::Status?
       attr_reader :status
 
       #: (String project_path) -> void
@@ -34,11 +34,9 @@ module RubyLsp
 
       private
 
-      attr_reader :project_path
-
       #: -> bool?
       def git_repo?
-        _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: project_path)
+        _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: @project_path)
         status.success?
       end
 
@@ -49,7 +47,7 @@ module RubyLsp
 
       #: -> Pathname
       def lockfile
-        @lockfile ||= Pathname(project_path).join("Gemfile.lock") #: Pathname?
+        @lockfile ||= Pathname(@project_path).join("Gemfile.lock") #: Pathname?
       end
 
       #: -> String
@@ -81,15 +79,16 @@ module RubyLsp
       #: (Array[String] gems) -> void
       def execute_tapioca_gem_command(gems)
         Bundler.with_unbundled_env do
-          stdout, stderr, status = T.unsafe(Open3).capture3(
-            "bundle",
-            "exec",
-            "tapioca",
-            "gem",
-            "--lsp_addon",
-            *gems,
-            chdir: project_path,
-          )
+          stdout, stderr, status = Open3 #: as untyped
+            .capture3(
+              "bundle",
+              "exec",
+              "tapioca",
+              "gem",
+              "--lsp_addon",
+              *gems,
+              chdir: @project_path,
+            )
 
           log_message(stdout) unless stdout.empty?
           @stderr = stderr unless stderr.empty?
@@ -101,7 +100,7 @@ module RubyLsp
       def remove_rbis(gems)
         files = Dir.glob(
           "sorbet/rbi/gems/{#{gems.join(",")}}@*.rbi",
-          base: project_path,
+          base: @project_path,
         )
         delete_files(files, "Removed RBIs for")
       end
@@ -117,16 +116,15 @@ module RubyLsp
 
       #: (*untyped flags) -> Array[String]
       def git_ls_gem_rbis(*flags)
-        flags = T.unsafe(["git", "ls-files", *flags, "sorbet/rbi/gems/"])
-
-        execute_in_project_path(*flags)
+        self #: as untyped # rubocop:disable Style/RedundantSelf
+          .execute_in_project_path("git", "ls-files", *flags, "sorbet/rbi/gems/")
           .lines
           .map(&:strip)
       end
 
       #: (Array[String] files, String message) -> void
       def delete_files(files, message)
-        files_to_remove = files.map { |file| File.join(project_path, file) }
+        files_to_remove = files.map { |file| File.join(@project_path, file) }
         FileUtils.rm(files_to_remove)
         log_message("#{message}: #{files.join(", ")}") unless files.empty?
       end
@@ -142,10 +140,12 @@ module RubyLsp
         @stdout += "#{message}\n"
       end
 
+      #: (*String, ?stdin: String?) -> String
       def execute_in_project_path(*parts, stdin: nil)
-        options = { chdir: project_path }
+        options = { chdir: @project_path }
         options[:stdin_data] = stdin if stdin
-        stdout_and_stderr, _status = T.unsafe(Open3).capture2e(*parts, options)
+        stdout_and_stderr, _status = Open3 #: as untyped
+          .capture2e(*parts, options)
         stdout_and_stderr
       end
     end

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

@@ -56,10 +56,30 @@ module Tapioca
         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 = signature.method if signature #: UnboundMethod
+          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)
@@ -192,18 +212,6 @@ module Tapioca
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end
-
-        #: (UnboundMethod method) -> 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/source_location.rb

@@ -24,20 +24,24 @@ module Tapioca
           # 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
 
         # @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
 
         #: (RBI::NodeWithComments node, String? file, Integer? line) -> void

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

@@ -16,6 +16,7 @@ module Tapioca
           "warn_indent:",
           "shareable_constant_value:",
           "rubocop:",
+          "@requires_ancestor:",
         ] #: Array[String]
 
         IGNORED_SIG_TAGS = ["param", "return"] #: Array[String]
@@ -29,6 +30,11 @@ module Tapioca
 
         private
 
+        #: (String line) -> bool
+        def rbs_comment?(line)
+          line.strip.start_with?(": ", "| ")
+        end
+
         # @override
         #: (ConstNodeAdded event) -> void
         def on_const(event)
@@ -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

data/lib/tapioca/gem/pipeline.rb

@@ -107,35 +107,66 @@ module Tapioca
         @payload_symbols.include?(symbol_name)
       end
 
-      # this looks something like:
-      # "(eval at /path/to/file.rb:123)"
-      # and we are just interested in the "/path/to/file.rb" part
-      EVAL_SOURCE_FILE_PATTERN = /\(eval at (.+):\d+\)/ #: Regexp
-
       #: ((String | Symbol) name) -> bool
       def constant_in_gem?(name)
-        return true unless Object.respond_to?(:const_source_location)
+        loc = const_source_location(name)
 
-        source_file, _ = Object.const_source_location(name)
-        return true unless source_file
-        # If the source location of the constant is "(eval)", all bets are off.
-        return true if source_file == "(eval)"
+        # If the source location of the constant isn't available or is "(eval)", all bets are off.
+        return true if loc.nil? || loc.file.nil? || loc.file == "(eval)"
 
-        # Ruby 3.3 adds automatic definition of source location for evals if
-        # `file` and `line` arguments are not provided. This results in the source
-        # file being something like `(eval at /path/to/file.rb:123)`. We try to parse
-        # this string to get the actual source file.
-        source_file = source_file.sub(EVAL_SOURCE_FILE_PATTERN, "\\1")
+        gem.contains_path?(loc.file)
+      end
 
-        gem.contains_path?(source_file)
+      class MethodDefinitionLookupResult
+        extend T::Helpers
+        abstract!
       end
 
-      #: (UnboundMethod method) -> bool
-      def method_in_gem?(method)
-        source_location = method.source_location&.first
-        return false if source_location.nil?
+      # 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
+
+        #: Runtime::SourceLocation
+        attr_reader :location
+
+        #: (Runtime::SourceLocation location) -> void
+        def initialize(location)
+          @location = location
+          super()
+        end
+      end
+
+      #: (Symbol method_name, Module owner) -> MethodDefinitionLookupResult
+      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 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) }
+
+        unless found
+          # If the source location of the method is "(eval)", err on the side of caution and include the method.
+          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 MethodInGemWithoutLocation.new if found
+        end
+
+        # If we searched but couldn't find a source location in the gem, return false to signal that.
+        return MethodNotInGem.new unless found
 
-        @gem.contains_path?(source_location)
+        MethodInGemWithLocation.new(found)
       end
 
       # Helpers

data/lib/tapioca/internal.rb

@@ -16,6 +16,12 @@ require "tapioca/runtime/generic_type_registry"
 
 # The rewriter needs to be loaded very early so RBS comments within Tapioca itself are rewritten
 require "spoom"
+# Eager load all the autoloads at this point, so that we don't enter into
+# a weird loop when the autoloads get triggered and we try to require the file.
+# This is especially important since Prism has a few autoloaded constants that
+# should NOT be rewritten (since they are needed for the rewriting itself), so
+# should be loaded as early as possible.
+Tapioca::Runtime::Trackers::Autoload.eager_load_all!
 require "tapioca/rbs/rewriter"
 # ^ Do not change the order of these requires
 

data/lib/tapioca/rbs/rewriter.rb

@@ -26,7 +26,7 @@ begin
         module InstructionSequenceMixin
           #: (String) -> RubyVM::InstructionSequence
           def load_iseq(path)
-            super
+            super if defined?(super)
           end
         end
       end
@@ -49,7 +49,7 @@ RequireHooks.source_transform(patterns: ["**/*.rb"]) do |path, source|
   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
+rescue Spoom::Sorbet::Translate::Error
   # If we can't translate the RBS comments back into Sorbet's signatures, we just skip the file.
   source
 end

data/lib/tapioca/runtime/reflection.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/runtime/source_location"
+
 # On Ruby 3.2 or newer, Class defines an attached_object method that returns the
 # attached class of a singleton class without iterating ObjectSpace. On older
 # versions of Ruby, we fall back to iterating ObjectSpace.
@@ -125,15 +127,19 @@ module Tapioca
         end
       end
 
+      SignatureBlockError = Class.new(Tapioca::Error)
+
       #: ((UnboundMethod | Method) method) -> untyped
       def signature_of!(method)
         T::Utils.signature_for_method(method)
+      rescue LoadError, StandardError
+        Kernel.raise SignatureBlockError
       end
 
       #: ((UnboundMethod | Method) method) -> untyped
       def signature_of(method)
         signature_of!(method)
-      rescue LoadError, StandardError
+      rescue SignatureBlockError
         nil
       end
 
@@ -169,23 +175,46 @@ module Tapioca
         T.unsafe(result)
       end
 
+      #: ((String | Symbol) constant_name) -> SourceLocation?
+      def const_source_location(constant_name)
+        return unless Object.respond_to?(:const_source_location)
+
+        file, line = Object.const_source_location(constant_name)
+
+        SourceLocation.from_loc([file, line]) if file && line
+      end
+
       # Examines the call stack to identify the closest location where a "require" is performed
       # by searching for the label "<top (required)>" or "block in <class:...>" in the
       # case of an ActiveSupport.on_load hook. If none is found, it returns the location
       # labeled "<main>", which is the original call site.
-      #: (Array[Thread::Backtrace::Location]? locations) -> String
+      #: (Array[Thread::Backtrace::Location]? locations) -> SourceLocation?
       def resolve_loc(locations)
-        return "" unless locations
+        return unless locations
 
+        # Find the location of the closest file load, which should give us the location of the file that
+        # triggered the definition.
         resolved_loc = locations.find do |loc|
           label = loc.label
           next unless label
 
           REQUIRED_FROM_LABELS.include?(label) || label.start_with?("block in <class:")
         end
-        return "" unless resolved_loc
+        return unless resolved_loc
+
+        resolved_loc_path = resolved_loc.absolute_path || resolved_loc.path
+
+        # Find the location of the last frame in this file to get the most accurate line number.
+        resolved_loc = locations.find { |loc| loc.absolute_path == resolved_loc_path }
+        return unless resolved_loc
+
+        # If the last operation was a `require`, and we have no more frames,
+        # we are probably dealing with a C-method.
+        return if locations.first&.label == "require"
+
+        file = resolved_loc.absolute_path || resolved_loc.path || ""
 
-        resolved_loc.absolute_path || ""
+        SourceLocation.from_loc([file, resolved_loc.lineno])
       end
 
       #: (Module constant) -> Set[String]

data/lib/tapioca/runtime/source_location.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    class SourceLocation
+      # this looks something like:
+      # "(eval at /path/to/file.rb:123)"
+      # and we are interested in the "/path/to/file.rb" and "123" parts
+      EVAL_SOURCE_FILE_PATTERN = /^\(eval at (?<file>.+):(?<line>\d+)\)/ #: Regexp
+
+      #: String
+      attr_reader :file
+
+      #: Integer
+      attr_reader :line
+
+      def initialize(file:, line:)
+        # Ruby 3.3 adds automatic definition of source location for evals if
+        # `file` and `line` arguments are not provided. This results in the source
+        # file being something like `(eval at /path/to/file.rb:123)`. We try to parse
+        # this string to get the actual source file.
+        eval_pattern_match = EVAL_SOURCE_FILE_PATTERN.match(file)
+        if eval_pattern_match
+          file = eval_pattern_match[:file]
+          line = eval_pattern_match[:line].to_i
+        end
+
+        @file = file
+        @line = line
+      end
+
+      # force all callers to use the from_loc method
+      private_class_method :new
+
+      class << self
+        #: ([String?, Integer?]? loc) -> SourceLocation?
+        def from_loc(loc)
+          new(file: loc.first, line: loc.last) if loc&.first && loc.last
+        end
+      end
+    end
+  end
+end

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

@@ -43,7 +43,9 @@ module Tapioca
               Kernel.define_method(:abort, NOOP_METHOD)
               Kernel.define_method(:exit, NOOP_METHOD)
 
-              block.call
+              Tapioca.silence_warnings do
+                block.call
+              end
             ensure
               Kernel.define_method(:exit, original_exit)
               Kernel.define_method(:abort, original_abort)

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

@@ -13,12 +13,7 @@ module Tapioca
         extend Reflection
         extend T::Sig
 
-        class ConstantLocation < T::Struct
-          const :lineno, Integer
-          const :path, String
-        end
-
-        @class_files = {}.compare_by_identity
+        @class_files = {}.compare_by_identity #: Hash[Module, Set[SourceLocation]]
 
         # Immediately activated upon load. Observes class/module definition.
         @class_tracepoint = TracePoint.trace(:class) do |tp|
@@ -28,14 +23,17 @@ module Tapioca
 
           path = tp.path
           if File.exist?(path)
-            loc = build_constant_location(tp, caller_locations)
+            loc = build_source_location(tp, caller_locations)
           else
             caller_location = T.must(caller_locations)
               .find { |loc| loc.path && File.exist?(loc.path) }
 
             next unless caller_location
 
-            loc = ConstantLocation.new(path: caller_location.absolute_path || "", lineno: caller_location.lineno)
+            loc = SourceLocation.from_loc([
+              caller_location.absolute_path || "",
+              caller_location.lineno,
+            ])
           end
 
           (@class_files[key] ||= Set.new) << loc
@@ -47,31 +45,37 @@ module Tapioca
           key = tp.return_value
           next unless Module === key
 
-          loc = build_constant_location(tp, caller_locations)
+          loc = build_source_location(tp, caller_locations)
           (@class_files[key] ||= Set.new) << loc
         end
 
         class << self
+          extend T::Sig
+
           def disable!
             @class_tracepoint.disable
             @creturn_tracepoint.disable
             super
           end
 
-          def build_constant_location(tp, locations)
-            file = resolve_loc(locations)
-            lineno = File.identical?(file, tp.path) ? tp.lineno : 0
+          def build_source_location(tp, locations)
+            loc = resolve_loc(locations)
+            file = loc&.file
+            line = loc&.line
+            lineno = file && File.identical?(file, tp.path) ? tp.lineno : (line || 0)
 
-            ConstantLocation.new(path: file, lineno: lineno)
+            SourceLocation.from_loc([file || "", lineno])
           end
 
           # 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.
+          #: (Module klass) -> Set[String]
           def files_for(klass)
-            locations_for(klass).map(&:path).to_set
+            locations_for(klass).map(&:file).to_set
           end
 
+          #: (Module klass) -> Set[SourceLocation]
           def locations_for(klass)
             @class_files.fetch(klass, Set.new)
           end

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module MethodDefinition
+        extend Tracker
+        extend T::Sig
+
+        @method_definitions = {}.compare_by_identity #: Hash[Module, Hash[Symbol, Array[SourceLocation]]]
+
+        class << self
+          #: (Symbol method_name, Module 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.
+            # In those cases, we should skip the registration, as the method's original
+            # definition should already be registered.
+            return if T::Private::DeclState.current.skip_on_method_added
+
+            loc = Reflection.resolve_loc(locations)
+            return unless loc
+
+            registrations_for(method_name, owner) << loc
+          end
+
+          #: (Symbol method_name, Module owner) -> Array[SourceLocation]
+          def method_definitions_for(method_name, owner)
+            definitions = registrations_for(method_name, owner)
+
+            if definitions.empty?
+              source_loc = owner.instance_method(method_name).source_location
+              definitions = [SourceLocation.from_loc(source_loc)].compact
+            end
+
+            definitions
+          end
+
+          private
+
+          #: (Symbol method_name, Module owner) -> Array[SourceLocation]
+          def registrations_for(method_name, owner)
+            owner_lookup = (@method_definitions[owner] ||= {})
+            owner_lookup[method_name] ||= []
+          end
+        end
+      end
+    end
+  end
+end
+
+class Module
+  prepend(Module.new do
+    def singleton_method_added(method_name)
+      Tapioca::Runtime::Trackers::MethodDefinition.register(method_name, singleton_class, caller_locations)
+      super
+    end
+
+    def method_added(method_name)
+      Tapioca::Runtime::Trackers::MethodDefinition.register(method_name, self, caller_locations)
+      super
+    end
+  end)
+end

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

@@ -32,8 +32,9 @@ module Tapioca
             return unless enabled?
 
             location = Reflection.resolve_loc(caller_locations)
+            return unless location
 
-            register_with_location(constant, mixin, mixin_type, location)
+            register_with_location(constant, mixin, mixin_type, location.file)
           end
 
           def resolve_to_attached_class(constant, mixin, mixin_type)

data/lib/tapioca/runtime/trackers.rb

@@ -52,3 +52,4 @@ require "tapioca/runtime/trackers/mixin"
 require "tapioca/runtime/trackers/constant_definition"
 require "tapioca/runtime/trackers/autoload"
 require "tapioca/runtime/trackers/required_ancestor"
+require "tapioca/runtime/trackers/method_definition"

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.17.2
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -281,9 +281,11 @@ files:
 - lib/tapioca/runtime/dynamic_mixin_compiler.rb
 - lib/tapioca/runtime/generic_type_registry.rb
 - lib/tapioca/runtime/reflection.rb
+- lib/tapioca/runtime/source_location.rb
 - lib/tapioca/runtime/trackers.rb
 - lib/tapioca/runtime/trackers/autoload.rb
 - lib/tapioca/runtime/trackers/constant_definition.rb
+- lib/tapioca/runtime/trackers/method_definition.rb
 - lib/tapioca/runtime/trackers/mixin.rb
 - lib/tapioca/runtime/trackers/required_ancestor.rb
 - lib/tapioca/runtime/trackers/tracker.rb