diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h
index 306eca7140d1a..9efca848ef03b 100644
--- a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h
+++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h
@@ -72,7 +72,8 @@ class StmtAncestorASTVisitor
   /// Accessor for DeclParents.
   const DeclParentMap &getDeclToParentStmtMap() { return DeclParents; }
 
-  friend class clang::RecursiveASTVisitor<StmtAncestorASTVisitor>;
+  friend class clang::RecursiveASTVisitorBase<StmtAncestorASTVisitor,
+                                              /*Const=*/false>;
 
 private:
   StmtParentMap StmtAncestors;
@@ -98,7 +99,8 @@ class ComponentFinderASTVisitor
   /// Accessor for Components.
   const ComponentVector &getComponents() { return Components; }
 
-  friend class clang::RecursiveASTVisitor<ComponentFinderASTVisitor>;
+  friend class clang::RecursiveASTVisitorBase<ComponentFinderASTVisitor,
+                                              /*Const=*/false>;
 
 private:
   ComponentVector Components;
@@ -155,7 +157,8 @@ class DependencyFinderASTVisitor
     return DependsOnInsideVariable;
   }
 
-  friend class clang::RecursiveASTVisitor<DependencyFinderASTVisitor>;
+  friend class clang::RecursiveASTVisitorBase<DependencyFinderASTVisitor,
+                                              /*Const=*/false>;
 
 private:
   const StmtParentMap *StmtParents;
@@ -188,7 +191,8 @@ class DeclFinderASTVisitor
     return Found;
   }
 
-  friend class clang::RecursiveASTVisitor<DeclFinderASTVisitor>;
+  friend class clang::RecursiveASTVisitorBase<DeclFinderASTVisitor,
+                                              /*Const=*/false>;
 
 private:
   std::string Name;
@@ -340,7 +344,7 @@ class ForLoopIndexUseVisitor
 private:
   /// Typedef used in CRTP functions.
   using VisitorBase = RecursiveASTVisitor<ForLoopIndexUseVisitor>;
-  friend class RecursiveASTVisitor<ForLoopIndexUseVisitor>;
+  friend class RecursiveASTVisitorBase<ForLoopIndexUseVisitor, /*Const=*/false>;
 
   /// Overriden methods for RecursiveASTVisitor's traversal.
   bool TraverseArraySubscriptExpr(ArraySubscriptExpr *E);
