tapioca 0.10.1 → 0.10.3

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

@@ -24,7 +24,7 @@ module Tapioca
           # The way we identify these "foreign constants" is by asking the mixin tracker which
           # constants have mixed in the current module that we are handling. We add all the
           # constants that we discover to the pipeline to be processed.
-          Runtime::Trackers::Mixin.constants_with_mixin(mixin).each_value do |location_info|
+          Runtime::Trackers::Mixin.constants_with_mixin(mixin).each do |mixin_type, location_info|
             location_info.each do |constant, location|
               next unless mixed_in_by_gem?(location)
 
@@ -35,10 +35,11 @@ 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?
-                attached_class = attached_class_of(constant)
+                attached_class = Runtime::Trackers::Mixin.resolve_to_attached_class(constant, mixin, mixin_type)
                 next unless attached_class
 
                 constant = attached_class
+                name = @pipeline.name_of(constant)
               end
 
               @pipeline.push_foreign_constant(name, constant) if name

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

@@ -28,7 +28,7 @@ module Tapioca
             tree: RBI::Tree,
             module_name: String,
             mod: Module,
-            for_visibility: T::Array[Symbol]
+            for_visibility: T::Array[Symbol],
           ).void
         end
         def compile_directly_owned_methods(tree, module_name, mod, for_visibility = [:public, :protected, :private])
@@ -57,7 +57,7 @@ module Tapioca
             symbol_name: String,
             constant: Module,
             method: T.nilable(UnboundMethod),
-            visibility: RBI::Visibility
+            visibility: RBI::Visibility,
           ).void
         end
         def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
@@ -112,7 +112,7 @@ module Tapioca
           rbi_method = RBI::Method.new(
             method_name,
             is_singleton: constant.singleton_class?,
-            visibility: visibility
+            visibility: visibility,
           )
 
           sanitized_parameters.each do |type, name|

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

@@ -36,7 +36,7 @@ module Tapioca
             tree: RBI::Tree,
             constant: Module,
             mods: T::Array[Module],
-            mixin_type: Runtime::Trackers::Mixin::Type
+            mixin_type: Runtime::Trackers::Mixin::Type,
           ).void
         end
         def add_mixins(tree, constant, mods, mixin_type)
@@ -69,15 +69,11 @@ module Tapioca
           params(
             constant: Module,
             mixin: Module,
-            mixin_type: Runtime::Trackers::Mixin::Type
+            mixin_type: Runtime::Trackers::Mixin::Type,
           ).returns(T::Boolean)
         end
         def mixed_in_by_gem?(constant, mixin, mixin_type)
-          mixin_location =
-            T.cast(
-              Runtime::Trackers::Mixin.constants_with_mixin(mixin).dig(mixin_type, constant),
-              T.nilable(String)
-            )
+          mixin_location = Runtime::Trackers::Mixin.mixin_location(mixin, mixin_type, constant)
 
           return true if mixin_location.nil?
 

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

@@ -61,7 +61,7 @@ module Tapioca
             gem_name: gem.name,
             gem_version: version,
             path: path.to_s,
-            line_number: line.to_s
+            line_number: line.to_s,
           )
           node.comments << RBI::Comment.new("") if node.comments.any?
           node.comments << RBI::Comment.new(uri.to_s)

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

@@ -26,7 +26,7 @@ module Tapioca
             # Don't compile modules of Object because Object::Foo == Foo
             # Don't compile modules of BasicObject because BasicObject::BasicObject == BasicObject
             next if (Object == constant || BasicObject == constant) && Module === subconstant
-            next unless subconstant
+            next unless Runtime::Reflection.constant_defined?(subconstant)
 
             @pipeline.push_constant(name, subconstant)
           end

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

@@ -43,7 +43,7 @@ module Tapioca
           separator = event.constant.singleton_class? ? "." : "#"
           event.node.comments = documentation_comments(
             "#{event.symbol}#{separator}#{event.node.name}",
-            sigs: event.node.sigs
+            sigs: event.node.sigs,
           )
         end
 

data/lib/tapioca/gem/pipeline.rb

@@ -91,7 +91,7 @@ module Tapioca
           method: UnboundMethod,
           node: RBI::Method,
           signature: T.untyped,
