Allow named tuple metaclass to be indexed

mimic behavior from tuple

spec/compiler/codegen/named_tuple_spec.cr

@@ -310,4 +310,27 @@ describe "Code gen: named tuple" do
       x = {a: 0, b: z}
       ))
   end
+
+  it "accesses T and creates instance from it" do
+    run("
+      struct NamedTuple
+        def named_args
+          T
+        end
+      end
+
+      class Foo
+        def initialize(@x : Int32)
+        end
+
+        def x
+          @x
+        end
+      end
+
+      t = {a: Foo.new(1)}
+      f = t.named_args[:a].new(2)
+      f.x
+      ").to_i.should eq(2)
+  end
 end

spec/compiler/semantic/named_tuple_spec.cr

@@ -294,4 +294,21 @@ describe "Semantic: named tuples" do
       ),
       "Can't convert an empty NamedTuple to a Hash"
   end
+
+  it "types T as a tuple of metaclasses" do
+    assert_type("
+      struct NamedTuple
+        def named_args
+          T
+        end
+      end
+
+      x = {a: 1, b: 1.5, c: 'a'}
+      x.named_args
+      ") do
+      meta = named_tuple_of({"a": int32, "b": float64, "c": char}).metaclass
+      meta.metaclass?.should be_true
+      meta
+    end
+  end
 end

src/compiler/crystal/codegen/primitives.cr

@@ -783,8 +783,15 @@ class Crystal::CodeGenVisitor
       ptr = aggregate_index value, index
       to_lhs ptr, type.entries[index].type
     else
-      type = (type.instance_type.as(TupleInstanceType))
-      type_id(type.tuple_types[index].as(Type).metaclass)
+      type = type.instance_type
+      case type
+      when TupleInstanceType
+        type_id(type.tuple_types[index].as(Type).metaclass)
+      when NamedTupleInstanceType
+        type_id(type.entries[index].type.as(Type).metaclass)
+      else
+        raise "BUG: unsupported codegen for tuple_indexer"
+      end
     end
   end
 

src/compiler/crystal/semantic/call.cr

@@ -440,10 +440,15 @@ class Crystal::Call
         instance_type.tuple_metaclass_indexer(index)
       end
     elsif owner.is_a?(NamedTupleInstanceType)
-      # Check named tuple inexer
+      # Check named tuple indexer
       named_tuple_indexer_helper(args, arg_types, owner, owner, nilable) do |instance_type, index|
         instance_type.tuple_indexer(index)
       end
+    elsif owner.metaclass? && (instance_type = owner.instance_type).is_a?(NamedTupleInstanceType)
+      # Check named tuple metaclass indexer
+      named_tuple_indexer_helper(args, arg_types, owner, instance_type, nilable) do |instance_type, index|
+        instance_type.tuple_metaclass_indexer(index)
+      end
     end
   end
 

src/compiler/crystal/semantic/main_visitor.cr

@@ -2703,8 +2703,12 @@ module Crystal
         node.type = scope.tuple_types[node.index].as(Type)
       elsif scope.is_a?(NamedTupleInstanceType)
         node.type = scope.entries[node.index].type
-      elsif scope
-        node.type = (scope.instance_type.as(TupleInstanceType).tuple_types[node.index].as(Type)).metaclass
+      elsif scope && (instance_type = scope.instance_type).is_a?(TupleInstanceType)
+        node.type = instance_type.tuple_types[node.index].as(Type).metaclass
+      elsif scope && (instance_type = scope.instance_type).is_a?(NamedTupleInstanceType)
+        node.type = instance_type.entries[node.index].type.metaclass
+      else
+        node.raise "unsupported TupleIndexer scope"
       end
       false
     end

src/compiler/crystal/types.cr

@@ -2179,6 +2179,11 @@ module Crystal
       tuple_indexer(indexers, index)
     end
 
+    def tuple_metaclass_indexer(index)
+      indexers = @tuple_metaclass_indexers ||= {} of Int32 => Def
+      tuple_indexer(indexers, index)
+    end
+
     private def tuple_indexer(indexers, index)
       indexers[index] ||= begin
         body = index == -1 ? NilLiteral.new : TupleIndexer.new(index)