diff --git a/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp b/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp
index d5ccbb73735ec..8161d4563fcec 100644
--- a/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp
@@ -95,7 +95,8 @@ static bool paramReferredExactlyOnce(const CXXConstructorDecl *Ctor,
   /// \see ExactlyOneUsageVisitor::hasExactlyOneUsageIn()
   class ExactlyOneUsageVisitor
       : public RecursiveASTVisitor<ExactlyOneUsageVisitor> {
-    friend class RecursiveASTVisitor<ExactlyOneUsageVisitor>;
+    friend class RecursiveASTVisitorBase<ExactlyOneUsageVisitor,
+                                         /*Const=*/false>;
 
   public:
     ExactlyOneUsageVisitor(const ParmVarDecl *ParamDecl)
diff --git a/clang-tools-extra/clangd/AST.cpp b/clang-tools-extra/clangd/AST.cpp
index 0dcff2eae05e7..ccec4478ecc04 100644
--- a/clang-tools-extra/clangd/AST.cpp
+++ b/clang-tools-extra/clangd/AST.cpp
@@ -479,7 +479,7 @@ namespace {
 /// not have the deduced type set. Instead, we have to go to the appropriate
 /// DeclaratorDecl/FunctionDecl and work our back to the AutoType that does have
 /// a deduced type set. The AST should be improved to simplify this scenario.
-class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
+class DeducedTypeVisitor : public ConstRecursiveASTVisitor<DeducedTypeVisitor> {
   SourceLocation SearchedLocation;
   const HeuristicResolver *Resolver;
 
@@ -493,7 +493,7 @@ class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
   //- decltype(auto) i = 1;
   //- auto& i = 1;
   //- auto* i = &a;
-  bool VisitDeclaratorDecl(DeclaratorDecl *D) {
+  bool VisitDeclaratorDecl(const DeclaratorDecl *D) {
     if (!D->getTypeSourceInfo() ||
         !D->getTypeSourceInfo()->getTypeLoc().getContainedAutoTypeLoc() ||
         D->getTypeSourceInfo()
@@ -522,7 +522,7 @@ class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
   //- auto foo() -> int {}
   //- auto foo() -> decltype(1+1) {}
   //- operator auto() const { return 10; }
-  bool VisitFunctionDecl(FunctionDecl *D) {
+  bool VisitFunctionDecl(const FunctionDecl *D) {
     if (!D->getTypeSourceInfo())
       return true;
     // Loc of auto in return type (c++14).
@@ -553,7 +553,7 @@ class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
   // Handle non-auto decltype, e.g.:
   // - auto foo() -> decltype(expr) {}
   // - decltype(expr);
-  bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
+  bool VisitDecltypeTypeLoc(const DecltypeTypeLoc TL) {
     if (TL.getBeginLoc() != SearchedLocation)
       return true;
 
@@ -571,7 +571,7 @@ class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
 
   // Handle functions/lambdas with `auto` typed parameters.
   // We deduce the type if there's exactly one instantiation visible.
-  bool VisitParmVarDecl(ParmVarDecl *PVD) {
+  bool VisitParmVarDecl(const ParmVarDecl *PVD) {
     if (!PVD->getType()->isDependentType())
       return true;
     // 'auto' here does not name an AutoType, but an implicit template param.
@@ -606,7 +606,7 @@ class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
     return true;
   }
 
-  static int paramIndex(const TemplateDecl &TD, NamedDecl &Param) {
+  static int paramIndex(const TemplateDecl &TD, const NamedDecl &Param) {
     unsigned I = 0;
     for (auto *ND : *TD.getTemplateParameters()) {
       if (&Param == ND)
@@ -620,7 +620,7 @@ class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
 };
 } // namespace
 
-std::optional<QualType> getDeducedType(ASTContext &ASTCtx,
+std::optional<QualType> getDeducedType(const ASTContext &ASTCtx,
                                        const HeuristicResolver *Resolver,
                                        SourceLocation Loc) {
   if (!Loc.isValid())
@@ -659,7 +659,7 @@ static NamedDecl *getOnlyInstantiationImpl(TemplateDeclTy *TD) {
   return Only;
 }
 
-NamedDecl *getOnlyInstantiation(NamedDecl *TemplatedDecl) {
+NamedDecl *getOnlyInstantiation(const NamedDecl *TemplatedDecl) {
   if (TemplateDecl *TD = TemplatedDecl->getDescribedTemplate()) {
     if (auto *CTD = llvm::dyn_cast<ClassTemplateDecl>(TD))
       return getOnlyInstantiationImpl(CTD);
diff --git a/clang-tools-extra/clangd/AST.h b/clang-tools-extra/clangd/AST.h
index 2b83595e5b8e9..813e684612c45 100644
--- a/clang-tools-extra/clangd/AST.h
+++ b/clang-tools-extra/clangd/AST.h
@@ -168,7 +168,8 @@ QualType declaredType(const TypeDecl *D);
 /// Retrieves the deduced type at a given location (auto, decltype).
 /// It will return the underlying type.
 /// If the type is an undeduced auto, returns the type itself.
-std::optional<QualType> getDeducedType(ASTContext &, const HeuristicResolver *,
+std::optional<QualType> getDeducedType(const ASTContext &,
+                                       const HeuristicResolver *,
                                        SourceLocation Loc);
 
 // Find the abbreviated-function-template `auto` within a type, or returns null.
@@ -180,7 +181,7 @@ TemplateTypeParmTypeLoc getContainedAutoParamType(TypeLoc TL);
 
 // If TemplatedDecl is the generic body of a template, and the template has
 // exactly one visible instantiation, return the instantiated body.
-NamedDecl *getOnlyInstantiation(NamedDecl *TemplatedDecl);
+NamedDecl *getOnlyInstantiation(const NamedDecl *TemplatedDecl);
 
 /// Return attributes attached directly to a node.
 std::vector<const Attr *> getAttributes(const DynTypedNode &);
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h
index 1d1b7f183f75a..a3ea8a58b024a 100644
--- a/clang/include/clang/AST/RecursiveASTVisitor.h
+++ b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -153,15 +153,29 @@ isSameMethod([[maybe_unused]] FirstMethodPtrTy FirstMethodPtr,
 /// By default, this visitor preorder traverses the AST. If postorder traversal
 /// is needed, the \c shouldTraversePostOrder method needs to be overridden
 /// to return \c true.
-template <typename Derived> class RecursiveASTVisitor {
+/// Base template for RecursiveASTVisitor that can handle both const and
+/// non-const AST node traversal. The IsConst template parameter determines
+/// whether AST node pointers are const or non-const.
+template <typename Derived, bool IsConst> class RecursiveASTVisitorBase {
+protected:
+  template <typename ASTNode>
+  using MaybeConst = std::conditional_t<IsConst, const ASTNode, ASTNode>;
+
 public:
+  // Type aliases that vary based on IsConst template parameter
+  using StmtPtr = MaybeConst<Stmt> *;
+  using DeclPtr = MaybeConst<Decl> *;
+  using TypePtr = MaybeConst<Type> *;
+  using ExprPtr = MaybeConst<Expr> *;
+  using AttrPtr = MaybeConst<Attr> *;
+
   /// A queue used for performing data recursion over statements.
   /// Parameters involving this type are used to implement data
   /// recursion over Stmts and Exprs within this class, and should
   /// typically not be explicitly specified by derived classes.
   /// The bool bit indicates whether the statement has been traversed or not.
-  typedef SmallVectorImpl<llvm::PointerIntPair<Stmt *, 1, bool>>
-    DataRecursionQueue;
+  using DataRecursionQueue =
+      SmallVectorImpl<llvm::PointerIntPair<StmtPtr, 1, bool>>;
 
   /// Return a reference to the derived class.
   Derived &getDerived() { return *static_cast<Derived *>(this); }
@@ -186,7 +200,7 @@ template <typename Derived> class RecursiveASTVisitor {
 
   /// Recursively visits an entire AST, starting from the TranslationUnitDecl.
   /// \returns false if visitation was terminated early.
-  bool TraverseAST(ASTContext &AST) {
+  bool TraverseAST(MaybeConst<ASTContext> &AST) {
     // Currently just an alias for TraverseDecl(TUDecl), but kept in case
     // we change the implementation again.
     return getDerived().TraverseDecl(AST.getTranslationUnitDecl());
@@ -197,19 +211,19 @@ template <typename Derived> class RecursiveASTVisitor {
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is nullptr).
-  bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue = nullptr);
+  bool TraverseStmt(StmtPtr S, DataRecursionQueue *Queue = nullptr);
 
   /// Invoked before visiting a statement or expression via data recursion.
   ///
   /// \returns false to skip visiting the node, true otherwise.
-  bool dataTraverseStmtPre(Stmt *S) { return true; }
+  bool dataTraverseStmtPre(StmtPtr 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.
-  bool dataTraverseStmtPost(Stmt *S) { return true; }
+  bool dataTraverseStmtPost(StmtPtr S) { return true; }
 
   /// Recursively visit a type, by dispatching to
   /// Traverse*Type() based on the argument's getTypeClass() property.
@@ -230,14 +244,14 @@ template <typename Derived> class RecursiveASTVisitor {
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is a Null type location).
-  bool TraverseAttr(Attr *At);
+  bool TraverseAttr(AttrPtr At);
 
   /// Recursively visit a declaration, by dispatching to
   /// Traverse*Decl() based on the argument's dynamic type.
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is NULL).
-  bool TraverseDecl(Decl *D);
+  bool TraverseDecl(DeclPtr D);
 
   /// Recursively visit a C++ nested-name-specifier.
   ///
@@ -294,20 +308,20 @@ template <typename Derived> class RecursiveASTVisitor {
   /// be overridden for clients that need access to the name.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  bool TraverseConstructorInitializer(CXXCtorInitializer *Init);
+  bool TraverseConstructorInitializer(MaybeConst<CXXCtorInitializer> *Init);
 
   /// Recursively visit a lambda capture. \c Init is the expression that
   /// will be used to initialize the capture.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
-                             Expr *Init);
+  bool TraverseLambdaCapture(MaybeConst<LambdaExpr> *LE, const LambdaCapture *C,
+                             MaybeConst<Expr> *Init);
 
   /// Recursively visit the syntactic or semantic form of an
   /// initialization list.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  bool TraverseSynOrSemInitListExpr(InitListExpr *S,
+  bool TraverseSynOrSemInitListExpr(MaybeConst<InitListExpr> *S,
                                     DataRecursionQueue *Queue = nullptr);
 
   /// Recursively visit an Objective-C protocol reference with location
@@ -319,14 +333,14 @@ template <typename Derived> class RecursiveASTVisitor {
   /// Recursively visit concept reference with location information.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
-  bool TraverseConceptReference(ConceptReference *CR);
+  bool TraverseConceptReference(MaybeConst<ConceptReference> *CR);
 
   // Visit concept reference.
-  bool VisitConceptReference(ConceptReference *CR) { return true; }
+  bool VisitConceptReference(MaybeConst<ConceptReference> *CR) { return true; }
   // ---- Methods on Attrs ----
 
   // Visit an attribute.
-  bool VisitAttr(Attr *A) { return true; }
+  bool VisitAttr(AttrPtr A) { return true; }
 
 // Declare Traverse* and empty Visit* for all Attr classes.
 #define ATTR_VISITOR_DECLS_ONLY
@@ -335,7 +349,10 @@ template <typename Derived> class RecursiveASTVisitor {
 
 // ---- Methods on Stmts ----
 
-  Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
+using MaybeConstChildRange =
+    std::conditional_t<IsConst, Stmt::const_child_range, Stmt::child_range>;
+
+MaybeConstChildRange getStmtChildren(StmtPtr S) { return S->children(); }
 
 private:
   // Traverse the given statement. If the most-derived traverse function takes a
@@ -345,15 +362,18 @@ template <typename Derived> class RecursiveASTVisitor {
   // arm call our function rather than the derived class version.
 #define TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE)                            \
   (::clang::detail::has_same_member_pointer_type<                              \
-       decltype(&RecursiveASTVisitor::Traverse##NAME),                         \
+       decltype(&RecursiveASTVisitorBase::Traverse##NAME),                     \
        decltype(&Derived::Traverse##NAME)>::value                              \
        ? static_cast<std::conditional_t<                                       \
              ::clang::detail::has_same_member_pointer_type<                    \
-                 decltype(&RecursiveASTVisitor::Traverse##NAME),               \
+                 decltype(&RecursiveASTVisitorBase::Traverse##NAME),           \
                  decltype(&Derived::Traverse##NAME)>::value,                   \
-             Derived &, RecursiveASTVisitor &>>(*this)                         \
-             .Traverse##NAME(static_cast<CLASS *>(VAR), QUEUE)                 \
-       : getDerived().Traverse##NAME(static_cast<CLASS *>(VAR)))
+             Derived &, RecursiveASTVisitorBase &>>(*this)                     \
+             .Traverse##NAME(const_cast<MaybeConst<CLASS> *>(                  \
+                                 static_cast<const CLASS *>(VAR)),             \
+                             QUEUE)                                            \
+       : getDerived().Traverse##NAME(const_cast<MaybeConst<CLASS> *>(          \
+             static_cast<const CLASS *>(VAR))))
 
 // Try to traverse the given statement, or enqueue it if we're performing data
 // recursion in the middle of traversing another statement. Can only be called
@@ -367,21 +387,22 @@ template <typename Derived> class RecursiveASTVisitor {
 public:
 // Declare Traverse*() for all concrete Stmt classes.
 #define ABSTRACT_STMT(STMT)
-#define STMT(CLASS, PARENT) \
-  bool Traverse##CLASS(CLASS *S, DataRecursionQueue *Queue = nullptr);
+#define STMT(CLASS, PARENT)                                                    \
+  bool Traverse##CLASS(MaybeConst<CLASS> *S,                                   \
+                       DataRecursionQueue *Queue = nullptr);
 #include "clang/AST/StmtNodes.inc"
   // The above header #undefs ABSTRACT_STMT and STMT upon exit.
 
   // Define WalkUpFrom*() and empty Visit*() for all Stmt classes.
-  bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); }
-  bool VisitStmt(Stmt *S) { return true; }
+  bool WalkUpFromStmt(StmtPtr S) { return getDerived().VisitStmt(S); }
+  bool VisitStmt(StmtPtr S) { return true; }
 #define STMT(CLASS, PARENT)                                                    \
-  bool WalkUpFrom##CLASS(CLASS *S) {                                           \
+  bool WalkUpFrom##CLASS(MaybeConst<CLASS> *S) {                               \
     TRY_TO(WalkUpFrom##PARENT(S));                                             \
     TRY_TO(Visit##CLASS(S));                                                   \
     return true;                                                               \
   }                                                                            \
-  bool Visit##CLASS(CLASS *S) { return true; }
+  bool Visit##CLASS(MaybeConst<CLASS> *S) { return true; }
 #include "clang/AST/StmtNodes.inc"
 
 // ---- Methods on Types ----
@@ -390,20 +411,21 @@ template <typename Derived> class RecursiveASTVisitor {
 // Declare Traverse*() for all concrete Type classes.
 #define ABSTRACT_TYPE(CLASS, BASE)
 #define TYPE(CLASS, BASE)                                                      \
-  bool Traverse##CLASS##Type(CLASS##Type *T, bool TraverseQualifier);
+  bool Traverse##CLASS##Type(MaybeConst<CLASS##Type> *T,                       \
+                             bool TraverseQualifier);
 #include "clang/AST/TypeNodes.inc"
   // The above header #undefs ABSTRACT_TYPE and TYPE upon exit.
 
   // Define WalkUpFrom*() and empty Visit*() for all Type classes.
-  bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); }
-  bool VisitType(Type *T) { return true; }
+  bool WalkUpFromType(TypePtr T) { return getDerived().VisitType(T); }
+  bool VisitType(TypePtr T) { return true; }
 #define TYPE(CLASS, BASE)                                                      \
-  bool WalkUpFrom##CLASS##Type(CLASS##Type *T) {                               \
+  bool WalkUpFrom##CLASS##Type(MaybeConst<CLASS##Type> *T) {                   \
     TRY_TO(WalkUpFrom##BASE(T));                                               \
     TRY_TO(Visit##CLASS##Type(T));                                             \
     return true;                                                               \
   }                                                                            \
-  bool Visit##CLASS##Type(CLASS##Type *T) { return true; }
+  bool Visit##CLASS##Type(MaybeConst<CLASS##Type> *T) { return true; }
 #include "clang/AST/TypeNodes.inc"
 
 // ---- Methods on TypeLocs ----
@@ -445,26 +467,28 @@ template <typename Derived> class RecursiveASTVisitor {
 
 // Declare Traverse*() for all concrete Decl classes.
 #define ABSTRACT_DECL(DECL)
-#define DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D);
+#define DECL(CLASS, BASE)                                                      \
+  bool Traverse##CLASS##Decl(MaybeConst<CLASS##Decl> *D);
 #include "clang/AST/DeclNodes.inc"
   // The above header #undefs ABSTRACT_DECL and DECL upon exit.
 
   // Define WalkUpFrom*() and empty Visit*() for all Decl classes.
-  bool WalkUpFromDecl(Decl *D) { return getDerived().VisitDecl(D); }
-  bool VisitDecl(Decl *D) { return true; }
+  bool WalkUpFromDecl(DeclPtr D) { return getDerived().VisitDecl(D); }
+  bool VisitDecl(DeclPtr D) { return true; }
 #define DECL(CLASS, BASE)                                                      \
-  bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) {                               \
+  bool WalkUpFrom##CLASS##Decl(MaybeConst<CLASS##Decl> *D) {                   \
     TRY_TO(WalkUpFrom##BASE(D));                                               \
     TRY_TO(Visit##CLASS##Decl(D));                                             \
     return true;                                                               \
   }                                                                            \
-  bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }
+  bool Visit##CLASS##Decl(MaybeConst<CLASS##Decl> *D) { return true; }
 #include "clang/AST/DeclNodes.inc"
 
   bool canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child);
 
 #define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND)                                   \
-  bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);
+  bool TraverseTemplateInstantiations(                                         \
+      MaybeConst<TMPLDECLKIND##TemplateDecl> *D);
   DEF_TRAVERSE_TMPL_INST(Class)
   DEF_TRAVERSE_TMPL_INST(Var)
   DEF_TRAVERSE_TMPL_INST(Function)
@@ -472,64 +496,68 @@ template <typename Derived> class RecursiveASTVisitor {
 
   bool TraverseTypeConstraint(const TypeConstraint *C);
 
-  bool TraverseConceptRequirement(concepts::Requirement *R);
-  bool TraverseConceptTypeRequirement(concepts::TypeRequirement *R);
-  bool TraverseConceptExprRequirement(concepts::ExprRequirement *R);
-  bool TraverseConceptNestedRequirement(concepts::NestedRequirement *R);
+  bool TraverseConceptRequirement(MaybeConst<concepts::Requirement> *R);
+  bool TraverseConceptTypeRequirement(MaybeConst<concepts::TypeRequirement> *R);
+  bool TraverseConceptExprRequirement(MaybeConst<concepts::ExprRequirement> *R);
+  bool
+  TraverseConceptNestedRequirement(MaybeConst<concepts::NestedRequirement> *R);
 
-  bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
+  /// Internal method for data recursion traversal
+  bool dataTraverseNode(StmtPtr S, DataRecursionQueue *Queue);
 
 private:
   // These are helper methods used by more than one Traverse* method.
-  bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
+  bool
+  TraverseTemplateParameterListHelper(MaybeConst<TemplateParameterList> *TPL);
 
   // Traverses template parameter lists of either a DeclaratorDecl or TagDecl.
   template <typename T>
   bool TraverseDeclTemplateParameterLists(T *D);
 
-  bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D);
+  bool TraverseTemplateTypeParamDeclConstraints(
+      const MaybeConst<TemplateTypeParmDecl> *D);
 
   bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
                                           unsigned Count);
   bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
-  bool TraverseSubstPackTypeHelper(SubstPackType *T);
+  bool TraverseSubstPackTypeHelper(MaybeConst<SubstPackType> *T);
   bool TraverseSubstPackTypeLocHelper(SubstPackTypeLoc TL);
-  bool TraverseRecordHelper(RecordDecl *D);
-  bool TraverseCXXRecordHelper(CXXRecordDecl *D);
-  bool TraverseDeclaratorHelper(DeclaratorDecl *D);
-  bool TraverseDeclContextHelper(DeclContext *DC);
-  bool TraverseFunctionHelper(FunctionDecl *D);
-  bool TraverseVarHelper(VarDecl *D);
-  bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
-  bool TraverseOMPLoopDirective(OMPLoopDirective *S);
-  bool TraverseOMPClause(OMPClause *C);
-  bool TraverseTagType(TagType *T, bool TraverseQualifier);
+  bool TraverseRecordHelper(MaybeConst<RecordDecl> *D);
+  bool TraverseCXXRecordHelper(MaybeConst<CXXRecordDecl> *D);
+  bool TraverseDeclaratorHelper(MaybeConst<DeclaratorDecl> *D);
+  bool TraverseDeclContextHelper(MaybeConst<DeclContext> *DC);
+  bool TraverseFunctionHelper(MaybeConst<FunctionDecl> *D);
+  bool TraverseVarHelper(MaybeConst<VarDecl> *D);
+  bool TraverseOMPExecutableDirective(MaybeConst<OMPExecutableDirective> *S);
+  bool TraverseOMPLoopDirective(MaybeConst<OMPLoopDirective> *S);
+  bool TraverseOMPClause(MaybeConst<OMPClause> *C);
+  bool TraverseTagType(MaybeConst<TagType> *T, bool TraverseQualifier);
   bool TraverseTagTypeLoc(TagTypeLoc TL, bool TraverseQualifier);
 #define GEN_CLANG_CLAUSE_CLASS
-#define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);
+#define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(MaybeConst<Class> *C);
 #include "llvm/Frontend/OpenMP/OMP.inc"
   /// Process clauses with list of variables.
   template <typename T> bool VisitOMPClauseList(T *Node);
   /// Process clauses with pre-initis.
-  bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
-  bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
+  bool VisitOMPClauseWithPreInit(MaybeConst<OMPClauseWithPreInit> *Node);
+  bool VisitOMPClauseWithPostUpdate(MaybeConst<OMPClauseWithPostUpdate> *Node);
 
-  bool PostVisitStmt(Stmt *S);
-  bool TraverseOpenACCConstructStmt(OpenACCConstructStmt *S);
-  bool
-  TraverseOpenACCAssociatedStmtConstruct(OpenACCAssociatedStmtConstruct *S);
+  bool PostVisitStmt(StmtPtr S);
+  bool TraverseOpenACCConstructStmt(MaybeConst<OpenACCConstructStmt> *S);
+  bool TraverseOpenACCAssociatedStmtConstruct(
+      MaybeConst<OpenACCAssociatedStmtConstruct> *S);
   bool VisitOpenACCClauseList(ArrayRef<const OpenACCClause *>);
   bool VisitOpenACCClause(const OpenACCClause *);
 };
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTypeConstraint(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTypeConstraint(
     const TypeConstraint *C) {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO(TraverseConceptReference(C->getConceptReference()));
     return true;
   }
-  if (Expr *IDC = C->getImmediatelyDeclaredConstraint()) {
+  if (ExprPtr IDC = C->getImmediatelyDeclaredConstraint()) {
     TRY_TO(TraverseStmt(IDC));
   } else {
     // Avoid traversing the ConceptReference in the TypeConstraint
@@ -541,27 +569,30 @@ bool RecursiveASTVisitor<Derived>::TraverseTypeConstraint(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConceptRequirement(
-    concepts::Requirement *R) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseConceptRequirement(
+    MaybeConst<concepts::Requirement> *R) {
   switch (R->getKind()) {
   case concepts::Requirement::RK_Type:
     return getDerived().TraverseConceptTypeRequirement(
-        cast<concepts::TypeRequirement>(R));
+        const_cast<MaybeConst<concepts::TypeRequirement> *>(
+            cast<concepts::TypeRequirement>(R)));
   case concepts::Requirement::RK_Simple:
   case concepts::Requirement::RK_Compound:
     return getDerived().TraverseConceptExprRequirement(
-        cast<concepts::ExprRequirement>(R));
+        const_cast<MaybeConst<concepts::ExprRequirement> *>(
+            cast<concepts::ExprRequirement>(R)));
   case concepts::Requirement::RK_Nested:
     return getDerived().TraverseConceptNestedRequirement(
-        cast<concepts::NestedRequirement>(R));
+        const_cast<MaybeConst<concepts::NestedRequirement> *>(
+            cast<concepts::NestedRequirement>(R)));
   }
   llvm_unreachable("unexpected case");
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S,
-                                                    DataRecursionQueue *Queue) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::dataTraverseNode(
+    StmtPtr S, DataRecursionQueue *Queue) {
   // Top switch stmt: dispatch to TraverseFooStmt for each concrete FooStmt.
   switch (S->getStmtClass()) {
   case Stmt::NoStmtClass:
@@ -578,17 +609,17 @@ bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S,
 
 #undef DISPATCH_STMT
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConceptTypeRequirement(
-    concepts::TypeRequirement *R) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseConceptTypeRequirement(
+    MaybeConst<concepts::TypeRequirement> *R) {
   if (R->isSubstitutionFailure())
     return true;
   return getDerived().TraverseTypeLoc(R->getType()->getTypeLoc());
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConceptExprRequirement(
-    concepts::ExprRequirement *R) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseConceptExprRequirement(
+    MaybeConst<concepts::ExprRequirement> *R) {
   if (!R->isExprSubstitutionFailure())
     TRY_TO(TraverseStmt(R->getExpr()));
   auto &RetReq = R->getReturnTypeRequirement();
@@ -604,16 +635,17 @@ bool RecursiveASTVisitor<Derived>::TraverseConceptExprRequirement(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConceptNestedRequirement(
-    concepts::NestedRequirement *R) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    TraverseConceptNestedRequirement(
+        MaybeConst<concepts::NestedRequirement> *R) {
   if (!R->hasInvalidConstraint())
     return getDerived().TraverseStmt(R->getConstraintExpr());
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::PostVisitStmt(StmtPtr S) {
   // In pre-order traversal mode, each Traverse##STMT method is responsible for
   // calling WalkUpFrom. Therefore, if the user overrides Traverse##STMT and
   // does not call the default implementation, the WalkUpFrom callback is not
@@ -636,16 +668,20 @@ bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) {
 #define ABSTRACT_STMT(STMT)
 #define STMT(CLASS, PARENT)                                                    \
   case Stmt::CLASS##Class:                                                     \
-    if (::clang::detail::isSameMethod(&RecursiveASTVisitor::Traverse##CLASS,   \
-                                      &Derived::Traverse##CLASS)) {            \
-      TRY_TO(WalkUpFrom##CLASS(static_cast<CLASS *>(S)));                      \
+    if (::clang::detail::isSameMethod(                                         \
+            &RecursiveASTVisitorBase::Traverse##CLASS,                         \
+            &Derived::Traverse##CLASS)) {                                      \
+      TRY_TO(WalkUpFrom##CLASS(                                                \
+          const_cast<MaybeConst<CLASS> *>(static_cast<const CLASS *>(S))));    \
     }                                                                          \
     break;
 #define INITLISTEXPR(CLASS, PARENT)                                            \
   case Stmt::CLASS##Class:                                                     \
-    if (::clang::detail::isSameMethod(&RecursiveASTVisitor::Traverse##CLASS,   \
-                                      &Derived::Traverse##CLASS)) {            \
-      auto ILE = static_cast<CLASS *>(S);                                      \
+    if (::clang::detail::isSameMethod(                                         \
+            &RecursiveASTVisitorBase::Traverse##CLASS,                         \
+            &Derived::Traverse##CLASS)) {                                      \
+      auto ILE =                                                               \
+          const_cast<MaybeConst<CLASS> *>(static_cast<const CLASS *>(S));      \
       if (auto Syn = ILE->isSemanticForm() ? ILE->getSyntacticForm() : ILE)    \
         TRY_TO(WalkUpFrom##CLASS(Syn));                                        \
       if (auto Sem = ILE->isSemanticForm() ? ILE : ILE->getSemanticForm())     \
@@ -662,9 +698,10 @@ bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) {
 
 // Inlining this method can lead to large code size and compile-time increases
 // without any benefit to runtime performance.
-template <typename Derived>
+template <typename Derived, bool IsConst>
 LLVM_ATTRIBUTE_NOINLINE bool
-RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S, DataRecursionQueue *Queue) {
+RecursiveASTVisitorBase<Derived, IsConst>::TraverseStmt(
+    StmtPtr S, DataRecursionQueue *Queue) {
   if (!S)
     return true;
 
@@ -673,12 +710,12 @@ RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S, DataRecursionQueue *Queue) {
     return true;
   }
 
-  SmallVector<llvm::PointerIntPair<Stmt *, 1, bool>, 8> LocalQueue;
+  SmallVector<llvm::PointerIntPair<StmtPtr, 1, bool>, 8> LocalQueue;
   LocalQueue.push_back({S, false});
 
   while (!LocalQueue.empty()) {
     auto &CurrSAndVisited = LocalQueue.back();
-    Stmt *CurrS = CurrSAndVisited.getPointer();
+    StmtPtr CurrS = CurrSAndVisited.getPointer();
     bool Visited = CurrSAndVisited.getInt();
     if (Visited) {
       LocalQueue.pop_back();
@@ -703,9 +740,9 @@ RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S, DataRecursionQueue *Queue) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseType(QualType T,
-                                                bool TraverseQualifier) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseType(
+    QualType T, bool TraverseQualifier) {
   if (T.isNull())
     return true;
 
@@ -714,7 +751,8 @@ bool RecursiveASTVisitor<Derived>::TraverseType(QualType T,
 #define TYPE(CLASS, BASE)                                                      \
   case Type::CLASS:                                                            \
     return getDerived().Traverse##CLASS##Type(                                 \
-        static_cast<CLASS##Type *>(const_cast<Type *>(T.getTypePtr())),        \
+        const_cast<MaybeConst<CLASS##Type> *>(                                 \
+            static_cast<const CLASS##Type *>(T.getTypePtr())),                 \
         TraverseQualifier);
 #include "clang/AST/TypeNodes.inc"
   }
@@ -722,9 +760,9 @@ bool RecursiveASTVisitor<Derived>::TraverseType(QualType T,
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL,
-                                                   bool TraverseQualifier) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTypeLoc(
+    TypeLoc TL, bool TraverseQualifier) {
   if (TL.isNull())
     return true;
 
@@ -741,12 +779,12 @@ bool RecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL,
 }
 
 // Define the Traverse*Attr(Attr* A) methods
-#define VISITORCLASS RecursiveASTVisitor
+#define VISITORCLASS RecursiveASTVisitorBase
 #include "clang/AST/AttrVisitor.inc"
 #undef VISITORCLASS
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseDecl(DeclPtr D) {
   if (!D)
     return true;
 
@@ -779,7 +817,9 @@ bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) {
 #define ABSTRACT_DECL(DECL)
 #define DECL(CLASS, BASE)                                                      \
   case Decl::CLASS:                                                            \
-    if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D)))    \
+    if (!getDerived().Traverse##CLASS##Decl(                                   \
+            const_cast<MaybeConst<CLASS##Decl> *>(                             \
+                static_cast<const CLASS##Decl *>(D))))                         \
       return false;                                                            \
     break;
 #include "clang/AST/DeclNodes.inc"
@@ -787,8 +827,8 @@ bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseNestedNameSpecifier(
     NestedNameSpecifier NNS) {
   switch (NNS.getKind()) {
   case NestedNameSpecifier::Kind::Null:
@@ -799,7 +839,7 @@ bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
     TRY_TO(TraverseNestedNameSpecifier(NNS.getAsNamespaceAndPrefix().Prefix));
     return true;
   case NestedNameSpecifier::Kind::Type: {
-    auto *T = const_cast<Type *>(NNS.getAsType());
+    auto *T = const_cast<MaybeConst<Type> *>(NNS.getAsType());
     TRY_TO(TraverseNestedNameSpecifier(T->getPrefix()));
     TRY_TO(TraverseType(QualType(T, 0), /*TraverseQualifier=*/false));
     return true;
@@ -808,8 +848,8 @@ bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
   llvm_unreachable("unhandled kind");
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseNestedNameSpecifierLoc(
     NestedNameSpecifierLoc NNS) {
   switch (NNS.getNestedNameSpecifier().getKind()) {
   case NestedNameSpecifier::Kind::Null:
@@ -831,8 +871,8 @@ bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseDeclarationNameInfo(
     DeclarationNameInfo NameInfo) {
   switch (NameInfo.getName().getNameKind()) {
   case DeclarationName::CXXConstructorName:
@@ -860,8 +900,9 @@ bool RecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateName(
+    TemplateName Template) {
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
     TRY_TO(TraverseNestedNameSpecifier(DTN->getQualifier()));
   } else if (QualifiedTemplateName *QTN =
@@ -874,8 +915,8 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateArgument(
     const TemplateArgument &Arg) {
   switch (Arg.getKind()) {
   case TemplateArgument::Null:
@@ -905,8 +946,8 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
 
 // FIXME: no template name location?
 // FIXME: no source locations for a template argument pack?
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateArgumentLoc(
     const TemplateArgumentLoc &ArgLoc) {
   const TemplateArgument &Arg = ArgLoc.getArgument();
 
@@ -944,8 +985,8 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateArguments(
     ArrayRef<TemplateArgument> Args) {
   for (const TemplateArgument &Arg : Args)
     TRY_TO(TraverseTemplateArgument(Arg));
@@ -953,9 +994,9 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer(
-    CXXCtorInitializer *Init) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseConstructorInitializer(
+    MaybeConst<CXXCtorInitializer> *Init) {
   if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())
     TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
 
@@ -965,11 +1006,10 @@ bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer(
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE,
-                                                    const LambdaCapture *C,
-                                                    Expr *Init) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseLambdaCapture(
+    MaybeConst<LambdaExpr> *LE, const LambdaCapture *C,
+    MaybeConst<Expr> *Init) {
   if (LE->isInitCapture(C))
     TRY_TO(TraverseDecl(C->getCapturedVar()));
   else
@@ -981,9 +1021,9 @@ RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE,
 
 // This macro makes available a variable T, the passed-in type.
 #define DEF_TRAVERSE_TYPE(TYPE, CODE)                                          \
-  template <typename Derived>                                                  \
-  bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T,                   \
-                                                    bool TraverseQualifier) {  \
+  template <typename Derived, bool IsConst>                                    \
+  bool RecursiveASTVisitorBase<Derived, IsConst>::Traverse##TYPE(              \
+      MaybeConst<TYPE> *T, bool TraverseQualifier) {                           \
     if (!getDerived().shouldTraversePostOrder())                               \
       TRY_TO(WalkUpFrom##TYPE(T));                                             \
     {                                                                          \
@@ -1025,13 +1065,13 @@ DEF_TRAVERSE_TYPE(DecayedType, { TRY_TO(TraverseType(T->getOriginalType())); })
 DEF_TRAVERSE_TYPE(ConstantArrayType, {
   TRY_TO(TraverseType(T->getElementType()));
   if (T->getSizeExpr())
-    TRY_TO(TraverseStmt(const_cast<Expr*>(T->getSizeExpr())));
+    TRY_TO(TraverseStmt(const_cast<MaybeConst<Expr> *>(T->getSizeExpr())));
 })
 
 DEF_TRAVERSE_TYPE(ArrayParameterType, {
   TRY_TO(TraverseType(T->getElementType()));
   if (T->getSizeExpr())
-    TRY_TO(TraverseStmt(const_cast<Expr *>(T->getSizeExpr())));
+    TRY_TO(TraverseStmt(const_cast<MaybeConst<Expr> *>(T->getSizeExpr())));
 })
 
 DEF_TRAVERSE_TYPE(IncompleteArrayType,
@@ -1094,7 +1134,7 @@ DEF_TRAVERSE_TYPE(FunctionProtoType, {
     TRY_TO(TraverseType(E));
   }
 
-  if (Expr *NE = T->getNoexceptExpr())
+  if (ExprPtr NE = T->getNoexceptExpr())
     TRY_TO(TraverseStmt(NE));
 })
 
@@ -1173,9 +1213,9 @@ DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); })
 DEF_TRAVERSE_TYPE(MacroQualifiedType,
                   { TRY_TO(TraverseType(T->getUnderlyingType())); })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTagType(TagType *T,
-                                                   bool TraverseQualifier) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTagType(
+    MaybeConst<TagType> *T, bool TraverseQualifier) {
   if (TraverseQualifier)
     TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
   return true;
@@ -1253,13 +1293,14 @@ DEF_TRAVERSE_TYPE(PredefinedSugarType, {})
 // clients that override the WalkUpFrom*Type() and/or Visit*Type() methods
 // continue to work.
 #define DEF_TRAVERSE_TYPELOC(TYPE, CODE)                                       \
-  template <typename Derived>                                                  \
-  bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(                      \
+  template <typename Derived, bool IsConst>                                    \
+  bool RecursiveASTVisitorBase<Derived, IsConst>::Traverse##TYPE##Loc(         \
       TYPE##Loc TL, bool TraverseQualifier) {                                  \
     if (!getDerived().shouldTraversePostOrder()) {                             \
       TRY_TO(WalkUpFrom##TYPE##Loc(TL));                                       \
       if (getDerived().shouldWalkTypesOfTypeLocs())                            \
-        TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr())));         \
+        TRY_TO(WalkUpFrom##TYPE(                                               \
+            const_cast<MaybeConst<TYPE> *>(TL.getTypePtr())));                 \
     }                                                                          \
     {                                                                          \
       CODE;                                                                    \
@@ -1267,13 +1308,14 @@ DEF_TRAVERSE_TYPE(PredefinedSugarType, {})
     if (getDerived().shouldTraversePostOrder()) {                              \
       TRY_TO(WalkUpFrom##TYPE##Loc(TL));                                       \
       if (getDerived().shouldWalkTypesOfTypeLocs())                            \
-        TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr())));         \
+        TRY_TO(WalkUpFrom##TYPE(                                               \
+            const_cast<MaybeConst<TYPE> *>(TL.getTypePtr())));                 \
     }                                                                          \
     return true;                                                               \
   }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseQualifiedTypeLoc(
     QualifiedTypeLoc TL, bool TraverseQualifier) {
   assert(TraverseQualifier &&
          "Qualifiers should never occur within NestedNameSpecifiers");
@@ -1330,8 +1372,9 @@ DEF_TRAVERSE_TYPELOC(AdjustedType,
 DEF_TRAVERSE_TYPELOC(DecayedType,
                      { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseArrayTypeLocHelper(
+    ArrayTypeLoc TL) {
   // This isn't available for ArrayType, but is for the ArrayTypeLoc.
   TRY_TO(TraverseStmt(TL.getSizeExpr()));
   return true;
@@ -1425,7 +1468,7 @@ DEF_TRAVERSE_TYPELOC(FunctionProtoType, {
     TRY_TO(TraverseType(E));
   }
 
-  if (Expr *NE = T->getNoexceptExpr())
+  if (ExprPtr NE = T->getNoexceptExpr())
     TRY_TO(TraverseStmt(NE));
 })
 
@@ -1478,16 +1521,16 @@ DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmType, {
   TRY_TO(TraverseType(TL.getTypePtr()->getReplacementType()));
 })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseSubstPackTypeLocHelper(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseSubstPackTypeLocHelper(
     SubstPackTypeLoc TL) {
   TRY_TO(TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseSubstPackTypeHelper(
-    SubstPackType *T) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseSubstPackTypeHelper(
+    MaybeConst<SubstPackType> *T) {
   TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));
   return true;
 }
@@ -1518,9 +1561,9 @@ DEF_TRAVERSE_TYPELOC(HLSLAttributedResourceType,
 DEF_TRAVERSE_TYPELOC(HLSLInlineSpirvType,
                      { TRY_TO(TraverseType(TL.getType())); })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTagTypeLoc(TagTypeLoc TL,
-                                                      bool TraverseQualifier) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTagTypeLoc(
+    TagTypeLoc TL, bool TraverseQualifier) {
   if (NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
       TraverseQualifier && QualifierLoc)
     TRY_TO(TraverseNestedNameSpecifierLoc(QualifierLoc));
@@ -1614,9 +1657,9 @@ DEF_TRAVERSE_TYPELOC(PredefinedSugarType, {})
 // Therefore each Traverse* only needs to worry about children other
 // than those.
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::canIgnoreChildDeclWhileTraversingDeclContext(
-    const Decl *Child) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child) {
   // BlockDecls are traversed through BlockExprs,
   // CapturedDecls are traversed through CapturedStmts.
   if (isa<BlockDecl>(Child) || isa<CapturedDecl>(Child))
@@ -1627,8 +1670,9 @@ bool RecursiveASTVisitor<Derived>::canIgnoreChildDeclWhileTraversingDeclContext(
   return false;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseDeclContextHelper(
+    MaybeConst<DeclContext> *DC) {
   if (!DC)
     return true;
 
@@ -1642,13 +1686,16 @@ bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
 
 // This macro makes available a variable D, the passed-in decl.
 #define DEF_TRAVERSE_DECL(DECL, CODE)                                          \
-  template <typename Derived>                                                  \
-  bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) {                 \
+  template <typename Derived, bool IsConst>                                    \
+  bool RecursiveASTVisitorBase<Derived, IsConst>::Traverse##DECL(              \
+      MaybeConst<DECL> *D) {                                                   \
     bool ShouldVisitChildren = true;                                           \
     bool ReturnValue = true;                                                   \
     if (!getDerived().shouldTraversePostOrder())                               \
       TRY_TO(WalkUpFrom##DECL(D));                                             \
-    { CODE; }                                                                  \
+    {                                                                          \
+      CODE;                                                                    \
+    }                                                                          \
     if (ReturnValue && ShouldVisitChildren)                                    \
       TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D)));             \
     if (ReturnValue) {                                                         \
@@ -1708,7 +1755,7 @@ DEF_TRAVERSE_DECL(FriendDecl, {
     TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
     // Traverse any CXXRecordDecl owned by this type, since
     // it will not be in the parent context:
-    if (auto *TT = D->getFriendType()->getType()->getAs<TagType>();
+    if (auto *TT = D->getFriendType()->getType()->template getAs<TagType>();
         TT && TT->isTagOwned())
       TRY_TO(TraverseDecl(TT->getOriginalDecl()));
   } else {
@@ -1723,8 +1770,7 @@ DEF_TRAVERSE_DECL(FriendTemplateDecl, {
     TRY_TO(TraverseDecl(D->getFriendDecl()));
   for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) {
     TemplateParameterList *TPL = D->getTemplateParameterList(I);
-    for (TemplateParameterList::iterator ITPL = TPL->begin(), ETPL = TPL->end();
-         ITPL != ETPL; ++ITPL) {
+    for (auto ITPL = TPL->begin(), ETPL = TPL->end(); ITPL != ETPL; ++ITPL) {
       TRY_TO(TraverseDecl(*ITPL));
     }
   }
@@ -1837,7 +1883,7 @@ DEF_TRAVERSE_DECL(ObjCMethodDecl, {
   if (D->getReturnTypeSourceInfo()) {
     TRY_TO(TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc()));
   }
-  for (ParmVarDecl *Parameter : D->parameters()) {
+  for (MaybeConst<ParmVarDecl> *Parameter : D->parameters()) {
     TRY_TO(TraverseDecl(Parameter));
   }
   if (D->isThisDeclarationADefinition()) {
@@ -1932,23 +1978,25 @@ DEF_TRAVERSE_DECL(OpenACCRoutineDecl, {
 })
 
 // A helper method for TemplateDecl's children.
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
-    TemplateParameterList *TPL) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    TraverseTemplateParameterListHelper(
+        MaybeConst<TemplateParameterList> *TPL) {
   if (TPL) {
-    for (NamedDecl *D : *TPL) {
+    for (MaybeConst<NamedDecl> *D : *TPL) {
       TRY_TO(TraverseDecl(D));
     }
-    if (Expr *RequiresClause = TPL->getRequiresClause()) {
+    if (ExprPtr RequiresClause = TPL->getRequiresClause()) {
       TRY_TO(TraverseStmt(RequiresClause));
     }
   }
   return true;
 }
 
-template <typename Derived>
+template <typename Derived, bool IsConst>
 template <typename T>
-bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) {
+bool RecursiveASTVisitorBase<
+    Derived, IsConst>::TraverseDeclTemplateParameterLists(T *D) {
   for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) {
     TemplateParameterList *TPL = D->getTemplateParameterList(i);
     TraverseTemplateParameterListHelper(TPL);
@@ -1956,9 +2004,9 @@ bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
-    ClassTemplateDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateInstantiations(
+    MaybeConst<ClassTemplateDecl> *D) {
   for (auto *SD : D->specializations()) {
     for (auto *RD : SD->redecls()) {
       assert(!cast<CXXRecordDecl>(RD)->isInjectedClassName());
@@ -1984,9 +2032,9 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
-    VarTemplateDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateInstantiations(
+    MaybeConst<VarTemplateDecl> *D) {
   for (auto *SD : D->specializations()) {
     for (auto *RD : SD->redecls()) {
       switch (
@@ -2009,9 +2057,9 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
 
 // A helper method for traversing the instantiations of a
 // function while skipping its specializations.
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
-    FunctionTemplateDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseTemplateInstantiations(
+    MaybeConst<FunctionTemplateDecl> *D) {
   for (auto *FD : D->specializations()) {
     for (auto *RD : FD->redecls()) {
       switch (RD->getTemplateSpecializationKind()) {
@@ -2076,9 +2124,10 @@ DEF_TRAVERSE_DECL(BuiltinTemplateDecl, {
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints(
-    const TemplateTypeParmDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    TraverseTemplateTypeParamDeclConstraints(
+        const MaybeConst<TemplateTypeParmDecl> *D) {
   if (const auto *TC = D->getTypeConstraint())
     TRY_TO(TraverseTypeConstraint(TC));
   return true;
@@ -2139,8 +2188,9 @@ DEF_TRAVERSE_DECL(EnumDecl, {
 })
 
 // Helper methods for RecordDecl and its children.
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseRecordHelper(
+    MaybeConst<RecordDecl> *D) {
   // We shouldn't traverse D->getTypeForDecl(); it's a result of
   // declaring the type, not something that was written in the source.
 
@@ -2149,15 +2199,16 @@ bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseCXXBaseSpecifier(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseCXXBaseSpecifier(
     const CXXBaseSpecifier &Base) {
   TRY_TO(TraverseTypeLoc(Base.getTypeSourceInfo()->getTypeLoc()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseCXXRecordHelper(
+    MaybeConst<CXXRecordDecl> *D) {
   if (!TraverseRecordHelper(D))
     return false;
   if (D->isCompleteDefinition()) {
@@ -2174,9 +2225,10 @@ DEF_TRAVERSE_DECL(RecordDecl, { TRY_TO(TraverseRecordHelper(D)); })
 
 DEF_TRAVERSE_DECL(CXXRecordDecl, { TRY_TO(TraverseCXXRecordHelper(D)); })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper(
-    const TemplateArgumentLoc *TAL, unsigned Count) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
+                                       unsigned Count) {
   for (unsigned I = 0; I < Count; ++I) {
     TRY_TO(TraverseTemplateArgumentLoc(TAL[I]));
   }
@@ -2248,8 +2300,9 @@ DEF_TRAVERSE_DECL(UnresolvedUsingValueDecl, {
 
 DEF_TRAVERSE_DECL(IndirectFieldDecl, {})
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseDeclaratorHelper(
+    MaybeConst<DeclaratorDecl> *D) {
   TRY_TO(TraverseDeclTemplateParameterLists(D));
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
   if (D->getTypeSourceInfo())
@@ -2303,8 +2356,9 @@ DEF_TRAVERSE_DECL(ObjCIvarDecl, {
   // FIXME: implement the rest.
 })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseFunctionHelper(
+    MaybeConst<FunctionDecl> *D) {
   TRY_TO(TraverseDeclTemplateParameterLists(D));
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
@@ -2339,14 +2393,14 @@ bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
   // FunctionNoProtoType or FunctionProtoType, or a typedef.  This
   // also covers the return type and the function parameters,
   // including exception specifications.
-  if (TypeSourceInfo *TSI = D->getTypeSourceInfo()) {
+  if (MaybeConst<TypeSourceInfo> *TSI = D->getTypeSourceInfo()) {
     TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
   } else if (getDerived().shouldVisitImplicitCode()) {
     // Visit parameter variable declarations of the implicit function
     // if the traverser is visiting implicit code. Parameter variable
     // declarations do not have valid TypeSourceInfo, so to visit them
     // we need to traverse the declarations explicitly.
-    for (ParmVarDecl *Parameter : D->parameters()) {
+    for (MaybeConst<ParmVarDecl> *Parameter : D->parameters()) {
       TRY_TO(TraverseDecl(Parameter));
     }
   }
@@ -2355,10 +2409,10 @@ bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
   if (const AssociatedConstraint &TrailingRequiresClause =
           D->getTrailingRequiresClause()) {
     TRY_TO(TraverseStmt(
-        const_cast<Expr *>(TrailingRequiresClause.ConstraintExpr)));
+        const_cast<MaybeConst<Expr> *>(TrailingRequiresClause.ConstraintExpr)));
   }
 
-  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
+  if (MaybeConst<CXXConstructorDecl> *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
     // Constructor initializers.
     for (auto *I : Ctor->inits()) {
       if (I->isWritten() || getDerived().shouldVisitImplicitCode())
@@ -2437,8 +2491,9 @@ DEF_TRAVERSE_DECL(CXXDestructorDecl, {
   ReturnValue = TraverseFunctionHelper(D);
 })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseVarHelper(
+    MaybeConst<VarDecl> *D) {
   TRY_TO(TraverseDeclaratorHelper(D));
   // Default params are taken care of when we traverse the ParmVarDecl.
   if (!isa<ParmVarDecl>(D) &&
@@ -2489,16 +2544,18 @@ DEF_TRAVERSE_DECL(ImplicitConceptSpecializationDecl, {
 
 // This macro makes available a variable S, the passed-in stmt.
 #define DEF_TRAVERSE_STMT(STMT, CODE)                                          \
-  template <typename Derived>                                                  \
-  bool RecursiveASTVisitor<Derived>::Traverse##STMT(                           \
-      STMT *S, DataRecursionQueue *Queue) {                                    \
+  template <typename Derived, bool IsConst>                                    \
+  bool RecursiveASTVisitorBase<Derived, IsConst>::Traverse##STMT(              \
+      MaybeConst<STMT> *S, DataRecursionQueue *Queue) {                        \
     bool ShouldVisitChildren = true;                                           \
     bool ReturnValue = true;                                                   \
     if (!getDerived().shouldTraversePostOrder())                               \
       TRY_TO(WalkUpFrom##STMT(S));                                             \
-    { CODE; }                                                                  \
+    {                                                                          \
+      CODE;                                                                    \
+    }                                                                          \
     if (ShouldVisitChildren) {                                                 \
-      for (Stmt * SubStmt : getDerived().getStmtChildren(S)) {                 \
+      for (auto SubStmt : getDerived().getStmtChildren(S)) {                   \
         TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt);                              \
       }                                                                        \
     }                                                                          \
@@ -2666,9 +2723,9 @@ DEF_TRAVERSE_STMT(BuiltinBitCastExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
 })
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
-    InitListExpr *S, DataRecursionQueue *Queue) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseSynOrSemInitListExpr(
+    MaybeConst<InitListExpr> *S, DataRecursionQueue *Queue) {
   if (S) {
     // Skip this if we traverse postorder. We will visit it later
     // in PostVisitStmt.
@@ -2676,7 +2733,7 @@ bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
       TRY_TO(WalkUpFromInitListExpr(S));
 
     // All we need are the default actions.  FIXME: use a helper function.
-    for (Stmt *SubStmt : S->children()) {
+    for (StmtPtr SubStmt : S->children()) {
       TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt);
     }
 
@@ -2686,15 +2743,15 @@ bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolLoc(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseObjCProtocolLoc(
     ObjCProtocolLoc ProtocolLoc) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConceptReference(
-    ConceptReference *CR) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseConceptReference(
+    MaybeConst<ConceptReference> *CR) {
   if (!getDerived().shouldTraversePostOrder())
     TRY_TO(VisitConceptReference(CR));
   TRY_TO(TraverseNestedNameSpecifierLoc(CR->getNestedNameSpecifierLoc()));
@@ -2716,9 +2773,9 @@ bool RecursiveASTVisitor<Derived>::TraverseConceptReference(
 // visited twice, if they appear both in the syntactic and the semantic form.
 //
 // There is no guarantee about which form \p S takes when this method is called.
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(
-    InitListExpr *S, DataRecursionQueue *Queue) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseInitListExpr(
+    MaybeConst<InitListExpr> *S, DataRecursionQueue *Queue) {
   if (S->isSemanticForm() && S->isSyntacticForm()) {
     // `S` does not have alternative forms, traverse only once.
     TRY_TO(TraverseSynOrSemInitListExpr(S, Queue));
@@ -2744,8 +2801,8 @@ DEF_TRAVERSE_STMT(GenericSelectionExpr, {
   else
     TRY_TO(TraverseTypeLoc(S->getControllingType()->getTypeLoc()));
 
-  for (const GenericSelectionExpr::Association Assoc : S->associations()) {
-    if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo())
+  for (auto Assoc : S->associations()) {
+    if (MaybeConst<TypeSourceInfo> *TSI = Assoc.getTypeSourceInfo())
       TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(Assoc.getAssociationExpr());
   }
@@ -2756,11 +2813,9 @@ DEF_TRAVERSE_STMT(GenericSelectionExpr, {
 // syntactic expressions and opaque values.
 DEF_TRAVERSE_STMT(PseudoObjectExpr, {
   TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getSyntacticForm());
-  for (PseudoObjectExpr::semantics_iterator i = S->semantics_begin(),
-                                            e = S->semantics_end();
-       i != e; ++i) {
-    Expr *sub = *i;
-    if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub))
+  for (auto i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) {
+    ExprPtr sub = *i;
+    if (MaybeConst<OpaqueValueExpr> *OVE = dyn_cast<OpaqueValueExpr>(sub))
       sub = OVE->getSourceExpr();
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(sub);
   }
@@ -2864,13 +2919,14 @@ DEF_TRAVERSE_STMT(LambdaExpr, {
     for (const auto &E : T->exceptions())
       TRY_TO(TraverseType(E));
 
-    if (Expr *NE = T->getNoexceptExpr())
+    if (ExprPtr NE = T->getNoexceptExpr())
       TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(NE);
 
     if (S->hasExplicitResultType())
       TRY_TO(TraverseTypeLoc(Proto.getReturnLoc()));
-    TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(
-        const_cast<Expr *>(S->getTrailingRequiresClause().ConstraintExpr));
+    if (auto *ConstraintExpr = S->getTrailingRequiresClause().ConstraintExpr) {
+      TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(ConstraintExpr);
+    }
 
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody());
   }
@@ -2945,7 +3001,7 @@ DEF_TRAVERSE_STMT(NoInitExpr, {})
 DEF_TRAVERSE_STMT(ArrayInitLoopExpr, {
   // FIXME: The source expression of the OVE should be listed as
   // a child of the ArrayInitLoopExpr.
-  if (OpaqueValueExpr *OVE = S->getCommonExpr())
+  if (MaybeConst<OpaqueValueExpr> *OVE = S->getCommonExpr())
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(OVE->getSourceExpr());
 })
 DEF_TRAVERSE_STMT(ArrayInitIndexExpr, {})
@@ -2966,7 +3022,7 @@ DEF_TRAVERSE_STMT(ObjCMessageExpr, {
 
 DEF_TRAVERSE_STMT(ObjCPropertyRefExpr, {
   if (S->isClassReceiver()) {
-    ObjCInterfaceDecl *IDecl = S->getClassReceiver();
+    MaybeConst<ObjCInterfaceDecl> *IDecl = S->getClassReceiver();
     QualType Type = IDecl->getASTContext().getObjCInterfaceType(IDecl);
     ObjCInterfaceLocInfo Data;
     Data.NameLoc = S->getReceiverLocation();
@@ -2996,7 +3052,7 @@ DEF_TRAVERSE_STMT(ConvertVectorExpr, {})
 DEF_TRAVERSE_STMT(StmtExpr, {})
 DEF_TRAVERSE_STMT(SourceLocExpr, {})
 DEF_TRAVERSE_STMT(EmbedExpr, {
-  for (IntegerLiteral *IL : S->underlying_data_elements()) {
+  for (MaybeConst<IntegerLiteral> *IL : S->underlying_data_elements()) {
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(IL);
   }
 })
@@ -3036,8 +3092,8 @@ DEF_TRAVERSE_STMT(CXXRewrittenBinaryOperator, {
   if (!getDerived().shouldVisitImplicitCode()) {
     CXXRewrittenBinaryOperator::DecomposedForm Decomposed =
         S->getDecomposedForm();
-    TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.LHS)));
-    TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.RHS)));
+    TRY_TO(TraverseStmt(const_cast<MaybeConst<Expr> *>(Decomposed.LHS)));
+    TRY_TO(TraverseStmt(const_cast<MaybeConst<Expr> *>(Decomposed.RHS)));
     ShouldVisitChildren = false;
   }
 })
@@ -3110,9 +3166,9 @@ DEF_TRAVERSE_STMT(ConceptSpecializationExpr, {
 
 DEF_TRAVERSE_STMT(RequiresExpr, {
   TRY_TO(TraverseDecl(S->getBody()));
-  for (ParmVarDecl *Parm : S->getLocalParameters())
+  for (MaybeConst<ParmVarDecl> *Parm : S->getLocalParameters())
     TRY_TO(TraverseDecl(Parm));
-  for (concepts::Requirement *Req : S->getRequirements())
+  for (MaybeConst<concepts::Requirement> *Req : S->getRequirements())
     TRY_TO(TraverseConceptRequirement(Req));
 })
 
@@ -3132,11 +3188,11 @@ DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, {})
 DEF_TRAVERSE_STMT(AsTypeExpr, {})
 
 // OpenMP directives.
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
-    OMPExecutableDirective *S) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseOMPExecutableDirective(
+    MaybeConst<OMPExecutableDirective> *S) {
   for (auto *C : S->clauses()) {
-    TRY_TO(TraverseOMPClause(C));
+    TRY_TO(TraverseOMPClause(const_cast<MaybeConst<OMPClause> *>(C)));
   }
   return true;
 }
@@ -3149,9 +3205,9 @@ DEF_TRAVERSE_STMT(OMPCanonicalLoop, {
   }
 })
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::TraverseOMPLoopDirective(OMPLoopDirective *S) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseOMPLoopDirective(
+    MaybeConst<OMPLoopDirective> *S) {
   return TraverseOMPExecutableDirective(S);
 }
 
@@ -3386,15 +3442,17 @@ DEF_TRAVERSE_STMT(OMPErrorDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 // OpenMP clauses.
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseOMPClause(
+    MaybeConst<OMPClause> *C) {
   if (!C)
     return true;
   switch (C->getClauseKind()) {
 #define GEN_CLANG_CLAUSE_CLASS
 #define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case llvm::omp::Clause::Enum:                                                \
-    TRY_TO(Visit##Class(static_cast<Class *>(C)));                             \
+    TRY_TO(Visit##Class(                                                       \
+        const_cast<MaybeConst<Class> *>(static_cast<const Class *>(C))));      \
     break;
 #define CLAUSE_NO_CLASS(Enum, Str)                                             \
   case llvm::omp::Clause::Enum:                                                \
@@ -3404,371 +3462,415 @@ bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPreInit(
-    OMPClauseWithPreInit *Node) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPClauseWithPreInit(
+    MaybeConst<OMPClauseWithPreInit> *Node) {
   TRY_TO(TraverseStmt(Node->getPreInitStmt()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPostUpdate(
-    OMPClauseWithPostUpdate *Node) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPClauseWithPostUpdate(
+    MaybeConst<OMPClauseWithPostUpdate> *Node) {
   TRY_TO(VisitOMPClauseWithPreInit(Node));
   TRY_TO(TraverseStmt(Node->getPostUpdateExpr()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAllocatorClause(
-    OMPAllocatorClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAllocatorClause(
+    MaybeConst<OMPAllocatorClause> *C) {
   TRY_TO(TraverseStmt(C->getAllocator()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAllocateClause(OMPAllocateClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAllocateClause(
+    MaybeConst<OMPAllocateClause> *C) {
   TRY_TO(TraverseStmt(C->getAllocator()));
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPIfClause(OMPIfClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPIfClause(
+    MaybeConst<OMPIfClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getCondition()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFinalClause(OMPFinalClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFinalClause(
+    MaybeConst<OMPFinalClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getCondition()));
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNumThreadsClause(
+    MaybeConst<OMPNumThreadsClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getNumThreads()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAlignClause(OMPAlignClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAlignClause(
+    MaybeConst<OMPAlignClause> *C) {
   TRY_TO(TraverseStmt(C->getAlignment()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSafelenClause(OMPSafelenClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSafelenClause(
+    MaybeConst<OMPSafelenClause> *C) {
   TRY_TO(TraverseStmt(C->getSafelen()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSimdlenClause(
+    MaybeConst<OMPSimdlenClause> *C) {
   TRY_TO(TraverseStmt(C->getSimdlen()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSizesClause(OMPSizesClause *C) {
-  for (Expr *E : C->getSizesRefs())
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSizesClause(
+    MaybeConst<OMPSizesClause> *C) {
+  for (MaybeConst<Expr> *E : C->getSizesRefs())
     TRY_TO(TraverseStmt(E));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPPermutationClause(
-    OMPPermutationClause *C) {
-  for (Expr *E : C->getArgsRefs())
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPPermutationClause(
+    MaybeConst<OMPPermutationClause> *C) {
+  for (MaybeConst<Expr> *E : C->getArgsRefs())
     TRY_TO(TraverseStmt(E));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFullClause(OMPFullClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFullClause(
+    MaybeConst<OMPFullClause> *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPPartialClause(OMPPartialClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPPartialClause(
+    MaybeConst<OMPPartialClause> *C) {
   TRY_TO(TraverseStmt(C->getFactor()));
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::VisitOMPCollapseClause(OMPCollapseClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPCollapseClause(
+    MaybeConst<OMPCollapseClause> *C) {
   TRY_TO(TraverseStmt(C->getNumForLoops()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDefaultClause(
+    MaybeConst<OMPDefaultClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPProcBindClause(OMPProcBindClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPProcBindClause(
+    MaybeConst<OMPProcBindClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUnifiedAddressClause(
-    OMPUnifiedAddressClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUnifiedAddressClause(
+    MaybeConst<OMPUnifiedAddressClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUnifiedSharedMemoryClause(
-    OMPUnifiedSharedMemoryClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    VisitOMPUnifiedSharedMemoryClause(
+        MaybeConst<OMPUnifiedSharedMemoryClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPReverseOffloadClause(
-    OMPReverseOffloadClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPReverseOffloadClause(
+    MaybeConst<OMPReverseOffloadClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDynamicAllocatorsClause(
-    OMPDynamicAllocatorsClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDynamicAllocatorsClause(
+    MaybeConst<OMPDynamicAllocatorsClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAtomicDefaultMemOrderClause(
-    OMPAtomicDefaultMemOrderClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    VisitOMPAtomicDefaultMemOrderClause(
+        MaybeConst<OMPAtomicDefaultMemOrderClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSelfMapsClause(OMPSelfMapsClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSelfMapsClause(
+    MaybeConst<OMPSelfMapsClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAtClause(OMPAtClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAtClause(
+    MaybeConst<OMPAtClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSeverityClause(OMPSeverityClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSeverityClause(
+    MaybeConst<OMPSeverityClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPMessageClause(OMPMessageClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPMessageClause(
+    MaybeConst<OMPMessageClause> *C) {
   TRY_TO(TraverseStmt(C->getMessageString()));
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::VisitOMPScheduleClause(OMPScheduleClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPScheduleClause(
+    MaybeConst<OMPScheduleClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getChunkSize()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPOrderedClause(OMPOrderedClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPOrderedClause(
+    MaybeConst<OMPOrderedClause> *C) {
   TRY_TO(TraverseStmt(C->getNumForLoops()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNowaitClause(OMPNowaitClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNowaitClause(
+    MaybeConst<OMPNowaitClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUntiedClause(OMPUntiedClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUntiedClause(
+    MaybeConst<OMPUntiedClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::VisitOMPMergeableClause(OMPMergeableClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPMergeableClause(
+    MaybeConst<OMPMergeableClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPReadClause(OMPReadClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPReadClause(
+    MaybeConst<OMPReadClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPWriteClause(OMPWriteClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPWriteClause(
+    MaybeConst<OMPWriteClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUpdateClause(OMPUpdateClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUpdateClause(
+    MaybeConst<OMPUpdateClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPCaptureClause(OMPCaptureClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPCaptureClause(
+    MaybeConst<OMPCaptureClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPCompareClause(OMPCompareClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPCompareClause(
+    MaybeConst<OMPCompareClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFailClause(OMPFailClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFailClause(
+    MaybeConst<OMPFailClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSeqCstClause(
+    MaybeConst<OMPSeqCstClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAcqRelClause(OMPAcqRelClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAcqRelClause(
+    MaybeConst<OMPAcqRelClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAbsentClause(OMPAbsentClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAbsentClause(
+    MaybeConst<OMPAbsentClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPHoldsClause(OMPHoldsClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPHoldsClause(
+    MaybeConst<OMPHoldsClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPContainsClause(OMPContainsClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPContainsClause(
+    MaybeConst<OMPContainsClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNoOpenMPClause(OMPNoOpenMPClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNoOpenMPClause(
+    MaybeConst<OMPNoOpenMPClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNoOpenMPRoutinesClause(
-    OMPNoOpenMPRoutinesClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNoOpenMPRoutinesClause(
+    MaybeConst<OMPNoOpenMPRoutinesClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNoOpenMPConstructsClause(
-    OMPNoOpenMPConstructsClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    VisitOMPNoOpenMPConstructsClause(
+        MaybeConst<OMPNoOpenMPConstructsClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNoParallelismClause(
-    OMPNoParallelismClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNoParallelismClause(
+    MaybeConst<OMPNoParallelismClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAcquireClause(OMPAcquireClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAcquireClause(
+    MaybeConst<OMPAcquireClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPReleaseClause(OMPReleaseClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPReleaseClause(
+    MaybeConst<OMPReleaseClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPRelaxedClause(OMPRelaxedClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPRelaxedClause(
+    MaybeConst<OMPRelaxedClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPWeakClause(OMPWeakClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPWeakClause(
+    MaybeConst<OMPWeakClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPThreadsClause(OMPThreadsClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPThreadsClause(
+    MaybeConst<OMPThreadsClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSIMDClause(OMPSIMDClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSIMDClause(
+    MaybeConst<OMPSIMDClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNogroupClause(OMPNogroupClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNogroupClause(
+    MaybeConst<OMPNogroupClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPInitClause(OMPInitClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPInitClause(
+    MaybeConst<OMPInitClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUseClause(OMPUseClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUseClause(
+    MaybeConst<OMPUseClause> *C) {
   TRY_TO(TraverseStmt(C->getInteropVar()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDestroyClause(OMPDestroyClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDestroyClause(
+    MaybeConst<OMPDestroyClause> *C) {
   TRY_TO(TraverseStmt(C->getInteropVar()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNovariantsClause(
-    OMPNovariantsClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNovariantsClause(
+    MaybeConst<OMPNovariantsClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getCondition()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNocontextClause(
-    OMPNocontextClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNocontextClause(
+    MaybeConst<OMPNocontextClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getCondition()));
   return true;
 }
 
-template <typename Derived>
+template <typename Derived, bool IsConst>
 template <typename T>
-bool RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) {
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPClauseList(T *Node) {
   for (auto *E : Node->varlist()) {
     TRY_TO(TraverseStmt(E));
   }
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPInclusiveClause(
-    OMPInclusiveClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPInclusiveClause(
+    MaybeConst<OMPInclusiveClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPExclusiveClause(
-    OMPExclusiveClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPExclusiveClause(
+    MaybeConst<OMPExclusiveClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPPrivateClause(
+    MaybeConst<OMPPrivateClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   for (auto *E : C->private_copies()) {
     TRY_TO(TraverseStmt(E));
@@ -3776,9 +3878,9 @@ bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
-    OMPFirstprivateClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFirstprivateClause(
+    MaybeConst<OMPFirstprivateClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   TRY_TO(VisitOMPClauseWithPreInit(C));
   for (auto *E : C->private_copies()) {
@@ -3790,9 +3892,9 @@ bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
-    OMPLastprivateClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPLastprivateClause(
+    MaybeConst<OMPLastprivateClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   TRY_TO(VisitOMPClauseWithPostUpdate(C));
   for (auto *E : C->private_copies()) {
@@ -3810,14 +3912,16 @@ bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPSharedClause(
+    MaybeConst<OMPSharedClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPLinearClause(OMPLinearClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPLinearClause(
+    MaybeConst<OMPLinearClause> *C) {
   TRY_TO(TraverseStmt(C->getStep()));
   TRY_TO(TraverseStmt(C->getCalcStep()));
   TRY_TO(VisitOMPClauseList(C));
@@ -3837,15 +3941,17 @@ bool RecursiveASTVisitor<Derived>::VisitOMPLinearClause(OMPLinearClause *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAlignedClause(OMPAlignedClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAlignedClause(
+    MaybeConst<OMPAlignedClause> *C) {
   TRY_TO(TraverseStmt(C->getAlignment()));
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPCopyinClause(OMPCopyinClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPCopyinClause(
+    MaybeConst<OMPCopyinClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   for (auto *E : C->source_exprs()) {
     TRY_TO(TraverseStmt(E));
@@ -3859,9 +3965,9 @@ bool RecursiveASTVisitor<Derived>::VisitOMPCopyinClause(OMPCopyinClause *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPCopyprivateClause(
-    OMPCopyprivateClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPCopyprivateClause(
+    MaybeConst<OMPCopyprivateClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   for (auto *E : C->source_exprs()) {
     TRY_TO(TraverseStmt(E));
@@ -3875,9 +3981,9 @@ bool RecursiveASTVisitor<Derived>::VisitOMPCopyprivateClause(
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::VisitOMPReductionClause(OMPReductionClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPReductionClause(
+    MaybeConst<OMPReductionClause> *C) {
   TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
   TRY_TO(VisitOMPClauseList(C));
@@ -3908,9 +4014,9 @@ RecursiveASTVisitor<Derived>::VisitOMPReductionClause(OMPReductionClause *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPTaskReductionClause(
-    OMPTaskReductionClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPTaskReductionClause(
+    MaybeConst<OMPTaskReductionClause> *C) {
   TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
   TRY_TO(VisitOMPClauseList(C));
@@ -3930,9 +4036,9 @@ bool RecursiveASTVisitor<Derived>::VisitOMPTaskReductionClause(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPInReductionClause(
-    OMPInReductionClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPInReductionClause(
+    MaybeConst<OMPInReductionClause> *C) {
   TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
   TRY_TO(VisitOMPClauseList(C));
@@ -3954,140 +4060,148 @@ bool RecursiveASTVisitor<Derived>::VisitOMPInReductionClause(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(OMPFlushClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFlushClause(
+    MaybeConst<OMPFlushClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDepobjClause(OMPDepobjClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDepobjClause(
+    MaybeConst<OMPDepobjClause> *C) {
   TRY_TO(TraverseStmt(C->getDepobj()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(OMPDependClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDependClause(
+    MaybeConst<OMPDependClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDeviceClause(OMPDeviceClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDeviceClause(
+    MaybeConst<OMPDeviceClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getDevice()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPMapClause(OMPMapClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPMapClause(
+    MaybeConst<OMPMapClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNumTeamsClause(
-    OMPNumTeamsClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNumTeamsClause(
+    MaybeConst<OMPNumTeamsClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   TRY_TO(VisitOMPClauseWithPreInit(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPThreadLimitClause(
-    OMPThreadLimitClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPThreadLimitClause(
+    MaybeConst<OMPThreadLimitClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   TRY_TO(VisitOMPClauseWithPreInit(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPPriorityClause(
-    OMPPriorityClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPPriorityClause(
+    MaybeConst<OMPPriorityClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getPriority()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPGrainsizeClause(
-    OMPGrainsizeClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPGrainsizeClause(
+    MaybeConst<OMPGrainsizeClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getGrainsize()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNumTasksClause(
-    OMPNumTasksClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNumTasksClause(
+    MaybeConst<OMPNumTasksClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getNumTasks()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPHintClause(OMPHintClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPHintClause(
+    MaybeConst<OMPHintClause> *C) {
   TRY_TO(TraverseStmt(C->getHint()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDistScheduleClause(
-    OMPDistScheduleClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDistScheduleClause(
+    MaybeConst<OMPDistScheduleClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getChunkSize()));
   return true;
 }
 
-template <typename Derived>
-bool
-RecursiveASTVisitor<Derived>::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDefaultmapClause(
+    MaybeConst<OMPDefaultmapClause> *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPToClause(OMPToClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPToClause(
+    MaybeConst<OMPToClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFromClause(OMPFromClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFromClause(
+    MaybeConst<OMPFromClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUseDevicePtrClause(
-    OMPUseDevicePtrClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUseDevicePtrClause(
+    MaybeConst<OMPUseDevicePtrClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUseDeviceAddrClause(
-    OMPUseDeviceAddrClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUseDeviceAddrClause(
+    MaybeConst<OMPUseDeviceAddrClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPIsDevicePtrClause(
-    OMPIsDevicePtrClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPIsDevicePtrClause(
+    MaybeConst<OMPIsDevicePtrClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPHasDeviceAddrClause(
-    OMPHasDeviceAddrClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPHasDeviceAddrClause(
+    MaybeConst<OMPHasDeviceAddrClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPNontemporalClause(
-    OMPNontemporalClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPNontemporalClause(
+    MaybeConst<OMPNontemporalClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   for (auto *E : C->private_refs()) {
     TRY_TO(TraverseStmt(E));
@@ -4095,20 +4209,22 @@ bool RecursiveASTVisitor<Derived>::VisitOMPNontemporalClause(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPOrderClause(OMPOrderClause *) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPOrderClause(
+    MaybeConst<OMPOrderClause> *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDetachClause(OMPDetachClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDetachClause(
+    MaybeConst<OMPDetachClause> *C) {
   TRY_TO(TraverseStmt(C->getEventHandler()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPUsesAllocatorsClause(
-    OMPUsesAllocatorsClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPUsesAllocatorsClause(
+    MaybeConst<OMPUsesAllocatorsClause> *C) {
   for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
     const OMPUsesAllocatorsClause::Data Data = C->getAllocatorData(I);
     TRY_TO(TraverseStmt(Data.Allocator));
@@ -4117,77 +4233,83 @@ bool RecursiveASTVisitor<Derived>::VisitOMPUsesAllocatorsClause(
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPAffinityClause(
-    OMPAffinityClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPAffinityClause(
+    MaybeConst<OMPAffinityClause> *C) {
   TRY_TO(TraverseStmt(C->getModifier()));
-  for (Expr *E : C->varlist())
+  for (ExprPtr E : C->varlist())
     TRY_TO(TraverseStmt(E));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFilterClause(OMPFilterClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPFilterClause(
+    MaybeConst<OMPFilterClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getThreadID()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPBindClause(OMPBindClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPBindClause(
+    MaybeConst<OMPBindClause> *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPXDynCGroupMemClause(
-    OMPXDynCGroupMemClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPXDynCGroupMemClause(
+    MaybeConst<OMPXDynCGroupMemClause> *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getSize()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDoacrossClause(
-    OMPDoacrossClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPDoacrossClause(
+    MaybeConst<OMPDoacrossClause> *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPXAttributeClause(
-    OMPXAttributeClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPXAttributeClause(
+    MaybeConst<OMPXAttributeClause> *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPXBareClause(OMPXBareClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOMPXBareClause(
+    MaybeConst<OMPXBareClause> *C) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseOpenACCConstructStmt(
-    OpenACCConstructStmt *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::TraverseOpenACCConstructStmt(
+    MaybeConst<OpenACCConstructStmt> *C) {
   TRY_TO(VisitOpenACCClauseList(C->clauses()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseOpenACCAssociatedStmtConstruct(
-    OpenACCAssociatedStmtConstruct *S) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::
+    TraverseOpenACCAssociatedStmtConstruct(
+        MaybeConst<OpenACCAssociatedStmtConstruct> *S) {
   TRY_TO(TraverseOpenACCConstructStmt(S));
-  TRY_TO(TraverseStmt(S->getAssociatedStmt()));
+  // TODO: Need to access getAssociatedStmt() which is currently protected
+  // TRY_TO(TraverseStmt(S->getAssociatedStmt()));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOpenACCClause(const OpenACCClause *C) {
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOpenACCClause(
+    const OpenACCClause *C) {
   for (const Stmt *Child : C->children())
-    TRY_TO(TraverseStmt(const_cast<Stmt *>(Child)));
+    TRY_TO(TraverseStmt(const_cast<MaybeConst<Stmt> *>(Child)));
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOpenACCClauseList(
+template <typename Derived, bool IsConst>
+bool RecursiveASTVisitorBase<Derived, IsConst>::VisitOpenACCClauseList(
     ArrayRef<const OpenACCClause *> Clauses) {
 
   for (const auto *C : Clauses)
@@ -4257,6 +4379,16 @@ DEF_TRAVERSE_STMT(HLSLOutArgExpr, {})
 
 #undef TRY_TO
 
+// Backward compatibility - keep the original class name structure
+template <typename Derived>
+class RecursiveASTVisitor
+    : public RecursiveASTVisitorBase<Derived, /*IsConst=*/false> {};
+
+// New const-aware visitor interface
+template <typename Derived>
+class ConstRecursiveASTVisitor
+    : public RecursiveASTVisitorBase<Derived, /*IsConst=*/true> {};
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
diff --git a/clang/include/clang/AST/StmtOpenACC.h b/clang/include/clang/AST/StmtOpenACC.h
index 8b4554e996326..a6b6d9d802c2a 100644
--- a/clang/include/clang/AST/StmtOpenACC.h
+++ b/clang/include/clang/AST/StmtOpenACC.h
@@ -81,7 +81,6 @@ class OpenACCConstructStmt : public Stmt {
 class OpenACCAssociatedStmtConstruct : public OpenACCConstructStmt {
   friend class ASTStmtWriter;
   friend class ASTStmtReader;
-  template <typename Derived> friend class RecursiveASTVisitor;
   Stmt *AssociatedStmt = nullptr;
 
 protected:
diff --git a/clang/lib/AST/ParentMapContext.cpp b/clang/lib/AST/ParentMapContext.cpp
index acc011cb2faa4..506e4dd9d00d6 100644
--- a/clang/lib/AST/ParentMapContext.cpp
+++ b/clang/lib/AST/ParentMapContext.cpp
@@ -363,7 +363,7 @@ class ParentMapContext::ParentMap::ASTVisitor
   ASTVisitor(ParentMap &Map) : Map(Map) {}
 
 private:
-  friend class RecursiveASTVisitor<ASTVisitor>;
+  friend class RecursiveASTVisitorBase<ASTVisitor, false>;
 
   using VisitorBase = RecursiveASTVisitor<ASTVisitor>;
 
diff --git a/clang/lib/Index/IndexBody.cpp b/clang/lib/Index/IndexBody.cpp
index 1979117d4695c..887b56968e47d 100644
--- a/clang/lib/Index/IndexBody.cpp
+++ b/clang/lib/Index/IndexBody.cpp
@@ -508,7 +508,7 @@ class BodyIndexer : public RecursiveASTVisitor<BodyIndexer> {
   bool TraverseTypeConstraint(const TypeConstraint *C) {
     IndexCtx.handleReference(C->getNamedConcept(), C->getConceptNameLoc(),
                              Parent, ParentDC);
-    return RecursiveASTVisitor::TraverseTypeConstraint(C);
+    return base::TraverseTypeConstraint(C);
   }
 };
 
diff --git a/clang/unittests/AST/RecursiveASTVisitorTest.cpp b/clang/unittests/AST/RecursiveASTVisitorTest.cpp
index c5ad29a77d211..f2111a9551213 100644
--- a/clang/unittests/AST/RecursiveASTVisitorTest.cpp
+++ b/clang/unittests/AST/RecursiveASTVisitorTest.cpp
@@ -143,6 +143,82 @@ std::vector<VisitEvent> collectEvents(llvm::StringRef Code,
       Code, FileName);
   return std::move(Visitor).takeEvents();
 }
+class ConstCollectInterestingEvents
+    : public ConstRecursiveASTVisitor<ConstCollectInterestingEvents> {
+public:
+  bool TraverseFunctionDecl(const FunctionDecl *D) {
+    Events.push_back(VisitEvent::StartTraverseFunction);
+    bool Ret = ConstRecursiveASTVisitor::TraverseFunctionDecl(D);
+    Events.push_back(VisitEvent::EndTraverseFunction);
+
+    return Ret;
+  }
+
+  bool TraverseAttr(const Attr *A) {
+    Events.push_back(VisitEvent::StartTraverseAttr);
+    bool Ret = ConstRecursiveASTVisitor::TraverseAttr(A);
+    Events.push_back(VisitEvent::EndTraverseAttr);
+
+    return Ret;
+  }
+
+  bool TraverseEnumDecl(const EnumDecl *D) {
+    Events.push_back(VisitEvent::StartTraverseEnum);
+    bool Ret = ConstRecursiveASTVisitor::TraverseEnumDecl(D);
+    Events.push_back(VisitEvent::EndTraverseEnum);
+
+    return Ret;
+  }
+
+  bool TraverseTypedefTypeLoc(TypedefTypeLoc TL, bool TraverseQualifier) {
+    Events.push_back(VisitEvent::StartTraverseTypedefType);
+    bool Ret =
+        ConstRecursiveASTVisitor::TraverseTypedefTypeLoc(TL, TraverseQualifier);
+    Events.push_back(VisitEvent::EndTraverseTypedefType);
+
+    return Ret;
+  }
+
+  bool TraverseObjCInterfaceDecl(const ObjCInterfaceDecl *ID) {
+    Events.push_back(VisitEvent::StartTraverseObjCInterface);
+    bool Ret = ConstRecursiveASTVisitor::TraverseObjCInterfaceDecl(ID);
+    Events.push_back(VisitEvent::EndTraverseObjCInterface);
+
+    return Ret;
+  }
+
+  bool TraverseObjCProtocolDecl(const ObjCProtocolDecl *PD) {
+    Events.push_back(VisitEvent::StartTraverseObjCProtocol);
+    bool Ret = ConstRecursiveASTVisitor::TraverseObjCProtocolDecl(PD);
+    Events.push_back(VisitEvent::EndTraverseObjCProtocol);
+
+    return Ret;
+  }
+
+  bool TraverseObjCProtocolLoc(ObjCProtocolLoc ProtocolLoc) {
+    Events.push_back(VisitEvent::StartTraverseObjCProtocolLoc);
+    bool Ret = ConstRecursiveASTVisitor::TraverseObjCProtocolLoc(ProtocolLoc);
+    Events.push_back(VisitEvent::EndTraverseObjCProtocolLoc);
+
+    return Ret;
+  }
+
+  std::vector<VisitEvent> takeEvents() && { return std::move(Events); }
+
+private:
+  std::vector<VisitEvent> Events;
+};
+
+std::vector<VisitEvent> collectConstEvents(llvm::StringRef Code,
+                                           const Twine &FileName = "input.cc") {
+  ConstCollectInterestingEvents Visitor;
+  clang::tooling::runToolOnCode(
+      std::make_unique<ProcessASTAction>(
+          [&](const clang::ASTContext &Ctx) { Visitor.TraverseAST(Ctx); }),
+      Code, FileName);
+  return std::move(Visitor).takeEvents();
+}
+
 } // namespace
 
 TEST(RecursiveASTVisitorTest, AttributesInsideDecls) {
@@ -151,6 +227,7 @@ TEST(RecursiveASTVisitorTest, AttributesInsideDecls) {
 __attribute__((annotate("something"))) int foo() { return 10; }
   )cpp";
 
+  EXPECT_EQ(collectEvents(Code), collectConstEvents(Code));
   EXPECT_THAT(collectEvents(Code),
               ElementsAre(VisitEvent::StartTraverseFunction,
                           VisitEvent::StartTraverseAttr,
@@ -165,6 +242,7 @@ TEST(RecursiveASTVisitorTest, EnumDeclWithBase) {
   enum Bar : Foo;
   )cpp";
 
+  EXPECT_EQ(collectEvents(Code), collectConstEvents(Code));
   EXPECT_THAT(collectEvents(Code),
               ElementsAre(VisitEvent::StartTraverseEnum,
                           VisitEvent::StartTraverseTypedefType,
@@ -184,6 +262,7 @@ TEST(RecursiveASTVisitorTest, InterfaceDeclWithProtocols) {
   @end
   )cpp";
 
+  EXPECT_EQ(collectEvents(Code), collectConstEvents(Code));
   EXPECT_THAT(collectEvents(Code, "input.m"),
               ElementsAre(VisitEvent::StartTraverseObjCProtocol,
                           VisitEvent::EndTraverseObjCProtocol,
@@ -196,3 +275,53 @@ TEST(RecursiveASTVisitorTest, InterfaceDeclWithProtocols) {
                           VisitEvent::EndTraverseObjCProtocolLoc,
                           VisitEvent::EndTraverseObjCInterface));
 }
+
+TEST(ConstRecursiveASTVisitorTest, ConstCorrectness) {
+  // This test verifies that ConstRecursiveASTVisitor properly enforces
+  // const-correctness.
+  // The derived class defines const versions of the Visit* methods,
+  // and they should correctly override the default implementations,
+  // which is demonstrated by non-0 counters.
+
+  class ConstCorrectnessValidator
+      : public ConstRecursiveASTVisitor<ConstCorrectnessValidator> {
+  public:
+    bool VisitFunctionDecl(const FunctionDecl *D) {
+      FunctionDeclCount++;
+      return true;
+    }
+
+    bool VisitStmt(const Stmt *S) {
+      StmtCount++;
+      return true;
+    }
+
+    int getFunctionDeclCount() const { return FunctionDeclCount; }
+    int getStmtCount() const { return StmtCount; }
+
+  private:
+    int FunctionDeclCount = 0;
+    int StmtCount = 0;
+  };
+
+  llvm::StringRef Code = R"cpp(
+    int foo() {
+      return 42;
+    }
+    void bar() {
+      int x = 0;
+      x += 2;
+    }
+  )cpp";
+
+  ConstCorrectnessValidator Visitor;
+  clang::tooling::runToolOnCode(
+      std::make_unique<ProcessASTAction>(
+          [&](clang::ASTContext &Ctx) { Visitor.TraverseAST(Ctx); }),
+      Code);
+
+  // Verify that the visitor found the expected number of nodes
+  EXPECT_EQ(Visitor.getFunctionDeclCount(), 2); // foo and bar
+  // There are at least 3 statements: return 42; int x = 0; x += 2;
+  EXPECT_GE(Visitor.getStmtCount(), 3);
+}
diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp
index 1342e1a6ffb5b..fef20abec00f1 100644
--- a/clang/utils/TableGen/ClangAttrEmitter.cpp
+++ b/clang/utils/TableGen/ClangAttrEmitter.cpp
@@ -3983,10 +3983,10 @@ void EmitClangAttrASTVisitor(const RecordKeeper &Records, raw_ostream &OS) {
     const Record &R = *Attr;
     if (!R.getValueAsBit("ASTNode"))
       continue;
-    OS << "  bool Traverse"
-       << R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
-    OS << "  bool Visit"
-       << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
+    OS << "  bool Traverse" << R.getName() << "Attr(MaybeConst<" << R.getName()
+       << "Attr> *A);\n";
+    OS << "  bool Visit" << R.getName() << "Attr(MaybeConst<" << R.getName()
+       << "Attr> *A) {\n"
        << "    return true; \n"
        << "  }\n";
   }
@@ -3998,9 +3998,9 @@ void EmitClangAttrASTVisitor(const RecordKeeper &Records, raw_ostream &OS) {
     if (!R.getValueAsBit("ASTNode"))
       continue;
 
-    OS << "template <typename Derived>\n"
-       << "bool VISITORCLASS<Derived>::Traverse"
-       << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
+    OS << "template <typename Derived, bool IsConst>\n"
+       << "bool VISITORCLASS<Derived, IsConst>::Traverse" << R.getName()
+       << "Attr(MaybeConst<" << R.getName() << "Attr> *A) {\n"
        << "  if (!getDerived().VisitAttr(A))\n"
        << "    return false;\n"
        << "  if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
@@ -4018,8 +4018,9 @@ void EmitClangAttrASTVisitor(const RecordKeeper &Records, raw_ostream &OS) {
   }
 
   // Write generic Traverse routine
-  OS << "template <typename Derived>\n"
-     << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
+  OS << "template <typename Derived, bool IsConst>\n"
+     << "bool VISITORCLASS<Derived, IsConst>::TraverseAttr("
+     << "MaybeConst<Attr> *A) {\n"
      << "  if (!A)\n"
      << "    return true;\n"
      << "\n"
@@ -4032,7 +4033,8 @@ void EmitClangAttrASTVisitor(const RecordKeeper &Records, raw_ostream &OS) {
 
     OS << "    case attr::" << R.getName() << ":\n"
        << "      return getDerived().Traverse" << R.getName() << "Attr("
-       << "cast<" << R.getName() << "Attr>(A));\n";
+       << "const_cast<MaybeConst<" << R.getName()
+       << "Attr> *>(static_cast<const " << R.getName() << "Attr *>(A)));\n";
   }
   OS << "  }\n";  // end switch
   OS << "  llvm_unreachable(\"bad attribute kind\");\n";