-          parameters: T::Array[[Symbol, String]]
+          parameters: T::Array[[Symbol, String]],
         ).void.checked(:never)
       end
       def push_method(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
@@ -162,7 +162,7 @@ module Tapioca
         return if symbol_in_payload?(symbol) && !@bootstrap_symbols.include?(symbol)
 
         constant = constantize(symbol)
-        push_constant(symbol, constant) if constant
+        push_constant(symbol, constant) if Runtime::Reflection.constant_defined?(constant)
       end
 
       sig { params(event: Gem::ConstantFound).void.checked(:never) }
@@ -260,6 +260,7 @@ module Tapioca
         return if klass_name&.start_with?("T::Types::", "T::Private::")
 
         type_name = klass_name || "T.untyped"
+        type_name = "T.untyped" if type_name == "NilClass"
         node = RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})")
         push_const(name, klass, node)
         @root << node
@@ -321,7 +322,7 @@ module Tapioca
           next unless superclass_name
 
           resolved_superclass = constantize(superclass_name)
-          next unless Module === resolved_superclass
+          next unless Module === resolved_superclass && Runtime::Reflection.constant_defined?(resolved_superclass)
           next if name_of(resolved_superclass) == constant_name
 
           # We found a suitable superclass
@@ -341,7 +342,7 @@ module Tapioca
 
       sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
       def defined_in_gem?(constant, strict: true)
-        files = Set.new(get_file_candidates(constant))
+        files = get_file_candidates(constant)
           .merge(Runtime::Trackers::ConstantDefinition.files_for(constant))
 
         return !strict if files.empty?
@@ -351,13 +352,11 @@ module Tapioca
         end
       end
 
-      sig { params(constant: Module).returns(T::Array[String]) }
+      sig { params(constant: Module).returns(T::Set[String]) }
       def get_file_candidates(constant)
-        wrapped_module = Pry::WrappedModule.new(constant)
-
-        wrapped_module.send(:method_candidates).flatten.filter_map(&:source_file).uniq
+        file_candidates_for(constant)
       rescue ArgumentError, NameError
-        []
+        Set.new
       end
 
       sig { params(name: String).void }
@@ -390,6 +389,9 @@ module Tapioca
         type_variables = Runtime::GenericTypeRegistry.lookup_type_variables(constant)
         return type_name unless type_variables
 
+        type_variables = type_variables.reject(&:fixed?)
+        return type_name if type_variables.empty?
+
         type_variable_names = type_variables.map { "T.untyped" }.join(", ")
 
         "#{type_name}[#{type_variable_names}]"

data/lib/tapioca/gemfile.rb

@@ -8,7 +8,7 @@ module Tapioca
     Spec = T.type_alias do
       T.any(
         ::Bundler::StubSpecification,
-        ::Gem::Specification
+        ::Gem::Specification,
       )
     end
 
@@ -147,7 +147,7 @@ module Tapioca
               .flat_map do |spec|
                 spec.files.filter_map { |file| [file.realpath.to_s, spec] if file.exist? }
               end.to_h,
-            T.nilable(T::Hash[String, Gemfile::GemSpec])
+            T.nilable(T::Hash[String, Gemfile::GemSpec]),
           )
         end
       end
@@ -157,7 +157,7 @@ module Tapioca
           "sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime",
           "debug", "fakefs",
         ].freeze,
-        T::Array[String]
+        T::Array[String],
       )
 
       sig { returns(String) }
@@ -201,7 +201,7 @@ module Tapioca
         if default_gem?
           files.any? { |file| file.to_s == to_realpath(path) }
         else
-          to_realpath(path).start_with?(full_gem_path) || has_parent_gemspec?(path)
+          path_in_dir?(to_realpath(path), full_gem_path) || has_parent_gemspec?(path)
         end
       end
 

data/lib/tapioca/helpers/config_helper.rb

@@ -96,7 +96,7 @@ module Tapioca
       params(
         command_options: T::Hash[Symbol, Thor::Option],
         config_key: String,
-        config_options: T::Hash[T.untyped, T.untyped]
+        config_options: T::Hash[T.untyped, T.untyped],
       ).returns(T::Array[ConfigError])
     end
     def validate_config_options(command_options, config_key, config_options)
