Switch from Visit to Traverse functions in TBR.

Currently, `TBRAnalyzer` is implemented as a `RecursiveASTVisitor`, meaning it automatically visits all sub-stmts recursively. However, in TBR, we often need to visit sub-stmts in a specific way, e.g.
When analyzing
```
x = y;
```
we should visit ``x`` with settings according to the fact that ``x`` is being overwritten, and then reset the settings. The same goes for ``y``.
Therefore, we cannot perform the analysis in the order, in which `RecursiveASTVisitor` visits this stmt: `x = y`, then `x`, then `y`. Instead, we call ``TraverseStmt`` manually inside ``VisitBinaryOperator``. Because of this we traverse stmts more times than we need to:
```
1) x = y;   ->  also x and y manually
2) x          -> automatically, unnecessary
3) y          -> automatically, unnecessary
```
We can show that for nested stmts, this will bump complexity from linear to quadratic. The same problem also occurs for other stmts like ``CallExpr``, where we visit the ``DeclRefExpr`` of the function.
This can be solved by switching from ``Visit`` functions to ``Traverse`` and returning ``false`` to prevent the visitor from entering the child nodes (returning ``false`` in ``Visit`` functions stops the whole visitation). The only downside is that ``Traverse`` only works with exact node type matches, e.g. ``TraverseCallExpr`` is not called for a ``CXXMemberCallExpr`` even though it's a subclass of ``CallExpr``.
We can solve this by introducing dummy functions like
```
TBRAnalyzer::TraverseCXXMemberCallExpr(const CXXMemberCallExpr* MCE) {
  TBRAnalyzer::TraverseCallExpr(MCE);
  return false;
}
```

Author: PetroZarytskyi

lib/Differentiator/TBRAnalyzer.cpp

