from:"Eduardo Caldas via Phabricator via cfe\-commits"

[PATCH] D82954: Fix crash on overloaded postfix unary operators due to invalid sloc

2020-07-03 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 275316.
eduucaldas added a comment.
Herald added a subscriber: mgorny.

Nits


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82954/new/

https://reviews.llvm.org/D82954

Files:
  clang/include/clang/AST/ExprCXX.h
  clang/lib/AST/ExprCXX.cpp
  clang/unittests/Tooling/CMakeLists.txt
  clang/unittests/Tooling/CXXOperatorCallExprTest.cpp

Index: clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
===
--- /dev/null
+++ clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
@@ -0,0 +1,77 @@
+//===- unittests/Tooling/CXXOperatorCallExprTest.cpp --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+//
+// Unit tests for the predicates in CXXOperatorCallExpr.
+//
+//===--===//
+
+#include "TestVisitor.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace {
+
+TEST(CXXOperatorPredicatesTest, InfixBinaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+friend X operator+(X, X);
+  };
+  void test(X x){
+x + x;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_TRUE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, CallLikeOp) {
+  const std::string Code = R"cpp(
+  struct X{
+int operator[](int idx);
+  };
+  void test(X x){
+x[1];
+  }
+  )cpp";
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, PostfixUnaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+X operator++(int);
+  };
+  void test(X x){
+x++;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+} // namespace
+} // namespace clang
Index: clang/unittests/Tooling/CMakeLists.txt
===
--- clang/unittests/Tooling/CMakeLists.txt
+++ clang/unittests/Tooling/CMakeLists.txt
@@ -18,6 +18,7 @@
   CastExprTest.cpp
   CommentHandlerTest.cpp
   CompilationDatabaseTest.cpp
+  CXXOperatorCallExprTest.cpp
   DependencyScannerTest.cpp
   DiagnosticsYamlTest.cpp
   ExecutionTest.cpp
Index: clang/lib/AST/ExprCXX.cpp
===
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -46,15 +46,17 @@
 //===--===//
 
 bool CXXOperatorCallExpr::isInfixBinaryOp() const {
-  // An infix binary operator is any operator with two arguments other than
-  // operator() and operator[]. Note that none of these operators can have
-  // default arguments, so it suffices to check the number of argument
-  // expressions.
   if (getNumArgs() != 2)
 return false;
-
   switch (getOperator()) {
-  case OO_Call: case OO_Subscript:
+  // operator() may have two arguments, but it's not a binary operator
+  case OO_Call:
+  // operator[] takes two arguments but it's not infix
+  case OO_Subscript:
+  // Postfix unary operators (++ and --) take 2 arguments to differ from their
+  // prefix counterparts
+  case OO_PlusPlus:
+  case OO_MinusMinus:
 return false;
   default:
 return true;
Index: clang/include/clang/AST/ExprCXX.h
===
--- clang/include/clang/AST/ExprCXX.h
+++ clang/include/clang/AST/ExprCXX.h
@@ -121,6 +121,7 @@
Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual ||
Opc == OO_CaretEqual || Opc == OO_PipeEqual;
   }
+
   bool isAssignmentOp() const { return isAssignmentOp(getOperator()); }
 
   static bool isComparisonOp(OverloadedOperatorKind Opc) {
@@ -137,9 +138,9 @@
   return false;
 }
   }
+
   bool isComparisonOp() const { return isComparisonOp(getOperator()); }
 
-  /// Is this written as an infix binary operator?
   bool isInfixBinaryOp() const;
 
   /// Returns the location of the operator symbol in the expression.
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82954: Fix crash on overloaded postfix unary operators due to invalid sloc

2020-07-03 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 275318.
eduucaldas added a comment.

Revert mistake on last update, used `arc diff --update` with the wrong diff


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82954/new/

https://reviews.llvm.org/D82954

Files:
  clang/lib/Tooling/Syntax/BuildTree.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
@@ -2323,6 +2323,64 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  X operator++(int);
+};
+void test(X x) {
+  x++;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-SimpleDeclaration
+| | |-X
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-++
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   |-SimpleDeclaration
+| | |   | `-int
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-PostfixUnaryOperatorExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-IdExpression
+| |   `-UnqualifiedId
+| | `-++
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -12,6 +12,7 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TypeLoc.h"
@@ -114,6 +115,85 @@
 };
 } // namespace
 
+syntax::NodeKind getOperatorNodeKind(const CXXOperatorCallExpr ) {
+  switch (E.getOperator()) {
+  // Comparison
+  case OO_EqualEqual:
+  case OO_ExclaimEqual:
+  case OO_Greater:
+  case OO_GreaterEqual:
+  case OO_Less:
+  case OO_LessEqual:
+  case OO_Spaceship:
+  // Assignment
+  case OO_Equal:
+  case OO_SlashEqual:
+  case OO_PercentEqual:
+  case OO_CaretEqual:
+  case OO_PipeEqual:
+  case OO_LessLessEqual:
+  case OO_GreaterGreaterEqual:
+  case OO_PlusEqual:
+  case OO_MinusEqual:
+  case OO_StarEqual:
+  case OO_AmpEqual:
+  // Binary computation
+  case OO_Slash:
+  case OO_Percent:
+  case OO_Caret:
+  case OO_Pipe:
+  case OO_LessLess:
+  case OO_GreaterGreater:
+  case OO_AmpAmp:
+  case OO_PipePipe:
+return syntax::NodeKind::BinaryOperatorExpression;
+  case OO_Tilde:
+  case OO_Exclaim:
+return syntax::NodeKind::PrefixUnaryOperatorExpression;
+  // Prefix/Postfix increment/decrement
+  case OO_PlusPlus:
+  case OO_MinusMinus:
+switch (E.getNumArgs()) {
+case 1:
+  return syntax::NodeKind::PrefixUnaryOperatorExpression;
+case 2:
+  return syntax::NodeKind::PostfixUnaryOperatorExpression;
+default:
+  llvm_unreachable("Invalid number of arguments for operator");
+}
+  // Operators that can be unary or binary
+  case OO_Plus:
+  case OO_Minus:
+  case OO_Star:
+  case OO_Amp:
+switch (E.getNumArgs()) {
+case 1:
+  return syntax::NodeKind::PrefixUnaryOperatorExpression;
+case 2:
+  return syntax::NodeKind::BinaryOperatorExpression;
+default:
+  llvm_unreachable("Invalid number of arguments for operator");
+}
+return syntax::NodeKind::BinaryOperatorExpression;
+  // Not supported by SyntaxTree
+  case OO_New:
+  case OO_Delete:
+  case OO_Array_New:
+  case OO_Array_Delete:
+  case OO_Coawait:
+  case OO_Call:
+  case OO_Subscript:
+  case OO_Arrow:
+  case OO_Comma:
+  case OO_ArrowStar:
+return syntax::NodeKind::UnknownExpression;
+  case OO_Conditional: // not overloadable
+  case NUM_OVERLOADED_OPERATORS:
+  case OO_None:
+llvm_unreachable("Not an overloadable operator");
+  }
+}
+
 /// Gets the range of declarator as defined by the C++ grammar. E.g.
 /// `int a;` -> range of `a`,
 /// `int *a;` -> range of `*a`,
@@ -658,6 +738,8 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
+if (S->getLocation().isInvalid())
+  return true;
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
@@ -730,7 +812,8 @@
   }
 
   bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
-if (S->isInfixBinaryOp()) {
+switch

[PATCH] D82954: Fix crash on overloaded postfix unary operators due to invalid sloc

2020-07-03 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 275315.
eduucaldas added a comment.

- Remove predicates in `CXXOperatorCallExpr`.
- Implement getOperatorNodeKind to dispatch from `CXXOperatorCallExpr` to 
syntax constructs  like `BinaryOperatorExpression`, 
`PrefixUnaryOperatorExpression`...


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82954/new/

https://reviews.llvm.org/D82954

Files:
  clang/lib/Tooling/Syntax/BuildTree.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
@@ -2323,6 +2323,64 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  X operator++(int);
+};
+void test(X x) {
+  x++;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-SimpleDeclaration
+| | |-X
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-++
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   |-SimpleDeclaration
+| | |   | `-int
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-PostfixUnaryOperatorExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-IdExpression
+| |   `-UnqualifiedId
+| | `-++
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -12,6 +12,7 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TypeLoc.h"
@@ -114,6 +115,85 @@
 };
 } // namespace
 
+syntax::NodeKind getOperatorNodeKind(const CXXOperatorCallExpr ) {
+  switch (E.getOperator()) {
+  // Comparison
+  case OO_EqualEqual:
+  case OO_ExclaimEqual:
+  case OO_Greater:
+  case OO_GreaterEqual:
+  case OO_Less:
+  case OO_LessEqual:
+  case OO_Spaceship:
+  // Assignment
+  case OO_Equal:
+  case OO_SlashEqual:
+  case OO_PercentEqual:
+  case OO_CaretEqual:
+  case OO_PipeEqual:
+  case OO_LessLessEqual:
+  case OO_GreaterGreaterEqual:
+  case OO_PlusEqual:
+  case OO_MinusEqual:
+  case OO_StarEqual:
+  case OO_AmpEqual:
+  // Binary computation
+  case OO_Slash:
+  case OO_Percent:
+  case OO_Caret:
+  case OO_Pipe:
+  case OO_LessLess:
+  case OO_GreaterGreater:
+  case OO_AmpAmp:
+  case OO_PipePipe:
+return syntax::NodeKind::BinaryOperatorExpression;
+  case OO_Tilde:
+  case OO_Exclaim:
+return syntax::NodeKind::PrefixUnaryOperatorExpression;
+  // Prefix/Postfix increment/decrement
+  case OO_PlusPlus:
+  case OO_MinusMinus:
+switch (E.getNumArgs()) {
+case 1:
+  return syntax::NodeKind::PrefixUnaryOperatorExpression;
+case 2:
+  return syntax::NodeKind::PostfixUnaryOperatorExpression;
+default:
+  llvm_unreachable("Invalid number of arguments for operator");
+}
+  // Operators that can be unary or binary
+  case OO_Plus:
+  case OO_Minus:
+  case OO_Star:
+  case OO_Amp:
+switch (E.getNumArgs()) {
+case 1:
+  return syntax::NodeKind::PrefixUnaryOperatorExpression;
+case 2:
+  return syntax::NodeKind::BinaryOperatorExpression;
+default:
+  llvm_unreachable("Invalid number of arguments for operator");
+}
+return syntax::NodeKind::BinaryOperatorExpression;
+  // Not supported by SyntaxTree
+  case OO_New:
+  case OO_Delete:
+  case OO_Array_New:
+  case OO_Array_Delete:
+  case OO_Coawait:
+  case OO_Call:
+  case OO_Subscript:
+  case OO_Arrow:
+  case OO_Comma:
+  case OO_ArrowStar:
+return syntax::NodeKind::UnknownExpression;
+  case OO_Conditional: // not overloadable
+  case NUM_OVERLOADED_OPERATORS:
+  case OO_None:
+llvm_unreachable("Not an overloadable operator");
+  }
+}
+
 /// Gets the range of declarator as defined by the C++ grammar. E.g.
 /// `int a;` -> range of `a`,
 /// `int *a;` -> range of `*a`,
@@ -658,6 +738,8 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
+if (S->getLocation().isInvalid())
+  return true;
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
@@ -730,7 +812,8 @@
   }

[PATCH] D82960: Add parenthesized expression to SyntaxTree

2020-07-02 Thread Eduardo Caldas via Phabricator via cfe-commits

This revision was automatically updated to reflect the committed changes.
Closed by commit rGfdbd78333fc6: Add parenthesized expression to SyntaxTree 
(authored by eduucaldas).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82960/new/

https://reviews.llvm.org/D82960

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
@@ -1129,6 +1129,61 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, ParenExpr) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  (1);
+  ((1));
+  (1 + (2));
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-IntegerLiteralExpression
+| | | `-1
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-ParenExpression
+| | | |-(
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | `-)
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-BinaryOperatorExpression
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | |-+
+| | | `-ParenExpression
+| | |   |-(
+| | |   |-IntegerLiteralExpression
+| | |   | `-2
+| | |   `-)
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2040,7 +2095,7 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-ParenExpression
 | | | |-(
 | | | |-BinaryOperatorExpression
 | | | | |-IntegerLiteralExpression
@@ -2050,7 +2105,7 @@
 | | | |   `-2
 | | | `-)
 | | |-*
-| | `-UnknownExpression
+| | `-ParenExpression
 | |   |-(
 | |   |-BinaryOperatorExpression
 | |   | |-IntegerLiteralExpression
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -18,6 +18,8 @@
 return OS << "TranslationUnit";
   case NodeKind::UnknownExpression:
 return OS << "UnknownExpression";
+  case NodeKind::ParenExpression:
+return OS << "ParenExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
   case NodeKind::CharacterLiteralExpression:
@@ -180,6 +182,8 @@
 return OS << "IdExpression_qualifier";
   case syntax::NodeRole::NestedNameSpecifier_specifier:
 return OS << "NestedNameSpecifier_specifier";
+  case syntax::NodeRole::ParenExpression_subExpression:
+return OS << "ParenExpression_subExpression";
   }
   llvm_unreachable("invalid role");
 }
@@ -203,6 +207,21 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::ParenExpression::openParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::OpenParen));
+}
+
+syntax::Expression *syntax::ParenExpression::subExpression() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::ParenExpression_subExpression));
+}
+
+syntax::Leaf *syntax::ParenExpression::closeParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::CloseParen));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -647,6 +647,16 @@
 return true;
   }
 
+  bool WalkUpFromParenExpr(ParenExpr *S) {
+Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
+Builder.markExprChild(S->getSubExpr(),
+  syntax::NodeRole::ParenExpression_subExpression);
+Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::ParenExpression, S);
+return true;
+  }
+
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -43,6 +43,7 @@
   PrefixUnaryOperatorExpression,
   PostfixUnaryOperatorExpression,

[PATCH] D82954: Fix crash on overloaded postfix unary operators due to invalid sloc

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked an inline comment as done.
eduucaldas added inline comments.



Comment at: clang/lib/AST/ExprCXX.cpp:82
+  default:
+return getNumArgs() == 1;
+  }

riccibruno wrote:
> This will be true for `operator->`.
Thank you ! I had missed that! I'll propose a more robust solution. I'll 
probably split this patch. But I'll take care to subscribe you to anything 
related


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82954/new/

https://reviews.llvm.org/D82954



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82960: Add parenthesized expression to SyntaxTree

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 274796.
eduucaldas added a comment.

nitpick comment


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82960/new/

https://reviews.llvm.org/D82960

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
@@ -1129,6 +1129,61 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, ParenExpr) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  (1);
+  ((1));
+  (1 + (2));
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-IntegerLiteralExpression
+| | | `-1
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-ParenExpression
+| | | |-(
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | `-)
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-BinaryOperatorExpression
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | |-+
+| | | `-ParenExpression
+| | |   |-(
+| | |   |-IntegerLiteralExpression
+| | |   | `-2
+| | |   `-)
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2040,7 +2095,7 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-ParenExpression
 | | | |-(
 | | | |-BinaryOperatorExpression
 | | | | |-IntegerLiteralExpression
@@ -2050,7 +2105,7 @@
 | | | |   `-2
 | | | `-)
 | | |-*
-| | `-UnknownExpression
+| | `-ParenExpression
 | |   |-(
 | |   |-BinaryOperatorExpression
 | |   | |-IntegerLiteralExpression
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -18,6 +18,8 @@
 return OS << "TranslationUnit";
   case NodeKind::UnknownExpression:
 return OS << "UnknownExpression";
+  case NodeKind::ParenExpression:
+return OS << "ParenExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
   case NodeKind::CharacterLiteralExpression:
@@ -180,6 +182,8 @@
 return OS << "IdExpression_qualifier";
   case syntax::NodeRole::NestedNameSpecifier_specifier:
 return OS << "NestedNameSpecifier_specifier";
+  case syntax::NodeRole::ParenExpression_subExpression:
+return OS << "ParenExpression_subExpression";
   }
   llvm_unreachable("invalid role");
 }
@@ -203,6 +207,21 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::ParenExpression::openParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::OpenParen));
+}
+
+syntax::Expression *syntax::ParenExpression::subExpression() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::ParenExpression_subExpression));
+}
+
+syntax::Leaf *syntax::ParenExpression::closeParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::CloseParen));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -647,6 +647,16 @@
 return true;
   }
 
+  bool WalkUpFromParenExpr(ParenExpr *S) {
+Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
+Builder.markExprChild(S->getSubExpr(),
+  syntax::NodeRole::ParenExpression_subExpression);
+Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::ParenExpression, S);
+return true;
+  }
+
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -43,6 +43,7 @@
   PrefixUnaryOperatorExpression,
   PostfixUnaryOperatorExpression,
   BinaryOperatorExpression,
+  ParenExpression,
   IntegerLiteralExpression,

[PATCH] D82960: Add parenthesized expression to SyntaxTree

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 274795.
eduucaldas added a comment.

Ordering nit


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82960/new/

https://reviews.llvm.org/D82960

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
@@ -1129,6 +1129,61 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, ParenExpr) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  (1);
+  ((1));
+  (1 + (2));
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-IntegerLiteralExpression
+| | | `-1
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-ParenExpression
+| | | |-(
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | `-)
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-BinaryOperatorExpression
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | |-+
+| | | `-ParenExpression
+| | |   |-(
+| | |   |-IntegerLiteralExpression
+| | |   | `-2
+| | |   `-)
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2040,7 +2095,7 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-ParenExpression
 | | | |-(
 | | | |-BinaryOperatorExpression
 | | | | |-IntegerLiteralExpression
@@ -2050,7 +2105,7 @@
 | | | |   `-2
 | | | `-)
 | | |-*
-| | `-UnknownExpression
+| | `-ParenExpression
 | |   |-(
 | |   |-BinaryOperatorExpression
 | |   | |-IntegerLiteralExpression
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -18,6 +18,8 @@
 return OS << "TranslationUnit";
   case NodeKind::UnknownExpression:
 return OS << "UnknownExpression";
+  case NodeKind::ParenExpression:
+return OS << "ParenExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
   case NodeKind::CharacterLiteralExpression:
@@ -180,6 +182,8 @@
 return OS << "IdExpression_qualifier";
   case syntax::NodeRole::NestedNameSpecifier_specifier:
 return OS << "NestedNameSpecifier_specifier";
+  case syntax::NodeRole::ParenExpression_subExpression:
+return OS << "ParenExpression_subExpression";
   }
   llvm_unreachable("invalid role");
 }
@@ -203,6 +207,21 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::ParenExpression::openParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::OpenParen));
+}
+
+syntax::Expression *syntax::ParenExpression::subExpression() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::ParenExpression_subExpression));
+}
+
+syntax::Leaf *syntax::ParenExpression::closeParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::CloseParen));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -647,6 +647,16 @@
 return true;
   }
 
+  bool WalkUpFromParenExpr(ParenExpr *S) {
+Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
+Builder.markExprChild(S->getSubExpr(),
+  syntax::NodeRole::ParenExpression_subExpression);
+Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::ParenExpression, S);
+return true;
+  }
+
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -43,6 +43,7 @@
   PrefixUnaryOperatorExpression,
   PostfixUnaryOperatorExpression,
   BinaryOperatorExpression,
+  ParenExpression,
   IntegerLiteralExpression,

[PATCH] D82960: Add parenthesized expression to SyntaxTree

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82960

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
@@ -1129,6 +1129,61 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, ParenExpr) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  (1);
+  ((1));
+  (1 + (2));
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-IntegerLiteralExpression
+| | | `-1
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-ParenExpression
+| | | |-(
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | `-)
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-ParenExpression
+| | |-(
+| | |-BinaryOperatorExpression
+| | | |-IntegerLiteralExpression
+| | | | `-1
+| | | |-+
+| | | `-ParenExpression
+| | |   |-(
+| | |   |-IntegerLiteralExpression
+| | |   | `-2
+| | |   `-)
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2040,7 +2095,7 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-ParenExpression
 | | | |-(
 | | | |-BinaryOperatorExpression
 | | | | |-IntegerLiteralExpression
@@ -2050,7 +2105,7 @@
 | | | |   `-2
 | | | `-)
 | | |-*
-| | `-UnknownExpression
+| | `-ParenExpression
 | |   |-(
 | |   |-BinaryOperatorExpression
 | |   | |-IntegerLiteralExpression
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -42,6 +42,8 @@
 return OS << "IdExpression";
   case NodeKind::UnknownStatement:
 return OS << "UnknownStatement";
+  case NodeKind::ParenExpression:
+return OS << "ParenExpression";
   case NodeKind::DeclarationStatement:
 return OS << "DeclarationStatement";
   case NodeKind::EmptyStatement:
@@ -180,6 +182,8 @@
 return OS << "IdExpression_qualifier";
   case syntax::NodeRole::NestedNameSpecifier_specifier:
 return OS << "NestedNameSpecifier_specifier";
+  case syntax::NodeRole::ParenExpression_subExpression:
+return OS << "ParenExpression_subExpression";
   }
   llvm_unreachable("invalid role");
 }
@@ -203,6 +207,21 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::ParenExpression::openParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::OpenParen));
+}
+
+syntax::Expression *syntax::ParenExpression::subExpression() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::ParenExpression_subExpression));
+}
+
+syntax::Leaf *syntax::ParenExpression::closeParen() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::CloseParen));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -647,6 +647,16 @@
 return true;
   }
 
+  bool WalkUpFromParenExpr(ParenExpr *S) {
+Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
+Builder.markExprChild(S->getSubExpr(),
+  syntax::NodeRole::ParenExpression_subExpression);
+Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::ParenExpression, S);
+return true;
+  }
+
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -40,6 +40,7 @@
 
   // Expressions.
   UnknownExpression,
+  ParenExpression,
   PrefixUnaryOperatorExpression,
   PostfixUnaryOperatorExpression,
   BinaryOperatorExpression,
@@ -161,7 +162,8 @@
   ParametersAndQualifiers_trailingReturn,

[PATCH] D82954: Fix crash on overloaded postfix unary operators due to invalid sloc

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added a reviewer: gribozavr2.
eduucaldas marked an inline comment as done.
eduucaldas added a comment.

Code that reproduces the crash 
Notice that when using a postfix unary operator ++ one argument is introduced 
to differ it from its prefix counterpart, but that argument is not used. This 
phantom argument shows up in the ClangAST in the form of an `IntegerLiteral` 
with `invalid sloc`. This invalid sloc in a valid AST node was causing the 
SyntaxTree generation to crash.
We can address this problems at two different levels:

1. At the `TraverseCXXOperatorCallExpr`, by overriding it and replacing the 
children iteration to not iterate over this phantom argument.
2. At the `WalkUpFromIntegerLiteral`, by skipping the visitation of the phantom 
node.

We preferred the latter.

1. Cons: We would have to duplicate the implementation of RecursiveASTVisitor 
in BuildTree, to handle this subtle change in traversal. That would add code 
complexity.
2. Cons: We are handling a problem of `CXXOperatorCallExpr` in `IntegerLiteral`.

We chose the latter as, anyways, if an AST node has an invalid sloc, it was 
either a problem with parsing or the node is supposed to be ignored




Comment at: clang/include/clang/AST/ExprCXX.h:143-148
+  bool isPostfixUnaryOp() const;
+
+  bool isPrefixUnaryOp() const;
+
+  bool isUnaryOp() const;
+

Should new additions to CXXOperatorCallExpr go on a different patch?
I'll also add unit tests for those. I'm waiting for review on 
https://reviews.llvm.org/D82937, to do that.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82954/new/

https://reviews.llvm.org/D82954



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82954: Fix crash on overloaded postfix unary operators due to invalid sloc

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82954

Files:
  clang/include/clang/AST/ExprCXX.h
  clang/lib/AST/ExprCXX.cpp
  clang/lib/Tooling/Syntax/BuildTree.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
@@ -2268,6 +2268,64 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  X operator++(int);
+};
+void test(X x) {
+  x++;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-SimpleDeclaration
+| | |-X
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-++
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   |-SimpleDeclaration
+| | |   | `-int
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-PostfixUnaryOperatorExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-IdExpression
+| |   `-UnqualifiedId
+| | `-++
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -648,6 +648,8 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
+if (S->getLocation().isInvalid())
+  return true;
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
@@ -733,8 +735,23 @@
   Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::BinaryOperatorExpression, S);
   return true;
