[libc++] Migrate warning flags to the DSL

[ldionne]

Summary

This makes us closer to running the test suite on platforms where the
legacy test suite configuration doesn't work.

[ldionne]

Rebase

[ldionne]

Rebase

[ldionne]

Rebase onto master

[ldionne]

Rebase onto master with all GCC warnings fixed (should be)

[ldionne]

Build passed with retries, will commit.

libcxx/docs/TestingLibcxx.rst

 
 Some other common examples include:
 
 .. code-block:: bash
 
   # Specify a custom compiler.
   $ <build>/bin/llvm-lit -sv libcxx/test/std --param=cxx_under_test=/opt/bin/g++
 
-  # Enable warnings in the test suite
-  $ <build>/bin/llvm-lit -sv libcxx/test --param=enable_warnings=true
+  # Disable warnings in the test suite
+  $ <build>/bin/llvm-lit -sv libcxx/test --param=enable_warnings=False
 
   # Use UBSAN when running the tests.
   $ <build>/bin/llvm-lit -sv libcxx/test --param=use_sanitizer=Undefined
 
 Using a custom site configuration
 ---------------------------------
 
 By default, the libc++ test suite will use a site configuration that matches

libcxx/utils/libcxx/test/config.py

def configure(self):
         self.cxx_stdlib_under_test = self.get_lit_conf('cxx_stdlib_under_test', 'libc++')
         self.cxx_library_root = self.get_lit_conf('cxx_library_root', self.libcxx_obj_root)
         self.abi_library_root = self.get_lit_conf('abi_library_path', None)
         self.cxx_runtime_root = self.get_lit_conf('cxx_runtime_root', self.cxx_library_root)
         self.configure_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_debug_mode()
-        self.configure_warnings()
         self.configure_sanitizer()
         self.configure_coverage()
         self.configure_modules()
         self.configure_substitutions()
         self.configure_features()
 
         libcxx.test.newconfig.configure(
             libcxx.test.params.DEFAULT_PARAMETERS,
def configure_default_compile_flags(self):
         support_path = os.path.join(self.libcxx_src_root, 'test/support')
         self.cxx.compile_flags += ['-I' + support_path]
 
         # If we're testing the upstream LLVM libc++, disable availability markup,
         # which is not relevant for non-shipped flavors of libc++.
         if not self.use_system_cxx_lib:
             self.cxx.compile_flags += ['-D_LIBCPP_DISABLE_AVAILABILITY']
 
+        # On GCC, the libc++ headers cause errors due to throw() decorators
+        # on operator new clashing with those from the test suite, so we
+        # don't enable warnings in system headers on GCC.
+        if self.cxx.type != 'gcc':
+            self.cxx.compile_flags += ['-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER']
+
         # Add includes for the PSTL headers
         pstl_src_root = self.get_lit_conf('pstl_src_root')
         pstl_obj_root = self.get_lit_conf('pstl_obj_root')
         if pstl_src_root is not None and pstl_obj_root is not None:
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_src_root, 'include')]
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_obj_root, 'generated_headers')]
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_src_root, 'test')]
             self.config.available_features.add('parallel-algorithms')
def configure_debug_mode(self):
         debug_level = self.get_lit_conf('debug_level', None)
         if not debug_level:
             return
         if debug_level not in ['0', '1']:
             self.lit_config.fatal('Invalid value for debug_level "%s".'
                                   % debug_level)
         self.cxx.compile_flags += ['-D_LIBCPP_DEBUG=%s' % debug_level]
 
-    def configure_warnings(self):
-        # Turn on warnings by default for Clang based compilers
-        default_enable_warnings = self.cxx.type in ['clang', 'apple-clang']
-        enable_warnings = self.get_lit_bool('enable_warnings',
-                                            default_enable_warnings)
-        self.cxx.useWarnings(enable_warnings)
-        self.cxx.warning_flags += ['-Werror', '-Wall', '-Wextra']
-        # On GCC, the libc++ headers cause errors due to throw() decorators
-        # on operator new clashing with those from the test suite, so we
-        # don't enable warnings in system headers on GCC.
-        if self.cxx.type != 'gcc':
-            self.cxx.warning_flags += ['-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER']
-        self.cxx.addWarningFlagIfSupported('-Wshadow')
-        self.cxx.addWarningFlagIfSupported('-Wno-unused-command-line-argument')
-        self.cxx.addWarningFlagIfSupported('-Wno-attributes')
-        self.cxx.addWarningFlagIfSupported('-Wno-pessimizing-move')
-        self.cxx.addWarningFlagIfSupported('-Wno-c++11-extensions')
-        self.cxx.addWarningFlagIfSupported('-Wno-user-defined-literals')
-        self.cxx.addWarningFlagIfSupported('-Wno-noexcept-type')
-        self.cxx.addWarningFlagIfSupported('-Wno-aligned-allocation-unavailable')
-        self.cxx.addWarningFlagIfSupported('-Wno-atomic-alignment')
-
-        # GCC warns about places where we might want to add sized allocation/deallocation
-        # functions, but we know better what we're doing/testing in the test suite.
-        self.cxx.addWarningFlagIfSupported('-Wno-sized-deallocation')
-
-        # These warnings should be enabled in order to support the MSVC
-        # team using the test suite; They enable the warnings below and
-        # expect the test suite to be clean.
-        self.cxx.addWarningFlagIfSupported('-Wsign-compare')
-        self.cxx.addWarningFlagIfSupported('-Wunused-variable')
-        self.cxx.addWarningFlagIfSupported('-Wunused-parameter')
-        self.cxx.addWarningFlagIfSupported('-Wunreachable-code')
-        self.cxx.addWarningFlagIfSupported('-Wno-unused-local-typedef')
-
     def configure_sanitizer(self):
         san = self.get_lit_conf('use_sanitizer', '').strip()
         if san:
             # Search for llvm-symbolizer along the compiler path first
             # and then along the PATH env variable.
             symbolizer_search_paths = os.environ.get('PATH', '')
             cxx_path = libcxx.util.which(self.cxx.path)
             if cxx_path is not None:

