tapioca 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 590bba5b82c68fea817819ca7d749a8527cc74915df1989639d6b9a23792f4ac
-  data.tar.gz: 1209c829aca470f50a86db985e3764827c679fca90c312f39daac81b3389d196
+  metadata.gz: e53d805bebee7cb1898eb795daebc5c7f586b5dea934a6056dfc2e1037168e83
+  data.tar.gz: a9baac8cc53cc87f24495961dfe738603900e9818542c722b79211da2aaea84a
 SHA512:
-  metadata.gz: 151fb7e27e03ffaab3a9f7723333154bff8b773d5d98c24e048c726966a2e8c37ea59781d9fc2d445e2b0dd98bbb932461ad525aeb262b97ff56468da693e515
-  data.tar.gz: 81e6a1f2f25ccd489ae50076a3b07082e53cf279375d5dbd5219916591a3c49b743bc022aea97cef5ff7f88fe919e2d5d1a632892a8596fcb5e888032096e7de
+  metadata.gz: 101e3405eb9fbc011e3ddb8ad33a622c74f18cde1d3b6be204aa7840fc7d1f89b1c61e61585cfe9d26c397e67839d09fcd85671c5c0b92f2c8b78741ee4e5ded
+  data.tar.gz: 0a7ad144e5860f72158c194de01213809a5294b69eb2a6de12288d827ca574efdc8937c967ec5c578b1a7c429d4f9e29bd5a1ee6738a373cf4cc57ca2ed8163a

data/README.md

@@ -152,6 +152,8 @@ Options:
           [--verify], [--no-verify]                           # Verify RBIs are up-to-date
           [--doc], [--no-doc]                                 # Include YARD documentation from sources when generating RBIs. Warning: this might be slow
                                                               # Default: true
+          [--loc], [--no-loc]                                 # Include comments with source location when generating RBIs
+                                                              # Default: true
           [--exported-gem-rbis], [--no-exported-gem-rbis]     # Include RBIs found in the `rbi/` directory of the gem
                                                               # Default: true
   -w, [--workers=N]                                           # EXPERIMENTAL: Number of parallel workers to use when generating RBIs
@@ -740,6 +742,8 @@ Options:
                                                    # Default: sorbet/rbi/todo.rbi
       [--payload], [--no-payload]                  # Check shims against Sorbet's payload
                                                    # Default: true
+  -w, [--workers=N]                                # EXPERIMENTAL: Number of parallel workers
+                                                   # Default: 1
   -c, [--config=<config file path>]                # Path to the Tapioca configuration file
                                                    # Default: sorbet/tapioca/config.yml
   -V, [--verbose], [--no-verbose]                  # Verbose output for debugging purposes
@@ -802,6 +806,7 @@ gem:
     activesupport: 'false'
   verify: false
   doc: true
+  loc: true
   exported_gem_rbis: true
   workers: 1
   auto_strictness: true
@@ -815,6 +820,7 @@ check_shims:
   annotations_rbi_dir: sorbet/rbi/annotations
   todo_rbi_file: sorbet/rbi/todo.rbi
   payload: true
+  workers: 1
 annotations:
   sources:
   - https://raw.githubusercontent.com/Shopify/rbi-central/main

data/lib/tapioca/cli.rb

@@ -190,6 +190,10 @@ module Tapioca
       type: :boolean,
       desc: "Include YARD documentation from sources when generating RBIs. Warning: this might be slow",
       default: true
+    option :loc,
+      type: :boolean,
+      desc: "Include comments with source location when generating RBIs",
+      default: true
     option :exported_gem_rbis,
       type: :boolean,
       desc: "Include RBIs found in the `rbi/` directory of the gem",
@@ -233,6 +237,7 @@ module Tapioca
           outpath: Pathname.new(options[:outdir]),
           file_header: options[:file_header],
           include_doc: options[:doc],
+          include_loc: options[:loc],
           include_exported_rbis: options[:exported_gem_rbis],
           number_of_workers: options[:workers],
           auto_strictness: options[:auto_strictness],
@@ -255,7 +260,7 @@ module Tapioca
         end
 
         if gems.empty? && !all
