tapioca 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9cda50b7996366aafe00f6b8643f17385088e842c9626c23b922202702d8ee4
-  data.tar.gz: 040d9732ca74f020d475c3965392b63c2b9a525876cfd765b2c21fa0d031df54
+  metadata.gz: 92e743973e21c5d863f898255a4ccfcf620deea13cbb4807d43ad0c58085285e
+  data.tar.gz: 4a8e05c974c11d4d201e1f2342e1769260a63ceaff18d54a71167dd929f6f23a
 SHA512:
-  metadata.gz: a7678c337e77326cedb49b06088ec1b24ae9b08f2047f02efc741134dc6a6efe851a702f45e02c571850c1762aca4de134067015aa8f2da06be9aa1cabb2050b
-  data.tar.gz: edd3d2148f8c4ee3c04bdc5025502e859f8d726bf38c741d4357a152770608ba639ad420070a8e071a261b4459bb20b7b637a390991877fd757e9d04a3d0d4b7
+  metadata.gz: 92b8a9e0306b22869147b1f0a3912f6fb88e3583e54caab6dbc37450996d15046ae049bea5fcfd46090575e94c7b4b16ff4ca833b63fdc125b30601211a2603e
+  data.tar.gz: d76e8b15e040f6fe60cb940ef3654dffd45eaf3edaaa563a6404a178014bc767866c5668d0dc2560610e75adb5034ac6ae0c94d19d6fa1c5d4812c5769a78a74

data/README.md

@@ -152,8 +152,6 @@ 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
@@ -742,8 +740,6 @@ 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
@@ -806,7 +802,6 @@ gem:
     activesupport: 'false'
   verify: false
   doc: true
-  loc: true
   exported_gem_rbis: true
   workers: 1
   auto_strictness: true
@@ -820,7 +815,6 @@ 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,10 +190,6 @@ 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",
@@ -237,7 +233,6 @@ 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],
@@ -260,7 +255,7 @@ module Tapioca
         end
 
         if gems.empty? && !all
-          command.sync(should_verify: verify, exclude: options[:exclude])
+          command.sync(should_verify: verify)
         else
           command.execute
         end
@@ -275,7 +270,6 @@ 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],
@@ -283,8 +277,7 @@ 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],
-        number_of_workers: options[:workers]
+        payload: options[:payload]
       )
       command.execute
     end

data/lib/tapioca/commands/annotations.rb

@@ -112,7 +112,7 @@ 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| hash[gem_name] << uri if index.has_gem?(gem_name) }
+          @indexes.each { |uri, index| T.must(hash[gem_name]) << uri if index.has_gem?(gem_name) }
         end
 
         if fetchable_gems.empty?
@@ -193,8 +193,7 @@ module Tapioca
           # Please run `#{default_command(:annotations)}` to update it.
         COMMENT
 
-        # Split contents into newlines and ensure trailing empty lines are included
-        contents = content.split("\n", -1)
+        contents = content.split("\n")
         if contents[0]&.start_with?("# typed:") && contents[1]&.empty?
           contents.insert(2, header).join("\n")
         else

data/lib/tapioca/commands/check_shims.rb

@@ -15,19 +15,10 @@ module Tapioca
           annotations_rbi_dir: String,
           shim_rbi_dir: String,
           todo_rbi_file: String,
-          payload: T::Boolean,
-          number_of_workers: T.nilable(Integer)
+          payload: T::Boolean
         ).void
       end
-      def initialize(
-        gem_rbi_dir:,
-        dsl_rbi_dir:,
-        annotations_rbi_dir:,
-        shim_rbi_dir:,
-        todo_rbi_file:,
-        payload:,
-        number_of_workers:
-      )
+      def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:)
         super()
         @gem_rbi_dir = gem_rbi_dir
         @dsl_rbi_dir = dsl_rbi_dir
@@ -35,7 +26,6 @@ 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 }
@@ -61,7 +51,7 @@ module Tapioca
                 exit(1)
               end
 