@@ -157,18 +157,18 @@ module Tapioca
         if match
           ConfigErrorMessagePart.new(
             message: "#{match[1]}#{match[2]}",
-            colors: [:bold, :blue]
+            colors: [:bold, :blue],
           )
         else
           ConfigErrorMessagePart.new(
             message: part,
-            colors: [:yellow]
+            colors: [:yellow],
           )
         end
       end
 
       ConfigError.new(
-        message_parts: message_parts
+        message_parts: message_parts,
       )
     end
 

data/lib/tapioca/helpers/env_helper.rb

@@ -11,6 +11,7 @@ module Tapioca
     sig { params(options: T::Hash[Symbol, T.untyped]).void }
     def set_environment(options) # rubocop:disable Naming/AccessorMethodName
       ENV["RAILS_ENV"] = ENV["RACK_ENV"] = options[:environment]
+      ENV["RUBY_DEBUG_ENABLE"] = "0"
     end
   end
 end

data/lib/tapioca/helpers/gem_helper.rb

@@ -5,15 +5,17 @@ module Tapioca
   module GemHelper
     extend T::Sig
 
-    sig { params(gemfile_dir: String, full_gem_path: String).returns(T::Boolean) }
-    def gem_in_app_dir?(gemfile_dir, full_gem_path)
-      !gem_in_bundle_path?(to_realpath(full_gem_path)) &&
-        full_gem_path.start_with?(to_realpath(gemfile_dir))
+    sig { params(app_dir: String, full_gem_path: String).returns(T::Boolean) }
+    def gem_in_app_dir?(app_dir, full_gem_path)
+      app_dir = to_realpath(app_dir)
+      full_gem_path = to_realpath(full_gem_path)
+
+      !gem_in_bundle_path?(full_gem_path) && path_in_dir?(full_gem_path, app_dir)
     end
 
     sig { params(full_gem_path: String).returns(T::Boolean) }
     def gem_in_bundle_path?(full_gem_path)
-      full_gem_path.start_with?(Bundler.bundle_path.to_s, Bundler.app_cache.to_s)
+      path_in_dir?(full_gem_path, Bundler.bundle_path) || path_in_dir?(full_gem_path, Bundler.app_cache)
     end
 
     sig { params(path: T.any(String, Pathname)).returns(String) }
@@ -22,5 +24,15 @@ module Tapioca
       path_string = File.realpath(path_string) if File.exist?(path_string)
       path_string
     end
+
+    private
+
+    sig { params(path: T.any(Pathname, String), dir: T.any(Pathname, String)).returns(T::Boolean) }
+    def path_in_dir?(path, dir)
+      dir = Pathname.new(dir)
+      path = Pathname.new(path)
+
+      path.ascend.any?(dir)
+    end
   end
 end

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -42,7 +42,7 @@ module Tapioca
       params(
         index: RBI::Index,
         shim_rbi_dir: String,
-        todo_rbi_file: String
+        todo_rbi_file: String,
       ).returns(T::Hash[String, T::Array[RBI::Node]])
     end
     def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:)
@@ -80,7 +80,7 @@ module Tapioca
         dsl_dir: String,
         auto_strictness: T::Boolean,
         gems: T::Array[Gemfile::GemSpec],
-        compilers: T::Enumerable[Class]
+        compilers: T::Enumerable[Class],
       ).void
     end
     def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])
@@ -92,7 +92,7 @@ module Tapioca
         "--error-url-base=#{error_url_base}",
         "--stop-after namer",
         dsl_dir,
-        gem_dir
+        gem_dir,
       )
       say(" Done", :green)
 

data/lib/tapioca/helpers/rbi_helper.rb

@@ -17,28 +17,20 @@ module Tapioca
           variance: Symbol,
           fixed: T.nilable(String),
           upper: T.nilable(String),
-          lower: T.nilable(String)
+          lower: T.nilable(String),
         ).returns(String)
       end
       def serialize_type_variable(type, variance, fixed, upper, lower)
         variance = nil if variance == :invariant
 
-        bounds = []
-        bounds << "fixed: #{fixed}" if fixed
-        bounds << "lower: #{lower}" if lower
-        bounds << "upper: #{upper}" if upper
-
-        parameters = []
         block = []
+        block << "fixed: #{fixed}" if fixed
+        block << "lower: #{lower}" if lower
+        block << "upper: #{upper}" if upper
 
+        parameters = []
         parameters << ":#{variance}" if variance
 
