[libc++] Add a new concept of ConfigAction, and use it in the DSL

[ldionne]

Summary

This will allow adding bare compiler flags through the new
configuration DSL. Previously, this would have required adding
a Lit feature for each such flag.

[ldionne]

@arichardson You might be interested by this.

[ldionne]

Fix debug mode param

libcxx/test/libcxx/selftest/dsl/dsl.sh.py

 
 class TestFeature(SetupConfigs):
     """
     Tests for libcxx.test.dsl.Feature
     """
     def test_trivial(self):
         feature = dsl.Feature(name='name')
         origSubstitutions = copy.deepcopy(self.config.substitutions)
-        self.assertTrue(feature.isSupported(self.config))
-        feature.enableIn(self.config)
+        actions = feature.getActions(self.config)
+        self.assertTrue(len(actions) == 1)
+        for a in actions:
+            a.applyTo(self.config)
         self.assertEqual(origSubstitutions, self.config.substitutions)
         self.assertIn('name', self.config.available_features)
 
     def test_name_can_be_a_callable(self):
         feature = dsl.Feature(name=lambda cfg: 'name')
-        assert feature.isSupported(self.config)
-        self.assertEqual('name', feature.getName(self.config))
-        feature.enableIn(self.config)
+        for a in feature.getActions(self.config):
+            a.applyTo(self.config)
         self.assertIn('name', self.config.available_features)
 
     def test_name_is_not_a_string_1(self):
         feature = dsl.Feature(name=None)
-        assert feature.isSupported(self.config)
-        self.assertRaises(ValueError, lambda: feature.getName(self.config))
-        self.assertRaises(ValueError, lambda: feature.enableIn(self.config))
+        self.assertRaises(ValueError, lambda: feature.getActions(self.config))
+        self.assertRaises(ValueError, lambda: feature.pretty(self.config))
 
     def test_name_is_not_a_string_2(self):
         feature = dsl.Feature(name=lambda cfg: None)
-        assert feature.isSupported(self.config)
-        self.assertRaises(ValueError, lambda: feature.getName(self.config))
-        self.assertRaises(ValueError, lambda: feature.enableIn(self.config))
+        self.assertRaises(ValueError, lambda: feature.getActions(self.config))
+        self.assertRaises(ValueError, lambda: feature.pretty(self.config))
 
-    def test_getName_when_unsupported(self):
-        feature = dsl.Feature(name='name', when=lambda _: False)
-        assert not feature.isSupported(self.config)
-        self.assertRaises(AssertionError, lambda: feature.getName(self.config))
-
-    def test_adding_compile_flag(self):
-        feature = dsl.Feature(name='name', compileFlag='-foo')
+    def test_adding_action(self):
+        feature = dsl.Feature(name='name', actions=[dsl.AddCompileFlag('-std=c++03')])
         origLinkFlags = copy.deepcopy(self.getSubstitution('%{link_flags}'))
-        assert feature.isSupported(self.config)
-        feature.enableIn(self.config)
+        for a in feature.getActions(self.config):
+            a.applyTo(self.config)
         self.assertIn('name', self.config.available_features)
-        self.assertIn('-foo', self.getSubstitution('%{compile_flags}'))
+        self.assertIn('-std=c++03', self.getSubstitution('%{compile_flags}'))
         self.assertEqual(origLinkFlags, self.getSubstitution('%{link_flags}'))
 