-          command.sync(should_verify: verify)
+          command.sync(should_verify: verify, exclude: options[:exclude])
         else
           command.execute
         end
@@ -270,6 +275,7 @@ module Tapioca
     option :annotations_rbi_dir, type: :string, desc: "Path to annotations RBIs", default: DEFAULT_ANNOTATIONS_DIR
     option :todo_rbi_file, type: :string, desc: "Path to the generated todo RBI file", default: DEFAULT_TODO_FILE
     option :payload, type: :boolean, desc: "Check shims against Sorbet's payload", default: true
+    option :workers, aliases: ["-w"], type: :numeric, desc: "EXPERIMENTAL: Number of parallel workers", default: 1
     def check_shims
       command = Commands::CheckShims.new(
         gem_rbi_dir: options[:gem_rbi_dir],
@@ -277,7 +283,8 @@ module Tapioca
         shim_rbi_dir: options[:shim_rbi_dir],
         annotations_rbi_dir: options[:annotations_rbi_dir],
         todo_rbi_file: options[:todo_rbi_file],
-        payload: options[:payload]
+        payload: options[:payload],
+        number_of_workers: options[:workers]
       )
       command.execute
     end

data/lib/tapioca/commands/annotations.rb

@@ -193,7 +193,8 @@ module Tapioca
           # Please run `#{default_command(:annotations)}` to update it.
         COMMENT
 
-        contents = content.split("\n")
+        # Split contents into newlines and ensure trailing empty lines are included
+        contents = content.split("\n", -1)
         if contents[0]&.start_with?("# typed:") && contents[1]&.empty?
           contents.insert(2, header).join("\n")
         else

data/lib/tapioca/commands/check_shims.rb

@@ -15,10 +15,19 @@ module Tapioca
           annotations_rbi_dir: String,
           shim_rbi_dir: String,
           todo_rbi_file: String,
-          payload: T::Boolean
+          payload: T::Boolean,
+          number_of_workers: T.nilable(Integer)
         ).void
       end
-      def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:)
+      def initialize(
+        gem_rbi_dir:,
+        dsl_rbi_dir:,
+        annotations_rbi_dir:,
+        shim_rbi_dir:,
+        todo_rbi_file:,
+        payload:,
+        number_of_workers:
+      )
         super()
         @gem_rbi_dir = gem_rbi_dir
         @dsl_rbi_dir = dsl_rbi_dir
@@ -26,6 +35,7 @@ module Tapioca
         @shim_rbi_dir = shim_rbi_dir
         @todo_rbi_file = todo_rbi_file
         @payload = payload
+        @number_of_workers = number_of_workers
       end
 
       sig { override.void }
@@ -51,7 +61,7 @@ module Tapioca
                 exit(1)
               end
 
-              index_payload(index, payload_path)
+              index_rbis(index, "payload", payload_path, number_of_workers: @number_of_workers)
             end
           else
             say_error("The version of Sorbet used in your Gemfile.lock does not support `--print=payload-sources`")
@@ -62,10 +72,10 @@ module Tapioca
         end
 
         index_rbi(index, "todo", @todo_rbi_file)
-        index_rbis(index, "shim", @shim_rbi_dir)
-        index_rbis(index, "gem", @gem_rbi_dir)
-        index_rbis(index, "dsl", @dsl_rbi_dir)
-        index_rbis(index, "annotation", @annotations_rbi_dir)
+        index_rbis(index, "shim", @shim_rbi_dir, number_of_workers: @number_of_workers)
+        index_rbis(index, "gem", @gem_rbi_dir, number_of_workers: @number_of_workers)
+        index_rbis(index, "dsl", @dsl_rbi_dir, number_of_workers: @number_of_workers)
+        index_rbis(index, "annotation", @annotations_rbi_dir, number_of_workers: @number_of_workers)
 
         duplicates = duplicated_nodes_from_index(index, shim_rbi_dir: @shim_rbi_dir, todo_rbi_file: @todo_rbi_file)
         unless duplicates.empty?

data/lib/tapioca/commands/gem.rb

@@ -17,6 +17,7 @@ module Tapioca
           outpath: Pathname,
           file_header: T::Boolean,
           include_doc: T::Boolean,
