[clang-tidy] Adds QualifierAlignment to misc-const-correctness.

[Mordante]

Summary

The fixit for misc-const-correctness was hard-coded to use east const.
Clang-format has the option to change east const to west const, but
that's not fool-proof.

This adds a option to the checker to select the placement of the const.
The naming is based on clang-format For backwards compatibility the east
const is the default.

Also fixes the documentation; previously it suggested west const is the
default.

[Eugene.Zelenko]

Shouldn't east/west added as aliases?

[njames93]

Duplicate of D131386

[Mordante]

In D131859#3721877, @njames93 wrote:

Duplicate of D131386

Thanks for the information. Can you integrate the additional fixes of this patch in yours; specifically the documentation and release notes fixes.

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h

 //===--- ConstCorrectnessCheck.h - clang-tidy -------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONSTCORRECTNESSCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONSTCORRECTNESSCHECK_H
 
 #include "../ClangTidyCheck.h"
+#include "../utils/FixItHintUtils.h"
 #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace clang {
 namespace tidy {
 
 namespace misc {
 
private:
 
   const bool AnalyzeValues;
   const bool AnalyzeReferences;
   const bool WarnPointersAsValues;
 
   const bool TransformValues;
   const bool TransformReferences;
   const bool TransformPointersAsValues;
+
+  const utils::fixit::QualifierPolicy QualPolicy;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONSTCORRECTNESSCHECK_H

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp

 //===--- ConstCorrectnessCheck.cpp - clang-tidy -----------------*- C++ -*-===//
 //
 // 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 "ConstCorrectnessCheck.h"
-#include "../utils/FixItHintUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 #include <iostream>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+
+template <> struct OptionEnumMapping<utils::fixit::QualifierPolicy> {
+  static llvm::ArrayRef<std::pair<utils::fixit::QualifierPolicy, StringRef>>
+  getEnumMapping() {
+    static constexpr std::pair<utils::fixit::QualifierPolicy, StringRef>
+        Mapping[] = {{utils::fixit::QualifierPolicy::Left, "left"},
+                     {utils::fixit::QualifierPolicy::Right, "right"}};
+    return makeArrayRef(Mapping);
+  }
+};
+
 namespace misc {
 
 namespace {
 // FIXME: This matcher exists in some other code-review as well.
 // It should probably move to ASTMatchers.
 AST_MATCHER(VarDecl, isLocal) { return Node.isLocalVarDecl(); }
 AST_MATCHER_P(DeclStmt, containsAnyDeclaration,
               ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
ConstCorrectnessCheck::ConstCorrectnessCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       AnalyzeValues(Options.get("AnalyzeValues", true)),
       AnalyzeReferences(Options.get("AnalyzeReferences", true)),
       WarnPointersAsValues(Options.get("WarnPointersAsValues", false)),
       TransformValues(Options.get("TransformValues", true)),
       TransformReferences(Options.get("TransformReferences", true)),
       TransformPointersAsValues(
-          Options.get("TransformPointersAsValues", false)) {
+          Options.get("TransformPointersAsValues", false)),
+      QualPolicy(Options.get("QualifierAlignment",
+                             utils::fixit::QualifierPolicy::Right)) {
   if (AnalyzeValues == false && AnalyzeReferences == false)
     this->configurationDiag(
         "The check 'misc-const-correctness' will not "
         "perform any analysis because both 'AnalyzeValues' and "
         "'AnalyzeReferences' are false.");
 }
 
 void ConstCorrectnessCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
void ConstCorrectnessCheck::check(const MatchFinder::MatchResult &Result) {
   // a transformation might effect the other variables as well and be incorrect.
   if (VarDeclStmt == nullptr || !VarDeclStmt->isSingleDecl())
     return;
 
   using namespace utils::fixit;
   if (VC == VariableCategory::Value && TransformValues) {
     Diag << addQualifierToVarDecl(*Variable, *Result.Context,
                                   DeclSpec::TQ_const, QualifierTarget::Value,
-                                  QualifierPolicy::Right);
+                                  QualPolicy);
     // FIXME: Add '{}' for default initialization if no user-defined default
     // constructor exists and there is no initializer.
     return;
   }
 
   if (VC == VariableCategory::Reference && TransformReferences) {
     Diag << addQualifierToVarDecl(*Variable, *Result.Context,
                                   DeclSpec::TQ_const, QualifierTarget::Value,
-                                  QualifierPolicy::Right);
+                                  QualPolicy);
     return;
   }
 
   if (VC == VariableCategory::Pointer) {
     if (WarnPointersAsValues && TransformPointersAsValues) {
       Diag << addQualifierToVarDecl(*Variable, *Result.Context,
                                     DeclSpec::TQ_const, QualifierTarget::Value,
-                                    QualifierPolicy::Right);
+                                    QualPolicy);
     }
     return;
   }
 }
 
 void ConstCorrectnessCheck::registerScope(const CompoundStmt *LocalScope,
                                           ASTContext *Context) {
   auto &Analyzer = ScopesCache[LocalScope];
   if (!Analyzer)
     Analyzer = std::make_unique<ExprMutationAnalyzer>(*LocalScope, *Context);
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`bugprone-signal-handler
   <clang-tidy/checks/bugprone/signal-handler>` check. Partial
   support for C++14 signal handler rules was added. Bug report generation was
   improved.
 
+* :doc:`misc-const-correctness <clang-tidy/checks/misc/const-correctness>`
+  check now supports a ``QualifierAlignment`` option to control the location of
+  ``const`` in the fixit-hints.
+
 Removed checks
 ^^^^^^^^^^^^^^
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 

clang-tools-extra/docs/clang-tidy/checks/misc/const-correctness.rst

.. code-block:: c++
   // but use it as read-only. This means that `i` can be declared ``const``.
   int result = i * i;
 
 The check can analyzes values, pointers and references but not (yet) pointees:
 
 .. code-block:: c++
 
   // Normal values like built-ins or objects.
-  int potential_const_int = 42; // 'const int potential_const_int = 42' suggestion.
+  int potential_const_int = 42; // 'int const potential_const_int = 42' suggestion.
   int copy_of_value = potential_const_int;
 
-  MyClass could_be_const; // 'const MyClass could_be_const' suggestion;
+  MyClass could_be_const; // 'MyClass const could_be_const' suggestion;
   could_be_const.const_qualified_method();
 
   // References can be declared const as well.
-  int &reference_value = potential_const_int; // 'const int &reference_value' suggestion.
+  int &reference_value = potential_const_int; // 'int const &reference_value' suggestion.
   int another_copy = reference_value;
 
   // The similar semantics of pointers are not (yet) analyzed.
-  int *pointer_variable = &potential_const_int; // Not 'const int *pointer_variable' suggestion.
+  int *pointer_variable = &potential_const_int; // Not 'int const *pointer_variable' suggestion.
   int last_copy = *pointer_variable;
 
 The automatic code transformation is only applied to variables that are declared in single
 declarations. You may want to prepare your code base with
 `readability-isolate-declaration <../readability/isolate-declaration.html>`_ first.
 
 Note that there is the check
 `cppcoreguidelines-avoid-non-const-global-variables <cppcoreguidelines-avoid-non-const-global-variables.html>`_

 Pointees can not be analyzed for constness yet. The following code is shows this limitation.
 
 .. code-block:: c++
 
   // Declare a variable that will not be modified.
   int constant_value = 42;
 
   // Declare a pointer to that variable, that does not modify either, but misses 'const'.
-  // Could be 'const int *pointer_to_constant = &constant_value;'
+  // Could be 'int const *pointer_to_constant = &constant_value;'
   int *pointer_to_constant = &constant_value;
 
   // Usage:
   int result = 520 * 120 * (*pointer_to_constant);
 
 This limitation affects the capability to add ``const`` to methods which is not possible, too.
 
 Options
.. code-block:: c++
     const int * const pointer_variable = &value;
 
     // The following operations are forbidden for `pointer_variable`.
     // *pointer_variable = 44;
     // pointer_variable = nullptr;
 
 .. option:: TransformValues (default = 1)
 
-  Provides fixit-hints for value types that automatically adds ``const`` if its a single declaration.
+  Provides fixit-hints for value types that automatically adds ``const`` if it's a single declaration.
 
   .. code-block:: c++
 
-    // Emits a hint for 'value' to become 'const int value = 42;'.
+    // Emits a hint for 'value' to become 'int const value = 42;'.
     int value = 42;
     // Result is modified later in its life-time. No diagnostic and fixit hint will be emitted.
     int result = value * 3;
     result -= 10;
 
 .. option:: TransformReferences (default = 1)
 
   Provides fixit-hints for reference types that automatically adds ``const`` if its a single
   declaration.
 
   .. code-block:: c++
 
     // This variable could still be a constant. But because there is a non-const reference to
     // it, it can not be transformed (yet).
     int value = 42;
-    // The reference 'ref_value' is not modified and can be made 'const int &ref_value = value;'
+    // The reference 'ref_value' is not modified and can be made 'int const &ref_value = value;'
     int &ref_value = value;
 
     // Result is modified later in its life-time. No diagnostic and fixit hint will be emitted.
     int result = ref_value * 3;
     result -= 10;
 
 .. option:: TransformPointersAsValues (default = 0)
 
.. code-block:: c++
     int result = 100 * (*ptr_value);
     // This modification of the pointee is still allowed and not analyzed/diagnosed.
     *ptr_value = 0;
 
     // The following pointer may not become a 'int *const'.
     int *changing_pointee = &value;
     changing_pointee = &result;
 
+.. option:: QualifierAlignment (default = right)
+
+   Determines the position of the ``const`` in the fixit-hints:
+
+   * ``right`` places the ``const`` at the right hand side, also known as east const.
+
+     .. code-block:: c++
+
+      // Emits a hint for 'value' to become 'int const value = 42;'.
+      int value = 42;
+
+      // Emits a hint for 'ref_value' to become 'int const &ref_value = value;'
+      int &ref_value = value;
+
+
+   * ``left`` places the ``const`` at the left hand side, also known as west const.
+
+     .. code-block:: c++
+
+      // Emits a hint for 'value' to become 'const int value = 42;'.
+      int value = 42;a
+
+      // Emits a hint for 'ref_value' to become 'const int &ref_value = value;'
+      int &ref_value = value;
+

clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-transform-pointer-as-values.cpp

 // RUN: %check_clang_tidy %s misc-const-correctness %t \
 // RUN: -config='{CheckOptions: \
 // RUN:  [{key: "misc-const-correctness.AnalyzeValues", value: true},\
 // RUN:   {key: "misc-const-correctness.WarnPointersAsValues", value: true}, \
 // RUN:   {key: "misc-const-correctness.TransformPointersAsValues", value: true},\
 // RUN:  ]}' -- -fno-delayed-template-parsing
 
+// RUN: %check_clang_tidy %s misc-const-correctness %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: "misc-const-correctness.AnalyzeValues", value: true},\
+// RUN:   {key: "misc-const-correctness.WarnPointersAsValues", value: true}, \
+// RUN:   {key: "misc-const-correctness.TransformPointersAsValues", value: true},\
+// RUN:   {key: 'misc-const-correctness.QualifierAlignment', value: right}, \
+// RUN:  ]}' -- -fno-delayed-template-parsing
+
+// RUN: %check_clang_tidy %s misc-const-correctness %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: "misc-const-correctness.AnalyzeValues", value: true},\
+// RUN:   {key: "misc-const-correctness.WarnPointersAsValues", value: true}, \
+// RUN:   {key: "misc-const-correctness.TransformPointersAsValues", value: true},\
+// RUN:   {key: 'misc-const-correctness.QualifierAlignment', value: left}, \
+// RUN:  ]}' -- -fno-delayed-template-parsing
+
 void potential_const_pointer() {
   double np_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
   double *p_local0 = &np_local0[1];
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double *' can be declared 'const'
   // CHECK-FIXES: double *const p_local0 = &np_local0[1];
 }

clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-transform-values.cpp

-// RUN: %check_clang_tidy %s misc-const-correctness %t -- \
+// RUN: %check_clang_tidy -check-suffix=RIGHT %s misc-const-correctness %t -- \
 // RUN:   -config="{CheckOptions: [\
 // RUN:   {key: 'misc-const-correctness.TransformValues', value: true},\
 // RUN:   {key: 'misc-const-correctness.WarnPointersAsValues', value: false}, \
 // RUN:   {key: 'misc-const-correctness.TransformPointersAsValues', value: false}, \
 // RUN:   ]}" -- -fno-delayed-template-parsing
 
+// RUN: %check_clang_tidy -check-suffix=RIGHT %s misc-const-correctness %t -- \
+// RUN:   -config="{CheckOptions: [\
+// RUN:   {key: 'misc-const-correctness.TransformValues', value: true},\
+// RUN:   {key: 'misc-const-correctness.WarnPointersAsValues', value: false}, \
+// RUN:   {key: 'misc-const-correctness.TransformPointersAsValues', value: false}, \
+// RUN:   {key: 'misc-const-correctness.QualifierAlignment', value: right}, \
+// RUN:   ]}" -- -fno-delayed-template-parsing
+
+// RUN: %check_clang_tidy -check-suffix=LEFT %s misc-const-correctness %t -- \
+// RUN:   -config="{CheckOptions: [\
+// RUN:   {key: 'misc-const-correctness.TransformValues', value: true},\
+// RUN:   {key: 'misc-const-correctness.WarnPointersAsValues', value: false}, \
+// RUN:   {key: 'misc-const-correctness.TransformPointersAsValues', value: false}, \
+// RUN:   {key: 'misc-const-correctness.QualifierAlignment', value: left}, \
+// RUN:   ]}" -- -fno-delayed-template-parsing
+
 bool global;
 char np_global = 0; // globals can't be known to be const
 
 namespace foo {
 int scoped;
 float np_scoped = 1; // namespace variables are like globals
 } // namespace foo
 
 // Lambdas should be ignored, because they do not follow the normal variable
 // semantic (e.g. the type is only known to the compiler).
 void lambdas() {
   auto Lambda = [](int i) { return i < 0; };
 }
 
 void some_function(double, wchar_t);
 
 void some_function(double np_arg0, wchar_t np_arg1) {
   int p_local0 = 2;
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
-  // CHECK-FIXES: int const p_local0 = 2;
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  // CHECK-FIXES-RIGHT: int const p_local0 = 2;
+  // CHECK-FIXES-LEFT: const int p_local0 = 2;
 }
 
 void nested_scopes() {
   {
     int p_local1 = 42;
-    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: variable 'p_local1' of type 'int' can be declared 'const'
-    // CHECK-FIXES: int const p_local1 = 42;
+    // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:5: warning: variable 'p_local1' of type 'int' can be declared 'const'
+    // CHECK-FIXES-RIGHT: int const p_local1 = 42;
+    // CHECK-FIXES-LEFT: const int p_local1 = 42;
   }
 }
 
 template <typename T>
 void define_locals(T np_arg0, T &np_arg1, int np_arg2) {
   T np_local0 = 0;
   int p_local1 = 42;
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
-  // CHECK-FIXES: int const p_local1 = 42;
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
+  // CHECK-FIXES-RIGHT: int const p_local1 = 42;
+  // CHECK-FIXES-LEFT: const int p_local1 = 42;
 }
 
 void template_instantiation() {
   const int np_local0 = 42;
   int np_local1 = 42;
 
   define_locals(np_local0, np_local1, np_local0);
   define_locals(np_local1, np_local1, np_local1);
struct ConstNonConstClass {
   const double &ConstMemberRef;
 
   double *NonConstMemberPtr;
   const double *ConstMemberPtr;
 };
 
 void direct_class_access() {
   ConstNonConstClass p_local0;
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass' can be declared 'const'
-  // CHECK-FIXES: ConstNonConstClass const p_local0;
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass' can be declared 'const'
+  // CHECK-FIXES-RIGHT: ConstNonConstClass const p_local0;
+  // CHECK-FIXES-LEFT: const ConstNonConstClass p_local0;
   p_local0.constMethod();
 }
 
 void class_access_array() {
   ConstNonConstClass p_local0[2];
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass[2]' can be declared 'const'
-  // CHECK-FIXES: ConstNonConstClass const p_local0[2];
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass[2]' can be declared 'const'
+  // CHECK-FIXES-RIGHT: ConstNonConstClass const p_local0[2];
+  // CHECK-FIXES-LEFT: const ConstNonConstClass p_local0[2];
   p_local0[0].constMethod();
 }
 
 struct MyVector {
   double *begin();
   const double *begin() const;
 
   double *end();
   const double *end() const;
 
   double &operator[](int index);
   double operator[](int index) const;
 
   double values[100];
 };
 
 void vector_usage() {
   double p_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double[10]' can be declared 'const'
-  // CHECK-FIXES: double const p_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double[10]' can be declared 'const'
+  // CHECK-FIXES-RIGHT: double const p_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-FIXES-LEFT: const double p_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
 }
 
 void range_for() {
   int np_local0[2] = {1, 2};
   // The transformation is not possible because the range-for-loop mutates the array content.
   int *const np_local1[2] = {&np_local0[0], &np_local0[1]};
   for (int *non_const_ptr : np_local1) {
     *non_const_ptr = 45;
   }
 
   int *np_local2[2] = {&np_local0[0], &np_local0[1]};
   for (int *non_const_ptr : np_local2) {
     *non_const_ptr = 45;
   }
 }
 
 void decltype_declaration() {
   decltype(sizeof(void *)) p_local0 = 42;
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'decltype(sizeof(void *))'
-  // CHECK-FIXES: decltype(sizeof(void *)) const p_local0 = 42;
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'decltype(sizeof(void *))'
+  // CHECK-FIXES-RIGHT: decltype(sizeof(void *)) const p_local0 = 42;
+  // CHECK-FIXES-LEFT: const decltype(sizeof(void *)) p_local0 = 42;
 }
 
 // Taken from libcxx/include/type_traits and improved readability.
 template <class Tp, Tp v>
 struct integral_constant {
   static constexpr const Tp value = v;
   using value_type = Tp;
   using type = integral_constant;
struct TMPClass {
   T sometimesConst() const { return T{}; }
 
   template <typename T2 = T, typename = typename enable_if<not_integral<T2>::value>::type>
   T sometimesConst() { return T{}; }
 };
 
 void meta_type() {
   TMPClass<int> p_local0;
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'TMPClass<int>' can be declared 'const'
-  // CHECK-FIXES: TMPClass<int> const p_local0;
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'TMPClass<int>' can be declared 'const'
+  // CHECK-FIXES-RIGHT: TMPClass<int> const p_local0;
+  // CHECK-FIXES-LEFT: const TMPClass<int> p_local0;
   p_local0.alwaysConst();
   p_local0.sometimesConst();
 
   TMPClass<double> p_local1;
-  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'TMPClass<double>' can be declared 'const'
-  // CHECK-FIXES: TMPClass<double> const p_local1;
+  // CHECK-MESSAGES-RIGHT: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'TMPClass<double>' can be declared 'const'
+  // CHECK-FIXES-RIGHT: TMPClass<double> const p_local1;
+  // CHECK-FIXES-LEFT: const TMPClass<double> p_local1;
   p_local1.alwaysConst();
 
   TMPClass<double> p_local2; // Don't attempt to make this const
   p_local2.sometimesConst();
 }

clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-wrong-config.cpp

 // RUN: %check_clang_tidy %s misc-const-correctness %t \
 // RUN: -config='{CheckOptions: \
 // RUN:  [{key: "misc-const-correctness.AnalyzeValues", value: false},\
 // RUN:   {key: "misc-const-correctness.AnalyzeReferences", value: false},\
+// RUN:   {key: 'misc-const-correctness.QualifierAlignment', value: centre}, \
 // RUN:  ]}' -- -fno-delayed-template-parsing
 
 // CHECK-MESSAGES: warning: The check 'misc-const-correctness' will not perform any analysis because both 'AnalyzeValues' and 'AnalyzeReferences' are false. [clang-tidy-config]
+// CHECK-MESSAGES: warning: invalid configuration value 'centre' for option 'misc-const-correctness.QualifierAlignment' [clang-tidy-config]
 
 void g() {
   int p_local0 = 42;
   // CHECK-FIXES-NOT: int const p_local0 = 42;
 }