class ScalarCollectionIntegrationTest extends AbstractIntegrationSpec {
    def "can create instance of #{type.name}"() {
        given:
        buildFile << """
class Rules extends RuleSource {
    @Model
    void strings(${type.name}<String> s) {
    }

    @Mutate
    void tasks(ModelMap<Task> tasks, @Path("strings") def strings) {
        tasks.create("show") {
            doLast {

        ]
    }

    def "dollar method is only detected with no explicit receiver - #code"() {
        when:
        buildScript """
            class MyPlugin {
              static class Rules extends RuleSource {
                @Model
                String foo() {
                  "foo"
                }
              }
            }

            apply type: MyPlugin

            model {

import java.lang.annotation.Target;

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation finalizes the rule subject.
 * <p>
 * Finalize rules execute after {@link Mutate} rules, but before {@link Validate} rules.
 * The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.
 * <p>
 * Please see {@link RuleSource} for more information on method rules.
 */

    def "configuration cycle error contains information useful for troubleshooting"() {
        when:
        buildScript '''
            class Rules extends RuleSource {
                @Model
                String first(@Path("second") String second) {
                    "foo"
                }

                @Model
                String second() {

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation initializes the rule subject with default values.
 * <p>

import org.gradle.api.Incubating;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.model.Defaults;
import org.gradle.model.ModelMap;
import org.gradle.model.RuleSource;
import org.gradle.nativeplatform.NativeComponentSpec;
import org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec;
import org.gradle.nativeplatform.test.internal.NativeTestSuites;

    }

    @Override
    public void named(String name, Class<? extends RuleSource> ruleSource) {
        viewState.assertCanMutate();
        ModelRuleDescriptor descriptor = sourceDescriptor.append("named(%s, %s)", name, ruleSource.getName());
        ModelReference<T> subject = ModelReference.of(modelNode.getPath().child(name), elementType);

            }

            @Managed
            interface Family {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void somePlatform(Platform platform) {
                    assert platform.displayName == null
                    assert platform.operatingSystem != null

import org.gradle.internal.service.ServiceRegistry;
import org.gradle.language.base.plugins.LifecycleBasePlugin;
import org.gradle.model.Model;
import org.gradle.model.Mutate;
import org.gradle.model.RuleSource;
import org.gradle.model.Validate;
import org.gradle.model.internal.core.Hidden;
import org.gradle.model.internal.core.NamedEntityInstantiator;
import org.gradle.model.internal.core.NodeInitializerRegistry;

    }

    @Override
    public void put(String name, T instance) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void named(String name, Class<? extends RuleSource> ruleSource) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void all(Action<? super T> configAction) {
        collection.all(configAction);
    }

    @Override