[Syntax] Tablegen literal expressions.

[sammccall]

Summary

Non-mechanical changes:

• Added FIXME to StringLiteral to cover multi-token string literals.
• LiteralExpression::getLiteralToken() is gone. (It was never called) This is because we don't codegen methods in Alternatives It's conceptually suspect if we consider multi-token string literals, though.

clang/include/clang/Tooling/Syntax/Nodes.h

 class CallArguments final : public List {
 public:
   CallArguments() : List(NodeKind::CallArguments) {}
   static bool classof(const Node *N);
   std::vector<Expression *> getArguments();
   std::vector<List::ElementAndDelimiter<Expression>> getArgumentsAndCommas();
 };
 
-/// Expression for literals. C++ [lex.literal]
-class LiteralExpression : public Expression {
-public:
-  LiteralExpression(NodeKind K) : Expression(K) {}
-  static bool classof(const Node *N);
-  Leaf *getLiteralToken();
-};
-
-/// Expression for integer literals. C++ [lex.icon]
-class IntegerLiteralExpression final : public LiteralExpression {
-public:
-  IntegerLiteralExpression()
-      : LiteralExpression(NodeKind::IntegerLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for character literals. C++ [lex.ccon]
-class CharacterLiteralExpression final : public LiteralExpression {
-public:
-  CharacterLiteralExpression()
-      : LiteralExpression(NodeKind::CharacterLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for floating-point literals. C++ [lex.fcon]
-class FloatingLiteralExpression final : public LiteralExpression {
-public:
-  FloatingLiteralExpression()
-      : LiteralExpression(NodeKind::FloatingLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for string-literals. C++ [lex.string]
-class StringLiteralExpression final : public LiteralExpression {
-public:
-  StringLiteralExpression()
-      : LiteralExpression(NodeKind::StringLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for boolean literals. C++ [lex.bool]
-class BoolLiteralExpression final : public LiteralExpression {
-public:
-  BoolLiteralExpression()
-      : LiteralExpression(NodeKind::BoolLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for the `nullptr` literal. C++ [lex.nullptr]
-class CxxNullPtrExpression final : public LiteralExpression {
-public:
-  CxxNullPtrExpression() : LiteralExpression(NodeKind::CxxNullPtrExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for user-defined literal. C++ [lex.ext]
-/// user-defined-literal:
-///   user-defined-integer-literal
-///   user-defined-floating-point-literal
-///   user-defined-string-literal
-///   user-defined-character-literal
-class UserDefinedLiteralExpression : public LiteralExpression {
-public:
-  UserDefinedLiteralExpression(NodeKind K) : LiteralExpression(K) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for user-defined-integer-literal. C++ [lex.ext]
-class IntegerUserDefinedLiteralExpression final
-    : public UserDefinedLiteralExpression {
-public:
-  IntegerUserDefinedLiteralExpression()
-      : UserDefinedLiteralExpression(
-            NodeKind::IntegerUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for user-defined-floating-point-literal. C++ [lex.ext]
-class FloatUserDefinedLiteralExpression final
-    : public UserDefinedLiteralExpression {
-public:
-  FloatUserDefinedLiteralExpression()
-      : UserDefinedLiteralExpression(
-            NodeKind::FloatUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for user-defined-character-literal. C++ [lex.ext]
-class CharUserDefinedLiteralExpression final
-    : public UserDefinedLiteralExpression {
-public:
-  CharUserDefinedLiteralExpression()
-      : UserDefinedLiteralExpression(
-            NodeKind::CharUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
-/// Expression for user-defined-string-literal. C++ [lex.ext]
-class StringUserDefinedLiteralExpression final
-    : public UserDefinedLiteralExpression {
-public:
-  StringUserDefinedLiteralExpression()
-      : UserDefinedLiteralExpression(
-            NodeKind::StringUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
-};
-
 /// An abstract class for prefix and postfix unary operators.
 class UnaryOperatorExpression : public Expression {
 public:
   UnaryOperatorExpression(NodeKind K) : Expression(K) {}
   static bool classof(const Node *N);
   Leaf *getOperatorToken();
   Expression *getOperand();
 };

clang/include/clang/Tooling/Syntax/Nodes.td

let documentation = [{
     e.g. `(3 + 2)` in `a = 1 + (3 + 2);`
   }];
   let children = [
     Role<"OpenParen", Token<"l_paren">>,
     Role<"SubExpression", Expression>,
     Role<"CloseParen", Token<"r_paren">>,
   ];
 }
-def LiteralExpression : External<Expression> {}
-def IntegerLiteralExpression : External<LiteralExpression> {}
-def CharacterLiteralExpression : External<LiteralExpression> {}
-def FloatingLiteralExpression : External<LiteralExpression> {}
-def StringLiteralExpression : External<LiteralExpression> {}
-def BoolLiteralExpression : External<LiteralExpression> {}
-def CxxNullPtrExpression : External<LiteralExpression> {}
-def UserDefinedLiteralExpression : External<LiteralExpression> {}
-def IntegerUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
-def FloatUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
-def CharUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
-def StringUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
+def LiteralExpression : Alternatives<Expression> {
+  let documentation = [{
+    Expression for literals. C++ [lex.literal]
+  }];
+}
+def IntegerLiteralExpression : Sequence<LiteralExpression> {
+  let documentation = [{
+    Expression for integer literals. C++ [lex.icon]
+  }];
+  let children = [
+    Role<"LiteralToken", Token<"numeric_constant">>,
+  ];
+}
+defvar AnyCharacterLiteral = AnyToken<[
+  "char_constant", "wide_char_constant", "utf8_char_constant",
+  "utf16_char_constant", "utf32_char_constant"
+]>;
+def CharacterLiteralExpression : Sequence<LiteralExpression> {
+  let documentation = [{
+    Expression for character literals. C++ [lex.ccon]
+  }];
+  let children = [
+    Role<"LiteralToken", AnyCharacterLiteral>,
+  ];
+}
+def FloatingLiteralExpression : Sequence<LiteralExpression> {
+  let documentation = [{
+    Expression for floating-point literals. C++ [lex.fcon]
+  }];
+  let children = [
+    Role<"LiteralToken", Token<"numeric_constant">>,
+  ];
+}
+defvar AnyStringLiteral = AnyToken<[
+  "string_literal", "wide_string_literal", "utf8_string_literal",
+  "utf16_string_literal", "utf32_string_literal"
+]>;
+def StringLiteralExpression : Sequence<LiteralExpression> {
+  let documentation = [{
+    Expression for string-literals. C++ [lex.string]
+  }];
+  // FIXME: string literals may consist of multiple tokens.
+  // These are merged in phase 6, but tokens are captured after phase 4.
+  // The child here should be a list of literal tokens instead.
+  let children = [
+    Role<"LiteralToken", AnyStringLiteral>,
+  ];
+}
+def BoolLiteralExpression : Sequence<LiteralExpression> {
+  let documentation = [{
+    Expression for boolean literals. C++ [lex.bool]
+  }];
+  let children = [
+    Role<"LiteralToken", AnyToken<["kw_false","kw_true"]>>,
+  ];
+}
+def CxxNullPtrExpression : Sequence<LiteralExpression> {
+  let documentation = [{
+    Expression for the `nullptr` literal. C++ [lex.nullptr]
+  }];
+  let children = [
+    Role<"LiteralToken", Keyword<"nullptr">>,
+  ];
+}
+def UserDefinedLiteralExpression : Alternatives<LiteralExpression> {
+  let documentation = [{
+    Expression for user-defined literal. C++ [lex.ext]
+    user-defined-literal:
+      user-defined-integer-literal
+      user-defined-floating-point-literal
+      user-defined-string-literal
+      user-defined-character-literal
+  }];
+}
+def IntegerUserDefinedLiteralExpression : Sequence<UserDefinedLiteralExpression> {
+  let documentation = [{
+    Expression for user-defined-integer-literal. C++ [lex.ext]
+  }];
+  let children = [
+    Role<"LiteralToken", Keyword<"numeric_constant">>,
+  ];
+}
+def FloatUserDefinedLiteralExpression : Sequence<UserDefinedLiteralExpression> {
+  let documentation = [{
+    Expression for user-defined-floating-point-literal. C++ [lex.ext]
+  }];
+  let children = [
+    Role<"LiteralToken", Keyword<"numeric_constant">>,
+  ];
+}
+def CharUserDefinedLiteralExpression : Sequence<UserDefinedLiteralExpression> {
+  let documentation = [{
+    Expression for user-defined-character-literal. C++ [lex.ext]
+  }];
+  let children = [
+    Role<"LiteralToken", AnyCharacterLiteral>,
+  ];
+}
+def StringUserDefinedLiteralExpression : Sequence<UserDefinedLiteralExpression> {
+  let documentation = [{
+    Expression for user-defined-string-literal. C++ [lex.ext]
+  }];
+  let children = [
+    Role<"LiteralToken", AnyStringLiteral>,
+  ];
+}
 def IdExpression : Sequence<Expression> {
   let documentation = [{
     Models an `id-expression`, e.g. `std::vector<int>::size`.
     C++ [expr.prim.id]
     id-expression:
       unqualified-id
       qualified-id
     qualified-id:

clang/lib/Tooling/Syntax/Nodes.cpp

syntax::DeclaratorList::getDeclaratorsAndCommas() {
   for (const auto &DeclaratorAsNodeAndComma : DeclaratorsAsNodesAndCommas) {
     Children.push_back(
         {llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNodeAndComma.element),
          DeclaratorAsNodeAndComma.delimiter});
   }
   return Children;
 }
 
-syntax::Leaf *syntax::LiteralExpression::getLiteralToken() {
-  return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
-}
-
 syntax::Expression *syntax::BinaryOperatorExpression::getLhs() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::LeftHandSide));
 }
 
 syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
 }