*/
public interface ModelRuleDescriptor {
    /**
     * This method is expected to be idempotent.
     *
     * @param appendable where to write the description to.
     */
    void describeTo(Appendable appendable);

    ModelRuleDescriptor append(ModelRuleDescriptor child);

    ModelRuleDescriptor append(String child);

    @FormatMethod

        super(toMessage(descriptor, error));
    }

    private static String toMessage(ModelRuleDescriptor descriptor) {
        StringBuilder builder = new StringBuilder("Exception thrown while executing model rule: ");
        descriptor.describeTo(builder);
        return builder.toString();
    }

package org.gradle.model.internal.core;

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

import java.util.Arrays;
import java.util.List;

public class AddProjectionsAction<T> extends AbstractModelAction<T> {
    private final Iterable<ModelProjection> projections;

    private AddProjectionsAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, Iterable<ModelProjection> projections) {
        super(subject, descriptor);

import com.google.common.collect.Multimap;
import javax.annotation.concurrent.ThreadSafe;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

@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;

@ThreadSafe
abstract class AbstractModelRuleDescriptor implements ModelRuleDescriptor {

    protected final static StringInterner STRING_INTERNER = new StringInterner();

    @Override
    public ModelRuleDescriptor append(ModelRuleDescriptor child) {
        return new NestedModelRuleDescriptor(this, child);
    }

    @Override
    public ModelRuleDescriptor append(String child) {

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

import javax.annotation.Nullable;
import java.util.ArrayDeque;
import java.util.Deque;

public class RuleContext {

    private static final ThreadLocal<Deque<ModelRuleDescriptor>> STACK = ThreadLocal.withInitial(ArrayDeque::new);

    @Nullable
    public static ModelRuleDescriptor get() {
        return STACK.get().peek();
    }

import com.google.common.base.Optional;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;
import org.gradle.model.internal.type.ModelType;

import javax.annotation.Nullable;

public interface ModelAdapter {

    @Nullable
    <T> ModelView<? extends T> asImmutable(ModelType<T> type, MutableModelNode node, @Nullable ModelRuleDescriptor ruleDescriptor);

    @Nullable

        checkCanRegister(type, descriptor);
        delegate.registerFactory(type, factory);
    }

    private void checkCanRegister(Class<? extends T> type, ModelRuleDescriptor descriptor) {
        Optional<ModelRuleDescriptor> creator = creators.get(type);
        if (creator != null) {

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

import java.util.Collections;
import java.util.List;

public class DirectNodeNoInputsModelAction<T> extends AbstractModelActionWithView<T> {

    private final BiAction<? super MutableModelNode, ? super T> action;

import java.io.IOException;

@ThreadSafe
class NestedModelRuleDescriptor extends AbstractModelRuleDescriptor {

    private final ModelRuleDescriptor parent;
    private final ModelRuleDescriptor child;

    public NestedModelRuleDescriptor(ModelRuleDescriptor parent, ModelRuleDescriptor child) {
        this.parent = parent;
        this.child = child;
    }

    @Override
    public void describeTo(Appendable appendable) {