tapioca 0.0.1 → 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30b2f07033fc6b668d5f04c1a9dc33f6d06f776610b4e7051d89f8916695cb3f
+  data.tar.gz: 4b06d393137b287fd2b4c0a68955542ad9d9a3ab6be094c144ccc433b787c938
+SHA512:
+  metadata.gz: 886c53802ecd357a27d13b045cae53ac2c14dd90e3003d0142f33e410d911f25fc882587e8e19fd44b3d80e03a08eaaa665657943936c6c154c49e44edb4e822
+  data.tar.gz: 3183720c7eaa9e89fdda702cbdaa1872eb7ae4ddf0b9b6ba329844a0db6ff29df7adaf2da33c2a92be73605b74eec7c639fa1dbf529f15a86d95d6ae26053bbf

data/Gemfile

@@ -1,4 +1,13 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source("https://rubygems.org")
 
-# Specify your gem's dependencies in tapioca.gemspec
 gemspec
+
+group(:deployment) do
+  gem("package_cloud", "~> 0.2.33")
+end
+
+group(:deployment, :development) do
+  gem("rake", "~> 12.3")
+end

data/README.md

@@ -1,17 +1,61 @@
 # Tapioca
 
-One project to glue them all
+[![Build Status](https://travis-ci.com/Shopify/tapioca.svg?token=AuiMGLmuYDrK2mb81pyq&branch=master)](https://travis-ci.com/Shopify/tapioca)
+
+Tapioca is a library used to generate RBI (Ruby interface) files for use with [Sorbet](https://sorbet.org). RBI files provide the structure (classes, modules, methods, parameters) of the gem/library to Sorbet to assist with typechecking. 
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'tapioca', '~> 0.1.2', require: false
+```
+
+and do not forget to execute `tapioca` using `bundler`:
+
+```shell
+$ bundle exec tapioca
+Commands:
+  tapioca bundle             # sync RBIs to Gemfile
+  tapioca generate [gem...]  # generate RBIs from gems
+  tapioca help [COMMAND]     # Describe available commands or one specific command
+
+Options:
+  --pre, -b, [--prerequire=file]              # A file to be required before Bundler.require is called
+  --post, -a, [--postrequire=file]            # A file to be required after Bundler.require is called
+  --out, -o, [--outdir=directory]             # The output directory for generated RBI files
+                                              # Default: sorbet/rbi/gems
+  --cmd, -c, [--generate-command=command]     # The command to run to regenerate RBI files
+  --typed, -t, [--typed-overrides=gem:level]  # Overrides for typed sigils for generated gem RBIs
+```
+
+## Usage
+
+### Generate for gems
+
+Command: `tapioca generate [gems...]`
+
+This will generate RBIs for the specified gems and place them in the RBI directory.
+
+### Generate for all gems in Gemfile
+
+Command: `tapioca bundle`
+
+This will sync the RBIs with the gems in the Gemfile and will add, update, and remove RBIs as necessary.
+
+### Flags
 
-    gem 'tapioca'
+- `--prerequire [file]`: A file to be required before `Bundler.require` is called.
+- `--postrequire [file]`: A file to be required after `Bundler.require` is called.
+- `--out [directory]`: The output directory for generated RBI files, default to `sorbet/rbi/gems`.
+- `--generate_command [command]`: The command to run to regenerate RBI files (used in header comment of the RBI files), defaults to the current command.
+- `--typed_overrides [gem:level]`: Overrides typed sigils for generated gem RBIs for gem `gem` to level `level` (`level` can be one of `ignore`, `false`, `true`, `strict`, or `strong`, see [the Sorbet docs](https://sorbet.org/docs/static#file-level-granularity-strictness-levels) for more details).
 
-And then execute:
+## Contributing
 
-    $ bundle
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/tapioca. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-Or install it yourself as:
+## License
 
-    $ gem install tapioca
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,2 +1,12 @@
-#!/usr/bin/env rake
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+end
+
+task(default: :spec)

data/exe/tapioca

@@ -0,0 +1,6 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/tapioca"
+
+Tapioca::Cli.start(ARGV)

data/lib/t.rb

@@ -0,0 +1,50 @@
+unless defined?(T)
+  module T
+    def self.any(type_a, type_b, *types); end
+    def self.nilable(type); end
+    def self.untyped; end
+    def self.noreturn; end
+    def self.all(type_a, type_b, *types); end
+    def self.enum(values); end
+    def self.proc; end
+    def self.self_type; end
+    def self.class_of(klass); end
+    def self.type_alias(type); end
+    def self.type_parameter(name); end
+
+    def self.cast(value, type, checked: true); value; end
+    def self.let(value, type, checked: true); value; end
+    def self.assert_type!(value, type, checked: true); value; end
+    def self.unsafe(value); value; end
+    def self.must(arg, msg=nil); arg; end
+    def self.reveal_type(value); value; end
+  end
+
+  module T::Sig
+    def sig(&blk); end
+  end
+
+  module T::Array
+    def self.[](type); end
+  end
+
+  module T::Hash
+    def self.[](keys, values); end
+  end
+
+  module T::Enumerable
+    def self.[](type); end
+  end
+
+  module T::Range
+    def self.[](type); end
+  end
+
+  module T::Set
+    def self.[](type); end
+  end
+
+  module T::Boolean
+  end
+end
+

data/lib/tapioca.rb

@@ -1,4 +1,21 @@
-require "tapioca/version"
+# typed: true
+# frozen_string_literal: true
+
+require "zeitwerk"
+require_relative "./t"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+loader.eager_load
 
 module Tapioca
+  def self.silence_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbosity
+  end
+
+  class Error < StandardError; end
 end

data/lib/tapioca/cli.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# typed: false
+
+require 'thor'
+
+module Tapioca
+  class Cli < Thor
+    class_option :prerequire,
+                  aliases: ["--pre", "-b"],
+                  banner: "file",
+                  desc: "A file to be required before Bundler.require is called"
+    class_option :postrequire,
+                  aliases: ["--post", "-a"],
+                  banner: "file",
+                  desc: "A file to be required after Bundler.require is called"
+    class_option :outdir,
+                  aliases: ["--out", "-o"],
+                  default: Generator::DEFAULT_OUTDIR,
+                  banner: "directory",
+                  desc: "The output directory for generated RBI files"
+    class_option :generate_command,
+                  aliases: ["--cmd", "-c"],
+                  banner: "command",
+                  desc: "The command to run to regenerate RBI files"
+    class_option :typed_overrides,
+                  aliases: ["--typed", "-t"],
+                  type: :hash,
+                  default: {},
+                  banner: "gem:level",
+                  desc: "Overrides for typed sigils for generated gem RBIs"
+
+    desc "generate [gem...]", "generate RBIs from gems"
+    def generate(*gems)
+      Tapioca.silence_warnings do
+        generator.build_gem_rbis(gems)
+      end
+    end
+
+    desc "bundle", "sync RBIs to Gemfile"
+    def bundle
+      Tapioca.silence_warnings do
+        generator.sync_rbis_with_gemfile
+      end
+    end
+
+    no_commands do
+      def generator
+        @generator ||= Generator.new(
+          outdir: options[:outdir],
+          prerequire: options[:prerequire],
+          postrequire: options[:postrequire],
+          command: options[:generate_command],
+          typed_overrides: options[:typed_overrides]
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,571 @@
+# frozen_string_literal: true
+# typed: true
+
+require 'pathname'
+
+module Tapioca
+  module Compilers
+    module SymbolTable
+      class SymbolGenerator
+        extend(T::Sig)
+
+        IGNORED_SYMBOLS = %w{
+          YAML
+          MiniTest
+          Mutex
+        }
+
+        attr_reader(:gem, :indent)
+
+        sig { params(gem: Gemfile::Gem, indent: Integer).void }
+        def initialize(gem, indent = 0)
+          @gem = gem
+          @indent = indent
+          @seen = Set.new
+          @alias_namespace ||= Set.new
+        end
+
+        sig { returns(String) }
+        def generate
+          symbols
+            .sort
+            .map(&method(:generate_from_symbol))
+            .compact
+            .join("\n\n")
+            .concat("\n")
+        end
+
+        private
+
+        sig { returns(T::Set[String]) }
+        def symbols
+          symbols = Tapioca::Compilers::SymbolTable::SymbolLoader.list_from_paths(gem.files)
+          symbols.union(engine_symbols(symbols))
+        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 = Object.const_get("Rails::Engine")
+            .descendants.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(symbol: String).returns(T.nilable(String)) }
+        def generate_from_symbol(symbol)
+          constant = resolve_constant(symbol)
+
+          return unless constant
+
+          compile(symbol, constant)
+        end
+
+        sig { params(symbol: String).returns(BasicObject) }
+        def resolve_constant(symbol)
+          Object.const_get(symbol, false)
+        rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
+          nil
+        end
+
+        sig { params(name: T.nilable(String), constant: BasicObject).returns(T.nilable(String)) }
+        def compile(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 unless parent_declares_constant?(name)
+
+          mark_seen(name)
+          compile_constant(name, constant)
+        end
+
+        sig { params(name: String, constant: BasicObject).returns(T.nilable(String)) }
+        def compile_constant(name, constant)
+          case constant
+          when Module
+            if name_of(constant) != name
+              compile_alias(name, constant)
+            else
+              compile_module(name, constant)
+            end
+          else
+            compile_object(name, constant)
+          end
+        end
+
+        sig { params(name: String, constant: Module).returns(T.nilable(String)) }
+        def compile_alias(name, constant)
+          return if symbol_ignored?(name)
+
+          constant_name = name_of(constant)
+          add_to_alias_namespace(name)
+
+          return if IGNORED_SYMBOLS.include?(name)
+
+          indented("#{name} = #{constant_name}")
+        end
+
+        sig { params(name: String, value: BasicObject).returns(T.nilable(String)) }
+        def compile_object(name, value)
+          indented("#{name} = T.let(T.unsafe(nil), #{type_name_of(value)})")
+        end
+
+        sig { params(value: BasicObject).returns(String) }
+        def type_name_of(value)
+          klass = class_of(value)
+
+          type_name = public_module?(klass) && name_of(klass) || "T.untyped"
+          # Range needs to be processed separately to be put in the T::Range[] form
+          type_name = "T::Range[#{type_name_of(T.cast(value, T::Range[T.untyped]).first)}]" if klass == Range
+
+          type_name
+        end
+
+        sig { params(name: String, constant: Module).returns(T.nilable(String)) }
+        def compile_module(name, constant)
+          return unless public_module?(constant)
+          return unless defined_in_gem?(constant, strict: false)
+
+          header =
+            if constant.is_a?(Class)
+              indented("class #{name}#{compile_superclass(constant)}")
+            else
+              indented("module #{name}")
+            end
+
+          body = compile_body(name, constant)
+
+          return if symbol_ignored?(name) && body.nil?
+
+          [
+            header,
+            body,
+            indented("end"),
+            compile_subconstants(name, constant),
+          ].select { |b| !b.nil? && b.strip != "" }.join("\n")
+        end
+
+        sig { params(name: String, constant: Module).returns(T.nilable(String)) }
+        def compile_body(name, constant)
+          with_indentation do
+            methods = compile_methods(name, constant)
+
+            return if symbol_ignored?(name) && methods.nil?
+
+            [
+              compile_mixins(constant),
+              methods,
+            ].select { |b| b != "" }.join("\n\n")
+          end
+        end
+
+        sig { params(name: String, constant: Module).returns(T.nilable(String)) }
+        def compile_subconstants(name, constant)
+          output = constants_of(constant).sort.uniq.map do |constant_name|
+            symbol = (name == "Object" ? "" : name) + "::#{constant_name}"
+            subconstant = resolve_constant(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(symbol, subconstant)
+          end.compact
+
+          return "" if output.empty?
+
+          "\n" + output.join("\n\n")
+        end
+
+        sig { params(constant: Class).returns(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 classes have superclasses that are private constants
+            # so if we generate code with that superclass, the output
+            # will not be compilable (since private constants are not
+            # publicly visible).
+            #
+            # So we skip superclasses that are not public and walk up the
+            # chain.
+            next unless public_module?(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 = T.must(name_of(superclass))
+            resolved_superclass = resolve_constant(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?
+
+          " < ::#{name}"
+        end
+
+        sig { params(constant: Module).returns(String) }
+        def compile_mixins(constant)
+          ignorable_ancestors =
+            if constant.is_a?(Class)
+              ancestors = constant.superclass&.ancestors || Object.ancestors
+              Set.new(ancestors)
+            else
+              Module.ancestors
+            end
+
+          inherited_singleton_class_ancestors =
+            if constant.is_a?(Class)
+              Set.new(constant.superclass.singleton_class.ancestors)
+            else
+              Module.ancestors
+            end
+
+          interesting_ancestors =
+            constant.ancestors.reject { |mod| ignorable_ancestors.include?(mod) }
+
+          prepend = interesting_ancestors.take_while { |c| !are_equal?(constant, c) }
+          include = interesting_ancestors.drop(prepend.size + 1)
+          extend  = constant.singleton_class.ancestors
+            .reject do |mod|
+              mod == constant.singleton_class ||
+                inherited_singleton_class_ancestors.include?(mod) ||
+                !public_module?(mod) ||
+                Module != class_of(mod)
+            end
+
+          prepends = prepend
+            .select(&method(:name_of))
+            .select(&method(:public_module?))
+            .map do |mod|
+              # TODO: Sorbet currently does not handle prepend
+              # properly for method resolution, so we generate an
+              # include statement instead
+              indented("include(#{qualified_name_of(mod)})")
+            end
+
+          includes = include
+            .select(&method(:name_of))
+            .select(&method(:public_module?))
+            .map do |mod|
+              indented("include(#{qualified_name_of(mod)})")
+            end
+
+          extends = extend
+            .select(&method(:name_of))
+            .select(&method(:public_module?))
+            .map do |mod|
+              indented("extend(#{qualified_name_of(mod)})")
+            end
+
+          mixes_class_methods = extend
+            .select do |mod|
+              qualified_name_of(mod) == "::ActiveSupport::Concern" &&
+                Module === resolve_constant("#{name_of(constant)}::ClassMethods")
+            end
+            .first(1)
+            .flat_map do
+              ["", indented("mixes_in_class_methods(ClassMethods)")]
+            end
+
+          (prepends + includes + extends + mixes_class_methods).join("\n")
+        end
+
+        sig { params(name: String, constant: Module).returns(T.nilable(String)) }
+        def compile_methods(name, constant)
+          initialize_method = compile_method(
+            name,
+            constant,
+            initialize_method_for(constant)
+          )
+
+          instance_methods = compile_directly_owned_methods(name, constant)
+          singleton_methods = compile_directly_owned_methods(name, constant.singleton_class, [:public])
+
+          return if symbol_ignored?(name) && instance_methods.empty? && singleton_methods.empty?
+
+          [
+            initialize_method || "",
+            instance_methods,
+            singleton_methods,
+          ].select { |b| b.strip != "" }.join("\n\n")
+        end
+
+        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(String) }
+        def compile_directly_owned_methods(module_name, mod, for_visibility = [:public, :protected, :private])
+          method_names_by_visibility(mod)
+            .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
+            .flat_map do |visibility, method_list|
+              compiled = method_list.sort!.map do |name|
+                next if name == :initialize
+                compile_method(module_name, mod, mod.instance_method(name))
+              end
+              compiled.compact!
+
+              unless compiled.empty? || visibility == :public
+                # add visibility badge
+                compiled.unshift('', indented(visibility.to_s), '')
+              end
+
+              compiled
+            end
+            .compact
+            .join("\n")
+        end
+
+        sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+        def method_names_by_visibility(mod)
+          {
+            public: Module.instance_method(:public_instance_methods).bind(mod).call,
+            protected: Module.instance_method(:protected_instance_methods).bind(mod).call,
+            private: Module.instance_method(:private_instance_methods).bind(mod).call,
+          }
+        end
+
+        sig do
+          params(
+            symbol_name: String,
+            constant: Module,
+            method: T.nilable(UnboundMethod)
+          ).returns(T.nilable(String))
+        end
+        def compile_method(symbol_name, constant, method)
+          return unless method
+          return unless method.owner == constant
+          return if symbol_ignored?(symbol_name) && !method_in_gem?(method)
+
+          method_name = method.name.to_s
+          return unless valid_method_name?(method_name)
+
+          params = T.let(method.parameters, T::Array[T::Array[Symbol]])
+          parameters = params.map do |(type, name)|
+            name ||= :_
+
+            case type
+            when :req
+              name.to_s
+            when :opt
+              "#{name} = _"
+            when :rest
+              "*#{name}"
+            when :keyreq
+              "#{name}:"
+            when :key
+              "#{name}: _"
+            when :keyrest
+              "**#{name}"
+            when :block
+              "&#{name}"
+            end
+          end.join(', ')
+
+          method_name.prepend(constant.singleton_class? ? 'self.' : '')
+          parameters = "(#{parameters})" if parameters != ""
+
+          indented("def #{method_name}#{parameters}; end")
+        end
+
+        sig { params(symbol_name: String).returns(T::Boolean) }
+        def symbol_ignored?(symbol_name)
+          SymbolLoader.ignore_symbol?(symbol_name)
+        end
+
+        sig { params(path: String).returns(T::Boolean) }
+        def path_in_gem?(path)
+          path.start_with?(gem.full_gem_path)
+        end
+
+        SPECIAL_METHOD_NAMES = %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `]
+
+        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 do
+          type_parameters(:U)
+            .params(
+              _blk: T.proc
+                .returns(T.type_parameter(:U))
+            )
+            .returns(T.type_parameter(:U))
+        end
+        def with_indentation(&_blk)
+          @indent += 2
+          yield
+        ensure
+          @indent -= 2
+        end
+
+        sig { params(str: String).returns(String) }
+        def indented(str)
+          " " * @indent + str
+        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?
+
+          path_in_gem?(source_location)
+        end
+
+        sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
+        def defined_in_gem?(constant, strict: true)
+          files = get_file_candidates(constant)
+
+          return !strict if files.empty?
+
+          files.any? do |file|
+            path_in_gem?(file)
+          end
+        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
+
+        def initialize_method_for(constant)
+          constant.instance_method(:initialize)
+        rescue
+          nil
+        end
+
+        def parent_declares_constant?(name)
+          name_parts = name.split("::")
+
+          parent_name = name_parts[0...-1].join("::").delete_prefix("::")
+          parent_name = 'Object' if parent_name == ""
+          parent = T.cast(resolve_constant(parent_name), T.nilable(Module))
+
+          return false unless parent
+
+          constants_of(parent).include?(name_parts.last.to_sym)
+        end
+
+        sig { params(constant: Module).returns(T::Boolean) }
+        def public_module?(constant)
+          constant_name = name_of(constant)
+          return false unless constant_name
+
+          begin
+            # can't use !! here because the constant might override ! and mess with us
+            Module === eval(constant_name) # rubocop:disable Security/Eval
+          rescue NameError
+            false
+          end
+        end
+
+        sig { params(constant: BasicObject).returns(Class) }
+        def class_of(constant)
+          Kernel.instance_method(:class).bind(constant).call
+        end
+
+        sig { params(constant: Module).returns(T::Array[Symbol]) }
+        def constants_of(constant)
+          Module.instance_method(:constants).bind(constant).call(false)
+        end
+
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def name_of(constant)
+          name = Module.instance_method(:name).bind(constant).call
+          return if name.nil?
+          return unless are_equal?(constant, resolve_constant(name))
+          name = "Struct" if name =~ /^(::)?Struct::[^:]+$/
+          name
+        end
+
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def qualified_name_of(constant)
+          name = name_of(constant)
+          return if name.nil?
+          name.prepend("::") unless name.start_with?("::")
+          name
+        end
+
+        sig { params(constant: Class).returns(T.nilable(Class)) }
+        def superclass_of(constant)
+          Class.instance_method(:superclass).bind(constant).call
+        end
+
+        sig { params(constant: Module, other: BasicObject).returns(T::Boolean) }
+        def are_equal?(constant, other)
+          BasicObject.instance_method(:equal?).bind(constant).call(other)
+        end
+      end
+    end
+  end
+end