[SyntaxTree] Unbox operators into tokens for nodes generated from `CXXOperatorCallExpr`

[eduucaldas]

Summary

For an user define <, x < y would yield the syntax tree:

BinaryOperatorExpression
|-IdExpression
| `-UnqualifiedId
|   `-x
|-IdExpression
| `-UnqualifiedId
|   `-<
`-IdExpression
  `-UnqualifiedId
    `-y

But there is no syntatic difference at call site between call site or
built-in <. As such they should generate the same syntax tree, namely:

BinaryOperatorExpression
|-IdExpression
| `-UnqualifiedId
|   `-x
|-<
`-IdExpression
  `-UnqualifiedId
    `-y

[eduucaldas]

Add explanation comments

[eduucaldas]

clang/lib/Tooling/Syntax/BuildTree.cpp

1025

Here we want to check if this child is just a DeclRefExpr to an operator - as opposed to an operand.
Is comparing SourceLocation generally safe?
Is there a better way of figuring out if the child DeclRefExpr refers to an operator?

[gribozavr2]

clang/lib/Tooling/Syntax/BuildTree.cpp

1017–1018

1023–1029

[gribozavr2]

clang/lib/Tooling/Syntax/BuildTree.cpp

1025

Comparing SourceLocations should work, but you're right that it is a questionable pattern.

Iterating only over S->arguments() instead of all children could work here.

[eduucaldas]

use arguments instead of children

clang/lib/Tooling/Syntax/BuildTree.cpp

1025

Very good tip!

clang/lib/Tooling/Syntax/BuildTree.cpp

 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #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/StmtIterator.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeLocVisitor.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Lexer.h"
bool WalkUpFromBinaryOperator(BinaryOperator *S) {
     Builder.markExprChild(
         S->getRHS(), syntax::NodeRole::BinaryOperatorExpression_rightHandSide);
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::BinaryOperatorExpression, S);
     return true;
   }
 
   bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
-    if (getOperatorNodeKind(*S) ==
-        syntax::NodeKind::PostfixUnaryOperatorExpression) {
+    for (auto *child : S->children()) {
       // A postfix unary operator is declared as taking two operands. The
       // second operand is used to distinguish from its prefix counterpart. In
       // the semantic AST this "phantom" operand is represented as a
       // `IntegerLiteral` with invalid `SourceLocation`. We skip visiting this
       // operand because it does not correspond to anything written in source
       // code
-      for (auto *child : S->children()) {
-        if (child->getSourceRange().isInvalid())
-          continue;
-        if (!TraverseStmt(child))
-          return false;
-      }
-      return WalkUpFromCXXOperatorCallExpr(S);
-    } else
-      return RecursiveASTVisitor::TraverseCXXOperatorCallExpr(S);
+      if (child->getSourceRange().isInvalid()) {
+        assert(getOperatorNodeKind(*S) ==
+               syntax::NodeKind::PostfixUnaryOperatorExpression);
+        continue;
+      }
+      if (child->getBeginLoc() == S->getOperatorLoc())
   }
 
   bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
     switch (getOperatorNodeKind(*S)) {
     case syntax::NodeKind::BinaryOperatorExpression:
       Builder.markExprChild(
           S->getArg(0),
           syntax::NodeRole::BinaryOperatorExpression_leftHandSide);
       Builder.markChildToken(

clang/unittests/Tooling/Syntax/TreeTest.cpp

`-SimpleDeclaration
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-=
+    | | |-=
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-UnknownExpression
     | | | `-IdExpression
     | | |   `-UnqualifiedId
     | | |     `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-+
+    | | |-+
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-<
+    | | |-<
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-<<
+    | | |-<<
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-,
+    | | |-,
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
`-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-++
+    | | |-++
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-x
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-!
+    | | |-!
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-x
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-&
+    | | |-&
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-x
     | `-;
     `-}
 )txt"));
 }
 
`-SimpleDeclaration
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-PostfixUnaryOperatorExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-++
+    | | `-++
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(