initializer.execute(t, ModelViews.assertType(modelViews.get(0), input.getType()).getInstance());
            }
        });
    }

    @Override
    protected void execute(MutableModelNode modelNode, T view, List<ModelView<?>> inputs) {
        action.execute(view, inputs);
    }

        def barRegistration = ModelRegistrations.unmanagedInstance(barReference, factory).descriptor(descriptor).build()
        registry.register(barRegistration)
        def foo = registry.atStateOrLater(fooReference.path, ModelNode.State.Discovered)

        then:
        !foo.promise.canBeViewedAs(ModelType.of(String))
        foo.promise.canBeViewedAs(ModelType.of(List))

        registry.realize(fooReference.path, fooReference.type).is(fooList)

    interface ImplementationInfo {
        /**
         * Creates an instance of the delegate for the given node.
         */
        Object create(MutableModelNode modelNode);

        /**
         * The default implementation type that can be used as a delegate for any managed subtypes of the public type.
         */
        ModelType<?> getDelegateType();

        /**

        }

        @Override
        public Object create(MutableModelNode modelNode) {
            ImplementationFactory<PUBLIC, Object> implementationFactory = Cast.uncheckedNonnullCast(implementationRegistration.getFactory());
            return implementationFactory.create(publicType, implementationRegistration.getImplementationType(), modelNode.getPath().getName(), modelNode);
        }

        @Override

            .descriptor(new SimpleModelRuleDescriptor("<create $name>"))
        modelRegistry.register(registration.build())

        return modelRegistry.atState(name, ModelNode.State.Initialized)
    }

            }
        }
        apply plugin:BinaryTasksPlugin
'''

        when:
        run "model"

        then:
        def tasksNode = ModelReportOutput.from(output).modelNode.tasks
        tasksNode.sampleLibBinaryOneTask.@type[0] == 'org.gradle.api.DefaultTask'
    }

    def "can reference rule-added tasks in model"() {
        given:
        buildFile << '''

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.registry

import org.gradle.model.internal.core.ModelNode.State
import org.gradle.model.internal.core.ModelPath
import org.gradle.model.internal.core.MutableModelNode

class ModelGraphTest extends RegistrySpec {
    def graph = new ModelGraph(root())
    def nodes = [:]

            @Override
            public void execute(MutableModelNode modelNode, List<ModelView<?>> inputs) {
                WeaklyTypeReferencingMethod<Object, Object> method = Cast.uncheckedCast(methodRuleDefinition.getMethod());
                ModelRuleInvoker<Object> invoker = new DefaultModelRuleInvoker<Object, Object>(method, factory);
                action.execute(invoker, modelNode, inputs.subList(0, action.getInputs().size()));
            }

            }
        }
    }
}

"""

        when:
        succeeds "model"

        then:
        def modelReport = ModelReportOutput.from(output).modelNode
        assert modelReport.components.custom.valueForBinary.@nodeValue[0] == 'configured-value'
        assert modelReport.components.custom.binaries.myBinary.valueFromComponent.@nodeValue[0] == 'configured-value'
    }

Class <org.gradle.model.internal.core.ModelNode$State> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ModelNode.java:0)
Class <org.gradle.model.internal.core.ModelNode> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ModelNode.java:0)