-}
-return RecursiveASTVisitor::WalkUpFromCXXOperatorCallExpr(S);
+} else if (S->isUnaryOp()) {
+  Builder.markChildToken(
+  S->getOperatorLoc(),
+  syntax::NodeRole::OperatorExpression_operatorToken);
+  Builder.markExprChild(S->getArg(0),
+syntax::NodeRole::UnaryOperatorExpression_operand);
+  if (S->isPostfixUnaryOp())
+Builder.foldNode(
+Builder.getExprRange(S),
+new (allocator()) syntax::PostfixUnaryOperatorExpression, S);
+  else
+Builder.foldNode(
+Builder.getExprRange(S),
+new (allocator()) syntax::PrefixUnaryOperatorExpression, S);
+  return true;
+} else
+  return RecursiveASTVisitor::WalkUpFromCXXOperatorCallExpr(S);
   }
 
   bool WalkUpFromNamespaceDecl(NamespaceDecl *S) {
Index: clang/lib/AST/ExprCXX.cpp
===
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -48,7 +48,6 @@
 bool CXXOperatorCallExpr::isInfixBinaryOp() const {
   if (getNumArgs() != 2)
 return false;
-
   switch (getOperator()) {
   // operator() may have two arguments, but it's not a binary operator
   case OO_Call:
@@ -64,6 +63,30 @@
   }
 }
 
+bool CXXOperatorCallExpr::isPostfixUnaryOp() const {
+  switch (getOperator()) {
+  case OO_PlusPlus:
+  case OO_MinusMinus:
+return getNumArgs() == 2;
+  default:
+return false;
+  }
+}
+
+bool CXXOperatorCallExpr::isPrefixUnaryOp() const {
+  switch (getOperator()) {
+  case OO_Call:
+  case OO_Subscript:
+return false;
+  default:
+return getNumArgs() == 1;
+  }
+}
+
+bool CXXOperatorCallExpr::isUnaryOp() const {
+  return isPrefixUnaryOp() || isPostfixUnaryOp();
+}
+
 CXXRewrittenBinaryOperator::DecomposedForm
 CXXRewrittenBinaryOperator::getDecomposedForm() const {
   DecomposedForm Result = {};
Index: clang/include/clang/AST/ExprCXX.h
===
--- clang/include/clang/AST/ExprCXX.h
+++ clang/include/clang/AST/ExprCXX.h
@@ -121,6 +121,7 @@
Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual ||
Opc == OO_CaretEqual || Opc == OO_PipeEqual;
   }
+
   bool isAssignmentOp() const { return isAssignmentOp(getOperator()); }
 
   static bool isComparisonOp(OverloadedOperatorKind Opc) {
@@ -139,7 +140,12 @@
   }
   bool isComparisonOp() const { return isComparisonOp(getOperator()); }
 
-  /// Is this written as an infix binary operator?
+  bool isPostfixUnaryOp() const;
+
+  bool isPrefixUnaryOp() const;
+
+  bool

[PATCH] D82937: Fix `isInfixBinaryOp` that returned true for postfix ++

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 274769.
eduucaldas added a comment.

better comment


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82937/new/

https://reviews.llvm.org/D82937

Files:
  clang/lib/AST/ExprCXX.cpp
  clang/unittests/Tooling/CMakeLists.txt
  clang/unittests/Tooling/CXXOperatorCallExprTest.cpp

Index: clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
===
--- /dev/null
+++ clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
@@ -0,0 +1,77 @@
+//===- unittests/Tooling/CXXOperatorCallExprTest.cpp --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+//
+// Unit tests for the predicates in CXXOperatorCallExpr.
+//
+//===--===//
+
+#include "TestVisitor.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace {
+
+TEST(CXXOperatorPredicatesTest, InfixBinaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+friend X operator+(X, X);
+  };
+  void test(X x){
+x + x;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_TRUE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, CallLikeOp) {
+  const std::string Code = R"cpp(
+  struct X{
+int operator[](int idx);
+  };
+  void test(X x){
+x[1];
+  }
+  )cpp";
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, PostfixUnaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+X operator++(int);
+  };
+  void test(X x){
+x++;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+} // namespace
+} // namespace clang
Index: clang/unittests/Tooling/CMakeLists.txt
===
--- clang/unittests/Tooling/CMakeLists.txt
+++ clang/unittests/Tooling/CMakeLists.txt
@@ -18,6 +18,7 @@
   CastExprTest.cpp
   CommentHandlerTest.cpp
   CompilationDatabaseTest.cpp
+  CXXOperatorCallExprTest.cpp
   DependencyScannerTest.cpp
   DiagnosticsYamlTest.cpp
   ExecutionTest.cpp
Index: clang/lib/AST/ExprCXX.cpp
===
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -46,15 +46,18 @@
 //===--===//
 
 bool CXXOperatorCallExpr::isInfixBinaryOp() const {
-  // An infix binary operator is any operator with two arguments other than
-  // operator() and operator[]. Note that none of these operators can have
-  // default arguments, so it suffices to check the number of argument
-  // expressions.
   if (getNumArgs() != 2)
 return false;
 
   switch (getOperator()) {
-  case OO_Call: case OO_Subscript:
+  // operator() may have two arguments, but it's not a binary operator
+  case OO_Call:
+  // operator[] takes two arguments but it's not infix
+  case OO_Subscript:
+  // Postfix unary operators (++ and --) take 2 arguments to differ from their
+  // prefix counterparts
+  case OO_PlusPlus:
+  case OO_MinusMinus:
 return false;
   default:
 return true;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82937: Fix `isInfixBinaryOp` that returned true for postfix ++

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added a reviewer: gribozavr2.
eduucaldas marked 2 inline comments as done.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/CXXOperatorCallExprTest.cpp:1
+//===- unittests/Tooling/CXXOperatorCallExprTest.cpp 
--===//
+//

This file is in the `unittests/Tooling` instead in the `unittests/AST` 
directory because I wanted to have access to the `TestVisitor` infrastructure. 
I know the solution is not optimal and I am looking for suggestions



Comment at: clang/unittests/Tooling/CXXOperatorCallExprTest.cpp:29
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {

Previous code do something else. Look at `CallsVisitor` in 
`clang/unittests/Tooling/SourceCodeTest.cpp` . I prefer this approach because 
* The whole logic is then inside the the test case
* There is not a big addition to lines of code


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82937/new/

https://reviews.llvm.org/D82937



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82937: Fix `isInfixBinaryOp` that returned true for postfix ++

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 274720.
eduucaldas added a comment.

nits


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82937/new/

https://reviews.llvm.org/D82937

Files:
  clang/lib/AST/ExprCXX.cpp
  clang/unittests/Tooling/CMakeLists.txt
  clang/unittests/Tooling/CXXOperatorCallExprTest.cpp

Index: clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
===
--- /dev/null
+++ clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
@@ -0,0 +1,77 @@
+//===- unittests/Tooling/CXXOperatorCallExprTest.cpp --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+//
+// Unit tests for the predicates in CXXOperatorCallExpr.
+//
+//===--===//
+
+#include "TestVisitor.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace {
+
+TEST(CXXOperatorPredicatesTest, InfixBinaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+friend X operator+(X, X);
+  };
+  void test(X x){
+x + x;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_TRUE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, CallLikeOp) {
+  const std::string Code = R"cpp(
+  struct X{
+int operator[](int idx);
+  };
+  void test(X x){
+x[1];
+  }
+  )cpp";
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, PostfixUnaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+X operator++(int);
+  };
+  void test(X x){
+x++;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+} // namespace
+} // namespace clang
Index: clang/unittests/Tooling/CMakeLists.txt
===
--- clang/unittests/Tooling/CMakeLists.txt
+++ clang/unittests/Tooling/CMakeLists.txt
@@ -18,6 +18,7 @@
   CastExprTest.cpp
   CommentHandlerTest.cpp
   CompilationDatabaseTest.cpp
+  CXXOperatorCallExprTest.cpp
   DependencyScannerTest.cpp
   DiagnosticsYamlTest.cpp
   ExecutionTest.cpp
Index: clang/lib/AST/ExprCXX.cpp
===
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -47,14 +47,17 @@
 
 bool CXXOperatorCallExpr::isInfixBinaryOp() const {
   // An infix binary operator is any operator with two arguments other than
-  // operator() and operator[]. Note that none of these operators can have
-  // default arguments, so it suffices to check the number of argument
-  // expressions.
+  // operator()/operator[], and operator++/operator--. Note that none of these
+  // operators can have default arguments, so it suffices to check the number of
+  // argument expressions.
   if (getNumArgs() != 2)
 return false;
 
   switch (getOperator()) {
-  case OO_Call: case OO_Subscript:
+  case OO_Call:
+  case OO_Subscript:
+  case OO_PlusPlus:
+  case OO_MinusMinus:
 return false;
   default:
 return true;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82937: Fix `isInfixBinaryOp` that returned true for postfix ++

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added subscribers: cfe-commits, mgorny.
Herald added a project: clang.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82937

Files:
  clang/lib/AST/ExprCXX.cpp
  clang/unittests/Tooling/CMakeLists.txt
  clang/unittests/Tooling/CXXOperatorCallExprTest.cpp

Index: clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
===
--- /dev/null
+++ clang/unittests/Tooling/CXXOperatorCallExprTest.cpp
@@ -0,0 +1,78 @@
+
+//===- unittests/Tooling/CXXOperatorCallExprTest.cpp --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+//
+// Unit tests for the predicates in CXXOperatorCallExpr.
+//
+//===--===//
+
+#include "TestVisitor.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace {
+
+TEST(CXXOperatorPredicatesTest, InfixBinaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+friend X operator+(X, X);
+  };
+  void test(X x){
+x + x;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_TRUE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, CallLikeOp) {
+  const std::string Code = R"cpp(
+  struct X{
+int operator[](int idx);
+  };
+  void test(X x){
+x[1];
+  }
+  )cpp";
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+
+TEST(CXXOperatorPredicatesTest, PostfixUnaryOp) {
+  const std::string Code = R"cpp(
+  struct X{
+X operator++(int);
+  };
+  void test(X x){
+x++;
+  }
+  )cpp";
+
+  struct Visitor : TestVisitor {
+bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  EXPECT_FALSE(E->isInfixBinaryOp());
+  return true;
+}
+  } visitor;
+
+  visitor.runOver(Code);
+}
+} // namespace
+} // namespace clang
Index: clang/unittests/Tooling/CMakeLists.txt
===
--- clang/unittests/Tooling/CMakeLists.txt
+++ clang/unittests/Tooling/CMakeLists.txt
@@ -61,6 +61,7 @@
   RewriterTest.cpp
   SourceCodeBuildersTest.cpp
   SourceCodeTest.cpp
+  CXXOperatorCallExprTest.cpp
   StencilTest.cpp
   ToolingTest.cpp
   TransformerTest.cpp
Index: clang/lib/AST/ExprCXX.cpp
===
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -47,14 +47,17 @@
 
 bool CXXOperatorCallExpr::isInfixBinaryOp() const {
   // An infix binary operator is any operator with two arguments other than
-  // operator() and operator[]. Note that none of these operators can have
-  // default arguments, so it suffices to check the number of argument
-  // expressions.
+  // operator()/operator[], and operator++/operator--. Note that none of these
+  // operators can have default arguments, so it suffices to check the number of
+  // argument expressions.
   if (getNumArgs() != 2)
 return false;
 
   switch (getOperator()) {
-  case OO_Call: case OO_Subscript:
+  case OO_Call:
+  case OO_Subscript:
+  case OO_PlusPlus:
+  case OO_MinusMinus:
 return false;
   default:
 return true;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82875: Added tests for RecursiveASTVisitor for AST nodes that are special cased

2020-07-01 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas accepted this revision.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:501
   WalkUpFromStmt IntegerLiteral(1)
-WalkUpFromBinaryOperator BinaryOperator(+)
-  WalkUpFromExpr BinaryOperator(+)
-WalkUpFromStmt BinaryOperator(+)
+WalkUpFromUnaryOperator UnaryOperator(-)
+  WalkUpFromExpr UnaryOperator(-)

A question came to mind: " Does WalkUpFromUnaryMinus walk up to 
WalkUpFromUnaryOperator? " Perhaps that could be included in a test.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82875/new/

https://reviews.llvm.org/D82875



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82787: Make RecursiveASTVisitor call WalkUpFrom for unary and binary operators in post-order traversal mode

2020-06-30 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added inline comments.



Comment at: clang/include/clang/AST/RecursiveASTVisitor.h:649
+  case BO_##NAME:  
\
+if (isSameMethod(::TraverseBin##NAME,  
\
+ ::TraverseBin##NAME)) {   
\

There's only one place that call PostVisitStmt. Could we pull this conditional 
there? It is repeated in every macro. It would make this function much simpler, 
and make clear at call site what is being done


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82787/new/

https://reviews.llvm.org/D82787



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82485: Add tests for sequences of callbacks that RecursiveASTVisitor produces

2020-06-29 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas accepted this revision.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:117
+  recordDefaultImplementation(
+  __func__, [&, this]() { RecordingVisitorBase::WalkUpFromStmt(S); });
+  return true;

gribozavr2 wrote:
> eduucaldas wrote:
> > Do we need this `this`?
> Yes, we're calling a method on `this` from the base class. 
> `RecordingVisitorBase::WalkUpFromStmt(S);` is implicitly calling a member 
> function, `this-> RecordingVisitorBase::WalkUpFromStmt(S);`.
True! The `&` default captures `this` already, but a better suggestion would be 
to use the capture: `[S, this]` or perhaps to just use `S` as an argument of 
the lambda. 
That is a nitpick though, feel free to push the patch :)


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82485/new/

https://reviews.llvm.org/D82485



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82485: Add tests for sequences of callbacks that RecursiveASTVisitor produces

2020-06-26 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added a comment.

A more general feedback.
From our conversation one of the issues was that the tests wre only surfacing 
overriden methods. For instance, whenever we recorded a WalkUpFromExpr, and 
thus the callback showed up in the test, we actually did **not** walk up.
Now, in all the test cases we are calling the default implementation. We are 
not surfacing that WalkUpFrom **can** not walk up.




Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:76
+  template 
+  void recordDefaultImplementation(StringRef CallbackName,
+   CallDefault CallDefaultFn) {

We don't use CallbackName.



Comment at: 
clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:107-110
+  recordCallback(__func__, IL);
+  recordDefaultImplementation(__func__, [&, this]() {
+RecordingVisitorBase::TraverseIntegerLiteral(IL);
+  });

I think you meant to unify `recordCallback` and `recodDefaultImplentation` into 
one, and that's why you had added this `__func__` to 
`recordDefaultImplementation`.



Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:117
+  recordDefaultImplementation(
+  __func__, [&, this]() { RecordingVisitorBase::WalkUpFromStmt(S); });
+  return true;

Do we need this `this`?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82485/new/

https://reviews.llvm.org/D82485



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82312: Add `CharLiteral` to SyntaxTree

2020-06-26 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added a comment.

In D82312#2116028 , @vvereschaka wrote:

> Hello Eduardo,
>
> sorry, but one of your these commits break the clang unit tests on the 
> following builders:
>
> - http://lab.llvm.org:8011/builders/llvm-clang-x86_64-win-fast/builds/18313
> - http://lab.llvm.org:8011/builders/llvm-clang-win-x-aarch64/builds/256
> - http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l/builds/96
>
>   with the following errors: ``` FAILED: 
> tools/clang/unittests/Tooling/Syntax/CMakeFiles/SyntaxTests.dir/TreeTest.cpp.obj
>  
> C:\PROGRA~2\MICROS~1\2017\COMMUN~1\VC\Tools\MSVC\1416~1.270\bin\Hostx64\x64\cl.exe
>   /nologo /TP -DGTEST_HAS_RTTI=0 -DGTEST_HAS_TR1_TUPLE=0 -DGTEST_LANG_CXX11=1 
> -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS 
> -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_GNU_SOURCE 
> -D_HAS_EXCEPTIONS=0 -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS 
> -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS 
> -D__STDC_LIMIT_MACROS -Itools\clang\unittests\Tooling\Syntax 
> -IC:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax
>  
> -IC:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\include
>  -Itools\clang\include -Iinclude 
> -IC:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\llvm\include
>  
> -IC:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\llvm\utils\unittest\googletest\include
>  
> -IC:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\llvm\utils\unittest\googlemock\include
>  /DWIN32 /D_WINDOWS   /Zc:inline /Zc:strictStrings /Oi /Zc:rvalueCast /W4 
>  -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 
> -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 
> -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 
> -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 
> -wd4709 -wd4324 -w14062 -we4238 /Gw /MD /O2 
>  /Ob2 /DNDEBUG/EHs-c- /GR- 
> -std:c++14 /showIncludes 
> /Fotools\clang\unittests\Tooling\Syntax\CMakeFiles\SyntaxTests.dir\TreeTest.cpp.obj
>  /Fdtools\clang\unittests\Tooling\Syntax\CMakeFiles\SyntaxTests.dir\ /FS -c 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp
>  
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1665):
>  error C2017: illegal escape sequence 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1665):
>  error C2146: syntax error: missing ')' before identifier 'n' 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1639):
>  error C2660: 'testing::internal::GetBoolAssertionFailureMessage': function 
> does not take 2 arguments 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\llvm\utils\unittest\googletest\include\gtest/internal/gtest-internal.h(226):
>  note: see declaration of 'testing::internal::GetBoolAssertionFailureMessage' 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1639):
>  error C2440: '': cannot convert from 'initializer list' 
> to 'testing::internal::AssertHelper' 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1665):
>  note: No constructor could take the source type, or constructor overload 
> resolution was ambiguous 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1665):
>  error C2146: syntax error: missing ';' before identifier 'n' 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1665):
>  error C2059: syntax error: ')' 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1639):
>  error C2065: 'n': undeclared identifier 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1665):
>  error C2146: syntax error: missing ';' before identifier 'SyntaxTree' 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1639):
>  error C2065: 'SyntaxTree': undeclared identifier 
> C:\buildbot\as-builder-3\llvm-clang-x86_64-win-fast\llvm-project\clang\unittests\Tooling\Syntax\TreeTest.cpp(1639):
>  error C2143: syntax error: missing ';' before 'string' ``` see more details 
> here: 
> http://lab.llvm.org:8011/builders/llvm-clang-x86_64-win-fast/builds/18313/steps/test-check-clang-unit/logs/stdio
>
>   I mean the following commits: *221d7bbe49cceb0e408f0f46d9f8371e6c9fee2c 
>

[PATCH] D82360: Add StringLiteral to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

This revision was automatically updated to reflect the committed changes.
Closed by commit rG466e8b7ea6e1: Add StringLiteral to SyntaxTree (authored by 
eduucaldas).

Changed prior to commit:
  https://reviews.llvm.org/D82360?vs=273346=273438#toc

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82360/new/

https://reviews.llvm.org/D82360

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
@@ -1399,6 +1399,109 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, StringLiteral) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  "a\n\0\x20";
+  L"αβ";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-"a\n\0\x20"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-L"αβ"
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, StringLiteralUtf) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u8"a\x1f\x05";
+  u"C++抽象構文木";
+  U"\n";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-u8"a\x1f\x05"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-u"C++抽象構文木"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-U"\n"
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, StringLiteralRaw) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  R"SyntaxTree(
+  Hello "Syntax" \"
+  )SyntaxTree";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-R"SyntaxTree(
+  Hello "Syntax" \"
+  )SyntaxTree"
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2730,7 +2833,7 @@
 | |-BoolLiteralExpression
 | | `-true
 | |-,
-| |-UnknownExpression
+| |-StringLiteralExpression
 | | `-"message"
 | |-)
 | `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -26,6 +26,8 @@
 return OS << "BoolLiteralExpression";
   case NodeKind::CharacterLiteralExpression:
 return OS << "CharacterLiteralExpression";
+  case NodeKind::StringLiteralExpression:
+return OS << "StringLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -214,6 +216,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::StringLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -667,6 +667,12 @@
  new (allocator()) syntax::CharacterLiteralExpression, S);
 return true;
   }
+  bool WalkUpFromStringLiteral(StringLiteral *S) {
+Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::StringLiteralExpression, S);
+return true;
+  }
 
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -47,6 +47,7 @@
   IntegerLiteralExpression,
   BoolLiteralExpression,
   CharacterLiteralExpression,
+  StringLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -287,6 +288,16 @@
   syntax::Leaf *literalToken();
 };

[PATCH] D82318: Add `FloatingLiteral` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

This revision was automatically updated to reflect the committed changes.
Closed by commit rG7b404b6d0031: Add `FloatingLiteral` to SyntaxTree (authored 
by eduucaldas).

Changed prior to commit:
  https://reviews.llvm.org/D82318?vs=273347=273437#toc

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82318/new/

https://reviews.llvm.org/D82318

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
@@ -53,6 +53,8 @@
 
   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 @@
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 @@
 )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 @@
   `-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 @@
 )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 @@
   `-CompoundStatement
 |-{
 |-ExpressionStatement
-

[PATCH] D82312: Add `CharLiteral` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

This revision was automatically updated to reflect the committed changes.
Closed by commit rG221d7bbe49cc: Add `CharLiteral` to SyntaxTree (authored by 
eduucaldas).

Changed prior to commit:
  https://reviews.llvm.org/D82312?vs=273343=273436#toc

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82312/new/

https://reviews.llvm.org/D82312

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
@@ -73,6 +73,10 @@
 return Language == Lang_C89 || Language == Lang_C99;
   }
 
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1232,6 +1236,135 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, CharacterLiteral) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  'a';
+  '\n';
+  '\x20';
+  '\0';
+  L'a';
+  L'α';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'\n'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'\x20'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'\0'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-L'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-L'α'
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, CharacterLiteralUtf) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u'a';
+  u'構';
+  U'a';
+  U'';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u'構'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-U'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-U''
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, CharacterLiteralUtf8) {
+  if (!GetParam().isCXX17OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u8'a';
+  u8'\x7f';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u8'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u8'\x7f'
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, BoolLiteral) {
   if (GetParam().hasBoolType()) {
 return;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -24,6 +24,8 @@
 return OS << "IntegerLiteralExpression";
   case NodeKind::BoolLiteralExpression:
 return OS << "BoolLiteralExpression";
+  case NodeKind::CharacterLiteralExpression:
+return OS << "CharacterLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -207,6 +209,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::CharacterLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -661,6 +661,13 @@
 return true;
   }
 
+  bool WalkUpFromCharacterLiteral(CharacterLiteral *S) {
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::CharacterLiteralExpression,

[PATCH] D82310: Add `BoolLiteralExpression` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

This revision was automatically updated to reflect the committed changes.
Closed by commit rG7f7f8564808b: Add `BoolLiteralExpression` to SyntaxTree 
(authored by eduucaldas).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82310/new/

https://reviews.llvm.org/D82310

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool hasBoolType() const {
+return Language == Lang_C89 || Language == Lang_C99;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,40 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, BoolLiteral) {
+  if (GetParam().hasBoolType()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  true;
+  false;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-BoolLiteralExpression
+| | `-true
+| `-;
+|-ExpressionStatement
+| |-BoolLiteralExpression
+| | `-false
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -1691,18 +1729,18 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-BoolLiteralExpression
 | | | `-true
 | | |-||
-| | `-UnknownExpression
+| | `-BoolLiteralExpression
 | |   `-false
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-BoolLiteralExpression
 | | | `-true
 | | |-or
-| | `-UnknownExpression
+| | `-BoolLiteralExpression
 | |   `-false
 | `-;
 |-ExpressionStatement
@@ -2556,7 +2594,7 @@
 |-StaticAssertDeclaration
 | |-static_assert
 | |-(
-| |-UnknownExpression
+| |-BoolLiteralExpression
 | | `-true
 | |-,
 | |-UnknownExpression
