tapioca 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92e743973e21c5d863f898255a4ccfcf620deea13cbb4807d43ad0c58085285e
-  data.tar.gz: 4a8e05c974c11d4d201e1f2342e1769260a63ceaff18d54a71167dd929f6f23a
+  metadata.gz: 212af3a2ba5204b2aa479e52acddf879f32755faaee95691ce51e5c26b306481
+  data.tar.gz: e8f957c96874e08fed7cce1580ac110c41bef0853c6f52f2e46c90bb6435bfe8
 SHA512:
-  metadata.gz: 92b8a9e0306b22869147b1f0a3912f6fb88e3583e54caab6dbc37450996d15046ae049bea5fcfd46090575e94c7b4b16ff4ca833b63fdc125b30601211a2603e
-  data.tar.gz: d76e8b15e040f6fe60cb940ef3654dffd45eaf3edaaa563a6404a178014bc767866c5668d0dc2560610e75adb5034ac6ae0c94d19d6fa1c5d4812c5769a78a74
+  metadata.gz: fe339f96a20827fd80cb4134ccfcb258319ea43017f8b0f98170792e8732e464e468efeed7f7c0092fb095fff1e62e2f79f51113bbc6cff78e45b9cf288febc3
+  data.tar.gz: dafe9aeaa6118b98c1c4a5e40064a55aacf7bc883d9ffb406bca0edd8bfecacb52b7f1f0c898bb8b09fa2c3101c9a88e3ba812fbbd3f71c15837fb110b241e69

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,14 +275,18 @@ 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
+      Tapioca.disable_traces
+
       command = Commands::CheckShims.new(
         gem_rbi_dir: options[:gem_rbi_dir],
         dsl_rbi_dir: options[:dsl_rbi_dir],
         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
@@ -296,8 +305,7 @@ module Tapioca
       default: {}
     def annotations
       if !options[:netrc] && options[:netrc_file]
-        say_error("Options `--no-netrc` and `--netrc-file` can't be used together", :bold, :red)
-        exit(1)
+        raise Thor::Error, set_color("Options `--no-netrc` and `--netrc-file` can't be used together", :bold, :red)
       end
 
       command = Commands::Annotations.new(

data/lib/tapioca/commands/annotations.rb

@@ -88,8 +88,7 @@ module Tapioca
         end
 
         if indexes.empty?
-          say_error("\nCan't fetch annotations without sources (no index fetched)", :bold, :red)
-          exit(1)
+          raise Thor::Error, set_color("Can't fetch annotations without sources (no index fetched)", :bold, :red)
         end
 
         indexes
@@ -112,12 +111,15 @@ module Tapioca
         fetchable_gems = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
 
         gem_names.each_with_object(fetchable_gems) do |gem_name, hash|
-          @indexes.each { |uri, index| T.must(hash[gem_name]) << uri if index.has_gem?(gem_name) }
+          @indexes.each do |uri, index|
+            T.must(hash[gem_name]) << uri if index.has_gem?(gem_name)
+          end
         end
 
         if fetchable_gems.empty?
           say(" Nothing to do")
-          exit(0)
+
+          return []
         end
 
         say("\n")
@@ -193,7 +195,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 }
@@ -34,7 +44,8 @@ module Tapioca
 
         if (!Dir.exist?(@shim_rbi_dir) || Dir.empty?(@shim_rbi_dir)) && !File.exist?(@todo_rbi_file)
           say("No shim RBIs to check", :green)
-          exit(0)
+
+          return
         end
 
         payload_path = T.let(nil, T.nilable(String))
@@ -46,45 +57,55 @@ module Tapioca
               result = sorbet("--no-config --print=payload-sources:#{payload_path}")
 
               unless result.status
-                say_error("Sorbet failed to dump payload")
-                say_error(result.err)
-                exit(1)
+                raise Thor::Error, <<~ERROR
+                  "Sorbet failed to dump payload"
+                  #{result.err}
+                ERROR
               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`")
-            say_error("Current: v#{SORBET_GEM_SPEC.version}")
-            say_error("Required: #{FEATURE_REQUIREMENTS[:print_payload_sources]}")
-            exit(1)
+            raise Thor::Error, <<~ERROR
+              The version of Sorbet used in your Gemfile.lock does not support `--print=payload-sources`
+              Current: v#{SORBET_GEM_SPEC.version}
+              Required: #{FEATURE_REQUIREMENTS[:print_payload_sources]}
+            ERROR
           end
         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?
+          messages = []
+
           duplicates.each do |key, nodes|
-            say_error("\nDuplicated RBI for #{key}:", :red)
+            messages << set_color("\nDuplicated RBI for #{key}:", :red)
+
             nodes.each do |node|
               node_loc = node.loc
+
               next unless node_loc
 
               loc_string = location_to_payload_url(node_loc, path_prefix: payload_path)
-              say_error(" * #{loc_string}", :red)
+              messages << set_color(" * #{loc_string}", :red)
             end
           end
-          say_error("\nPlease remove the duplicated definitions from #{@shim_rbi_dir} and #{@todo_rbi_file}", :red)
-          exit(1)
+
+          messages << set_color(
+            "\nPlease remove the duplicated definitions from #{@shim_rbi_dir} and #{@todo_rbi_file}", :red
+          )
+
+          raise Thor::Error, messages.join("\n")
         end
 
         say("\nNo duplicates found in shim RBIs", :green)
-        exit(0)
       end
     end
   end

data/lib/tapioca/commands/dsl.rb

@@ -191,6 +191,7 @@ module Tapioca
         end
 
         unprocessable_constants = constant_map.select { |_, v| v.nil? }
+
         unless unprocessable_constants.empty?
           unprocessable_constants.each do |name, _|
             say("Error: Cannot find constant '#{name}'", :red)
@@ -198,7 +199,7 @@ module Tapioca
             remove_file(filename) if File.file?(filename)
           end
 
-          exit(1)
+          raise Thor::Error, ""
         end
 
         constant_map.values
@@ -211,12 +212,13 @@ module Tapioca
         end
 
         unprocessable_compilers = compiler_map.select { |_, v| v.nil? }
+
         unless unprocessable_compilers.empty?
-          unprocessable_compilers.each do |name, _|
-            say("Error: Cannot find compiler '#{name}'", :red)
-          end
+          message = unprocessable_compilers.map do |name, _|
+            set_color("Error: Cannot find compiler '#{name}'", :red)
+          end.join("\n")
 
-          exit(1)
+          raise Thor::Error, message
         end
 
         T.cast(compiler_map.values, T::Array[T.class_of(Tapioca::Dsl::Compiler)])
@@ -332,18 +334,18 @@ module Tapioca
         if diff.empty?
           say("Nothing to do, all RBIs are up-to-date.")
         else
-          say("RBI files are out-of-date. In your development environment, please run:", :green)
-          say("  `#{default_command(command)}`", [:green, :bold])
-          say("Once it is complete, be sure to commit and push any changes", :green)
-
-          say("")
-
-          say("Reason:", [:red])
-          diff.group_by(&:last).sort.each do |cause, diff_for_cause|
-            say(build_error_for_files(cause, diff_for_cause.map(&:first)))
-          end
-
-          exit(1)
+          reasons = diff.group_by(&:last).sort.map do |cause, diff_for_cause|
+            build_error_for_files(cause, diff_for_cause.map(&:first))
+          end.join("\n")
+
+          raise Thor::Error, <<~ERROR
+            #{set_color("RBI files are out-of-date. In your development environment, please run:", :green)}
+              #{set_color("`#{default_command(command)}`", [:green, :bold])}
+            #{set_color("Once it is complete, be sure to commit and push any changes", :green)}
+
+            #{set_color("Reason:", :red)}
+            #{reasons}
+          ERROR
         end
       end
 

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
 
@@ -163,11 +166,12 @@ module Tapioca
         return bundle.dependencies if gem_names.empty?
 
         gem_names.map do |gem_name|
-          gem = bundle.gem(gem_name)
+          gem = @bundle.gem(gem_name)
+
           if gem.nil?
-            say("Error: Cannot find gem '#{gem_name}'", :red)
-            exit(1)
+            raise Thor::Error, set_color("Error: Cannot find gem '#{gem_name}'", :red)
           end
+
           gem
         end
       end
@@ -182,7 +186,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 +205,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
@@ -325,18 +331,18 @@ module Tapioca
         if diff.empty?
           say("Nothing to do, all RBIs are up-to-date.")
         else
-          say("RBI files are out-of-date. In your development environment, please run:", :green)
-          say("  `#{default_command(command)}`", [:green, :bold])
-          say("Once it is complete, be sure to commit and push any changes", :green)
-
-          say("")
-
-          say("Reason:", [:red])
-          diff.group_by(&:last).sort.each do |cause, diff_for_cause|
-            say(build_error_for_files(cause, diff_for_cause.map(&:first)))
-          end
-
-          exit(1)
+          reasons = diff.group_by(&:last).sort.map do |cause, diff_for_cause|
+            build_error_for_files(cause, diff_for_cause.map(&:first))
+          end.join("\n")
+
+          raise Thor::Error, <<~ERROR
+            #{set_color("RBI files are out-of-date. In your development environment, please run:", :green)}
+              #{set_color("`#{default_command(command)}`", [:green, :bold])}
+            #{set_color("Once it is complete, be sure to commit and push any changes", :green)}
+
+            #{set_color("Reason:", :red)}
+            #{reasons}
+          ERROR
         end
       end
 

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

@@ -42,13 +42,12 @@ module Tapioca
 
         sig { override.void }
         def decorate
-          method_names = fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
-            .drop(1) # drop the anonymous class itself from the array
-            .reject(&:name) # only collect anonymous ancestors because fixture methods are always on an anonymous module
-            .map! do |mod|
-              [mod.private_instance_methods(false), mod.instance_methods(false)]
-            end
-            .flatten # merge methods into a single list
+          method_names = if fixture_loader.respond_to?(:fixture_sets)
+            method_names_from_lazy_fixture_loader
+          else
+            method_names_from_eager_fixture_loader
+          end
+
           return if method_names.empty?
 
           root.create_path(constant) do |mod|
@@ -69,11 +68,27 @@ module Tapioca
 
         sig { returns(Class) }
         def fixture_loader
-          Class.new do
+          @fixture_loader ||= T.let(Class.new do
             T.unsafe(self).include(ActiveRecord::TestFixtures)
             T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
             T.unsafe(self).fixtures(:all)
-          end
+          end, T.nilable(Class))
+        end
+
+        sig { returns(T::Array[String]) }
+        def method_names_from_lazy_fixture_loader
+          T.unsafe(fixture_loader).fixture_sets.keys
+        end
+
+        sig { returns(T::Array[Symbol]) }
+        def method_names_from_eager_fixture_loader
+          fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
+            .drop(1) # drop the anonymous class itself from the array
+            .reject(&:name) # only collect anonymous ancestors because fixture methods are always on an anonymous module
+            .map! do |mod|
+              [mod.private_instance_methods(false), mod.instance_methods(false)]
+            end
+            .flatten # merge methods into a single list
         end
 
         sig { params(mod: RBI::Scope, name: String).void }

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/compilers/protobuf.rb

@@ -60,6 +60,14 @@ module Tapioca
       #   def number_value=(value); end
       # end
       # ~~~
+      #
+      # Please note that you might have to ignore the originally generated Protobuf Ruby files
+      # to avoid _Redefining constant_ issues when doing type checking.
+      # Do this by extending your Sorbet config file:
+      #
+      # ~~~
+      # --ignore=/path/to/proto/cart_pb.rb
+      # ~~~
       class Protobuf < Compiler
         class Field < T::Struct
           prop :name, String

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,17 @@ module Tapioca
 
           first_argument_type.to_s
         end
+
+        sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
+        def enum_setter_type(column_type)
+          # In Rails < 7 this method is private. When support for that is dropped we can call the method directly
+          case column_type.send(: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,67 @@
+# 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)
+
+          # On native extensions, the source location may point to a shared object (.so, .bundle) file, which we cannot
+          # use for jump to definition. Only add source comments on Ruby files
+          return unless path.extname == ".rb"
+
+          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/", "").to_s
+          end
+
+          # Strip out the RUBY_ROOT prefix, which is different for each user
+          path = path.sub(RbConfig::CONFIG["rubylibdir"], "RUBY_ROOT")
+
+          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) }
@@ -353,7 +355,7 @@ module Tapioca
       def get_file_candidates(constant)
         wrapped_module = Pry::WrappedModule.new(constant)
 