+          include_loc: T::Boolean,
           include_exported_rbis: T::Boolean,
           number_of_workers: T.nilable(Integer),
           auto_strictness: T::Boolean,
@@ -33,6 +34,7 @@ module Tapioca
         outpath:,
         file_header:,
         include_doc:,
+        include_loc:,
         include_exported_rbis:,
         number_of_workers: nil,
         auto_strictness: true,
@@ -58,6 +60,7 @@ module Tapioca
         @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @include_doc = T.let(include_doc, T::Boolean)
+        @include_loc = T.let(include_loc, T::Boolean)
         @include_exported_rbis = include_exported_rbis
       end
 
@@ -94,12 +97,12 @@ module Tapioca
         end
       end
 
-      sig { params(should_verify: T::Boolean).void }
-      def sync(should_verify: false)
+      sig { params(should_verify: T::Boolean, exclude: T::Array[String]).void }
+      def sync(should_verify: false, exclude: [])
         if should_verify
           say("Checking for out-of-date RBIs...")
           say("")
-          perform_sync_verification
+          perform_sync_verification(exclude: exclude)
           return
         end
 
@@ -182,7 +185,7 @@ module Tapioca
           default_command(:gem, gem.name),
           reason: "types exported from the `#{gem.name}` gem",) if @file_header
 
-        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc).compile
+        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis
 
@@ -201,11 +204,13 @@ module Tapioca
         end
       end
 
-      sig { void }
-      def perform_sync_verification
+      sig { params(exclude: T::Array[String]).void }
+      def perform_sync_verification(exclude: [])
         diff = {}
 
         removed_rbis.each do |gem_name|
+          next if exclude.include?(gem_name)
+
           filename = existing_rbi(gem_name)
           diff[filename] = :removed
         end

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

@@ -65,7 +65,7 @@ module Tapioca
       class FrozenRecord < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::FrozenRecord::Base) } }
+        ConstantType = type_member { { fixed: T.all(T.class_of(::FrozenRecord::Base), Extensions::FrozenRecord) } }
 
         sig { override.void }
         def decorate
@@ -97,7 +97,7 @@ module Tapioca
 
         sig { params(record: RBI::Scope).void }
         def decorate_scopes(record)
-          scopes = T.unsafe(constant).__tapioca_scope_names
+          scopes = constant.__tapioca_scope_names
           return if scopes.nil?
 
           module_name = "GeneratedRelationMethods"

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

@@ -38,12 +38,20 @@ module Tapioca
               "::Time"
             when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
               "::ActiveSupport::TimeWithZone"
+            when ActiveRecord::Enum::EnumType
+              "::String"
             else
               handle_unknown_type(column_type)
             end
 
           column = @constant.columns_hash[column_name]
-          setter_type = getter_type
+          setter_type =
+            case column_type
+            when ActiveRecord::Enum::EnumType
+              enum_setter_type(column_type)
+            else
+              getter_type
+            end
 
           if column&.null
             return [as_nilable_type(getter_type), as_nilable_type(setter_type)]
@@ -108,6 +116,16 @@ module Tapioca
 
           first_argument_type.to_s
         end
+
+        sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
+        def enum_setter_type(column_type)
+          case column_type.subtype
+          when ActiveRecord::Type::Integer
+            "T.any(::String, ::Symbol, ::Integer)"
+          else
+            "T.any(::String, ::Symbol)"
+          end
+        end
       end
     end
   end

data/lib/tapioca/gem/events.rb

@@ -105,6 +105,9 @@ module Tapioca
     class MethodNodeAdded < NodeAdded
       extend T::Sig
 
+      sig { returns(UnboundMethod) }
+      attr_reader :method
+
       sig { returns(RBI::Method) }
       attr_reader :node
 
@@ -118,14 +121,16 @@ module Tapioca
         params(
           symbol: String,
           constant: Module,
+          method: UnboundMethod,
           node: RBI::Method,
           signature: T.untyped,
           parameters: T::Array[[Symbol, String]]
         ).void.checked(:never)
       end