@@ -2566,7 +2604,7 @@
 `-StaticAssertDeclaration
   |-static_assert
   |-(
-  |-UnknownExpression
+  |-BoolLiteralExpression
   | `-true
   |-)
   `-;
@@ -3186,7 +3224,7 @@
   |   |-)
   |   |-noexcept
   |   |-(
-  |   |-UnknownExpression
+  |   |-BoolLiteralExpression
   |   | `-true
   |   `-)
   `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::BoolLiteralExpression:
+return OS << "BoolLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::BoolLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 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),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  BoolLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -264,6 +265,16 @@
   syntax::Leaf *literalToken();
 };
 
+/// Expression for boolean literals. C++ [lex.bool]
+class BoolLiteralExpression final : public Expression {
+public:
+  BoolLiteralExpression() :

[PATCH] D82318: Add `FloatingLiteral` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 273347.
eduucaldas marked an inline comment as done.
eduucaldas added a comment.

Fix indenting


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82318/new/

https://reviews.llvm.org/D82318

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,91 @@
 )txt"));
 }
 
+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() {
+  0xfp1;
+  0xf.p1;
+  0x.fp1;
+  0xf.fp1f;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xfp1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xf.p1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0x.fp1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xf.fp1f
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::FloatingLiteralExpression:
+return OS << "FloatingLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -195,6 +197,11 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::FloatingLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromFloatingLiteral(FloatingLiteral *S) {
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::FloatingLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  FloatingLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -254,6 +255,17 @@
   syntax::Leaf *nullPtrKeyword();
 };
 
+/// Expression for floating-point literals. C++ [lex.fcon]
+class FloatingLiteralExpression final : public Expression {
+public:
+  FloatingLiteralExpression()
+  : Expression(NodeKind::FloatingLiteralExpression) {}
+  static bool classof(const

[PATCH] D82360: Add StringLiteral to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 273346.
eduucaldas added a comment.

Add unicode tests


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82360/new/

https://reviews.llvm.org/D82360

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
@@ -1228,6 +1228,109 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, StringLiteral) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  "a\n\0\x20";
+  L"αβ";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-"a\n\0\x20"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-L"αβ"
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, StringLiteralUtf) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u8"a\x1f\x05";
+  u"C++抽象構文木";
+  U"\n";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-u8"a\x1f\x05"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-u"C++抽象構文木"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-U"\n"
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, StringLiteralRaw) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  R"SyntaxTree(
+  Hello "Syntax" \"
+  )SyntaxTree";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-R"SyntaxTree(
+  Hello "Syntax" \"
+  )SyntaxTree"
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2559,7 +2662,7 @@
 | |-UnknownExpression
 | | `-true
 | |-,
-| |-UnknownExpression
+| |-StringLiteralExpression
 | | `-"message"
 | |-)
 | `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::StringLiteralExpression:
+return OS << "StringLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::StringLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromStringLiteral(StringLiteral *S) {
+Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::StringLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  StringLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -264,6 +265,16 @@
   syntax::Leaf *literalToken();
 };
 
+/// Expression for string-literals. C++ [lex.string]
+class StringLiteralExpression final : public Expression {
+public:
+  StringLiteralExpression() :

[PATCH] D82312: Add `CharLiteral` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 273343.
eduucaldas marked 3 inline comments as done.
eduucaldas added a comment.

Add tests for unicode characters


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82312/new/

https://reviews.llvm.org/D82312

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,135 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, CharacterLiteral) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  'a';
+  '\n';
+  '\x20';
+  '\0';
+  L'a';
+  L'α';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'\n'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'\x20'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'\0'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-L'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-L'α'
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, CharacterLiteralUtf) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u'a';
+  u'構';
+  U'a';
+  U'';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u'構'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-U'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-U''
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, CharacterLiteralUtf8) {
+  if (!GetParam().isCXX17OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u8'a';
+  u8'\x7f';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u8'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u8'\x7f'
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::CharacterLiteralExpression:
+return OS << "CharacterLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::CharacterLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromCharacterLiteral(CharacterLiteral *S) {
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::CharacterLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {

[PATCH] D82310: Add `BoolLiteralExpression` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:1240
+  true;
+  false;
+}

gribozavr2 wrote:
> eduucaldas wrote:
> > gribozavr2 wrote:
> > > C99 has bool literals, but the program should include stdbool.h.
> > > 
> > > I feel like it is better to make the predicate something like 
> > > "hasBoolType()" and change the test to include stdbool.h.
> > [[ https://clang.llvm.org/doxygen/stdbool_8h_source.html | stdbool ]] 
> > consists on macro definitions, mapping booleans to integers. `true` is 
> > preprocessed into 1 and `false` to 0 .
> > I don't  think there is a reasonable way of getting the proper SyntaxTree 
> > from that macro expansion
> > 
> > Additional problem, we don't have the test infrastructure for includes, 
> > AFAIK ^^
> > 
> > Finally, regarding the predicates, I prefer if they relate to languages, 
> > otherwise we might create many predicates that test for exactly the same 
> > thing, e.g. we would have `hasBoolType()` and `hasNullPtr()` that 
> > ultimately do the same thing, test if Language is not C 
> > true is preprocessed into 1 and false to 0 .
> 
> I see -- yes, that would make a completely different syntax tree.
> 
> > Finally, regarding the predicates, I prefer if they relate to languages, 
> > otherwise we might create many predicates that test for exactly the same 
> > thing
> 
> Generally, testing for features instead of product versions is considered 
> better, as that leads to more future-proof code (for example, we learned this 
> lesson again in the area of web extensions and standards). In future, Clang 
> can start supporting a language feature in other language modes as an 
> extension (for example, supporting `_Atomic` in C++ is already a thing), or 
> the language standard itself can decide to incorporate the feature (for 
> example, C 2035 could adopt the `nullptr` keyword). It is highly unlikely for 
> complex features like templates, but may reasonably happen for simpler 
> features.
> Generally, testing for features instead of product versions is considered 
> better, as that leads to more future-proof code 

I totally agree with all you said. My worry was more regarding the fact that 
the implementation of `hasBoolType` would merely check for the language 
anyways. So if, following what you said, `true` and `false` really became a 
feature of C35 then the code would still be broken. 

But then I guess it would be easier to fix `hasBoolType` than finding all the 
places where we used just `isC` because booleans are not in C. 

Specially if all these predicates were put in `clang/Testing/CommandLineArgs.h` 
or something similar where more people would be seeing it. 

Which brings the question shouldn't we move these predicates up?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82310/new/

https://reviews.llvm.org/D82310



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82310: Add `BoolLiteralExpression` to SyntaxTree

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 273310.
eduucaldas marked 2 inline comments as done.
eduucaldas added a comment.

isC -> hasBoolType


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82310/new/

https://reviews.llvm.org/D82310

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool hasBoolType() const {
+return Language == Lang_C89 || Language == Lang_C99;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,40 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, BoolLiteral) {
+  if (GetParam().hasBoolType()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  true;
+  false;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-BoolLiteralExpression
+| | `-true
+| `-;
+|-ExpressionStatement
+| |-BoolLiteralExpression
+| | `-false
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -1691,18 +1729,18 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-BoolLiteralExpression
 | | | `-true
 | | |-||
-| | `-UnknownExpression
+| | `-BoolLiteralExpression
 | |   `-false
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-BoolLiteralExpression
 | | | `-true
 | | |-or
-| | `-UnknownExpression
+| | `-BoolLiteralExpression
 | |   `-false
 | `-;
 |-ExpressionStatement
@@ -2556,7 +2594,7 @@
 |-StaticAssertDeclaration
 | |-static_assert
 | |-(
-| |-UnknownExpression
+| |-BoolLiteralExpression
 | | `-true
 | |-,
 | |-UnknownExpression
@@ -2566,7 +2604,7 @@
 `-StaticAssertDeclaration
   |-static_assert
   |-(
-  |-UnknownExpression
+  |-BoolLiteralExpression
   | `-true
   |-)
   `-;
@@ -3186,7 +3224,7 @@
   |   |-)
   |   |-noexcept
   |   |-(
-  |   |-UnknownExpression
+  |   |-BoolLiteralExpression
   |   | `-true
   |   `-)
   `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::BoolLiteralExpression:
+return OS << "BoolLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::BoolLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 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),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  BoolLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -264,6 +265,16 @@
   syntax::Leaf *literalToken();
 };
 
+/// Expression for boolean literals. C++ [lex.bool]
+class BoolLiteralExpression final : public Expression {
+public:
+  BoolLiteralExpression() : Expression(NodeKind::BoolLiteralExpression)

[PATCH] D82485: Add tests for sequences of callbacks that RecursiveASTVisitor produces

2020-06-25 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked 2 inline comments as done.
eduucaldas added inline comments.

Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:1
+//===--- clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp 
---===//
+//

I find this name too general. 
We are testing here the behavior of TraverseStmt specifically, perhaps 
`TraverseStmt.cpp` would be a more appropriate name

Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:17
+class RecordingVisitorBase : public TestVisitor {
+  bool VisitPostOrder;
+

ymandel wrote:
> Consider using an enum rather than a bool.
Agreed.
This would avoid all the /*VisitPostOrder=*/false

Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:81
+
+bool TraverseIntegerLiteral(IntegerLiteral *E) {
+  recordCallback(__func__, E);

E for Expr? Ok, Expr is base class of IntegerLiteral.
I propose to use either: 
S for Stmt, it  is a more homogeneus name and **also** a base class of 
IntegerLiteral
Or 
IL for IntegerLiteral, and then we stick with this convention

Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:124
+TraverseIntegerLiteral IntegerLiteral(3)
+WalkUpFromStmt IntegerLiteral(3)
+WalkUpFromStmt BinaryOperator(+)

Good! Here the post order is still calling WalkUpFrom even though our Traverse 
doesn't call it in IntegerLiteral!

Comment at: 
clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:148-161
+bool WalkUpFromStmt(Stmt *S) {
+  recordCallback(__func__, S);
+  return true;
+}
+
+bool WalkUpFromExpr(Expr *E) {
+  recordCallback(__func__, E);

> E for Expr? Ok, Expr is base class of IntegerLiteral.
> I propose to use either:
> S for Stmt, it is a more homogeneus name and also a base class of 
> IntegerLiteral
> Or
> IL for IntegerLiteral, and then we stick with this convention

Here it gets even more confusing.

Comment at: clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:153
+
+bool WalkUpFromExpr(Expr *E) {
+  recordCallback(__func__, E);

I think overriding WalkUpFromDerived when you already have WalkUpFromStmt 
doesn't bring much value.
In the case of fully derived AST nodes we just get the repeated information 
about the type of this node, e.g. 
WalkUpFromIntegerLiteral IntegerLiteral(x) 
instead of
WalkUpFromStmt IntegerLiteral(x)

In the case of intermediate AST nodes, as WalkUpFromExpr, we get some 
information but do we need that?
Here for instance, the information we get is: 
WalkUpFromExpr Node => Node is an Expr
WalkUpFromStmt Node => Node is a Stmt
I don't think this information is very valuable

Comment at: 
clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp:300-309
+WalkUpFromStmt CompoundStmt
+WalkUpFromStmt IntegerLiteral(1)
+WalkUpFromStmt BinaryOperator(+)
+WalkUpFromStmt IntegerLiteral(2)
+WalkUpFromStmt IntegerLiteral(3)
+WalkUpFromStmt CallExpr(add)
+WalkUpFromStmt ImplicitCastExpr

I think we spotted something funny here. RAV didn't call our overriden 
TraverseBinaryOperator.

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82485/new/

https://reviews.llvm.org/D82485

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82302: [Discussion] Interface for nodes related to id-expression

2020-06-24 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 273093.
eduucaldas added a comment.

remove union. or relation implemented as a parent-child relation


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82302/new/

https://reviews.llvm.org/D82302

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

Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  IdExpression,
 
   // Statements.
   UnknownStatement,
@@ -84,7 +85,10 @@
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
-  MemberPointer
+  MemberPointer,
+  NestedNameSpecifier,
+  NameSpecifier,
+  UnqualifiedId
 };
 /// For debugging purposes.
 llvm::raw_ostream <<(llvm::raw_ostream , NodeKind K);
@@ -187,6 +191,108 @@
   }
 };
 
+/// A sequence of these specifiers makes a `nested-name-specifier`.
+/// e.g. the `std::` or `vector::` in `std::vector::size`.
+class NameSpecifier final : public Tree {
+private:
+public:
+  NameSpecifier() : Tree(NodeKind::NameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::NameSpecifier;
+  }
+
+  // See discussion about OR relation in `UnqualifiedId`
+  NodeKind getChildKind();
+  syntax::Leaf *getIdentifier();
+  syntax::Leaf *getNamespaceName();
+  //(...)
+
+  // Should we create accessors to everything?
+  syntax::Leaf *doubleCommaToken();
+};
+
+/// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
+/// e.g. the `std::vector::` in `std::vector::size`.
+class NestedNameSpecifier final : public Tree {
+public:
+  NestedNameSpecifier() : Tree(NodeKind::NestedNameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() <= NodeKind::NestedNameSpecifier;
+  }
+  std::vector specifiers();
+};
+
+// Models `operator-function-id`. To be implemented, not interesting for
+// discussion
+class OperatorFunctionId;
+// Models `identifier`. This is merely a token.
+class Identifier;
+
+/// Models an `unqualified-id`, e.g. the `size` in `std::vector::size`.
+// C++ [expr.prim.id.unqual]
+// unqualified-id:
+//   identifier
+//   operator-function-id
+//   conversion-function-id
+//   literal-operator-id
+//   ~ type-name
+//   ~ decltype-specifier
+//   template-id
+class UnqualifiedId final : public Tree {
+  // As {`identifier`, `operator-function-id`, ...} appear in other parts of the
+  // grammar - `template-id` appears almost everywhere - we implement them as
+  // standalone nodes instead of derived from `unqualified-id`. We encode the
+  // relation `unqualified-id` = {`identifier` OR `operator-function-id` OR ...}
+  // through a parent-child relation and to discover which child we have we
+  // check the `NodeKind` of the child.
+private:
+public:
+  UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::UnqualifiedId;
+  }
+  NodeKind getChildKind();
+
+  // The way to use the API would be to call `getChildKind()`
+  // and then use the appropriate accessor according to the kind of the child.
+  syntax::Identifier *
+  getIdentifier(); // Drawback: Identifier is merely a Token, as such we
+   // could've use a `syntax::Leaf`
+  syntax::OperatorFunctionId *getOperatorFunctionId();
+  // (...)
+};
+
+/// Models an `id-expression`, e.g. `std::vector::size`.
+/// C++ [expr.prim.id]
+/// id-expression:
+///   unqualified-id
+///   qualified-id
+/// qualified-id:
+///   nested-name-specifier template_opt unqualified-id
+/// For simplicity we use:
+/// id-expression:
+///   nested-name-specifier_opt template_opt unqualified-id
+/// That is a bit more general than the grammar rule and allows forbidden
+/// syntax. That's ok, it is not our duty to verify the syntax of the program
+class IdExpression final : public Expression {
+public:
+  IdExpression() : Expression(NodeKind::IdExpression) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::IdExpression;
+  }
+  // `qualifier` and `templateKeyword` are optional children of
+  // id-expression whereas `id` is a required child.
+  // How to make this distinction clear both to the reader and to the compiler?
+  // For children that are:
+  //  * required: use reference; optional: use pointer
+  //  * required: reference; optional: optional reference
+  // We could also use attributes to document that a pointer is not null
+  syntax::NestedNameSpecifier *qualifier();
+  syntax::Leaf *templateKeyword();
+
+  syntax::UnqualifiedId *id();
+};
+
 /// C++11 'nullptr' expression.
 class CxxNullPtrExpression final : public Expression {
 public:
___
cfe-commits mailing list
cfe-commits@lists.llvm.org

[PATCH] D82302: [Discussion] Interface for nodes related to id-expression

2020-06-24 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 273096.
eduucaldas added a comment.

Polishing


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82302/new/

https://reviews.llvm.org/D82302

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

Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  IdExpression,
 
   // Statements.
   UnknownStatement,
@@ -84,7 +85,10 @@
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
-  MemberPointer
+  MemberPointer,
+  NestedNameSpecifier,
+  NameSpecifier,
+  UnqualifiedId
 };
 /// For debugging purposes.
 llvm::raw_ostream <<(llvm::raw_ostream , NodeKind K);
@@ -187,6 +191,109 @@
   }
 };
 