-    def test_compile_flag_can_be_a_callable(self):
+    def test_actions_can_be_a_callable(self):
         feature = dsl.Feature(name='name',
-                              compileFlag=lambda cfg: (self.assertIs(self.config, cfg), '-foo')[1])
-        assert feature.isSupported(self.config)
-        feature.enableIn(self.config)
-        self.assertIn('-foo', self.getSubstitution('%{compile_flags}'))
-
-    def test_adding_link_flag(self):
-        feature = dsl.Feature(name='name', linkFlag='-foo')
-        origCompileFlags = copy.deepcopy(self.getSubstitution('%{compile_flags}'))
-        assert feature.isSupported(self.config)
-        feature.enableIn(self.config)
-        self.assertIn('name', self.config.available_features)
-        self.assertIn('-foo', self.getSubstitution('%{link_flags}'))
-        self.assertEqual(origCompileFlags, self.getSubstitution('%{compile_flags}'))
-
-    def test_link_flag_can_be_a_callable(self):
-        feature = dsl.Feature(name='name',
-                              linkFlag=lambda cfg: (self.assertIs(self.config, cfg), '-foo')[1])
-        assert feature.isSupported(self.config)
-        feature.enableIn(self.config)
-        self.assertIn('-foo', self.getSubstitution('%{link_flags}'))
-
-    def test_adding_both_flags(self):
-        feature = dsl.Feature(name='name', compileFlag='-hello', linkFlag='-world')
-        assert feature.isSupported(self.config)
-        feature.enableIn(self.config)
-        self.assertIn('name', self.config.available_features)
-
-        self.assertIn('-hello', self.getSubstitution('%{compile_flags}'))
-        self.assertNotIn('-world', self.getSubstitution('%{compile_flags}'))
-
-        self.assertIn('-world', self.getSubstitution('%{link_flags}'))
-        self.assertNotIn('-hello', self.getSubstitution('%{link_flags}'))
+                              actions=lambda cfg: (
+                                self.assertIs(self.config, cfg),
+                                [dsl.AddCompileFlag('-std=c++03')]
+                              )[1])
+        for a in feature.getActions(self.config):
+            a.applyTo(self.config)
+        self.assertIn('-std=c++03', self.getSubstitution('%{compile_flags}'))
 
     def test_unsupported_feature(self):
         feature = dsl.Feature(name='name', when=lambda _: False)
-        self.assertFalse(feature.isSupported(self.config))
-        # Also make sure we assert if we ever try to add it to a config
-        self.assertRaises(AssertionError, lambda: feature.enableIn(self.config))
+        self.assertEqual(feature.getActions(self.config), [])
 
     def test_is_supported_gets_passed_the_config(self):
         feature = dsl.Feature(name='name', when=lambda cfg: (self.assertIs(self.config, cfg), True)[1])
-        self.assertTrue(feature.isSupported(self.config))
+        self.assertEqual(len(feature.getActions(self.config)), 1)
+
 
+def _throw():
+    raise ValueError()
 
 class TestParameter(SetupConfigs):
     """
     Tests for libcxx.test.dsl.Parameter
     """
     def test_empty_name_should_blow_up(self):
-        self.assertRaises(ValueError, lambda: dsl.Parameter(name='', choices=['c++03'], type=str, help='', feature=lambda _: None))
+        self.assertRaises(ValueError, lambda: dsl.Parameter(name='', choices=['c++03'], type=str, help='', actions=lambda _: []))
 
     def test_empty_choices_should_blow_up(self):
-        self.assertRaises(ValueError, lambda: dsl.Parameter(name='std', choices=[], type=str, help='', feature=lambda _: None))
+        self.assertRaises(ValueError, lambda: dsl.Parameter(name='std', choices=[], type=str, help='', actions=lambda _: []))
 
     def test_name_is_set_correctly(self):
-        param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='', feature=lambda _: None)
+        param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='', actions=lambda _: [])
         self.assertEqual(param.name, 'std')
 
     def test_no_value_provided_and_no_default_value(self):
-        param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='', feature=lambda _: None)
-        self.assertRaises(ValueError, lambda: param.getFeature(self.config, self.litConfig.params))
+        param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='', actions=lambda _: [])
+        self.assertRaises(ValueError, lambda: param.getActions(self.config, self.litConfig.params))
 
     def test_no_value_provided_and_default_value(self):
         param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='', default='c++03',
-                              feature=lambda std: dsl.Feature(name=std))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda std: [dsl.AddFeature(std)])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('c++03', self.config.available_features)
 
     def test_value_provided_on_command_line_and_no_default_value(self):
         self.litConfig.params['std'] = 'c++03'
         param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='',
