tapioca 0.16.10 → 0.17.0

data/lib/tapioca/dsl/pipeline.rb

@@ -6,37 +6,25 @@ module Tapioca
     class Pipeline
       extend T::Sig
 
-      sig { returns(T::Enumerable[T.class_of(Compiler)]) }
+      #: T::Enumerable[singleton(Compiler)]
       attr_reader :active_compilers
 
-      sig { returns(T::Array[Module]) }
+      #: Array[Module]
       attr_reader :requested_constants
 
-      sig { returns(T::Array[Pathname]) }
+      #: Array[Pathname]
       attr_reader :requested_paths
 
-      sig { returns(T::Array[Module]) }
+      #: Array[Module]
       attr_reader :skipped_constants
 
-      sig { returns(T.proc.params(error: String).void) }
+      #: ^(String error) -> void
       attr_reader :error_handler
 
-      sig { returns(T::Array[String]) }
+      #: Array[String]
       attr_reader :errors
 
-      sig do
-        params(
-          requested_constants: T::Array[Module],
-          requested_paths: T::Array[Pathname],
-          requested_compilers: T::Array[T.class_of(Compiler)],
-          excluded_compilers: T::Array[T.class_of(Compiler)],
-          error_handler: T.proc.params(error: String).void,
-          skipped_constants: T::Array[Module],
-          number_of_workers: T.nilable(Integer),
-          compiler_options: T::Hash[String, T.untyped],
-          lsp_addon: T::Boolean,
-        ).void
-      end
+      #: (requested_constants: Array[Module], ?requested_paths: Array[Pathname], ?requested_compilers: Array[singleton(Compiler)], ?excluded_compilers: Array[singleton(Compiler)], ?error_handler: ^(String error) -> void, ?skipped_constants: Array[Module], ?number_of_workers: Integer?, ?compiler_options: Hash[String, untyped], ?lsp_addon: bool) -> void
       def initialize(
         requested_constants:,
         requested_paths: [],
@@ -48,10 +36,8 @@ module Tapioca
         compiler_options: {},
         lsp_addon: false
       )
-        @active_compilers = T.let(
-          gather_active_compilers(requested_compilers, excluded_compilers),
-          T::Enumerable[T.class_of(Compiler)],
-        )
+        @active_compilers =
+          gather_active_compilers(requested_compilers, excluded_compilers) #: Enumerable[singleton(Compiler)]
         @requested_constants = requested_constants
         @requested_paths = requested_paths
         @error_handler = error_handler
@@ -59,14 +45,10 @@ module Tapioca
         @number_of_workers = number_of_workers
         @compiler_options = compiler_options
         @lsp_addon = lsp_addon
-        @errors = T.let([], T::Array[String])
+        @errors = [] #: Array[String]
       end
 
-      sig do
-        type_parameters(:T).params(
-          blk: T.proc.params(constant: Module, rbi: RBI::File).returns(T.type_parameter(:T)),
-        ).returns(T::Array[T.type_parameter(:T)])
-      end
+      #: [T] { (Module constant, RBI::File rbi) -> T } -> Array[T]
       def run(&blk)
         constants_to_process = gather_constants(requested_constants, requested_paths, skipped_constants)
           .select { |c| Module === c } # Filter value constants out
@@ -78,6 +60,7 @@ module Tapioca
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
           ERROR
+          raise Thor::Error, ""
         end
 
         if defined?(::ActiveRecord::Base) && constants_to_process.any? { |c| ::ActiveRecord::Base > c }
@@ -94,19 +77,23 @@ module Tapioca
           blk.call(constant, rbi)
         end
 
-        errors.each do |msg|
-          report_error(msg)
+        if errors.any?
+          errors.each do |msg|
+            report_error(msg)
+          end
+
+          raise Thor::Error, ""
         end
 
         result.compact
       end
 
-      sig { params(error: String).void }
+      #: (String error) -> void
       def add_error(error)
         @errors << error
       end
 
