Improve Record type inference for hash literals (#360)

* Improve Record type field access semantics

Record types have statically defined fields, unlike Hash which allows
dynamic keys. This change makes the type inference more precise:

- Non-existent field access (e.g., `record[:unknown]`) now returns `nil`
  instead of `untyped`, since Record fields are fixed at definition time
- Symbol variable access (e.g., `record[key]`) now returns
  `nil | union of all field types` to account for the possibility that
  the key may not exist in the Record

Hash type behavior remains unchanged (returns `untyped` for unknown keys).

* Use Type::Record for hash literals with symbol keys

This improves RBS output precision for hash literals. For example:
- Before: `def foo: -> Hash[:a | :b, Integer | String]`
- After:  `def foo: -> { a: Integer, b: String }`

Record type preserves individual field types instead of merging
all keys and values into a single union type.

Author: sinsoku

lib/typeprof/core/ast/value.rb

@@ -293,13 +293,18 @@ def install0(genv)
         unified_key = Vertex.new(self)
         unified_val = Vertex.new(self)
         literal_pairs = {}
+        all_symbol_keys = true
         @keys.zip(@vals) do |key, val|
           if key
             k = key.install(genv).new_vertex(genv, self)
             v = val.install(genv).new_vertex(genv, self)
             @changes.add_edge(genv, k, unified_key)
             @changes.add_edge(genv, v, unified_val)
-            literal_pairs[key.lit] = v if key.is_a?(SymbolNode)
+            if key.is_a?(SymbolNode)
+              literal_pairs[key.lit] = v
+            else
+              all_symbol_keys = false
+            end
           else
             if val.is_a?(DummyNilNode)
               h = @lenv.get_var(:"**anonymous_keyword")
@@ -310,10 +315,13 @@ def install0(genv)
             @changes.add_hash_splat_box(genv, h, unified_key, unified_val)
           end
         end
+        base_hash_type = genv.gen_hash_type(unified_key, unified_val)
         if @splat
-          Source.new(genv.gen_hash_type(unified_key, unified_val))
+          Source.new(base_hash_type)
+        elsif all_symbol_keys
+          Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
         else
-          Source.new(Type::Hash.new(genv, literal_pairs, genv.gen_hash_type(unified_key, unified_val)))
+          Source.new(Type::Hash.new(genv, literal_pairs, base_hash_type))
         end
       end
     end

lib/typeprof/core/builtin.rb

@@ -90,7 +90,7 @@ def array_push(changes, node, ty, a_args, ret)
     def hash_aref(changes, node, ty, a_args, ret)
       if a_args.positionals.size == 1
         case ty
-        when Type::Hash, Type::Record
+        when Type::Hash
           idx = node.positional_args[0]
           idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
           value = ty.get_value(idx)
@@ -101,6 +101,20 @@ def hash_aref(changes, node, ty, a_args, ret)
             changes.add_edge(@genv, Source.new(), ret)
           end
           true
+        when Type::Record
+          idx = node.positional_args[0]
+          idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
+          value = ty.get_value(idx)
+          if value
+            changes.add_edge(@genv, value, ret)
+          else
+            changes.add_edge(@genv, Source.new(@genv.nil_type), ret)
+          end
+          # Symbol variable access - add nil possibility
+          if idx.nil?
+            changes.add_edge(@genv, Source.new(@genv.nil_type), ret)
+          end
+          true
         else
           false
         end
@@ -125,6 +139,15 @@ def hash_aset(changes, node, ty, a_args, ret)
           end
           changes.add_edge(@genv, val, ret)
           true
+        when Type::Record
+          val = a_args.positionals[1]
+          idx = node.positional_args[0]
+          if idx.is_a?(AST::SymbolNode)
+            field_vtx = ty.get_value(idx.lit)
+            changes.add_edge(@genv, val, field_vtx) if field_vtx
+          end
+          changes.add_edge(@genv, val, ret)
+          true
         else
           false
         end

lib/typeprof/core/env/method.rb

@@ -69,6 +69,9 @@ def get_keyword_arg(genv, changes, name)
         case ty
         when Type::Hash
           changes.add_edge(genv, ty.get_value(name), vtx)
+        when Type::Record
+          field_vtx = ty.get_value(name)
+          changes.add_edge(genv, field_vtx, vtx) if field_vtx
         when Type::Instance
           if ty.mod == genv.mod_hash
             changes.add_edge(genv, ty.args[1], vtx)

lib/typeprof/core/type.rb

@@ -16,16 +16,33 @@ def self.strip_array(s)
     end
 
     def self.extract_hash_value_type(s)
-      if s.start_with?("Hash[") && s.end_with?("]")
+      begin
         type = RBS::Parser.parse_type(s)
+        collect_hash_value_types(type).uniq.join(" | ")
+      rescue
+        s
+      end
+    end
 
-        if type.is_a?(RBS::Types::Union)
-          type.types.map {|t| t.args[1].to_s }.join(" | ")
+    # Returns an array of value type strings from hash-like types
+    def self.collect_hash_value_types(type)
+      case type
+      when RBS::Types::Record
+        # Extract value types from record fields
+        # all_fields returns { key => [type, required] }
+        type.all_fields.values.map { |t, _required| t.to_s }
+      when RBS::Types::ClassInstance
+        # Handle Hash[K, V]
+        if type.name.name == :Hash && type.args.size == 2
+          [type.args[1].to_s]
         else
-          type.args[1].to_s
+          [type.to_s]
         end
+      when RBS::Types::Union
+        # Handle union of types - extract value types from all hash-like types
+        type.types.flat_map { |t| collect_hash_value_types(t) }
       else
-        s
+        [type.to_s]
       end
     end
 

scenario/args/anonymous_keyword.rb

@@ -12,5 +12,5 @@ def bar(**)
 ## assert
 class Object
   def foo: (**untyped) -> nil
-  def bar: (**Integer | String | untyped) -> nil
+  def bar: (**untyped | Integer | String) -> nil
 end

scenario/block/rbs_block6.rb

@@ -11,5 +11,5 @@ def foo(h)
 
 ## assert
 class Object
-  def foo: (Hash[:a, Integer] | Hash[:b, String]) -> (Integer | String)?
+  def foo: ({ a: Integer } | { b: String }) -> (Integer | String)?
 end

scenario/hash/basic1.rb

@@ -17,7 +17,7 @@ def baz
 
 ## assert
 class Object
-  def foo: -> Hash[:a | :b, Float | Integer | String]
+  def foo: -> { a: Integer, b: String }
   def bar: -> Integer
-  def baz: -> (Float | Integer | String)
+  def baz: -> nil
 end

scenario/hash/hash-splat.rb

@@ -10,5 +10,5 @@ def bar
 ## assert
 class Object
   def foo: -> Hash[:a | :b, Integer]
-  def bar: -> Hash[:a, Integer]
+  def bar: -> { a: Integer }
 end

scenario/hash/implicit.rb

@@ -7,5 +7,5 @@ def create
 
 ## assert
 class Object
-  def create: -> Hash[:x | :y, Integer | String]
+  def create: -> { x: Integer, y: String }
 end

scenario/method/keywords.rb

@@ -71,5 +71,5 @@ def foo(a:, b: 1, **c)
 
 ## assert
 class Object
-  def foo: (a: String, ?b: Integer, **Integer | String | true) -> Hash[:a | :b | :c, Integer | String | true]
+  def foo: (a: String, ?b: Integer, **String | Integer | true) -> { a: String, b: Integer, c: true }
 end