tapioca 0.16.9 → 0.17.7

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -2,14 +2,11 @@
 # frozen_string_literal: true
 
 module Tapioca
+  # @requires_ancestor: Thor::Shell
+  # @requires_ancestor: SorbetHelper
   module RBIFilesHelper
     extend T::Sig
-    extend T::Helpers
-
-    requires_ancestor { Thor::Shell }
-    requires_ancestor { SorbetHelper }
-
-    sig { params(index: RBI::Index, kind: String, file: String).void }
+    #: (RBI::Index index, String kind, String file) -> void
     def index_rbi(index, kind, file)
       return unless File.exist?(file)
 
@@ -21,7 +18,7 @@ module Tapioca
       say("(#{time.round(2)}s)")
     end
 
-    sig { params(index: RBI::Index, kind: String, dir: String, number_of_workers: T.nilable(Integer)).void }
+    #: (RBI::Index index, String kind, String dir, number_of_workers: Integer?) -> void
     def index_rbis(index, kind, dir, number_of_workers:)
       return unless Dir.exist?(dir) && !Dir.empty?(dir)
 
@@ -38,13 +35,7 @@ module Tapioca
       say("(#{time.round(2)}s)")
     end
 
-    sig do
-      params(
-        index: RBI::Index,
-        shim_rbi_dir: String,
-        todo_rbi_file: String,
-      ).returns(T::Hash[String, T::Array[RBI::Node]])
-    end
+    #: (RBI::Index index, shim_rbi_dir: String, todo_rbi_file: String) -> Hash[String, Array[RBI::Node]]
     def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:)
       duplicates = {}
       say("Looking for duplicates... ")
@@ -61,7 +52,7 @@ module Tapioca
       duplicates
     end
 
-    sig { params(loc: RBI::Loc, path_prefix: T.nilable(String)).returns(String) }
+    #: (RBI::Loc loc, path_prefix: String?) -> String
     def location_to_payload_url(loc, path_prefix:)
       return loc.to_s unless path_prefix
 
@@ -73,16 +64,7 @@ module Tapioca
       url
     end
 
-    sig do
-      params(
-        command: String,
-        gem_dir: String,
-        dsl_dir: String,
-        auto_strictness: T::Boolean,
-        gems: T::Array[Gemfile::GemSpec],
-        compilers: T::Enumerable[T.class_of(Dsl::Compiler)],
-      ).void
-    end
+    #: (command: String, gem_dir: String, dsl_dir: String, auto_strictness: bool, ?gems: Array[Gemfile::GemSpec], ?compilers: T::Enumerable[singleton(Dsl::Compiler)]) -> void
     def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])
       error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
 
@@ -146,12 +128,12 @@ module Tapioca
         update_gem_rbis_strictnesses(redef_errors, gem_dir)
       end
 
-      Kernel.raise Thor::Error, error_messages.join("\n") if parse_errors.any?
+      Kernel.raise Tapioca::Error, error_messages.join("\n") if parse_errors.any?
     end
 
     private
 
-    sig { params(index: RBI::Index, files: T::Array[String], number_of_workers: T.nilable(Integer)).void }
+    #: (RBI::Index index, Array[String] files, number_of_workers: Integer?) -> void
     def parse_and_index_files(index, files, number_of_workers:)
       executor = Executor.new(files, number_of_workers: number_of_workers)
 
@@ -167,64 +149,100 @@ module Tapioca
       index.visit_all(trees)
     end
 
-    sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String, todo_rbi_file: String).returns(T::Boolean) }
+    # Do the list of `nodes` sharing the same name have duplicates?
+    #: (Array[RBI::Node] nodes, shim_rbi_dir: String, todo_rbi_file: String) -> bool
     def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:)
+      # If there is only one node, there are no duplicates
       return false if nodes.size == 1
 
+      # Extract the nodes from the sorbet/rbi/shims/ directory and the todo.rbi file
       shims_or_todos = extract_shims_and_todos(nodes, shim_rbi_dir: shim_rbi_dir, todo_rbi_file: todo_rbi_file)
       return false if shims_or_todos.empty?
 