-        wrapped_module.candidates.map(&:file).to_a.compact
+        wrapped_module.send(:method_candidates).flatten.filter_map(&:source_file).uniq
       rescue ArgumentError, NameError
         []
       end

data/lib/tapioca/helpers/config_helper.rb

@@ -86,8 +86,7 @@ module Tapioca
       end.compact
 
       unless errors.empty?
-        print_errors(config_file, errors)
-        exit(1)
+        raise Thor::Error, build_error_message(config_file, errors)
       end
     ensure
       @validating_config = false
@@ -173,18 +172,19 @@ module Tapioca
       )
     end
 
-    sig { params(config_file: String, errors: T::Array[ConfigError]).void }
-    def print_errors(config_file, errors)
-      say_error("\nConfiguration file ", :red)
-      say_error("#{config_file} ", :blue, :bold)
-      say_error("has the following errors:\n\n", :red)
+    sig { params(config_file: String, errors: T::Array[ConfigError]).returns(String) }
+    def build_error_message(config_file, errors)
+      error_messages = errors.map do |error|
+        "- " + error.message_parts.map do |part|
+          T.unsafe(self).set_color(part.message, *part.colors)
+        end.join
+      end.join("\n")
 
-      errors.each do |error|
-        say_error("- ")
-        error.message_parts.each do |part|
-          T.unsafe(self).say_error(part.message, *part.colors)
-        end
-      end
+      <<~ERROR
+        #{set_color("\nConfiguration file", :red)} #{set_color(config_file, :blue, :bold)} #{set_color("has the following errors:", :red)}
+
+        #{error_messages}
+      ERROR
     end
 
     sig do

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
 
