* @param state the desired node state
     * @return the node at the desired state
     */
    ModelNode atStateOrLater(ModelPath path, ModelNode.State state);
    <T> T atStateOrLater(ModelPath path, ModelType<T> type, ModelNode.State state);

    ModelNode.State state(ModelPath path);

    void remove(ModelPath path);

    /**
     * Attempts to bind the references of all model rules known at this point in time.
     * <p>

            String modelPath = extractModelPathFromMethodTarget(call);
            rewriteCreator(call, modelPath, closureExpression, classArg, displayName);
            return;
        }

        restrict(call, INVALID_RULE_SIGNATURE);
    }

@ThreadSafe
public class DefaultModelRegistration implements ModelRegistration {
    private final ModelPath path;
    private final ModelRuleDescriptor descriptor;
    private final boolean hidden;
    private final Multimap<ModelActionRole, ? extends ModelAction> actions;

    public DefaultModelRegistration(ModelPath path, ModelRuleDescriptor descriptor,

    }

    public static <T> ModelView<T> of(ModelPath path, ModelType<T> type, T instance) {
        return of(path, type, instance, Actions.doNothing());
    }

    public static <T> ModelView<T> of(ModelPath path, ModelType<T> type, T instance, Action<? super T> onClose) {
        return new InstanceModelView<T>(path, type, instance, onClose);
    }

    @Override
    public ModelPath getPath() {
        return path;
    }

import static org.gradle.util.internal.TextUtil.normaliseLineSeparators

class UnboundRulesProcessorTest extends RegistrySpec {

    List<RuleBinder> binders = []

    Transformer<List<ModelPath>, ModelPath> suggestionProvider = Transformers.constant([])

    String getReportForProcessedBinders() {
        reportFor(new UnboundRulesProcessor(binders, suggestionProvider).process())
    }

    }

    @Nullable
    public static MutableModelNode node(DefaultModelRegistry modelRegistry, String path) {
        return modelRegistry.node(ModelPath.path(path));
    }

    public static <C> ModelRegistry registerInstance(ModelRegistry modelRegistry, String path, final C c) {
        return modelRegistry.register(unmanaged(registration(ModelPath.path(path)), c));
    }

package org.gradle.model.internal.registry

import org.gradle.model.internal.core.ModelPath
import spock.lang.Specification

class ModelPathSuggestionProviderTest extends Specification {

    List<String> availablePaths

    List<String> suggestionsFor(String path) {
        new ModelPathSuggestionProvider(availablePaths.collect { new ModelPath(it) }).transform(new ModelPath(path))*.toString()
    }

     */
    @Nullable
    public ModelPath getPath() {
        return null;
    }

    /**
     * Returns the parent path of the nodes to select, or null if parent is not relevant.
     *
     * <p>A node will be selected if its parent's path equals the specified path.
     */
    @Nullable
    public ModelPath getParent() {
        return null;
    }

    /**

package org.gradle.model.internal.registry;

import org.gradle.model.internal.core.ModelNode;
import org.gradle.model.internal.core.ModelPath;

class NodeAtState implements Comparable<NodeAtState> {
    public final ModelPath path;
    public final ModelNode.State state;

    public NodeAtState(ModelPath path, ModelNode.State state) {
        this.path = path;
        this.state = state;
    }

    @Override

        } else {
            String modelPath = argExpression.getText();
            if (modelPath.isEmpty()) {
                error(argExpression, INVALID_ARGUMENT_LIST);
                return;
            }

            try {
                ModelPath.validatePath(modelPath);
            } catch (ModelPath.InvalidPathException e) {