}

    @Override
    public Object invokeMethod(String name, Object args) {
        return dynamicLookupRoutine.invokeMethod(dynamicObject, name, (Object[]) args);
    }

    @Override
    public DynamicObject getAsDynamicObject() {
        return dynamicObject;
    }

    /**

        this.files = files;
    }

    @Override
    public Object addToAntBuilder(Object node, String childNodeName) {
        final DynamicObject dynamicObject = new BeanDynamicObject(node);
        dynamicObject.invokeMethod(childNodeName == null ? "resources" : childNodeName, new Closure(this) {
            public Object doCall(Object ignore) {
                for (Map.Entry<String, File> entry : files.entrySet()) {

package org.gradle.internal.metaobject;

import org.gradle.api.internal.DynamicObjectAware;

public abstract class DynamicObjectUtil {
    public static DynamicObject asDynamicObject(Object object) {
        if (object instanceof DynamicObject) {
            return (DynamicObject)object;
        } else if (object instanceof DynamicObjectAware) {
            return ((DynamicObjectAware) object).getAsDynamicObject();
        } else {

package org.gradle.api.internal;

import org.gradle.api.NonNullApi;
import org.gradle.internal.metaobject.DynamicObject;

/**
 * An object that can present a dynamic view of itself.
 *
 * The exposed dynamic object <i>may</i> provide functionality over and above what the type implementing
 * this interface can do. For example, the {@link DynamicObject} may provide the ability to register new

    }

    @Override
    public Object addToAntBuilder(final Object node, String nodeName) {
        final DynamicObject dynamicObject = new BeanDynamicObject(node);
        for (final DirectoryTree tree : trees) {
            if (!tree.getDir().exists()) {
                continue;
            }

    private DynamicObject dynamicObject;
    private ExtensionContainer extensionContainer;
    private ConventionMapping conventionMapping;
    private org.gradle.api.plugins.Convention convention;

    private final Object object;

    public DslObject(Object object) {
        this.object = object;
    }

    @Override
    public DynamicObject getAsDynamicObject() {

    }


private
fun dynamicObjectFor(target: Any): DynamicObject =
    (target as? DynamicObjectAware ?: DslObject(target)).asDynamicObject


private
class NullableDynamicPropertyDelegate(
    private val dynamicLookupRoutine: DynamicLookupRoutine,
    private val owner: DynamicObject,
    private val name: String
) : PropertyDelegate {

        dynamicObject.setProperty("prop", "value")
        dynamicObject.getProperty("prop") == "value"

        dynamicObject.hasProperty("other")
    }

    def "can get and set static property using class object"() {
        def dynamicObject = new BeanDynamicObject(WithStaticFields.class)

        expect:
        dynamicObject.hasProperty("prop")
        dynamicObject.setProperty("prop", "value")

            return delegate;
        }
        DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(delegate);

        for (Map.Entry<?, ?> entry : properties.entrySet()) {
            String name = entry.getKey().toString();
            Object value = entry.getValue();

            DynamicInvokeResult result = dynamicObject.trySetProperty(name, value);
            if (result.isFound()) {

        BeforeConvention, AfterConvention
    }

    private final AbstractDynamicObject dynamicDelegate;
    private DynamicObject parent;
    private final org.gradle.api.plugins.Convention convention;
    private DynamicObject beforeConvention;
    private DynamicObject afterConvention;
    private final DynamicObject extraPropertiesDynamicObject;