-      sig { params(compiler_name: String).returns(T::Boolean) }
+      #: (String compiler_name) -> bool
       def compiler_enabled?(compiler_name)
         potential_names = Compilers::NAMESPACES.map { |namespace| namespace + compiler_name }
 
@@ -115,24 +102,16 @@ module Tapioca
         end
       end
 
-      sig { returns(T::Array[T.class_of(Compiler)]) }
+      #: -> Array[singleton(Compiler)]
       def compilers
-        @compilers ||= T.let(
-          Runtime::Reflection.descendants_of(Compiler).sort_by do |compiler|
-            T.must(compiler.name)
-          end,
-          T.nilable(T::Array[T.class_of(Compiler)]),
-        )
+        @compilers ||= Runtime::Reflection.descendants_of(Compiler).sort_by do |compiler|
+          T.must(compiler.name)
+        end #: Array[singleton(Compiler)]?
       end
 
       private
 
-      sig do
-        params(
-          requested_compilers: T::Array[T.class_of(Compiler)],
-          excluded_compilers: T::Array[T.class_of(Compiler)],
-        ).returns(T::Enumerable[T.class_of(Compiler)])
-      end
+      #: (Array[singleton(Compiler)] requested_compilers, Array[singleton(Compiler)] excluded_compilers) -> T::Enumerable[singleton(Compiler)]
       def gather_active_compilers(requested_compilers, excluded_compilers)
         active_compilers = compilers
         active_compilers -= excluded_compilers
@@ -140,13 +119,7 @@ module Tapioca
         active_compilers
       end
 
-      sig do
-        params(
-          requested_constants: T::Array[Module],
-          requested_paths: T::Array[Pathname],
-          skipped_constants: T::Array[Module],
-        ).returns(T::Set[Module])
-      end
+      #: (Array[Module] requested_constants, Array[Pathname] requested_paths, Array[Module] skipped_constants) -> Set[Module]
       def gather_constants(requested_constants, requested_paths, skipped_constants)
         Compiler.requested_constants = requested_constants
         constants = Set.new.compare_by_identity
@@ -168,7 +141,7 @@ module Tapioca
         constants
       end
 
-      sig { params(constants: T::Set[Module]).returns(T::Set[Module]) }
+      #: (Set[Module] constants) -> Set[Module]
       def filter_anonymous_and_reloaded_constants(constants)
         # Group constants by their names
         constants_by_name = constants
@@ -197,7 +170,7 @@ module Tapioca
         Set.new.compare_by_identity.merge(filtered_constants)
       end
 
-      sig { params(constant: Module).returns(T.nilable(RBI::File)) }
+      #: (Module constant) -> RBI::File?
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
@@ -216,14 +189,13 @@ module Tapioca
         file
       end
 
-      sig { params(error: String).returns(T.noreturn) }
+      #: (String error) -> void
       def report_error(error)
         handler = error_handler
         handler.call(error)
-        exit(1)
       end
 
-      sig { void }
+      #: -> void
       def abort_if_pending_migrations!
         # When running within the add-on, we cannot invoke the abort if pending migrations task because that will exit
         # the process and crash the Rails runtime server. Instead, the Rails add-on checks for pending migrations and

data/lib/tapioca/executor.rb

@@ -5,26 +5,20 @@ module Tapioca
   class Executor
     extend T::Sig
 
-    MINIMUM_ITEMS_PER_WORKER = T.let(2, Integer)
+    MINIMUM_ITEMS_PER_WORKER = 2 #: Integer
 
-    sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(Integer)).void }
+    #: (Array[untyped] queue, ?number_of_workers: Integer?) -> void
     def initialize(queue, number_of_workers: nil)
       @queue = queue
 
       # Forking workers is expensive and not worth it for a low number of gems. Here we assign the number of workers to
       # be the minimum between the number of available processors (max) or the number of workers to make sure that each
       # one has at least 4 items to process
