public ModelMapBasedRule(ModelReference<C> subject, final ModelType<? extends T> baseType, MethodRuleDefinition<?, ?> ruleDefinition, ModelReference<?>... additionalInputs) {
        super(subject, ruleDefinition.getDescriptor());
        this.inputs = calculateInputs(
                baseType,
                ruleDefinition.getReferences().subList(1, ruleDefinition.getReferences().size()),

class MethodsTest extends Specification  {

    interface BaseType {
        Object someMethodName(Object o)
    }

    interface ChildType extends BaseType {
        @Override String someMethodName(Object o)
        int someMethodName(int i)
    }

    def "distinguish overloaded overridden method signatures"() {
        def takeObjReturnObj = BaseType.declaredMethods[0]

}


fun IsolateContext.logUnsupported(
    action: String,
    baseType: KClass<*>,
    documentationSection: DocumentationSection = RequirementsDisallowedTypes,
    appendix: StructuredMessageBuilder = {}
) {
    logUnsupported(action, documentationSection, appendix) {
        text(" object of type ")
        reference(baseType)
    }
}


fun IsolateContext.logUnsupported(
    action: String,

    @Test
    fun `field of bean found in input property of task`() {

        val beanType = PropertyTraceTest::class.java
        val taskType = Task::class.java

        assertThat(
            PropertyTrace.Property(
                PropertyKind.Field,
                "f",
                PropertyTrace.Bean(
                    beanType,
                    PropertyTrace.Property(

    val beanType = value.javaClass
    withBeanTrace(beanType) {
        writeClass(beanType)
        beanStateWriterFor(beanType).run {
            writeStateOf(value)
        }
    }
}


suspend fun ReadContext.decodeBean(): Any {
    val beanType = readClass()
    return withBeanTrace(beanType) {
        beanStateReaderFor(beanType).run {
            newBean(false).also {

        given:
        settingsFile << """
            abstract class SomeBuildService implements $BuildService.name<${BuildServiceParameters.name}.None> {
            }

            class SomeBean {
                private ${baseType.name} badReference
            }

            def configureGradleLifecycle() {
                ${baseType.name} badReference

class BeanPropertyReader(
    private val beanType: Class<*>,
    private val constructors: BeanConstructors,
    instantiatorFactory: InstantiatorFactory
) : BeanStateReader {
    // TODO should use the same scheme as the original bean
    private
    val instantiationScheme: InstantiationScheme = instantiatorFactory.decorateScheme()

    private
    val relevantFields = relevantStateOf(beanType)

    private

		targs := make([]types.Type, len)
		for i := range targs {
			targs[i] = r.typ()
		}
		baseType := r.typ()
		// The imported instantiated type doesn't include any methods, so
		// we must always use the methods of the base (orig) type.
		// TODO provide a non-nil *Context
		t, _ := types.Instantiate(nil, baseType, targs, false)
		return t

	case unionType:
		if r.p.exportVersion < iexportVersionGenerics {

     * Returns the {@link TypeToken} of a parameter specified by index.
     *
     * @param beanType the TypeToken of the bean
     * @param parameterizedClass the parameterized class
     * @param typeParameterIndex the index of the parameter
     * @return a TypeToken
     */
    public static <T> TypeToken<?> extractNestedType(TypeToken<T> beanType, Class<? super T> parameterizedClass, int typeParameterIndex) {

@ServiceScope(Scope.BuildTree::class)
interface BeanStateWriterLookup {
    fun beanStateWriterFor(beanType: Class<*>): BeanStateWriter
}


@ServiceScope(Scope.BuildTree::class)
interface BeanStateReaderLookup {
    fun beanStateReaderFor(beanType: Class<*>): BeanStateReader
}


class DefaultWriteContext(

    codec: Codec<Any?>,

    private
    val encoder: Encoder,