Revert "[Clang] [NFC] Introduce ConstDynamicRecursiveASTVisitor" (#124667)

Reverts #122991

One of the bots is breaking; I’ll have to investigate what the issue is;
this might be because I haven’t updated the branch in a while.

Author: Sirraide

clang/include/clang/AST/DynamicRecursiveASTVisitor.h

@@ -52,11 +52,7 @@ class ASTContext;
 /// WalkUpFromX or post-order traversal).
 ///
 /// \see RecursiveASTVisitor.
-template <bool IsConst> class DynamicRecursiveASTVisitorBase {
-protected:
-  template <typename ASTNode>
-  using MaybeConst = std::conditional_t<IsConst, const ASTNode, ASTNode>;
-
+class DynamicRecursiveASTVisitor {
 public:
   /// Whether this visitor should recurse into template instantiations.
   bool ShouldVisitTemplateInstantiations = false;
@@ -72,38 +68,36 @@ template <bool IsConst> class DynamicRecursiveASTVisitorBase {
   bool ShouldVisitLambdaBody = true;
 
 protected:
-  DynamicRecursiveASTVisitorBase() = default;
-  DynamicRecursiveASTVisitorBase(DynamicRecursiveASTVisitorBase &&) = default;
-  DynamicRecursiveASTVisitorBase(const DynamicRecursiveASTVisitorBase &) =
-      default;
-  DynamicRecursiveASTVisitorBase &
-  operator=(DynamicRecursiveASTVisitorBase &&) = default;
-  DynamicRecursiveASTVisitorBase &
-  operator=(const DynamicRecursiveASTVisitorBase &) = default;
+  DynamicRecursiveASTVisitor() = default;
+  DynamicRecursiveASTVisitor(DynamicRecursiveASTVisitor &&) = default;
+  DynamicRecursiveASTVisitor(const DynamicRecursiveASTVisitor &) = default;
+  DynamicRecursiveASTVisitor &
+  operator=(DynamicRecursiveASTVisitor &&) = default;
+  DynamicRecursiveASTVisitor &
+  operator=(const DynamicRecursiveASTVisitor &) = default;
 
 public:
   virtual void anchor();
-  virtual ~DynamicRecursiveASTVisitorBase() = default;
+  virtual ~DynamicRecursiveASTVisitor() = default;
 
   /// Recursively visits an entire AST, starting from the TranslationUnitDecl.
   /// \returns false if visitation was terminated early.
-  virtual bool TraverseAST(MaybeConst<ASTContext> &AST);
+  virtual bool TraverseAST(ASTContext &AST);
 
   /// Recursively visit an attribute, by dispatching to
   /// Traverse*Attr() based on the argument's dynamic type.
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is a Null type location).
-  virtual bool TraverseAttr(MaybeConst<Attr> *At);
+  virtual bool TraverseAttr(Attr *At);
 
   /// Recursively visit a constructor initializer.  This
   /// automatically dispatches to another visitor for the initializer
   /// expression, but not for the name of the initializer, so may
   /// be overridden for clients that need access to the name.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  virtual bool
-  TraverseConstructorInitializer(MaybeConst<CXXCtorInitializer> *Init);
+  virtual bool TraverseConstructorInitializer(CXXCtorInitializer *Init);
 
   /// Recursively visit a base specifier. This can be overridden by a
   /// subclass.
@@ -116,7 +110,7 @@ template <bool IsConst> class DynamicRecursiveASTVisitorBase {
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is NULL).
-  virtual bool TraverseDecl(MaybeConst<Decl> *D);
+  virtual bool TraverseDecl(Decl *D);
 
   /// Recursively visit a name with its location information.
   ///
@@ -127,15 +121,13 @@ template <bool IsConst> class DynamicRecursiveASTVisitorBase {
   /// will be used to initialize the capture.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  virtual bool TraverseLambdaCapture(MaybeConst<LambdaExpr> *LE,
-                                     const LambdaCapture *C,
-                                     MaybeConst<Expr> *Init);
+  virtual bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
+                                     Expr *Init);
 
   /// Recursively visit a C++ nested-name-specifier.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  virtual bool
-  TraverseNestedNameSpecifier(MaybeConst<NestedNameSpecifier> *NNS);
+  virtual bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
 
   /// Recursively visit a C++ nested-name-specifier with location
   /// information.
@@ -148,7 +140,7 @@ template <bool IsConst> class DynamicRecursiveASTVisitorBase {
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is nullptr).
-  virtual bool TraverseStmt(MaybeConst<Stmt> *S);
+  virtual bool TraverseStmt(Stmt *S);
 
   /// Recursively visit a template argument and dispatch to the
   /// appropriate method for the argument type.
@@ -198,86 +190,74 @@ template <bool IsConst> class DynamicRecursiveASTVisitorBase {
 
   /// Traverse a concept (requirement).
   virtual bool TraverseTypeConstraint(const TypeConstraint *C);
-  virtual bool TraverseConceptRequirement(MaybeConst<concepts::Requirement> *R);
-
-  virtual bool
-  TraverseConceptTypeRequirement(MaybeConst<concepts::TypeRequirement> *R);
-
-  virtual bool
-  TraverseConceptExprRequirement(MaybeConst<concepts::ExprRequirement> *R);
-
-  virtual bool
-  TraverseConceptNestedRequirement(MaybeConst<concepts::NestedRequirement> *R);
-
-  virtual bool TraverseConceptReference(MaybeConst<ConceptReference> *CR);
-  virtual bool VisitConceptReference(MaybeConst<ConceptReference> *CR) {
-    return true;
-  }
+  virtual bool TraverseConceptRequirement(concepts::Requirement *R);
+  virtual bool TraverseConceptTypeRequirement(concepts::TypeRequirement *R);
+  virtual bool TraverseConceptExprRequirement(concepts::ExprRequirement *R);
+  virtual bool TraverseConceptNestedRequirement(concepts::NestedRequirement *R);
+  virtual bool TraverseConceptReference(ConceptReference *CR);
+  virtual bool VisitConceptReference(ConceptReference *CR) { return true; }
 
   /// Visit a node.
-  virtual bool VisitAttr(MaybeConst<Attr> *A) { return true; }
-  virtual bool VisitDecl(MaybeConst<Decl> *D) { return true; }
-  virtual bool VisitStmt(MaybeConst<Stmt> *S) { return true; }
-  virtual bool VisitType(MaybeConst<Type> *T) { return true; }
+  virtual bool VisitAttr(Attr *A) { return true; }
+  virtual bool VisitDecl(Decl *D) { return true; }
+  virtual bool VisitStmt(Stmt *S) { return true; }
+  virtual bool VisitType(Type *T) { return true; }
   virtual bool VisitTypeLoc(TypeLoc TL) { return true; }
 
   /// Walk up from a node.
-  bool WalkUpFromDecl(MaybeConst<Decl> *D) { return VisitDecl(D); }
-  bool WalkUpFromStmt(MaybeConst<Stmt> *S) { return VisitStmt(S); }
-  bool WalkUpFromType(MaybeConst<Type> *T) { return VisitType(T); }
+  bool WalkUpFromDecl(Decl *D) { return VisitDecl(D); }
+  bool WalkUpFromStmt(Stmt *S) { return VisitStmt(S); }
+  bool WalkUpFromType(Type *T) { return VisitType(T); }
   bool WalkUpFromTypeLoc(TypeLoc TL) { return VisitTypeLoc(TL); }
 
   /// Invoked before visiting a statement or expression via data recursion.
   ///
   /// \returns false to skip visiting the node, true otherwise.
-  virtual bool dataTraverseStmtPre(MaybeConst<Stmt> *S) { return true; }
+  virtual bool dataTraverseStmtPre(Stmt *S) { return true; }
 
   /// Invoked after visiting a statement or expression via data recursion.
   /// This is not invoked if the previously invoked \c dataTraverseStmtPre
   /// returned false.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  virtual bool dataTraverseStmtPost(MaybeConst<Stmt> *S) { return true; }
-  virtual bool dataTraverseNode(MaybeConst<Stmt> *S);
+  virtual bool dataTraverseStmtPost(Stmt *S) { return true; }
+  virtual bool dataTraverseNode(Stmt *S);
 
 #define DEF_TRAVERSE_TMPL_INST(kind)                                           \
-  virtual bool TraverseTemplateInstantiations(                                 \
-      MaybeConst<kind##TemplateDecl> *D);
+  virtual bool TraverseTemplateInstantiations(kind##TemplateDecl *D);
   DEF_TRAVERSE_TMPL_INST(Class)
   DEF_TRAVERSE_TMPL_INST(Var)
   DEF_TRAVERSE_TMPL_INST(Function)
 #undef DEF_TRAVERSE_TMPL_INST
 
   // Decls.
 #define ABSTRACT_DECL(DECL)
-#define DECL(CLASS, BASE)                                                      \
-  virtual bool Traverse##CLASS##Decl(MaybeConst<CLASS##Decl> *D);
+#define DECL(CLASS, BASE) virtual bool Traverse##CLASS##Decl(CLASS##Decl *D);
 #include "clang/AST/DeclNodes.inc"
 
 #define DECL(CLASS, BASE)                                                      \
-  bool WalkUpFrom##CLASS##Decl(MaybeConst<CLASS##Decl> *D);                    \
-  virtual bool Visit##CLASS##Decl(MaybeConst<CLASS##Decl> *D) { return true; }
+  bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D);                                \
+  virtual bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }
 #include "clang/AST/DeclNodes.inc"
 
   // Stmts.
 #define ABSTRACT_STMT(STMT)
-#define STMT(CLASS, PARENT) virtual bool Traverse##CLASS(MaybeConst<CLASS> *S);
+#define STMT(CLASS, PARENT) virtual bool Traverse##CLASS(CLASS *S);
 #include "clang/AST/StmtNodes.inc"
 
 #define STMT(CLASS, PARENT)                                                    \
-  bool WalkUpFrom##CLASS(MaybeConst<CLASS> *S);                                \
-  virtual bool Visit##CLASS(MaybeConst<CLASS> *S) { return true; }
+  bool WalkUpFrom##CLASS(CLASS *S);                                            \
+  virtual bool Visit##CLASS(CLASS *S) { return true; }
 #include "clang/AST/StmtNodes.inc"
 
   // Types.
 #define ABSTRACT_TYPE(CLASS, BASE)
-#define TYPE(CLASS, BASE)                                                      \
-  virtual bool Traverse##CLASS##Type(MaybeConst<CLASS##Type> *T);
+#define TYPE(CLASS, BASE) virtual bool Traverse##CLASS##Type(CLASS##Type *T);
 #include "clang/AST/TypeNodes.inc"
 
 #define TYPE(CLASS, BASE)                                                      \
-  bool WalkUpFrom##CLASS##Type(MaybeConst<CLASS##Type> *T);                    \
-  virtual bool Visit##CLASS##Type(MaybeConst<CLASS##Type> *T) { return true; }
+  bool WalkUpFrom##CLASS##Type(CLASS##Type *T);                                \
+  virtual bool Visit##CLASS##Type(CLASS##Type *T) { return true; }
 #include "clang/AST/TypeNodes.inc"
 
   // TypeLocs.
@@ -291,14 +271,6 @@ template <bool IsConst> class DynamicRecursiveASTVisitorBase {
   virtual bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }
 #include "clang/AST/TypeLocNodes.def"
 };
-
-extern template class DynamicRecursiveASTVisitorBase<false>;
-extern template class DynamicRecursiveASTVisitorBase<true>;
-
-using DynamicRecursiveASTVisitor =
-    DynamicRecursiveASTVisitorBase</*Const=*/false>;
-using ConstDynamicRecursiveASTVisitor =
-    DynamicRecursiveASTVisitorBase</*Const=*/true>;
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_DYNAMIC_RECURSIVE_AST_VISITOR_H