libcxx/utils/libcxx/test/dsl.py

def applyTo(self, config):
     flag = self._getFlag(config)
     assert hasCompileFlag(config, flag), "Trying to enable link flag {}, which is not supported".format(flag)
     config.substitutions = _addToSubstitution(config.substitutions, '%{link_flags}', flag)
 
   def pretty(self, config, litParams):
     return 'add {} to %{{link_flags}}'.format(self._getFlag(config))
 
 
+class AddOptionalWarningFlag(ConfigAction):
+  """
+  This action adds the given warning flag to the %{compile_flags} substitution,
+  if it is supported by the compiler.
+
+  The flag can be a string or a callable, in which case it is called with the
+  configuration to produce the actual flag (as a string).
+  """
+  def __init__(self, flag):
+    self._getFlag = lambda config: flag(config) if callable(flag) else flag
+
+  def applyTo(self, config):
+    flag = self._getFlag(config)
+    # Use -Werror to make sure we see an error about the flag being unsupported.
+    if hasCompileFlag(config, '-Werror ' + flag):
+      config.substitutions = _addToSubstitution(config.substitutions, '%{compile_flags}', flag)
+
+  def pretty(self, config, litParams):
+    return 'add {} to %{{compile_flags}}'.format(self._getFlag(config))
+
+
 class Feature(object):
   """
   Represents a Lit available feature that is enabled whenever it is supported.
 
   A feature like this informs the test suite about a capability of the compiler,
   platform, etc. Unlike Parameters, it does not make sense to explicitly
   control whether a Feature is enabled -- it should be enabled whenever it
   is supported.

libcxx/utils/libcxx/test/params.py

 #===----------------------------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 from libcxx.test.dsl import *
 
 _allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++2a']
+_warningFlags = [
+  '-Werror',
+  '-Wall',
+  '-Wextra',
+  '-Wshadow',
+  '-Wno-unused-command-line-argument',
+  '-Wno-attributes',
+  '-Wno-pessimizing-move',
+  '-Wno-c++11-extensions',
+  '-Wno-user-defined-literals',
+  '-Wno-noexcept-type',
+  '-Wno-aligned-allocation-unavailable',
+  '-Wno-atomic-alignment',
+
+  # GCC warns about places where we might want to add sized allocation/deallocation
+  # functions, but we know better what we're doing/testing in the test suite.
+  '-Wno-sized-deallocation',
+
+  # These warnings should be enabled in order to support the MSVC
+  # team using the test suite; They enable the warnings below and
+  # expect the test suite to be clean.
+  '-Wsign-compare',
+  '-Wunused-variable',
+  '-Wunused-parameter',
+  '-Wunreachable-code',
+  '-Wno-unused-local-typedef',
+]
 
 DEFAULT_PARAMETERS = [
   # Core parameters of the test suite
   Parameter(name='std', choices=_allStandards, type=str,
             help="The version of the standard to compile the test suite with.",
             default=lambda cfg: next(s for s in reversed(_allStandards) if hasCompileFlag(cfg, '-std='+s)),
             actions=lambda std: [
               AddFeature(std),
Parameter(name='enable_rtti', choices=[True, False], type=bool, default=True,
             ]),
 
   Parameter(name='stdlib', choices=['libc++', 'libstdc++', 'msvc'], type=str, default='libc++',
             help="The C++ Standard Library implementation being tested.",
             actions=lambda stdlib: [
               AddFeature(stdlib)
             ]),
 
+  Parameter(name='enable_warnings', choices=[True, False], type=bool, default=True,
+            help="Whether to enable warnings when compiling the test suite.",
+            actions=lambda warnings: [] if not warnings else [
+              AddOptionalWarningFlag(w) for w in _warningFlags
+            ]),
+
   # Parameters to enable or disable parts of the test suite
   Parameter(name='enable_filesystem', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests for the C++ <filesystem> library.",
             actions=lambda filesystem: [] if filesystem else [
               AddFeature('c++filesystem-disabled')
             ]),
 
   Parameter(name='enable_experimental', choices=[True, False], type=bool, default=False,