is DataClass -> valueType is DataClass && (sameType(valueType, isAssignableTo) || isAssignableTo.name in valueType.supertypes)
    else -> sameType(valueType, isAssignableTo)
}


/**
 * Can't check for equality: TAPI proxies are not equal to the original implementations.
 * TODO: maybe "reify" the TAPI proxies to ensure equality?
 */
private
fun sameType(left: DataType, right: DataType) = when (left) {

					return fallbackSetter(ctx, value, v, field.Set)
				}
			}
		}
	}

	if field.Serializer != nil {
		var (
			oldFieldSetter = field.Set
			sameElemType   bool
			sameType       = field.FieldType == reflect.ValueOf(field.Serializer).Type()
		)

		if reflect.ValueOf(field.Serializer).Kind() == reflect.Ptr {
			sameElemType = field.FieldType == reflect.ValueOf(field.Serializer).Type().Elem()

    def "generates a node backed view class for an interface"() {
        expect:
        def impl = newNodeBackedInstance(SomeType)
        impl instanceof SomeType
    }

    def "generates a view class for an interface"() {
        expect:
        def impl = newSimpleInstance(SomeType)
        impl instanceof SomeType
    }

    def "generates a view class for an interface with type parameters"() {
        when:

            SomeType create(String name) {
                return new SomeType(name: name)
            }
        })
        def modelMap = new DomainObjectCollectionBackedModelMap("thing", SomeType, backingCollection, instantiator, Named.Namer.INSTANCE, Actions.doNothing())

        when:
        modelMap.create("alma", List)

        then:
        def e = thrown InvalidUserDataException

        expect:
        def result = instantiator.newInstance(SomeType, param)
        result instanceof SomeType
        result.result == param
    }

    def "creates instance with subtypes of constructor parameters"() {
        expect:
        def result = instantiator.newInstance(SomeType, "param")
        result instanceof SomeType
        result.result == "param"
    }

        SpecializedType2.isAssignableFrom(impl2)
    }

    SomeType newInstance(Class<? extends SomeType> implType, Class<? extends SomeType> publicType, SomeType target) {
        def generated = generate(implType, publicType)
        return generated.newInstance(target)
    }

    Class<? extends SomeType> generate(Class<? extends SomeType> implType, Class<? extends SomeType> publicType) {
        def generated = classes[publicType]

	for name, pmap := range envoyFilterStatusMap {
		for pt, applied := range pmap {
			if applied {
				envoyFilterStatus.With(nameType.Value(name)).With(patchType.Value(pt)).
					With(resultType.Value(string(Applied))).Record(1)
			} else {
				envoyFilterStatus.With(nameType.Value(name)).With(patchType.Value(pt)).
					With(resultType.Value(string(Applied))).Record(0)
			}
		}
	}

    final TypeMetaData type = new TypeMetaData('org.gradle.SomeType')

    def rawTypeForSimpleType() {
        expect:
        type.rawType.signature == 'org.gradle.SomeType'
    }

    def rawTypeForArrayType() {
        type.arrayDimensions = 2

        expect:
        type.rawType.signature == 'org.gradle.SomeType[][]'
    }

    def rawTypeForVarargsType() {
        when:

    @Test
    fun `can extract JavaFunction from single parameter signature string`() {
        assertThat(
            javaFunctionOf("org.gradle.SomeType.methodMan(java.lang.String)"),
            equalTo(
                JavaFunction(
                    "org.gradle.SomeType",
                    "methodMan",
                    listOf("java.lang.String"),
                    false
                )
            )
        )

        where:
        publicType                | displayName
        SomeTypeLanguageSourceSet | "SomeType source 'test'"
        SomeTypeSourceSet         | "SomeType source 'test'"
        SomeTypeSource            | "SomeType source 'test'"
        SomeTypeSet               | "SomeType source 'test'"
        SomeType                  | "SomeType source 'test'"
        SomeResourcesSet          | "SomeResources 'test'"
    }