[clang-tidy] Use globs in HeaderFilter

[carlosgalvezp]

Summary

Instead of regex, to allow for negative globs.

Rename HeaderFilterRegex to HeaderFilter,
to keep it consistent.

Fix existing usage of HeaderFilter in the codebase.

Add unit test excluding one directory.

[carlosgalvezp]

Fixed typo.

[lebedev.ri]

Not in favor of general directions like this.
Does it not break the existing uses (existing .clang-tidy's e.g.)

[carlosgalvezp]

Fixed formatting of release notes

[carlosgalvezp]

In D112720#3093636, @lebedev.ri wrote:

Not in favor of general directions like this.
Does it not break the existing uses (existing .clang-tidy's e.g.)

Yep, it's a breaking change. The purpose of this patch is mostly to show how it would look like and see if that would be the desired result. There's 2 aspects of it:

• Rename of HeaderFilterRegex to HeaderFilter, to be consistent with --header-filter. If this is too much breakage, I'm OK with reverting.
• Replace regex with globs. Won't break the use of .*. It will break for the use case of having a parent .clang-tidy with .* and a child .clang-tidy with my_folder/*\.h. I personally always found the current interface confusing as a user. What regex should I write? Should I consider full paths, relative paths, does it matter?

I suppose I can keep the exact same behavior as master, but that will add additional tweaks and complexity to the GlobList class.

[carlosgalvezp]

Just to clarify, this patch is the solution proposed by @alexfh here: https://reviews.llvm.org/D34654#3022728

[lebedev.ri]

As long as this blankedly breaks/regresses existing configs it's a non-starter i think.

[carlosgalvezp]

In D112720#3094163, @lebedev.ri wrote:

As long as this blankedly breaks/regresses existing configs it's a non-starter i think.

I see, thanks for the input!

I'm curious if there are any deprecation mechanisms for clang-tidy? Or can it only be updated in a backwards-compatible way? As seen in the other referenced patch, the backwards-compatible solution is to add yet another configurable parameter - ExcludedHeaderFilterRegex, which only contributes to more user confusion. Or keep calling the parameter HeaderFilterRegex and switch the implementation to something that is not a regex - even more confusion to the users.

Personally I think it would be good to have such mechanisms to be able to improve on existing design (not just add more functionality). It's impossible to predict the future so decisions that made total sense in the past might need to be revised later to adapt to user needs.

[lebedev.ri]

Assuming this is the change we want,
i would imagine the viable enablement path is to introduce some option "filters are regexes and not globs",
that defaults to false, and use it. Then some time later (2 releases?), flip the default and remove said option.
My main concern is that it should be possible to use the same config with clang-tidy from both trunk and last release.

[carlosgalvezp]

Makes total sense, thanks for the suggestion!

I'll wait for more reviewers to see if this behavior is what we want at all. If so I can revert the breaking changes and introduce that option.

[carlosgalvezp]

So after some thoughts, I came up with the following plan:

• This patch adds: HeaderFilter, HeaderFilterMode. HeaderFilter is intended to replace HeaderFilterRegex and we inform that HeaderFilterRegex is deprecated and will be removed in 2 releases. However during the transition period, both HeaderFilter and HeaderFilterRegex are accepted. HeaderFilterMode can take values: regex (default) or glob, and describes the behavior of HeaderFilter or HeaderFilterRegex. This allows people to use globs, while not breaking existing functionality.

• After 2 releases, we remove HeaderFilterRegex and set HeaderFilterMode as default to glob. We communicate that HeaderFilterMode is deprecated and will be removed in 2 releases.

• After (another) 2 releases, we remove HeaderFilterMode. The result is then what this patch looks like it is right now. Do we need to wait 2 more releases to remove HeaderFilterMode or can we do it already in the above step?

Does that sound good? Looking forward to your feedback.

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

 //===--- ClangTidyDiagnosticConsumer.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_CLANGTIDYDIAGNOSTICCONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
 #include "ClangTidyOptions.h"
 #include "ClangTidyProfiling.h"
+#include "GlobList.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 
 class ASTContext;

 
 private:
   void finalizeLastError();
   void removeIncompatibleErrors();
   void removeDuplicatedDiagnosticsOfAliasCheckers();
 
   /// Returns the \c HeaderFilter constructed for the options set in the
   /// context.
-  llvm::Regex *getHeaderFilter();
+  GlobList *getHeaderFilter();
 
   /// Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
   /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location, const SourceManager &Sources);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   void forwardDiagnostic(const Diagnostic &Info);
 
   ClangTidyContext &Context;
   DiagnosticsEngine *ExternalDiagEngine;
   bool RemoveIncompatibleErrors;
   bool GetFixesFromNotes;
   std::vector<ClangTidyError> Errors;
-  std::unique_ptr<llvm::Regex> HeaderFilter;
+  std::unique_ptr<GlobList> HeaderFilter;
   bool LastErrorRelatesToUserCode;
   bool LastErrorPassesLineFilter;
   bool LastErrorWasIgnored;
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
-#include "GlobList.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
if (!File) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }
 
   StringRef FileName(File->getName());
   LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
                                Sources.isInMainFile(Location) ||
-                               getHeaderFilter()->match(FileName);
+                               getHeaderFilter()->contains(FileName);
 
   unsigned LineNumber = Sources.getExpansionLineNumber(Location);
   LastErrorPassesLineFilter =
       LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
 }
 