-      not_shims_or_todos = nodes - shims_or_todos
-      shims_or_todos_empty_scopes = extract_empty_scopes(shims_or_todos)
+      # First let's look into scopes (classes, modules, sclass) for duplicates
+      has_duplicated_scopes?(nodes, shims_or_todos) ||
+        # Then let's look into mixins
+        has_duplicated_mixins?(shims_or_todos) ||
+        # Finally, let's compare the methods and attributes with the same name
+        has_duplicated_methods_and_attrs?(nodes, shims_or_todos)
+    end
+
+    #: (Array[RBI::Node], Array[RBI::Node]) -> bool
+    def has_duplicated_scopes?(all_nodes, shims_or_todos)
+      shims_or_todos_scopes = shims_or_todos.grep(RBI::Scope)
+      return false if shims_or_todos_scopes.empty?
+
+      # Extract the empty scopes from the shims or todos
+      # We do not care about non-empty scopes because they hold definitions that we will check against Tapioca's
+      # generated RBI files in another iteration.
+      shims_or_todos_empty_scopes = shims_or_todos_scopes.select(&:empty?)
 
-      # We need to discard classes that are redefining the parent of a class
-      shims_or_todos_empty_scopes.select! do |scope|
+      # Extract the nodes that are not shims or todos (basically the nodes from the RBI files generated by Tapioca)
+      not_shims_or_todos = all_nodes - shims_or_todos
+
+      shims_or_todos_empty_scopes.any? do |scope|
         # Empty modules are always duplicates
-        next true unless scope.is_a?(RBI::Class)
+        break true unless scope.is_a?(RBI::Class)
 
         # Empty classes without parents are also duplicates
         parent_name = scope.superclass_name
-        next true unless parent_name
+        break true unless parent_name
 
         # Empty classes that are not redefining the parent are also duplicates
-        not_shims_or_todos.any? { |node| node.is_a?(RBI::Class) && node.superclass_name == parent_name }
+        break true if not_shims_or_todos.any? do |node|
+          node.is_a?(RBI::Class) && node.superclass_name == parent_name
+        end
       end
-      return true unless shims_or_todos_empty_scopes.empty?
+    end
 
-      mixins = extract_mixins(shims_or_todos)
-      return true unless mixins.empty?
+    #: (Array[RBI::Node] shims_or_todos) -> bool
+    def has_duplicated_mixins?(shims_or_todos)
+      # Don't forget `shims_or_todos` is a list of nodes with the same qualified name, so if we find two mixins of the
+      # same name, they _are_ about the same thing, like two `include(A)` or two `requires_ancestor(A)` so this is a
+      # duplicate
+      shims_or_todos.any? { |node| node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor) }
+    end
 
-      props = extract_methods_and_attrs(shims_or_todos)
-      return false if props.empty?
+    #: (Array[RBI::Node] nodes, Array[RBI::Node] shims_or_todos) -> bool
+    def has_duplicated_methods_and_attrs?(nodes, shims_or_todos)
+      shims_or_todos_props = extract_methods_and_attrs(shims_or_todos)
+      if shims_or_todos_props.any?
+        shims_or_todos_props.each do |shim_or_todo_prop|
+          other_nodes = extract_methods_and_attrs(nodes) - [shim_or_todo_prop]
 
-      shims_or_todos_with_sigs = extract_nodes_with_sigs(props)
-      shims_or_todos_with_sigs.each do |shim_or_todo|
-        shims_or_todos_sigs = shim_or_todo.sigs
+          if shim_or_todo_prop.sigs.empty?
+            # If the node doesn't have a signature and is an attribute accessor, we have a duplicate
+            return true if shim_or_todo_prop.is_a?(RBI::Attr)
 
-        extract_methods_and_attrs(nodes).each do |node|
-          next if node == shim_or_todo
-          return true if shims_or_todos_sigs.all? { |sig| node.sigs.include?(sig) }
-        end
+            # Now we know it's a method
+
+            # If the node has no parameters and we compare it against an attribute of the same name, it's a duplicate
+            return true if shim_or_todo_prop.params.empty? && other_nodes.grep(RBI::Attr).any?
 
