tapioca 0.4.14 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fb77a2510082edca1c068015be8fa3d25ed500762d05ccfb4a330588a76b182
-  data.tar.gz: a75827dff3d7c5a49ea5d213cd7ce6b749fd4d6a4dc017bb4a8f734613a97031
+  metadata.gz: 5f64e1f934bd0528e93322b0ba116383fc7c053d1a0c35a3378664ecc3e08e69
+  data.tar.gz: 609a1125626ba712e042e2fb3346df852508595bf22c0187e8ded67b3c66ecf2
 SHA512:
-  metadata.gz: 4d9283382edeed31a09989a789ee2441351e241558b97da8ffdb7d9a4aaa911ec8642bd5849d9b8e5800ea47ca4f9ae46b9e20cd3b0716670f25ca1304edea0b
-  data.tar.gz: ec2baf1e85947f754324fd06b67cf43979b8b27ccf27f21edb929f5b5758d38c8f6ceb00eec817a7219e273abb8014ae47e2d38cdbb059335e96ddb4414543a2
+  metadata.gz: 0ffc0244e7bd3d86ead0c42eb2cf9e940c84d4d838143b96247e908ded022477829c92c1838f2b933294b590eae49c2cd667c57bad6219be9b983ba3c556ddff
+  data.tar.gz: 33f534d1521e209052a7edff35fe95979497c80e3fcf78b136c3bb13ea3471f8e1158db83cafff5f3aaf79f0cfa6a00129fb20fb2ce92a018883f94fe61e0264

data/README.md

