registry.realize("parent")

        expect:
        registry.atStateOrLater("parent", ModelNode.State.Registered).path == ModelPath.path("parent")
        registry.atStateOrLater("parent.foo", ModelNode.State.Registered).path == ModelPath.path("parent.foo")

        registry.remove(ModelPath.path("parent"))

        when:
        registry.atStateOrLater("parent", ModelNode.State.Registered) == null
        then:

            return description;
        }

        public String getPath() {
            return path;
        }
    }

    public AmbiguousBindingReporter(ModelReference<?> reference, ModelPath path1, ModelRuleDescriptor creator1, ModelPath path2, ModelRuleDescriptor creator2) {
        this(reference.getType().toString(), reference.getDescription(), ImmutableList.of(
                new Provider(String.valueOf(path1), String.valueOf(creator1)),

        }

        void inputReference(Class type, ModelNode.State state) {
            inputReference(ModelReference.of(null, ModelType.of(type), state).inScope(ModelPath.ROOT))
        }

        void inputReference(String path, ModelNode.State state) {
            inputReference(ModelReference.of(ModelPath.path(path), ModelType.untyped(), state))
        }

        buildFile """
            import org.gradle.model.internal.core.ModelPath

            pluginManager.withPlugin("my") {
              assert tasks."imperative-sentinel"
              // note: modelRegistry property is internal on project
              assert modelRegistry.node(ModelPath.path("thing")) != null
            }

            pluginManager.apply(MyPlugin)
        """

        super(message);
    }

    public ReadOnlyModelViewException(ModelPath path, ModelType<?> type, ModelRuleDescriptor ruleDescriptor) {
        super(createMessage("read only", path, type, ruleDescriptor));
    }

    protected static String createMessage(String viewType, ModelPath path, ModelType<?> type, ModelRuleDescriptor ruleDescriptor) {
        StringBuilder result = new StringBuilder();

public class WriteOnlyModelViewException extends GradleException {

    public WriteOnlyModelViewException(String property, ModelPath path, ModelType<?> type, ModelRuleDescriptor ruleDescriptor) {
        super(createMessage(property, path, type, ruleDescriptor));
    }

    private static String createMessage(String property, ModelPath path, ModelType<?> type, ModelRuleDescriptor ruleDescriptor) {
        StringBuilder result = new StringBuilder();

    }

    @Nullable
    @Override
    public ModelPath getPath() {
        return reference.getPath();
    }

    public ModelType<?> getType() {
        return reference.getType();
    }

    public boolean matches(MutableModelNode node) {
        return reference.isUntyped() || node.canBeViewedAs(reference.getType());
    }

    @Nullable
    public ModelPath getScope() {
        return reference.getScope();
    }

            @Override
            public boolean isSatisfiedBy(Annotation element) {
                return element.annotationType().equals(Path.class);
            }
        });
        ModelPath path = pathAnnotation == null ? null : ModelPath.path(pathAnnotation.value());
        ModelType<?> cast = method.getGenericParameterTypes().get(i);
        return ModelReference.of(path, cast, PARAMETER_DESC[i]);
    }

 * limitations under the License.
 */

package org.gradle.model.internal.inspect;

import org.gradle.model.internal.core.ModelAction;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.registry.ModelRegistry;

public interface MethodModelRuleApplicationContext {
    ModelRegistry getRegistry();

    /**
     * Contextualizes the given action.
     *

    protected final ModelPath path;
    protected final ModelType<E> elementType;
    protected final ModelType<C> type;
    protected final MutableModelNode modelNode;
    protected final boolean overwritable;
    protected final DefaultModelViewState state;