-        return false
+            # If the node has parameters, we compare them against all the other methods
+            # If at least one of them has the same parameters, it's a duplicate
+            return true if other_nodes.grep(RBI::Method).any? { |other| shim_or_todo_prop.params == other.params }
+          end
+
+          # We compare the shim or todo prop with all the other props of the same name
+          other_nodes.each do |node|
+            # Another prop has the same sig, we have a duplicate
+            return true if shim_or_todo_prop.sigs.any? { |sig| node.sigs.include?(sig) }
+          end
+        end
       end
 
-      true
+      false
     end
 
-    sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String, todo_rbi_file: String).returns(T::Array[RBI::Node]) }
+    #: (Array[RBI::Node] nodes, shim_rbi_dir: String, todo_rbi_file: String) -> Array[RBI::Node]
     def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:)
       nodes.select do |node|
         node.loc&.file&.start_with?(shim_rbi_dir) || node.loc&.file == todo_rbi_file
       end
     end
 
-    sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[RBI::Scope]) }
-    def extract_empty_scopes(nodes)
-      T.cast(nodes.select { |node| node.is_a?(RBI::Scope) && node.empty? }, T::Array[RBI::Scope])
-    end
-
-    sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
+    #: (Array[RBI::Node] nodes) -> Array[(RBI::Method | RBI::Attr)]
     def extract_methods_and_attrs(nodes)
       T.cast(
         nodes.select do |node|
@@ -234,22 +252,7 @@ module Tapioca
       )
     end
 
