Fix -Wno-error= parsing in clang-format.

[fodinabor]

Summary

As noted in https://reviews.llvm.org/D86137#2460135 parsing of
the clang-format parameter -Wno-error=unknown fails.
This currently is done by having -Wno-error=unknown as an option.
In this patch this is changed to make -Wno-error= parse an enum into a bit set.
This way the parsing is fixed and also we can possibly add new options easily.

[fodinabor]

Quoting my questions from the other review, as it should be more appropriate to discuss this here:

The formatting of the --help page is still slightly off (I guess cl::values descriptions are supposed to be single line), so I guess I have to investigate my formatting options here or move the more extensive description somewhere else...

Clang-format options:

  --Werror                   - If set, changes formatting warnings to errors
  --Wno-error=<value>        - If set don't error out on the specified warning type.
    =unknown                 -   If set, unknown format options are only warned about.
This can be used to enable formatting, even if the
configuration contains unknown (newer) options.
Use with caution, as this might lead to dramatically
differing format depending on an option being
supported or not.
  --assume-filename=<string> - Override filename used to determine the language.
                               When reading from stdin, clang-format assumes this
                               filename to determine the language.
  --cursor=<uint>            - The position of the cursor when invoking
...

Btw. is there a way to add tests for command-line options, so this won't happen unnoticed again?

[njames93]

In D93459#2460445, @fodinabor wrote:

Btw. is there a way to add tests for command-line options, so this won't happen unnoticed again?

I'd guess some lit tests could be used to verify the command line syntax is correct

// RUN: clang-format --Wno-error=unknown --style=`{UnknownKey: true}` --dump-config

If it can't parse that command line, or it maybe parses it incorrectly, clang-format will return non-zero and fail the test

[fodinabor]

Add lit test to ensure behaviour of the -Wno-error=unkown flag.

[MyDeveloperDay]

LGTM

[fodinabor]

Update ClangFormat.rst.
This is manually well formatted.. will try to make a new patch in the coming days to actually fix it in the support library.

clang/docs/ClangFormat.rst

.. code-block:: console
 
   USAGE: clang-format [options] [<file> ...]
 
   OPTIONS:
 
   Clang-format options:
 
     --Werror                   - If set, changes formatting warnings to errors
-    --Wno-error=unknown        - If set, unknown format options are only warned about.
+    --Wno-error=<value>        - If set don't error out on the specified warning type.
+      =unknown                 -   If set, unknown format options are only warned about.
                                    This can be used to enable formatting, even if the
                                    configuration contains unknown (newer) options.
                                    Use with caution, as this might lead to dramatically
                                    differing format depending on an option being
                                    supported or not.
     --assume-filename=<string> - Override filename used to determine the language.
                                  When reading from stdin, clang-format assumes this
                                  filename to determine the language.
     --cursor=<uint>            - The position of the cursor when invoking
                                  clang-format from an editor integration
     --dry-run                  - If set, do not actually make the formatting changes
     --dump-config              - Dump configuration options to stdout and exit.
                                  Can be used with -style option.

clang/test/Format/error-config.cpp

+// RUN: clang-format %s --Wno-error=unknown --style="{UnknownKey: true}" 2>&1 | FileCheck %s -check-prefix=CHECK
+// RUN: not clang-format %s --style="{UnknownKey: true}" 2>&1 | FileCheck %s -check-prefix=CHECK-FAIL
+
+// CHECK: YAML:1:2: warning: unknown key 'UnknownKey'
+// CHECK-NEXT: {UnknownKey: true}
+// CHECK-NEXT: ^~~~~~~~~~
+// CHECK-FAIL: YAML:1:2: error: unknown key 'UnknownKey'
+// CHECK-FAIL-NEXT: {UnknownKey: true}
+// CHECK-FAIL-NEXT: ^~~~~~~~~~
+
+int i ;

clang/tools/clang-format/ClangFormat.cpp

Cursor("cursor",
            cl::init(0), cl::cat(ClangFormatCategory));
 
 static cl::opt<bool> SortIncludes(
     "sort-includes",
     cl::desc("If set, overrides the include sorting behavior determined by the "
              "SortIncludes style flag"),
     cl::cat(ClangFormatCategory));
 
-// using the full param name as Wno-error probably won't be a common use case in
-// clang-format
-static cl::opt<bool> AllowUnknownOptions(
-    "Wno-error=unknown",
-    cl::desc("If set, unknown format options are only warned about.\n"
-             "This can be used to enable formatting, even if the\n"
-             "configuration contains unknown (newer) options.\n"
-             "Use with caution, as this might lead to dramatically\n"
-             "differing format depending on an option being\n"
-             "supported or not."),
-    cl::init(false), cl::cat(ClangFormatCategory));
-
 static cl::opt<bool>
     Verbose("verbose", cl::desc("If set, shows the list of processed files"),
             cl::cat(ClangFormatCategory));
 
 // Use --dry-run to match other LLVM tools when you mean do it but don't
 // actually do it
 static cl::opt<bool>
     DryRun("dry-run",
cl::desc("Set the maximum number of clang-format errors to emit before "
              "stopping (0 = no limit). Used only with --dry-run or -n"),
     cl::init(0), cl::cat(ClangFormatCategory));
 
 static cl::opt<bool>
     WarningsAsErrors("Werror",
                      cl::desc("If set, changes formatting warnings to errors"),
                      cl::cat(ClangFormatCategory));
 
+namespace {
+enum class WNoError { Unknown };
+}
+
+static cl::bits<WNoError> WNoErrorList(
+    "Wno-error",
+    cl::desc("If set don't error out on the specified warning type."),
+    cl::values(
+        clEnumValN(WNoError::Unknown, "unknown",
+                   "If set, unknown format options are only warned about.\n"
+                   "This can be used to enable formatting, even if the\n"
+                   "configuration contains unknown (newer) options.\n"
+                   "Use with caution, as this might lead to dramatically\n"
+                   "differing format depending on an option being\n"
+                   "supported or not.")),
+    cl::cat(ClangFormatCategory));
+
 static cl::opt<bool>
     ShowColors("fcolor-diagnostics",
                cl::desc("If set, and on a color-capable terminal controls "
                         "whether or not to print diagnostics in color"),
                cl::init(true), cl::cat(ClangFormatCategory), cl::Hidden);
 
 static cl::opt<bool>
     NoShowColors("fno-color-diagnostics",
static bool format(StringRef FileName) {
   StringRef AssumedFileName = (FileName == "-") ? AssumeFileName : FileName;
   if (AssumedFileName.empty()) {
     llvm::errs() << "error: empty filenames are not allowed\n";
     return true;
   }
 
   llvm::Expected<FormatStyle> FormatStyle =
       getStyle(Style, AssumedFileName, FallbackStyle, Code->getBuffer(),
-               nullptr, AllowUnknownOptions.getValue());
+               nullptr, WNoErrorList.isSet(WNoError::Unknown));
   if (!FormatStyle) {
     llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
     return true;
   }
 
   if (SortIncludes.getNumOccurrences() != 0)
     FormatStyle->SortIncludes = SortIncludes;
   unsigned CursorPosition = Cursor;