+/// A sequence of these specifiers makes a `nested-name-specifier`.
+/// e.g. the `std::` or `vector::` in `std::vector::size`.
+class NameSpecifier final : public Tree {
+private:
+public:
+  NameSpecifier() : Tree(NodeKind::NameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::NameSpecifier;
+  }
+
+  // Same solution as in `unqualified-id`
+  NodeKind getChildKind();
+  syntax::Leaf *getIdentifier();
+  syntax::Leaf *getNamespaceName();
+  //(...)
+
+  // Should we create accessors to everything?
+  syntax::Leaf *doubleCommaToken();
+};
+
+/// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
+/// e.g. the `std::vector::` in `std::vector::size`.
+class NestedNameSpecifier final : public Tree {
+public:
+  NestedNameSpecifier() : Tree(NodeKind::NestedNameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() <= NodeKind::NestedNameSpecifier;
+  }
+  std::vector specifiers();
+};
+
+// To be implemented, not interesting for discussion
+class OperatorFunctionId; // Models `operator-function-id`.
+class Identifier; // Models `identifier`.
+// (...)
+
+/// Models an `unqualified-id`, e.g. the `size` in `std::vector::size`.
+// C++ [expr.prim.id.unqual]
+// unqualified-id:
+//   identifier
+//   operator-function-id
+//   conversion-function-id
+//   literal-operator-id
+//   ~ type-name
+//   ~ decltype-specifier
+//   template-id
+class UnqualifiedId final : public Tree {
+  // As {`identifier`, `operator-function-id`, ...} appear in other parts of the
+  // grammar - `template-id` appears almost everywhere - we implement them as
+  // standalone nodes instead of derived from `unqualified-id`. We encode the
+  // relation `unqualified-id` = {`identifier` OR `operator-function-id` OR ...}
+  // through a parent-child relation and to discover which child we have we
+  // check the `NodeKind` of the child.
+private:
+public:
+  UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::UnqualifiedId;
+  }
+
+  // We use `getChildKind()` and use the returned `NodeKind` to access the
+  // appropriate variant via an accessor
+  NodeKind getChildKind();
+  // Accessors
+  syntax::Identifier *
+  getIdentifier(); // Drawback: Identifier is merely a Token, as such we
+   // could use a `syntax::Leaf` instead. Alternative: Use
+   // NodeRole information as well
+  syntax::OperatorFunctionId *getOperatorFunctionId();
+  // (...)
+};
+
+/// Models an `id-expression`, e.g. `std::vector::size`.
+/// C++ [expr.prim.id]
+/// id-expression:
+///   unqualified-id
+///   qualified-id
+/// qualified-id:
+///   nested-name-specifier template_opt unqualified-id
+/// For simplicity we use:
+/// id-expression:
+///   nested-name-specifier_opt template_opt unqualified-id
+/// That is a bit more general than the grammar rule and allows forbidden
+/// syntax. That's ok, it is not our duty to verify the syntax of the program
+class IdExpression final : public Expression {
+public:
+  IdExpression() : Expression(NodeKind::IdExpression) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::IdExpression;
+  }
+  // `qualifier` and `templateKeyword` are optional children of
+  // id-expression whereas `id` is a required child.
+  // How to make this distinction clear both to the reader and to the compiler?
+  // For children that are:
+  //  * required: use reference; optional: use pointer
+  //  * required: reference; optional: optional reference
+  // We could also use attributes to document that a pointer is not null
+  syntax::NestedNameSpecifier *qualifier();
+  syntax::Leaf *templateKeyword();
+
+  syntax::UnqualifiedId *id();
+};
+
 /// C++11 'nullptr' expression.
 class CxxNullPtrExpression final : public Expression {
 public:
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82312: Add `CharLiteral` to SyntaxTree

2020-06-23 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked 2 inline comments as done.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:1266
+
+TEST_P(SyntaxTreeTest, CharacterLiteralCxx11) {
+  if (!GetParam().isCXX11OrLater()) {

Rename to `CharacterLiteralUtf`?



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:1300
+
+TEST_P(SyntaxTreeTest, CharacterLiteralCxx17) {
+  if (!GetParam().isCXX17OrLater()) {

Rename to `CharacterLiteralUtf8`?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82312/new/

https://reviews.llvm.org/D82312



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82360: Add StringLiteral to SyntaxTree

2020-06-23 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82360

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
@@ -1228,6 +1228,114 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, StringLiteral) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  "a";
+  "a\n";
+  L"a";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-"a"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-"a\n"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-L"a"
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, StringLiteralUtf) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u8"a";
+  u"a";
+  U"a";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-u8"a"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-u"a"
+| `-;
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-U"a"
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, StringLiteralRaw) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  R"SyntaxTree(
+  Hello "Syntax" \"
+  )SyntaxTree";
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-StringLiteralExpression
+| | `-R"SyntaxTree(
+  Hello "Syntax" \"
+  )SyntaxTree"
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -2559,7 +2667,7 @@
 | |-UnknownExpression
 | | `-true
 | |-,
-| |-UnknownExpression
+| |-StringLiteralExpression
 | | `-"message"
 | |-)
 | `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::StringLiteralExpression:
+return OS << "StringLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::StringLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromStringLiteral(StringLiteral *S) {
+Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::StringLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  StringLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -264,6 +265,16 @@
   syntax::Leaf *literalToken();
 };
 
+/// Expression for string-literals. C++ [lex.string]
+class StringLiteralExpression final : public Expression {
+public:
+  StringLiteralExpression() :

[PATCH] D82318: Add `FloatingLiteral` to SyntaxTree

2020-06-23 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added a reviewer: gribozavr2.
eduucaldas marked an inline comment as done.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:72-75
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+

This was already defined in this [[ https://reviews.llvm.org/D82312 | patch ]]. 
But I wanted to make them independent.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82318/new/

https://reviews.llvm.org/D82318



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82310: Add `BoolLiteralExpression` to SyntaxTree

2020-06-23 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked an inline comment as done.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:1240
+  true;
+  false;
+}

gribozavr2 wrote:
> C99 has bool literals, but the program should include stdbool.h.
> 
> I feel like it is better to make the predicate something like "hasBoolType()" 
> and change the test to include stdbool.h.
[[ https://clang.llvm.org/doxygen/stdbool_8h_source.html | stdbool ]] consists 
on macro definitions, mapping booleans to integers. `true` is preprocessed into 
1 and `false` to 0 .
I don't  think there is a reasonable way of getting the proper SyntaxTree from 
that macro expansion

Additional problem, we don't have the test infrastructure for includes, AFAIK ^^

Finally, regarding the predicates, I prefer if they relate to languages, 
otherwise we might create many predicates that test for exactly the same thing, 
e.g. we would have `hasBoolType()` and `hasNullPtr()` that ultimately do the 
same thing, test if Language is not C 


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82310/new/

https://reviews.llvm.org/D82310



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82318: Add `FloatingLiteral` to SyntaxTree

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas updated this revision to Diff 272492.
eduucaldas added a comment.

removing automatically added include


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82318

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,91 @@
 )txt"));
 }
 
+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() {
+0xfp1;
+0xf.p1;
+0x.fp1;
+0xf.fp1f;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xfp1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xf.p1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0x.fp1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xf.fp1f
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::FloatingLiteralExpression:
+return OS << "FloatingLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -195,6 +197,11 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::FloatingLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromFloatingLiteral(FloatingLiteral *S) {
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::FloatingLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  FloatingLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -254,6 +255,17 @@
   syntax::Leaf *nullPtrKeyword();
 };
 
+/// Expression for floating-point literals. C++ [lex.fcon]
+class FloatingLiteralExpression final : public Expression {
+public:
+  FloatingLiteralExpression()
+  : Expression(NodeKind::FloatingLiteralExpression)

[PATCH] D82318: Add `FloatingLiteral` to SyntaxTree

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 272492.
eduucaldas added a comment.

removing automatically added include


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82318/new/

https://reviews.llvm.org/D82318

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,91 @@
 )txt"));
 }
 
+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() {
+0xfp1;
+0xf.p1;
+0x.fp1;
+0xf.fp1f;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xfp1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xf.p1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0x.fp1
+| `-;
+|-ExpressionStatement
+| |-FloatingLiteralExpression
+| | `-0xf.fp1f
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::FloatingLiteralExpression:
+return OS << "FloatingLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -195,6 +197,11 @@
   findChild(syntax::NodeRole::IdExpression_id));
 }
 
+syntax::Leaf *syntax::FloatingLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromFloatingLiteral(FloatingLiteral *S) {
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::FloatingLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  FloatingLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -254,6 +255,17 @@
   syntax::Leaf *nullPtrKeyword();
 };
 
+/// Expression for floating-point literals. C++ [lex.fcon]
+class FloatingLiteralExpression final : public Expression {
+public:
+  FloatingLiteralExpression()
+  : Expression(NodeKind::FloatingLiteralExpression) {}
+  static bool classof(const Node *N)

[PATCH] D82312: Add `CharLiteral` to SyntaxTree

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82312

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
@@ -69,6 +69,10 @@
Language == Lang_CXX20;
   }
 
+  bool isCXX17OrLater() const {
+return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -1228,6 +1232,100 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, CharacterLiteral) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  'a';
+  L'a';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-L'a'
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, CharacterLiteralCxx11) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u'a';
+  U'a';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u'a'
+| `-;
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-U'a'
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, CharacterLiteralCxx17) {
+  if (!GetParam().isCXX17OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  u8'a';
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CharacterLiteralExpression
+| | `-u8'a'
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::CharacterLiteralExpression:
+return OS << "CharacterLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::CharacterLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 return true;
   }
 
+  bool WalkUpFromCharacterLiteral(CharacterLiteral *S) {
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::CharacterLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  CharacterLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -254,6 +255,17 @@
   syntax::Leaf *nullPtrKeyword();
 };
 
+/// Expression for character literals. C++ [lex.ccon]
+class CharacterLiteralExpression final : public Expression {
+public:
+  CharacterLiteralExpression()
+  : Expression(NodeKind::CharacterLiteralExpression) {}
+

[PATCH] D82310: Add `BoolLiteralExpression` to SyntaxTree

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked 3 inline comments as done.
eduucaldas added inline comments.



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:268
 
+/// Expression for boolean literals. C++ [lex.bool]
+class BoolLiteralExpression final : public Expression {

Homogenize this comments for other literals, and possibly other expressions. To 
be done in future change



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:269
+/// Expression for boolean literals. C++ [lex.bool]
+class BoolLiteralExpression final : public Expression {
+public:

Unify Literals under a Literal class, following the grammar, [lex.literal]
To be done in a future change



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:54
 
+  bool isC() const { return Language == Lang_C89 || Language == Lang_C99; }
   bool isC99OrLater() const { return Language == Lang_C99; }

We could use this to extend the coverage of our tests from `isCXX` to `!isC`. 
To be done in a future change


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82310/new/

https://reviews.llvm.org/D82310



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82310: Add `BoolLiteralExpression` to SyntaxTree

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82310

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
@@ -51,6 +51,7 @@
   TestLanguage Language;
   std::string Target;
 
+  bool isC() const { return Language == Lang_C89 || Language == Lang_C99; }
   bool isC99OrLater() const { return Language == Lang_C99; }
 
   bool isCXX() const {
@@ -1228,6 +1229,40 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, BoolLiteral) {
+  if (GetParam().isC()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test() {
+  true;
+  false;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-BoolLiteralExpression
+| | `-true
+| `-;
+|-ExpressionStatement
+| |-BoolLiteralExpression
+| | `-false
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
@@ -1691,18 +1726,18 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-BoolLiteralExpression
 | | | `-true
 | | |-||
-| | `-UnknownExpression
+| | `-BoolLiteralExpression
 | |   `-false
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-BoolLiteralExpression
 | | | `-true
 | | |-or
-| | `-UnknownExpression
+| | `-BoolLiteralExpression
 | |   `-false
 | `-;
 |-ExpressionStatement
@@ -2556,7 +2591,7 @@
 |-StaticAssertDeclaration
 | |-static_assert
 | |-(
-| |-UnknownExpression
+| |-BoolLiteralExpression
 | | `-true
 | |-,
 | |-UnknownExpression
@@ -2566,7 +2601,7 @@
 `-StaticAssertDeclaration
   |-static_assert
   |-(
-  |-UnknownExpression
+  |-BoolLiteralExpression
   | `-true
   |-)
   `-;
@@ -3186,7 +3221,7 @@
   |   |-)
   |   |-noexcept
   |   |-(
-  |   |-UnknownExpression
+  |   |-BoolLiteralExpression
   |   | `-true
   |   `-)
   `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -22,6 +22,8 @@
 return OS << "CxxNullPtrExpression";
   case NodeKind::IntegerLiteralExpression:
 return OS << "IntegerLiteralExpression";
+  case NodeKind::BoolLiteralExpression:
+return OS << "BoolLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -200,6 +202,11 @@
   findChild(syntax::NodeRole::LiteralToken));
 }
 
+syntax::Leaf *syntax::BoolLiteralExpression::literalToken() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::LiteralToken));
+}
+
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::LiteralToken));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -654,6 +654,13 @@
 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),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  BoolLiteralExpression,
   IdExpression,
 
   // Statements.
@@ -264,6 +265,16 @@
   syntax::Leaf *literalToken();
 };
 
+/// Expression for boolean literals. C++ [lex.bool]
+class BoolLiteralExpression final : public Expression {
+public:
+  BoolLiteralExpression() : Expression(NodeKind::BoolLiteralExpression) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::BoolLiteralExpression;
+  }
+  syntax::Leaf *literalToken();
+};
+
 /// An abstract class for prefix and postfix

[PATCH] D82302: [Discussion] Interface for nodes related to id-expression

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 272445.
eduucaldas added a comment.

update comments, rollback references, and add them as proposition


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82302/new/

https://reviews.llvm.org/D82302

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

Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  IdExpression,
 
   // Statements.
   UnknownStatement,
@@ -84,7 +85,11 @@
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
-  MemberPointer
+  MemberPointer,
+  NestedNameSpecifier,
+  NameSpecifier,
+  UnqualifiedId,
+  OperatorFunctionId,
 };
 /// For debugging purposes.
 llvm::raw_ostream <<(llvm::raw_ostream , NodeKind K);
@@ -187,6 +192,135 @@
   }
 };
 
+/// A sequence of these specifiers make a `nested-name-specifier`.
+/// e.g. the `std::` or `vector::` in `std::vector::size`.
+class NameSpecifier final : public Tree {
+private:
+  // See discussion about implementation in UnqualifiedId
+  /// From C++ [expr.prim.id.qual]
+  /// nested-name-specifier:
+  ///   ::
+  ///   type-name ::
+  ///   namespace-name ::
+  ///   decltype-specifier ::
+  ///   nested-name-specifier identifier ::
+  ///   nested-name-specifier template_opt simple-template-id ::
+  enum SpecifierKind {
+Global,
+TypeSpec,
+Namespace,
+DecltypeSpec,
+Identifier,
+TypeSpecWithTemplate
+  };
+
+public:
+  NameSpecifier() : Tree(NodeKind::NameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::NameSpecifier;
+  }
+  SpecifierKind getKind();
+  syntax::Leaf *getIdentifier();
+  syntax::Leaf *getNamespaceName();
+  //(...)
+  syntax::Leaf *doubleCommaToken();
+};
+
+/// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
+/// e.g. the `std::vector::` in `std::vector::size`.
+class NestedNameSpecifier final : public Tree {
+public:
+  NestedNameSpecifier() : Tree(NodeKind::NestedNameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() <= NodeKind::NestedNameSpecifier;
+  }
+  std::vector specifiers();
+};
+
+/// Models a `operator-function-id`. C++ [over.oper]
+/// operator-function-id:
+///   'operator' operator
+/// operator:
+///   +   -   *   /   =
+/// (...)
+class OperatorFunctionId final : public Tree {
+public:
+  OperatorFunctionId() : Tree(NodeKind::OperatorFunctionId) {}
+  static bool classof(const Node *N) {
+return N->kind() <= NodeKind::OperatorFunctionId;
+  }
+  syntax::Leaf *operatorKeyword();
+  syntax::Leaf *operatorCode();
+};
+
+/// Models an `unqualified-id`, e.g. the `size` in `std::vector::size`.
+// C++ [expr.prim.id.unqual]
+// unqualified-id:
+//   identifier
+//   operator-function-id
+//   conversion-function-id
+//   literal-operator-id
+//   ~ type-name
+//   ~ decltype-specifier
+//   template-id
+class UnqualifiedId final : public Tree {
+  // The variants of `unqualified-id` - `identifier`, `operator-function-id`,
+  // ... - appear in other parts of the syntax. As such we want to implement
+  // them detached from `unqualified-id`. How to implement accessors to these
+  // variants?
+  //  * Store an union with the variants and an enum of the kinds of
+  //variants. Access these variants by asking of what kind is
+  //`unqualified-id` and then using the appropriate getter. See:
+  //`UnqualifiedId` in "llvm-project/clang/include/clang/Sema/DeclSpec.h".
+  //  * Similar but using std::variant instead of union.
+  //  * not implement those accessors.
+private:
+  enum class UnqualifiedIdKind {
+IK_Identifier,
+IK_OperatorFunctionId,
+IK_ConversionFunctionId,
+IK_LiteralOperatorId,
+IK_DestructorName,
+IK_TemplateId,
+  };
+
+public:
+  UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::UnqualifiedId;
+  }
+  UnqualifiedIdKind getKind();
+  syntax::Leaf *getIdentifier();
+  syntax::OperatorFunctionId *getOperatorFunctionId();
+  // (...)
+};
+
+/// Models an `id-expression`, e.g. `std::vector::size`.
+/// C++ [expr.prim.id]
+/// id-expression:
+///   unqualified-id
+///   qualified-id
+/// qualified-id:
+///   nested-name-specifier template_opt unqualified-id
+class IdExpression final : public Expression {
+public:
+  IdExpression() : Expression(NodeKind::IdExpression) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::IdExpression;
+  }
+  // `qualifier` and `templateKeyword` are optional children of
+  // id-expression whereas id is a required child.
+  // How to make this distinction clear both to the reader and to the compiler?
+  // For children that are:
+  //  * required: use reference; optional: use

[PATCH] D82302: [Discussion] Interface for nodes related to id-expression

2020-06-22 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82302

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

Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -45,6 +45,7 @@
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  IdExpression,
 
   // Statements.
   UnknownStatement,
@@ -84,7 +85,12 @@
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
-  MemberPointer
+  MemberPointer,
+  NestedNameSpecifier,
+  NameSpecifier,
+  NamespaceName,
+  UnqualifiedId,
+  OperatorFunctionId,
 };
 /// For debugging purposes.
 llvm::raw_ostream <<(llvm::raw_ostream , NodeKind K);
@@ -187,6 +193,130 @@
   }
 };
 
+/// A sequence of these specifiers make a `nested-name-specifier`.
+/// e.g. the `std::` or `vector::` in `std::vector::size`.
+/// nested-name-specifier:
+///   ::
+///   type-name ::
+///   namespace-name ::
+///   decltype-specifier ::
+///   nested-name-specifier identifier ::
+///   nested-name-specifier template_opt simple-template-id ::
+class NameSpecifier final : public Tree {
+private:
+  // See discussion about implementation in UnqualifiedId
+  enum SpecifierKind {
+Global,
+TypeSpec,
+Namespace,
+DecltypeSpec,
+Identifier,
+TypeSpecWithTemplate
+  };
+
+public:
+  NameSpecifier() : Tree(NodeKind::NameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::NameSpecifier;
+  }
+  SpecifierKind getKind();
+  syntax::Leaf *getIdentifier();
+  syntax::Leaf *getNamespaceName();
+  //(...)
+  syntax::Leaf ();
+};
+
+/// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
+/// e.g. the `std::vector::` in `std::vector::size`.
+class NestedNameSpecifier final : public Tree {
+public:
+  NestedNameSpecifier() : Tree(NodeKind::NestedNameSpecifier) {}
+  static bool classof(const Node *N) {
+return N->kind() <= NodeKind::NestedNameSpecifier;
+  }
+  std::vector specifiers();
+};
+
+/// Models a `operator-function-id`. C++ [over.oper]
+/// operator-function-id:
+///   'operator' operator
+/// operator:
+///   +   -   *   /   =
+/// (...)
+class OperatorFunctionId final : public Tree {
+public:
+  OperatorFunctionId() : Tree(NodeKind::OperatorFunctionId) {}
+  static bool classof(const Node *N) {
+return N->kind() <= NodeKind::OperatorFunctionId;
+  }
+  syntax::Leaf ();
+  syntax::Leaf ();
+};
+
+/// Models an `unqualified-id`.  / e.g. the `size` in `std::vector::size`.
+// C++ [expr.prim.id.unqual]
+// unqualified-id:
+//   identifier
+//   operator-function-id
+//   conversion-function-id
+//   literal-operator-id
+//   ~ type-name
+//   ~ decltype-specifier
+//   template-id
+class UnqualifiedId final : public Tree {
+  // The variants of `unqualified-id` - `identifier`, `operator-function-id`,
+  // ... - appear in other parts of the syntax. As such we want to implement
+  // them detached from `unqualified-id`. How to implement accessors to these
+  // variants?
+  //  * Store an union with the variants and an enum of the kinds of
+  //variants. Access these variants by asking of what kind is
+  //`unqualified-id` and then using the appropriate getter. See:
+  //`UnqualifiedId` in "llvm-project/clang/include/clang/Sema/DeclSpec.h".
+  //  * Similar but using std::variant instead of union.
+  //  * not implement those accessors.
+private:
+  enum class UnqualifiedIdKind {
+IK_Identifier,
+IK_OperatorFunctionId,
+IK_ConversionFunctionId,
+IK_LiteralOperatorId,
+IK_DestructorName,
+IK_TemplateId,
+  };
+
+public:
+  UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::UnqualifiedId;
+  }
+  UnqualifiedIdKind getKind();
+  syntax::Leaf *getIdentifier();
+  syntax::OperatorFunctionId *getOperatorFunctionId();
+  // (...)
+};
+
+/// Models an `id-expression`, e.g. `std::vector::size`.
+/// C++ [expr.prim.id]
+/// id-expression:
+///   unqualified-id
+///   qualified-id
+/// qualified-id:
+///   nested-name-specifier template_opt unqualified-id
+class IdExpression final : public Expression {
+public:
+  IdExpression() : Expression(NodeKind::IdExpression) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::IdExpression;
+  }
+  // `qualifier` and `templateKeyword` are optional children of
+  // id-expression whereas id is a required child.
+  // How to make this distinction clear both to the reader and to the compiler?
+  syntax::NestedNameSpecifier *qualifier();
+  syntax::Leaf *templateKeyword();
+
+  syntax::UnqualifiedId ();
+};
+
 /// C++11 'nullptr' expression.
 class CxxNullPtrExpression final : public Expression {
 public:

[PATCH] D82157: Fix crash on `user defined literals`

2020-06-19 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 271980.
eduucaldas added a comment.

Why does this work?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D82157/new/

https://reviews.llvm.org/D82157

Files:
  clang/lib/Tooling/Syntax/BuildTree.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
@@ -1228,6 +1228,93 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UserDefinedLiteral) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+long double operator "" _w(long double);
+unsigned operator "" _w(const char*);
+template  unsigned operator "" _x();
+int main() {
+1.2_w; // calls operator "" _w(1.2L)
+12_w;  // calls operator "" _w("12")
+12_x;  // calls operator<'1', '2'> "" _x()
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-long
+| |-double
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_w
+| | `-ParametersAndQualifiers
+| |   |-(
+| |   |-SimpleDeclaration
+| |   | |-long
+| |   | `-double
+| |   `-)
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_w
+| | `-ParametersAndQualifiers
+| |   |-(
+| |   |-SimpleDeclaration
+| |   | |-const
+| |   | |-char
+| |   | `-SimpleDeclarator
+| |   |   `-*
+| |   `-)
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-SimpleDeclaration
+| | `-char
+| |-...
+| |->
+| `-SimpleDeclaration
+|   |-unsigned
+|   |-SimpleDeclarator
+|   | |-operator
+|   | |-""
+|   | |-_x
+|   | `-ParametersAndQualifiers
+|   |   |-(
+|   |   `-)
+|   `-;
+`-SimpleDeclaration
+  |-int
+  |-SimpleDeclarator
+  | |-main
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-UserDefinedLiteralExpression
+| | `-1.2_w
+| `-;
+|-ExpressionStatement
+| |-UserDefinedLiteralExpression
+| | `-12_w
+| `-;
+|-ExpressionStatement
+| |-UserDefinedLiteralExpression
+| | `-12_x
+| `-;
+`-}
+)txt"));
+}
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -623,6 +623,19 @@
 return NNS;
   }
 
