Fix typing of union collections

lib/steep/type_construction.rb

@@ -1037,10 +1037,10 @@ def synthesize(node, hint: nil)
               case child.type
               when :pair
                 key, value = child.children
-                key_types << synthesize(key).type.yield_self do |type|
+                key_types << synthesize(key, hint: key_hint).type.yield_self do |type|
                   select_super_type(type, key_hint)
                 end
-                value_types << synthesize(value).type.yield_self do |type|
+                value_types << synthesize(value, hint: value_hint).type.yield_self do |type|
                   select_super_type(type, value_hint)
                 end
               when :kwsplat
@@ -1256,7 +1256,7 @@ def synthesize(node, hint: nil)
                       end
                     end
                   else
-                    [select_super_type(synthesize(e).type, element_hint)]
+                    [select_super_type(synthesize(e, hint: element_hint).type, element_hint)]
                   end
                 end
                 array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))

test/type_construction_test.rb

@@ -3682,6 +3682,27 @@ def test_array_optional
     end
   end
 
+  def test_array_union
+    with_checker <<EOF do |checker|
+class Animal
+end
+
+type animal = :dog | :cat
+Animal::ALL: Array[animal]
+EOF
+
+      source = parse_ruby(<<EOF)
+Animal::ALL = [:dog, :cat]
+EOF
+
+      with_standard_construction(checker, source) do |construction, typing|
+        construction.synthesize(source.node)
+
+        assert_no_error typing
+      end
+    end
+  end
+
   def test_passing_empty_block
     with_checker do |checker|
       source = parse_ruby(<<EOF)
@@ -4047,6 +4068,27 @@ def self.f: [A] ({ foo: A }) -> A
     end
   end
 
+  def test_hash_union
+    with_checker <<EOF do |checker|
+class Animal
+end
+
+type animal = :dog | :cat
+Animal::ALL: Hash[Symbol, animal]
+EOF
+
+      source = parse_ruby(<<EOF)
+Animal::ALL = { :dog => :dog, :cat => :cat }
+EOF
+
+      with_standard_construction(checker, source) do |construction, typing|
+        construction.synthesize(source.node)
+
+        assert_no_error typing
+      end
+    end
+  end
+
   def test_polymorphic_method
     with_checker <<-EOF do |checker|
 interface _Ref[X]