then:
        visitor.getNested("nested") == new CollectedNode(checkNotNull(typeMetadataStore.getTypeMetadata(NestedType.class)), "nested", "null")
        visitor.getNested("nestedObject") == new CollectedNode(checkNotNull(typeMetadataStore.getTypeMetadata(Object.class)), "nestedObject", "null")

    String getVeryDeepMessage()
}

interface ShallowChildModel extends BaseModel {
    String getShallowMessage()
}

interface SideModel extends BaseModel {
}

interface CompositeModel {
    BaseModel getNested()

        String output() { "output" }
    }

    static trait SimpleResult {
        String simpleResultMethod() { "simpleResultValue" }
    }

    static trait NestedResult {
        Nested getNested() { new Object().withTraits(Nested) }
    }

    static trait Nested {
        String getNestedValue() { "nestedValue" }

        String toString() { "Nested" }
    }

                private final DefaultModel nested
                DefaultCompositeModel(DefaultModel nested) { this.nested = nested }
                BaseModel getNested() { nested }
            }
        """
    }

    def "supports model polymorphism"() {
        given:
        file("plugins/src/main/groovy/my/MyModelBuilder.groovy") << """
            package my

        }

        given:
        buildFile << """
            interface NestedBean {
                @Input
                Property<URL> getNested()
            }

            abstract class TaskWithInput extends DefaultTask {

                private final NestedBean nested = project.objects.newInstance(NestedBean.class)

                @Input

                    @Input
                    ${type} getProp()
                    @Input @Optional
                    ${type} getOtherProp()
                    @Nested
                    NestedType getNested()
                }

                void transform(TransformOutputs outputs) {
                    println "processing using prop: \${parameters.prop.get()}, nested: \${parameters.nested.nestedProp.get()}"

        }

        given:
        buildFile << """
            interface NestedBean {
                $annotation
                Property<ResolvedArtifactResult> getNested()
            }

            abstract class TaskWithInput extends DefaultTask {

                private final NestedBean nested = project.objects.newInstance(NestedBean.class)

                $annotation

                @Input
                Property<String> getProp()
            }

            abstract class MyTask extends DefaultTask {
                @Nested
                abstract NestedType getNested()

                void nested(Action<NestedType> action) {
                    action.execute(nested)
                }

                @TaskAction
                void go() {

            abstract class TaskWithFailingNestedInput extends DefaultTask {
                @Inject
                abstract ProviderFactory getProviders()

                @Nested
                Object getNested() {
                    $propertyValue
                }

                @Input
                String input = "Hello"

                @OutputFile
                File outputFile

    }

    @Override
    public void report(CrossVersionPerformanceResults results) {
        if (!testIds.add(results.getTestId())) {
            throw new IllegalArgumentException(String.format("Multiple performance test executions with id '%s' found.", results.getTestId()));
        }
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.report(results);
        }