+  bool TraverseUserDefinedLiteral(UserDefinedLiteral *S) { return true; }
+
+  bool WalkUpFromUserDefinedLiteral(UserDefinedLiteral *S) {
+// The user-defined-literal `1.2_w` is not split in the tokens `1.2` and
+// `_w` as we might imagine, its tokens are `1.2_w` only.
+// As a node is built by folding tokens we cannot generate one
+// for `_w`
+Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::IntegerLiteralExpression, S);
+return true;
+  }
+
   bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
 if (auto *NNS = BuildNestedNameSpecifier(S->getQualifierLoc()))
   Builder.markChild(NNS, syntax::NodeRole::IdExpression_qualifier);
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D82157: Fix crash on `user defined literals`

2020-06-19 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Given an UserDefinedLiteral `1.2_w`:
Problem: Lexer generates one Token for the literal, but ClangAST
references two source locations
Fix: Ignore the operator and interpret it as the underlying literal.
e.g.: `1.2_w` token generates syntax node IntegerLiteral(1.2_w)


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D82157

Files:
  clang/lib/Tooling/Syntax/BuildTree.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
@@ -1228,6 +1228,95 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UserDefinedLiteral) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+long double operator "" _w(long double);
+unsigned operator "" _w(const char*);
+template  unsigned operator "" _x();
+int main() {
+1.2_w; // calls operator "" _w(1.2L)
+12_w;  // calls operator "" _w("12")
+12_x;  // calls operator<'1', '2'> "" _x()
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-long
+| |-double
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_w
+| | `-ParametersAndQualifiers
+| |   |-(
+| |   |-SimpleDeclaration
+| |   | |-long
+| |   | `-double
+| |   `-)
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_w
+| | `-ParametersAndQualifiers
+| |   |-(
+| |   |-SimpleDeclaration
+| |   | |-const
+| |   | |-char
+| |   | `-SimpleDeclarator
+| |   |   `-*
+| |   `-)
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-SimpleDeclaration
+| | `-char
+| |-...
+| |->
+| `-SimpleDeclaration
+|   |-unsigned
+|   |-SimpleDeclarator
+|   | |-operator
+|   | |-""
+|   | |-_x
+|   | `-ParametersAndQualifiers
+|   |   |-(
+|   |   `-)
+|   `-;
+`-SimpleDeclaration
+  |-int
+  |-SimpleDeclarator
+  | |-main
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-UnknownExpression
+| | `-UnknownExpression
+| |   `-1.2_w
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | `-UnknownExpression
+| |   `-12_w
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | `-12_x
+| `-;
+`-}
+)txt"));
+}
 TEST_P(SyntaxTreeTest, IntegerLiteral) {
   EXPECT_TRUE(treeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -624,6 +624,9 @@
   }
 
   bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
+if (S->getNameInfo().getName().getNameKind() ==
+clang::DeclarationName::CXXLiteralOperatorName)
+  return true;
 if (auto *NNS = BuildNestedNameSpecifier(S->getQualifierLoc()))
   Builder.markChild(NNS, syntax::NodeRole::IdExpression_qualifier);
 
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-18 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 271784.
eduucaldas added a comment.

change if -> asserts


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -485,8 +485,9 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
-| | `-a
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-a
 | |-)
 | `-EmptyStatement
 |   `-;
@@ -662,8 +663,9 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
-| | | `-test
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-test
 | | |-(
 | | `-)
 | `-;
@@ -675,16 +677,18 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
-| | | | `-test
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-test
 | | | |-(
 | | | `-)
 | | `-;
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
-|   | | `-test
+|   | |-IdExpression
+|   | | `-UnqualifiedId
+|   | |   `-test
 |   | |-(
 |   | `-)
 |   `-;
@@ -692,6 +696,509 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  // TODO: Expose `id-expression` from `Declarator`
+  friend X operator+(const X&, const X&);
+  operator int();
+};
+template
+void f(T&);
+void test(X x) {
+  x;  // identifier
+  operator+(x, x);// operator-function-id
+  f(x);// template-id
+  // TODO: Expose `id-expression` from `MemberExpr`
+  x.operator int();   // conversion-funtion-id
+  x.~X(); // ~type-name
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-UnknownDeclaration
+| | `-SimpleDeclaration
+| |   |-friend
+| |   |-X
+| |   |-SimpleDeclarator
+| |   | |-operator
+| |   | |-+
+| |   | `-ParametersAndQualifiers
+| |   |   |-(
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   |-,
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   `-)
+| |   `-;
+| |-SimpleDeclaration
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-int
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-UnknownDeclaration
+| | |-typename
+| | `-T
+| |->
+| `-SimpleDeclaration
+|   |-void
+|   |-SimpleDeclarator
+|   | |-f
+|   | `-ParametersAndQualifiers
+|   |   |-(
+|   |   |-SimpleDeclaration
+|   |   | |-T
+|   |   | `-SimpleDeclarator
+|   |   |   `-&
+|   |   `-)
+|   `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-x
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-operator
+| | |   `-+
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | |-,
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-f
+| | |   |-<
+| | |   |-X
+| | |   `->
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-UnknownExpression
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-x
+| | | |-.
+| | | |-operator
+| | | `-int
+| | |-(
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-UnknownExpression
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-x
+| | | |-.
+| | | |-~
+| | | `-X
+| | |-(
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLater) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X { };
+unsigned operator "" _w(long long unsigned);
+void test(X x) {
+  operator "" _w(1llu);   //

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-18 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked 2 inline comments as done.
eduucaldas added inline comments.



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:190
+return N->kind() == NodeKind::NameSpecifier;
+  }
+};

eduucaldas wrote:
> gribozavr2 wrote:
> > Should there be getters for various parts of the specifier?
> I think not.
Pospone to interface discussion with Yitzhak



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:214
+return N->kind() == NodeKind::UnqualifiedId;
+  }
+};

gribozavr2 wrote:
> Could you add TODOs about adding accessors?
Pospone to interface discussion with Yitzhak



Comment at: clang/lib/Tooling/Syntax/Nodes.cpp:178
 }
 
+std::vector syntax::NestedNameSpecifier::specifiers() 
{

I was thinking and our problem is bigger than not testing for `NodeRole`s, we 
don't test accessors at all!



Comment at: clang/lib/Tooling/Syntax/Nodes.cpp:182
+  for (auto *C = firstChild(); C; C = C->nextSibling()) {
+if (C->role() == syntax::NodeRole::NestedNameSpecifier_specifier)
+  Children.push_back(llvm::cast(C));

This should be an assert for now, as if that is not true it would be a logic 
problem. Same reasoning applies to `CompoundStatement`


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-18 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 271744.
eduucaldas marked 12 inline comments as done.
eduucaldas added a comment.

Aswering comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -485,8 +485,9 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
-| | `-a
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-a
 | |-)
 | `-EmptyStatement
 |   `-;
@@ -662,8 +663,9 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
-| | | `-test
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-test
 | | |-(
 | | `-)
 | `-;
@@ -675,16 +677,18 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
-| | | | `-test
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-test
 | | | |-(
 | | | `-)
 | | `-;
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
-|   | | `-test
+|   | |-IdExpression
+|   | | `-UnqualifiedId
+|   | |   `-test
 |   | |-(
 |   | `-)
 |   `-;
@@ -692,6 +696,509 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  // TODO: Expose `id-expression` from `Declarator`
+  friend X operator+(const X&, const X&);
+  operator int();
+};
+template
+void f(T&);
+void test(X x) {
+  x;  // identifier
+  operator+(x, x);// operator-function-id
+  f(x);// template-id
+  // TODO: Expose `id-expression` from `MemberExpr`
+  x.operator int();   // conversion-funtion-id
+  x.~X(); // ~type-name
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-UnknownDeclaration
+| | `-SimpleDeclaration
+| |   |-friend
+| |   |-X
+| |   |-SimpleDeclarator
+| |   | |-operator
+| |   | |-+
+| |   | `-ParametersAndQualifiers
+| |   |   |-(
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   |-,
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   `-)
+| |   `-;
+| |-SimpleDeclaration
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-int
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-UnknownDeclaration
+| | |-typename
+| | `-T
+| |->
+| `-SimpleDeclaration
+|   |-void
+|   |-SimpleDeclarator
+|   | |-f
+|   | `-ParametersAndQualifiers
+|   |   |-(
+|   |   |-SimpleDeclaration
+|   |   | |-T
+|   |   | `-SimpleDeclarator
+|   |   |   `-&
+|   |   `-)
+|   `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-x
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-operator
+| | |   `-+
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | |-,
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-f
+| | |   |-<
+| | |   |-X
+| | |   `->
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-UnknownExpression
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-x
+| | | |-.
+| | | |-operator
+| | | `-int
+| | |-(
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-UnknownExpression
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-x
+| | | |-.
+| | | |-~
+| | | `-X
+| | |-(
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLater) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X { };
+unsigned operator "" _w(long long unsigned);
+void test(X x) {
+

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-18 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 271630.
eduucaldas added a comment.

Fix mistake on getting SourceRange for template-id


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -485,8 +485,9 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
-| | `-a
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-a
 | |-)
 | `-EmptyStatement
 |   `-;
@@ -662,8 +663,9 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
-| | | `-test
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-test
 | | |-(
 | | `-)
 | `-;
@@ -675,16 +677,18 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
-| | | | `-test
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-test
 | | | |-(
 | | | `-)
 | | `-;
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
-|   | | `-test
+|   | |-IdExpression
+|   | | `-UnqualifiedId
+|   | |   `-test
 |   | |-(
 |   | `-)
 |   `-;
@@ -692,6 +696,475 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  // TODO: Expose `id-expression` from `Declarator`
+  friend X operator+(const X&, const X&);
+  operator int();
+};
+unsigned operator "" _w(long long unsigned);
+template
+void f(T&);
+void test(X x) {
+  x;  // identifier
+  operator+(x, x);// operator-function-id
+  operator "" _w(1llu);   // literal-operator-id
+
+  f(x);// template-id
+
+  // TODO: Expose `id-expression` from `MemberExpr`
+  x.operator int();   // conversion-funtion-id
+  x.~X(); // ~type-name
+  x.~decltype(x)();   // ~decltype-specifier
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-UnknownDeclaration
+| | `-SimpleDeclaration
+| |   |-friend
+| |   |-X
+| |   |-SimpleDeclarator
+| |   | |-operator
+| |   | |-+
+| |   | `-ParametersAndQualifiers
+| |   |   |-(
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   |-,
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   `-)
+| |   `-;
+| |-SimpleDeclaration
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-int
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_w
+| | `-ParametersAndQualifiers
+| |   |-(
+| |   |-SimpleDeclaration
+| |   | |-long
+| |   | |-long
+| |   | `-unsigned
+| |   `-)
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-UnknownDeclaration
+| | |-typename
+| | `-T
+| |->
+| `-SimpleDeclaration
+|   |-void
+|   |-SimpleDeclarator
+|   | |-f
+|   | `-ParametersAndQualifiers
+|   |   |-(
+|   |   |-SimpleDeclaration
+|   |   | |-T
+|   |   | `-SimpleDeclarator
+|   |   |   `-&
+|   |   `-)
+|   `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-x
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-operator
+| | |   `-+
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | |-,
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-operator
+| | |   |-""
+| | |   `-_w
+| | |-(
+| | |-IntegerLiteralExpression
+| | | `-1llu
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-f
+| | |   |-<
+| | |   |-X
+| | |   `->
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-UnknownExpression
+| | | |-IdExpression
+

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-18 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 271620.
eduucaldas marked 7 inline comments as done.
eduucaldas added a comment.

- cleanup for upstreaming
- better coverage for unqualified-id
- Better coverage for qualified-id
- Finish implementing unqualified-id.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -485,8 +485,9 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
-| | `-a
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-a
 | |-)
 | `-EmptyStatement
 |   `-;
@@ -662,8 +663,9 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
-| | | `-test
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-test
 | | |-(
 | | `-)
 | `-;
@@ -675,16 +677,18 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
-| | | | `-test
+| | | |-IdExpression
+| | | | `-UnqualifiedId
+| | | |   `-test
 | | | |-(
 | | | `-)
 | | `-;
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
-|   | | `-test
+|   | |-IdExpression
+|   | | `-UnqualifiedId
+|   | |   `-test
 |   | |-(
 |   | `-)
 |   `-;
@@ -692,6 +696,464 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+struct X {
+  // TODO: Expose `id-expression` from `Declarator`
+  friend X operator+(const X&, const X&);
+  operator int();
+};
+unsigned operator "" _w(long long unsigned);
+template
+void f(T&);
+void test(X x) {
+  x;  // identifier
+  operator+(x, x);// operator-function-id
+  operator "" _w(1llu);   // literal-operator-id
+
+  f(x);// template-id
+
+  // TODO: Expose `id-expression` from `MemberExpr`
+  x.operator int();   // conversion-funtion-id
+  x.~X(); // ~type-name
+  x.~decltype(x)();   // ~decltype-specifier
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-UnknownDeclaration
+| | `-SimpleDeclaration
+| |   |-friend
+| |   |-X
+| |   |-SimpleDeclarator
+| |   | |-operator
+| |   | |-+
+| |   | `-ParametersAndQualifiers
+| |   |   |-(
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   |-,
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   `-)
+| |   `-;
+| |-SimpleDeclaration
+| | |-SimpleDeclarator
+| | | |-operator
+| | | |-int
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   `-)
+| | `-;
+| |-}
+| `-;
+|-SimpleDeclaration
+| |-unsigned
+| |-SimpleDeclarator
+| | |-operator
+| | |-""
+| | |-_w
+| | `-ParametersAndQualifiers
+| |   |-(
+| |   |-SimpleDeclaration
+| |   | |-long
+| |   | |-long
+| |   | `-unsigned
+| |   `-)
+| `-;
+|-TemplateDeclaration
+| |-template
+| |-<
+| |-UnknownDeclaration
+| | |-typename
+| | `-T
+| |->
+| `-SimpleDeclaration
+|   |-void
+|   |-SimpleDeclarator
+|   | |-f
+|   | `-ParametersAndQualifiers
+|   |   |-(
+|   |   |-SimpleDeclaration
+|   |   | |-T
+|   |   | `-SimpleDeclarator
+|   |   |   `-&
+|   |   `-)
+|   `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IdExpression
+| | `-UnqualifiedId
+| |   `-x
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-operator
+| | |   `-+
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | |-,
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-operator
+| | |   |-""
+| | |   `-_w
+| | |-(
+| | |-IntegerLiteralExpression
+| | | `-1llu
+| | `-)
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   |-f
+| | |   |-<
+| | |   |-X
+| | |   `->
+| | |-(
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-x
+|

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-18 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked an inline comment as not done.
eduucaldas added inline comments.



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:190
+return N->kind() == NodeKind::NameSpecifier;
+  }
+};

gribozavr2 wrote:
> Should there be getters for various parts of the specifier?
I think not.



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:209
+/// qualified-id:
+///   nested-name-specifier template_opt unqualified-id
+class IdExpression final : public Expression {

gribozavr2 wrote:
> Please add a TODO for the accessor for the 'template' keyword (and a test 
> that has that keyword).
I can implement accessor. But I couldn't write a test with this template 
keyword that uses `DeclRefExpr`.  [[ https://godbolt.org/z/XWGuZP | This ]] is 
the test I came up with, note that both expressions are represented as 
`DependentScopeDeclRefExpr`



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:216
+  }
+
+  syntax::NestedNameSpecifier *qualifier();

Just by looking at code it is impossible to know if the accessed thing is 
optional or not. 
IdExpression ALWAYS has a UnqualifiedId
IdExpression MAY have a NestedNameSpecifier
This same issue repeats in other places


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-09 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 269422.
eduucaldas edited the summary of this revision.
eduucaldas added a comment.

Answering simple comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -802,15 +802,15 @@
 | |-UnknownExpression
 | | |-IdExpression
 | | | |-NestedNameSpecifier
-| | | | |-NameQualifier
+| | | | |-NameSpecifier
 | | | | | `-::
-| | | | |-NameQualifier
+| | | | |-NameSpecifier
 | | | | | |-a
 | | | | | `-::
-| | | | |-NameQualifier
+| | | | |-NameSpecifier
 | | | | | |-b
 | | | | | `-::
-| | | | `-NameQualifier
+| | | | `-NameSpecifier
 | | | |   |-S
 | | | |   `-::
 | | | `-f
@@ -1546,7 +1546,8 @@
 | |-BinaryOperatorExpression
 | | |-IdExpression
 | | | `-x
-| | |-=
+| | |-IdExpression
+| | | `-=
 | | `-IdExpression
 | |   `-y
 | `-;
@@ -1555,7 +1556,8 @@
 | | |-UnknownExpression
 | | | `-IdExpression
 | | |   `-x
-| | |-+
+| | |-IdExpression
+| | | `-+
 | | `-IdExpression
 | |   `-y
 | `-;
@@ -1563,7 +1565,8 @@
 | |-BinaryOperatorExpression
 | | |-IdExpression
 | | | `-x
-| | |-<
+| | |-IdExpression
+| | | `-<
 | | `-IdExpression
 | |   `-y
 | `-;
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -96,10 +96,8 @@
 return OS << "ParametersAndQualifiers";
   case NodeKind::MemberPointer:
 return OS << "MemberPointer";
-  case NodeKind::Operator:
-return OS << "Operator";
-  case NodeKind::NameQualifier:
-return OS << "NameQualifier";
+  case NodeKind::NameSpecifier:
+return OS << "NameSpecifier";
   case NodeKind::NestedNameSpecifier:
 return OS << "NestedNameSpecifier";
   }
@@ -170,19 +168,23 @@
 return OS << "IdExpression_unqualifiedId";
   case syntax::NodeRole::IdExpression_qualifier:
 return OS << "IdExpression_qualifier";
+  case syntax::NodeRole::NestedNameSpecifier_specifier:
+return OS << "NestedNameSpecifier_specifier";
   }
   llvm_unreachable("invalid role");
 }
 
-std::vector syntax::NestedNameSpecifier::specifiers() {
-  std::vector Children;
+std::vector syntax::NestedNameSpecifier::specifiers() {
+  std::vector Children;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
-Children.push_back(llvm::cast(C));
+if (C->role() == syntax::NodeRole::NestedNameSpecifier_specifier)
+  Children.push_back(llvm::cast(C));
   }
   return Children;
 }
-syntax::Leaf *syntax::IdExpression::qualifier() {
-  return llvm::cast_or_null(
+
+syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
+  return llvm::cast_or_null(
   findChild(syntax::NodeRole::IdExpression_qualifier));
 }
 
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -609,35 +609,28 @@
   }
 
   syntax::NestedNameSpecifier *
-  BuildNestedNameSpecifier(NestedNameSpecifierLoc NNS) {
-if (!NNS)
+  BuildNestedNameSpecifier(NestedNameSpecifierLoc QualifierLoc) {
+if (!QualifierLoc)
   return nullptr;
-NestedNameSpecifierLoc it = NNS;
-while (it) {
-  auto *NS = new (allocator()) syntax::NameQualifier;
+for (auto it = QualifierLoc; it; it = it.getPrefix()) {
+  auto *NS = new (allocator()) syntax::NameSpecifier;
   Builder.foldNode(Builder.getRange(it.getLocalSourceRange()), NS, nullptr);
-  Builder.markChild(NS, syntax::NodeRole::Unknown);
-  it = it.getPrefix();
+  Builder.markChild(NS, syntax::NodeRole::NestedNameSpecifier_specifier);
 }
-syntax::NestedNameSpecifier *sNNS =
-new (allocator()) syntax::NestedNameSpecifier;
-Builder.foldNode(Builder.getRange(NNS.getSourceRange()), sNNS, nullptr);
-return sNNS;
+auto *NNS = new (allocator()) syntax::NestedNameSpecifier;
+Builder.foldNode(Builder.getRange(QualifierLoc.getSourceRange()), NNS,
+ nullptr);
+return NNS;
   }
 
   bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
-if (S->getNameInfo().getName().getNameKind() ==
-clang::DeclarationName::CXXOperatorName) {
-  return true;
-} else {
-  auto *sNNS = BuildNestedNameSpecifier(S->getQualifierLoc());
-  if (sNNS)
-Builder.markChild(sNNS,

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-09 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 269423.
eduucaldas added a comment.

nswering simple comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -485,7 +485,7 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
+| |-IdExpression
 | | `-a
 | |-)
 | `-EmptyStatement
@@ -662,7 +662,7 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-test
 | | |-(
 | | `-)
@@ -675,7 +675,7 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
+| | | |-IdExpression
 | | | | `-test
 | | | |-(
 | | | `-)
@@ -683,7 +683,7 @@
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
+|   | |-IdExpression
 |   | | `-test
 |   | |-(
 |   | `-)
@@ -692,6 +692,135 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test(int b) {
+  int a;
+  a = b;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-DeclarationStatement
+| |-SimpleDeclaration
+| | |-int
+| | `-SimpleDeclarator
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-IdExpression
+| | | `-a
+| | |-=
+| | `-IdExpression
+| |   `-b
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+namespace a {
+  namespace b {
+struct S {
+  int i;
+  static void f(){}
+};
+  }
+}
+void test(int b) {
+  ::a::b::S::f();
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-NamespaceDefinition
+| |-namespace
+| |-a
+| |-{
+| |-NamespaceDefinition
+| | |-namespace
+| | |-b
+| | |-{
+| | |-SimpleDeclaration
+| | | |-struct
+| | | |-S
+| | | |-{
+| | | |-SimpleDeclaration
+| | | | |-int
+| | | | |-SimpleDeclarator
+| | | | | `-i
+| | | | `-;
+| | | |-SimpleDeclaration
+| | | | |-static
+| | | | |-void
+| | | | |-SimpleDeclarator
+| | | | | |-f
+| | | | | `-ParametersAndQualifiers
+| | | | |   |-(
+| | | | |   `-)
+| | | | `-CompoundStatement
+| | | |   |-{
+| | | |   `-}
+| | | |-}
+| | | `-;
+| | `-}
+| `-}
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | |-NestedNameSpecifier
+| | | | |-NameSpecifier
+| | | | | `-::
+| | | | |-NameSpecifier
+| | | | | |-a
+| | | | | `-::
+| | | | |-NameSpecifier
+| | | | | |-b
+| | | | | `-::
+| | | | `-NameSpecifier
+| | | |   |-S
+| | | |   `-::
+| | | `-f
+| | |-(
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
 return;
@@ -889,13 +1018,13 @@
 |-{
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `-++
 | `-;
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `---
 | `-;
@@ -941,61 +1070,61 @@
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |---
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-++
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-~
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |--
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-+
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 |

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-09 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas marked 6 inline comments as done.
eduucaldas added inline comments.



Comment at: clang/lib/Tooling/Syntax/BuildTree.cpp:618
+  Builder.foldNode(Builder.getRange(it.getLocalSourceRange()), NS, 
nullptr);
+  Builder.markChild(NS, syntax::NodeRole::Unknown);
+}

gribozavr2 wrote:
> Do we need to mark the role if it is unknown?
> 
Thanks, that had slipped through, sorry for that


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

2020-06-08 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 269129.
eduucaldas added a comment.

cleanup for upstreaming


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

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
@@ -485,7 +485,7 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
+| |-IdExpression
 | | `-a
 | |-)
 | `-EmptyStatement
@@ -662,7 +662,7 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-test
 | | |-(
 | | `-)
@@ -675,7 +675,7 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
+| | | |-IdExpression
 | | | | `-test
 | | | |-(
 | | | `-)
@@ -683,7 +683,7 @@
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
+|   | |-IdExpression
 |   | | `-test
 |   | |-(
 |   | `-)
@@ -692,6 +692,135 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test(int b) {
+  int a;
+  a = b;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-DeclarationStatement
+| |-SimpleDeclaration
+| | |-int
+| | `-SimpleDeclarator
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-IdExpression
+| | | `-a
+| | |-=
+| | `-IdExpression
+| |   `-b
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+namespace a {
+  namespace b {
+struct S {
+  int i;
+  static void f(){}
+};
+  }
+}
+void test(int b) {
+  ::a::b::S::f();
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-NamespaceDefinition
+| |-namespace
+| |-a
+| |-{
+| |-NamespaceDefinition
+| | |-namespace
+| | |-b
+| | |-{
+| | |-SimpleDeclaration
+| | | |-struct
+| | | |-S
+| | | |-{
+| | | |-SimpleDeclaration
+| | | | |-int
+| | | | |-SimpleDeclarator
+| | | | | `-i
+| | | | `-;
+| | | |-SimpleDeclaration
+| | | | |-static
+| | | | |-void
+| | | | |-SimpleDeclarator
+| | | | | |-f
+| | | | | `-ParametersAndQualifiers
+| | | | |   |-(
+| | | | |   `-)
+| | | | `-CompoundStatement
+| | | |   |-{
+| | | |   `-}
+| | | |-}
+| | | `-;
+| | `-}
+| `-}
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | |-NestedNameSpecifier
+| | | | |-NameSpecifier
+| | | | | `-::
+| | | | |-NameSpecifier
+| | | | | |-a
+| | | | | `-::
+| | | | |-NameSpecifier
+| | | | | |-b
+| | | | | `-::
+| | | | `-NameSpecifier
+| | | |   |-S
+| | | |   `-::
+| | | `-f
+| | |-(
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
 return;
@@ -889,13 +1018,13 @@
 |-{
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `-++
 | `-;
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `---
 | `-;
@@ -941,61 +1070,61 @@
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |---
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-++
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-~
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |--
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-+
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 |

[PATCH] D81280: (Incomplete)Add support for id-expression

2020-06-08 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 269127.
eduucaldas added a comment.

Add support for DeclRefExpr in SyntaxTree, by generating IdExpression


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81280/new/

https://reviews.llvm.org/D81280

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
@@ -485,7 +485,7 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
+| |-IdExpression
 | | `-a
 | |-)
 | `-EmptyStatement
@@ -662,7 +662,7 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-test
 | | |-(
 | | `-)
@@ -675,7 +675,7 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
+| | | |-IdExpression
 | | | | `-test
 | | | |-(
 | | | `-)
@@ -683,7 +683,7 @@
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
+|   | |-IdExpression
 |   | | `-test
 |   | |-(
 |   | `-)
@@ -724,12 +724,10 @@
 |-ExpressionStatement
 | |-BinaryOperatorExpression
 | | |-IdExpression
-| | | `-UnqualifiedId
-| | |   `-a
+| | | `-a
 | | |-=
 | | `-IdExpression
-| |   `-UnqualifiedId
-| | `-b
+| |   `-b
 | `-;
 `-}
 )txt"));
@@ -800,38 +798,22 @@
   |   `-)
   `-CompoundStatement
 |-{
-|-DeclarationStatement
-| |-SimpleDeclaration
-| | |-a
-| | |-::
-| | |-b
-| | |-::
-| | |-S
-| | `-SimpleDeclarator
-| |   `-UnknownExpression
-| | `-s
-| `-;
 |-ExpressionStatement
 | |-UnknownExpression
 | | |-IdExpression
 | | | |-NestedNameSpecifier
-| | | | |-NameQualifier
-| | | | | |-GlobalNamespace
-| | | | | `::
-| | | | |-NameQualifier
-| | | | | |-NamespaceName
-| | | | | | `-a
+| | | | |-NameSpecifier
+| | | | | `-::
+| | | | |-NameSpecifier
+| | | | | |-a
 | | | | | `-::
-| | | | |-NameQualifier
-| | | | | |-NamespaceName
-| | | | | | `-b
+| | | | |-NameSpecifier
+| | | | | |-b
 | | | | | `-::
-| | | | `-NameQualifier
-| | | |   |-TypeName
-| | | |   | `-S
+| | | | `-NameSpecifier
+| | | |   |-S
 | | | |   `-::
-| | | `-UnqualifiedId
-| | |   `-f
+| | | `-f
 | | |-(
 | | `-)
 | `-;
@@ -1036,13 +1018,13 @@
 |-{
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `-++
 | `-;
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `---
 | `-;
@@ -1088,61 +1070,61 @@
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |---
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-++
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-~
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |--
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-+
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-&
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-*
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-ap
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-!
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-__real
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-__imag
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 `-}
@@ -1183,13 +1165,13 @@
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-compl
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 |

[PATCH] D81280: (Incomplete)Add support for id-expression

2020-06-05 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

- TODO: Differ between NameQualifiers
- TODO: Box all operators
- Done: Treat NestedNameSpecifiers
- Done: [Try] Unbox all operators


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81280

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
@@ -485,7 +485,7 @@
 | | |-SimpleDeclarator
 | | | `-x
 | | `-:
-| |-UnknownExpression
+| |-IdExpression
 | | `-a
 | |-)
 | `-EmptyStatement
@@ -662,7 +662,7 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-test
 | | |-(
 | | `-)
@@ -675,7 +675,7 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-UnknownExpression
+| | | |-IdExpression
 | | | | `-test
 | | | |-(
 | | | `-)
@@ -683,7 +683,7 @@
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-UnknownExpression
+|   | |-IdExpression
 |   | | `-test
 |   | |-(
 |   | `-)
@@ -724,12 +724,10 @@
 |-ExpressionStatement
 | |-BinaryOperatorExpression
 | | |-IdExpression
-| | | `-UnqualifiedId
-| | |   `-a
+| | | `-a
 | | |-=
 | | `-IdExpression
-| |   `-UnqualifiedId
-| | `-b
+| |   `-b
 | `-;
 `-}
 )txt"));
@@ -800,38 +798,22 @@
   |   `-)
   `-CompoundStatement
 |-{
-|-DeclarationStatement
-| |-SimpleDeclaration
-| | |-a
-| | |-::
-| | |-b
-| | |-::
-| | |-S
-| | `-SimpleDeclarator
-| |   `-UnknownExpression
-| | `-s
-| `-;
 |-ExpressionStatement
 | |-UnknownExpression
 | | |-IdExpression
 | | | |-NestedNameSpecifier
 | | | | |-NameQualifier
-| | | | | |-GlobalNamespace
-| | | | | `::
+| | | | | `-::
 | | | | |-NameQualifier
-| | | | | |-NamespaceName
-| | | | | | `-a
+| | | | | |-a
 | | | | | `-::
 | | | | |-NameQualifier
-| | | | | |-NamespaceName
-| | | | | | `-b
+| | | | | |-b
 | | | | | `-::
 | | | | `-NameQualifier
-| | | |   |-TypeName
-| | | |   | `-S
+| | | |   |-S
 | | | |   `-::
-| | | `-UnqualifiedId
-| | |   `-f
+| | | `-f
 | | |-(
 | | `-)
 | `-;
@@ -1036,13 +1018,13 @@
 |-{
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `-++
 | `-;
 |-ExpressionStatement
 | |-PostfixUnaryOperatorExpression
-| | |-UnknownExpression
+| | |-IdExpression
 | | | `-a
 | | `---
 | `-;
@@ -1088,61 +1070,61 @@
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |---
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-++
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-~
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |--
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-+
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-&
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-*
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-ap
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-!
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-__real
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-__imag
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 `-}
@@ -1183,13 +1165,13 @@
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-compl
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-a
 | `-;
 |-ExpressionStatement
 | |-PrefixUnaryOperatorExpression
 | | |-not
-| | `-UnknownExpression
+| | `-IdExpression
 | |   `-b

[PATCH] D81157: Propose naming principle for NodeRole and apply it

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268517.
eduucaldas added a comment.

`ArrowToken`, `ExternKeyword`


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81157/new/

https://reviews.llvm.org/D81157

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/BuildTree.cpp
  clang/lib/Tooling/Syntax/Nodes.cpp

Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -110,6 +110,8 @@
 return OS << "CloseParen";
   case syntax::NodeRole::IntroducerKeyword:
 return OS << "IntroducerKeyword";
+  case syntax::NodeRole::LiteralToken:
+return OS << "LiteralToken";
   case syntax::NodeRole::BodyStatement:
 return OS << "BodyStatement";
   case syntax::NodeRole::CaseStatement_value:
@@ -120,18 +122,12 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::IntegerLiteralExpression_literalToken:
-return OS << "IntegerLiteralExpression_literalToken";
-  case syntax::NodeRole::CxxNullPtrExpression_keyword:
-return OS << "CxxNullPtrExpression_keyword";
-  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
-return OS << "UnaryOperatorExpression_operatorToken";
+  case syntax::NodeRole::OperatorExpression_operatorToken:
+return OS << "OperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
 return OS << "UnaryOperatorExpression_operand";
   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
 return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_operatorToken:
-return OS << "BinaryOperatorExpression_operatorToken";
   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
 return OS << "BinaryOperatorExpression_rightHandSide";
   case syntax::NodeRole::ReturnStatement_value:
@@ -148,14 +144,14 @@
 return OS << "SimpleDeclaration_declarator";
   case syntax::NodeRole::TemplateDeclaration_declaration:
 return OS << "TemplateDeclaration_declaration";
-  case syntax::NodeRole::ExplicitTemplateInstantiation_externKeyword:
-return OS << "ExplicitTemplateInstantiation_externKeyword";
+  case syntax::NodeRole::ExternKeyword:
+return OS << "ExternKeyword";
   case syntax::NodeRole::ExplicitTemplateInstantiation_declaration:
 return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
 return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_arrow:
-return OS << "TrailingReturnType_arrow";
+  case syntax::NodeRole::ArrowToken:
+return OS << "ArrowToken";
   case syntax::NodeRole::TrailingReturnType_declarator:
 return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
@@ -168,12 +164,12 @@
 
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::IntegerLiteralExpression_literalToken));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
@@ -183,7 +179,7 @@
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::UnaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
@@ -193,7 +189,7 @@
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::BinaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
@@ -367,7 +363,7 @@
 
 syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::ExplicitTemplateInstantiation_externKeyword));
+  findChild(syntax::NodeRole::ExternKeyword));
 }
 
 syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
@@ -402,7 +398,7 @@
 
 syntax::Leaf *syntax::TrailingReturnType::arrow() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::TrailingReturnType_arrow));
+  findChild(syntax::NodeRole::ArrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
---

[PATCH] D81157: Propose naming principle for NodeRole and apply it

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268519.
eduucaldas added a comment.

fixed


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81157/new/

https://reviews.llvm.org/D81157

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/BuildTree.cpp
  clang/lib/Tooling/Syntax/Nodes.cpp

Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -110,6 +110,12 @@
 return OS << "CloseParen";
   case syntax::NodeRole::IntroducerKeyword:
 return OS << "IntroducerKeyword";
+  case syntax::NodeRole::LiteralToken:
+return OS << "LiteralToken";
+  case syntax::NodeRole::ArrowToken:
+return OS << "ArrowToken";
+  case syntax::NodeRole::ExternKeyword:
+return OS << "ExternKeyword";
   case syntax::NodeRole::BodyStatement:
 return OS << "BodyStatement";
   case syntax::NodeRole::CaseStatement_value:
@@ -120,18 +126,12 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::IntegerLiteralExpression_literalToken:
-return OS << "IntegerLiteralExpression_literalToken";
-  case syntax::NodeRole::CxxNullPtrExpression_keyword:
-return OS << "CxxNullPtrExpression_keyword";
-  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
-return OS << "UnaryOperatorExpression_operatorToken";
+  case syntax::NodeRole::OperatorExpression_operatorToken:
+return OS << "OperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
 return OS << "UnaryOperatorExpression_operand";
   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
 return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_operatorToken:
-return OS << "BinaryOperatorExpression_operatorToken";
   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
 return OS << "BinaryOperatorExpression_rightHandSide";
   case syntax::NodeRole::ReturnStatement_value:
@@ -148,14 +148,10 @@
 return OS << "SimpleDeclaration_declarator";
   case syntax::NodeRole::TemplateDeclaration_declaration:
 return OS << "TemplateDeclaration_declaration";
-  case syntax::NodeRole::ExplicitTemplateInstantiation_externKeyword:
-return OS << "ExplicitTemplateInstantiation_externKeyword";
   case syntax::NodeRole::ExplicitTemplateInstantiation_declaration:
 return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
 return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_arrow:
-return OS << "TrailingReturnType_arrow";
   case syntax::NodeRole::TrailingReturnType_declarator:
 return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
@@ -168,12 +164,12 @@
 
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::IntegerLiteralExpression_literalToken));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
@@ -183,7 +179,7 @@
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::UnaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
@@ -193,7 +189,7 @@
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::BinaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
@@ -367,7 +363,7 @@
 
 syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::ExplicitTemplateInstantiation_externKeyword));
+  findChild(syntax::NodeRole::ExternKeyword));
 }
 
 syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
@@ -402,7 +398,7 @@
 
 syntax::Leaf *syntax::TrailingReturnType::arrow() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::TrailingReturnType_arrow));
+  findChild(syntax::NodeRole::ArrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
---

[PATCH] D81157: Propose naming principle for NodeRole and apply it

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added inline comments.



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:94
 /// a binary expression'. Used for implementing accessors.
+// How to name NodeRole:
+// If the child node is a token/keyword, end its name with 'Token'/'Keyword'

gribozavr2 wrote:
> I'd suggest to make this into a doc comment, but phrase it in a way that is 
> useful for users, so that they can understand the pattern too. For example:
> 
> Some roles describe parent/child relations that occur multiple times in 
> language grammar. We define only one role to describe all instances of such 
> recurring relations. For example, grammar for both "if" and "while" 
> statements requires an opening paren and a closing paren. The opening paren 
> token is assigned the `OpenParen` role regardless of whether it appears as a 
> child of `IfStatement` or `WhileStatement` node. More generally, when grammar 
> requires a certain fixed token (like a specific keyword, or an opening 
> paren), we define a role for this token and use it across all grammar rules 
> with the same requirement. Names of such reusable roles end with a `~Token` 
> or a `~Keyword` suffix.
> 
> Some roles are assigned only to child nodes of one specific parent syntax 
> node type. Names of such roles start with the name of the parent syntax tree 
> node type. For example, a syntax node with a role 
> `BinaryOperatorExpression_leftHandSide` can only appear as a child of a 
> `BinaryOperatorExpression` node.
> 
> 
Thank you a lot. This is really well explained



Comment at: clang/include/clang/Tooling/Syntax/Nodes.h:124
   IfStatement_thenStatement,
   IfStatement_elseKeyword,
   IfStatement_elseStatement,

gribozavr2 wrote:
> Shouldn't `elseKeyword` have no prefix?
When a keyword can only be used by IfStatement, then I think it actually helps 
readability to have it prepended with the ParentKind. Here everything is nicely 
grouped, and if someone needs to change IfStatement, it is clear to see where 
to make the change.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81157/new/

https://reviews.llvm.org/D81157



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for id-expression in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:829
+| | | | | `-::
+| | | | `-TypeSpecifier
+| | | |   |-S

eduucaldas wrote:
> Perhaps we shouldn't differ between specifiers as that is semantical 
> information
Followed the [[ https://eel.is/c++draft/expr.prim.id.qual | grammar ]], but 
added specifier in the end as we also hold the `::` and not only the names


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81157: Propose naming principle for NodeRole and apply it

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268502.
eduucaldas marked 2 inline comments as done.
eduucaldas added a comment.

Fix cout, add explanation


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81157/new/

https://reviews.llvm.org/D81157

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/BuildTree.cpp
  clang/lib/Tooling/Syntax/Nodes.cpp

Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -110,6 +110,8 @@
 return OS << "CloseParen";
   case syntax::NodeRole::IntroducerKeyword:
 return OS << "IntroducerKeyword";
+  case syntax::NodeRole::LiteralToken:
+return OS << "LiteralToken";
   case syntax::NodeRole::BodyStatement:
 return OS << "BodyStatement";
   case syntax::NodeRole::CaseStatement_value:
@@ -120,18 +122,12 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::IntegerLiteralExpression_literalToken:
-return OS << "IntegerLiteralExpression_literalToken";
-  case syntax::NodeRole::CxxNullPtrExpression_keyword:
-return OS << "CxxNullPtrExpression_keyword";
-  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
-return OS << "UnaryOperatorExpression_operatorToken";
+  case syntax::NodeRole::OperatorExpression_operatorToken:
+return OS << "OperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
 return OS << "UnaryOperatorExpression_operand";
   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
 return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_operatorToken:
-return OS << "BinaryOperatorExpression_operatorToken";
   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
 return OS << "BinaryOperatorExpression_rightHandSide";
   case syntax::NodeRole::ReturnStatement_value:
@@ -154,8 +150,8 @@
 return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
 return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_arrow:
-return OS << "TrailingReturnType_arrow";
+  case syntax::NodeRole::TrailingReturnType_arrowToken:
+return OS << "TrailingReturnType_arrowToken";
   case syntax::NodeRole::TrailingReturnType_declarator:
 return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
@@ -168,12 +164,12 @@
 
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::IntegerLiteralExpression_literalToken));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
@@ -183,7 +179,7 @@
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::UnaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
@@ -193,7 +189,7 @@
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::BinaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
@@ -402,7 +398,7 @@
 
 syntax::Leaf *syntax::TrailingReturnType::arrow() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::TrailingReturnType_arrow));
+  findChild(syntax::NodeRole::TrailingReturnType_arrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -609,26 +609,22 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
-Builder.markChildToken(
-S->getLocation(),
-syntax::NodeRole::IntegerLiteralExpression_literalToken);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
 return true;
   }
 
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
-Builder.markChildToken(S->getLocation(),
-

[PATCH] D81168: Add support for id-expression in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268503.
eduucaldas marked an inline comment as done.
eduucaldas added a comment.

.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168

Files:
  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
@@ -692,6 +692,152 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test(int b) {
+  int a;
+  a = b;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-DeclarationStatement
+| |-SimpleDeclaration
+| | |-int
+| | `-SimpleDeclarator
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-a
+| | |-=
+| | `-IdExpression
+| |   `-UnqualifiedId
+| | `-b
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+namespace a {
+  namespace b {
+struct S {
+  int i;
+  static void f(){}
+};
+  }
+}
+void test(int b) {
+  ::a::b::S::f();
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-NamespaceDefinition
+| |-namespace
+| |-a
+| |-{
+| |-NamespaceDefinition
+| | |-namespace
+| | |-b
+| | |-{
+| | |-SimpleDeclaration
+| | | |-struct
+| | | |-S
+| | | |-{
+| | | |-SimpleDeclaration
+| | | | |-int
+| | | | |-SimpleDeclarator
+| | | | | `-i
+| | | | `-;
+| | | |-SimpleDeclaration
+| | | | |-static
+| | | | |-void
+| | | | |-SimpleDeclarator
+| | | | | |-f
+| | | | | `-ParametersAndQualifiers
+| | | | |   |-(
+| | | | |   `-)
+| | | | `-CompoundStatement
+| | | |   |-{
+| | | |   `-}
+| | | |-}
+| | | `-;
+| | `-}
+| `-}
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-DeclarationStatement
+| |-SimpleDeclaration
+| | |-a
+| | |-::
+| | |-b
+| | |-::
+| | |-S
+| | `-SimpleDeclarator
+| |   `-UnknownExpression
+| | `-s
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | |-NestedNameSpecifier
+| | | | |-GlobalNamespaceSpecifier
+| | | | | `::
+| | | | |-NamespaceNameSpecifier
+| | | | | |-a
+| | | | | `-::
+| | | | |-NamespaceNameSpecifier
+| | | | | |-b
+| | | | | `-::
+| | | | `-TypeNameSpecifier
+| | | |   |-S
+| | | |   `-::
+| | | `-UnqualifiedId
+| | |   `-f
+| | |-(
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
 return;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for id-expression in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added a subscriber: gribozavr2.
eduucaldas marked an inline comment as done.
eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:829
+| | | | | `-::
+| | | | `-TypeSpecifier
+| | | |   |-S

Perhaps we shouldn't differ between specifiers as that is semantical information


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81168/new/

https://reviews.llvm.org/D81168



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81168: Add support for id-expression in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a subscriber: gribozavr2.
eduucaldas marked an inline comment as done.
eduucaldas added inline comments.
eduucaldas marked an inline comment as not done.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:829
+| | | | | `-::
+| | | | `-TypeSpecifier
+| | | |   |-S

Perhaps we shouldn't differ between specifiers as that is semantical information


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81168

Files:
  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
@@ -692,6 +692,152 @@
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+void test(int b) {
+  int a;
+  a = b;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-DeclarationStatement
+| |-SimpleDeclaration
+| | |-int
+| | `-SimpleDeclarator
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-IdExpression
+| | | `-UnqualifiedId
+| | |   `-a
+| | |-=
+| | `-IdExpression
+| |   `-UnqualifiedId
+| | `-b
+| `-;
+`-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedId) {
+  if (!GetParam().isCXX()) {
+return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+  R"cpp(
+namespace a {
+  namespace b {
+struct S {
+  int i;
+  static void f(){}
+};
+  }
+}
+void test(int b) {
+  ::a::b::S::f();
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+|-NamespaceDefinition
+| |-namespace
+| |-a
+| |-{
+| |-NamespaceDefinition
+| | |-namespace
+| | |-b
+| | |-{
+| | |-SimpleDeclaration
+| | | |-struct
+| | | |-S
+| | | |-{
+| | | |-SimpleDeclaration
+| | | | |-int
+| | | | |-SimpleDeclarator
+| | | | | `-i
+| | | | `-;
+| | | |-SimpleDeclaration
+| | | | |-static
+| | | | |-void
+| | | | |-SimpleDeclarator
+| | | | | |-f
+| | | | | `-ParametersAndQualifiers
+| | | | |   |-(
+| | | | |   `-)
+| | | | `-CompoundStatement
+| | | |   |-{
+| | | |   `-}
+| | | |-}
+| | | `-;
+| | `-}
+| `-}
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-DeclarationStatement
+| |-SimpleDeclaration
+| | |-a
+| | |-::
+| | |-b
+| | |-::
+| | |-S
+| | `-SimpleDeclarator
+| |   `-UnknownExpression
+| | `-s
+| `-;
+|-ExpressionStatement
+| |-UnknownExpression
+| | |-IdExpression
+| | | |-NameSpecifiers
+| | | | |-GlobalNamespaceSpecifier
+| | | | | `::
+| | | | |-NamespaceSpecifier
+| | | | | |-a
+| | | | | `-::
+| | | | |-NamespaceSpecifier
+| | | | | |-b
+| | | | | `-::
+| | | | `-TypeSpecifier
+| | | |   |-S
+| | | |   `-::
+| | | `-UnqualifiedId
+| | |   `-f
+| | |-(
+| | `-)
+| `-;
+`-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
 return;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81157: Propose naming principle for NodeRole and apply it

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81157

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/BuildTree.cpp
  clang/lib/Tooling/Syntax/Nodes.cpp

Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -120,18 +120,14 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::IntegerLiteralExpression_literalToken:
+  case syntax::NodeRole::LiteralToken:
 return OS << "IntegerLiteralExpression_literalToken";
-  case syntax::NodeRole::CxxNullPtrExpression_keyword:
-return OS << "CxxNullPtrExpression_keyword";
-  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
-return OS << "UnaryOperatorExpression_operatorToken";
+  case syntax::NodeRole::OperatorExpression_operatorToken:
+return OS << "OperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
 return OS << "UnaryOperatorExpression_operand";
   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
 return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_operatorToken:
-return OS << "BinaryOperatorExpression_operatorToken";
   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
 return OS << "BinaryOperatorExpression_rightHandSide";
   case syntax::NodeRole::ReturnStatement_value:
@@ -154,8 +150,8 @@
 return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
 return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_arrow:
-return OS << "TrailingReturnType_arrow";
+  case syntax::NodeRole::TrailingReturnType_arrowToken:
+return OS << "TrailingReturnType_arrowToken";
   case syntax::NodeRole::TrailingReturnType_declarator:
 return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
@@ -168,12 +164,12 @@
 
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::IntegerLiteralExpression_literalToken));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
@@ -183,7 +179,7 @@
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::UnaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
@@ -193,7 +189,7 @@
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::BinaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
@@ -402,7 +398,7 @@
 
 syntax::Leaf *syntax::TrailingReturnType::arrow() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::TrailingReturnType_arrow));
+  findChild(syntax::NodeRole::TrailingReturnType_arrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -609,26 +609,22 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
-Builder.markChildToken(
-S->getLocation(),
-syntax::NodeRole::IntegerLiteralExpression_literalToken);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
 return true;
   }
 
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
-Builder.markChildToken(S->getLocation(),
-   syntax::NodeRole::CxxNullPtrExpression_keyword);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::CxxNullPtrExpression, S);
 return true;
   }
 
   bool WalkUpFromUnaryOperator(UnaryOperator *S) {
-Builder.markChildToken(
-S->getOperatorLoc(),
-

[PATCH] D81155: Rename arrow -> arrowToken for unified naming

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81155

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/Nodes.cpp


Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -400,7 +400,7 @@
   findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Leaf *syntax::TrailingReturnType::arrow() {
+syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::TrailingReturnType_arrow));
 }
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -639,7 +639,7 @@
 return N->kind() == NodeKind::TrailingReturnType;
   }
   // TODO: add accessors for specifiers.
-  syntax::Leaf *arrow();
+  syntax::Leaf *arrowToken();
   syntax::SimpleDeclarator *declarator();
 };
 


Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -400,7 +400,7 @@
   findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Leaf *syntax::TrailingReturnType::arrow() {
+syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::TrailingReturnType_arrow));
 }
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -639,7 +639,7 @@
 return N->kind() == NodeKind::TrailingReturnType;
   }
   // TODO: add accessors for specifiers.