-                              feature=lambda std: dsl.Feature(name=std))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda std: [dsl.AddFeature(std)])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('c++03', self.config.available_features)
 
     def test_value_provided_on_command_line_and_default_value(self):
         """The value provided on the command line should override the default value"""
         self.litConfig.params['std'] = 'c++11'
         param = dsl.Parameter(name='std', choices=['c++03', 'c++11'], type=str, default='c++03', help='',
-                              feature=lambda std: dsl.Feature(name=std))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda std: [dsl.AddFeature(std)])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('c++11', self.config.available_features)
         self.assertNotIn('c++03', self.config.available_features)
 
     def test_value_provided_in_config_and_default_value(self):
         """The value provided in the config should override the default value"""
         self.config.std ='c++11'
         param = dsl.Parameter(name='std', choices=['c++03', 'c++11'], type=str, default='c++03', help='',
-                              feature=lambda std: dsl.Feature(name=std))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda std: [dsl.AddFeature(std)])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('c++11', self.config.available_features)
         self.assertNotIn('c++03', self.config.available_features)
 
     def test_value_provided_in_config_and_on_command_line(self):
         """The value on the command line should override the one in the config"""
         self.config.std = 'c++11'
         self.litConfig.params['std'] = 'c++03'
         param = dsl.Parameter(name='std', choices=['c++03', 'c++11'], type=str, help='',
-                              feature=lambda std: dsl.Feature(name=std))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda std: [dsl.AddFeature(std)])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('c++03', self.config.available_features)
         self.assertNotIn('c++11', self.config.available_features)
 
-    def test_feature_is_None(self):
+    def test_no_actions(self):
         self.litConfig.params['std'] = 'c++03'
         param = dsl.Parameter(name='std', choices=['c++03'], type=str, help='',
-                              feature=lambda _: None)
-        feature = param.getFeature(self.config, self.litConfig.params)
-        self.assertIsNone(feature)
+                              actions=lambda _: [])
+        actions = param.getActions(self.config, self.litConfig.params)
+        self.assertEqual(actions, [])
 
     def test_boolean_value_parsed_from_trueish_string_parameter(self):
         self.litConfig.params['enable_exceptions'] = "True"
         param = dsl.Parameter(name='enable_exceptions', choices=[True, False], type=bool, help='',
-                              feature=lambda exceptions: None if exceptions else ValueError())
-        self.assertIsNone(param.getFeature(self.config, self.litConfig.params))
+                              actions=lambda exceptions: [] if exceptions else _throw())
+        self.assertEqual(param.getActions(self.config, self.litConfig.params), [])
 
     def test_boolean_value_from_true_boolean_parameter(self):
         self.litConfig.params['enable_exceptions'] = True
         param = dsl.Parameter(name='enable_exceptions', choices=[True, False], type=bool, help='',
-                              feature=lambda exceptions: None if exceptions else ValueError())
-        self.assertIsNone(param.getFeature(self.config, self.litConfig.params))
+                              actions=lambda exceptions: [] if exceptions else _throw())
+        self.assertEqual(param.getActions(self.config, self.litConfig.params), [])
 
     def test_boolean_value_parsed_from_falseish_string_parameter(self):
         self.litConfig.params['enable_exceptions'] = "False"
         param = dsl.Parameter(name='enable_exceptions', choices=[True, False], type=bool, help='',
-                              feature=lambda exceptions: None if exceptions else dsl.Feature(name="-fno-exceptions"))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda exceptions: [] if exceptions else [dsl.AddFeature("-fno-exceptions")])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('-fno-exceptions', self.config.available_features)
 
     def test_boolean_value_from_false_boolean_parameter(self):
         self.litConfig.params['enable_exceptions'] = False
         param = dsl.Parameter(name='enable_exceptions', choices=[True, False], type=bool, help='',
-                              feature=lambda exceptions: None if exceptions else dsl.Feature(name="-fno-exceptions"))
-        param.getFeature(self.config, self.litConfig.params).enableIn(self.config)
+                              actions=lambda exceptions: [] if exceptions else [dsl.AddFeature("-fno-exceptions")])
+        for a in param.getActions(self.config, self.litConfig.params):
+            a.applyTo(self.config)
         self.assertIn('-fno-exceptions', self.config.available_features)
 
 
 if __name__ == '__main__':
     unittest.main(verbosity=2)

libcxx/utils/libcxx/test/dsl.py

