[clang] 7b404b6 - Add `FloatingLiteral` to SyntaxTree
Eduardo Caldas via cfe-commits
cfe-commits at lists.llvm.org
Thu Jun 25 10:05:22 PDT 2020
Author: Eduardo Caldas
Date: 2020-06-25T17:05:08Z
New Revision: 7b404b6d003181e990f53d27866ee98d5151c4f3
URL: https://github.com/llvm/llvm-project/commit/7b404b6d003181e990f53d27866ee98d5151c4f3
DIFF: https://github.com/llvm/llvm-project/commit/7b404b6d003181e990f53d27866ee98d5151c4f3.diff
LOG: Add `FloatingLiteral` to SyntaxTree
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D82318
Added:
Modified:
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
Removed:
################################################################################
diff --git a/clang/include/clang/Tooling/Syntax/Nodes.h b/clang/include/clang/Tooling/Syntax/Nodes.h
index e50e80ec1fc3..9446d911c18e 100644
--- a/clang/include/clang/Tooling/Syntax/Nodes.h
+++ b/clang/include/clang/Tooling/Syntax/Nodes.h
@@ -43,11 +43,12 @@ enum class NodeKind : uint16_t {
PrefixUnaryOperatorExpression,
PostfixUnaryOperatorExpression,
BinaryOperatorExpression,
- CxxNullPtrExpression,
IntegerLiteralExpression,
- BoolLiteralExpression,
CharacterLiteralExpression,
+ FloatingLiteralExpression,
StringLiteralExpression,
+ BoolLiteralExpression,
+ CxxNullPtrExpression,
IdExpression,
// Statements.
@@ -247,14 +248,14 @@ class UnknownExpression final : public Expression {
}
};
-/// C++11 'nullptr' expression.
-class CxxNullPtrExpression final : public Expression {
+/// Expression for integer literals. C++ [lex.icon]
+class IntegerLiteralExpression final : public Expression {
public:
- CxxNullPtrExpression() : Expression(NodeKind::CxxNullPtrExpression) {}
+ IntegerLiteralExpression() : Expression(NodeKind::IntegerLiteralExpression) {}
static bool classof(const Node *N) {
- return N->kind() == NodeKind::CxxNullPtrExpression;
+ return N->kind() == NodeKind::IntegerLiteralExpression;
}
- syntax::Leaf *nullPtrKeyword();
+ syntax::Leaf *literalToken();
};
/// Expression for character literals. C++ [lex.ccon]
@@ -268,12 +269,23 @@ class CharacterLiteralExpression final : public Expression {
syntax::Leaf *literalToken();
};
-/// Expression for integer literals.
-class IntegerLiteralExpression final : public Expression {
+/// Expression for floating-point literals. C++ [lex.fcon]
+class FloatingLiteralExpression final : public Expression {
public:
- IntegerLiteralExpression() : Expression(NodeKind::IntegerLiteralExpression) {}
+ FloatingLiteralExpression()
+ : Expression(NodeKind::FloatingLiteralExpression) {}
static bool classof(const Node *N) {
- return N->kind() == NodeKind::IntegerLiteralExpression;
+ return N->kind() == NodeKind::FloatingLiteralExpression;
+ }
+ syntax::Leaf *literalToken();
+};
+
+/// Expression for string-literals. C++ [lex.string]
+class StringLiteralExpression final : public Expression {
+public:
+ StringLiteralExpression() : Expression(NodeKind::StringLiteralExpression) {}
+ static bool classof(const Node *N) {
+ return N->kind() == NodeKind::StringLiteralExpression;
}
syntax::Leaf *literalToken();
};
@@ -288,14 +300,14 @@ class BoolLiteralExpression final : public Expression {
syntax::Leaf *literalToken();
};
-/// Expression for string-literals. C++ [lex.string]
-class StringLiteralExpression final : public Expression {
+/// Expression for the `nullptr` literal. C++ [lex.nullptr]
+class CxxNullPtrExpression final : public Expression {
public:
- StringLiteralExpression() : Expression(NodeKind::StringLiteralExpression) {}
+ CxxNullPtrExpression() : Expression(NodeKind::CxxNullPtrExpression) {}
static bool classof(const Node *N) {
- return N->kind() == NodeKind::StringLiteralExpression;
+ return N->kind() == NodeKind::CxxNullPtrExpression;
}
- syntax::Leaf *literalToken();
+ syntax::Leaf *nullPtrKeyword();
};
/// An abstract class for prefix and postfix unary operators.
diff --git a/clang/lib/Tooling/Syntax/BuildTree.cpp b/clang/lib/Tooling/Syntax/BuildTree.cpp
index bd2f372e057b..6f740b3ab146 100644
--- a/clang/lib/Tooling/Syntax/BuildTree.cpp
+++ b/clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,19 +654,20 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
return true;
}
- bool WalkUpFromCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) {
+ bool WalkUpFromCharacterLiteral(CharacterLiteral *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
- new (allocator()) syntax::BoolLiteralExpression, S);
+ new (allocator()) syntax::CharacterLiteralExpression, S);
return true;
}
- bool WalkUpFromCharacterLiteral(CharacterLiteral *S) {
+ bool WalkUpFromFloatingLiteral(FloatingLiteral *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
- new (allocator()) syntax::CharacterLiteralExpression, S);
+ new (allocator()) syntax::FloatingLiteralExpression, S);
return true;
}
+
bool WalkUpFromStringLiteral(StringLiteral *S) {
Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
@@ -674,6 +675,13 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
return true;
}
+ bool WalkUpFromCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) {
+ Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+ Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::BoolLiteralExpression, S);
+ return true;
+ }
+
bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
diff --git a/clang/lib/Tooling/Syntax/Nodes.cpp b/clang/lib/Tooling/Syntax/Nodes.cpp
index 290b1e6bafa1..1f601fdf180b 100644
--- a/clang/lib/Tooling/Syntax/Nodes.cpp
+++ b/clang/lib/Tooling/Syntax/Nodes.cpp
@@ -18,16 +18,18 @@ llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
return OS << "TranslationUnit";
case NodeKind::UnknownExpression:
return OS << "UnknownExpression";
- case NodeKind::CxxNullPtrExpression:
- return OS << "CxxNullPtrExpression";
case NodeKind::IntegerLiteralExpression:
return OS << "IntegerLiteralExpression";
- case NodeKind::BoolLiteralExpression:
- return OS << "BoolLiteralExpression";
case NodeKind::CharacterLiteralExpression:
return OS << "CharacterLiteralExpression";
+ case NodeKind::FloatingLiteralExpression:
+ return OS << "FloatingLiteralExpression";
case NodeKind::StringLiteralExpression:
return OS << "StringLiteralExpression";
+ case NodeKind::BoolLiteralExpression:
+ return OS << "BoolLiteralExpression";
+ case NodeKind::CxxNullPtrExpression:
+ return OS << "CxxNullPtrExpression";
case NodeKind::PrefixUnaryOperatorExpression:
return OS << "PrefixUnaryOperatorExpression";
case NodeKind::PostfixUnaryOperatorExpression:
@@ -206,12 +208,12 @@ syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
findChild(syntax::NodeRole::LiteralToken));
}
-syntax::Leaf *syntax::BoolLiteralExpression::literalToken() {
+syntax::Leaf *syntax::CharacterLiteralExpression::literalToken() {
return llvm::cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::LiteralToken));
}
-syntax::Leaf *syntax::CharacterLiteralExpression::literalToken() {
+syntax::Leaf *syntax::FloatingLiteralExpression::literalToken() {
return llvm::cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::LiteralToken));
}
@@ -221,6 +223,11 @@ syntax::Leaf *syntax::StringLiteralExpression::literalToken() {
findChild(syntax::NodeRole::LiteralToken));
}
+syntax::Leaf *syntax::BoolLiteralExpression::literalToken() {
+ return llvm::cast_or_null<syntax::Leaf>(
+ findChild(syntax::NodeRole::LiteralToken));
+}
+
syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
return llvm::cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::LiteralToken));
diff --git a/clang/unittests/Tooling/Syntax/TreeTest.cpp b/clang/unittests/Tooling/Syntax/TreeTest.cpp
index bc2a65b2dd07..5dd6cc747628 100644
--- a/clang/unittests/Tooling/Syntax/TreeTest.cpp
+++ b/clang/unittests/Tooling/Syntax/TreeTest.cpp
@@ -53,6 +53,8 @@ struct TestClangConfig {
bool isC99OrLater() const { return Language == Lang_C99; }
+ bool isC() const { return Language == Lang_C89 || Language == Lang_C99; }
+
bool isCXX() const {
return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14 || Language == Lang_CXX17 ||
@@ -69,10 +71,6 @@ struct TestClangConfig {
Language == Lang_CXX20;
}
- bool hasBoolType() const {
- return Language == Lang_C89 || Language == Lang_C99;
- }
-
bool isCXX17OrLater() const {
return Language == Lang_CXX17 || Language == Lang_CXX20;
}
@@ -1207,14 +1205,66 @@ void test(S s) {
)txt"));
}
-TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
+TEST_P(SyntaxTreeTest, IntegerLiteral) {
+ EXPECT_TRUE(treeDumpEqual(
+ R"cpp(
+void test() {
+ 12;
+ 12u;
+ 12l;
+ 12ul;
+ 014;
+ 0XC;
+}
+)cpp",
+ R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+ |-void
+ |-SimpleDeclarator
+ | |-test
+ | `-ParametersAndQualifiers
+ | |-(
+ | `-)
+ `-CompoundStatement
+ |-{
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-12
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-12u
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-12l
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-12ul
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-014
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-0XC
+ | `-;
+ `-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, IntegerLiteralLongLong) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test() {
- nullptr;
+ 12ll;
+ 12ull;
}
)cpp",
R"txt(
@@ -1229,8 +1279,70 @@ void test() {
`-CompoundStatement
|-{
|-ExpressionStatement
- | |-CxxNullPtrExpression
- | | `-nullptr
+ | |-IntegerLiteralExpression
+ | | `-12ll
+ | `-;
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-12ull
+ | `-;
+ `-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, IntegerLiteralBinary) {
+ if (!GetParam().isCXX14OrLater()) {
+ return;
+ }
+ EXPECT_TRUE(treeDumpEqual(
+ R"cpp(
+void test() {
+ 0b1100;
+}
+)cpp",
+ R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+ |-void
+ |-SimpleDeclarator
+ | |-test
+ | `-ParametersAndQualifiers
+ | |-(
+ | `-)
+ `-CompoundStatement
+ |-{
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-0b1100
+ | `-;
+ `-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, IntegerLiteralWithDigitSeparators) {
+ if (!GetParam().isCXX14OrLater()) {
+ return;
+ }
+ EXPECT_TRUE(treeDumpEqual(
+ R"cpp(
+void test() {
+ 1'2'0ull;
+}
+)cpp",
+ R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+ |-void
+ |-SimpleDeclarator
+ | |-test
+ | `-ParametersAndQualifiers
+ | |-(
+ | `-)
+ `-CompoundStatement
+ |-{
+ |-ExpressionStatement
+ | |-IntegerLiteralExpression
+ | | `-1'2'0ull
| `-;
`-}
)txt"));
@@ -1365,15 +1477,58 @@ void test() {
)txt"));
}
-TEST_P(SyntaxTreeTest, BoolLiteral) {
- if (GetParam().hasBoolType()) {
+TEST_P(SyntaxTreeTest, FloatingLiteral) {
+ EXPECT_TRUE(treeDumpEqual(
+ R"cpp(
+void test() {
+ 1e-2;
+ 2.;
+ .2;
+ 2.f;
+}
+)cpp",
+ R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+ |-void
+ |-SimpleDeclarator
+ | |-test
+ | `-ParametersAndQualifiers
+ | |-(
+ | `-)
+ `-CompoundStatement
+ |-{
+ |-ExpressionStatement
+ | |-FloatingLiteralExpression
+ | | `-1e-2
+ | `-;
+ |-ExpressionStatement
+ | |-FloatingLiteralExpression
+ | | `-2.
+ | `-;
+ |-ExpressionStatement
+ | |-FloatingLiteralExpression
+ | | `-.2
+ | `-;
+ |-ExpressionStatement
+ | |-FloatingLiteralExpression
+ | | `-2.f
+ | `-;
+ `-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, FloatingLiteralHexadecimal) {
+ if (!GetParam().isCXX17OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test() {
- true;
- false;
+ 0xfp1;
+ 0xf.p1;
+ 0x.fp1;
+ 0xf.fp1f;
}
)cpp",
R"txt(
@@ -1388,12 +1543,20 @@ void test() {
`-CompoundStatement
|-{
|-ExpressionStatement
- | |-BoolLiteralExpression
- | | `-true
+ | |-FloatingLiteralExpression
+ | | `-0xfp1
| `-;
|-ExpressionStatement
- | |-BoolLiteralExpression
- | | `-false
+ | |-FloatingLiteralExpression
+ | | `-0xf.p1
+ | `-;
+ |-ExpressionStatement
+ | |-FloatingLiteralExpression
+ | | `-0x.fp1
+ | `-;
+ |-ExpressionStatement
+ | |-FloatingLiteralExpression
+ | | `-0xf.fp1f
| `-;
`-}
)txt"));
@@ -1502,66 +1665,15 @@ void test() {
)txt"));
}
-TEST_P(SyntaxTreeTest, IntegerLiteral) {
- EXPECT_TRUE(treeDumpEqual(
- R"cpp(
-void test() {
- 12;
- 12u;
- 12l;
- 12ul;
- 014;
- 0XC;
-}
-)cpp",
- R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
- |-void
- |-SimpleDeclarator
- | |-test
- | `-ParametersAndQualifiers
- | |-(
- | `-)
- `-CompoundStatement
- |-{
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12
- | `-;
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12u
- | `-;
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12l
- | `-;
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12ul
- | `-;
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-014
- | `-;
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-0XC
- | `-;
- `-}
-)txt"));
-}
-
-TEST_P(SyntaxTreeTest, IntegerLiteralLongLong) {
- if (!GetParam().isCXX11OrLater()) {
+TEST_P(SyntaxTreeTest, BoolLiteral) {
+ if (GetParam().isC()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test() {
- 12ll;
- 12ull;
+ true;
+ false;
}
)cpp",
R"txt(
@@ -1576,54 +1688,25 @@ void test() {
`-CompoundStatement
|-{
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12ll
+ | |-BoolLiteralExpression
+ | | `-true
| `-;
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-12ull
- | `-;
- `-}
-)txt"));
-}
-
-TEST_P(SyntaxTreeTest, IntegerLiteralBinary) {
- if (!GetParam().isCXX14OrLater()) {
- return;
- }
- EXPECT_TRUE(treeDumpEqual(
- R"cpp(
-void test() {
- 0b1100;
-}
-)cpp",
- R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
- |-void
- |-SimpleDeclarator
- | |-test
- | `-ParametersAndQualifiers
- | |-(
- | `-)
- `-CompoundStatement
- |-{
- |-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-0b1100
+ | |-BoolLiteralExpression
+ | | `-false
| `-;
`-}
)txt"));
}
-TEST_P(SyntaxTreeTest, IntegerLiteralWithDigitSeparators) {
- if (!GetParam().isCXX14OrLater()) {
+TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
+ if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test() {
- 1'2'0ull;
+ nullptr;
}
)cpp",
R"txt(
@@ -1638,8 +1721,8 @@ void test() {
`-CompoundStatement
|-{
|-ExpressionStatement
- | |-IntegerLiteralExpression
- | | `-1'2'0ull
+ | |-CxxNullPtrExpression
+ | | `-nullptr
| `-;
`-}
)txt"));
More information about the cfe-commits
mailing list