@@ -97,14 +100,16 @@ module Tapioca
 
       if errors.empty?
         say("  No errors found\n\n", [:green, :bold])
+
         return
       end
 
       parse_errors = errors.select { |error| error.code < 4000 }
 
-      if parse_errors.any?
-        say_error(<<~ERR, :red)
+      error_messages = []
 
+      if parse_errors.any?
+        error_messages << set_color(<<~ERR, :red)
           ##### INTERNAL ERROR #####
 
           There are parse errors in the generated RBI files.
@@ -116,27 +121,23 @@ module Tapioca
 
           Command:
             #{command}
-
         ERR
 
-        say_error(<<~ERR, :red) if gems.any?
+        error_messages << set_color(<<~ERR, :red) if gems.any?
           Gems:
           #{gems.map { |gem| "  #{gem.name} (#{gem.version})" }.join("\n")}
-
         ERR
 
-        say_error(<<~ERR, :red) if compilers.any?
+        error_messages << set_color(<<~ERR, :red) if compilers.any?
           Compilers:
           #{compilers.map { |compiler| "  #{compiler.name}" }.join("\n")}
-
         ERR
 
-        say_error(<<~ERR, :red)
+        error_messages << set_color(<<~ERR, :red)
           Errors:
           #{parse_errors.map { |error| "  #{error}" }.join("\n")}
 
           ##########################