-              index_rbis(index, "payload", payload_path, number_of_workers: @number_of_workers)
+              index_payload(index, payload_path)
             end
           else
             say_error("The version of Sorbet used in your Gemfile.lock does not support `--print=payload-sources`")
@@ -72,10 +62,10 @@ module Tapioca
         end
 
         index_rbi(index, "todo", @todo_rbi_file)
-        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)
+        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)
 
         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,7 +17,6 @@ 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,
@@ -34,7 +33,6 @@ module Tapioca
         outpath:,
         file_header:,
         include_doc:,
-        include_loc:,
         include_exported_rbis:,
         number_of_workers: nil,
         auto_strictness: true,
@@ -60,7 +58,6 @@ 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
 
@@ -97,12 +94,12 @@ module Tapioca
         end
       end
 
-      sig { params(should_verify: T::Boolean, exclude: T::Array[String]).void }
-      def sync(should_verify: false, exclude: [])
+      sig { params(should_verify: T::Boolean).void }
+      def sync(should_verify: false)
         if should_verify
           say("Checking for out-of-date RBIs...")
           say("")
-          perform_sync_verification(exclude: exclude)
+          perform_sync_verification
           return
         end
 
@@ -185,7 +182,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, include_loc: @include_loc).compile
+        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc).compile
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis
 
@@ -204,13 +201,11 @@ module Tapioca
         end
       end
 
-      sig { params(exclude: T::Array[String]).void }
-      def perform_sync_verification(exclude: [])
+      sig { void }
+      def perform_sync_verification
         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/compiler.rb

@@ -52,7 +52,6 @@ module Tapioca
           T::Set[Module].new(gather_constants).compare_by_identity,
           T.nilable(T::Set[Module])
         )
-        T.must(@processable_constants)
       end
 
       # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.

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

@@ -216,7 +216,6 @@ module Tapioca
         sig { returns(String) }
         def constant_name
           @constant_name ||= T.let(T.must(qualified_name_of(constant)), T.nilable(String))
-          T.must(@constant_name)
         end
 
         sig { params(method_name: Symbol).returns(T::Boolean) }

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

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

@@ -38,20 +38,12 @@ 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 =
-            case column_type
-            when ActiveRecord::Enum::EnumType
-              enum_setter_type(column_type)
-            else
-              getter_type
-            end
+          setter_type = getter_type
 
           if column&.null
             return [as_nilable_type(getter_type), as_nilable_type(setter_type)]
@@ -116,16 +108,6 @@ 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,9 +105,6 @@ module Tapioca
     class MethodNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(UnboundMethod) }
-      attr_reader :method
-
       sig { returns(RBI::Method) }
       attr_reader :node
 
@@ -121,16 +118,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 initialize(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
+      def initialize(symbol, constant, node, signature, parameters)
         super(symbol, constant)
         @node = node
-        @method = method
         @signature = signature
         @parameters = parameters
       end

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

@@ -35,10 +35,10 @@ module Tapioca
               # base constant. Then, generate RBIs as if the base constant is extending the mixin,
               # which is functionally equivalent to including or prepending to the singleton class.
               if !name && constant.singleton_class?
-                name = constant_name_from_singleton_class(constant)
-                next unless name
+                attached_class = attached_class_of(constant)
+                next unless attached_class
 
-                constant = T.cast(constantize(name), Module)
+                constant = attached_class
               end
 
               @pipeline.push_foreign_constant(name, constant) if name

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

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

data/lib/tapioca/gem/listeners.rb

@@ -15,4 +15,3 @@ 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, include_loc: T::Boolean).void }
-      def initialize(gem, include_doc: false, include_loc: false)
+      sig { params(gem: Gemfile::GemSpec, include_doc: T::Boolean).void }
+      def initialize(gem, include_doc: false)
         @root = T.let(RBI::Tree.new, RBI::Tree)
         @gem = gem
         @seen = T.let(Set.new, T::Set[String])