def featureTestMacros(config, flags=''):
 
   The keys are strings representing feature test macros, and the values are
   integers representing the value of the macro.
   """
   allMacros = compilerMacros(config, flags)
   return {m: int(v.rstrip('LlUu')) for (m, v) in allMacros.items() if m.startswith('__cpp_')}
 
 
+def _addToSubstitution(substitutions, key, value):
+  return [(k, v + ' ' + value) if k == key else (k, v) for (k, v) in substitutions]
+
+
+class ConfigAction(object):
+  """
+  This class represents an action that can be performed on a Lit TestingConfig
+  object.
+
+  Examples of such actions are adding or modifying substitutions, Lit features,
+  etc. This class only provides the interface of such actions, and it is meant
+  to be subclassed appropriately to create new actions.
+  """
+  def applyTo(self, config):
+    """
+    Applies the action to the given configuration.
+
+    This should modify the configuration object in place, and return nothing.
+
+    If applying the action to the configuration would yield an invalid
+    configuration, and it is possible to diagnose it here, this method
+    should produce an error. For example, it should be an error to modify
+    a substitution in a way that we know for sure is invalid (e.g. adding
+    a compiler flag when we know the compiler doesn't support it). Failure
+    to do so early may lead to difficult-to-diagnose issues down the road.
+    """
+    pass
+
+  def pretty(self, config, litParams):
+    """
+    Returns a short and human-readable string describing what this action does.
+
+    This is used for logging purposes when running the test suite, so it should
+    be kept concise.
+    """
+    pass
+
+
+class AddFeature(ConfigAction):
+  """
+  This action defines the given Lit feature when running the test suite.
+
+  The name of the feature can be a string or a callable, in which case it is
+  called with the configuration to produce the feature name (as a string).
+  """
+  def __init__(self, name):
+    self._name = name
+
+  def _getName(self, config):
+    name = self._name(config) if callable(self._name) else self._name
+    if not isinstance(name, str):
+      raise ValueError("Lit feature did not resolve to a string (got {})".format(name))
+    return name
+
+  def applyTo(self, config):
+    config.available_features.add(self._getName(config))
+
+  def pretty(self, config, litParams):
+    return 'add Lit feature {}'.format(self._getName(config))
+
+
+class AddFlag(ConfigAction):
+  """
+  This action adds the given flag to the %{flags} substitution.
+
+  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)
+    assert hasCompileFlag(config, flag), "Trying to enable flag {}, which is not supported".format(flag)
+    config.substitutions = _addToSubstitution(config.substitutions, '%{flags}', flag)
+
+  def pretty(self, config, litParams):
+    return 'add {} to %{{flags}}'.format(self._getFlag(config))
+
+
+class AddCompileFlag(ConfigAction):
+  """
+  This action adds the given flag to the %{compile_flags} substitution.
+
+  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)
+    assert hasCompileFlag(config, flag), "Trying to enable compile flag {}, which is not supported".format(flag)
+    config.substitutions = _addToSubstitution(config.substitutions, '%{compile_flags}', flag)
+
+  def pretty(self, config, litParams):
+    return 'add {} to %{{compile_flags}}'.format(self._getFlag(config))
+
+
+class AddLinkFlag(ConfigAction):
+  """
+  This action adds the given flag to the %{link_flags} substitution.
+
+  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)
+    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 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.
   """
-  def __init__(self, name, compileFlag=None, linkFlag=None, when=lambda _: True):
+  def __init__(self, name, actions=None, when=lambda _: True):
     """
     Create a Lit feature for consumption by a test suite.
 
     - name
         The name of the feature. This is what will end up in Lit's available
         features if the feature is enabled. This can be either a string or a
         callable, in which case it is passed the TestingConfig and should
         generate a string representing the name of the feature.
 
-    - compileFlag
-        An optional compile flag to add when this feature is added to a
-        TestingConfig. If provided, this must be a string representing a
-        compile flag that will be appended to the end of the %{compile_flags}
-        substitution of the TestingConfig.
-
-    - linkFlag
-        An optional link flag to add when this feature is added to a
-        TestingConfig. If provided, this must be a string representing a
-        link flag that will be appended to the end of the %{link_flags}
-        substitution of the TestingConfig.
+    - actions
+        An optional list of ConfigActions to apply when the feature is supported.
+        An AddFeature action is always created regardless of any actions supplied
+        here -- these actions are meant to perform more than setting a corresponding
+        Lit feature (e.g. adding compiler flags). If 'actions' is a callable, it
+        is called with the current configuration object to generate the actual
+        list of actions.
 
     - when
         A callable that gets passed a TestingConfig and should return a
         boolean representing whether the feature is supported in that
         configuration. For example, this can use `hasCompileFlag` to
         check whether the compiler supports the flag that the feature
         represents. If omitted, the feature will always be considered
         supported.
     """
     self._name = name
-    self._compileFlag = compileFlag
-    self._linkFlag = linkFlag
+    self._actions = [] if actions is None else actions
     self._isSupported = when
 
-  def isSupported(self, config):
-    """
-    Return whether the feature is supported by the given TestingConfig.
-    """
-    return self._isSupported(config)
-
-  def getName(self, config):
-    """
-    Return the name of the feature.
-
-    It is an error to call `f.getName(cfg)` if the feature `f` is not supported.
-    """
-    assert self.isSupported(config), \
-      "Trying to get the name of a feature that is not supported in the given configuration"
+  def _getName(self, config):
     name = self._name(config) if callable(self._name) else self._name
     if not isinstance(name, str):
       raise ValueError("Feature did not resolve to a name that's a string, got {}".format(name))
     return name
 
-  def enableIn(self, config):
+  def getActions(self, config):
     """