-    sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Mixin, RBI::RequiresAncestor)]) }
-    def extract_mixins(nodes)
-      T.cast(
-        nodes.select do |node|
-          node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor)
-        end,
-        T::Array[T.all(RBI::Mixin, RBI::RequiresAncestor)],
-      )
-    end
-
-    sig { params(nodes: T::Array[T.any(RBI::Method, RBI::Attr)]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
-    def extract_nodes_with_sigs(nodes)
-      nodes.reject { |node| node.sigs.empty? }
-    end
-
-    sig { params(errors: T::Array[Spoom::Sorbet::Errors::Error], gem_dir: String).void }
+    #: (Array[Spoom::Sorbet::Errors::Error] errors, String gem_dir) -> void
     def update_gem_rbis_strictnesses(errors, gem_dir)
       files = []
 
@@ -276,7 +279,7 @@ module Tapioca
       say("\n")
     end
 
-    sig { params(path: String).returns(String) }
+    #: (String path) -> String
     def gem_name_from_rbi_path(path)
       T.must(File.basename(path, ".rbi").split("@").first)
     end

data/lib/tapioca/helpers/rbi_helper.rb

@@ -11,15 +11,7 @@ module Tapioca
     class << self
       extend T::Sig
 
-      sig do
-        params(
-          type: String,
-          variance: Symbol,
-          fixed: T.nilable(String),
-          upper: T.nilable(String),
-          lower: T.nilable(String),
-        ).returns(String)
-      end
+      #: (String type, Symbol variance, String? fixed, String? upper, String? lower) -> String
       def serialize_type_variable(type, variance, fixed, upper, lower)
         variance = nil if variance == :invariant
 
@@ -38,47 +30,47 @@ module Tapioca
       end
     end
 
-    sig { params(name: String, type: String).returns(RBI::TypedParam) }
+    #: (String name, type: String) -> RBI::TypedParam
     def create_param(name, type:)
       create_typed_param(RBI::ReqParam.new(name), type)
     end
 
-    sig { params(name: String, type: String, default: String).returns(RBI::TypedParam) }
+    #: (String name, type: String, default: String) -> RBI::TypedParam
     def create_opt_param(name, type:, default:)
       create_typed_param(RBI::OptParam.new(name, default), type)
     end
 
-    sig { params(name: String, type: String).returns(RBI::TypedParam) }
+    #: (String name, type: String) -> RBI::TypedParam
     def create_rest_param(name, type:)
       create_typed_param(RBI::RestParam.new(name), type)
     end
 
-    sig { params(name: String, type: String).returns(RBI::TypedParam) }
+    #: (String name, type: String) -> RBI::TypedParam
     def create_kw_param(name, type:)
       create_typed_param(RBI::KwParam.new(name), type)
     end
 
-    sig { params(name: String, type: String, default: String).returns(RBI::TypedParam) }
+    #: (String name, type: String, default: String) -> RBI::TypedParam
     def create_kw_opt_param(name, type:, default:)
       create_typed_param(RBI::KwOptParam.new(name, default), type)
     end
 
-    sig { params(name: String, type: String).returns(RBI::TypedParam) }
+    #: (String name, type: String) -> RBI::TypedParam
     def create_kw_rest_param(name, type:)
       create_typed_param(RBI::KwRestParam.new(name), type)
     end
 
-    sig { params(name: String, type: String).returns(RBI::TypedParam) }
+    #: (String name, type: String) -> RBI::TypedParam
     def create_block_param(name, type:)
       create_typed_param(RBI::BlockParam.new(name), type)
     end
 
-    sig { params(param: RBI::Param, type: String).returns(RBI::TypedParam) }
+    #: (RBI::Param param, String type) -> RBI::TypedParam
     def create_typed_param(param, type)
       RBI::TypedParam.new(param: param, type: sanitize_signature_types(type))
     end
 
-    sig { params(sig_string: String).returns(String) }
+    #: (String sig_string) -> String
     def sanitize_signature_types(sig_string)
       sig_string
         .gsub(".returns(<VOID>)", ".void")
@@ -87,7 +79,7 @@ module Tapioca
         .gsub(".params()", "")
     end
 
-    sig { params(type: String).returns(String) }
+    #: (String type) -> String
     def as_nilable_type(type)
       if type.start_with?("T.nilable(", "::T.nilable(") || type == "T.untyped" || type == "::T.untyped"
         type
@@ -96,7 +88,7 @@ module Tapioca
       end
     end
 
-    sig { params(type: String).returns(String) }
+    #: (String type) -> String
     def as_non_nilable_type(type)
       if type.match(/\A(?:::)?T.nilable\((.+)\)\z/)
         T.must(::Regexp.last_match(1))
@@ -105,12 +97,12 @@ module Tapioca
       end
     end
 
-    sig { params(name: String).returns(T::Boolean) }
+    #: (String name) -> bool
     def valid_method_name?(name)
       Prism.parse_success?("def self.#{name}(a); end")
     end
 
-    sig { params(name: String).returns(T::Boolean) }
+    #: (String name) -> bool
     def valid_parameter_name?(name)
       Prism.parse_success?("def sentinel_method_name(#{name}:); end")
     end

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -5,42 +5,33 @@ module Tapioca
   module SorbetHelper
     extend T::Sig
 
-    SORBET_GEM_SPEC = T.let(
-      ::Gem::Specification.find_by_name("sorbet-static"),
-      ::Gem::Specification,
-    )
+    SORBET_GEM_SPEC = ::Gem::Specification.find_by_name("sorbet-static") #: ::Gem::Specification
 
-    SORBET_BIN = T.let(
-      Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
-      Pathname,
-    )
+    SORBET_BIN = Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet" #: Pathname
 
     SORBET_EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
     SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
 
-    SPOOM_CONTEXT = T.let(Spoom::Context.new("."), Spoom::Context)
+    SPOOM_CONTEXT = Spoom::Context.new(".") #: Spoom::Context
 
-    FEATURE_REQUIREMENTS = T.let(
-      {
-        # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
-      }.freeze,
-      T::Hash[Symbol, ::Gem::Requirement],
-    )
+    FEATURE_REQUIREMENTS = {
+      # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
+    }.freeze #: Hash[Symbol, ::Gem::Requirement]
 
-    sig { params(sorbet_args: String).returns(Spoom::ExecResult) }
+    #: (*String sorbet_args) -> Spoom::ExecResult
     def sorbet(*sorbet_args)
       SPOOM_CONTEXT.srb(sorbet_args.join(" "), sorbet_bin: sorbet_path)
     end
 
-    sig { returns(String) }
+    #: -> String
     def sorbet_path
       sorbet_path = ENV.fetch(SORBET_EXE_PATH_ENV_VAR, SORBET_BIN)
       sorbet_path = SORBET_BIN if sorbet_path.empty?
       sorbet_path.to_s.shellescape
     end
 
-    sig { params(feature: Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
+    #: (Symbol feature, ?version: ::Gem::Version?) -> bool
     def sorbet_supports?(feature, version: nil)
       version = SORBET_GEM_SPEC.version unless version
       requirement = FEATURE_REQUIREMENTS[feature]

data/lib/tapioca/helpers/source_uri.rb

@@ -7,38 +7,28 @@ module Tapioca
   class SourceURI < URI::File
     extend T::Sig
 
-    COMPONENT = T.let(
-      [
-        :scheme,
-        :gem_name,
-        :gem_version,
-        :path,
-        :line_number,
-      ].freeze,
-      T::Array[Symbol],
-    )
+    COMPONENT = [
+      :scheme,
+      :gem_name,
+      :gem_version,
+      :path,
+      :line_number,
+    ].freeze #: Array[Symbol]
 
     # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
     # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
     # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
     # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
     # have the uri gem in their own bundle and thus not use a compatible version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :gem_version
 
     class << self
       extend T::Sig
 
-      sig do
-        params(
-          gem_name: String,
-          gem_version: T.nilable(String),
-          path: String,
-          line_number: T.nilable(String),
-        ).returns(T.attached_class)
-      end
+      #: (gem_name: String, gem_version: String?, path: String, line_number: String?) -> instance
       def build(gem_name:, gem_version:, path:, line_number:)
         super(
           {
@@ -51,24 +41,24 @@ module Tapioca
       end
     end
 
-    sig { returns(T.nilable(String)) }
+    #: -> String?
     def gem_name
       host
     end
 
-    sig { returns(T.nilable(String)) }
+    #: -> String?
     def line_number
       fragment
     end
 
-    sig { params(v: T.nilable(String)).void }
+    #: (String? v) -> void
     def set_path(v) # rubocop:disable Naming/AccessorMethodName
       return if v.nil?
 
       @gem_version, @path = v.split("/", 2)
     end
 
-    sig { params(v: T.nilable(String)).returns(T::Boolean) }
+    #: (String? v) -> bool
     def check_host(v)
       return true unless v
 
@@ -80,7 +70,7 @@ module Tapioca
       true
     end
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
     end

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

@@ -4,38 +4,35 @@
 module Tapioca
   module Helpers
     module Test
+      # @requires_ancestor: Kernel
       module Content
         extend T::Sig
-        extend T::Helpers
-
-        requires_ancestor { Kernel }
-
-        sig { void }
+        #: -> void
         def teardown
           super
           remove_tmp_path
         end
 
-        sig { params(args: String).returns(String) }
+        #: (*String args) -> String
         def tmp_path(*args)
-          @tmp_path = T.let(@tmp_path, T.nilable(String))
+          @tmp_path = @tmp_path #: String?
           @tmp_path ||= Dir.mktmpdir
           T.unsafe(File).join(@tmp_path, *args)
         end
 
-        sig { void }
+        #: -> void
         def remove_tmp_path
           FileUtils.rm_rf(tmp_path)
         end
 
-        sig { params(name: String, content: String, require_file: T::Boolean).returns(String) }
+        #: (String name, String content, ?require_file: bool) -> String
         def add_ruby_file(name, content, require_file: true)
           add_content_file(name, content).tap do |file_name|
             Tapioca.silence_warnings { require(file_name) } if require_file
           end
         end
 
-        sig { params(name: String, content: String).returns(String) }
+        #: (String name, String content) -> String
         def add_content_file(name, content)
           file_name = tmp_path("lib/#{name}")
           raise ArgumentError, "a file named '#{name}' was already added; cannot overwrite." if File.exist?(file_name)

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

@@ -10,47 +10,39 @@ require "tapioca/helpers/sorbet_helper"
 module Tapioca
   module Helpers
     module Test
+      # @requires_ancestor: Kernel
       module DslCompiler
         extend T::Sig
-        extend T::Helpers
-
         include Isolation
         include Content
         include Template
 
-        requires_ancestor { Kernel }
-
-        sig { params(compiler_class: T.class_of(Tapioca::Dsl::Compiler)).void }
+        #: (singleton(Tapioca::Dsl::Compiler) compiler_class) -> void
         def use_dsl_compiler(compiler_class)
-          @context = T.let(CompilerContext.new(compiler_class), T.nilable(CompilerContext))
+          @context = CompilerContext.new(compiler_class) #: CompilerContext?
         end
 
-        sig { params(compiler_classes: T.class_of(Tapioca::Dsl::Compiler)).void }
+        #: (*singleton(Tapioca::Dsl::Compiler) compiler_classes) -> void
         def activate_other_dsl_compilers(*compiler_classes)
           context.activate_other_dsl_compilers(compiler_classes)
         end
 
-        sig do
-          params(
-            constant_name: T.any(Symbol, String),
-            compiler_options: T::Hash[Symbol, T.untyped],
-          ).returns(String)
-        end
+        #: ((Symbol | String) constant_name, ?compiler_options: Hash[Symbol, untyped]) -> String
         def rbi_for(constant_name, compiler_options: {})
           context.rbi_for(constant_name, compiler_options: compiler_options)
         end
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def gathered_constants
           context.gathered_constants
         end
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def generated_errors
           context.errors
         end
 
-        sig { returns(CompilerContext) }
+        #: -> CompilerContext
         def context
           raise "Please call `use_dsl_compiler` before" unless @context
 
@@ -62,41 +54,36 @@ module Tapioca
 
           include SorbetHelper
 
-          sig { returns(T.class_of(Tapioca::Dsl::Compiler)) }
+          #: singleton(Tapioca::Dsl::Compiler)
           attr_reader :compiler_class
 
-          sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+          #: Array[singleton(Tapioca::Dsl::Compiler)]
           attr_reader :other_compiler_classes
 
-          sig { params(compiler_class: T.class_of(Tapioca::Dsl::Compiler)).void }
+          #: (singleton(Tapioca::Dsl::Compiler) compiler_class) -> void
           def initialize(compiler_class)
             @compiler_class = compiler_class
-            @other_compiler_classes = T.let([], T::Array[T.class_of(Tapioca::Dsl::Compiler)])
-            @pipeline = T.let(nil, T.nilable(Tapioca::Dsl::Pipeline))
-            @errors = T.let([], T::Array[String])
+            @other_compiler_classes = [] #: Array[singleton(Tapioca::Dsl::Compiler)]
+            @pipeline = nil #: Tapioca::Dsl::Pipeline?
+            @errors = [] #: Array[String]
           end
 
-          sig { params(compiler_classes: T::Array[T.class_of(Tapioca::Dsl::Compiler)]).void }
+          #: (Array[singleton(Tapioca::Dsl::Compiler)] compiler_classes) -> void
           def activate_other_dsl_compilers(compiler_classes)
             @other_compiler_classes = compiler_classes
           end
 
-          sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+          #: -> Array[singleton(Tapioca::Dsl::Compiler)]
           def activated_compiler_classes
             [compiler_class, *other_compiler_classes]
           end
 
-          sig { returns(T::Array[String]) }
+          #: -> Array[String]
           def gathered_constants
             compiler_class.processable_constants.filter_map(&:name).sort
           end
 
-          sig do
-            params(
-              constant_name: T.any(Symbol, String),
-              compiler_options: T::Hash[Symbol, T.untyped],
-            ).returns(String)
-          end
+          #: ((Symbol | String) constant_name, ?compiler_options: Hash[Symbol, untyped]) -> String
           def rbi_for(constant_name, compiler_options: {})
             # Make sure this is a constant that we can handle.
             unless gathered_constants.include?(constant_name.to_s)
@@ -131,14 +118,14 @@ module Tapioca
             rbi
           end
 
-          sig { returns(T::Array[String]) }
+          #: -> Array[String]
           def errors
             pipeline.errors
           end
 
           private
 
-          sig { returns(Tapioca::Dsl::Pipeline) }
+          #: -> Tapioca::Dsl::Pipeline
           def pipeline
             @pipeline ||= Tapioca::Dsl::Pipeline.new(
               requested_constants: [],