-      def initialize(symbol, constant, node, signature, parameters)
+      def initialize(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
         super(symbol, constant)
         @node = node
+        @method = method
         @signature = signature
         @parameters = parameters
       end

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

@@ -134,7 +134,7 @@ module Tapioca
             end
           end
 
-          @pipeline.push_method(symbol_name, constant, rbi_method, signature, sanitized_parameters)
+          @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, sanitized_parameters)
           tree << rbi_method
         end
 

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

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SourceLocation < Base
+        extend T::Sig
+
+        private
+
+        sig { override.params(event: ConstNodeAdded).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 }
+        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)
+          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?
+        end
+
+        sig { override.params(event: MethodNodeAdded).void }
+        def on_method(event)
+          file, line = event.method.source_location
+          add_source_location_comment(event.node, file, line)
+        end
+
+        sig { params(node: RBI::NodeWithComments, file: T.nilable(String), line: T.nilable(Integer)).void }
+        def add_source_location_comment(node, file, line)
+          return unless file && line
+
+          gem = @pipeline.gem
+          path = Pathname.new(file)
+          return unless File.exist?(path)
+
+          path = if path.realpath.to_s.start_with?(gem.full_gem_path)
+            "#{gem.name}-#{gem.version}/#{path.realpath.relative_path_from(gem.full_gem_path)}"
+          else
+            path.sub("#{Bundler.bundle_path}/gems/", "")
+          end
+
+          node.comments << RBI::Comment.new("") if node.comments.any?
+          node.comments << RBI::Comment.new("source://#{path}:#{line}")
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners.rb

@@ -15,3 +15,4 @@ 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/source_location"

data/lib/tapioca/gem/pipeline.rb

@@ -13,8 +13,8 @@ module Tapioca
       sig { returns(Gemfile::GemSpec) }
       attr_reader :gem
 
-      sig { params(gem: Gemfile::GemSpec, include_doc: T::Boolean).void }
-      def initialize(gem, include_doc: false)
+      sig { params(gem: Gemfile::GemSpec, include_doc: T::Boolean, include_loc: T::Boolean).void }
+      def initialize(gem, include_doc: false, include_loc: false)
         @root = T.let(RBI::Tree.new, RBI::Tree)
         @gem = gem
         @seen = T.let(Set.new, T::Set[String])
@@ -40,6 +40,7 @@ module Tapioca
         @node_listeners << Gem::Listeners::Subconstants.new(self)
         @node_listeners << Gem::Listeners::YardDoc.new(self) 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)
       end
 
@@ -87,13 +88,14 @@ module Tapioca
         params(
           symbol: String,
           constant: Module,
+          method: UnboundMethod,
           node: RBI::Method,
           signature: T.untyped,
           parameters: T::Array[[Symbol, String]]
         ).void.checked(:never)
       end
-      def push_method(symbol, constant, node, signature, parameters)
-        @events << Gem::MethodNodeAdded.new(symbol, constant, node, signature, parameters)
+      def push_method(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
+        @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
       end
 
       sig { params(symbol_name: String).returns(T::Boolean) }

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -9,33 +9,33 @@ module Tapioca
     requires_ancestor { Thor::Shell }
     requires_ancestor { SorbetHelper }
 
-    sig { params(index: RBI::Index, dir: String).void }
-    def index_payload(index, dir)
-      return unless Dir.exist?(dir)
-
-      say("Loading Sorbet payload... ")
-      files = Dir.glob("#{dir}/**/*.rbi").sort
-      parse_and_index_files(index, files)
-      say(" Done", :green)
-    end
-
     sig { params(index: RBI::Index, kind: String, file: String).void }
     def index_rbi(index, kind, file)
       return unless File.exist?(file)
 
       say("Loading #{kind} RBIs from #{file}... ")
-      parse_and_index_file(index, file)
-      say(" Done", :green)
+      time = Benchmark.realtime do
+        parse_and_index_files(index, [file], number_of_workers: 1)
+      end
+      say(" Done ", :green)
+      say("(#{time.round(2)}s)")
     end
 
-    sig { params(index: RBI::Index, kind: String, dir: String).void }
-    def index_rbis(index, kind, dir)
+    sig { params(index: RBI::Index, kind: String, dir: String, number_of_workers: T.nilable(Integer)).void }
+    def index_rbis(index, kind, dir, number_of_workers:)
       return unless Dir.exist?(dir) && !Dir.empty?(dir)
 
-      say("Loading #{kind} RBIs from #{dir}... ")
-      files = Dir.glob("#{dir}/**/*.rbi").sort
-      parse_and_index_files(index, files)
-      say(" Done", :green)
+      if kind == "payload"
+        say("Loading Sorbet payload... ")
+      else
+        say("Loading #{kind} RBIs from #{dir}... ")
+      end
+      time = Benchmark.realtime do
+        files = Dir.glob("#{dir}/**/*.rbi").sort
+        parse_and_index_files(index, files, number_of_workers: number_of_workers)
+      end
+      say(" Done ", :green)
+      say("(#{time.round(2)}s)")
     end
 
     sig do
@@ -48,13 +48,16 @@ module Tapioca
     def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:)
       duplicates = {}
       say("Looking for duplicates... ")
