TableGen: Generalize type deduction for !listconcat

[nhaehnle]

Summary

This way, it should work even with complex operands.

Change-Id: Iaccf5bbb50bd5882a0ba5d59689e4381315fb361

[tra]

While we're on the subject of !listconcat, is there a way to make !listconcat([1,2,3], []) work?

[nhaehnle]

Thanks. Some of my later patches should at least make !listconcat([1,2,3], []) easier to get to, but I can't test right now whether it's already working. The idea is to pass the correct ItemType to ParseValue when parsing the operands.

llvm/trunk/lib/TableGen/TGParser.cpp

case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     if (Lex.getCode() != tgtok::r_paren) {
       TokError("expected ')' in operator");
       return nullptr;
     }
     Lex.Lex();  // eat the ')'
 
     // If we are doing !listconcat, we should know the type by now
     if (OpTok == tgtok::XListConcat) {
-      if (VarInit *Arg0 = dyn_cast<VarInit>(InitList[0]))
-        Type = Arg0->getType();
-      else if (ListInit *Arg0 = dyn_cast<ListInit>(InitList[0]))
+      if (TypedInit *Arg0 = dyn_cast<TypedInit>(InitList[0]))
         Type = Arg0->getType();
       else {
         InitList[0]->print(errs());
         Error(OpLoc, "expected a list");
         return nullptr;
       }
     }
 

llvm/trunk/test/TableGen/listconcat.td

 // RUN: llvm-tblgen %s | FileCheck %s
 
+// CHECK: class X<list<int> X:a = ?, list<int> X:b = ?, list<int> X:c = ?> {
+// CHECK:   list<int> x = !listconcat(!listconcat(X:a, X:b), !listconcat(X:b, X:c));
+// CHECK: }
+
 // CHECK: class Y<list<string> Y:S = ?> {
 // CHECK:   list<string> T1 = !listconcat(Y:S, ["foo"]);
 // CHECK:   list<string> T2 = !listconcat(Y:S, !listconcat(["foo"], !listconcat(Y:S, ["bar", "baz"])));
 // CHECK: }
 
+// CHECK: def DX {
+// CHECK:   list<int> x = [0, 1, 1, 2]
+// CHECK: }
+
 // CHECK: def Z {
 // CHECK:   list<string> T1 = ["fu", "foo"];
 // CHECK:   list<string> T2 = ["fu", "foo", "fu", "bar", "baz"];
 // CHECK: }
 
+class X<list<int> a, list<int> b, list<int> c> {
+    list<int> x = !listconcat(!listconcat(a, b), !listconcat(b, c));
+}
+
 class Y<list<string> S> {
   list<string> T1 = !listconcat(S, ["foo"]);
   list<string> T2 = !listconcat(S, ["foo"], S, ["bar", "baz"]);
 }
 
+def DX : X<[0], [1], [2]>;
+
 def Z : Y<["fu"]>;