Recover actual types from VariantCollectionCoercer in multi-type params

In Grape >= 3.3 `type: [A, B]` is wrapped in a VariantCollectionCoercer,
and Grape's documentation pipeline serialises that wrapper via #to_s
before storing it in route.params, which discards the original type
list. The previous behaviour exposed the coercer's #inspect string
(e.g. "#<Grape::Validations::Types::VariantCollectionCoercer:0x...>")
as the swagger type.

The live coercer is still reachable via the matching CoerceValidator's
@converter, so collect_variant_types walks namespace_stackable[:validations]
and builds a name => [types] lookup. When fulfill_params sees the
VariantCollectionCoercer signature in the serialised type, it substitutes
the real type list and lets the existing Array handling in
DataType.parse_multi_type pick the primary type, matching how older Grape
versions behaved when they passed the type array through directly.

Author: numbata

lib/grape-swagger/request_param_parsers/route.rb

@@ -19,8 +19,9 @@ def parse
         stackable_values = route.app&.inheritable_setting&.namespace_stackable
 
         path_params = build_path_params(stackable_values)
+        variant_types = collect_variant_types(stackable_values)
 
-        fulfill_params(path_params)
+        fulfill_params(path_params, variant_types)
       end
 
       private
@@ -47,7 +48,33 @@ def fetch_inherited_params(stackable_values)
         end
       end
 
-      def fulfill_params(path_params)
+      # In Grape >= 3.3 `type: [A, B]` is wrapped in VariantCollectionCoercer and
+      # Grape's documentation pipeline serialises it via `#to_s`, so the original
+      # type list is lost in route.params. The live coercer is still reachable
+      # through the CoerceValidator's @converter, so we rebuild a name => types
+      # map and restore it in fulfill_params.
+      def collect_variant_types(stackable_values)
+        variant_types = {}
+        return variant_types unless defined?(Grape::Validations::Types::VariantCollectionCoercer) &&
+                                    defined?(Grape::Validations::Validators::CoerceValidator) &&
+                                    stackable_values.respond_to?(:[])
+
+        Array(stackable_values[:validations]).each do |validator|
+          next unless validator.is_a?(Grape::Validations::Validators::CoerceValidator)
+
+          converter = validator.instance_variable_get(:@converter)
+          next unless converter.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
+
+          types = converter.instance_variable_get(:@types)
+          Array(validator.instance_variable_get(:@attrs)).each do |attr|
+            variant_types[attr.to_s] = types
+          end
+        end
+
+        variant_types
+      end
+
+      def fulfill_params(path_params, variant_types)
         # Merge path params options into route params
         route.params.each_with_object({}) do |(param, definition), accum|
           # The route.params hash includes both parametrized params (with a string as a key)
@@ -57,10 +84,18 @@ def fulfill_params(path_params)
           next if param.is_a?(String) && accum.key?(key)
 
           defined_options = definition.is_a?(Hash) ? definition : {}
+          defined_options = restore_variant_type(defined_options, param, variant_types)
           value = (path_params[param] || {}).merge(defined_options)
           accum[key] = value.empty? ? DEFAULT_PARAM_TYPE : value
         end
       end
+
+      def restore_variant_type(defined_options, param, variant_types)
+        types = variant_types[param.to_s]
+        return defined_options unless types
+
+        defined_options.merge(type: types)
+      end
     end
   end
 end