-    Enable a feature in a TestingConfig.
+    Return the list of actions associated to this feature.
 
-    The name of the feature is added to the set of available features of
-    `config`, and any compile or link flags provided upon construction of
-    the Feature are added to the end of the corresponding substitution in
-    the config.
-
-    It is an error to call `f.enableIn(cfg)` if the feature `f` is not
-    supported in that TestingConfig (i.e. if `not f.isSupported(cfg)`).
-    """
-    assert self.isSupported(config), \
-      "Trying to enable feature {} that is not supported in the given configuration".format(self._name)
-
-    addTo = lambda subs, sub, flag: [(s, x + ' ' + flag) if s == sub else (s, x) for (s, x) in subs]
-    if self._compileFlag:
-      compileFlag = self._compileFlag(config) if callable(self._compileFlag) else self._compileFlag
-      config.substitutions = addTo(config.substitutions, '%{compile_flags}', compileFlag)
-    if self._linkFlag:
-      linkFlag = self._linkFlag(config) if callable(self._linkFlag) else self._linkFlag
-      config.substitutions = addTo(config.substitutions, '%{link_flags}', linkFlag)
-    config.available_features.add(self.getName(config))
+    If the feature is not supported, an empty list is returned.
+    If the feature is supported, an `AddFeature` action is automatically added
+    to the returned list of actions, in addition to any actions provided on
+    construction.
+    """
+    if not self._isSupported(config):
+      return []
+    else:
+      actions = self._actions(config) if callable(self._actions) else self._actions
+      return [AddFeature(self._getName(config))] + actions
+
+  def pretty(self, config):
+    """
+    Returns the Feature's name.
+    """
+    return self._getName(config)
 
 
 def _str_to_bool(s):
   """
   Convert a string value to a boolean.
 
   True values are "y", "yes", "t", "true", "on" and "1", regardless of capitalization.
   False values are "n", "no", "f", "false", "off" and "0", regardless of capitalization.
class Parameter(object):
   Lit configuration files. This method will set the parameter globally for
   all test suites being run.
 
   The second method is to set `config.KEY = VALUE` somewhere in the Lit
   configuration files, which sets the parameter only for the test suite(s)
   that use that `config` object.
 
   Parameters can have multiple possible values, and they can have a default
-  value when left unspecified. They can also have a Feature associated to them,
-  in which case the Feature is added to the TestingConfig if the parameter is
-  enabled. It is an error if the Parameter is enabled but the Feature associated
-  to it is not supported, for example trying to set the compilation standard to
-  C++17 when `-std=c++17` is not supported by the compiler.
+  value when left unspecified. They can also have any number of ConfigActions
+  associated to them, in which case the actions will be performed on the
+  TestingConfig if the parameter is enabled. Depending on the actions
+  associated to a Parameter, it may be an error to enable the Parameter
+  if some actions are not supported in the given configuration. For example,
+  trying to set the compilation standard to C++23 when `-std=c++23` is not
+  supported by the compiler would be an error.
 
   One important point is that Parameters customize the behavior of the test
   suite in a bounded way, i.e. there should be a finite set of possible choices
   for `<VALUE>`. While this may appear to be an aggressive restriction, this
   is actually a very important constraint that ensures that the set of
   configurations supported by a test suite is finite. Otherwise, a test
   suite could have an unbounded number of supported configurations, and
   nobody wants to be stuck maintaining that. If it's not possible for an
   option to have a finite set of possible values (e.g. the path to the
   compiler), it can be handled in the `lit.cfg`, but it shouldn't be
   represented with a Parameter.
   """
