var mset methodSet

		for _, e := range current {
			typ := e.typ

			// If we have a named type, we may have associated methods.
			// Look for those first.
			if named := asNamed(typ); named != nil {
				if alt := seen.lookup(named); alt != nil {
					// We have seen this type before, at a more shallow depth
					// (note that multiples of this type at the current depth

        when:
        def fred = container.named("fred", Person)
        def bob = container.named("bob", AgeAwarePerson) {
            it.age = 50
        }
        then:
        fred.present
        fred.get().name == "fred"
        bob.present
        bob.get().age == 50

        when:
        container.named("bob") {
            it.age = 100
        }
        then:

        registry
            .mutate(NativeToolChainRegistry) { it.add toolChain("tc") }
            .mutate(PlatformContainer) { it.add named(NativePlatformInternal, "platform") }
            .mutate(BuildTypeContainer) { it.add named(BuildType, "bt") }
            .mutate(FlavorContainer) { it.add named(Flavor, "flavor1") }

        then:
        single(toolChains).name == 'tc'
        platforms.size() == 1

    @Inject
    IvyVariantDerivationRule(ObjectFactory objectFactory) {
        jarLibraryElements = objectFactory.named(LibraryElements, LibraryElements.JAR)
        libraryCategory = objectFactory.named(Category, Category.LIBRARY)
        javaRuntimeUsage = objectFactory.named(Usage, Usage.JAVA_RUNTIME)
        javaApiUsage = objectFactory.named(Usage, Usage.JAVA_API)
    }

    void execute(ComponentMetadataContext context) {

    private val javaApiUsage: Usage

    init {
        jarLibraryElements = objectFactory.named(LibraryElements.JAR)
        libraryCategory = objectFactory.named(Category.LIBRARY)
        javaRuntimeUsage = objectFactory.named(Usage.JAVA_RUNTIME)
        javaApiUsage = objectFactory.named(Usage.JAVA_API)
    }

    override fun execute(context: ComponentMetadataContext) {

    }


    @Managed
    static abstract class NonNamedThing {
        abstract String getName()

        abstract void setName(String name)
    }

    def "named struct does not have name populated if does not implement named"() {
        when:
        registry.registerWithInitializer("foo", NonNamedThing, nodeInitializerRegistry)

        then:
        registry.realize("foo", NonNamedThing).name == null
    }

            attribute(myAttribute, 'my-value')
        }
    }
}
// end::attributes-on-configurations[]

// tag::named-attributes[]
configurations {
    myConfiguration {
        attributes {
            attribute(myUsage, project.objects.named(Usage, 'my-value'))
        }
    }
}

    isCanBeConsumed = false
    attributes {
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_API))
        attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.CLASSES))
    }
}
notForAccessorGeneration {
    dependencies {

    }

    def "toString() declared in super-class takes precedence over Named"() {
        def value = new NamedExtendingHasToString(name: "name", superToString: "super-to-string")

        expect:
        RendererUtils.displayValueOf(value) == "super-to-string"
    }

    static class SimpleNamed implements Named {
        String name
    }

    static class NamedWithToString extends SimpleNamed {

            onNamedWithAction("alice", DomainObjectBase.Foo::class, aliceProvider)
            on { named(eq("bob"), eq(DomainObjectBase.Bar::class.java)) } doReturn bobProvider
            on { named(eq("jim")) } doReturn defaultProvider
            on { named(eq("steve")) } doReturn defaultProvider
        }

        container {
            val a = "alice"(DomainObjectBase.Foo::class) {