-      @number_of_workers = T.let(
-        number_of_workers || [max_processors, (queue.length.to_f / MINIMUM_ITEMS_PER_WORKER).ceil].min,
-        Integer,
-      )
+      @number_of_workers = number_of_workers ||
+        [max_processors, (queue.length.to_f / MINIMUM_ITEMS_PER_WORKER).ceil].min #: Integer
     end
 
-    sig do
-      type_parameters(:T).params(
-        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T)),
-      ).returns(T::Array[T.type_parameter(:T)])
-    end
+    #: [T] { (untyped item) -> T } -> Array[T]
     def run_in_parallel(&block)
       # To have the parallel gem run jobs in the parent process, you must pass 0 as the number of processes
       number_of_processes = @number_of_workers == 1 ? 0 : @number_of_workers
@@ -33,7 +27,7 @@ module Tapioca
 
     private
 
-    sig { returns(Integer) }
+    #: -> Integer
     def max_processors
       env_max_processors = ENV["PARALLEL_PROCESSOR_COUNT"].to_i
       env_max_processors.positive? ? env_max_processors : Etc.nprocessors

data/lib/tapioca/gem/events.rb

@@ -13,10 +13,10 @@ module Tapioca
     class SymbolFound < Event
       extend T::Sig
 
-      sig { returns(String) }
+      #: String
       attr_reader :symbol
 
-      sig { params(symbol: String).void }
+      #: (String symbol) -> void
       def initialize(symbol)
         super()
         @symbol = symbol
@@ -26,13 +26,15 @@ module Tapioca
     class ConstantFound < Event
       extend T::Sig
 
-      sig { returns(String) }
+      #: String
       attr_reader :symbol
 
-      sig { returns(BasicObject).checked(:never) }
+      # @without_runtime
+      #: BasicObject
       attr_reader :constant
 
-      sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
+      # @without_runtime
+      #: (String symbol, BasicObject constant) -> void
       def initialize(symbol, constant)
         super()
         @symbol = symbol
@@ -43,12 +45,13 @@ module Tapioca
     class ForeignConstantFound < ConstantFound
       extend T::Sig
 
-      sig { override.returns(Module) }
+      # @override
+      #: -> Module
       def constant
         T.cast(@constant, Module)
       end
 
-      sig { params(symbol: String, constant: Module).void }
+      #: (String symbol, Module constant) -> void
       def initialize(symbol, constant)
         super
       end
@@ -60,13 +63,13 @@ module Tapioca
 
       abstract!
 
-      sig { returns(String) }
+      #: String
       attr_reader :symbol
 
-      sig { returns(Module).checked(:never) }
+      #: Module
       attr_reader :constant
 
-      sig { params(symbol: String, constant: Module).void.checked(:never) }
+      #: (String symbol, Module constant) -> void
       def initialize(symbol, constant)
         super()
         @symbol = symbol
@@ -77,10 +80,10 @@ module Tapioca
     class ConstNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(RBI::Const) }
+      #: RBI::Const
       attr_reader :node
 
-      sig { params(symbol: String, constant: Module, node: RBI::Const).void.checked(:never) }
+      #: (String symbol, Module constant, RBI::Const node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -90,10 +93,10 @@ module Tapioca
     class ScopeNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(RBI::Scope) }
+      #: RBI::Scope
       attr_reader :node
 
-      sig { params(symbol: String, constant: Module, node: RBI::Scope).void.checked(:never) }
+      #: (String symbol, Module constant, RBI::Scope node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -105,28 +108,19 @@ module Tapioca
     class MethodNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(UnboundMethod) }
+      #: UnboundMethod
       attr_reader :method
 
-      sig { returns(RBI::Method) }
+      #: RBI::Method
       attr_reader :node
 
-      sig { returns(T.untyped) }
+      #: untyped
       attr_reader :signature
 
-      sig { returns(T::Array[[Symbol, String]]) }
+      #: Array[[Symbol, String]]
       attr_reader :parameters
 