-  syntax::Leaf *arrow();
+  syntax::Leaf *arrowToken();
   syntax::SimpleDeclarator *declarator();
 };
 
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D81135: Add support for IntegerLiteral in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268428.
eduucaldas marked 4 inline comments as done.
eduucaldas added a comment.

Fix nits


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81135/new/

https://reviews.llvm.org/D81135

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
@@ -64,6 +64,11 @@
Language == Lang_CXX17 || Language == Lang_CXX20;
   }
 
+  bool isCXX14OrLater() const {
+return Language == Lang_CXX14 || Language == Lang_CXX17 ||
+   Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -314,7 +319,7 @@
   |-SimpleDeclarator
   | |-b
   | |-=
-  | `-UnknownExpression
+  | `-IntegerLiteralExpression
   |   `-42
   `-;
 )txt");
@@ -371,7 +376,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -380,7 +385,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-CompoundStatement
@@ -390,7 +395,7 @@
 | `-IfStatement
 |   |-if
 |   |-(
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-0
 |   |-)
 |   `-CompoundStatement
@@ -461,7 +466,7 @@
 | |   |-a
 | |   `-ArraySubscript
 | | |-[
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-3
 | | `-]
 | `-;
@@ -501,7 +506,7 @@
 | | `-SimpleDeclarator
 | |   |-a
 | |   |-=
