TableGen: Allow implicit casting between string and code

[nhaehnle]

Summary

Perhaps the distinction between the two should be removed entirely
in the long term, and the [{ ... }] syntax should just be a convenient
way of writing multi-line strings.

In the meantime, a lot of existing .td files are quite relaxed about
string vs. code, and this change allows switching on more consistent
type checks without breaking those.

Change-Id: If85e3e04469e41b58e2703b62ac0032d2711713c

llvm/trunk/include/llvm/TableGen/Record.h

 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == CodeRecTyKind;
   }
 
   static CodeRecTy *get() { return &Shared; }
 
   std::string getAsString() const override { return "code"; }
+
+  bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
 /// 'int' - Represent an integer value of no particular size
 class IntRecTy : public RecTy {
   static IntRecTy Shared;
 
   IntRecTy() : RecTy(IntRecTyKind) {}
 
public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == StringRecTyKind ||
            RT->getRecTyKind() == CodeRecTyKind;
   }
 
   static StringRecTy *get() { return &Shared; }
 
   std::string getAsString() const override;
+
+  bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
 /// 'list<Ty>' - Represent a list of values, all of which must be of
 /// the specified type.
 class ListRecTy : public RecTy {
   friend ListRecTy *RecTy::getListTy();
 
   RecTy *Ty;

llvm/trunk/lib/TableGen/Record.cpp

bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
 }
 
 bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   RecTyKind kind = RHS->getRecTyKind();
   return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
 }
 
+bool CodeRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
+  RecTyKind Kind = RHS->getRecTyKind();
+  return Kind == CodeRecTyKind || Kind == StringRecTyKind;
+}
+
 std::string StringRecTy::getAsString() const {
   return "string";
 }
 
+bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
+  RecTyKind Kind = RHS->getRecTyKind();
+  return Kind == StringRecTyKind || Kind == CodeRecTyKind;
+}
+
 std::string ListRecTy::getAsString() const {
   return "list<" + Ty->getAsString() + ">";
 }
 
 bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
     return Ty->typeIsConvertibleTo(ListTy->getElementType());
   return false;
StringInit *StringInit::get(StringRef V) {
   if (!Entry.second)
     Entry.second = new(Allocator) StringInit(Entry.getKey());
   return Entry.second;
 }
 
 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<StringRecTy>(Ty))
     return const_cast<StringInit *>(this);
+  if (isa<CodeRecTy>(Ty))
+    return CodeInit::get(getValue());
 
   return nullptr;
 }
 
 Init *CodeInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<CodeRecTy>(Ty))
     return const_cast<CodeInit *>(this);
+  if (isa<StringRecTy>(Ty))
+    return StringInit::get(getValue());
 
   return nullptr;
 }
 
 static void ProfileListInit(FoldingSetNodeID &ID,
                             ArrayRef<Init *> Range,
                             RecTy *EltTy) {
   ID.AddInteger(Range.size());

llvm/trunk/test/TableGen/code.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// TODO: Both of these should result in CodeInits, i.e. print [{...}].
+// CHECK: def A0 {
+// CHECK:   code Code = "Simple";
+// CHECK: }
+
+// CHECK: def B0 {
+// CHECK:   code Code = "With paste 7";
+// CHECK: }
+
+class A<code c> {
+  code Code = c;
+}
+
+def A0 : A<"Simple">;
+
+class B<int i> : A<"With paste " # i>;
+
+def B0 : B<7>;