-
         ERR
       end
 
@@ -145,26 +146,24 @@ module Tapioca
         update_gem_rbis_strictnesses(redef_errors, gem_dir)
       end
 
-      Kernel.exit(1) if parse_errors.any?
+      Kernel.raise Thor::Error, error_messages.join("\n") if parse_errors.any?
     end
 
     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)
-      end
-    end
+    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)
 
-    sig { params(index: RBI::Index, file: String).void }
-    def parse_and_index_file(index, file)
-      return if Spoom::Sorbet::Sigils.file_strictness(file) == "ignore"
+      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
 
-      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,15 +93,36 @@ module Tapioca
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
-      name == "==" || !(
-        name.to_sym.inspect.start_with?(':"', ":@", ":$") ||
-        name.delete_suffix("=").to_sym.inspect.start_with?(':"', ":@", ":$")
-      )
+      # try to parse a method definition with this name
+      iseq = RubyVM::InstructionSequence.compile("def #{name}; end", nil, nil, 0, false)
+      # pull out the first operation in the instruction sequence and its first argument
+      op, arg, _data = iseq.to_a.dig(-1, 0)
+      # make sure that the operation is a method definition and the method that was
+      # defined has the expected name, for example, for `def !foo; end` we don't get
+      # a syntax error but instead get a method defined as `"foo"`
+      op == :definemethod && arg == name.to_sym
+    rescue SyntaxError
+      false
     end
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_parameter_name?(name)
-      /^([[:lower:]]|_|[^[[:ascii:]]])([[:alnum:]]|_|[^[[:ascii:]]])*$/.match?(name)
+      sentinel_method_name = :sentinel_method_name
+      # try to parse a method definition with this name as the name of a
+      # keyword parameter. If we use a positional parameter, then parameter names
+      # like `&` (and maybe others) will be treated like `def foo(&); end` and will
+      # thus be considered valid. Using a required keyword parameter prevents that
+      # confusion between Ruby syntax and parameter name.
+      iseq = RubyVM::InstructionSequence.compile("def #{sentinel_method_name}(#{name}:); end", nil, nil, 0, false)
+      # pull out the first operation in the instruction sequence and its first argument and data
+      op, arg, data = iseq.to_a.dig(-1, 0)
+      # make sure that:
+      # 1. a method was defined, and
+      # 2. the method has the expected method name, and
+      # 3. the method has a keyword parameter with the expected name
+      op == :definemethod && arg == sentinel_method_name && data.dig(11, :keyword, 0) == name.to_sym
+    rescue SyntaxError
+      false
     end
   end
 end