-      sig do
-        params(
-          symbol: String,
-          constant: Module,
-          method: UnboundMethod,
-          node: RBI::Method,
-          signature: T.untyped,
-          parameters: T::Array[[Symbol, String]],
-        ).void.checked(:never)
-      end
+      #: (String symbol, Module constant, UnboundMethod method, RBI::Method node, untyped signature, Array[[Symbol, String]] parameters) -> void
       def initialize(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
         super(symbol, constant)
         @node = node

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

@@ -10,12 +10,12 @@ module Tapioca
 
         abstract!
 
-        sig { params(pipeline: Pipeline).void }
+        #: (Pipeline pipeline) -> void
         def initialize(pipeline)
           @pipeline = pipeline
         end
 
-        sig { params(event: NodeAdded).void }
+        #: (NodeAdded event) -> void
         def dispatch(event)
           return if ignore?(event)
 
@@ -33,19 +33,19 @@ module Tapioca
 
         private
 
-        sig { params(event: ConstNodeAdded).void }
+        #: (ConstNodeAdded event) -> void
         def on_const(event)
         end
 
-        sig { params(event: ScopeNodeAdded).void }
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
         end
 
-        sig { params(event: MethodNodeAdded).void }
+        #: (MethodNodeAdded event) -> void
         def on_method(event)
         end
 
-        sig { params(event: NodeAdded).returns(T::Boolean) }
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           # Some listeners do not have to take any action on certain events. For example,
           # almost every listener should skip ForeignScopeNodeAdded events in order not to generate

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           return if constant.is_a?(Class)
@@ -27,7 +28,8 @@ module Tapioca
           end
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           mixin = event.constant
           return if Class === mixin # Classes can't be mixed into other constants
@@ -47,16 +48,13 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            location: String,
-          ).returns(T::Boolean)
-        end
+        #: (String location) -> bool
         def mixed_in_by_gem?(location)
           @pipeline.gem.contains_path?(location)
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -12,7 +12,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           symbol = event.symbol
           constant = event.constant
@@ -23,15 +24,7 @@ module Tapioca
           compile_directly_owned_methods(node, symbol, singleton_class_of(constant), attached_class: constant)
         end
 
-        sig do
-          params(
-            tree: RBI::Tree,
-            module_name: String,
-            mod: Module,
-            for_visibility: T::Array[Symbol],
-            attached_class: T.nilable(Module),
-          ).void
-        end
+        #: (RBI::Tree tree, String module_name, Module mod, ?Array[Symbol] for_visibility, ?attached_class: Module?) -> void
         def compile_directly_owned_methods(
           tree,
           module_name,
@@ -59,29 +52,21 @@ module Tapioca
             end
         end
 
-        sig do
-          params(
-            tree: RBI::Tree,
-            symbol_name: String,
-            constant: Module,
-            method: T.nilable(UnboundMethod),
-            visibility: RBI::Visibility,
-          ).void
-        end
+        #: (RBI::Tree tree, String symbol_name, Module constant, UnboundMethod? method, ?RBI::Visibility visibility) -> void
         def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
           return unless method
           return unless method_owned_by_constant?(method, constant)
           return if @pipeline.symbol_in_payload?(symbol_name) && !@pipeline.method_in_gem?(method)
 
           signature = lookup_signature_of(method)
-          method = T.let(signature.method, UnboundMethod) if signature
+          method = signature.method if signature #: UnboundMethod
 
           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)]])
+          parameters = method.parameters #: Array[[Symbol, Symbol?]]
 
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
@@ -154,10 +139,10 @@ module Tapioca
         # This method implements a better way of checking whether a constant defines a method.
         # It walks up the ancestor tree via the `super_method` method; if any of the super
         # methods are owned by the constant, it means that the constant declares the method.
-        sig { params(method: UnboundMethod, constant: Module).returns(T::Boolean) }
+        #: (UnboundMethod method, Module constant) -> bool
         def method_owned_by_constant?(method, constant)
           # Widen the type of `method` to be nilable
