[tablegen] !strconcat accepts more than two arguments but this wasn't documented or tested.

[dsanders]

Summary

• Updated the documentation
• Added a test for >2 arguments
• Added a check for the lexical concatenation
• Made the existing test a bit stricter.

[dsanders]

ping...

[t.p.northover]

Hi Daniel,

Sorry about the delay, improving documentation's a worthy cause.

docs/TableGen/LangIntro.rst

163

This should probably be updated to either !strconcat(a, ...) or !strconcat(a, b, ...). Is a single argument supported, BTW?

[dsanders]

Hi Tim,

Thanks for the review.

docs/TableGen/LangIntro.rst

163

I agree, I'll update it to !strconcat(a, b, ...)

Is a single argument supported, BTW?

No, it reports an error if it only gets one argument.

[dsanders]

• !strconcat(a, b) -> !strconcat(a, b, ...)

[t.p.northover]

Excellent! Thanks Daniel. That answers all the questions I had looking at the updated documentation so go for it!

Cheers.

Tim.

docs/TableGen/LangIntro.rst

 ``foreach <var> = {0-15,32-47} in ...``
     Loop over ranges of integers. The braces are required for multiple ranges.
 
 ``(DEF a, b)``
     a dag value.  The first element is required to be a record definition, the
     remaining elements in the list may be arbitrary other values, including
     nested ```dag``' values.
 
-``!strconcat(a, b)``
+``!strconcat(a, b, ...)``
     A string value that is the result of concatenating the 'a' and 'b' strings.
+    More than two arguments are accepted with the result being the concatenation
+    of all the strings given.
 
 ``str1#str2``
     "#" (paste) is a shorthand for !strconcat.  It may concatenate things that
     are not quoted strings, in which case an implicit !cast<string> is done on
     the operand of the paste.
 
 ``!cast<type>(a)``
     A symbol of type *type* obtained by looking up the string 'a' in the symbol

test/TableGen/strconcat.td

 // RUN: llvm-tblgen %s | FileCheck %s
 
-// CHECK: fufoo
+// CHECK: class Y<string Y:S = ?> {
+// CHECK:   string T = !strconcat(Y:S, "foo");
+// CHECK:   string T2 = !strconcat(Y:S, !strconcat("foo", !strconcat(Y:S, "bar")));
+// CHECK:   string S = "foobar";
+// CHECK: }
+
+// CHECK: def Z {
+// CHECK:   string T = "fufoo";
+// CHECK:   string T2 = "fufoofubar";
+// CHECK:   string S = "foobar";
+// CHECK: }
 
 class Y<string S> {
   string T = !strconcat(S, "foo");
+  // More than two arguments is equivalent to nested calls
+  string T2 = !strconcat(S, "foo", S, "bar");
 
   // String values concatenate lexically, as in C.
   string S = "foo" "bar";
 }
 
 def Z : Y<"fu">;