@@ -40,7 +40,6 @@ 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
 
@@ -88,14 +87,13 @@ 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, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
-        @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
+      def push_method(symbol, constant, node, signature, parameters)
+        @events << Gem::MethodNodeAdded.new(symbol, constant, 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}... ")
-      time = Benchmark.realtime do
-        parse_and_index_files(index, [file], number_of_workers: 1)
-      end
-      say(" Done ", :green)
-      say("(#{time.round(2)}s)")
+      parse_and_index_file(index, file)
+      say(" Done", :green)
     end
 
-    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:)
+    sig { params(index: RBI::Index, kind: String, dir: String).void }
+    def index_rbis(index, kind, dir)
       return unless Dir.exist?(dir) && !Dir.empty?(dir)
 
-      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)")
+      say("Loading #{kind} RBIs from #{dir}... ")
+      files = Dir.glob("#{dir}/**/*.rbi").sort
+      parse_and_index_files(index, files)
+      say(" Done", :green)
     end
 
     sig do
@@ -48,16 +48,13 @@ module Tapioca
     def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:)
       duplicates = {}
       say("Looking for duplicates... ")
-      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)
+      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
-        end
+        duplicates[key] = nodes
       end
-      say(" Done ", :green)
-      say("(#{time.round(2)}s)")
+      say(" Done", :green)
       duplicates
     end
 
@@ -153,19 +150,21 @@ module Tapioca
 
     private
 
-    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)
+    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, file: String).void }
+    def parse_and_index_file(index, file)
+      return if Spoom::Sorbet::Sigils.file_strictness(file) == "ignore"
 
-      index.visit_all(trees)
+      tree = RBI::Parser.parse_file(file)
+      index.visit(tree)
+    rescue RBI::ParseError => e
+      say_error("\nWarning: #{e} (#{e.location})", :yellow)
     end
 
     sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String, todo_rbi_file: String).returns(T::Boolean) }
@@ -178,6 +177,9 @@ module Tapioca
       shims_or_todos_empty_scopes = extract_empty_scopes(shims_or_todos)
       return true unless shims_or_todos_empty_scopes.empty?
 
+      mixins = extract_mixins(shims_or_todos)
+      return true unless mixins.empty?
+
       props = extract_methods_and_attrs(shims_or_todos)
       return false if props.empty?
 
@@ -215,6 +217,13 @@ module Tapioca
       end, T::Array[T.any(RBI::Method, RBI::Attr)])
     end
 
