eduucaldas updated this revision to Diff 277060.
eduucaldas marked an inline comment as done.
eduucaldas added a comment.
Add assert
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D82157/new/
https://reviews.llvm.org/D82157
Files:
clang/include/clang/Tooling/Syntax/Nodes.h
clang/lib/Tooling/Syntax/BuildTree.cpp
clang/lib/Tooling/Syntax/Nodes.cpp
clang/unittests/Tooling/Syntax/TreeTest.cpp
Index: clang/unittests/Tooling/Syntax/TreeTest.cpp
===================================================================
--- clang/unittests/Tooling/Syntax/TreeTest.cpp
+++ clang/unittests/Tooling/Syntax/TreeTest.cpp
@@ -1184,20 +1184,139 @@
)txt"));
}
-TEST_P(SyntaxTreeTest, IntegerLiteral) {
+TEST_P(SyntaxTreeTest, UserDefinedLiteral) {
+ if (!GetParam().isCXX11OrLater()) {
+ return;
+ }
EXPECT_TRUE(treeDumpEqual(
R"cpp(
+typedef decltype(sizeof(void *)) size_t;
+
+unsigned operator "" _i(unsigned long long);
+unsigned operator "" _f(long double);
+unsigned operator "" _c(char);
+unsigned operator "" _s(const char*, size_t);
+unsigned operator "" _r(const char*);
+template <char...>
+unsigned operator "" _t();
+
void test() {
- 12;
- 12u;
- 12l;
- 12ul;
- 014;
- 0XC;
+ 12_i; // call: operator "" _i(12uLL) | kind: integer
+ 1.2_f; // call: operator "" _f(1.2L) | kind: float
+ '2'_c; // call: operator "" _c('2') | kind: char
+ "12"_s; // call: operator "" _s("12") | kind: string
+
+ 12_r; // call: operator "" _r("12") | kind: integer
+ 1.2_r; // call: operator "" _i("1.2") | kind: float
+ 12_t; // call: operator<'1', '2'> "" _x() | kind: integer
+ 1.2_t; // call: operator<'1', '2'> "" _x() | kind: float
}
-)cpp",
+ )cpp",
R"txt(
*: TranslationUnit
+|-SimpleDeclaration
+| |-typedef
+| |-decltype
+| |-(
+| |-UnknownExpression
+| | |-sizeof
+| | |-(
+| | |-void
+| | |-*
+| | `-)
+| |-)
+| |-SimpleDeclarator
+| | `-size_t
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_i
+| | `-ParametersAndQualifiers
+| | |-(
+| | |-SimpleDeclaration
+| | | |-unsigned
+| | | |-long
+| | | `-long
+| | `-)
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_f
+| | `-ParametersAndQualifiers
+| | |-(
+| | |-SimpleDeclaration
+| | | |-long
+| | | `-double
+| | `-)
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_c
+| | `-ParametersAndQualifiers
+| | |-(
+| | |-SimpleDeclaration
+| | | `-char
+| | `-)
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_s
+| | `-ParametersAndQualifiers
+| | |-(
+| | |-SimpleDeclaration
+| | | |-const
+| | | |-char
+| | | `-SimpleDeclarator
+| | | `-*
+| | |-,
+| | |-SimpleDeclaration
+| | | `-size_t
+| | `-)
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_r
+| | `-ParametersAndQualifiers
+| | |-(
+| | |-SimpleDeclaration
+| | | |-const
+| | | |-char
+| | | `-SimpleDeclarator
+| | | `-*
+| | `-)
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-SimpleDeclaration
+| | `-char
+| |-...
+| |->
+| `-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_t
+| | `-ParametersAndQualifiers
+| | |-(
+| | `-)
+| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
@@ -1208,28 +1327,36 @@
`-CompoundStatement
|-{
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12
+ | |-IntegerUserDefinedLiteralExpression
+ | | `-12_i
| `-;
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12u
+ | |-FloatUserDefinedLiteralExpression
+ | | `-1.2_f
| `-;
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12l
+ | |-CharUserDefinedLiteralExpression
+ | | `-'2'_c
| `-;
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12ul
+ | |-StringUserDefinedLiteralExpression
+ | | `-"12"_s
| `-;
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-014
+ | |-IntegerUserDefinedLiteralExpression
+ | | `-12_r
| `-;
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-0XC
+ | |-FloatUserDefinedLiteralExpression
+ | | `-1.2_r
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerUserDefinedLiteralExpression
+ | | `-12_t
+ | `-;
+ |-ExpressionStatement
+ | |-FloatUserDefinedLiteralExpression
+ | | `-1.2_t
| `-;
`-}
)txt"));
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===================================================================
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -32,6 +32,14 @@
return OS << "BoolLiteralExpression";
case NodeKind::CxxNullPtrExpression:
return OS << "CxxNullPtrExpression";
+ case NodeKind::IntegerUserDefinedLiteralExpression:
+ return OS << "IntegerUserDefinedLiteralExpression";
+ case NodeKind::FloatUserDefinedLiteralExpression:
+ return OS << "FloatUserDefinedLiteralExpression";
+ case NodeKind::CharUserDefinedLiteralExpression:
+ return OS << "CharUserDefinedLiteralExpression";
+ case NodeKind::StringUserDefinedLiteralExpression:
+ return OS << "StringUserDefinedLiteralExpression";
case NodeKind::PrefixUnaryOperatorExpression:
return OS << "PrefixUnaryOperatorExpression";
case NodeKind::PostfixUnaryOperatorExpression:
@@ -252,6 +260,11 @@
findChild(syntax::NodeRole::LiteralToken));
}
+syntax::Leaf *syntax::UserDefinedLiteralExpression::literalToken() {
+ return llvm::cast_or_null<syntax::Leaf>(
+ findChild(syntax::NodeRole::LiteralToken));
+}
+
syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
return llvm::cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::BinaryOperatorExpression_leftHandSide));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===================================================================
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -23,6 +23,7 @@
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/TokenKinds.h"
#include "clang/Lex/Lexer.h"
+#include "clang/Lex/LiteralSupport.h"
#include "clang/Tooling/Syntax/Nodes.h"
#include "clang/Tooling/Syntax/Tokens.h"
#include "clang/Tooling/Syntax/Tree.h"
@@ -216,7 +217,8 @@
}
if (Initializer.isValid()) {
auto InitializerEnd = Initializer.getEnd();
- assert(SM.isBeforeInTranslationUnit(End, InitializerEnd) || End == InitializerEnd);
+ assert(SM.isBeforeInTranslationUnit(End, InitializerEnd) ||
+ End == InitializerEnd);
End = InitializerEnd;
}
return SourceRange(Start, End);
@@ -551,8 +553,8 @@
namespace {
class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
public:
- explicit BuildTreeVisitor(ASTContext &Ctx, syntax::TreeBuilder &Builder)
- : Builder(Builder), LangOpts(Ctx.getLangOpts()) {}
+ explicit BuildTreeVisitor(ASTContext &Context, syntax::TreeBuilder &Builder)
+ : Builder(Builder), Context(Context) {}
bool shouldTraversePostOrder() const { return true; }
@@ -708,6 +710,54 @@
return NNS;
}
+ bool TraverseUserDefinedLiteral(UserDefinedLiteral *S) {
+ // The semantic AST node `UserDefinedLiteral` (UDL) may have one child node
+ // referencing the location of the UDL suffix (`_w` in `1.2_w`). The
+ // UDL suffix location does not point to the beginning of a token, so we
+ // can't represent the UDL suffix as a separate syntax tree node.
+
+ return WalkUpFromUserDefinedLiteral(S);
+ }
+
+ syntax::UserDefinedLiteralExpression *
+ buildUserDefinedLiteral(UserDefinedLiteral *S) {
+ switch (S->getLiteralOperatorKind()) {
+ case clang::UserDefinedLiteral::LOK_Integer:
+ return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
+ case clang::UserDefinedLiteral::LOK_Floating:
+ return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
+ case clang::UserDefinedLiteral::LOK_Character:
+ return new (allocator()) syntax::CharUserDefinedLiteralExpression;
+ case clang::UserDefinedLiteral::LOK_String:
+ return new (allocator()) syntax::StringUserDefinedLiteralExpression;
+ case clang::UserDefinedLiteral::LOK_Raw:
+ case clang::UserDefinedLiteral::LOK_Template:
+ // For raw literal operator and numeric literal operator template we
+ // cannot get the type of the operand in the semantic AST. We get this
+ // information from the token. As integer and floating point have the same
+ // token kind, we run `NumericLiteralParser` again to distinguish them.
+ auto TokLoc = S->getBeginLoc();
+ auto TokSpelling =
+ Builder.findToken(TokLoc)->text(Context.getSourceManager());
+ auto Literal =
+ NumericLiteralParser(TokSpelling, TokLoc, Context.getSourceManager(),
+ Context.getLangOpts(), Context.getTargetInfo(),
+ Context.getDiagnostics());
+ if (Literal.isIntegerLiteral())
+ return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
+ else {
+ assert(Literal.isFloatingLiteral());
+ return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
+ }
+ }
+ }
+
+ bool WalkUpFromUserDefinedLiteral(UserDefinedLiteral *S) {
+ Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
+ Builder.foldNode(Builder.getExprRange(S), buildUserDefinedLiteral(S), S);
+ return true;
+ }
+
bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
if (auto *NNS = BuildNestedNameSpecifier(S->getQualifierLoc()))
Builder.markChild(NNS, syntax::NodeRole::IdExpression_qualifier);
@@ -817,9 +867,9 @@
bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
if (getOperatorNodeKind(*S) ==
syntax::NodeKind::PostfixUnaryOperatorExpression) {
- // A postfix unary operator is declared as taking two operands. The second
- // operand is used to distinguish from its prefix counterpart. In the
- // semantic AST this "phantom" operand is represented as a
+ // A postfix unary operator is declared as taking two operands. The
+ // second operand is used to distinguish from its prefix counterpart. In
+ // the semantic AST this "phantom" operand is represented as a
// `IntegerLiteral` with invalid `SourceLocation`. We skip visiting this
// operand because it does not correspond to anything written in source
// code
@@ -1225,7 +1275,7 @@
llvm::BumpPtrAllocator &allocator() { return Builder.allocator(); }
syntax::TreeBuilder &Builder;
- const LangOptions &LangOpts;
+ const ASTContext &Context;
};
} // namespace
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===================================================================
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -50,6 +50,10 @@
StringLiteralExpression,
BoolLiteralExpression,
CxxNullPtrExpression,
+ IntegerUserDefinedLiteralExpression,
+ FloatUserDefinedLiteralExpression,
+ CharUserDefinedLiteralExpression,
+ StringUserDefinedLiteralExpression,
IdExpression,
// Statements.
@@ -325,6 +329,72 @@
syntax::Leaf *nullPtrKeyword();
};
+/// 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 Expression {
+public:
+ UserDefinedLiteralExpression(NodeKind K) : Expression(K) {}
+ static bool classof(const Node *N) {
+ return N->kind() == NodeKind::IntegerUserDefinedLiteralExpression ||
+ N->kind() == NodeKind::FloatUserDefinedLiteralExpression ||
+ N->kind() == NodeKind::CharUserDefinedLiteralExpression ||
+ N->kind() == NodeKind::StringUserDefinedLiteralExpression;
+ }
+ syntax::Leaf *literalToken();
+};
+
+/// 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) {
+ return N->kind() == NodeKind::IntegerUserDefinedLiteralExpression;
+ }
+};
+
+/// 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) {
+ return N->kind() == NodeKind::FloatUserDefinedLiteralExpression;
+ }
+};
+
+/// 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) {
+ return N->kind() == NodeKind::CharUserDefinedLiteralExpression;
+ }
+};
+
+/// 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) {
+ return N->kind() == NodeKind::StringUserDefinedLiteralExpression;
+ }
+};
+
/// An abstract class for prefix and postfix unary operators.
class UnaryOperatorExpression : public Expression {
public:
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