data/lib/tapioca/helpers/test/template.rb

@@ -19,6 +19,11 @@ module Tapioca
           ::Gem::Requirement.new(selector).satisfied_by?(::Gem::Version.new(RUBY_VERSION))
         end
 
+        sig { params(selector: String).returns(T::Boolean) }
+        def rails_version(selector)
+          ::Gem::Requirement.new(selector).satisfied_by?(ActiveSupport.gem_version)
+        end
+
         sig { params(src: String).returns(String) }
         def template(src)
           erb = if ERB_SUPPORTS_KVARGS

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"
@@ -33,6 +34,7 @@ require "tapioca/helpers/rbi_helper"
 require "tapioca/sorbet_ext/fixed_hash_patch"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"
+require "tapioca/sorbet_ext/proc_bind_patch"
 require "tapioca/runtime/generic_type_registry"
 
 require "tapioca/helpers/cli_helper"

data/lib/tapioca/runtime/loader.rb

@@ -6,6 +6,7 @@ module Tapioca
     class Loader
       extend(T::Sig)
       include Tapioca::GemHelper
+      include Thor::Base
 
       sig do
         params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void
@@ -29,12 +30,17 @@ module Tapioca
         silence_deprecations
 
         if environment_load
-          safe_require("./config/environment")
+          require "./config/environment"
         else
-          safe_require("./config/application")
+          require "./config/application"
         end
 
         eager_load_rails_app if eager_load
+      rescue LoadError, StandardError => e
+        say("Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
+          "but it failed. If your application uses Rails please ensure it can be loaded correctly before generating " \
+          "RBIs.\n#{e}", :yellow)
+        say("Continuing RBI generation without loading the Rails application.")
       end
 
       private

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(singleton_class: Module).returns(T.nilable(Module)) }

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))
+        Tapioca.register_trace(:class) do |tp|
+          next if tp.self.singleton_class?
+
+          key = tp.self
+
+          path = tp.path
+          if File.exist?(path)
+            loc = build_constant_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)
           end
+
+          (@class_files[key] ||= Set.new) << loc
+        end
+
+        Tapioca.register_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/sorbet_ext/proc_bind_patch.rb

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module T
+  module Types
+    module ProcBindPatch
+      def initialize(arg_types, returns, bind = T::Private::Methods::ARG_NOT_PROVIDED)
+        super(arg_types, returns)
+
+        unless bind == T::Private::Methods::ARG_NOT_PROVIDED
+          @bind = T.let(T::Utils.coerce(bind), T::Types::Base)
+        end
+      end
+
+      def name
+        name = super
+        name = name.sub("T.proc", "T.proc.bind(#{@bind})") unless @bind.nil?
+        name
+      end
+    end
+
+    Proc.prepend(ProcBindPatch)
+  end
+end
+
+module T
+  module Private
+    module Methods
+      module ProcBindPatch
+        def finalize_proc(decl)
+          super
+
+          T.unsafe(T::Types::Proc).new(decl.params, decl.returns, decl.bind)
+        end
+      end
+
+      singleton_class.prepend(ProcBindPatch)
+    end
+  end
+end

data/lib/tapioca/version.rb

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

data/lib/tapioca.rb

@@ -6,6 +6,18 @@ require "sorbet-runtime"
 module Tapioca
   extend T::Sig
 
+  @traces = T.let([], T::Array[TracePoint])
+
+  sig { params(trace_name: Symbol, block: T.proc.params(arg0: TracePoint).void).void }
+  def self.register_trace(trace_name, &block)
+    @traces << TracePoint.trace(trace_name, &block)
+  end
+
+  sig { void }
+  def self.disable_traces
+    @traces.each(&:disable)
+  end
+
   sig do
     type_parameters(:Result)
       .params(blk: T.proc.returns(T.type_parameter(:Result)))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-19 00:00:00.000000000 Z
+date: 2022-08-22 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
@@ -255,6 +256,7 @@ files:
 - lib/tapioca/sorbet_ext/fixed_hash_patch.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
+- lib/tapioca/sorbet_ext/proc_bind_patch.rb
 - lib/tapioca/static/requires_compiler.rb
 - lib/tapioca/static/symbol_loader.rb
 - lib/tapioca/static/symbol_table_parser.rb