-llvm::Regex *ClangTidyDiagnosticConsumer::getHeaderFilter() {
+GlobList *ClangTidyDiagnosticConsumer::getHeaderFilter() {
   if (!HeaderFilter)
     HeaderFilter =
-        std::make_unique<llvm::Regex>(*Context.getOptions().HeaderFilterRegex);
+        std::make_unique<GlobList>(*Context.getOptions().HeaderFilter);
   return HeaderFilter.get();
 }
 
 void ClangTidyDiagnosticConsumer::removeIncompatibleErrors() {
   // Each error is modelled as the set of intervals in which it applies
   // replacements. To detect overlapping replacements, we use a sweep line
   // algorithm over these sets of intervals.
   // An event here consists of the opening or closing of an interval. During the

clang-tools-extra/clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
   /// Checks filter.
   llvm::Optional<std::string> Checks;
 
   /// WarningsAsErrors filter.
   llvm::Optional<std::string> WarningsAsErrors;
 
   /// Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
-  llvm::Optional<std::string> HeaderFilterRegex;
+  llvm::Optional<std::string> HeaderFilter;
 
-  /// Output warnings from system headers matching \c HeaderFilterRegex.
+  /// Output warnings from system headers matching \c HeaderFilter.
   llvm::Optional<bool> SystemHeaders;
 
   /// Format code around applied fixes with clang-format using this
   /// style.
   ///
   /// Can be one of:
   ///   * 'none' - don't format code around applied fixes;
   ///   * 'llvm', 'google', 'mozilla' or other predefined clang-format style

clang-tools-extra/clang-tidy/ClangTidyOptions.cpp

 
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
         IO, Options.CheckOptions);
     bool Ignored = false;
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
-    IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
+    IO.mapOptional("HeaderFilter", Options.HeaderFilter);
     IO.mapOptional("AnalyzeTemporaryDtors", Ignored); // legacy compatibility
     IO.mapOptional("FormatStyle", Options.FormatStyle);
     IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", NOpts->Options);
     IO.mapOptional("ExtraArgs", Options.ExtraArgs);
     IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
     IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
     IO.mapOptional("UseColor", Options.UseColor);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
 ClangTidyOptions ClangTidyOptions::getDefaults() {
   ClangTidyOptions Options;
   Options.Checks = "";
   Options.WarningsAsErrors = "";
-  Options.HeaderFilterRegex = "";
+  Options.HeaderFilter = "";
   Options.SystemHeaders = false;
   Options.FormatStyle = "none";
   Options.User = llvm::None;
   for (const ClangTidyModuleRegistry::entry &Module :
        ClangTidyModuleRegistry::entries())
     Options.mergeWith(Module.instantiate()->getModuleOptions(), 0);
   return Options;
 }
static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
   if (Src)
     Dest = Src;
 }
 
 ClangTidyOptions &ClangTidyOptions::mergeWith(const ClangTidyOptions &Other,
                                               unsigned Order) {
   mergeCommaSeparatedLists(Checks, Other.Checks);
   mergeCommaSeparatedLists(WarningsAsErrors, Other.WarningsAsErrors);
-  overrideValue(HeaderFilterRegex, Other.HeaderFilterRegex);
+  overrideValue(HeaderFilter, Other.HeaderFilter);
   overrideValue(SystemHeaders, Other.SystemHeaders);
   overrideValue(FormatStyle, Other.FormatStyle);
   overrideValue(User, Other.User);
   overrideValue(UseColor, Other.UseColor);
   mergeVectors(ExtraArgs, Other.ExtraArgs);
   mergeVectors(ExtraArgsBefore, Other.ExtraArgsBefore);
 
   for (const auto &KeyValue : Other.CheckOptions) {

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

Configuration files:
   will be applied on top of the parent one. If any configuration options have
   a corresponding command-line option, command-line option takes precedence.
   The effective configuration can be inspected using -dump-config:
 
     $ clang-tidy -dump-config
     ---
     Checks:              '-*,some-check'
     WarningsAsErrors:    ''
-    HeaderFilterRegex:   ''
+    HeaderFilter:   ''
     FormatStyle:         none
     InheritParentConfig: true
     User:                user
     CheckOptions:
       - key:             some-check.SomeOption
         value:           'some value'
     ...
 

 This option's value is appended to the value of
 the 'WarningsAsErrors' option in .clang-tidy
 file, if any.
 )"),
                                              cl::init(""),
                                              cl::cat(ClangTidyCategory));
 
 static cl::opt<std::string> HeaderFilter("header-filter", cl::desc(R"(
-Regular expression matching the names of the
+Glob expression matching the names of the
 headers to output diagnostics from. Diagnostics
 from the main file of each translation unit are
 always displayed.
 Can be used together with -line-filter.
-This option overrides the 'HeaderFilterRegex'
+This option overrides the 'HeaderFilter'
 option in .clang-tidy file, if any.
 )"),
                                          cl::init(""),
                                          cl::cat(ClangTidyCategory));
 
 static cl::opt<bool>
     SystemHeaders("system-headers",
                   cl::desc("Display the errors from system headers."),

 Apply suggested fixes even if compilation
 errors were found. If compiler errors have
 attached fix-its, clang-tidy will apply them as
 well.
 )"),
                                cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> FixNotes("fix-notes", cl::desc(R"(
-If a warning has no fix, but a single fix can 
-be found through an associated diagnostic note, 
-apply the fix. 
-Specifying this flag will implicitly enable the 
+If a warning has no fix, but a single fix can
+be found through an associated diagnostic note,
+apply the fix.
+Specifying this flag will implicitly enable the
 '--fix' flag.
 )"),
                               cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<std::string> FormatStyle("format-style", cl::desc(R"(
 Style for formatting code around applied fixes:
   - 'none' (default) turns off formatting
   - 'file' (literally 'file', not a placeholder)
if (Stats.ErrorsIgnoredNOLINT) {
       llvm::errs() << Separator << Stats.ErrorsIgnoredNOLINT << " NOLINT";
       Separator = ", ";
     }
     if (Stats.ErrorsIgnoredCheckFilter)
       llvm::errs() << Separator << Stats.ErrorsIgnoredCheckFilter
                    << " with check filters";
     llvm::errs() << ").\n";
     if (Stats.ErrorsIgnoredNonUserCode)
-      llvm::errs() << "Use -header-filter=.* to display errors from all "
+      llvm::errs() << "Use -header-filter=* to display errors from all "
                       "non-system headers. Use -system-headers to display "
                       "errors from system headers as well.\n";
   }
 }
 
 static std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider(
    llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS) {
   ClangTidyGlobalOptions GlobalOptions;
   if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return nullptr;
   }
 
   ClangTidyOptions DefaultOptions;
   DefaultOptions.Checks = DefaultChecks;
   DefaultOptions.WarningsAsErrors = "";
-  DefaultOptions.HeaderFilterRegex = HeaderFilter;
+  DefaultOptions.HeaderFilter = HeaderFilter;
   DefaultOptions.SystemHeaders = SystemHeaders;
   DefaultOptions.FormatStyle = FormatStyle;
   DefaultOptions.User = llvm::sys::Process::GetEnv("USER");
   // USERNAME is used on Windows.
   if (!DefaultOptions.User)
     DefaultOptions.User = llvm::sys::Process::GetEnv("USERNAME");
 
   ClangTidyOptions OverrideOptions;
   if (Checks.getNumOccurrences() > 0)
     OverrideOptions.Checks = Checks;
   if (WarningsAsErrors.getNumOccurrences() > 0)
     OverrideOptions.WarningsAsErrors = WarningsAsErrors;
   if (HeaderFilter.getNumOccurrences() > 0)
-    OverrideOptions.HeaderFilterRegex = HeaderFilter;
+    OverrideOptions.HeaderFilter = HeaderFilter;
   if (SystemHeaders.getNumOccurrences() > 0)
     OverrideOptions.SystemHeaders = SystemHeaders;
   if (FormatStyle.getNumOccurrences() > 0)
     OverrideOptions.FormatStyle = FormatStyle;
   if (UseColor.getNumOccurrences() > 0)
     OverrideOptions.UseColor = UseColor;
 
   auto LoadConfig =

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+.. warning::
+
+  - `HeaderFilterRegex` has been renamed to `HeaderFilter`.
+  - `HeaderFilter` is now a glob expression, instead a regex expression. The consequences are:
+
+    - The glob expression must match the full path of the header, therefore users should use:
+
+      `HeaderFilter: '*/header.h'`
+
+    - Multiple positive or negative globs can be used, with the same semantics as `Checks`:
+
+      `HeaderFilter: '*/header1.h,-*/header2.h'`
+
 - Added support for globbing in `NOLINT*` expressions, to simplify suppressing
   multiple warnings in the same line.
 
 - Added support for `NOLINTBEGIN` ... `NOLINTEND` comments to suppress
   Clang-Tidy warnings over multiple lines.
 
 New checks
 ^^^^^^^^^^

clang-tools-extra/docs/clang-tidy/index.rst

--format-style=<string>        -
                                      This option overrides the 'FormatStyle` option in
                                      .clang-tidy file, if any.
     --header-filter=<string>       -
                                      Regular expression matching the names of the
                                      headers to output diagnostics from. Diagnostics
                                      from the main file of each translation unit are
                                      always displayed.
                                      Can be used together with -line-filter.
-                                     This option overrides the 'HeaderFilterRegex'
+                                     This option overrides the 'HeaderFilter'
                                      option in .clang-tidy file, if any.
     --line-filter=<string>         -
                                      List of files with line ranges to filter the
                                      warnings. Can be used together with
                                      -header-filter. The format of the list is a
                                      JSON array of objects:
                                        [
                                          {"name":"file1.cpp","lines":[[1,3],[5,7]]},
Configuration files:
     will be applied on top of the parent one. If any configuration options have
     a corresponding command-line option, command-line option takes precedence.
     The effective configuration can be inspected using -dump-config:
 
       $ clang-tidy -dump-config
       ---
       Checks:              '-*,some-check'
       WarningsAsErrors:    ''
-      HeaderFilterRegex:   ''
+      HeaderFilter:   ''
       FormatStyle:         none
       InheritParentConfig: true
       User:                user
       CheckOptions:
         - key:             some-check.SomeOption
           value:           'some value'
       ...
 

clang-tools-extra/test/clang-tidy/checkers/abseil-no-internal-dependencies.cpp

 // RUN: %check_clang_tidy %s abseil-no-internal-dependencies %t,  -- -- -I %S/Inputs
-// RUN: clang-tidy -checks='-*, abseil-no-internal-dependencies' -header-filter='.*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
+// RUN: clang-tidy -checks='-*, abseil-no-internal-dependencies' -header-filter='*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
 
 #include "absl/strings/internal-file.h"
 #include "absl/flags/internal-file.h"
 // CHECK-NOT: warning:
 
 #include "absl/external-file.h"
 // CHECK: absl/external-file.h:6:24: warning: do not reference any 'internal' namespaces; those implementation details are reserved to Abseil [abseil-no-internal-dependencies]
 

clang-tools-extra/test/clang-tidy/checkers/abseil-no-namespace.cpp

 // RUN: %check_clang_tidy %s abseil-no-namespace %t -- -- -I %S/Inputs
-// RUN: clang-tidy -checks='-*, abseil-no-namespace' -header-filter='.*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
+// RUN: clang-tidy -checks='-*, abseil-no-namespace' -header-filter='*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
 
 /// Warning will not be triggered on internal Abseil code that is included.
 #include "absl/strings/internal-file.h"
 // CHECK-NOT: warning:
 
 /// Warning will be triggered on code that is not internal that is included.
 #include "absl/external-file.h"
 // CHECK: absl/external-file.h:1:11: warning: namespace 'absl' is reserved

clang-tools-extra/test/clang-tidy/checkers/altera-id-dependent-backward-branch.cpp

-// RUN: %check_clang_tidy %s altera-id-dependent-backward-branch %t -- -header-filter=.* "--" -cl-std=CL1.2 -c --include opencl-c.h
+// RUN: %check_clang_tidy %s altera-id-dependent-backward-branch %t -- -header-filter=* "--" -cl-std=CL1.2 -c --include opencl-c.h
 
 typedef struct ExampleStruct {
   int IDDepField;
 } ExampleStruct;
 
 void error() {
   // ==== Conditional Expressions ====
   int accumulator = 0;

clang-tools-extra/test/clang-tidy/checkers/altera-single-work-item-barrier.cpp

-// RUN: %check_clang_tidy -check-suffix=OLDCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=.* "--" -cl-std=CL1.2 -c --include opencl-c.h -DOLDCLOLDAOC
-// RUN: %check_clang_tidy -check-suffix=NEWCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=.* "--" -cl-std=CL2.0 -c --include opencl-c.h -DNEWCLOLDAOC
-// RUN: %check_clang_tidy -check-suffix=OLDCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: [{key: altera-single-work-item-barrier.AOCVersion, value: 1701}]}' -header-filter=.* "--" -cl-std=CL1.2 -c --include opencl-c.h -DOLDCLNEWAOC
-// RUN: %check_clang_tidy -check-suffix=NEWCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: [{key: altera-single-work-item-barrier.AOCVersion, value: 1701}]}' -header-filter=.* "--" -cl-std=CL2.0 -c --include opencl-c.h -DNEWCLNEWAOC
+// RUN: %check_clang_tidy -check-suffix=OLDCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=* "--" -cl-std=CL1.2 -c --include opencl-c.h -DOLDCLOLDAOC
+// RUN: %check_clang_tidy -check-suffix=NEWCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=* "--" -cl-std=CL2.0 -c --include opencl-c.h -DNEWCLOLDAOC
+// RUN: %check_clang_tidy -check-suffix=OLDCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: [{key: altera-single-work-item-barrier.AOCVersion, value: 1701}]}' -header-filter=* "--" -cl-std=CL1.2 -c --include opencl-c.h -DOLDCLNEWAOC
+// RUN: %check_clang_tidy -check-suffix=NEWCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: [{key: altera-single-work-item-barrier.AOCVersion, value: 1701}]}' -header-filter=* "--" -cl-std=CL2.0 -c --include opencl-c.h -DNEWCLNEWAOC
 
 #ifdef OLDCLOLDAOC  // OpenCL 1.2 Altera Offline Compiler < 17.1
 void __kernel error_barrier_no_id(__global int * foo, int size) {
   // CHECK-MESSAGES-OLDCLOLDAOC: :[[@LINE-1]]:15: warning: kernel function 'error_barrier_no_id' does not call 'get_global_id' or 'get_local_id' and will be treated as a single work-item [altera-single-work-item-barrier]
   for (int j = 0; j < 256; j++) {
   for (int i = 256; i < size; i+= 256) {
       foo[j] += foo[j+i];
     }

clang-tools-extra/test/clang-tidy/checkers/altera-struct-pack-align-no-crash.cpp

-// RUN: %check_clang_tidy -expect-clang-tidy-error %s altera-struct-pack-align %t -- -header-filter=.*
+// RUN: %check_clang_tidy -expect-clang-tidy-error %s altera-struct-pack-align %t -- -header-filter=*
 
 struct A;
 struct B {
   A a;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: error: field has incomplete type 'A' [clang-diagnostic-error]
 };

clang-tools-extra/test/clang-tidy/checkers/altera-struct-pack-align.cpp

-// RUN: %check_clang_tidy %s altera-struct-pack-align %t -- -header-filter=.*
+// RUN: %check_clang_tidy %s altera-struct-pack-align %t -- -header-filter=*
 
 // Struct needs both alignment and packing
 struct error {
   char a;
   double b;
   char c;
 };
 // CHECK-MESSAGES: :[[@LINE-5]]:8: warning: accessing fields in struct 'error' is inefficient due to padding; only needs 10 bytes but is using 24 bytes [altera-struct-pack-align]

clang-tools-extra/test/clang-tidy/checkers/altera-unroll-loops.cpp

-// RUN: %check_clang_tidy %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 50}]}" -header-filter=.*
-// RUN: %check_clang_tidy -check-suffix=MULT %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 5}]}" -header-filter=.* "--" -DMULT
+// RUN: %check_clang_tidy %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 50}]}" -header-filter=*
+// RUN: %check_clang_tidy -check-suffix=MULT %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 5}]}" -header-filter=* "--" -DMULT
 
 #ifdef MULT
 // For loops with *= and /= increments.
 void for_loop_mult_div_increments(int *A) {
 // *=
 #pragma unroll
   for (int i = 2; i <= 32; i *= 2)
     A[i]++; // OK

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-macro-usage.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t -- -header-filter=.* -system-headers --
+// RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t -- -header-filter=* -system-headers --
 
 #ifndef INCLUDE_GUARD
 #define INCLUDE_GUARD
 
 #define PROBLEMATIC_CONSTANT 0
 // CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant
 
 #define PROBLEMATIC_FUNCTION(x, y) ((a) > (b) ? (a) : (b))

clang-tools-extra/test/clang-tidy/checkers/google-namespaces.cpp

-// RUN: clang-tidy %s -checks='-*,google-build-namespaces,google-build-using-namespace' -header-filter='.*' -- | FileCheck %s -implicit-check-not="{{warning|error}}:"
+// RUN: clang-tidy %s -checks='-*,google-build-namespaces,google-build-using-namespace' -header-filter='*' -- | FileCheck %s -implicit-check-not="{{warning|error}}:"
 #include "Inputs/google-namespaces.h"
 // CHECK: warning: do not use unnamed namespaces in header files [google-build-namespaces]
 
 using namespace spaaaace;
 // CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; use using-declarations instead [google-build-using-namespace]
 
 using spaaaace::core; // no-warning
 

clang-tools-extra/test/clang-tidy/checkers/google-readability-casting.c

 // RUN: %check_clang_tidy %s google-readability-casting %t -- -- -x c
 // The testing script always adds .cpp extension to the input file name, so we
 // need to run clang-tidy directly in order to verify handling of .c files:
 // RUN: clang-tidy --checks=-*,google-readability-casting %s -- -x c++ | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning|error}}:'
 // RUN: cp %s %t.main_file.cpp
-// RUN: clang-tidy --checks=-*,google-readability-casting -header-filter='.*' %t.main_file.cpp -- -I%S -DTEST_INCLUDE -x c++ | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning|error}}:'
+// RUN: clang-tidy --checks=-*,google-readability-casting -header-filter='*' %t.main_file.cpp -- -I%S -DTEST_INCLUDE -x c++ | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning|error}}:'
 
 #ifdef TEST_INCLUDE
 
 #undef TEST_INCLUDE
 #include "google-readability-casting.c"
 
 #else
 

clang-tools-extra/test/clang-tidy/checkers/misc-unused-parameters.cpp

 // RUN: echo "static void staticFunctionHeader(int i) {;}" > %T/header.h
 // RUN: echo "static void staticFunctionHeader(int  /*i*/) {;}" > %T/header-fixed.h
-// RUN: %check_clang_tidy -std=c++11 %s misc-unused-parameters %t -- -header-filter='.*' -- -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++11 %s misc-unused-parameters %t -- -header-filter='*' -- -fno-delayed-template-parsing
 // RUN: diff %T/header.h %T/header-fixed.h
 // FIXME: Make the test work in all language modes.
 
 #include "header.h"
 // CHECK-MESSAGES: header.h:1:38: warning
 
 // Basic removal
 // =============

clang-tools-extra/test/clang-tidy/checkers/modernize-concat-nested-namespaces.cpp

 // RUN: cp %S/Inputs/modernize-concat-nested-namespaces/modernize-concat-nested-namespaces.h %T/modernize-concat-nested-namespaces.h
-// RUN: %check_clang_tidy -std=c++17 %s modernize-concat-nested-namespaces %t -- -header-filter=".*" -- -I %T
+// RUN: %check_clang_tidy -std=c++17 %s modernize-concat-nested-namespaces %t -- -header-filter="*" -- -I %T
 // RUN: FileCheck -input-file=%T/modernize-concat-nested-namespaces.h %S/Inputs/modernize-concat-nested-namespaces/modernize-concat-nested-namespaces.h -check-prefix=CHECK-FIXES
 // Restore header file and re-run with c++20:
 // RUN: cp %S/Inputs/modernize-concat-nested-namespaces/modernize-concat-nested-namespaces.h %T/modernize-concat-nested-namespaces.h
-// RUN: %check_clang_tidy -std=c++20 %s modernize-concat-nested-namespaces %t -- -header-filter=".*" -- -I %T
+// RUN: %check_clang_tidy -std=c++20 %s modernize-concat-nested-namespaces %t -- -header-filter="*" -- -I %T
 // RUN: FileCheck -input-file=%T/modernize-concat-nested-namespaces.h %S/Inputs/modernize-concat-nested-namespaces/modernize-concat-nested-namespaces.h -check-prefix=CHECK-FIXES
 
 #include "modernize-concat-nested-namespaces.h"
 // CHECK-MESSAGES-DAG: modernize-concat-nested-namespaces.h:1:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
 
 namespace n1 {}
 
 namespace n2 {

clang-tools-extra/test/clang-tidy/checkers/modernize-pass-by-value-header.cpp

 // RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
-// RUN: clang-tidy %s -checks='-*,modernize-pass-by-value' -header-filter='.*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
+// RUN: clang-tidy %s -checks='-*,modernize-pass-by-value' -header-filter='*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
 // RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=CHECK-FIXES
 // FIXME: Make the test work in all language modes.
 
 #include "pass-by-value-header.h"
 // CHECK-MESSAGES: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
 // CHECK-FIXES: #include <utility>
 // CHECK-FIXES: A(ThreadId tid) : threadid(std::move(tid)) {}

clang-tools-extra/test/clang-tidy/checkers/modernize-pass-by-value-multi-fixes.cpp

 // RUN: cat %S/Inputs/modernize-pass-by-value/header-with-fix.h > %T/pass-by-value-header-with-fix.h
 // RUN: sed -e 's#//.*$##' %s > %t.cpp
-// RUN: clang-tidy %t.cpp -checks='-*,modernize-pass-by-value' -header-filter='.*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
+// RUN: clang-tidy %t.cpp -checks='-*,modernize-pass-by-value' -header-filter='*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
 // RUN: FileCheck -input-file=%t.cpp %s -check-prefix=CHECK-FIXES
 // RUN: FileCheck -input-file=%T/pass-by-value-header-with-fix.h %s -check-prefix=CHECK-HEADER-FIXES
 
 #include "pass-by-value-header-with-fix.h"
 // CHECK-HEADER-FIXES: Foo(S s);
 Foo::Foo(const S &s) : s(s) {}
 // CHECK-MESSAGES: :9:10: warning: pass by value and use std::move [modernize-pass-by-value]
 // CHECK-FIXES: #include <utility>
 // CHECK-FIXES: Foo::Foo(S s) : s(std::move(s)) {}

clang-tools-extra/test/clang-tidy/checkers/portability-restrict-system-includes-transitive.cpp

 // RUN: rm -rf %T/Headers
 // RUN: mkdir %T/Headers
 // RUN: cp -r %S/Inputs/portability-restrict-system-includes %T/Headers/portability-restrict-system-includes
 // RUN: %check_clang_tidy -std=c++11 %s portability-restrict-system-includes %t \
 // RUN:   -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: 'transitive.h,s.h'}]}" \
-// RUN:   -system-headers -header-filter=.* \
+// RUN:   -system-headers -header-filter=* \
 // RUN:   -- -I %T/Headers/portability-restrict-system-includes -isystem %T/Headers/portability-restrict-system-includes/system
 // RUN: FileCheck -input-file=%T/Headers/portability-restrict-system-includes/transitive2.h %s -check-prefix=CHECK-FIXES
 // RUN: rm -rf %T/Headers
 // FIXME: Make the test work in all language modes.
 
 // transitive.h includes <r.h> and <t.h>
 #include <transitive.h>
 // CHECK-MESSAGES: :1:1: warning: system include r.h not allowed, transitively included from {{.*}}

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-multiple-styles.cpp

 // InheritParentConfig is needed to look for the clang-tidy configuration files.
 
 // RUN: %check_clang_tidy -check-suffixes=ENABLED,SHARED -std=c++11 %s \
 // RUN: readability-identifier-naming %t -- \
 // RUN:  -config='{ InheritParentConfig: true, CheckOptions: [ \
 // RUN:   {key: readability-identifier-naming.FunctionCase, value: camelBack}, \
 // RUN:   {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \
 // RUN:   {key: readability-identifier-naming.GetConfigPerFile, value: true} \
-// RUN:  ]}' -header-filter='.*' -- -I%theaders
+// RUN:  ]}' -header-filter='*' -- -I%theaders
 
 // On DISABLED run, everything should be made 'camelBack'.
 
 // RUN: cp -R %S/Inputs/readability-identifier-naming/. %theaders
 // RUN: %check_clang_tidy -check-suffixes=DISABLED,SHARED -std=c++11 %s \
 // RUN: readability-identifier-naming %t -- \
 // RUN:  -config='{ InheritParentConfig: false, CheckOptions: [ \
 // RUN:   {key: readability-identifier-naming.FunctionCase, value: camelBack}, \
 // RUN:   {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \
 // RUN:   {key: readability-identifier-naming.GetConfigPerFile, value: false} \
-// RUN:  ]}' -header-filter='.*' -- -I%theaders
+// RUN:  ]}' -header-filter='*' -- -I%theaders
 
 #include "global-style1/header.h"
 #include "global-style2/header.h"
 
 void goodStyle() {
   style_first_good();
   STYLE_SECOND_GOOD();
   //      CHECK-FIXES-DISABLED: styleFirstGood();

clang-tools-extra/test/clang-tidy/checkers/zircon-temporary-objects.cpp

 // RUN: %check_clang_tidy %s zircon-temporary-objects %t -- \
 // RUN:   -config="{CheckOptions: [{key: zircon-temporary-objects.Names, value: 'Foo;NS::Bar'}]}" \
-// RUN:   -header-filter=.*
+// RUN:   -header-filter=*
 
 // Should flag instances of Foo, NS::Bar.
 
 class Foo {
 public:
   Foo() = default;
   Foo(int Val) : Val(Val){};
 

clang-tools-extra/test/clang-tidy/infrastructure/Inputs/config-files/.clang-tidy

 Checks: 'from-parent'
-HeaderFilterRegex: 'parent'
+HeaderFilter: 'parent'

clang-tools-extra/test/clang-tidy/infrastructure/Inputs/config-files/1/.clang-tidy

 Checks: 'from-child1'
-HeaderFilterRegex: 'child1'
+HeaderFilter: 'child1'

clang-tools-extra/test/clang-tidy/infrastructure/Inputs/config-files/3/.clang-tidy

 InheritParentConfig: true
 Checks: 'from-child3'
-HeaderFilterRegex: 'child3'
+HeaderFilter: 'child3'

clang-tools-extra/test/clang-tidy/infrastructure/Inputs/overlapping/o.h

-// run: clang-tidy -checks=-*,llvm-include-order -header-filter=.* %s \
+// run: clang-tidy -checks=-*,llvm-include-order -header-filter=* %s \
 // run:   -- -isystem %S/Inputs/Headers -I %S/Inputs/overlapping | \
 // run:   not grep "note: this fix will not be applied because it overlaps with another fix"
 
 #include "b.h"
 #include "a.h"
 
 // The comments above are there to match the offset of the #include with the
 // offset of the #includes in the .cpp file.

clang-tools-extra/test/clang-tidy/infrastructure/clang-tidy-mac-libcxx.cpp

 // Clang on MacOS can find libc++ living beside the installed compiler.
 // This test makes sure clang-tidy emulates this properly.
 //
 // RUN: rm -rf %t
 // RUN: mkdir %t
 //
 // Install the mock libc++ (simulates the libc++ directory structure).
 // RUN: cp -r %S/Inputs/mock-libcxx %t/
 //
 // Pretend clang is installed beside the mock library that we provided.
 // RUN: echo '[{"directory":"%t","command":"%t/mock-libcxx/bin/clang++ -stdlib=libc++ -std=c++11 -target x86_64-apple-darwin -c test.cpp","file":"test.cpp"}]' | sed -e 's/\\/\//g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
-// RUN: clang-tidy -header-filter='.*' -system-headers -checks='-*,modernize-use-using'  "%t/test.cpp" | FileCheck %s
+// RUN: clang-tidy -header-filter='*' -system-headers -checks='-*,modernize-use-using'  "%t/test.cpp" | FileCheck %s
 // CHECK: mock_vector:{{[0-9]+}}:{{[0-9]+}}: warning: use 'using' instead of 'typedef'
 
 #include <mock_vector>
 typedef vector* vec_ptr;

clang-tools-extra/test/clang-tidy/infrastructure/clang-tidy-run-with-database.cpp

 // RUN: mkdir -p %T/compilation-database-test/include
 // RUN: mkdir -p %T/compilation-database-test/a
 // RUN: mkdir -p %T/compilation-database-test/b
 // RUN: echo 'int *AA = 0;' > %T/compilation-database-test/a/a.cpp
 // RUN: echo 'int *AB = 0;' > %T/compilation-database-test/a/b.cpp
 // RUN: echo 'int *BB = 0;' > %T/compilation-database-test/b/b.cpp
 // RUN: echo 'int *BC = 0;' > %T/compilation-database-test/b/c.cpp
 // RUN: echo 'int *HP = 0;' > %T/compilation-database-test/include/header.h
 // RUN: echo '#include "header.h"' > %T/compilation-database-test/b/d.cpp
 // RUN: sed 's|test_dir|%/T/compilation-database-test|g' %S/Inputs/compilation-database/template.json > %T/compile_commands.json
 
 // Regression test: shouldn't crash.
-// RUN: not clang-tidy --checks=-*,modernize-use-nullptr -p %T %T/compilation-database-test/b/not-exist -header-filter=.* 2>&1 | FileCheck %s -check-prefix=CHECK-NOT-EXIST
+// RUN: not clang-tidy --checks=-*,modernize-use-nullptr -p %T %T/compilation-database-test/b/not-exist -header-filter=* 2>&1 | FileCheck %s -check-prefix=CHECK-NOT-EXIST
 // CHECK-NOT-EXIST: Error while processing {{.*[/\\]}}not-exist.
 // CHECK-NOT-EXIST: unable to handle compilation
 // CHECK-NOT-EXIST: Found compiler error
 
-// RUN: clang-tidy --checks=-*,modernize-use-nullptr -p %T %T/compilation-database-test/a/a.cpp %T/compilation-database-test/a/b.cpp %T/compilation-database-test/b/b.cpp %T/compilation-database-test/b/c.cpp %T/compilation-database-test/b/d.cpp -header-filter=.* -fix
+// RUN: clang-tidy --checks=-*,modernize-use-nullptr -p %T %T/compilation-database-test/a/a.cpp %T/compilation-database-test/a/b.cpp %T/compilation-database-test/b/b.cpp %T/compilation-database-test/b/c.cpp %T/compilation-database-test/b/d.cpp -header-filter=* -fix
 // RUN: FileCheck -input-file=%T/compilation-database-test/a/a.cpp %s -check-prefix=CHECK-FIX1
 // RUN: FileCheck -input-file=%T/compilation-database-test/a/b.cpp %s -check-prefix=CHECK-FIX2
 // RUN: FileCheck -input-file=%T/compilation-database-test/b/b.cpp %s -check-prefix=CHECK-FIX3
 // RUN: FileCheck -input-file=%T/compilation-database-test/b/c.cpp %s -check-prefix=CHECK-FIX4
 // RUN: FileCheck -input-file=%T/compilation-database-test/include/header.h %s -check-prefix=CHECK-FIX5
 
 // CHECK-FIX1: int *AA = nullptr;
 // CHECK-FIX2: int *AB = nullptr;
 // CHECK-FIX3: int *BB = nullptr;
 // CHECK-FIX4: int *BC = nullptr;
 // CHECK-FIX5: int *HP = nullptr;

clang-tools-extra/test/clang-tidy/infrastructure/config-files.cpp

 // RUN: clang-tidy -dump-config %S/Inputs/config-files/- -- | FileCheck %s -check-prefix=CHECK-BASE
 // CHECK-BASE: Checks: {{.*}}from-parent
-// CHECK-BASE: HeaderFilterRegex: parent
+// CHECK-BASE: HeaderFilter: parent
 // RUN: clang-tidy -dump-config %S/Inputs/config-files/1/- -- | FileCheck %s -check-prefix=CHECK-CHILD1
 // CHECK-CHILD1: Checks: {{.*}}from-child1
-// CHECK-CHILD1: HeaderFilterRegex: child1
+// CHECK-CHILD1: HeaderFilter: child1
 // RUN: clang-tidy -dump-config %S/Inputs/config-files/2/- -- | FileCheck %s -check-prefix=CHECK-CHILD2
 // CHECK-CHILD2: Checks: {{.*}}from-parent
-// CHECK-CHILD2: HeaderFilterRegex: parent
+// CHECK-CHILD2: HeaderFilter: parent
 // RUN: clang-tidy -dump-config %S/Inputs/config-files/3/- -- | FileCheck %s -check-prefix=CHECK-CHILD3
 // CHECK-CHILD3: Checks: {{.*}}from-parent,from-child3
-// CHECK-CHILD3: HeaderFilterRegex: child3
+// CHECK-CHILD3: HeaderFilter: child3
 // RUN: clang-tidy -dump-config -checks='from-command-line' -header-filter='from command line' %S/Inputs/config-files/- -- | FileCheck %s -check-prefix=CHECK-COMMAND-LINE
 // CHECK-COMMAND-LINE: Checks: {{.*}}from-parent,from-command-line
-// CHECK-COMMAND-LINE: HeaderFilterRegex: from command line
+// CHECK-COMMAND-LINE: HeaderFilter: from command line
 
 // For this test we have to use names of the real checks because otherwise values are ignored.
 // RUN: clang-tidy -dump-config %S/Inputs/config-files/4/44/- -- | FileCheck %s -check-prefix=CHECK-CHILD4
 // CHECK-CHILD4: Checks: {{.*}}modernize-loop-convert,modernize-use-using,llvm-qualified-auto
 // CHECK-CHILD4-DAG: - key: llvm-qualified-auto.AddConstToQualified{{ *[[:space:]] *}}value: 'true'
 // CHECK-CHILD4-DAG: - key: modernize-loop-convert.MaxCopySize{{ *[[:space:]] *}}value: '20'
 // CHECK-CHILD4-DAG: - key: modernize-loop-convert.MinConfidence{{ *[[:space:]] *}}value: reasonable
 // CHECK-CHILD4-DAG: - key: modernize-use-using.IgnoreMacros{{ *[[:space:]] *}}value: 'false'

clang-tools-extra/test/clang-tidy/infrastructure/expand-modular-headers-ppcallbacks.cpp

 // Sanity-check. Run without modules:
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
 // RUN: %check_clang_tidy -std=c++11 %s readability-identifier-naming %t/without-modules -- \
 // RUN:   -config="CheckOptions: [{ \
 // RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
-// RUN:   -header-filter=.* \
+// RUN:   -header-filter=* \
 // RUN:   -- -I %t/
 //
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
 // RUN: %check_clang_tidy -std=c++17 %s readability-identifier-naming %t/without-modules -- \
 // RUN:   -config="CheckOptions: [{ \
 // RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
-// RUN:   -header-filter=.* \
+// RUN:   -header-filter=* \
 // RUN:   -- -I %t/
 //
 // Run clang-tidy on a file with modular includes:
 //
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
 // RUN: %check_clang_tidy -std=c++11 %s readability-identifier-naming %t/with-modules -- \
 // RUN:   -config="CheckOptions: [{ \
 // RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
-// RUN:   -header-filter=.* \
+// RUN:   -header-filter=* \
 // RUN:   -- -I %t/ \
 // RUN:   -fmodules -fimplicit-modules -fno-implicit-module-maps \
 // RUN:   -fmodule-map-file=%t/module.modulemap \
 // RUN:   -fmodules-cache-path=%t/module-cache/
 //
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
 // RUN: %check_clang_tidy -std=c++17 %s readability-identifier-naming %t/with-modules -- \
 // RUN:   -config="CheckOptions: [{ \
 // RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
-// RUN:   -header-filter=.* \
+// RUN:   -header-filter=* \
 // RUN:   -- -I %t/ \
 // RUN:   -fmodules -fimplicit-modules -fno-implicit-module-maps \
 // RUN:   -fmodule-map-file=%t/module.modulemap \
 // RUN:   -fmodules-cache-path=%t/module-cache/
 // FIXME: Make the test work in all language modes.
 #include "c.h"
 
 // CHECK-MESSAGES: a.h:1:9: warning: invalid case style for macro definition 'a' [readability-identifier-naming]

clang-tools-extra/test/clang-tidy/infrastructure/file-filter-symlinks.cpp

 // REQUIRES: shell
 
 // RUN: rm -rf %t
 // RUN: mkdir -p %t/dir1/dir2
 // RUN: echo 'class A { A(int); };' > %t/dir1/header.h
 // RUN: ln -s %t/dir1/header.h %t/dir1/header_alias.h
 //
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='dir1/dir2/\.\./header_alias\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='dir1/dir2/\.\./header_alias\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header_alias\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header_alias\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/dir1/dir2/../header_alias.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/dir1/dir2/../header_alias.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/header_alias.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/header_alias.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/header.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/header.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
 
 // Check that `-header-filter` operates on the same file paths as paths in
 // diagnostics printed by ClangTidy.
 #include "dir1/dir2/../header_alias.h"
 // CHECK_HEADER_ALIAS: dir1/dir2/../header_alias.h:1:11: warning: single-argument constructors
 // CHECK_HEADER-NOT: warning:

clang-tools-extra/test/clang-tidy/infrastructure/file-filter.cpp

 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK-QUIET %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2 %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2-QUIET %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header2\.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3 %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header2\.h' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3-QUIET %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2 %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2-QUIET %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/header2.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3 %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*/header2.h' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3-QUIET %s
 // FIXME: "-I %S/Inputs/file-filter/system/.." must be redundant.
 //       On Win32, file-filter/system\system-header1.h precedes
 //       file-filter\header*.h due to code order between '/' and '\\'.
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4 %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers -quiet %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4-QUIET %s
-
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*' -system-headers %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4 %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*' -system-headers -quiet %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4-QUIET %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='*,-*/header1.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK5 %s
 #include "header1.h"
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK2-QUIET: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:
 // CHECK4: header1.h:1:12: warning: single-argument constructors
 // CHECK4-QUIET: header1.h:1:12: warning: single-argument constructors
+// CHECK5-NOT: warning:
 
 #include "header2.h"
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2: header2.h:1:12: warning: single-argument constructors
 // CHECK2-QUIET: header2.h:1:12: warning: single-argument constructors
 // CHECK3: header2.h:1:12: warning: single-argument constructors
 // CHECK3-QUIET: header2.h:1:12: warning: single-argument constructors
 // CHECK4: header2.h:1:12: warning: single-argument constructors
 // CHECK4-QUIET: header2.h:1:12: warning: single-argument constructors
+// CHECK5: header2.h:1:12: warning: single-argument constructors
 
 #include <system-header.h>
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2-NOT: warning:
 // CHECK2-QUIET-NOT: warning:
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:
 // CHECK4: system-header.h:1:12: warning: single-argument constructors
 // CHECK4-QUIET: system-header.h:1:12: warning: single-argument constructors
+// CHECK5-NOT: warning:
 
 class A { A(int); };
 // CHECK: :[[@LINE-1]]:11: warning: single-argument constructors
 // CHECK-QUIET: :[[@LINE-2]]:11: warning: single-argument constructors
 // CHECK2: :[[@LINE-3]]:11: warning: single-argument constructors
 // CHECK2-QUIET: :[[@LINE-4]]:11: warning: single-argument constructors
 // CHECK3: :[[@LINE-5]]:11: warning: single-argument constructors
 // CHECK3-QUIET: :[[@LINE-6]]:11: warning: single-argument constructors
 // CHECK4: :[[@LINE-7]]:11: warning: single-argument constructors
 // CHECK4-QUIET: :[[@LINE-8]]:11: warning: single-argument constructors
+// CHECK5: :[[@LINE-9]]:11: warning: single-argument constructors
 
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2-NOT: warning:
 // CHECK2-QUIET-NOT: warning:
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:
 // CHECK4-NOT: warning:
 // CHECK4-QUIET-NOT: warning:
+// CHECK5-NOT: warning:
 
 // CHECK: Suppressed 3 warnings (3 in non-user code)
-// CHECK: Use -header-filter=.* to display errors from all non-system headers.
+// CHECK: Use -header-filter=* to display errors from all non-system headers.
 // CHECK-QUIET-NOT: Suppressed
 // CHECK2: Suppressed 1 warnings (1 in non-user code)
-// CHECK2: Use -header-filter=.* {{.*}}
+// CHECK2: Use -header-filter=* {{.*}}
 // CHECK2-QUIET-NOT: Suppressed
 // CHECK3: Suppressed 2 warnings (2 in non-user code)
-// CHECK3: Use -header-filter=.* {{.*}}
+// CHECK3: Use -header-filter=* {{.*}}
 // CHECK3-QUIET-NOT: Suppressed
 // CHECK4-NOT: Suppressed {{.*}} warnings
-// CHECK4-NOT: Use -header-filter=.* {{.*}}
+// CHECK4-NOT: Use -header-filter=* {{.*}}
 // CHECK4-QUIET-NOT: Suppressed
+// CHECK5: Suppressed 2 warnings (2 in non-user code)
+// CHECK5: Use -header-filter=* {{.*}}

clang-tools-extra/test/clang-tidy/infrastructure/line-filter.cpp

-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -line-filter='[{"name":"line-filter.cpp","lines":[[18,18],[22,22]]},{"name":"header1.h","lines":[[1,2]]},{"name":"header2.h"},{"name":"header3.h"}]' -header-filter='header[12]\.h$' %s -- -I %S/Inputs/line-filter 2>&1 | FileCheck %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -line-filter='[{"name":"line-filter.cpp","lines":[[18,18],[22,22]]},{"name":"header1.h","lines":[[1,2]]},{"name":"header2.h"},{"name":"header3.h"}]' -header-filter='*/header1.h,*/header2.h' %s -- -I %S/Inputs/line-filter 2>&1 | FileCheck %s
 
 #include "header1.h"
 // CHECK-NOT: header1.h:{{.*}} warning
 // CHECK: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK: header1.h:2:12: warning: single-argument constructors {{.*}}
 // CHECK-NOT: header1.h:{{.*}} warning
 
 #include "header2.h"

clang-tools-extra/test/clang-tidy/infrastructure/nolintbeginend-error-within-include.cpp

-// RUN: %check_clang_tidy %s google-explicit-constructor %t -- --header-filter=.* -system-headers -- -isystem %S/Inputs/nolintbeginend
+// RUN: %check_clang_tidy %s google-explicit-constructor %t -- --header-filter=* -system-headers -- -isystem %S/Inputs/nolintbeginend
 
 #include "error_in_include.inc"
 // CHECK-MESSAGES: error_in_include.inc:1:11: warning: single-argument constructors must be marked explicit
 
 #include "nolint_in_include.inc"
 
 // CHECK-MESSAGES: Suppressed 1 warnings (1 NOLINT).

clang-tools-extra/test/clang-tidy/infrastructure/overlapping.cpp

-// RUN: clang-tidy -checks=-*,llvm-include-order -header-filter=.* %s \
+// RUN: clang-tidy -checks=-*,llvm-include-order -header-filter=* %s \
 // RUN:   -- -isystem %S/Inputs/Headers -I %S/Inputs/overlapping | \
 // RUN:   not grep "note: this fix will not be applied because it overlaps with another fix"
 
 #include <s.h>
 #include "o.h"
 
 // Test that clang-tidy takes into account in which file we are doing the
 // replacements to determine if they overlap or not. In the file "o.h" there is
 // a similar error at the same file offset, but they do not overlap.

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

TEST(ParseLineFilter, ValidFilter) {
   EXPECT_EQ(1u, Options.LineFilter[2].LineRanges.size());
   EXPECT_EQ(100u, Options.LineFilter[2].LineRanges[0].first);
   EXPECT_EQ(1000u, Options.LineFilter[2].LineRanges[0].second);
 }
 
 TEST(ParseConfiguration, ValidConfiguration) {
   llvm::ErrorOr<ClangTidyOptions> Options =
       parseConfiguration(llvm::MemoryBufferRef("Checks: \"-*,misc-*\"\n"
-                                               "HeaderFilterRegex: \".*\"\n"
+                                               "HeaderFilter: \"*\"\n"
                                                "AnalyzeTemporaryDtors: true\n"
                                                "User: some.user",
                                                "Options"));
   EXPECT_TRUE(!!Options);
   EXPECT_EQ("-*,misc-*", *Options->Checks);
-  EXPECT_EQ(".*", *Options->HeaderFilterRegex);
+  EXPECT_EQ("*", *Options->HeaderFilter);
   EXPECT_EQ("some.user", *Options->User);
 }
 
 TEST(ParseConfiguration, MergeConfigurations) {
   llvm::ErrorOr<ClangTidyOptions> Options1 =
       parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check1,check2"
-      HeaderFilterRegex: "filter1"
+      HeaderFilter: "filter1"
       AnalyzeTemporaryDtors: true
       User: user1
       ExtraArgs: ['arg1', 'arg2']
       ExtraArgsBefore: ['arg-before1', 'arg-before2']
       UseColor: false
   )",
                                                "Options1"));
   ASSERT_TRUE(!!Options1);
   llvm::ErrorOr<ClangTidyOptions> Options2 =
       parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check3,check4"
-      HeaderFilterRegex: "filter2"
+      HeaderFilter: "filter2"
       AnalyzeTemporaryDtors: false
       User: user2
       ExtraArgs: ['arg3', 'arg4']
       ExtraArgsBefore: ['arg-before3', 'arg-before4']
       UseColor: true
   )",
                                                "Options2"));
   ASSERT_TRUE(!!Options2);
   ClangTidyOptions Options = Options1->merge(*Options2, 0);
   EXPECT_EQ("check1,check2,check3,check4", *Options.Checks);
-  EXPECT_EQ("filter2", *Options.HeaderFilterRegex);
+  EXPECT_EQ("filter2", *Options.HeaderFilter);
   EXPECT_EQ("user2", *Options.User);
   ASSERT_TRUE(Options.ExtraArgs.hasValue());
   EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(),
                                               Options.ExtraArgs->end(), ","));
   ASSERT_TRUE(Options.ExtraArgsBefore.hasValue());
   EXPECT_EQ("arg-before1,arg-before2,arg-before3,arg-before4",
             llvm::join(Options.ExtraArgsBefore->begin(),
                        Options.ExtraArgsBefore->end(), ","));

libc/src/.clang-tidy

 Checks: '-*,llvmlibc-*'
-HeaderFilterRegex: '.*'
+HeaderFilter: '*'
 WarningsAsErrors: 'llvmlibc-*'
 CheckOptions:
   - key:             llvmlibc-restrict-system-libc-headers.Includes
     value:           '-*, linux/*, asm/*.h, asm-generic/*.h'

libc/test/src/CMakeLists.txt

 
 if(COMPILER_RESOURCE_DIR AND LLVM_LIBC_ENABLE_LINTING)
   add_custom_target(
     libc-integration-test-tidy
     VERBATIM
     COMMAND $<TARGET_FILE:clang-tidy> --system-headers
       --checks=-*,llvmlibc-restrict-system-libc-headers
       "--extra-arg=-resource-dir=${COMPILER_RESOURCE_DIR}"
-      --header-filter=.*
+      --header-filter=*
       --warnings-as-errors=llvmlibc-*
       "-config={CheckOptions: [{key: llvmlibc-restrict-system-libc-headers.Includes, value: '-*, linux/*, asm/*.h, asm-generic/*.h'}]}"
       --quiet
       -p ${PROJECT_BINARY_DIR}
       ${public_test}
     DEPENDS
       clang-tidy ${public_test}
   )
   add_dependencies(libc-integration-test libc-integration-test-tidy)
 endif()
 
 target_link_libraries(libc-integration-test
   PRIVATE
   ${library_files}
 )