-| |   `-UnknownExpression
+| |   `-IntegerLiteralExpression
 | | `-10
 | `-;
 `-}
@@ -532,14 +537,14 @@
 |-SwitchStatement
 | |-switch
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
 |   |-{
 |   |-CaseStatement
 |   | |-case
-|   | |-UnknownExpression
+|   | |-IntegerLiteralExpression
 |   | | `-0
 |   | |-:
 |   | `-DefaultStatement
@@ -573,7 +578,7 @@
 |-WhileStatement
 | |-while
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -610,7 +615,7 @@
 | |-:
 | `-ReturnStatement
 |   |-return
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-100
 |   `-;
 `-}
@@ -648,7 +653,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-ExpressionStatement
@@ -699,6 +704,149 @@
 )txt");
 }
 
+TEST_P(SyntaxTreeTest, IntegerLiteral) {
+  expectTreeDumpEqual(
+  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;
+  }
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  12ll;
+  12ull;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-12ll
+| `-;
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-12ull
+| `-;
+`-}
+)txt");
+}
+
+TEST_P(SyntaxTreeTest, IntegerLiteralBinary) {
+  if (!GetParam().isCXX14OrLater()) {
+return;
+  }
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  0b1100;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-0b1100
+| `-;
+`-}

[PATCH] D81135: Add support for IntegerLiteral in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268420.
eduucaldas added a comment.

answering comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81135/new/

https://reviews.llvm.org/D81135

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
@@ -64,6 +64,11 @@
Language == Lang_CXX17 || Language == Lang_CXX20;
   }
 
+  bool isCXX14OrLater() const {
+return Language == Lang_CXX14 || Language == Lang_CXX17 ||
+   Language == Lang_CXX20;
+  }
+
   bool supportsCXXDynamicExceptionSpecification() const {
 return Language == Lang_CXX03 || Language == Lang_CXX11 ||
Language == Lang_CXX14;
@@ -314,7 +319,7 @@
   |-SimpleDeclarator
   | |-b
   | |-=
-  | `-UnknownExpression
+  | `-IntegerLiteralExpression
   |   `-42
   `-;
 )txt");
@@ -371,7 +376,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -380,7 +385,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-CompoundStatement
@@ -390,7 +395,7 @@
 | `-IfStatement
 |   |-if
 |   |-(
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-0
 |   |-)
 |   `-CompoundStatement
@@ -461,7 +466,7 @@
 | |   |-a
 | |   `-ArraySubscript
 | | |-[
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-3
 | | `-]
 | `-;
@@ -501,7 +506,7 @@
 | | `-SimpleDeclarator
 | |   |-a
 | |   |-=
-| |   `-UnknownExpression
+| |   `-IntegerLiteralExpression
 | | `-10
 | `-;
 `-}
@@ -532,14 +537,14 @@
 |-SwitchStatement
 | |-switch
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
 |   |-{
 |   |-CaseStatement
 |   | |-case
-|   | |-UnknownExpression
+|   | |-IntegerLiteralExpression
 |   | | `-0
 |   | |-:
 |   | `-DefaultStatement
@@ -573,7 +578,7 @@
 |-WhileStatement
 | |-while
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -610,7 +615,7 @@
 | |-:
 | `-ReturnStatement
 |   |-return
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-100
 |   `-;
 `-}
@@ -648,7 +653,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-ExpressionStatement
@@ -699,6 +704,149 @@
 )txt");
 }
 
+TEST_P(SyntaxTreeTest, IntegerLiteral) {
+  expectTreeDumpEqual(
+  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, LongLongLiteral) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  12ll;
+  12ull;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-12ll
+| `-;
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-12ull
+| `-;
+`-}
+)txt");
+}
+
+TEST_P(SyntaxTreeTest, BinaryLiteral) {
+  if (!GetParam().isCXX14OrLater()) {
+return;
+  }
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  0b1100;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-0b1100
+| `-;
+`-}
+)txt");
+}
+
+TEST_P(SyntaxTreeTest,

[PATCH] D81135: Add support for IntegerLiteral in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268403.
eduucaldas added a comment.

fix


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81135/new/

https://reviews.llvm.org/D81135

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
@@ -314,7 +314,7 @@
   |-SimpleDeclarator
   | |-b
   | |-=
-  | `-UnknownExpression
+  | `-IntegerLiteralExpression
   |   `-42
   `-;
 )txt");
@@ -371,7 +371,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -380,7 +380,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-CompoundStatement
@@ -390,7 +390,7 @@
 | `-IfStatement
 |   |-if
 |   |-(
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-0
 |   |-)
 |   `-CompoundStatement
@@ -461,7 +461,7 @@
 | |   |-a
 | |   `-ArraySubscript
 | | |-[
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-3
 | | `-]
 | `-;
@@ -501,7 +501,7 @@
 | | `-SimpleDeclarator
 | |   |-a
 | |   |-=
-| |   `-UnknownExpression
+| |   `-IntegerLiteralExpression
 | | `-10
 | `-;
 `-}
@@ -532,14 +532,14 @@
 |-SwitchStatement
 | |-switch
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
 |   |-{
 |   |-CaseStatement
 |   | |-case
-|   | |-UnknownExpression
+|   | |-IntegerLiteralExpression
 |   | | `-0
 |   | |-:
 |   | `-DefaultStatement
@@ -573,7 +573,7 @@
 |-WhileStatement
 | |-while
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -610,7 +610,7 @@
 | |-:
 | `-ReturnStatement
 |   |-return
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-100
 |   `-;
 `-}
@@ -648,7 +648,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-ExpressionStatement
@@ -699,6 +699,32 @@
 )txt");
 }
 
+TEST_P(SyntaxTreeTest, IntegerLiteralExpression) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  42;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-42
+| `-;
+`-}
+)txt");
+}
+
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
   expectTreeDumpEqual(
   R"cpp(
@@ -914,18 +940,18 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |--
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-==
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
@@ -933,7 +959,7 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-1
 | `-;
 |-ExpressionStatement
@@ -941,23 +967,23 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-<<=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-1
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-||
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-0
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-&
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
@@ -965,7 +991,7 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-^=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-3
 | `-;
 `-}
@@ -1018,10 +1044,10 @@
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-bitand
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression

[PATCH] D81135: Add support for IntegerLiteral in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268397.
eduucaldas added a comment.

answer comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81135/new/

https://reviews.llvm.org/D81135

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/BuildTree.cpp
  clang/lib/Tooling/Syntax/Nodes.cpp

Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -120,18 +120,14 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::IntegerLiteralExpression_literalToken:
+  case syntax::NodeRole::LiteralToken:
 return OS << "IntegerLiteralExpression_literalToken";
-  case syntax::NodeRole::CxxNullPtrExpression_keyword:
-return OS << "CxxNullPtrExpression_keyword";
-  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
-return OS << "UnaryOperatorExpression_operatorToken";
+  case syntax::NodeRole::OperatorExpression_operatorToken:
+return OS << "OperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
 return OS << "UnaryOperatorExpression_operand";
   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
 return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_operatorToken:
-return OS << "BinaryOperatorExpression_operatorToken";
   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
 return OS << "BinaryOperatorExpression_rightHandSide";
   case syntax::NodeRole::ReturnStatement_value:
@@ -154,8 +150,8 @@
 return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
 return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_arrow:
-return OS << "TrailingReturnType_arrow";
+  case syntax::NodeRole::TrailingReturnType_arrowToken:
+return OS << "TrailingReturnType_arrowToken";
   case syntax::NodeRole::TrailingReturnType_declarator:
 return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
@@ -168,12 +164,12 @@
 
 syntax::Leaf *syntax::IntegerLiteralExpression::literal() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::IntegerLiteralExpression_literalToken));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
@@ -183,7 +179,7 @@
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::UnaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
@@ -193,7 +189,7 @@
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::BinaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
@@ -402,7 +398,7 @@
 
 syntax::Leaf *syntax::TrailingReturnType::arrow() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::TrailingReturnType_arrow));
+  findChild(syntax::NodeRole::TrailingReturnType_arrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -609,26 +609,22 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
-Builder.markChildToken(
-S->getLocation(),
-syntax::NodeRole::IntegerLiteralExpression_literalToken);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
 return true;
   }
 
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
-Builder.markChildToken(S->getLocation(),
-   syntax::NodeRole::CxxNullPtrExpression_keyword);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::CxxNullPtrExpression, S);
 return true;
   }
 
   bool WalkUpFromUnaryOperator(UnaryOperator *S) {
-Builder.markChildToken(
-

[PATCH] D81136: Define rules for naming NodeRole and apply them.

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81136

Files:
  clang/include/clang/Tooling/Syntax/Nodes.h
  clang/lib/Tooling/Syntax/BuildTree.cpp
  clang/lib/Tooling/Syntax/Nodes.cpp

Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -120,18 +120,14 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::IntegerLiteralExpression_literalToken:
+  case syntax::NodeRole::LiteralToken:
 return OS << "IntegerLiteralExpression_literalToken";
-  case syntax::NodeRole::CxxNullPtrExpression_keyword:
-return OS << "CxxNullPtrExpression_keyword";
-  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
-return OS << "UnaryOperatorExpression_operatorToken";
+  case syntax::NodeRole::OperatorExpression_operatorToken:
+return OS << "OperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
 return OS << "UnaryOperatorExpression_operand";
   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
 return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_operatorToken:
-return OS << "BinaryOperatorExpression_operatorToken";
   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
 return OS << "BinaryOperatorExpression_rightHandSide";
   case syntax::NodeRole::ReturnStatement_value:
@@ -154,8 +150,8 @@
 return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
 return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_arrow:
-return OS << "TrailingReturnType_arrow";
+  case syntax::NodeRole::TrailingReturnType_arrowToken:
+return OS << "TrailingReturnType_arrowToken";
   case syntax::NodeRole::TrailingReturnType_declarator:
 return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
@@ -168,12 +164,12 @@
 
 syntax::Leaf *syntax::IntegerLiteralExpression::literal() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::IntegerLiteralExpression_literalToken));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+  findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
@@ -183,7 +179,7 @@
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::UnaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
@@ -193,7 +189,7 @@
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::BinaryOperatorExpression_operatorToken));
+  findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
@@ -402,7 +398,7 @@
 
 syntax::Leaf *syntax::TrailingReturnType::arrow() {
   return llvm::cast_or_null(
-  findChild(syntax::NodeRole::TrailingReturnType_arrow));
+  findChild(syntax::NodeRole::TrailingReturnType_arrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -609,26 +609,22 @@
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
-Builder.markChildToken(
-S->getLocation(),
-syntax::NodeRole::IntegerLiteralExpression_literalToken);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::IntegerLiteralExpression, S);
 return true;
   }
 
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
-Builder.markChildToken(S->getLocation(),
-   syntax::NodeRole::CxxNullPtrExpression_keyword);
+Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
 Builder.foldNode(Builder.getExprRange(S),
  new (allocator()) syntax::CxxNullPtrExpression, S);
 return true;
   }
 
   bool WalkUpFromUnaryOperator(UnaryOperator *S) {
-Builder.markChildToken(
-S->getOperatorLoc(),
-

[PATCH] D81135: Add support for IntegerLiteral in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas updated this revision to Diff 268382.
eduucaldas added a comment.

Add support for IntegerLiteral in SyntaxTree


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81135/new/

https://reviews.llvm.org/D81135

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
@@ -314,7 +314,7 @@
   |-SimpleDeclarator
   | |-b
   | |-=
-  | `-UnknownExpression
+  | `-IntegerLiteralExpression
   |   `-42
   `-;
 )txt");
@@ -371,7 +371,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -380,7 +380,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-CompoundStatement
@@ -390,7 +390,7 @@
 | `-IfStatement
 |   |-if
 |   |-(
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-0
 |   |-)
 |   `-CompoundStatement
@@ -461,7 +461,7 @@
 | |   |-a
 | |   `-ArraySubscript
 | | |-[
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-3
 | | `-]
 | `-;
@@ -501,7 +501,7 @@
 | | `-SimpleDeclarator
 | |   |-a
 | |   |-=
-| |   `-UnknownExpression
+| |   `-IntegerLiteralExpression
 | | `-10
 | `-;
 `-}
@@ -532,14 +532,14 @@
 |-SwitchStatement
 | |-switch
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
 |   |-{
 |   |-CaseStatement
 |   | |-case
-|   | |-UnknownExpression
+|   | |-IntegerLiteralExpression
 |   | | `-0
 |   | |-:
 |   | `-DefaultStatement
@@ -573,7 +573,7 @@
 |-WhileStatement
 | |-while
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -610,7 +610,7 @@
 | |-:
 | `-ReturnStatement
 |   |-return
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-100
 |   `-;
 `-}
@@ -648,7 +648,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-ExpressionStatement
@@ -699,6 +699,32 @@
 )txt");
 }
 
+TEST_P(SyntaxTreeTest, IntegerLiteralExpression) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  42;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-42
+| `-;
+`-}
+)txt");
+}
+
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
   expectTreeDumpEqual(
   R"cpp(
@@ -914,18 +940,18 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |--
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-==
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
@@ -933,7 +959,7 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-1
 | `-;
 |-ExpressionStatement
@@ -941,23 +967,23 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-<<=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-1
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-||
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-0
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-&
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
@@ -965,7 +991,7 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-^=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-3
 | `-;
 `-}
@@ -1018,10 +1044,10 @@
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-bitand
-| |

[PATCH] D81135: Add support for IntegerLiteral in SyntaxTree

2020-06-04 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81135

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
@@ -314,7 +314,7 @@
   |-SimpleDeclarator
   | |-b
   | |-=
-  | `-UnknownExpression
+  | `-IntegerLiteralExpression
   |   `-42
   `-;
 )txt");
@@ -371,7 +371,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -380,7 +380,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-CompoundStatement
@@ -390,7 +390,7 @@
 | `-IfStatement
 |   |-if
 |   |-(
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-0
 |   |-)
 |   `-CompoundStatement
@@ -461,7 +461,7 @@
 | |   |-a
 | |   `-ArraySubscript
 | | |-[
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-3
 | | `-]
 | `-;
@@ -501,7 +501,7 @@
 | | `-SimpleDeclarator
 | |   |-a
 | |   |-=