@@ -264,11 +264,6 @@ void TBRAnalyzer::markLocation(const clang::Expr* E) {
 void TBRAnalyzer::setIsRequired(const clang::Expr* E, bool isReq) {
   // FIXME: generalize to other exprs
   if (const auto* DRE = dyn_cast<DeclRefExpr>(E)) {
-    // Since TBRAnalyzer is a RecursiveASTVisitor,
-    // it automatically visits all sub-stmts including
-    // decl refs of functions.
-    if (!isa<VarDecl>(DRE->getDecl()))
-      return;
     const auto* VD = cast<VarDecl>(DRE->getDecl());
     auto& curBranch = getCurBlockVarsData();
     if (curBranch.find(VD) == curBranch.end()) {
@@ -566,12 +561,12 @@ void TBRAnalyzer::merge(VarsData* targetData, VarsData* mergeData) {
   }
 }
 
-bool TBRAnalyzer::VisitDeclRefExpr(DeclRefExpr* DRE) {
+bool TBRAnalyzer::TraverseDeclRefExpr(DeclRefExpr* DRE) {
   setIsRequired(DRE);
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitDeclStmt(DeclStmt* DS) {
+bool TBRAnalyzer::TraverseDeclStmt(DeclStmt* DS) {
   for (auto* D : DS->decls()) {
     if (auto* VD = dyn_cast<VarDecl>(D)) {
       addVar(VD);
@@ -590,10 +585,10 @@ bool TBRAnalyzer::VisitDeclStmt(DeclStmt* DS) {
       }
     }
   }
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitConditionalOperator(clang::ConditionalOperator* CO) {
+bool TBRAnalyzer::TraverseConditionalOperator(clang::ConditionalOperator* CO) {
   setMode(0);
   TraverseStmt(CO->getCond());
   resetMode();
@@ -609,10 +604,10 @@ bool TBRAnalyzer::VisitConditionalOperator(clang::ConditionalOperator* CO) {
   TraverseStmt(CO->getTrueExpr());
 
   merge(m_BlockData[m_CurBlockID].get(), thenBranch.get());
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitBinaryOperator(BinaryOperator* BinOp) {
+bool TBRAnalyzer::TraverseBinaryOperator(BinaryOperator* BinOp) {
   const auto opCode = BinOp->getOpcode();
   Expr* L = BinOp->getLHS();
   Expr* R = BinOp->getRHS();
@@ -705,10 +700,16 @@ bool TBRAnalyzer::VisitBinaryOperator(BinaryOperator* BinOp) {
   // else {
   // FIXME: add logic/bitwise/comparison operators
   // }
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitUnaryOperator(clang::UnaryOperator* UnOp) {
+bool TBRAnalyzer::TraverseCompoundAssignOperator(
+    clang::CompoundAssignOperator* BinOp) {
+  TBRAnalyzer::TraverseBinaryOperator(BinOp);
+  return false;
+}
+
+bool TBRAnalyzer::TraverseUnaryOperator(clang::UnaryOperator* UnOp) {
   const auto opCode = UnOp->getOpcode();
   Expr* E = UnOp->getSubExpr();
   TraverseStmt(E);
@@ -733,10 +734,10 @@ bool TBRAnalyzer::VisitUnaryOperator(clang::UnaryOperator* UnOp) {
   // expressions. However, it is not clear where the FieldDecls of real and
   // imaginary parts should be deduced from (their names might be
   // compiler-specific).  So for now we visit the whole subexpression.
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitCallExpr(clang::CallExpr* CE) {
+bool TBRAnalyzer::TraverseCallExpr(clang::CallExpr* CE) {
   // FIXME: Currently TBR analysis just stops here and assumes that all the
   // variables passed by value/reference are used/used and changed. Analysis
   // could proceed to the function to analyse data flow inside it.
@@ -769,10 +770,20 @@ bool TBRAnalyzer::VisitCallExpr(clang::CallExpr* CE) {
     }
   }
   resetMode();
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitCXXConstructExpr(clang::CXXConstructExpr* CE) {
+bool TBRAnalyzer::TraverseCXXMemberCallExpr(clang::CXXMemberCallExpr* CE) {
+  TBRAnalyzer::TraverseCallExpr(CE);
+  return false;
+}
+
+bool TBRAnalyzer::TraverseCXXOperatorCallExpr(clang::CXXOperatorCallExpr* CE) {
+  TBRAnalyzer::TraverseCallExpr(CE);
+  return false;
+}
+
+bool TBRAnalyzer::TraverseCXXConstructExpr(clang::CXXConstructExpr* CE) {
   // FIXME: Currently TBR analysis just stops here and assumes that all the
   // variables passed by value/reference are used/used and changed. Analysis
   // could proceed to the constructor to analyse data flow inside it.
@@ -796,31 +807,31 @@ bool TBRAnalyzer::VisitCXXConstructExpr(clang::CXXConstructExpr* CE) {
     }
   }
   resetMode();
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitMemberExpr(clang::MemberExpr* ME) {
+bool TBRAnalyzer::TraverseMemberExpr(clang::MemberExpr* ME) {
   setIsRequired(ME);
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitArraySubscriptExpr(clang::ArraySubscriptExpr* ASE) {
+bool TBRAnalyzer::TraverseArraySubscriptExpr(clang::ArraySubscriptExpr* ASE) {
   setMode(0);
   TraverseStmt(ASE->getBase());
   resetMode();
   setIsRequired(ASE);
   setMode(Mode::kMarkingMode | Mode::kNonLinearMode);
   TraverseStmt(ASE->getIdx());
   resetMode();
-  return true;
+  return false;
 }
 
-bool TBRAnalyzer::VisitInitListExpr(clang::InitListExpr* ILE) {
+bool TBRAnalyzer::TraverseInitListExpr(clang::InitListExpr* ILE) {
   setMode(Mode::kMarkingMode);
   for (auto* init : ILE->inits())
     TraverseStmt(init);
   resetMode();
-  return true;
+  return false;
 }
 
 } // end namespace clad

lib/Differentiator/TBRAnalyzer.h

@@ -1,7 +1,9 @@
 #ifndef CLAD_DIFFERENTIATOR_TBRANALYZER_H
 #define CLAD_DIFFERENTIATOR_TBRANALYZER_H
 
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Stmt.h"
 #include "clang/Analysis/CFG.h"
 
 #include "clad/Differentiator/CladUtils.h"
@@ -299,16 +301,19 @@ class TBRAnalyzer : public clang::RecursiveASTVisitor<TBRAnalyzer> {
 
   void VisitCFGBlock(const clang::CFGBlock& block);
 
-  bool VisitArraySubscriptExpr(clang::ArraySubscriptExpr* ASE);
-  bool VisitBinaryOperator(clang::BinaryOperator* BinOp);
-  bool VisitCallExpr(clang::CallExpr* CE);
-  bool VisitConditionalOperator(clang::ConditionalOperator* CO);
-  bool VisitCXXConstructExpr(clang::CXXConstructExpr* CE);
-  bool VisitDeclRefExpr(clang::DeclRefExpr* DRE);
-  bool VisitDeclStmt(clang::DeclStmt* DS);
-  bool VisitInitListExpr(clang::InitListExpr* ILE);
-  bool VisitMemberExpr(clang::MemberExpr* ME);
-  bool VisitUnaryOperator(clang::UnaryOperator* UnOp);
+  bool TraverseArraySubscriptExpr(clang::ArraySubscriptExpr* ASE);
+  bool TraverseBinaryOperator(clang::BinaryOperator* BinOp);
+  bool TraverseCallExpr(clang::CallExpr* CE);
+  bool TraverseConditionalOperator(clang::ConditionalOperator* CO);
+  bool TraverseCompoundAssignOperator(clang::CompoundAssignOperator* BinOp);
+  bool TraverseCXXConstructExpr(clang::CXXConstructExpr* CE);
+  bool TraverseCXXMemberCallExpr(clang::CXXMemberCallExpr* CE);
+  bool TraverseCXXOperatorCallExpr(clang::CXXOperatorCallExpr* CE);
+  bool TraverseDeclRefExpr(clang::DeclRefExpr* DRE);
+  bool TraverseDeclStmt(clang::DeclStmt* DS);
+  bool TraverseInitListExpr(clang::InitListExpr* ILE);
+  bool TraverseMemberExpr(clang::MemberExpr* ME);
+  bool TraverseUnaryOperator(clang::UnaryOperator* UnOp);
 };
 
 } // end namespace clad