-  def __init__(self, name, choices, type, help, feature, default=None):
+  def __init__(self, name, choices, type, help, actions, default=None):
     """
     Create a Lit parameter to customize the behavior of a test suite.
 
     - name
         The name of the parameter that can be used to set it on the command-line.
         On the command-line, the parameter can be set using `--param <name>=<value>`
         when running Lit. This must be non-empty.
 
     - choices
         A non-empty set of possible values for this parameter. This must be
         anything that can be iterated. It is an error if the parameter is
         given a value that is not in that set, whether explicitly or through
         a default value.
 
     - type
         A callable that can be used to parse the value of the parameter given
         on the command-line. As a special case, using the type `bool` also
         allows parsing strings with boolean-like contents.
 
     - help
         A string explaining the parameter, for documentation purposes.
         TODO: We should be able to surface those from the Lit command-line.
 
-    - feature
+    - actions
         A callable that gets passed the parsed value of the parameter (either
         the one passed on the command-line or the default one), and that returns
-        either None or a Feature.
+        a list of ConfigAction to perform given the value of the parameter.
+        All the ConfigAction must be supported in the given configuration.
 
     - default
         An optional default value to use for the parameter when no value is
         provided on the command-line. If the default value is a callable, it
         is called with the TestingConfig and should return the default value
         for the parameter. Whether the default value is computed or specified
         directly, it must be in the 'choices' provided for that Parameter.
     """
     self._name = name
     if len(self._name) == 0:
       raise ValueError("Parameter name must not be the empty string")
 
     self._choices = list(choices) # should be finite
     if len(self._choices) == 0:
       raise ValueError("Parameter '{}' must be given at least one possible value".format(self._name))
 
     self._parse = lambda x: (_str_to_bool(x) if type is bool and isinstance(x, str)
                                              else type(x))
     self._help = help
-    self._feature = feature
+    self._actions = actions
     self._default = default
 
-  @property
-  def name(self):
+  def _getValue(self, config, litParams):
     """
-    Return the name of the parameter.
-
-    This is the name that can be used to set the parameter on the command-line
-    when running Lit.
+    Return the value of the parameter given the configuration objects.
     """
-    return self._name
-
-  def getFeature(self, config, litParams):
     param = getattr(config, self.name, None)
     param = litParams.get(self.name, param)
     if param is None and self._default is None:
       raise ValueError("Parameter {} doesn't have a default value, but it was not specified in the Lit parameters or in the Lit config".format(self.name))
     getDefault = lambda: self._default(config) if callable(self._default) else self._default
     value = self._parse(param) if param is not None else getDefault()
     if value not in self._choices:
       raise ValueError("Got value '{}' for parameter '{}', which is not in the provided set of possible choices: {}".format(value, self.name, self._choices))
-    return self._feature(value)
+    return value
+
+  @property
+  def name(self):
+    """
+    Return the name of the parameter.
+
+    This is the name that can be used to set the parameter on the command-line
+    when running Lit.
+    """
+    return self._name
+
+  def getActions(self, config, litParams):
+    """
+    Return the list of actions associated to this value of the parameter.
+    """
+    return self._actions(self._getValue(config, litParams))
+
+  def pretty(self, config, litParams):
+    """
+    Return a pretty representation of the parameter's name and value.
+    """
+    return "{}={}".format(self.name, self._getValue(config, litParams))

