[clang-tidy] performance-unnecessary-copy-initialization: handle pointer containers.

[courbet]

Summary

This includes modifying DeclRefExprUtils to handle more cases.

[courbet]

Rebase on submitted unit tests so that we can see the changes better.

[flx]

This looks great, but goes past my knowledge of the AST API :) While the existing and new test coverage provides good confidence, one other reviewer taking look would be good.

clang-tools-extra/clang-tidy/utils/DeclRefExprUtils.cpp

112

Reuse Ctx here?

[courbet]

Add more comments on the approach.

[courbet]

address comment

clang-tools-extra/clang-tidy/performance/UnnecessaryCopyInitialization.cpp

AST_MATCHER_FUNCTION_P(StatementMatcher, isConstRefReturningMethodCall,
   // const, this will be checked in `check()` part. This returned const
   // reference is highly likely to outlive the local const reference of the
   // variable being declared. The assumption is that the const reference being
   // returned either points to a global static variable or to a member of the
   // called object.
   const auto MethodDecl =
       cxxMethodDecl(returns(hasCanonicalType(matchers::isReferenceToConst())))
           .bind(MethodDeclId);
-  const auto ReceiverExpr = declRefExpr(to(varDecl().bind(ObjectArgId)));
+  const auto ReceiverExpr =
+      ignoringParenImpCasts(declRefExpr(to(varDecl().bind(ObjectArgId))));
   const auto ReceiverType =
       hasCanonicalType(recordType(hasDeclaration(namedDecl(
           unless(matchers::matchesAnyListedName(ExcludedContainerTypes))))));
 
   return expr(anyOf(
       cxxMemberCallExpr(callee(MethodDecl), on(ReceiverExpr),
                         thisPointerType(ReceiverType)),
-      cxxOperatorCallExpr(callee(MethodDecl), hasArgument(0, ReceiverExpr),
-                          hasArgument(0, hasType(ReceiverType)))));
+      cxxOperatorCallExpr(
+          callee(MethodDecl),
+          // We allow operators to be called on objects or
+          // dereference of pointer-to-object.
+          hasArgument(0, expr(hasType(ReceiverType),
+                              anyOf(ReceiverExpr,
+                                    ignoringParenImpCasts(unaryOperator(
+                                        hasOperatorName("*"),
+                                        hasUnaryOperand(ReceiverExpr)))))))));
 }
 
 AST_MATCHER_FUNCTION(StatementMatcher, isConstRefReturningFunctionCall) {
   // Only allow initialization of a const reference from a free function if it
   // has no arguments. Otherwise it could return an alias to one of its
   // arguments and the arguments need to be checked for const use as well.
   return callExpr(callee(functionDecl(returns(hasCanonicalType(
                                           matchers::isReferenceToConst())))

clang-tools-extra/clang-tidy/utils/DeclRefExprUtils.cpp

 //===--- DeclRefExprUtils.cpp - clang-tidy---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DeclRefExprUtils.h"

 // Extracts all Nodes keyed by ID from Matches and inserts them into Nodes.
 template <typename Node>
 void extractNodesByIdTo(ArrayRef<BoundNodes> Matches, StringRef ID,
                         SmallPtrSet<const Node *, 16> &Nodes) {
   for (const auto &Match : Matches)
     Nodes.insert(Match.getNodeAs<Node>(ID));
 }
 
+// A matcher that matches DeclRefExprs that are only used in a const way.
+// When the variable is a pointer, we require all nesting levels to be const.
+AST_MATCHER(DeclRefExpr, isOnlyUsedAsConst) {
+  // The idea of the algorithm is that even if the root DeclRefExpr (`Node`) is
+  // modifiable, it can be cast to a const higher up in the AST. For example:
+  //
+  // |-CallExpr <line:16:3, col:17> 'void'
+  //   | |-ImplicitCastExpr <col:3> 'void (*)(const S *)' <FunctionToPointerDecay>
+  //   | | `-DeclRefExpr <col:3> 'void (const S *)' lvalue Function 0x55e4ecbc8208 'useConstPtr' 'void (const S *)'
+  //   | `-ImplicitCastExpr <col:15, col:16> 'const S *' <NoOp>
+  //   |   `-UnaryOperator <col:15, col:16> 'S *' prefix '&' cannot overflow
+  //   |     `-DeclRefExpr <col:16> 'S' lvalue ParmVar 0x55e4ecbc82c0 's' 'S'
+  //
+  // The only node where constness matters is the `ImplicitCastExpr` to
+  // `const S*`, because that's the one that is passed to the `CallExpr`. The
+  // fact that intermediate nodes (e.g. `UnaryOperator`) can modify the value is
+  // irrelevant, because no ancestor of these nodes actually observes their
+  // value in a mutable way.
+  //
+  // We classify nodes in two types depending on whether they can modify the
+  // state of the objects represented by their arguments: We call "vetted" the
+  // nodes that cannot change the that state.
+  // For example, a `CallExpr` node can mutate the state of its arguments
+  // (e.g., a function that takes a parameter by reference can mutate the state
+  // of that argument), so it is not vetted. However, an `LValueToRValue` cast
+  // does not directly change the state of its argument, (only a parent can) so
+  // it is vetted.
+  //
+  // The algorithm works as follows: we look at the inverse tree rooted at
+  // `Node` (DeclRefExpr->UnaryOperator->ImplicitCastExpr->CallExpr in the
+  // example), and walk up the vetted nodes to find nodes that have unvetted
+  // parents. We call these "unsafe" nodes.
+  // In the example above, the DeclRefExpr, UnaryOperator, and ImplicitCastExpr
+  // are vetted. The DeclRefExpr and UnaryOperator are safe, and the
+  // ImplicitCastExpr is unsafe.
+  // When we find an unsafe node, we finally check whether the type of that node
+  // allows mutations (in which case the parent can actually mutate the state),
+  // or not (e.g. a `const T*` rvalue cannot be modified through that pointer).
+  // If we find an unsafe node with a type that allows mutation, we cannot
+  // guarantee the the value is used only in a const way, so we return false.
+  // Else, we keep traversing the tree until we find a mutable unsafe node or
+  // there are no more nodes, in which case we conclude that there is no way to
+  // modify the state of the root.
+
+  // We traverse the inverse tree in DFS. The stack contains only vetted nodes.
+  std::vector<const Expr *> Stack = {&Node};
+  auto &Ctx = Finder->getASTContext();
+
+  // Returns true if the node is vetted.
+  const auto IsVetted = [](const Expr *const E) {
+    if (const auto *const Paren = dyn_cast<ParenExpr>(E)) {
+      return true; // No-op.
+    }
+    if (const auto *const Cast = dyn_cast<CastExpr>(E)) {
+      // Bail out on casts that we cannot check. Defaults to safe.
+      switch (Cast->getCastKind()) {
+      case CK_LValueToRValue:
+      case CK_NoOp:
+      case CK_BaseToDerived:
+      case CK_DerivedToBase:
+      case CK_UncheckedDerivedToBase:
+      case CK_Dynamic:
+      case CK_BaseToDerivedMemberPointer:
+      case CK_DerivedToBaseMemberPointer:
+      case CK_ToVoid:
+      case CK_PointerToBoolean:
+        return true;
+      default:
+        return false;
+      }
+    }
+    if (const auto *const Op = dyn_cast<UnaryOperator>(E)) {
+      switch (Op->getOpcode()) {
+      case UO_AddrOf:
+      case UO_Deref:
+        return true;
+      default:
+        return false;
+      }
+    }
+    if (const auto *const Member = dyn_cast<MemberExpr>(E)) {
+      if (const auto *const Method =
+              dyn_cast<CXXMethodDecl>(Member->getMemberDecl())) {
+        return Method->isConst();
+      }
+      return true;
+    }
+    return false;
+  };
+
+  while (!Stack.empty()) {
+    const Expr *const E = Stack.back();
+    Stack.pop_back();
+    const auto Parents = Ctx.getParents(*E);
+    bool IsUnsafe = false;
+    for (const auto &Parent : Parents) {
+      const Expr *const ParentExpr = Parent.get<Expr>();
+      if (ParentExpr == nullptr) {
+        continue; // ParentExpr's value is unused.
+      }
+      if (IsVetted(ParentExpr)) {
+        Stack.push_back(ParentExpr);
+      } else {
+        // `E` has an unvetted parent, it's unsafe.
+        IsUnsafe = true;
+      }
+    }
+    if (IsUnsafe) {
+      // The node is unsafe, check the type of the node for mutability.
+      SourceLocation Loc;
+      switch (
+          E->ClassifyModifiable(Finder->getASTContext(), Loc).getModifiable()) {
+      case Expr::Classification::CM_Untested:
+      case Expr::Classification::CM_Modifiable:
+        return false;
+      case Expr::Classification::CM_ConstQualified:
+      case Expr::Classification::CM_ConstQualifiedField:
+      case Expr::Classification::CM_ConstAddrSpace:
+      case Expr::Classification::CM_Function:
+      case Expr::Classification::CM_RValue:
+      case Expr::Classification::CM_LValueCast:
+        break;
+      // Not sure about these, err on the safe side.
+      case Expr::Classification::CM_NoSetterProperty:
+      case Expr::Classification::CM_ArrayType:
+      case Expr::Classification::CM_IncompleteType:
+        return false;
+      }
+      // Check that the type prevents modification through pointers.
+      for (QualType Ty = E->getType().getCanonicalType()->getPointeeType();
+           !Ty.isNull(); Ty = Ty->getPointeeType()) {
+        Ty = Ty.getCanonicalType();
+        if (!Ty.isConstQualified()) {
+          return false;
+        }
+      }
+    }
+  }
+  // All unsafe nodes have immutable type.
+  return true;
+}
+
 } // namespace
 
 // Finds all DeclRefExprs where a const method is called on VarDecl or VarDecl
 // is the a const reference or value argument to a CallExpr or CXXConstructExpr.
 SmallPtrSet<const DeclRefExpr *, 16>
 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt,
                            ASTContext &Context) {
-  auto DeclRefToVar =
-      declRefExpr(to(varDecl(equalsNode(&VarDecl)))).bind("declRef");
-  auto ConstMethodCallee = callee(cxxMethodDecl(isConst()));
-  // Match method call expressions where the variable is referenced as the this
-  // implicit object argument and operator call expression for member operators
-  // where the variable is the 0-th argument.
-  auto Matches = match(
-      findAll(expr(anyOf(cxxMemberCallExpr(ConstMethodCallee, on(DeclRefToVar)),
-                         cxxOperatorCallExpr(ConstMethodCallee,
-                                             hasArgument(0, DeclRefToVar))))),
+  auto Matches = match(findAll(declRefExpr(to(varDecl(equalsNode(&VarDecl))),
+                                           isOnlyUsedAsConst())
+                                   .bind("declRef")),
                        Stmt, Context);
   SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
-  auto ConstReferenceOrValue =
-      qualType(anyOf(matchers::isReferenceToConst(),
-                     unless(anyOf(referenceType(), pointerType(),
-                                  substTemplateTypeParmType()))));
-  auto ConstReferenceOrValueOrReplaced = qualType(anyOf(
-      ConstReferenceOrValue,
-      substTemplateTypeParmType(hasReplacementType(ConstReferenceOrValue))));
-  auto UsedAsConstRefOrValueArg = forEachArgumentWithParam(
-      DeclRefToVar, parmVarDecl(hasType(ConstReferenceOrValueOrReplaced)));
-  Matches = match(findAll(invocation(UsedAsConstRefOrValueArg)), Stmt, Context);
-  extractNodesByIdTo(Matches, "declRef", DeclRefs);
-  // References and pointers to const assignments.
-  Matches =
-      match(findAll(declStmt(
-                has(varDecl(hasType(qualType(matchers::isReferenceToConst())),
-                            hasInitializer(ignoringImpCasts(DeclRefToVar)))))),
-            Stmt, Context);
-  extractNodesByIdTo(Matches, "declRef", DeclRefs);
-  Matches =
-      match(findAll(declStmt(has(varDecl(
-                hasType(qualType(matchers::isPointerToConst())),
-                hasInitializer(ignoringImpCasts(unaryOperator(
-                    hasOperatorName("&"), hasUnaryOperand(DeclRefToVar)))))))),
-            Stmt, Context);
-  extractNodesByIdTo(Matches, "declRef", DeclRefs);
   return DeclRefs;
 }
 
 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
                        ASTContext &Context) {
   // Collect all DeclRefExprs to the loop variable and all CallExprs and
   // CXXConstructExprs where the loop variable is used as argument to a const
   // reference parameter.

clang-tools-extra/test/clang-tidy/checkers/performance-unnecessary-copy-initialization.cpp

void PositiveOperatorCallConstValueParamAlias(const ExpensiveToCopyContainerAlias C) {
   const ExpensiveToCopyType VarCopyConstructed(C[42]);
   // CHECK-MESSAGES: [[@LINE-1]]:29: warning: the const qualified variable 'VarCopyConstructed'
   // CHECK-FIXES: const ExpensiveToCopyType& VarCopyConstructed(C[42]);
   VarCopyConstructed.constMethod();
 }
 
 void PositiveOperatorCallConstValueParam(const Container<ExpensiveToCopyType>* C) {
   const auto AutoAssigned = (*C)[42];
-  // TODO-MESSAGES: [[@LINE-1]]:14: warning: the const qualified variable 'AutoAssigned'
-  // TODO-FIXES: const auto& AutoAssigned = (*C)[42];
+  // CHECK-MESSAGES: [[@LINE-1]]:14: warning: the const qualified variable 'AutoAssigned'
+  // CHECK-FIXES: const auto& AutoAssigned = (*C)[42];
   AutoAssigned.constMethod();
 
   const auto AutoCopyConstructed((*C)[42]);
-  // TODO-MESSAGES: [[@LINE-1]]:14: warning: the const qualified variable 'AutoCopyConstructed'
-  // TODO-FIXES: const auto& AutoCopyConstructed((*C)[42]);
+  // CHECK-MESSAGES: [[@LINE-1]]:14: warning: the const qualified variable 'AutoCopyConstructed'
+  // CHECK-FIXES: const auto& AutoCopyConstructed((*C)[42]);
   AutoCopyConstructed.constMethod();
 
   const ExpensiveToCopyType VarAssigned = C->operator[](42);
-  // TODO-MESSAGES: [[@LINE-1]]:29: warning: the const qualified variable 'VarAssigned'
-  // TODO-FIXES: const ExpensiveToCopyType& VarAssigned = C->operator[](42);
+  // CHECK-MESSAGES: [[@LINE-1]]:29: warning: the const qualified variable 'VarAssigned'
+  // CHECK-FIXES: const ExpensiveToCopyType& VarAssigned = C->operator[](42);
   VarAssigned.constMethod();
 
   const ExpensiveToCopyType VarCopyConstructed(C->operator[](42));
-  // TODO-MESSAGES: [[@LINE-1]]:29: warning: the const qualified variable 'VarCopyConstructed'
-  // TODO-FIXES: const ExpensiveToCopyType& VarCopyConstructed(C->operator[](42));
+  // CHECK-MESSAGES: [[@LINE-1]]:29: warning: the const qualified variable 'VarCopyConstructed'
+  // CHECK-FIXES: const ExpensiveToCopyType& VarCopyConstructed(C->operator[](42));
   VarCopyConstructed.constMethod();
 }
 
 void PositiveLocalConstValue() {
   const ExpensiveToCopyType Obj;
   const auto UnnecessaryCopy = Obj.reference();
   // CHECK-MESSAGES: [[@LINE-1]]:14: warning: the const qualified variable 'UnnecessaryCopy'
   // CHECK-FIXES: const auto& UnnecessaryCopy = Obj.reference();

clang-tools-extra/unittests/clang-tidy/DeclRefExprUtilsTest.cpp

EXPECT_EQ(Code, runCheckOnCode<ConstReferenceDeclRefExprsTransform>(
                       join(Parts, "")));
 }
 
 TEST(ConstReferenceDeclRefExprsTest, ConstValueVar) {
   RunTest(R"(
     void f(const S target) {
       useVal(/*const*/target);
       useConstRef(/*const*/target);
-      useConstPtr(&target);
-      useConstPtrConstRef(&target);
+      useConstPtr(&/*const*/target);
+      useConstPtrConstRef(&/*const*/target);
       /*const*/target.constMethod();
       /*const*/target(ConstTag{});
       /*const*/target[42];
       useConstRef((/*const*/target));
       (/*const*/target).constMethod();
       (void)(/*const*/target == /*const*/target);
-      (void)target;
-      (void)&target;
-      (void)*&target;
+      (void)/*const*/target;
+      (void)&/*const*/target;
+      (void)*&/*const*/target;
       S copy1 = /*const*/target;
       S copy2(/*const*/target);
-      useInt(target.int_member);
-      useIntConstRef(target.int_member);
+      useInt(/*const*/target.int_member);
+      useIntConstRef(/*const*/target.int_member);
       useIntPtr(target.ptr_member);
-      useIntConstPtr(&target.int_member);
+      useIntConstPtr(&/*const*/target.int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, ConstRefVar) {
   RunTest(R"(
     void f(const S& target) {
       useVal(/*const*/target);
       useConstRef(/*const*/target);
-      useConstPtr(&target);
-      useConstPtrConstRef(&target);
+      useConstPtr(&/*const*/target);
+      useConstPtrConstRef(&/*const*/target);
       /*const*/target.constMethod();
       /*const*/target(ConstTag{});
       /*const*/target[42];
       useConstRef((/*const*/target));
       (/*const*/target).constMethod();
       (void)(/*const*/target == /*const*/target);
-      (void)target;
-      (void)&target;
-      (void)*&target;
+      (void)/*const*/target;
+      (void)&/*const*/target;
+      (void)*&/*const*/target;
       S copy1 = /*const*/target;
       S copy2(/*const*/target);
-      useInt(target.int_member);
-      useIntConstRef(target.int_member);
+      useInt(/*const*/target.int_member);
+      useIntConstRef(/*const*/target.int_member);
       useIntPtr(target.ptr_member);
-      useIntConstPtr(&target.int_member);
+      useIntConstPtr(&/*const*/target.int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, ValueVar) {
   RunTest(R"(
     void f(S target, const S& other) {
       useConstRef(/*const*/target);
       useVal(/*const*/target);
-      useConstPtr(&target);
-      useConstPtrConstRef(&target);
+      useConstPtr(&/*const*/target);
+      useConstPtrConstRef(&/*const*/target);
       /*const*/target.constMethod();
       target.nonConstMethod();
       /*const*/target(ConstTag{});
       target[42];
       /*const*/target(ConstTag{});
       target(NonConstTag{});
       useRef(target);
       usePtr(&target);
       useConstRef((/*const*/target));
       (/*const*/target).constMethod();
       (void)(/*const*/target == /*const*/target);
       (void)(/*const*/target == other);
-      (void)target;
-      (void)&target;
-      (void)*&target;
+      (void)/*const*/target;
+      (void)&/*const*/target;
+      (void)*&/*const*/target;
       S copy1 = /*const*/target;
       S copy2(/*const*/target);
-      useInt(target.int_member);
-      useIntConstRef(target.int_member);
+      useInt(/*const*/target.int_member);
+      useIntConstRef(/*const*/target.int_member);
       useIntPtr(target.ptr_member);
-      useIntConstPtr(&target.int_member);
+      useIntConstPtr(&/*const*/target.int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, RefVar) {
   RunTest(R"(
     void f(S& target) {
       useVal(/*const*/target);
       useConstRef(/*const*/target);
-      useConstPtr(&target);
-      useConstPtrConstRef(&target);
+      useConstPtr(&/*const*/target);
+      useConstPtrConstRef(&/*const*/target);
       /*const*/target.constMethod();
       target.nonConstMethod();
       /*const*/target(ConstTag{});
       target[42];
       useConstRef((/*const*/target));
       (/*const*/target).constMethod();
       (void)(/*const*/target == /*const*/target);
-      (void)target;
-      (void)&target;
-      (void)*&target;
+      (void)/*const*/target;
+      (void)&/*const*/target;
+      (void)*&/*const*/target;
       S copy1 = /*const*/target;
       S copy2(/*const*/target);
-      useInt(target.int_member);
-      useIntConstRef(target.int_member);
+      useInt(/*const*/target.int_member);
+      useIntConstRef(/*const*/target.int_member);
       useIntPtr(target.ptr_member);
-      useIntConstPtr(&target.int_member);
+      useIntConstPtr(&/*const*/target.int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, PtrVar) {
   RunTest(R"(
     void f(S* target) {
-      useVal(*target);
-      useConstRef(*target);
-      useConstPtr(target);
+      useVal(*/*const*/target);
+      useConstRef(*/*const*/target);
+      useConstPtr(/*const*/target);
       useConstPtrConstRef(/*const*/target);
       /*const*/target->constMethod();
       target->nonConstMethod();
-      (*target)(ConstTag{});
+      (*/*const*/target)(ConstTag{});
       (*target)[42];
       target->operator[](42);
-      useConstRef((*target));
+      useConstRef((*/*const*/target));
       (/*const*/target)->constMethod();
-      (void)(*target == *target);
-      (void)*target;
-      (void)target;
-      S copy1 = *target;
-      S copy2(*target);
-      useInt(target->int_member);
-      useIntConstRef(target->int_member);
+      (void)(*/*const*/target == */*const*/target);
+      (void)*/*const*/target;
+      (void)/*const*/target;
+      S copy1 = */*const*/target;
+      S copy2(*/*const*/target);
+      useInt(/*const*/target->int_member);
+      useIntConstRef(/*const*/target->int_member);
       useIntPtr(target->ptr_member);
-      useIntConstPtr(&target->int_member);
+      useIntConstPtr(&/*const*/target->int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, ConstPtrVar) {
   RunTest(R"(
     void f(const S* target) {
-      useVal(*target);
-      useConstRef(*target);
-      useConstPtr(target);
+      useVal(*/*const*/target);
+      useConstRef(*/*const*/target);
+      useConstPtr(/*const*/target);
       useConstPtrRef(target);
       useConstPtrPtr(&target);
-      useConstPtrConstPtr(&target);
+      useConstPtrConstPtr(&/*const*/target);
       useConstPtrConstRef(/*const*/target);
       /*const*/target->constMethod();
-      (*target)(ConstTag{});
-      (*target)[42];
+      (*/*const*/target)(ConstTag{});
+      (*/*const*/target)[42];
       /*const*/target->operator[](42);
-      (void)(*target == *target);
-      (void)target;
-      (void)*target;
-      if(target) {}
-      S copy1 = *target;
-      S copy2(*target);
-      useInt(target->int_member);
-      useIntConstRef(target->int_member);
+      (void)(*/*const*/target == */*const*/target);
+      (void)/*const*/target;
+      (void)*/*const*/target;
+      if(/*const*/target) {}
+      S copy1 = */*const*/target;
+      S copy2(*/*const*/target);
+      useInt(/*const*/target->int_member);
+      useIntConstRef(/*const*/target->int_member);
       useIntPtr(target->ptr_member);
-      useIntConstPtr(&target->int_member);
+      useIntConstPtr(&/*const*/target->int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, ConstPtrPtrVar) {
   RunTest(R"(
     void f(const S** target) {
-      useVal(**target);
-      useConstRef(**target);
-      useConstPtr(*target);
+      useVal(**/*const*/target);
+      useConstRef(**/*const*/target);
+      useConstPtr(*/*const*/target);
       useConstPtrRef(*target);
       useConstPtrPtr(target);
-      useConstPtrConstPtr(target);
-      useConstPtrConstRef(*target);
-      (void)target;
-      (void)*target;
-      (void)**target;
-      if(target) {}
-      if(*target) {}
-      S copy1 = **target;
-      S copy2(**target);
-      useInt((*target)->int_member);
-      useIntConstRef((*target)->int_member);
+      useConstPtrConstPtr(/*const*/target);
+      useConstPtrConstRef(*/*const*/target);
+      (void)/*const*/target;
+      (void)*/*const*/target;
+      (void)**/*const*/target;
+      if(/*const*/target) {}
+      if(*/*const*/target) {}
+      S copy1 = **/*const*/target;
+      S copy2(**/*const*/target);
+      useInt((*/*const*/target)->int_member);
+      useIntConstRef((*/*const*/target)->int_member);
       useIntPtr((*target)->ptr_member);
-      useIntConstPtr(&(*target)->int_member);
+      useIntConstPtr(&(*/*const*/target)->int_member);
     }
 )");
 }
 
 TEST(ConstReferenceDeclRefExprsTest, ConstPtrConstPtrVar) {
   RunTest(R"(
     void f(const S* const* target) {
-      useVal(**target);
-      useConstRef(**target);
-      useConstPtr(*target);
-      useConstPtrConstPtr(target);
-      useConstPtrConstRef(*target);
-      (void)target;
-      (void)target;
-      (void)**target;
-      if(target) {}
-      if(*target) {}
-      S copy1 = **target;
-      S copy2(**target);
-      useInt((*target)->int_member);
-      useIntConstRef((*target)->int_member);
+      useVal(**/*const*/target);
+      useConstRef(**/*const*/target);
+      useConstPtr(*/*const*/target);
+      useConstPtrConstPtr(/*const*/target);
+      useConstPtrConstRef(*/*const*/target);
+      (void)/*const*/target;
+      (void)*/*const*/target;
+      (void)**/*const*/target;
+      if(/*const*/target) {}
+      if(*/*const*/target) {}
+      S copy1 = **/*const*/target;
+      S copy2(**/*const*/target);
+      useInt((*/*const*/target)->int_member);
+      useIntConstRef((*/*const*/target)->int_member);
       useIntPtr((*target)->ptr_member);
-      useIntConstPtr(&(*target)->int_member);
+      useIntConstPtr(&(*/*const*/target)->int_member);
     }
 )");
 }
 
 } // namespace test
 } // namespace tidy
 } // namespace clang