fix: correctly instantiate sorbet type aliases for enums and unions

Author: stainless-app[bot]

lib/orb/internal/type/array_of.rb

@@ -12,6 +12,7 @@ module Type
       # Array of items of a given type.
       class ArrayOf
         include Orb::Internal::Type::Converter
+        include Orb::Internal::Util::SorbetRuntimeSupport
 
         private_class_method :new
 
@@ -110,6 +111,13 @@ def dump(value, state:)
           end
         end
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          T::Array[Orb::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
+        end
+
         # @api private
         #
         # @return [generic<Elem>]

lib/orb/internal/type/base_model.rb

@@ -304,6 +304,13 @@ def dump(value, state:)
 
             acc
           end
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            self
+          end
         end
 
         class << self

lib/orb/internal/type/boolean.rb

@@ -10,6 +10,7 @@ module Type
       # Ruby has no Boolean class; this is something for models to refer to.
       class Boolean
         extend Orb::Internal::Type::Converter
+        extend Orb::Internal::Util::SorbetRuntimeSupport
 
         private_class_method :new
 
@@ -56,6 +57,13 @@ def coerce(value, state:)
           #     @option state [Boolean] :can_retry
           #
           #   @return [Boolean, Object]
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            T::Boolean
+          end
         end
       end
     end

lib/orb/internal/type/enum.rb

@@ -108,6 +108,18 @@ def coerce(value, state:)
         #
         #   @return [Symbol, Object]
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          case values
+          in []
+            T.noreturn
+          in [value, *_]
+            T.all(Orb::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(value), self)
+          end
+        end
+
         # @api private
         #
         # @param depth [Integer]

lib/orb/internal/type/file_input.rb

@@ -88,6 +88,13 @@ def dump(value, state:)
 
             value
           end
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            T.any(Pathname, StringIO, IO, String, Orb::FilePart)
+          end
         end
       end
     end

lib/orb/internal/type/hash_of.rb

@@ -12,6 +12,7 @@ module Type
       # Hash of items of a given type.
       class HashOf
         include Orb::Internal::Type::Converter
+        include Orb::Internal::Util::SorbetRuntimeSupport
 
         private_class_method :new
 
@@ -130,6 +131,13 @@ def dump(value, state:)
           end
         end
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          T::Hash[Orb::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
+        end
+
         # @api private
         #
         # @return [generic<Elem>]

lib/orb/internal/type/union.rb

@@ -231,6 +231,18 @@ def dump(value, state:)
           super
         end
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          case (v = variants)
+          in []
+            T.noreturn
+          else
+            T.any(*v.map { Orb::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(_1) })
+          end
+        end
+
         # rubocop:enable Style/CaseEquality
         # rubocop:enable Style/HashEachMethods
 

lib/orb/internal/type/unknown.rb

@@ -10,6 +10,7 @@ module Type
       # When we don't know what to expect for the value.
       class Unknown
         extend Orb::Internal::Type::Converter
+        extend Orb::Internal::Util::SorbetRuntimeSupport
 
         # rubocop:disable Lint/UnusedMethodArgument
 
@@ -58,6 +59,13 @@ def coerce(value, state:)
           #     @option state [Boolean] :can_retry
           #
           #   @return [Object]
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            T.anything
+          end
         end
 
         # rubocop:enable Lint/UnusedMethodArgument

lib/orb/internal/util.rb

@@ -9,6 +9,23 @@ module Util
       # @return [Float]
       def self.monotonic_secs = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # @api private
+      #
+      # @param ns [Module, Class]
+      #
+      # @return [Enumerable<Module, Class>]
+      def self.walk_namespaces(ns)
+        ns.constants(false).lazy.flat_map do
+          case (c = ns.const_get(_1, false))
+          in Module | Class
+            walk_namespaces(c)
+          else
+            []
+          end
+        end
+          .chain([ns])
+      end
+
       class << self
         # @api private
         #
@@ -826,11 +843,39 @@ def const_missing(name)
           sorbet_runtime_constants.fetch(name).call
         end
 
+        # @api private
+        #
+        # @param name [Symbol]
+        #
+        # @return [Boolean]
+        def sorbet_constant_defined?(name) = sorbet_runtime_constants.key?(name)
+
         # @api private
         #
         # @param name [Symbol]
         # @param blk [Proc]
         def define_sorbet_constant!(name, &blk) = sorbet_runtime_constants.store(name, blk)
+
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type = raise NotImplementedError
+
+        class << self
+          # @api private
+          #
+          # @param type [Orb::Internal::Util::SorbetRuntimeSupport, Object]
+          #
+          # @return [Object]
+          def to_sorbet_type(type)
+            case type
+            in Orb::Internal::Util::SorbetRuntimeSupport
+              type.to_sorbet_type
+            else
+              type
+            end
+          end
+        end
       end
 
       extend Orb::Internal::Util::SorbetRuntimeSupport

lib/orb/models.rb

@@ -5,26 +5,40 @@ module Orb
     cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, Orb::Internal::AnyHash) } }
   end
 
-  [*Orb::Internal::Type::Enum.included_modules, *Orb::Internal::Type::Union.included_modules].each do |cls|
-    cls.constants.each do |name|
-      case cls.const_get(name)
-      in true | false
-        cls.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T.all(T::Boolean, cls) } }
-        cls.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
-      in Integer
-        cls.define_sorbet_constant!(:TaggedInteger) { T.type_alias { T.all(Integer, cls) } }
-        cls.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
-      in Float
-        cls.define_sorbet_constant!(:TaggedFloat) { T.type_alias { T.all(Float, cls) } }
-        cls.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
-      in Symbol
-        cls.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { T.all(Symbol, cls) } }
-        cls.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
-      else
+  Orb::Internal::Util.walk_namespaces(Orb::Models).each do |mod|
+    case mod
+    in Orb::Internal::Type::Enum | Orb::Internal::Type::Union
+      mod.constants.each do |name|
+        case mod.const_get(name)
+        in true | false
+          mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T.all(T::Boolean, mod) } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { T.all(Integer, mod) } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { T.all(Float, mod) } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { T.all(Symbol, mod) } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
       end
+    else
     end
   end
 
+  Orb::Internal::Util.walk_namespaces(Orb::Models)
+                     .lazy
+                     .grep(Orb::Internal::Type::Union)
+                     .each do |mod|
+    const = :Variants
+    next if mod.sorbet_constant_defined?(const)
+
+    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+  end
+
   Alert = Orb::Models::Alert
 
   AlertCreateForCustomerParams = Orb::Models::AlertCreateForCustomerParams