-        if sorbet_supports?(:type_variable_block_syntax)
-          block = bounds
-        else
-          parameters.concat(bounds)
-        end
-
         serialized = type.dup
         serialized << "(#{parameters.join(", ")})" unless parameters.empty?
         serialized << " { { #{block.join(", ")} } }" unless block.empty?

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -7,12 +7,12 @@ module Tapioca
 
     SORBET_GEM_SPEC = T.let(
       ::Gem::Specification.find_by_name("sorbet-static"),
-      ::Gem::Specification
+      ::Gem::Specification,
     )
 
     SORBET_BIN = T.let(
       Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
-      Pathname
+      Pathname,
     )
 
     SORBET_EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
@@ -20,9 +20,7 @@ module Tapioca
     SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
 
     FEATURE_REQUIREMENTS = T.let({
-      to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),         # https://github.com/sorbet/sorbet/pull/4706
-      print_payload_sources: ::Gem::Requirement.new(">= 0.5.9818"),      # https://github.com/sorbet/sorbet/pull/5504
-      type_variable_block_syntax: ::Gem::Requirement.new(">= 0.5.9892"), # https://github.com/sorbet/sorbet/pull/5639
+      # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
     }.freeze, T::Hash[Symbol, ::Gem::Requirement])
 
     sig { params(sorbet_args: String).returns(Spoom::ExecResult) }

data/lib/tapioca/helpers/source_uri.rb

@@ -29,7 +29,7 @@ module URI
           gem_name: String,
           gem_version: T.nilable(String),
           path: String,
-          line_number: T.nilable(String)
+          line_number: T.nilable(String),
         ).returns(URI::Source)
       end
       def build(gem_name:, gem_version:, path:, line_number:)

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

@@ -109,7 +109,7 @@ module Tapioca
           def pipeline
             @pipeline ||= Tapioca::Dsl::Pipeline.new(
               requested_constants: [],
-              requested_compilers: activated_compiler_classes
+              requested_compilers: activated_compiler_classes,
             )
           end
         end

data/lib/tapioca/loaders/dsl.rb

@@ -9,9 +9,9 @@ module Tapioca
       class << self
         extend T::Sig
 
-        sig { params(tapioca_path: String, eager_load: T::Boolean).void }
-        def load_application(tapioca_path:, eager_load: true)
-          loader = new(tapioca_path: tapioca_path)
+        sig { params(tapioca_path: String, eager_load: T::Boolean, app_root: String).void }
+        def load_application(tapioca_path:, eager_load: true, app_root: ".")
+          loader = new(tapioca_path: tapioca_path, app_root: app_root)
           loader.load
         end
       end
@@ -26,12 +26,13 @@ module Tapioca
 
       protected
 
-      sig { params(tapioca_path: String, eager_load: T::Boolean).void }
-      def initialize(tapioca_path:, eager_load: true)
+      sig { params(tapioca_path: String, eager_load: T::Boolean, app_root: String).void }
+      def initialize(tapioca_path:, eager_load: true, app_root: ".")
         super()
 
         @tapioca_path = tapioca_path
         @eager_load = eager_load
+        @app_root = app_root
       end
 
       sig { void }
@@ -63,7 +64,8 @@ module Tapioca
 
         load_rails_application(
           environment_load: true,
-          eager_load: @eager_load
+          eager_load: @eager_load,
+          app_root: @app_root,
         )
 
         say("Done", :green)
@@ -71,7 +73,7 @@ module Tapioca
 
       sig { void }
       def abort_if_pending_migrations!
-        return unless File.exist?("config/application.rb")
+        return unless File.exist?("#{@app_root}/config/application.rb")
         return unless defined?(::Rake)
 
         Rails.application.load_tasks

data/lib/tapioca/loaders/gem.rb

@@ -14,7 +14,7 @@ module Tapioca
             bundle: Gemfile,
             prerequire: T.nilable(String),
             postrequire: String,
-            default_command: String
+            default_command: String,
           ).void
         end
         def load_application(bundle:, prerequire:, postrequire:, default_command:)
@@ -38,7 +38,7 @@ module Tapioca
           bundle: Gemfile,
           prerequire: T.nilable(String),
           postrequire: String,
-          default_command: String
+          default_command: String,
         ).void
       end
       def initialize(bundle:, prerequire:, postrequire:, default_command:)

