tapioca 0.6.1 → 0.7.0

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -1,780 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "pathname"
-
-module Tapioca
-  module Compilers
-    module SymbolTable
-      class SymbolGenerator
-        extend(T::Sig)
-        include(Reflection)
-
-        IGNORED_SYMBOLS = T.let(["YAML", "MiniTest", "Mutex"], T::Array[String])
-        IGNORED_COMMENTS = T.let([
-          ":doc:",
-          ":nodoc:",
-          "typed:",
-          "frozen_string_literal:",
-          "encoding:",
-          "warn_indent:",
-          "shareable_constant_value:",
-          "rubocop:",
-        ], T::Array[String])
-
-        sig { returns(Gemfile::GemSpec) }
-        attr_reader :gem
-
-        sig { returns(Integer) }
-        attr_reader :indent
-
-        sig { params(gem: Gemfile::GemSpec, indent: Integer, include_doc: T::Boolean).void }
-        def initialize(gem, indent = 0, include_doc = false)
-          @gem = gem
-          @indent = indent
-          @seen = T.let(Set.new, T::Set[String])
-          @alias_namespace = T.let(Set.new, T::Set[String])
-          @symbol_queue = T.let(symbols.sort.dup, T::Array[String])
-          @symbols = T.let(nil, T.nilable(T::Set[String]))
-          @include_doc = include_doc
-
-          gem.parse_yard_docs if include_doc
-        end
-
-        sig { params(rbi: RBI::File).void }
-        def generate(rbi)
-          generate_from_symbol(rbi.root, T.must(@symbol_queue.shift)) until @symbol_queue.empty?
-        end
-
-        private
-
-        sig { params(name: T.nilable(String)).void }
-        def add_to_symbol_queue(name)
-          @symbol_queue << name unless name.nil? || symbols.include?(name) || symbol_ignored?(name)
-        end
-
-        sig { returns(T::Set[String]) }
-        def symbols
-          @symbols ||= begin
-            symbols = Tapioca::Compilers::SymbolTable::SymbolLoader.list_from_paths(gem.files)
-            symbols.union(engine_symbols(symbols))
-          end
-        end
-
-        sig { params(symbols: T::Set[String]).returns(T::Set[String]) }
-        def engine_symbols(symbols)
-          return Set.new unless Object.const_defined?("Rails::Engine")
-
-          engine = descendants_of(Object.const_get("Rails::Engine"))
-            .reject(&:abstract_railtie?)
-            .find do |klass|
-              name = name_of(klass)
-              !name.nil? && symbols.include?(name)
-            end
-
-          return Set.new unless engine
-
-          paths = engine.config.eager_load_paths.flat_map do |load_path|
-            Pathname.glob("#{load_path}/**/*.rb")
-          end
-
-          Tapioca::Compilers::SymbolTable::SymbolLoader.list_from_paths(paths)
-        rescue
-          Set.new
-        end
-
-        sig { params(tree: RBI::Tree, symbol: String).void }
-        def generate_from_symbol(tree, symbol)
-          constant = constantize(symbol)
-
-          return unless constant
-
-          compile(tree, symbol, constant)
-        end
-
-        sig { params(tree: RBI::Tree, name: T.nilable(String), constant: BasicObject).void.checked(:never) }
-        def compile(tree, name, constant)
-          return unless constant
-          return unless name
-          return if name.strip.empty?
-          return if name.start_with?("#<")
-          return if name.downcase == name
-          return if alias_namespaced?(name)
-          return if seen?(name)
-          return if T::Enum === constant # T::Enum instances are defined via `compile_enums`
-
-          mark_seen(name)
-          compile_constant(tree, name, constant)
-        end
-
-        sig { params(tree: RBI::Tree, name: String, constant: BasicObject).void.checked(:never) }
-        def compile_constant(tree, name, constant)
-          case constant
-          when Module
-            if name_of(constant) != name
-              compile_alias(tree, name, constant)
-            else
-              compile_module(tree, name, constant)
-            end
-          else
-            compile_object(tree, name, constant)
-          end
-        end
-
-        sig { params(tree: RBI::Tree, name: String, constant: Module).void }
-        def compile_alias(tree, name, constant)
-          return if symbol_ignored?(name)
-
-          target = name_of(constant)
-          # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
-          target = "#{constant.class}.new" unless target
-
-          add_to_alias_namespace(name)
-
-          return if IGNORED_SYMBOLS.include?(name)
-
-          tree << RBI::Const.new(name, target)
-        end
-
-        sig { params(tree: RBI::Tree, name: String, value: BasicObject).void.checked(:never) }
-        def compile_object(tree, name, value)
-          return if symbol_ignored?(name)
-
-          klass = class_of(value)
-          return if klass == TypeMember || klass == TypeTemplate
-
-          klass_name = if klass == ObjectSpace::WeakMap
-            # WeakMap is an implicit generic with one type variable
-            "ObjectSpace::WeakMap[T.untyped]"
-          elsif T::Generic === klass
-            generic_name_of(klass)
-          else
-            name_of(klass)
-          end
-
-          comments = documentation_comments(name)
-
-          if klass_name == "T::Private::Types::TypeAlias"
-            type_alias = sanitize_signature_types(T.unsafe(value).aliased_type.to_s)
-            constant = RBI::Const.new(name, "T.type_alias { #{type_alias} }", comments: comments)
-            tree << constant
-            return
-          end
-
-          return if klass_name&.start_with?("T::Types::", "T::Private::")
-
-          type_name = klass_name || "T.untyped"
-          constant = RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})", comments: comments)
-
-          tree << constant
-        end
-
-        sig { params(tree: RBI::Tree, name: String, constant: Module).void }
-        def compile_module(tree, name, constant)
-          return unless defined_in_gem?(constant, strict: false)
-
-          comments = documentation_comments(name)
-          scope =
-            if constant.is_a?(Class)
-              superclass = compile_superclass(constant)
-              RBI::Class.new(name, superclass_name: superclass, comments: comments)
-            else
-              RBI::Module.new(name, comments: comments)
-            end
-
-          compile_body(scope, name, constant)
-
-          return if symbol_ignored?(name) && scope.empty?
-
-          tree << scope
-          compile_subconstants(tree, name, constant)
-        end
-
-        sig { params(tree: RBI::Tree, name: String, constant: Module).void }
-        def compile_body(tree, name, constant)
-          # Compiling type variables must happen first to populate generic names
-          compile_type_variables(tree, constant)
-          compile_methods(tree, name, constant)
-          compile_module_helpers(tree, constant)
-          compile_mixins(tree, constant)
-          compile_props(tree, constant)
-          compile_enums(tree, constant)
-          compile_dynamic_mixins(tree, constant)
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_dynamic_mixins(tree, constant)
-          return if constant.is_a?(Class)
-
-          mixin_compiler = DynamicMixinCompiler.new(constant)
-          mixin_compiler.compile_class_attributes(tree)
-          dynamic_extends, dynamic_includes = mixin_compiler.compile_mixes_in_class_methods(tree)
-
-          (dynamic_includes + dynamic_extends).each do |mod|
-            add_to_symbol_queue(name_of(mod))
-          end
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_module_helpers(tree, constant)
-          abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type) ||
-            T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
-
-          tree << RBI::Helper.new(abstract_type.to_s) if abstract_type
-          tree << RBI::Helper.new("final") if T::Private::Final.final_module?(constant)
-          tree << RBI::Helper.new("sealed") if T::Private::Sealed.sealed_module?(constant)
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_props(tree, constant)
-          return unless T::Props::ClassMethods === constant
-
-          constant.props.map do |name, prop|
-            type = prop.fetch(:type_object, "T.untyped").to_s.gsub(".returns(<VOID>)", ".void")
-
-            default = prop.key?(:default) ? "T.unsafe(nil)" : nil
-            tree << if prop.fetch(:immutable, false)
-              RBI::TStructConst.new(name.to_s, type, default: default)
-            else
-              RBI::TStructProp.new(name.to_s, type, default: default)
-            end
-          end
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_enums(tree, constant)
-          return unless T::Enum > constant
-
-          enums = T.unsafe(constant).values.map do |enum_type|
-            enum_type.instance_variable_get(:@const_name).to_s
-          end
-
-          tree << RBI::TEnumBlock.new(enums)
-        end
-
-        sig { params(tree: RBI::Tree, name: String, constant: Module).void }
-        def compile_subconstants(tree, name, constant)
-          constants_of(constant).sort.uniq.map do |constant_name|
-            symbol = (name == "Object" ? "" : name) + "::#{constant_name}"
-            subconstant = constantize(symbol)
-
-            # 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
-
-            compile(tree, symbol, subconstant)
-          end
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_type_variables(tree, constant)
-          compile_type_variable_declarations(tree, constant)
-
-          sclass = RBI::SingletonClass.new
-          compile_type_variable_declarations(sclass, singleton_class_of(constant))
-          tree << sclass if sclass.nodes.length > 1
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_type_variable_declarations(tree, constant)
-          # Try to find the type variables defined on this constant, bail if we can't
-          type_variables = GenericTypeRegistry.lookup_type_variables(constant)
-          return unless type_variables
-
-          # Create a map of subconstants (via their object ids) to their names.
-          # We need this later when we want to lookup the name of the registered type
-          # variable via the value of the type variable constant.
-          subconstant_to_name_lookup = constants_of(constant)
-            .each_with_object({}.compare_by_identity) do |constant_name, table|
-            table[constantize(constant_name.to_s, namespace: constant)] = constant_name.to_s
-          end
-
-          # Map each type variable to its string representation.
-          #
-          # Each entry of `type_variables` maps an object_id to a String,
-          # and the order they are inserted into the hash is the order they should be
-          # defined in the source code.
-          #
-          # By looping over these entries and then getting the actual constant name
-          # from the `subconstant_to_name_lookup` we defined above, gives us all the
-          # information we need to serialize type variable definitions.
-          type_variable_declarations = type_variables.map do |type_variable, serialized_type_variable|
-            constant_name = subconstant_to_name_lookup[type_variable]
-            type_variable.name = constant_name
-            # Here, we know that constant_value will be an instance of
-            # T::Types::CustomTypeVariable, which knows how to serialize
-            # itself to a type_member/type_template
-            tree << RBI::TypeMember.new(constant_name, serialized_type_variable)
-          end
-
-          return if type_variable_declarations.empty?
-
-          tree << RBI::Extend.new("T::Generic")
-        end
-
-        sig { params(constant: Class).returns(T.nilable(String)) }
-        def compile_superclass(constant)
-          superclass = T.let(nil, T.nilable(Class)) # rubocop:disable Lint/UselessAssignment
-
-          while (superclass = superclass_of(constant))
-            constant_name = name_of(constant)
-            constant = superclass
-
-            # Some types have "themselves" as their superclass
-            # which can happen via:
-            #
-            # class A < Numeric; end
-            # A = Class.new(A)
-            # A.superclass #=> A
-            #
-            # We compare names here to make sure we skip those
-            # superclass instances and walk up the chain.
-            #
-            # The name comparison is against the name of the constant
-            # resolved from the name of the superclass, since
-            # this is also possible:
-            #
-            # B = Class.new
-            # class A < B; end
-            # B = A
-            # A.superclass.name #=> "B"
-            # B #=> A
-            superclass_name = name_of(superclass)
-            next unless superclass_name
-
-            resolved_superclass = constantize(superclass_name)
-            next unless Module === resolved_superclass
-            next if name_of(resolved_superclass) == constant_name
-
-            # We found a suitable superclass
-            break
-          end
-
-          return if superclass == ::Object || superclass == ::Delegator
-          return if superclass.nil?
-
-          name = name_of(superclass)
-          return if name.nil? || name.empty?
-
-          add_to_symbol_queue(name)
-
-          "::#{name}"
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_mixins(tree, constant)
-          singleton_class = singleton_class_of(constant)
-
-          interesting_ancestors = interesting_ancestors_of(constant)
-          interesting_singleton_class_ancestors = interesting_ancestors_of(singleton_class)
-
-          prepends = interesting_ancestors.take_while { |c| !are_equal?(constant, c) }
-          includes = interesting_ancestors.drop(prepends.size + 1)
-          extends  = interesting_singleton_class_ancestors.reject do |mod|
-            Module != class_of(mod) || are_equal?(mod, singleton_class)
-          end
-
-          add_mixins(tree, prepends.reverse, Trackers::Mixin::Type::Prepend)
-          add_mixins(tree, includes.reverse, Trackers::Mixin::Type::Include)
-          add_mixins(tree, extends.reverse, Trackers::Mixin::Type::Extend)
-        end
-
-        sig do
-          params(
-            tree: RBI::Tree,
-            mods: T::Array[Module],
-            mixin_type: Trackers::Mixin::Type
-          ).void
-        end
-        def add_mixins(tree, mods, mixin_type)
-          mods
-            .select do |mod|
-              name = name_of(mod)
-
-              name && !name.start_with?("T::")
-            end
-            .map do |mod|
-              add_to_symbol_queue(name_of(mod))
-
-              qname = qualified_name_of(mod)
-              case mixin_type
-              # TODO: Sorbet currently does not handle prepend
-              # properly for method resolution, so we generate an
-              # include statement instead
-              when Trackers::Mixin::Type::Include, Trackers::Mixin::Type::Prepend
-                tree << RBI::Include.new(T.must(qname))
-              when Trackers::Mixin::Type::Extend
-                tree << RBI::Extend.new(T.must(qname))
-              end
-            end
-        end
-
-        sig { params(tree: RBI::Tree, name: String, constant: Module).void }
-        def compile_methods(tree, name, constant)
-          compile_method(
-            tree,
-            name,
-            constant,
-            initialize_method_for(constant)
-          )
-
-          compile_directly_owned_methods(tree, name, constant)
-          compile_directly_owned_methods(tree, name, singleton_class_of(constant))
-        end
-
-        sig do
-          params(
-            tree: RBI::Tree,
-            module_name: String,
-            mod: Module,
-            for_visibility: T::Array[Symbol]
-          ).void
-        end
-        def compile_directly_owned_methods(tree, module_name, mod, for_visibility = [:public, :protected, :private])
-          method_names_by_visibility(mod)
-            .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
-            .each do |visibility, method_list|
-              method_list.sort!.map do |name|
-                next if name == :initialize
-                vis = case visibility
-                when :protected
-                  RBI::Protected.new
-                when :private
-                  RBI::Private.new
-                else
-                  RBI::Public.new
-                end
-                compile_method(tree, module_name, mod, mod.instance_method(name), vis)
-              end
-            end
-        end
-
-        sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
-        def method_names_by_visibility(mod)
-          {
-            public: public_instance_methods_of(mod),
-            protected: protected_instance_methods_of(mod),
-            private: private_instance_methods_of(mod),
-          }
-        end
-
-        sig { params(constant: Module, method_name: String).returns(T::Boolean) }
-        def struct_method?(constant, method_name)
-          return false unless T::Props::ClassMethods === constant
-
-          constant
-            .props
-            .keys
-            .include?(method_name.gsub(/=$/, "").to_sym)
-        end
-
-        sig do
-          params(
-            tree: RBI::Tree,
-            symbol_name: String,
-            constant: Module,
-            method: T.nilable(UnboundMethod),
-            visibility: RBI::Visibility
-          ).void
-        end
-        def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
-          return unless method
-          return unless method.owner == constant
-          return if symbol_ignored?(symbol_name) && !method_in_gem?(method)
-
-          signature = signature_of(method)
-          method = T.let(signature.method, UnboundMethod) if signature
-
-          method_name = method.name.to_s
-          return unless valid_method_name?(method_name)
-          return if struct_method?(constant, method_name)
-          return if method_name.start_with?("__t_props_generated_")
-
-          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
-
-          sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
-            fallback_arg_name = "_arg#{index}"
-
-            unless name
-              # For attr_writer methods, Sorbet signatures have the name
-              # of the method (without the trailing = sign) as the name of
-              # the only parameter. So, if the parameter does not have a name
-              # then the replacement name should be the name of the method
-              # (minus trailing =) if and only if there is a signature for the
-              # method and the parameter is required and there is a single
-              # parameter and the signature also defines a single parameter and
-              # the name of the method ends with a = character.
-              writer_method_with_sig = (
-                signature && type == :req &&
-                parameters.size == 1 &&
-                signature.arg_types.size == 1 &&
-                method_name[-1] == "="
-              )
-
-              name = if writer_method_with_sig
-                T.must(method_name[0...-1]).to_sym
-              else
-                fallback_arg_name
-              end
-            end
-
-            # Sanitize param names
-            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, fallback_arg_name)
-
-            [type, name]
-          end
-
-          separator = constant.singleton_class? ? "." : "#"
-          comments = documentation_comments("#{symbol_name}#{separator}#{method_name}")
-          rbi_method = RBI::Method.new(
-            method_name,
-            is_singleton: constant.singleton_class?,
-            visibility: visibility,
-            comments: comments
-          )
-
-          rbi_method.sigs << compile_signature(signature, sanitized_parameters) if signature
-
-          sanitized_parameters.each do |type, name|
-            case type
-            when :req
-              rbi_method << RBI::Param.new(name)
-            when :opt
-              rbi_method << RBI::OptParam.new(name, "T.unsafe(nil)")
-            when :rest
-              rbi_method << RBI::RestParam.new(name)
-            when :keyreq
-              rbi_method << RBI::KwParam.new(name)
-            when :key
-              rbi_method << RBI::KwOptParam.new(name, "T.unsafe(nil)")
-            when :keyrest
-              rbi_method << RBI::KwRestParam.new(name)
-            when :block
-              rbi_method << RBI::BlockParam.new(name)
-            end
-          end
-
-          tree << rbi_method
-        end
-
-        TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
-
-        sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(RBI::Sig) }
-        def compile_signature(signature, parameters)
-          parameter_types = T.let(signature.arg_types.to_h, T::Hash[Symbol, T::Types::Base])
-          parameter_types.merge!(signature.kwarg_types)
-          parameter_types[signature.rest_name] = signature.rest_type if signature.has_rest
-          parameter_types[signature.keyrest_name] = signature.keyrest_type if signature.has_keyrest
-          parameter_types[signature.block_name] = signature.block_type if signature.block_name
-
-          sig = RBI::Sig.new
-
-          parameters.each do |_, name|
-            type = sanitize_signature_types(parameter_types[name.to_sym].to_s)
-            add_to_symbol_queue(type)
-            sig << RBI::SigParam.new(name, type)
-          end
-
-          return_type = name_of_type(signature.return_type)
-          sig.return_type = sanitize_signature_types(return_type)
-          add_to_symbol_queue(sig.return_type)
-
-          parameter_types.values.join(", ").scan(TYPE_PARAMETER_MATCHER).flatten.uniq.each do |k, _|
-            sig.type_params << k
-          end
-
-          case signature.mode
-          when "abstract"
-            sig.is_abstract = true
-          when "override"
-            sig.is_override = true
-          when "overridable_override"
-            sig.is_overridable = true
-            sig.is_override = true
-          when "overridable"
-            sig.is_overridable = true
-          end
-
-          sig
-        end
-
-        sig { params(sig_string: String).returns(String) }
-        def sanitize_signature_types(sig_string)
-          sig_string
-            .gsub(".returns(<VOID>)", ".void")
-            .gsub("<VOID>", "void")
-            .gsub("<NOT-TYPED>", "T.untyped")
-            .gsub(".params()", "")
-        end
-
-        sig { params(symbol_name: String).returns(T::Boolean) }
-        def symbol_ignored?(symbol_name)
-          SymbolLoader.ignore_symbol?(symbol_name)
-        end
-
-        SPECIAL_METHOD_NAMES = T.let([
-          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
-          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"
-        ], T::Array[String])
-
-        sig { params(name: String).returns(T::Boolean) }
-        def valid_method_name?(name)
-          return true if SPECIAL_METHOD_NAMES.include?(name)
-          !!name.match(/^[[:word:]]+[?!=]?$/)
-        end
-
-        sig { params(method: UnboundMethod).returns(T::Boolean) }
-        def method_in_gem?(method)
-          source_location = method.source_location&.first
-          return false if source_location.nil?
-
-          gem.contains_path?(source_location)
-        end
-
-        sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
-        def defined_in_gem?(constant, strict: true)
-          files = Set.new(get_file_candidates(constant))
-            .merge(Tapioca::Trackers::ConstantDefinition.files_for(constant))
-
-          return !strict if files.empty?
-
-          files.any? do |file|
-            gem.contains_path?(file)
-          end
-        end
-
-        sig do
-          params(
-            mod: Module,
-            mixin_type: Trackers::Mixin::Type,
-            mixin_locations: T::Hash[Trackers::Mixin::Type, T::Hash[Module, T::Array[String]]]
-          ).returns(T::Boolean)
-        end
-        def mixed_in_by_gem?(mod, mixin_type, mixin_locations)
-          locations = mixin_locations.dig(mixin_type, mod)
-          return true unless locations
-          locations.any? { |location| gem.contains_path?(location) }
-        end
-
-        sig { params(constant: Module).returns(T::Array[String]) }
-        def get_file_candidates(constant)
-          wrapped_module = Pry::WrappedModule.new(constant)
-
-          wrapped_module.candidates.map(&:file).to_a.compact
-        rescue ArgumentError, NameError
-          []
-        end
-
-        sig { params(name: String).void }
-        def add_to_alias_namespace(name)
-          @alias_namespace.add("#{name}::")
-        end
-
-        sig { params(name: String).returns(T::Boolean) }
-        def alias_namespaced?(name)
-          @alias_namespace.any? do |namespace|
-            name.start_with?(namespace)
-          end
-        end
-
-        sig { params(name: String).void }
-        def mark_seen(name)
-          @seen.add(name)
-        end
-
-        sig { params(name: String).returns(T::Boolean) }
-        def seen?(name)
-          @seen.include?(name)
-        end
-
-        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
-        def initialize_method_for(constant)
-          constant.instance_method(:initialize)
-        rescue
-          nil
-        end
-
-        sig { params(constant: Module).returns(T::Array[Module]) }
-        def interesting_ancestors_of(constant)
-          inherited_ancestors_ids = Set.new(
-            inherited_ancestors_of(constant).map { |mod| object_id_of(mod) }
-          )
-          # TODO: There is actually a bug here where this will drop modules that
-          # may be included twice. For example:
-          #
-          # ```ruby
-          # class Foo
-          #   prepend Kernel
-          # end
-          # ````
-          # would give:
-          # ```ruby
-          # Foo.ancestors #=> [Kernel, Foo, Object, Kernel, BasicObject]
-          # ````
-          # but since we drop `Kernel` whenever we match it, we would miss
-          # the `prepend Kernel` in the output.
-          #
-          # Instead, we should only drop the tail matches of the ancestors and
-          # inherited ancestors, past the location of the constant itself.
-          constant.ancestors.reject do |mod|
-            inherited_ancestors_ids.include?(object_id_of(mod))
-          end
-        end
-
-        sig { params(constant: Module).returns(T.nilable(String)) }
-        def name_of(constant)
-          name = name_of_proxy_target(constant, super(class_of(constant)))
-          return name if name
-          name = super(constant)
-          return if name.nil?
-          return unless are_equal?(constant, constantize(name, inherit: true))
-          name = "Struct" if name =~ /^(::)?Struct::[^:]+$/
-          name
-        end
-
-        sig { params(constant: T.all(Module, T::Generic)).returns(String) }
-        def generic_name_of(constant)
-          type_name = T.must(constant.name)
-          return type_name if type_name =~ /\[.*\]$/
-
-          type_variables = Tapioca::GenericTypeRegistry.lookup_type_variables(constant)
-          return type_name unless type_variables
-
-          type_variable_names = type_variables.map { "T.untyped" }.join(", ")
-
-          "#{type_name}[#{type_variable_names}]"
-        end
-
-        sig { params(constant: Module, class_name: T.nilable(String)).returns(T.nilable(String)) }
-        def name_of_proxy_target(constant, class_name)
-          return unless class_name == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
-          # We are dealing with a ActiveSupport::Deprecation::DeprecatedConstantProxy
-          # so try to get the name of the target class
-          begin
-            target = constant.__send__(:target)
-          rescue NoMethodError
-            return
-          end
-
-          name_of(target)
-        end
-
-        sig { params(name: String).returns(T::Array[RBI::Comment]) }
-        def documentation_comments(name)
-          return [] unless @include_doc
-
-          yard_docs = YARD::Registry.at(name)
-          return [] unless yard_docs
-
-          docstring = yard_docs.docstring
-          return [] if /(copyright|license)/i.match?(docstring)
-
-          docstring.lines
-            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } }
-            .map! { |line| RBI::Comment.new(line) }
-        end
-      end
-    end
-  end
-end