-      index.keys.each do |key|
-        nodes = index[key]
-        next unless shims_or_todos_have_duplicates?(nodes, shim_rbi_dir: shim_rbi_dir, todo_rbi_file: todo_rbi_file)
+      time = Benchmark.realtime do
+        index.keys.each do |key|
+          nodes = index[key]
+          next unless shims_or_todos_have_duplicates?(nodes, shim_rbi_dir: shim_rbi_dir, todo_rbi_file: todo_rbi_file)
 
-        duplicates[key] = nodes
+          duplicates[key] = nodes
+        end
       end
-      say(" Done", :green)
+      say(" Done ", :green)
+      say("(#{time.round(2)}s)")
       duplicates
     end
 
@@ -150,19 +153,19 @@ module Tapioca
 
     private
 
-    sig { params(index: RBI::Index, files: T::Array[String]).void }
-    def parse_and_index_files(index, files)
-      files.each do |file|
-        parse_and_index_file(index, file)
+    sig { params(index: RBI::Index, files: T::Array[String], number_of_workers: T.nilable(Integer)).void }
+    def parse_and_index_files(index, files, number_of_workers:)
+      executor = Executor.new(files, number_of_workers: number_of_workers)
+
+      trees = executor.run_in_parallel do |file|
+        next if Spoom::Sorbet::Sigils.file_strictness(file) == "ignore"
+
+        RBI::Parser.parse_file(file)
+      rescue RBI::ParseError => e
+        say_error("\nWarning: #{e} (#{e.location})", :yellow)
       end
-    end
 
-    sig { params(index: RBI::Index, file: String).void }
-    def parse_and_index_file(index, file)
-      tree = RBI::Parser.parse_file(file)
-      index.visit(tree)
-    rescue RBI::ParseError => e
-      say_error("\nWarning: #{e} (#{e.location})", :yellow)
+      index.visit_all(trees)
     end
 
     sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String, todo_rbi_file: String).returns(T::Boolean) }

data/lib/tapioca/helpers/rbi_helper.rb

@@ -93,7 +93,10 @@ module Tapioca
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
-      !name.to_sym.inspect.start_with?(':"', ":@", ":$")
+      name == "==" || !(
+        name.to_sym.inspect.start_with?(':"', ":@", ":$") ||
+        name.delete_suffix("=").to_sym.inspect.start_with?(':"', ":@", ":$")
+      )
     end
 
     sig { params(name: String).returns(T::Boolean) }

data/lib/tapioca/internal.rb

@@ -7,6 +7,7 @@ require "tapioca"
 require "tapioca/runtime/reflection"
 require "tapioca/runtime/trackers"
 
+require "benchmark"
 require "bundler"
 require "erb"
 require "etc"

data/lib/tapioca/runtime/reflection.rb

@@ -158,15 +158,14 @@ module Tapioca
       # Examines the call stack to identify the closest location where a "require" is performed
       # by searching for the label "<top (required)>". If none is found, it returns the location
       # labeled "<main>", which is the original call site.
-      sig { returns(String) }
-      def required_from_location
-        locations = Kernel.caller_locations
+      sig { params(locations: T.nilable(T::Array[Thread::Backtrace::Location])).returns(String) }
+      def resolve_loc(locations)
         return "" unless locations
 
