Fix key type for empty NamedTuple be Symbol

spec/std/named_tuple_spec.cr

@@ -290,9 +290,18 @@ describe "NamedTuple" do
     NamedTuple.new.empty?.should be_true
   end
 
-  it "does to_a" do
-    tup = {a: 1, b: 'a'}
-    tup.to_a.should eq([{:a, 1}, {:b, 'a'}])
+  describe "to_a" do
+    it "creates an array of key-value pairs" do
+      tup = {a: 1, b: 'a'}
+      tup.to_a.should eq([{:a, 1}, {:b, 'a'}])
+    end
+
+    it "preserves key type for empty named tuples" do
+      tup = NamedTuple.new
+      arr = tup.to_a
+      arr.should be_empty
+      arr.should be_a(Array({Symbol, NoReturn}))
+    end
   end
 
   it "does map" do
@@ -327,10 +336,19 @@ describe "NamedTuple" do
     u.should_not eq(v)
   end
 
-  it "does to_h" do
-    tup1 = {a: 1, b: "hello"}
-    hash = tup1.to_h
-    hash.should eq({:a => 1, :b => "hello"})
+  describe "to_h" do
+    it "creates a hash" do
+      tup1 = {a: 1, b: "hello"}
+      hash = tup1.to_h
+      hash.should eq({:a => 1, :b => "hello"})
+    end
+
+    it "creates an empty hash from an empty named tuple" do
+      tup = NamedTuple.new
+      hash = tup.to_h
+      hash.should be_empty
+      hash.should be_a(Hash(Symbol, NoReturn))
+    end
   end
 
   it "does to_s" do

src/named_tuple.cr

@@ -494,10 +494,12 @@ struct NamedTuple
   # tuple = {name: "Crystal", year: 2011}
   # tuple.to_a # => [{:name, "Crystal"}, {:year, 2011}]
   # ```
+  #
+  # NOTE: `to_a` on an empty named tuple produces an `Array(Tuple(Symbol, NoReturn))`
   def to_a
-    ary = Array({typeof(first_key_internal), typeof(first_value_internal)}).new(size)
+    ary = Array({Symbol, typeof(first_value_internal)}).new(size)
     each do |key, value|
-      ary << {key.as(typeof(first_key_internal)), value.as(typeof(first_value_internal))}
+      ary << {key.as(Symbol), value.as(typeof(first_value_internal))}
     end
     ary
   end
@@ -508,9 +510,11 @@ struct NamedTuple
   # tuple = {name: "Crystal", year: 2011}
   # tuple.to_h # => {:name => "Crystal", :year => 2011}
   # ```
+  #
+  # NOTE: `to_h` on an empty named tuple produces a `Hash(Symbol, NoReturn)`
   def to_h
     {% if T.size == 0 %}
-      {} of NoReturn => NoReturn
+      {} of Symbol => NoReturn
     {% else %}
       {
         {% for key in T %}
@@ -582,7 +586,7 @@ struct NamedTuple
     {% end %}
   end
 
-  private def first_key_internal
+  private def first_key_internal : Symbol
     i = 0
     keys[i]
   end