@@ -1,3 +1,5 @@
+> :warning: **Note**: This software is currently under active development. The API and interface should be considered unstable until a v1.0.0 release.
+
 # Tapioca
 
 ![Build Status](https://github.com/Shopify/tapioca/workflows/CI/badge.svg)
@@ -14,7 +16,7 @@ For gems that have a normal default `require` and load all of their constants th
 
 For example, suppose you are using the class `BetterHtml::Parser` exported from the `better_html` gem. Just doing a `require "better_html"` (which is the default require) does not load that type:
 
-```ruby
+```shell
 $ bundle exec pry
 [1] pry(main)> require 'better_html'
 => true
@@ -110,7 +112,7 @@ This will generate DSL RBIs for specified constants (or for all handled constant
 - `--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.
+- `--generate-command [command]`: **[DEPRECATED]** 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).
 
 ## Contributing

data/exe/tapioca

@@ -1,6 +1,21 @@
 #! /usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative "../lib/tapioca"
+require 'sorbet-runtime'
 
-Tapioca::Cli.start(ARGV)
+begin
+  T::Configuration.default_checked_level = :never
+  # Suppresses errors caused by T.cast, T.let, T.must, etc.
+  T::Configuration.inline_type_error_handler = ->(*) {}
+  # Suppresses errors caused by incorrect parameter ordering
+  T::Configuration.sig_validation_error_handler = ->(*) {}
+rescue
+  # Need this rescue so that if another gem has
+  # already set the checked level by the time we
+  # get to it, we don't fail outright.
+  nil
+end
+
+require_relative "../lib/tapioca/internal"
+
+Tapioca::Cli::Main.start(ARGV)

data/lib/tapioca.rb

@@ -17,31 +17,5 @@ module Tapioca
   class Error < StandardError; end
 end
 
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
-
-require "tapioca/loader"
-require "tapioca/constant_locator"
-require "tapioca/config"
-require "tapioca/config_builder"
-require "tapioca/generator"
-require "tapioca/cli"
-require "tapioca/gemfile"
-require "tapioca/compilers/sorbet"
-require "tapioca/compilers/requires_compiler"
-require "tapioca/compilers/symbol_table_compiler"
-require "tapioca/compilers/symbol_table/symbol_generator"
-require "tapioca/compilers/symbol_table/symbol_loader"
-require "tapioca/compilers/todos_compiler"
-require "tapioca/compilers/dsl_compiler"
+require "tapioca/compilers/dsl/base"
 require "tapioca/version"

data/lib/tapioca/cli.rb

@@ -4,112 +4,5 @@
 require 'thor'
 
 module Tapioca
-  class Cli < Thor
-    include(Thor::Actions)
-
-    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"],
-                  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 :exclude,
-                  aliases: ["-x"],
-                  type: :array,
-                  banner: "gem [gem ...]",
-                  desc: "Excludes the given gem(s) from RBI generation"
-    class_option :typed_overrides,
-                  aliases: ["--typed", "-t"],
-                  type: :hash,
-                  banner: "gem:level [gem:level ...]",
-                  desc: "Overrides for typed sigils for generated gem RBIs"
-
-    map T.unsafe(%w[--version -v] => :__print_version)
-
-    desc "init", "initializes folder structure"
-    def init
-      create_file(Config::SORBET_CONFIG, skip: true) do
-        <<~CONTENT
-          --dir
-          .
-        CONTENT
-      end
-      create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
-        <<~CONTENT
-          # typed: false
-          # frozen_string_literal: true
-
-          # Add your extra requires here
-        CONTENT
-      end
-    end
-
-    desc "require", "generate the list of files to be required by tapioca"
-    def require
-      Tapioca.silence_warnings do
-        generator.build_requires
-      end
-    end
-
-    desc "todo", "generate the list of unresolved constants"
-    def todo
-      Tapioca.silence_warnings do
-        generator.build_todos
-      end
-    end
-
-    desc "dsl [constant...]", "generate RBIs for dynamic methods"
-    option :generators,
-      type: :array,
-      aliases: ["--gen", "-g"],
-      banner: "generator [generator ...]",
-      desc: "Only run supplied DSL generators"
-    def dsl(*constants)
-      Tapioca.silence_warnings do
-        generator.build_dsl(constants)
-      end
-    end
-
-    desc "generate [gem...]", "generate RBIs from gems"
-    def generate(*gems)
-      Tapioca.silence_warnings do
-        generator.build_gem_rbis(gems)
-      end
-    end
-
-    desc "sync", "sync RBIs to Gemfile"
-    def sync
-      Tapioca.silence_warnings do
-        generator.sync_rbis_with_gemfile
-      end
-    end
-
-    desc "--version, -v", "show version"
-    def __print_version
-      puts "Tapioca v#{Tapioca::VERSION}"
-    end
-
-    no_commands do
-      def self.exit_on_failure?
-        true
-      end
-
-      def generator
-        current_command = T.must(current_command_chain.first)
-        @generator ||= Generator.new(
-          ConfigBuilder.from_options(current_command, options)
-        )
-      end
-    end
-  end
+  module Cli; end
 end

data/lib/tapioca/cli/main.rb

@@ -0,0 +1,142 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Cli
+    class Main < Thor
+      include(Thor::Actions)
+
+      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"],
+                    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 :exclude,
+                    aliases: ["-x"],
+                    type: :array,
+                    banner: "gem [gem ...]",
+                    desc: "Excludes the given gem(s) from RBI generation"
+      class_option :typed_overrides,
+                    aliases: ["--typed", "-t"],
+                    type: :hash,
+                    banner: "gem:level [gem:level ...]",
+                    desc: "Overrides for typed sigils for generated gem RBIs"
+
+      map T.unsafe(%w[--version -v] => :__print_version)
+
+      desc "init", "initializes folder structure"
+      def init
+        create_config
+        create_post_require
+        generate_binstub
+      end
+
+      desc "require", "generate the list of files to be required by tapioca"
+      def require
+        Tapioca.silence_warnings do
+          generator.build_requires
+        end
+      end
+
+      desc "todo", "generate the list of unresolved constants"
+      def todo
+        Tapioca.silence_warnings do
+          generator.build_todos
+        end
+      end
+
+      desc "dsl [constant...]", "generate RBIs for dynamic methods"
+      option :generators,
+        type: :array,
+        aliases: ["--gen", "-g"],
+        banner: "generator [generator ...]",
+        desc: "Only run supplied DSL generators"
+      option :verify,
+        type: :boolean,
+        default: false,
+        desc: "Verifies RBIs are up-to-date"
+      def dsl(*constants)
+        Tapioca.silence_warnings do
+          generator.build_dsl(constants, should_verify: options[:verify])
+        end
+      end
+
+      desc "generate [gem...]", "generate RBIs from gems"
+      def generate(*gems)
+        Tapioca.silence_warnings do
+          generator.build_gem_rbis(gems)
+        end
+      end
+
+      desc "sync", "sync RBIs to Gemfile"
+      def sync
+        Tapioca.silence_warnings do
+          generator.sync_rbis_with_gemfile
+        end
+      end
+
+      desc "--version, -v", "show version"
+      def __print_version
+        puts "Tapioca v#{Tapioca::VERSION}"
+      end
+
+      private
+
+      def create_config
+        create_file(Config::SORBET_CONFIG, skip: true) do
+          <<~CONTENT
+            --dir
+            .
+          CONTENT
+        end
+      end
+
+      def create_post_require
+        create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
+          <<~CONTENT
+            # typed: false
+            # frozen_string_literal: true
+
+            # Add your extra requires here
+          CONTENT
+        end
+      end
+
+      def generate_binstub
+        bin_stub_exists = File.exist?("bin/tapioca")
+        installer = Bundler::Installer.new(Bundler.root, Bundler.definition)
+        spec = Bundler.definition.specs.find { |s| s.name == "tapioca" }
+        installer.generate_bundler_executable_stubs(spec, { force: true })
+        if bin_stub_exists
+          shell.say_status(:force, "bin/tapioca", :yellow)
+        else
+          shell.say_status(:create, "bin/tapioca", :green)
+        end
+      end
+
+      no_commands do
+        def self.exit_on_failure?
+          true
+        end
+
+        def generator
+          current_command = T.must(current_command_chain.first)
+          @generator ||= Generator.new(
+            ConfigBuilder.from_options(current_command, options)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -371,7 +371,6 @@ module Tapioca
           return unless signature
 
           return_type = signature.return_type
-          return if T::Types::Simple === return_type && T::Generic === return_type.raw_type
           return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
 
           return_type.to_s
@@ -382,10 +381,11 @@ module Tapioca
           signature = T::Private::Methods.signature_for_method(column_type.method(method))
           return unless signature
 
-          arg_type = signature.arg_types.first.last
-          return if T::Types::Simple === arg_type && T::Generic === arg_type.raw_type
+          # Arg types is an array [name, type] entries, so we desctructure the type of
+          # first argument to get the first argument type
+          _, first_argument_type = signature.arg_types.first
 
-          arg_type.to_s
+          first_argument_type.to_s
         end
 
         sig { params(type: String).returns(String) }

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

@@ -60,7 +60,7 @@ module Tapioca
 
             model.create_module(module_name) do |mod|
               scope_method_names.each do |scope_method|
-                generate_scope_method(scope_method, mod)
+                generate_scope_method(scope_method.to_s, mod)
               end
             end
 

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

@@ -123,7 +123,7 @@ module Tapioca
         # Compile a Ruby method return type into a Parlour type
         sig do
           params(method_def: T.any(Method, UnboundMethod))
-            .returns(String)
+            .returns(T.nilable(String))
         end
         def compile_method_return_type_to_parlour(method_def)
           signature = T::Private::Methods.signature_for_method(method_def)

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

@@ -89,7 +89,7 @@ module Tapioca
       class UrlHelpers < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
         def decorate(root, constant)
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
@@ -127,7 +127,7 @@ module Tapioca
 
         private
 
-        sig { params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
+        sig { params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -143,7 +143,7 @@ module Tapioca
           end
         end
 
-        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module), helper_module: Module).void }
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: Module, helper_module: Module).void }
         def create_mixins_for(mod, constant, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/compilers/sorbet.rb

@@ -8,6 +8,7 @@ module Tapioca
   module Compilers
     module Sorbet
       SORBET = Pathname.new(Gem::Specification.find_by_name("sorbet-static").full_gem_path) / "libexec" / "sorbet"
+      EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
       class << self
         extend(T::Sig)
@@ -26,7 +27,9 @@ module Tapioca
 
         sig { returns(String) }
         def sorbet_path
-          SORBET.to_s.shellescape
+          sorbet_path = ENV.fetch(EXE_PATH_ENV_VAR, SORBET)
+          sorbet_path = SORBET if sorbet_path.empty?
+          sorbet_path.to_s.shellescape
         end
       end
     end

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

@@ -74,9 +74,15 @@ module Tapioca
           compile(symbol, constant)
         end
 
-        sig { params(symbol: String, inherit: T::Boolean).returns(BasicObject).checked(:never) }
-        def resolve_constant(symbol, inherit: false)
-          Object.const_get(symbol, inherit)
+        sig do
+          params(
+            symbol: String,
+            inherit: T::Boolean,
+            namespace: Module
+          ).returns(BasicObject).checked(:never)
+        end
+        def resolve_constant(symbol, inherit: false, namespace: Object)
+          namespace.const_get(symbol, inherit)
         rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
           nil
         end
@@ -95,6 +101,7 @@ module Tapioca
           return if alias_namespaced?(name)
           return if seen?(name)
           return unless parent_declares_constant?(name)
+          return if T::Enum === constant # T::Enum instances are defined via `compile_enums`
 
           mark_seen(name)
           compile_constant(name, constant)
@@ -141,9 +148,11 @@ module Tapioca
         def compile_object(name, value)
           return if symbol_ignored?(name)
           klass = class_of(value)
-          return if name_of(klass)&.start_with?("T::Types::", "T::Private::")
+          klass_name = name_of(klass)
+
+          return if klass_name&.start_with?("T::Types::", "T::Private::")
 
-          type_name = public_module?(klass) && name_of(klass) || "T.untyped"
+          type_name = public_module?(klass) && klass_name || "T.untyped"
           indented("#{name} = T.let(T.unsafe(nil), #{type_name})")
         end
 
@@ -180,15 +189,17 @@ module Tapioca
 
             [
               compile_module_helpers(constant),
+              compile_type_variables(constant),
               compile_mixins(constant),
               compile_mixes_in_class_methods(constant),
               compile_props(constant),
+              compile_enums(constant),
               methods,
-            ].select { |b| b != "" }.join("\n\n")
+            ].select { |b| b && !b.empty? }.join("\n\n")
           end
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_module_helpers(constant)
           abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type)
 
@@ -197,12 +208,14 @@ module Tapioca
           helpers << indented("final!") if T::Private::Final.final_module?(constant)
           helpers << indented("sealed!") if T::Private::Sealed.sealed_module?(constant)
 
+          return if helpers.empty?
+
           helpers.join("\n")
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_props(constant)
-          return "" unless T::Props::ClassMethods === constant
+          return unless T::Props::ClassMethods === constant
 
           constant.props.map do |name, prop|
             method = "prop"
@@ -217,6 +230,23 @@ module Tapioca
           end.join("\n")
         end
 
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_enums(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
+
+          content = [
+            indented('enums do'),
+            *enums.map { |e| indented("  #{e} = new") }.join("\n"),
+            indented('end'),
+          ]
+
+          content.join("\n")
+        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|
@@ -231,11 +261,71 @@ module Tapioca
             compile(symbol, subconstant)
           end.compact
 
-          return "" if output.empty?
+          return if output.empty?
 
           "\n" + output.join("\n\n")
         end
 
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_type_variables(constant)
+          type_variables = compile_type_variable_declarations(constant)
+          singleton_class_type_variables = compile_type_variable_declarations(singleton_class_of(constant))
+
+          return if !type_variables && !singleton_class_type_variables
+
+          type_variables += "\n" if type_variables
+          singleton_class_type_variables += "\n" if singleton_class_type_variables
+
+          [
+            type_variables,
+            singleton_class_type_variables,
+          ].compact.join("\n").rstrip
+        end
+
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_type_variable_declarations(constant)
+          with_indentation_for_constant(constant) do
+            # 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).map do |constant_name|
+              [
+                object_id_of(resolve_constant(constant_name.to_s, namespace: constant)),
+                constant_name,
+              ]
+            end.to_h
+
+            # 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_id, serialized_type_variable|
+              constant_name = subconstant_to_name_lookup[type_variable_id]
+              # 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
+              indented("#{constant_name} = #{serialized_type_variable}")
+            end.compact
+
+            return if type_variable_declarations.empty?
+
+            [
+              indented("extend T::Generic"),
+              "",
+              *type_variable_declarations,
+            ].compact.join("\n")
+          end
+        end
+
         sig { params(constant: Class).returns(String) }
         def compile_superclass(constant)
           superclass = T.let(nil, T.nilable(Class)) # rubocop:disable Lint/UselessAssignment
@@ -345,9 +435,13 @@ module Tapioca
             end
 
             define_singleton_method(:include) do |mod|
-              before = singleton_class.ancestors
-              super(mod).tap do
-                mixins_from_modules[mod] = singleton_class.ancestors - before
+              begin
+                before = singleton_class.ancestors
+                super(mod).tap do
+                  mixins_from_modules[mod] = singleton_class.ancestors - before
+                end
+              rescue Exception # rubocop:disable Lint/RescueException
+                # this is a best effort, bail if we can't perform this
               end
             end
 
@@ -408,29 +502,19 @@ module Tapioca
           instance_methods = compile_directly_owned_methods(name, constant)
           singleton_methods = compile_directly_owned_methods(name, singleton_class_of(constant))
 
-          return if symbol_ignored?(name) && instance_methods.empty? && singleton_methods.empty?
+          return if symbol_ignored?(name) && !instance_methods && !singleton_methods
 
           [
-            initialize_method || "",
+            initialize_method,
             instance_methods,
             singleton_methods,
-          ].select { |b| b.strip != "" }.join("\n\n")
+          ].select { |b| b && !b.strip.empty? }.join("\n\n")
         end
 
-        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(String) }
+        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(T.nilable(String)) }
         def compile_directly_owned_methods(module_name, mod, for_visibility = [:public, :protected, :private])
-          indent_step = 0
-          preamble = nil
-          postamble = nil
-
-          if mod.singleton_class?
-            indent_step = 1
-            preamble = indented("class << self")
-            postamble = indented("end")
-          end
-
-          methods = with_indentation(indent_step) do
-            method_names_by_visibility(mod)
+          with_indentation_for_constant(mod) do
+            methods = 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|
@@ -447,16 +531,11 @@ module Tapioca
                 compiled
               end
               .compact
-              .join("\n")
-          end
 
-          return "" if methods.strip == ""
+            return if methods.empty?
 
-          [
-            preamble,
-            methods,
-            postamble,
-          ].compact.join("\n")
+            methods.join("\n")
+          end
         end
 
         sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
@@ -636,6 +715,33 @@ module Tapioca
           @indent -= 2 * step
         end
 
+        sig do
+          params(
+            constant: Module,
+            blk: T.proc
+              .returns(T.nilable(String))
+          )
+            .returns(T.nilable(String))
+        end
+        def with_indentation_for_constant(constant, &blk)
+          step = if constant.singleton_class?
+            1
+          else
+            0
+          end
+
+          result = with_indentation(step, &blk)
+
+          return result unless result
+          return result unless constant.singleton_class?
+
+          [
+            indented("class << self"),
+            result,
+            indented("end"),
+          ].compact.join("\n")
+        end
+
         sig { params(str: String).returns(String) }
         def indented(str)
           " " * @indent + str
@@ -836,12 +942,12 @@ module Tapioca
           nil
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: T::Types::Base).returns(String) }
         def type_of(constant)
           constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
         end
 
-        sig { params(object: Object).returns(T::Boolean).checked(:never) }
+        sig { params(object: BasicObject).returns(Integer).checked(:never) }
         def object_id_of(object)
           Object.instance_method(:object_id).bind(object).call
         end