return DynamicInvokeResult.notFound();
            }

            // Fall back to propertyMissing, if available
            MetaMethod propertyMissing = findGetPropertyMissingMethod(metaClass);
            if (propertyMissing != null) {
                try {
                    return DynamicInvokeResult.found(propertyMissing.invoke(bean, new Object[]{name}));
                } catch (MissingPropertyException e) {

 *
 * Note that when a type implements this interface, dynamic Groovy dispatch will not be used to discover opaque properties. That is, methods such as propertyMissing() will be ignored.
 */
public interface PropertyMixIn {
    PropertyAccess getAdditionalProperties();

        }
        addSignatory(project, name);
    }

    @SuppressWarnings("unused") // invoked by Groovy
    public GnupgSignatory propertyMissing(String signatoryName) {
        return getSignatory(signatoryName);
    }

        }
        addSignatory(name, keyId, secretKey, password);
    }

    @SuppressWarnings("unused") // invoked by Groovy
    public PgpSignatory propertyMissing(String signatoryName) {
        return getSignatory(signatoryName);
    }

                throw new IllegalArgumentException("Invalid args (" + name + ": " + Arrays.toString(args) + ")");
        }
    }

    @SuppressWarnings("unused") // invoked by Groovy
    public PgpSignatory propertyMissing(String signatoryName) {
        return getSignatory(signatoryName);
    }

    ConfigurationsBuilder(Set<String> alreadyCreated) {
        this.alreadyCreated = alreadyCreated
    }

    @Override
    String getSectionName() {
        "configurations"
    }

    Object propertyMissing(String name) {
        sections << new ConfigurationCreation(new GenericSection({ name }, {
            if (alreadyCreated.add(name)) {
                "val $name by configurations.creating"
            } else {

    }

    public void propertyMissing(String property, Object newValue) {
        doSetProperty(property, newValue);
    }

    @SuppressWarnings("deprecation")
    private void doSetProperty(String property, Object newValue) {
        PropertyHelper.getPropertyHelper(getProject()).setUserProperty(null, property, newValue);
    }

    public Object propertyMissing(String name) {

    Operations(InstantFactory instantFactory, OperationListener listener) {
        this.listener = listener
        this.instantFactory = instantFactory
    }

    public def propertyMissing(String name) {
        synchronized (lock) {
            if (!operations.containsKey(name)) {
                throw new IllegalStateException("Operation '$name' has not been defined by any test thread.")
            }

@SuppressWarnings({"deprecation", "FieldNamingConvention"})
public class ConventionAwareHelper implements ConventionMapping, org.gradle.api.internal.HasConvention {
    //prefix internal fields with _ so that they don't get into the way of propertyMissing()
    private final org.gradle.api.plugins.Convention _convention;
    private final IConventionAware _source;
    // These are properties that could have convention mapping applied to them

        return value
    }

    def getOwnerProp() {
        return 'ownerProp'
    }

    def propertyMissing(String name) {
        if (name == 'dynamicProp') {
            return values[name]
        }
        throw new MissingPropertyException("fail")
    }

    def propertyMissing(String name, Object value) {
        if (name == 'dynamicProp') {
            values[name] = value
            return