+    sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Mixin, RBI::RequiresAncestor)]) }
+    def extract_mixins(nodes)
+      T.cast(nodes.select do |node|
+        node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor)
+      end, T::Array[T.all(RBI::Mixin, RBI::RequiresAncestor)])
+    end
+
     sig { params(nodes: T::Array[T.any(RBI::Method, RBI::Attr)]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
     def extract_nodes_with_sigs(nodes)
       nodes.reject { |node| node.sigs.empty? }

data/lib/tapioca/helpers/rbi_helper.rb

@@ -93,36 +93,15 @@ module Tapioca
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
-      # 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
+      name == "==" || !(
+        name.to_sym.inspect.start_with?(':"', ":@", ":$") ||
+        name.delete_suffix("=").to_sym.inspect.start_with?(':"', ":@", ":$")
+      )
     end
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_parameter_name?(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
+      /^([[:lower:]]|_|[^[[:ascii:]]])([[:alnum:]]|_|[^[[:ascii:]]])*$/.match?(name)
     end
   end
 end

data/lib/tapioca/internal.rb

@@ -7,7 +7,6 @@ require "tapioca"
 require "tapioca/runtime/reflection"
 require "tapioca/runtime/trackers"
 
-require "benchmark"
 require "bundler"
 require "erb"
 require "etc"
@@ -34,7 +33,6 @@ 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/rbi_ext/model.rb

@@ -101,7 +101,7 @@ module RBI
 
     sig { returns(T::Hash[String, RBI::Node]) }
     def nodes_cache
-      T.must(@nodes_cache ||= T.let({}, T.nilable(T::Hash[String, Node])))
+      @nodes_cache ||= T.let({}, T.nilable(T::Hash[String, Node]))
     end
 
     sig { params(node: RBI::Node).returns(RBI::Node) }

data/lib/tapioca/rbi_formatter.rb

@@ -22,7 +22,7 @@ module Tapioca
     def write_empty_body_comment!(file)
       file.comments << RBI::BlankLine.new unless file.comments.empty?
       file.comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
-      file.comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
+      file.comments << RBI::Comment.new("see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem")
     end
   end
 

data/lib/tapioca/runtime/reflection.rb

@@ -158,25 +158,25 @@ 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 { params(locations: T.nilable(T::Array[Thread::Backtrace::Location])).returns(String) }
-      def resolve_loc(locations)
+      sig { returns(String) }
+      def required_from_location
+        locations = Kernel.caller_locations
         return "" unless locations
 
-        resolved_loc = locations.find { |loc| REQUIRED_FROM_LABELS.include?(loc.label) }
-        return "" unless resolved_loc
+        required_location = locations.find { |loc| REQUIRED_FROM_LABELS.include?(loc.label) }
+        return "" unless required_location
 
-        resolved_loc.absolute_path || ""
+        required_location.absolute_path || ""
       end
 
-      sig { params(constant: Module).returns(T.nilable(String)) }
-      def constant_name_from_singleton_class(constant)
-        constant.to_s.match("#<Class:(.+)>")&.captures&.first
-      end
+      sig { params(singleton_class: Module).returns(T.nilable(Module)) }
+      def attached_class_of(singleton_class)
+        # https://stackoverflow.com/a/36622320/98634
+        result = ObjectSpace.each_object(singleton_class).find do |klass|
+          singleton_class_of(T.cast(klass, Module)) == singleton_class
+        end
 
-      sig { params(constant: Module).returns(T.nilable(BasicObject)) }
-      def constant_from_singleton_class(constant)
-        constant_name = constant_name_from_singleton_class(constant)
-        constantize(constant_name) if constant_name
+        T.cast(result, Module)
       end
     end
   end

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

@@ -17,54 +17,36 @@ module Tapioca
           const :path, String
         end
 
-        @class_files = {}.compare_by_identity
+        @class_files = {}
 
         # Immediately activated upon load. Observes class/module definition.
         TracePoint.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)
+          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))
           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)
-          locations_for(klass).map(&:path).to_set
-        end
-
-        def self.locations_for(klass)
-          @class_files.fetch(klass, Set.new)
+          name = String === klass ? klass : name_of(klass)
+          files = @class_files.fetch(name, [])
+          files.map(&:path).to_set
         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.resolve_loc(caller_locations)
+          location = Reflection.required_from_location
 
           constants = constants_with_mixin(mixin)
           constants.fetch(mixin_type).store(constant, location)
@@ -103,7 +103,7 @@ class Module
     # this mixin can be found whether searching for an include/prepend on the singleton class
     # or an extend on the attached class.
     def register_extend_on_attached_class(constant)
-      attached_class = Tapioca::Runtime::Reflection.constant_from_singleton_class(constant)
+      attached_class = Tapioca::Runtime::Reflection.attached_class_of(constant)
 
       Tapioca::Runtime::Trackers::Mixin.register(
         T.cast(attached_class, Module),

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -1,28 +1,18 @@
 # 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
-          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
+          ::Tapioca::Runtime::Reflection.qualified_name_of(@raw_type)
         end
       end
 

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-19 00:00:00.000000000 Z
+date: 2022-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -224,7 +224,6 @@ 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
@@ -256,7 +255,6 @@ 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

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

@@ -1,67 +0,0 @@
-# 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/sorbet_ext/proc_bind_patch.rb

@@ -1,40 +0,0 @@
-# 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