Macros: make T easier to deal with, when it's the T of a tuple, union…

… or named tuple
crystal-lang · Jun 3, 2016 · c983908 · c983908
1 parent 5fc4f1a
commit c983908
Showing 4 changed files with 53 additions and 0 deletions.
diff --git a/spec/compiler/codegen/named_tuple_spec.cr b/spec/compiler/codegen/named_tuple_spec.cr
@@ -277,4 +277,15 @@ describe "Code gen: named tuple" do
       end
       )).to_i.should eq(42)
   end
+
+  it "provides T as a named tuple literal" do
+    run(%(
+      struct NamedTuple
+        def self.foo
+          {{ T.class_name }}
+        end
+      end
+      NamedTuple(x: Nil, y: Int32).foo
+      )).to_string.should eq("NamedTupleLiteral")
+  end
 end
diff --git a/spec/compiler/codegen/tuple_spec.cr b/spec/compiler/codegen/tuple_spec.cr
@@ -294,4 +294,15 @@ describe "Code gen: tuple" do
       end
       )).to_i.should eq(42)
   end
+
+  it "provides T as a tuple literal" do
+    run(%(
+      struct Tuple
+        def self.foo
+          {{ T.class_name }}
+        end
+      end
+      Tuple(Nil, Int32).foo
+      )).to_string.should eq("TupleLiteral")
+  end
 end
diff --git a/spec/compiler/codegen/union_type_spec.cr b/spec/compiler/codegen/union_type_spec.cr
@@ -192,4 +192,15 @@ describe "Code gen: union type" do
       )).to_string
     (str == "(Int32 | Float64)" || str == "(Float64 | Int32)").should be_true
   end
+
+  it "provides T as a tuple literal" do
+    run(%(
+      struct Union
+        def self.foo
+          {{ T.class_name }}
+        end
+      end
+      Union(Nil, Int32).foo
+      )).to_string.should eq("TupleLiteral")
+  end
 end
diff --git a/src/compiler/crystal/macros/macros.cr b/src/compiler/crystal/macros/macros.cr
@@ -505,6 +505,26 @@ module Crystal
         when Const
           matched_type.value
         when Type
+          # The T of a tuple, named tuple or union produce tuple literals
+          # or named tuple literals. The compiler has them as a type
+          # (a tuple type, or a named tuple type) but the user should see
+          # them as literals, and having them as a type doesn't add
+          # any useful information.
+          if node.single?("T")
+            instance_type = @type_lookup.instance_type
+            case instance_type
+            when TupleInstanceType
+              return TupleLiteral.map(instance_type.tuple_types) { |t| TypeNode.new(t) }
+            when NamedTupleInstanceType
+              entries = instance_type.entries.map do |entry|
+                NamedTupleLiteral::Entry.new(entry.name, TypeNode.new(entry.type))
+              end
+              return NamedTupleLiteral.new(entries)
+            when UnionType
+              return TupleLiteral.map(instance_type.union_types) { |t| TypeNode.new(t) }
+            end
+          end
+
           TypeNode.new(matched_type)
         when ASTNode
           matched_type