data/lib/tapioca/loaders/loader.rb

@@ -33,16 +33,16 @@ module Tapioca
         load_rails_engines
       end
 
-      sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
-      def load_rails_application(environment_load: false, eager_load: false)
-        return unless File.exist?("config/application.rb")
+      sig { params(environment_load: T::Boolean, eager_load: T::Boolean, app_root: String).void }
+      def load_rails_application(environment_load: false, eager_load: false, app_root: ".")
+        return unless File.exist?("#{app_root}/config/application.rb")
 
         silence_deprecations
 
         if environment_load
-          require "./config/environment"
+          require "./#{app_root}/config/environment"
         else
-          require "./config/application"
+          require "./#{app_root}/config/application"
         end
 
         eager_load_rails_app if eager_load
@@ -113,7 +113,7 @@ module Tapioca
         if Object.const_defined?("ActiveSupport")
           Object.const_get("ActiveSupport").run_load_hooks(
             :before_eager_load,
-            application
+            application,
           )
         end
 

data/lib/tapioca/rbi_ext/model.rb

@@ -32,7 +32,7 @@ module RBI
       params(
         name: String,
         superclass_name: T.nilable(String),
-        block: T.nilable(T.proc.params(scope: RBI::Scope).void)
+        block: T.nilable(T.proc.params(scope: RBI::Scope).void),
       ).returns(Scope)
     end
     def create_class(name, superclass_name: nil, &block)
@@ -68,7 +68,7 @@ module RBI
         variance: Symbol,
         fixed: T.nilable(String),
         upper: T.nilable(String),
-        lower: T.nilable(String)
+        lower: T.nilable(String),
       ).void
     end
     def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: nil, lower: nil)
@@ -82,14 +82,17 @@ module RBI
         parameters: T::Array[TypedParam],
         return_type: String,
         class_method: T::Boolean,
-        visibility: RBI::Visibility
+        visibility: RBI::Visibility,
+        comments: T::Array[RBI::Comment],
       ).void
     end
-    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new)
+    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new,
+      comments: [])
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sig = RBI::Sig.new(return_type: return_type)
-      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility)
+      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility,
+        comments: comments)
       parameters.each do |param|
         method << param.param
         sig << RBI::SigParam.new(param.param.name, param.type)

data/lib/tapioca/rbi_formatter.rb

@@ -9,7 +9,7 @@ module Tapioca
       params(
         file: RBI::File,
         command: String,
-        reason: T.nilable(String)
+        reason: T.nilable(String),
       ).void
     end
     def write_header!(file, command, reason: nil)
@@ -32,6 +32,6 @@ module Tapioca
     max_line_length: nil,
     nest_singleton_methods: true,
     nest_non_public_methods: true,
-    sort_nodes: true
+    sort_nodes: true,
   ), RBIFormatter)
 end

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -23,14 +23,30 @@ module Tapioca
     module GenericTypeRegistry
       @generic_instances = T.let(
         {},
-        T::Hash[String, Module]
+        T::Hash[String, Module],
       )
 
       @type_variables = T.let(
         {}.compare_by_identity,
-        T::Hash[Module, T::Array[TypeVariableModule]]
+        T::Hash[Module, T::Array[TypeVariableModule]],
       )
 
+      class GenericType < T::Types::Simple
+        extend T::Sig
+
+        sig { params(raw_type: Module, underlying_type: Module).void }
+        def initialize(raw_type, underlying_type)
+          super(raw_type)
+
+          @underlying_type = T.let(underlying_type, Module)
+        end
+
+        sig { params(obj: T.untyped).returns(T::Boolean) }
+        def valid?(obj)
+          obj.is_a?(@underlying_type)
+        end
+      end
+
       class << self
         extend T::Sig
 
@@ -116,6 +132,10 @@ module Tapioca
           generic_type.define_singleton_method(:name, name_proc)
           generic_type.define_singleton_method(:to_s, name_proc)
 
+          override_type = GenericType.new(generic_type, constant)
+          override_type_proc = -> { override_type }
+          generic_type.define_singleton_method(:__tapioca_override_type, override_type_proc)
+
           # We need to define a `<=` method on the cloned constant, so that Sorbet
           # can do covariance/contravariance checks on the type variables.
           #