libcxx/utils/libcxx/test/features.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 *
 import sys
 
 _isClang      = lambda cfg: '__clang__' in compilerMacros(cfg) and '__apple_build_version__' not in compilerMacros(cfg)
 _isAppleClang = lambda cfg: '__apple_build_version__' in compilerMacros(cfg)
 _isGCC        = lambda cfg: '__GNUC__' in compilerMacros(cfg) and '__clang__' not in compilerMacros(cfg)
 
 DEFAULT_FEATURES = [
-  Feature(name='fcoroutines-ts', compileFlag='-fcoroutines-ts',
+  Feature(name='fcoroutines-ts',
           when=lambda cfg: hasCompileFlag(cfg, '-fcoroutines-ts') and
-                           featureTestMacros(cfg, flags='-fcoroutines-ts').get('__cpp_coroutines', 0) >= 201703),
+                           featureTestMacros(cfg, flags='-fcoroutines-ts').get('__cpp_coroutines', 0) >= 201703,
+          actions=[AddCompileFlag('-fcoroutines-ts')]),
+
+  Feature(name='thread-safety',
+          when=lambda cfg: hasCompileFlag(cfg, '-Werror=thread-safety'),
+          actions=[AddCompileFlag('-Werror=thread-safety')]),
+
+  Feature(name='diagnose-if-support',
+          when=lambda cfg: hasCompileFlag(cfg, '-Wuser-defined-warnings'),
+          actions=[AddCompileFlag('-Wuser-defined-warnings')]),
 
-  Feature(name='thread-safety',                 when=lambda cfg: hasCompileFlag(cfg, '-Werror=thread-safety'), compileFlag='-Werror=thread-safety'),
   Feature(name='has-fblocks',                   when=lambda cfg: hasCompileFlag(cfg, '-fblocks')),
   Feature(name='-fsized-deallocation',          when=lambda cfg: hasCompileFlag(cfg, '-fsized-deallocation')),
   Feature(name='-faligned-allocation',          when=lambda cfg: hasCompileFlag(cfg, '-faligned-allocation')),
   Feature(name='fdelayed-template-parsing',     when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')),
   Feature(name='libcpp-no-if-constexpr',        when=lambda cfg: '__cpp_if_constexpr' not in featureTestMacros(cfg)),
   Feature(name='libcpp-no-structured-bindings', when=lambda cfg: '__cpp_structured_bindings' not in featureTestMacros(cfg)),
   Feature(name='libcpp-no-deduction-guides',    when=lambda cfg: featureTestMacros(cfg).get('__cpp_deduction_guides', 0) < 201611),
   Feature(name='libcpp-no-concepts',            when=lambda cfg: featureTestMacros(cfg).get('__cpp_concepts', 0) < 201811),
   Feature(name='has-fobjc-arc',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and
                                                                  sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms.
   Feature(name='objective-c++',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')),
-  Feature(name='diagnose-if-support',           when=lambda cfg: hasCompileFlag(cfg, '-Wuser-defined-warnings'), compileFlag='-Wuser-defined-warnings'),
   Feature(name='modules-support',               when=lambda cfg: hasCompileFlag(cfg, '-fmodules')),
   Feature(name='non-lockfree-atomics',          when=lambda cfg: sourceBuilds(cfg, """
                                                                   #include <atomic>
                                                                   struct Large { int storage[100]; };
                                                                   std::atomic<Large> x;
                                                                   int main(int, char**) { return x.load(), x.is_lock_free(); }
                                                                 """)),
 
DEFAULT_FEATURES += [
     Feature(name=lambda cfg, m=macro, f=feature: f + (
               '={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''
             ),
             when=lambda cfg, m=macro: m in compilerMacros(cfg),
 
             # FIXME: This is a hack that should be fixed using module maps.
             # If modules are enabled then we have to lift all of the definitions
             # in <__config_site> onto the command line.
-            compileFlag=lambda cfg, m=macro: '-Wno-macro-redefined -D{}'.format(m) + (
+            actions=lambda cfg, m=macro: [
+              AddCompileFlag('-Wno-macro-redefined -D{}'.format(m) + (
                 '={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''
-            )
+              ))
+            ]
     )
   ]
 
 
 # Mapping from canonical locale names (used in the tests) to possible locale
 # names on various systems. Each locale is considered supported if any of the
 # alternative names is supported.
 locales = {

libcxx/utils/libcxx/test/newconfig.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
 #
 #===----------------------------------------------------------------------===##
 
 def _getSubstitution(substitution, config):
   for (orig, replacement) in config.substitutions:
     if orig == substitution:
       return replacement
   raise ValueError('Substitution {} is not in the config.'.format(substitution))
 
 def configure(parameters, features, config, lit_config):
-  # Apply parameters to the configuration first, since parameters are things
-  # that we request explicitly and which might influence what features are
-  # implicitly made available next.
+  # Apply the actions supplied by parameters to the configuration first, since
+  # parameters are things that we request explicitly and which might influence
+  # what features are implicitly made available next.
   for param in parameters:
-    feature = param.getFeature(config, lit_config.params)
-    if feature:
-      feature.enableIn(config)
-      lit_config.note("Enabling Lit feature '{}' as a result of parameter '{}'".format(feature.getName(config), param.name))
+    actions = param.getActions(config, lit_config.params)
+    for action in actions:
+      action.applyTo(config)
+      lit_config.note("Applied '{}' as a result of parameter '{}'".format(
+        action.pretty(config, lit_config.params),
+        param.pretty(config, lit_config.params)))
 
   # Then, apply the automatically-detected features.
-  printFeatures = []
   for feature in features:
-    if feature.isSupported(config):
-      feature.enableIn(config)
-      printFeatures.append(feature.getName(config))
-  printFeatures = ["'{}'".format(f) for f in sorted(printFeatures)]
-  lit_config.note("Enabling implicitly detected Lit features {}".format(', '.join(printFeatures)))
+    actions = feature.getActions(config)
+    for action in actions:
+      action.applyTo(config)
+      lit_config.note("Applied '{}' as a result of implicitly detected feature '{}'".format(
+        action.pretty(config, lit_config.params),
+        feature.pretty(config)))
 
   # Print the basic substitutions
   for sub in ('%{cxx}', '%{flags}', '%{compile_flags}', '%{link_flags}', '%{exec}'):
     lit_config.note("Using {} substitution: '{}'".format(sub, _getSubstitution(sub, config)))

libcxx/utils/libcxx/test/params.py

 
 _allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++2a']
 
 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)),
-            feature=lambda std:
-              Feature(name=std, compileFlag='-std={}'.format(std),
-                      when=lambda cfg: hasCompileFlag(cfg, '-std={}'.format(std)))),
+            actions=lambda std: [
+              AddFeature(std),
+              AddCompileFlag('-std={}'.format(std)),
+            ]),
 
   Parameter(name='enable_exceptions', choices=[True, False], type=bool, default=True,
             help="Whether to enable exceptions when compiling the test suite.",
-            feature=lambda exceptions: None if exceptions else
-              Feature(name='no-exceptions', compileFlag='-fno-exceptions')),
+            actions=lambda exceptions: [] if exceptions else [
+              AddFeature('no-exceptions'),
+              AddCompileFlag('-fno-exceptions')
+            ]),
 
   Parameter(name='enable_rtti', choices=[True, False], type=bool, default=True,
             help="Whether to enable RTTI when compiling the test suite.",
-            feature=lambda rtti: None if rtti else
-              Feature(name='no-rtti', compileFlag='-fno-rtti')),
+            actions=lambda rtti: [] if rtti else [
+              AddFeature('no-rtti'),
+              AddCompileFlag('-fno-rtti')
+            ]),
 
   Parameter(name='stdlib', choices=['libc++', 'libstdc++', 'msvc'], type=str, default='libc++',
             help="The C++ Standard Library implementation being tested.",
-            feature=lambda stdlib: Feature(name=stdlib)),
+            actions=lambda stdlib: [
+              AddFeature(stdlib)
+            ]),
 
   # 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.",