-| |   `-UnknownExpression
+| |   `-IntegerLiteralExpression
 | | `-10
 | `-;
 `-}
@@ -532,14 +532,14 @@
 |-SwitchStatement
 | |-switch
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
 |   |-{
 |   |-CaseStatement
 |   | |-case
-|   | |-UnknownExpression
+|   | |-IntegerLiteralExpression
 |   | | `-0
 |   | |-:
 |   | `-DefaultStatement
@@ -573,7 +573,7 @@
 |-WhileStatement
 | |-while
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | `-CompoundStatement
@@ -610,7 +610,7 @@
 | |-:
 | `-ReturnStatement
 |   |-return
-|   |-UnknownExpression
+|   |-IntegerLiteralExpression
 |   | `-100
 |   `-;
 `-}
@@ -648,7 +648,7 @@
 |-IfStatement
 | |-if
 | |-(
-| |-UnknownExpression
+| |-IntegerLiteralExpression
 | | `-1
 | |-)
 | |-ExpressionStatement
@@ -699,6 +699,32 @@
 )txt");
 }
 
+TEST_P(SyntaxTreeTest, IntegerLiteralExpression) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  42;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-IntegerLiteralExpression
+| | `-42
+| `-;
+`-}
+)txt");
+}
+
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
   expectTreeDumpEqual(
   R"cpp(
@@ -914,18 +940,18 @@
 |-{
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |--
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-==
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
@@ -933,7 +959,7 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-1
 | `-;
 |-ExpressionStatement
@@ -941,23 +967,23 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-<<=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-1
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-||
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-0
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-&
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;
 |-ExpressionStatement
@@ -965,7 +991,7 @@
 | | |-UnknownExpression
 | | | `-a
 | | |-^=
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-3
 | `-;
 `-}
@@ -1018,10 +1044,10 @@
 | `-;
 |-ExpressionStatement
 | |-BinaryOperatorExpression
-| | |-UnknownExpression
+| | |-IntegerLiteralExpression
 | | | `-1
 | | |-bitand
-| | `-UnknownExpression
+| | `-IntegerLiteralExpression
 | |   `-2
 | `-;

[PATCH] D81092: Add support for `nullptr` in SyntaxTrees

2020-06-03 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D81092

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
@@ -670,6 +670,35 @@
 )txt");
 }
 
+TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
+  if (!GetParam().isCXX11OrLater()) {
+return;
+  }
+  expectTreeDumpEqual(
+  R"cpp(
+void test() {
+  nullptr;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-CxxNullPtrExpression
+| | `-nullptr
+| `-;
+`-}
+)txt");
+}
+
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
   expectTreeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -18,6 +18,8 @@
 return OS << "TranslationUnit";
   case NodeKind::UnknownExpression:
 return OS << "UnknownExpression";
+  case NodeKind::CxxNullPtrExpression:
+return OS << "CxxNullPtrExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
 return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
@@ -116,6 +118,8 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
+  case syntax::NodeRole::CxxNullPtrExpression_keyword:
+return OS << "CxxNullPtrExpression_keyword";
   case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
 return OS << "UnaryOperatorExpression_operatorToken";
   case syntax::NodeRole::UnaryOperatorExpression_operand:
@@ -158,6 +162,11 @@
   llvm_unreachable("invalid role");
 }
 
+syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
+  return llvm::cast_or_null(
+  findChild(syntax::NodeRole::CxxNullPtrExpression_keyword));
+}
+
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
   return llvm::cast_or_null(
   findChild(syntax::NodeRole::BinaryOperatorExpression_leftHandSide));
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -608,6 +608,14 @@
 return true;
   }
 
+  bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
+Builder.markChildToken(S->getLocation(),
+   syntax::NodeRole::CxxNullPtrExpression_keyword);
+Builder.foldNode(Builder.getExprRange(S),
+ new (allocator()) syntax::CxxNullPtrExpression, S);
+return true;
+  }
+
   bool WalkUpFromUnaryOperator(UnaryOperator *S) {
 Builder.markChildToken(
 S->getOperatorLoc(),
Index: clang/include/clang/Tooling/Syntax/Nodes.h
===
--- clang/include/clang/Tooling/Syntax/Nodes.h
+++ clang/include/clang/Tooling/Syntax/Nodes.h
@@ -43,6 +43,7 @@
   PrefixUnaryOperatorExpression,
   PostfixUnaryOperatorExpression,
   BinaryOperatorExpression,
+  CxxNullPtrExpression,
 
   // Statements.
   UnknownStatement,
@@ -112,6 +113,7 @@
   BinaryOperatorExpression_leftHandSide,
   BinaryOperatorExpression_operatorToken,
   BinaryOperatorExpression_rightHandSide,
+  CxxNullPtrExpression_keyword,
   CaseStatement_value,
   IfStatement_thenStatement,
   IfStatement_elseKeyword,
@@ -166,6 +168,16 @@
   }
 };
 
+/// C++11 'nullptr' expression.
+class CxxNullPtrExpression final : public Expression {
+public:
+  CxxNullPtrExpression() : Expression(NodeKind::CxxNullPtrExpression) {}
+  static bool classof(const Node *N) {
+return N->kind() == NodeKind::CxxNullPtrExpression;
+  }
+  syntax::Leaf *nullPtrKeyword();
+};
+
 /// 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

[PATCH] D81019: Syntax tree: ignore implicit expressions at the top level of statements

2020-06-03 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas accepted this revision.
eduucaldas added inline comments.



Comment at: clang/lib/Tooling/Syntax/BuildTree.cpp:1048
+  syntax::Tree *ChildNode;
+  if (Expr *ChildExpr = dyn_cast(Child)) {
+// This is an expression in a statement position, consume the trailing

I thought this treatement of derived class should be done by 
RecursiveASTVisitor 
This is kinda the task of WalkUpFrom*, unfortunately WalkUpFromThis follows the 
order:
WalkUpFromBase;
VisitThis;

And we would've wanted the opposite order:
VisitThis
WalkUpFromBase



Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D81019/new/

https://reviews.llvm.org/D81019



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D80822: Run syntax tree tests in many language modes

2020-06-02 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas added inline comments.



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:54-63
+  bool isCXX() const {
+return Language == Lang_CXX || Language == Lang_CXX11 ||
+   Language == Lang_CXX14 || Language == Lang_CXX17 ||
+   Language == Lang_CXX2a;
+  }
+
+  bool isCXX11OrLater() const {

These could be on the clang/Testing



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:181
+
+Invocation = createInvocationFromCommandLine(ArgsCStr, Diags, FS);
 assert(Invocation);

Note: This already adds -fsyntax-only as a flag



Comment at: clang/unittests/Tooling/Syntax/TreeTest.cpp:206
   void expectTreeDumpEqual(StringRef Code, StringRef Tree,
bool RunWithDelayedTemplateParsing = true) {
+SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));

is RunWithDelayedTemplateParsing being used?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D80822/new/

https://reviews.llvm.org/D80822



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D80812: Add support for Overloaded Binary Operators in SyntaxTree

2020-05-29 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D80812

Files:
  clang/lib/Tooling/Syntax/BuildTree.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
@@ -993,6 +993,134 @@
 )txt");
 }
 
+TEST_F(SyntaxTreeTest, UserDefinedBinaryOperator) {
+  expectTreeDumpEqual(
+  R"cpp(
+struct X {
+  X& operator=(const X&);
+  friend X operator+(X, const X&);
+  friend bool operator<(const X&, const X&);
+};
+void test(X x, X y) {
+  x = y;
+  x + y;
+  x < y;
+}
+  )cpp",
+  R"txt(
+*: TranslationUnit
+|-SimpleDeclaration
+| |-struct
+| |-X
+| |-{
+| |-SimpleDeclaration
+| | |-X
+| | |-SimpleDeclarator
+| | | |-&
+| | | |-operator
+| | | |-=
+| | | `-ParametersAndQualifiers
+| | |   |-(
+| | |   |-SimpleDeclaration
+| | |   | |-const
+| | |   | |-X
+| | |   | `-SimpleDeclarator
+| | |   |   `-&
+| | |   `-)
+| | `-;
+| |-UnknownDeclaration
+| | `-SimpleDeclaration
+| |   |-friend
+| |   |-X
+| |   |-SimpleDeclarator
+| |   | |-operator
+| |   | |-+
+| |   | `-ParametersAndQualifiers
+| |   |   |-(
+| |   |   |-SimpleDeclaration
+| |   |   | `-X
+| |   |   |-,
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   `-)
+| |   `-;
+| |-UnknownDeclaration
+| | `-SimpleDeclaration
+| |   |-friend
+| |   |-bool
+| |   |-SimpleDeclarator
+| |   | |-operator
+| |   | |-<
+| |   | `-ParametersAndQualifiers
+| |   |   |-(
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   |-,
+| |   |   |-SimpleDeclaration
+| |   |   | |-const
+| |   |   | |-X
+| |   |   | `-SimpleDeclarator
+| |   |   |   `-&
+| |   |   `-)
+| |   `-;
+| |-}
+| `-;
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-x
+  |   |-,
+  |   |-SimpleDeclaration
+  |   | |-X
+  |   | `-SimpleDeclarator
+  |   |   `-y
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-x
+| | |-UnknownExpression
+| | | `-=
+| | `-UnknownExpression
+| |   `-y
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-UnknownExpression
+| | |   `-x
+| | |-UnknownExpression
+| | | `-+
+| | `-UnknownExpression
+| |   `-y
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-x
+| | |-UnknownExpression
+| | | `-<
+| | `-UnknownExpression
+| |   `-y
+| `-;
+`-}
+)txt");
+}
+
 TEST_F(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   expectTreeDumpEqual(
   R"cpp(
Index: clang/lib/Tooling/Syntax/BuildTree.cpp
===
--- clang/lib/Tooling/Syntax/BuildTree.cpp
+++ clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -640,6 +640,24 @@
 return true;
   }
 
+  bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
+if (S->isInfixBinaryOp()) {
+  Builder.markExprChild(
+  S->getArg(0),
+  syntax::NodeRole::BinaryOperatorExpression_leftHandSide);
+  Builder.markChildToken(
+  S->getOperatorLoc(),
+  syntax::NodeRole::BinaryOperatorExpression_operatorToken);
+  Builder.markExprChild(
+  S->getArg(1),
+  syntax::NodeRole::BinaryOperatorExpression_rightHandSide);
+  Builder.foldNode(Builder.getExprRange(S),
+   new (allocator()) syntax::BinaryOperatorExpression, S);
+  return true;
+}
+return RecursiveASTVisitor::WalkUpFromCXXOperatorCallExpr(S);
+  }
+
   bool WalkUpFromNamespaceDecl(NamespaceDecl *S) {
 auto Tokens = Builder.getDeclarationRange(S);
 if (Tokens.front().kind() == tok::coloncolon) {
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D80731: Improve test infrastructure in SyntaxTree

2020-05-28 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

- Test if the code sourcing the SyntaxTree compiles
- Output compiler errors and warnings to err
- Fix tests with code that did not compile


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D80731

Files:
  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
@@ -15,6 +15,7 @@
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendAction.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Syntax/BuildTree.h"
@@ -97,8 +98,12 @@
 
 constexpr const char *FileName = "./input.cpp";
 FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
+
 if (!Diags->getClient())
-  Diags->setClient(new IgnoringDiagConsumer);
+  Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), DiagOpts.get()));
+Diags->setSeverityForGroup(diag::Flavor::WarningOrError, "unused-value",
+   diag::Severity::Ignored, SourceLocation());
+
 // Prepare to run a compiler.
 std::vector Args = {
 "syntax-test", "-target",   Target.c_str(),
@@ -117,7 +122,11 @@
 
 syntax::TranslationUnit *Root = nullptr;
 BuildSyntaxTreeAction Recorder(Root, this->Arena);
-if (!Compiler.ExecuteAction(Recorder)) {
+
+// Action could not be executed but the frontend didn't identify any errors
+// in the code ==> problem in setting up the action
+if (!Compiler.ExecuteAction(Recorder) &&
+Diags->getClient()->getNumErrors() == 0) {
   ADD_FAILURE() << "failed to run the frontend";
   std::abort();
 }
@@ -143,6 +152,8 @@
 continue;
   }
   auto *Root = buildTree(Code, Target);
+  EXPECT_EQ(Diags->getClient()->getNumErrors(), 0u)
+  << "Source file has syntax errors, they were printed to the test log";
   std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
   EXPECT_EQ(Expected, Actual)
   << "for target " << Target << " the resulting dump is:\n"
@@ -180,8 +191,10 @@
   }
 
   // Data fields.
+  llvm::IntrusiveRefCntPtr DiagOpts =
+  new DiagnosticOptions();
   llvm::IntrusiveRefCntPtr Diags =
-  new DiagnosticsEngine(new DiagnosticIDs, new DiagnosticOptions);
+  new DiagnosticsEngine(new DiagnosticIDs, DiagOpts.get());
   IntrusiveRefCntPtr FS =
   new llvm::vfs::InMemoryFileSystem;
   llvm::IntrusiveRefCntPtr FileMgr =
@@ -517,11 +530,11 @@
   // Unhandled statements should end up as 'unknown statement'.
   // This example uses a 'label statement', which does not yet have a syntax
   // counterpart.
-  expectTreeDumpEqual("void main() { foo: return 100; }",
+  expectTreeDumpEqual("int main() { foo: return 100; }",
   R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
-  |-void
+  |-int
   |-SimpleDeclarator
   | |-main
   | `-ParametersAndQualifiers
@@ -1166,7 +1179,7 @@
   // Free-standing classes, must live inside a SimpleDeclaration.
   expectTreeDumpEqual(
   R"cpp(
-sturct X;
+struct X;
 struct X {};
 
 struct Y *y1;
@@ -1177,7 +1190,7 @@
   R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
-| |-sturct
+| |-struct
 | |-X
 | `-;
 |-SimpleDeclaration
@@ -1660,7 +1673,7 @@
 int a[10];
 int b[1][2][3];
 int c[] = {1,2,3};
-void f(int xs[static 10]);
+// void f(int xs[static 10]);
 )cpp",
   R"txt(
 *: TranslationUnit
@@ -1694,163 +1707,146 @@
 | |   | `-3
 | |   `-]
 | `-;
-|-SimpleDeclaration
-| |-int
-| |-SimpleDeclarator
-| | |-c
-| | |-ArraySubscript
-| | | |-[
-| | | `-]
-| | |-=
-| | `-UnknownExpression
-| |   `-UnknownExpression
-| | |-{
-| | |-UnknownExpression
-| | | `-1
-| | |-,
-| | |-UnknownExpression
-| | | `-2
-| | |-,
-| | |-UnknownExpression
-| | | `-3
-| | `-}
-| `-;
 `-SimpleDeclaration
-  |-void
+  |-int
   |-SimpleDeclarator
-  | |-f
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   |-xs
-  |   |   `-ArraySubscript
-  |   | |-[
-  |   | |-static
-  |   | |-UnknownExpression
-  |   | | `-10
-  |   | `-]
-  |   `-)
-  `-;
-   )txt");
+  | |-c
+  | |-ArraySubscript
+  | | |-[
+  | | `-]
+  | |-=
+  | `-UnknownExpression
+  |   `-UnknownExpression
+  | |-{
+  | |-UnknownExpression
+  | | `-1
+  | |-,
+  | |-UnknownExpression
+  | | `-2
+  | |-,
+  | |-UnknownExpression
+  | | `-3
+  | `-}
+  `-;   )txt");
 }
 
 TEST_F(SyntaxTreeTest, ParameterListsInDeclarators) {

[PATCH] D80624: Add support for UnaryOperator in SyntaxTree

2020-05-27 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.
gribozavr2 accepted this revision.
This revision is now accepted and ready to land.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D80624

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
@@ -594,6 +594,161 @@
 )txt");
 }
 
+TEST_F(SyntaxTreeTest, PostfixUnaryOperator) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test(int a) {
+  a++;
+  a--;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-a
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-PostfixUnaryOperatorExpression
+| | |-UnknownExpression
+| | | `-a
+| | `-++
+| `-;
+|-ExpressionStatement
+| |-PostfixUnaryOperatorExpression
+| | |-UnknownExpression
+| | | `-a
+| | `---
+| `-;
+`-}
+)txt");
+}
+
+TEST_F(SyntaxTreeTest, PrefixUnaryOperator) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test(int a, int *ap, bool b) {
+  --a; ++a;
+  ~a; compl a;
+  -a;
+  +a;
+  
+  *ap;
+  !b; not b;
+  __real a; __imag a;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-a
+  |   |-,
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   |-*
+  |   |   `-ap
+  |   |-,
+  |   |-SimpleDeclaration
+  |   | |-bool
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |---
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-++
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-~
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-compl
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |--
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-+
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-&
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-*
+| | `-UnknownExpression
+| |   `-ap
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-!
+| | `-UnknownExpression
+| |   `-b
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-not
+| | `-UnknownExpression
+| |   `-b
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-__real
+| | `-UnknownExpression
+| |   `-a
+| `-;
+|-ExpressionStatement
+| |-PrefixUnaryOperatorExpression
+| | |-__imag
+| | `-UnknownExpression
+| |   `-a
+| `-;
+`-}
+)txt");
+}
+
 TEST_F(SyntaxTreeTest, BinaryOperator) {
   expectTreeDumpEqual(
   R"cpp(
@@ -1866,7 +2021,7 @@
 | |-SimpleDeclarator
 | | |-west
 | | |-=
-| | `-UnknownExpression
+| | `-PrefixUnaryOperatorExpression
 | |   |--
 | |   `-UnknownExpression
 | | `-1
Index: clang/lib/Tooling/Syntax/Nodes.cpp
===
--- clang/lib/Tooling/Syntax/Nodes.cpp
+++ clang/lib/Tooling/Syntax/Nodes.cpp
@@ -18,6 +18,10 @@
 return OS << "TranslationUnit";
   case NodeKind::UnknownExpression:
 return OS << "UnknownExpression";
+  case NodeKind::PrefixUnaryOperatorExpression:
+return OS << "PrefixUnaryOperatorExpression";
+  case NodeKind::PostfixUnaryOperatorExpression:
+return OS << "PostfixUnaryOperatorExpression";
   case NodeKind::BinaryOperatorExpression:
 return OS << "BinaryOperatorExpression";
   case NodeKind::UnknownStatement:
@@ -112,6 +116,10 @@
 return OS << "IfStatement_elseKeyword";
   case syntax::NodeRole::IfStatement_elseStatement:
 return OS << "IfStatement_elseStatement";
+  case syntax::NodeRole::UnaryOperatorExpression_operatorToken:
+return OS << "UnaryOperatorExpression_operatorToken";
+  case

[PATCH] D80540: Add support for binary operators in Syntax Trees

2020-05-26 Thread Eduardo Caldas via Phabricator via cfe-commits

eduucaldas created this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
eduucaldas added a reviewer: gribozavr2.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D80540

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
@@ -564,7 +564,8 @@
 |-{
 |-ExpressionStatement
 | |-UnknownExpression
-| | |-test
+| | |-UnknownExpression
+| | | `-test
 | | |-(
 | | `-)
 | `-;
@@ -576,14 +577,16 @@
 | |-)
 | |-ExpressionStatement
 | | |-UnknownExpression
-| | | |-test
+| | | |-UnknownExpression
+| | | | `-test
 | | | |-(
 | | | `-)
 | | `-;
 | |-else
 | `-ExpressionStatement
 |   |-UnknownExpression
-|   | |-test
+|   | |-UnknownExpression
+|   | | `-test
 |   | |-(
 |   | `-)
 |   `-;
@@ -591,6 +594,237 @@
 )txt");
 }
 
+TEST_F(SyntaxTreeTest, BinaryOperator) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test(int a) {
+  1 - 2;
+  1 == 2;
+  a = 1;
+  a <<= 1;
+
+  true || false;
+  true or false;
+
+  1 & 2;
+  1 bitand 2;
+
+  a ^= 3;
+  a xor_eq 3;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-a
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-1
+| | |--
+| | `-UnknownExpression
+| |   `-2
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-1
+| | |-==
+| | `-UnknownExpression
+| |   `-2
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-a
+| | |-=
+| | `-UnknownExpression
+| |   `-1
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-a
+| | |-<<=
+| | `-UnknownExpression
+| |   `-1
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-true
+| | |-||
+| | `-UnknownExpression
+| |   `-false
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-true
+| | |-or
+| | `-UnknownExpression
+| |   `-false
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-1
+| | |-&
+| | `-UnknownExpression
+| |   `-2
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-1
+| | |-bitand
+| | `-UnknownExpression
+| |   `-2
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-a
+| | |-^=
+| | `-UnknownExpression
+| |   `-3
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | `-a
+| | |-xor_eq
+| | `-UnknownExpression
+| |   `-3
+| `-;
+`-}
+)txt");
+}
+
+TEST_F(SyntaxTreeTest, NestedBinaryOperator) {
+  expectTreeDumpEqual(
+  R"cpp(
+void test(int a, int b) {
+  (1 + 2) * (4 / 2);
+  a + b + 42;
+  a = b = 42;
+  a + b * 4 + 2;
+  a % 2 + b * 42;
+}
+)cpp",
+  R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-a
+  |   |-,
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+|-{
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| | | |-(
+| | | |-BinaryOperatorExpression
+| | | | |-UnknownExpression
+| | | | | `-1
+| | | | |-+
+| | | | `-UnknownExpression
+| | | |   `-2
+| | | `-)
+| | |-*
+| | `-UnknownExpression
+| |   |-(
+| |   |-BinaryOperatorExpression
+| |   | |-UnknownExpression
+| |   | | `-4
+| |   | |-/
+| |   | `-UnknownExpression
+| |   |   `-2
+| |   `-)
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-BinaryOperatorExpression
+| | | |-UnknownExpression
+| | | | `-a
+| | | |-+
+| | | `-UnknownExpression
+| | |   `-b
+| | |-+
+| | `-UnknownExpression
+| |   `-42
+| `-;
+|-ExpressionStatement
+| |-BinaryOperatorExpression
+| | |-UnknownExpression
+| |

< 1 2 3 4 5

401 - 480 of 480 matches

Mail list logo