-          method = T.let(method, T.nilable(UnboundMethod))
+          method = method #: UnboundMethod?
 
           while method
             return true if method.owner == constant
@@ -168,7 +153,7 @@ module Tapioca
           false
         end
 
-        sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+        #: (Module mod) -> Hash[Symbol, Array[Symbol]]
         def method_names_by_visibility(mod)
           {
             public: public_instance_methods_of(mod),
@@ -177,7 +162,7 @@ module Tapioca
           }
         end
 
-        sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+        #: (Module constant, String method_name) -> bool
         def struct_method?(constant, method_name)
           return false unless T::Props::ClassMethods === constant
 
@@ -187,12 +172,7 @@ module Tapioca
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
-        sig do
-          params(
-            attached_class: T.nilable(Module),
-            method_name: Symbol,
-          ).returns(T.nilable(T::Boolean))
-        end
+        #: (Module? attached_class, Symbol method_name) -> bool?
         def method_new_in_abstract_class?(attached_class, method_name)
           attached_class &&
             method_name == :new &&
@@ -200,19 +180,20 @@ module Tapioca
             Class === attached_class.singleton_class
         end
 
-        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
+        #: (Module constant) -> UnboundMethod?
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue
           nil
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end
 
-        sig { params(method: UnboundMethod).returns(T.untyped) }
+        #: (UnboundMethod method) -> untyped
         def lookup_signature_of(method)
           signature_of!(method)
         rescue LoadError, StandardError => error

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

@@ -11,7 +11,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           singleton_class = singleton_class_of(constant)
@@ -31,14 +32,7 @@ module Tapioca
           add_mixins(node, constant, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
         end
 
-        sig do
-          params(
-            tree: RBI::Tree,
-            constant: Module,
-            mods: T::Array[Module],
-            mixin_type: Runtime::Trackers::Mixin::Type,
-          ).void
-        end
+        #: (RBI::Tree tree, Module constant, Array[Module] mods, Runtime::Trackers::Mixin::Type mixin_type) -> void
         def add_mixins(tree, constant, mods, mixin_type)
           mods
             .select do |mod|
@@ -65,13 +59,7 @@ module Tapioca
             end
         end
 
-        sig do
-          params(
-            constant: Module,
-            mixin: Module,
-            mixin_type: Runtime::Trackers::Mixin::Type,
-          ).returns(T::Boolean)
-        end
+        #: (Module constant, Module mixin, Runtime::Trackers::Mixin::Type mixin_type) -> bool
         def mixed_in_by_gem?(constant, mixin, mixin_type)
           mixin_location = Runtime::Trackers::Mixin.mixin_location(mixin, mixin_type, constant)
 
@@ -80,14 +68,14 @@ module Tapioca
           @pipeline.gem.contains_path?(mixin_location)
         end
 
-        sig { params(mixin_name: String).returns(T::Boolean) }
+        #: (String mixin_name) -> bool
         def filtered_mixin?(mixin_name)
           # filter T:: namespace mixins that aren't T::Props
           # T::Props and subconstants have semantic value
           mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
         end
 
-        sig { params(constant: Module).returns(T::Array[Module]) }
+        #: (Module constant) -> Array[Module]
         def interesting_ancestors_of(constant)
           inherited_ancestors = Set.new.compare_by_identity.merge(inherited_ancestors_of(constant))
 

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

@@ -11,12 +11,14 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           event.node.detach if @pipeline.symbol_in_payload?(event.symbol) && event.node.empty?
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end

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

@@ -9,7 +9,8 @@ module Tapioca
 
         private
 
-        sig { override.params(event: ScopeNodeAdded).void }
+        # @override
+        #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
           return unless T::Enum > event.constant # rubocop:disable Style/InvertibleUnlessCondition
@@ -24,7 +25,8 @@ module Tapioca
           event.node << enum_block
         end
 
-        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        # @override
+        #: (NodeAdded event) -> bool
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end