-            feature=lambda filesystem: None if filesystem else
-              Feature(name='c++filesystem-disabled')),
+            actions=lambda filesystem: [] if filesystem else [
+              AddFeature('c++filesystem-disabled')
+            ]),
 
   Parameter(name='enable_experimental', choices=[True, False], type=bool, default=False,
             help="Whether to enable tests for experimental C++ libraries (typically Library Fundamentals TSes).",
-          feature=lambda experimental: None if not experimental else
-            Feature(name='c++experimental', linkFlag='-lc++experimental')),
+            actions=lambda experimental: [] if not experimental else [
+              AddFeature('c++experimental'),
+              AddLinkFlag('-lc++experimental')
+            ]),
 
   Parameter(name='long_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that take longer to run. This can be useful when running on a very slow device.",
-            feature=lambda enabled: Feature(name='long_tests') if enabled else None),
+            actions=lambda enabled: [] if not enabled else [
+              AddFeature('long_tests')
+            ]),
 
   Parameter(name='enable_debug_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that exercise the libc++ debugging mode.",
-            feature=lambda enabled: None if enabled else Feature(name='libcxx-no-debug-mode')),
+            actions=lambda enabled: [] if enabled else [
+              AddFeature('libcxx-no-debug-mode')
+            ]),
 ]