interpreter: add feature.allowed()

This method simplifies the conversion of Feature objects to booleans.
Often, one has to use the "not" operator in order to treat "auto"
and "enabled" the same way.

"allowed()" also works well in conjunction with the require method that
is introduced in the next patch.  For example,

  if get_option('foo').require(host_machine.system() == 'windows').allowed() then
    src += ['foo.c']
    config.set10('HAVE_FOO', 1)
  endif

can be used instead of

  if host_machine.system() != 'windows'
    if get_option('foo').enabled()
      error('...')
    endif
  endif
  if not get_option('foo').disabled() then
    src += ['foo.c']
    config.set10('HAVE_FOO', 1)
  endif

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

docs/markdown/Reference-manual.md

@@ -2818,6 +2818,7 @@ The following methods are defined for all [`feature` options](Build-options.md#f
 - `enabled()`: returns whether the feature was set to `'enabled'`
 - `disabled()`: returns whether the feature was set to `'disabled'`
 - `auto()`: returns whether the feature was set to `'auto'`
+- `allowed()` *(since 0.59.0)*: returns whether the feature was set to `'enabled'` or `'auto'`
 
 ### `generator` object
 

mesonbuild/interpreter/interpreterobjects.py

@@ -72,6 +72,7 @@ class FeatureOptionHolder(InterpreterObject, ObjectHolder[coredata.UserFeatureOp
         self.name = name
         self.methods.update({'enabled': self.enabled_method,
                              'disabled': self.disabled_method,
+                             'allowed': self.allowed_method,
                              'auto': self.auto_method,
                              })
 
@@ -85,6 +86,11 @@ class FeatureOptionHolder(InterpreterObject, ObjectHolder[coredata.UserFeatureOp
     def disabled_method(self, args, kwargs):
         return self.held_object.is_disabled()
 
+    @noPosargs
+    @permittedKwargs({})
+    def allowed_method(self, args, kwargs):
+        return not self.held_object.is_disabled()
+
     @noPosargs
     @permittedKwargs({})
     def auto_method(self, args, kwargs):

test cases/common/192 feature option/meson.build

@@ -8,18 +8,22 @@ disabled_opt = get_option('disabled')
 assert(not feature_opts.enabled(), 'Should be auto option')
 assert(not feature_opts.disabled(), 'Should be auto option')
 assert(feature_opts.auto(), 'Should be auto option')
+assert(feature_opts.allowed(), 'Should be auto option')
 
 assert(required_opt.enabled(), 'Should be enabled option')
 assert(not required_opt.disabled(), 'Should be enabled option')
 assert(not required_opt.auto(), 'Should be enabled option')
+assert(required_opt.allowed(), 'Should be enabled option')
 
 assert(not optional_opt.enabled(), 'Should be auto option')
 assert(not optional_opt.disabled(), 'Should be auto option')
 assert(optional_opt.auto(), 'Should be auto option')
+assert(optional_opt.allowed(), 'Should be auto option')
 
 assert(not disabled_opt.enabled(), 'Should be disabled option')
 assert(disabled_opt.disabled(), 'Should be disabled option')
 assert(not disabled_opt.auto(), 'Should be disabled option')
+assert(not disabled_opt.allowed(), 'Should be disabled option')
 
 dep = dependency('threads', required : required_opt)
 assert(dep.found(), 'Should find required "threads" dep')