Fix rb prototype type for return with multiple values

For the first case it resovled to untyped
For the second case, it was `Array | untyped`

In both cases we know it will return an array

Author: Earlopain

lib/rbs/prototype/rb.rb

@@ -669,6 +669,8 @@ def body_type(node)
             body_type(node.statements)
           when Prism::StatementsNode
             block_type(node)
+          when Prism::ReturnNode
+            return_node_to_type(node)
           else
             literal_to_type(node)
           end
@@ -678,21 +680,16 @@ def block_type(node)
           return_stmts = any_node?(node) do |n|
             n.is_a?(Prism::ReturnNode)
           end&.map do |return_node|
-            return_args = return_node.arguments&.arguments || []
-            return_types =  return_args.map { |arg| literal_to_type(arg) }
-
-            if return_types.size >= 2
-              t = types_to_union_type(return_types)
-              BuiltinNames::Array.instance_type(t)
-            else
-              return_types.first || Types::Bases::Nil.new(location: nil)
-            end
+            return_node_to_type(return_node)
           end || []
 
           last_node = node.compact_child_nodes.last
-          last_evaluated =  last_node ? literal_to_type(last_node) : Types::Bases::Nil.new(location: nil)
-          # FIXME: Skipt if last_evaluated ReturnNode
-          types_to_union_type([*return_stmts, last_evaluated])
+          case last_node
+          when nil, Prism::ReturnNode
+            types_to_union_type(return_stmts)
+          else
+            types_to_union_type([*return_stmts, literal_to_type(last_node)])
+          end
         end
 
         def literal_to_symbol(node)
@@ -784,6 +781,18 @@ def literal_to_type(node)
           end
         end
 
+        def return_node_to_type(node)
+          return_args = node.arguments&.arguments || []
+          return_types =  return_args.map { |arg| literal_to_type(arg) }
+
+          if return_types.size >= 2
+            t = types_to_union_type(return_types)
+            BuiltinNames::Array.instance_type(t)
+          else
+            return_types.first || Types::Bases::Nil.new(location: nil)
+          end
+        end
+
         def types_to_union_type(types)
           return untyped if types.empty?
 

sig/prototype/rb.rbs

@@ -62,6 +62,8 @@ module RBS
 
         def block_type: (Prism::Node node) -> Types::t
 
+        def return_node_to_type: (Prism::ReturnNode) -> Types::t
+
         def literal_to_type: (Prism::Node node) -> Types::t
 
         def types_to_union_type: (Array[Types::t] types) -> Types::t

test/rbs/rb_prototype_test.rb

@@ -324,6 +324,29 @@ def with_unless: () -> (:sym | nil)
 EOR
   end
 
+  def test_defs_return_type_multiple
+    rb = <<~RUBY
+      class Hello
+        def one_statement
+          return 1, ""
+        end
+
+        def multiple_statements
+          foo
+          return 1, ""
+        end
+      end
+    RUBY
+
+    assert_write RB.parse(rb), <<~RBS
+      class Hello
+        def one_statement: () -> ::Array[1 | \"\"]
+
+        def multiple_statements: () -> ::Array[1 | \"\"]
+      end
+    RBS
+  end
+
   def test_sclass
     rb = <<-EOR
 class Hello