-        required_location = locations.find { |loc| REQUIRED_FROM_LABELS.include?(loc.label) }
-        return "" unless required_location
+        resolved_loc = locations.find { |loc| REQUIRED_FROM_LABELS.include?(loc.label) }
+        return "" unless resolved_loc
 
-        required_location.absolute_path || ""
+        resolved_loc.absolute_path || ""
       end
 
       sig { params(constant: Module).returns(T.nilable(String)) }

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

@@ -17,36 +17,54 @@ module Tapioca
           const :path, String
         end
 
-        @class_files = {}
+        @class_files = {}.compare_by_identity
 
         # Immediately activated upon load. Observes class/module definition.
         TracePoint.trace(:class) do |tp|
-          unless tp.self.singleton_class?
-            key = name_of(tp.self)
-            file = tp.path
-            lineno = tp.lineno
-
-            if file == "(eval)"
-              caller_location = T.must(caller_locations)
-                .drop_while { |loc| loc.path == "(eval)" }
-                .first
-
-              file = caller_location&.path
-              lineno = caller_location&.lineno
-            end
-
-            @class_files[key] ||= Set.new
-            @class_files[key] << ConstantLocation.new(path: T.must(file), lineno: T.must(lineno))
+          next if tp.self.singleton_class?
+
+          key = tp.self
+
+          if tp.path == "(eval)"
+            caller_location = T.must(caller_locations)
+              .drop_while { |loc| loc.path == "(eval)" }
+              .first
+
+            next unless caller_location
+
+            loc = ConstantLocation.new(path: caller_location.absolute_path || "", lineno: caller_location.lineno)
+          else
+            loc = build_constant_location(tp, caller_locations)
           end
+
+          (@class_files[key] ||= Set.new) << loc
+        end
+
+        TracePoint.trace(:c_return) do |tp|
+          next unless tp.method_id == :new
+          next unless Module === tp.return_value
+
+          key = tp.return_value
+          loc = build_constant_location(tp, caller_locations)
+          (@class_files[key] ||= Set.new) << loc
+        end
+
+        def self.build_constant_location(tp, locations)
+          file = resolve_loc(caller_locations)
+          lineno = file == File.realpath(tp.path) ? tp.lineno : 0
+
+          ConstantLocation.new(path: file, lineno: 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.
         def self.files_for(klass)
-          name = String === klass ? klass : name_of(klass)
-          files = @class_files.fetch(name, [])
-          files.map(&:path).to_set
+          locations_for(klass).map(&:path).to_set
+        end
+
+        def self.locations_for(klass)
+          @class_files.fetch(klass, Set.new)
         end
       end
     end

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

@@ -42,7 +42,7 @@ module Tapioca
         def self.register(constant, mixin, mixin_type)
           return unless @enabled
 
-          location = Reflection.required_from_location
+          location = Reflection.resolve_loc(caller_locations)
 
           constants = constants_with_mixin(mixin)
           constants.fetch(mixin_type).store(constant, location)

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -1,18 +1,28 @@
 # typed: true
 # frozen_string_literal: true
 
-# We need sorbet to compile the signature for `qualified_name_of` before applying
-# the patch to avoid an infinite loop.
-T::Utils.signature_for_method(::Tapioca::Runtime::Reflection.method(:qualified_name_of))
-
 module T
   module Types
     class Simple
       module NamePatch
+        NAME_METHOD = T.let(Module.instance_method(:name), UnboundMethod)
+
         def name
           # Sorbet memoizes this method into the `@name` instance variable but
           # doing so means that types get memoized before this patch is applied
-          ::Tapioca::Runtime::Reflection.qualified_name_of(@raw_type)
+          qualified_name_of(@raw_type)
+        end
+
+        def qualified_name_of(constant)
+          name = NAME_METHOD.bind_call(constant)
+          name = nil if name&.start_with?("#<")
+          return if name.nil?
+
+          if name.start_with?("::")
+            name
+          else
+            "::#{name}"
+          end
         end
       end
 

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-07 00:00:00.000000000 Z
+date: 2022-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -224,6 +224,7 @@ files:
 - lib/tapioca/gem/listeners/sorbet_required_ancestors.rb
 - lib/tapioca/gem/listeners/sorbet_signatures.rb
 - 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