.collect(Collectors.toList());

        return builder -> builder
            .addAnnotation(GENERATED_ANNOTATION.asClassName())
            .addModifiers(Modifier.PUBLIC)
            .addMethods(methods);
    }

    private static MethodSpec mapToMethodSpec(CallInterceptionRequest request, Consumer<? super CallInterceptionRequest> onProcessedRequest, Consumer<? super HasFailures.FailureInfo> onFailure) {

        addMethod(ACC_PUBLIC, name, descriptor, signature, body);
    }

    /**
     * Adds a method to the generated type.
     */
    protected void addMethod(int access, String name, String descriptor, BytecodeFragment body) {
        addMethod(access, name, descriptor, null, body);
    }

    /**
     * Adds a method to the generated type.

        ClassMetaData classMetaData = new ClassMetaData("org.gradle.$SIMPLE_CLASSNAME")
        classMetaData.addMethod(METHOD_NAME, TypeMetaData.VOID, null)
        classMetaData.addMethod(METHOD_NAME, TypeMetaData.VOID, null).addParameter('param1', new TypeMetaData("java.lang.Integer"))
        def overloadedCalculateMethod = classMetaData.addMethod('calculate', TypeMetaData.VOID, null)

            .addParameter(boolean.class, "isStatic")
            .addCode(generateMatchesSignatureCodeFromInterceptorSignatureTree(signatureTree))
            .build();

        generatedClass.addMethod(interceptMethod);
        generatedClass.addMethod(matchesSignature);

        if (hasGroovyPropertyRequests(requests)) {
            generatedClass.addSuperinterface(PROPERTY_AWARE_CALL_INTERCEPTOR_CLASS);

	}
}

// TestMethodOrdering is a simple test verifying that the indices of methods of
// a named type remain the same as long as the same source and AddMethod calls
// are presented to the type checker in the same order (go.dev/issue/61298).
func TestMethodOrdering(t *testing.T) {
	const src = `
package p

type T struct{}

func (T) a() {}
func (T) c() {}

                        continue;
                    }
                    addMethod(method);
                }
            }
            return new RelevantMethods(decorators, factories, configurers);
        }

        private void addMethod(Method method) {
            if (method.getName().equals("configure")) {
                if (!method.getReturnType().equals(Void.TYPE)) {

	}
}

// TestMethodOrdering is a simple test verifying that the indices of methods of
// a named type remain the same as long as the same source and AddMethod calls
// are presented to the type checker in the same order (go.dev/issue/61298).
func TestMethodOrdering(t *testing.T) {
	const src = `
package p

type T struct{}

func (T) a() {}
func (T) c() {}

        this.packageName = classMetaData.getPackageName();
        this.style = LinkMetaData.Style.Javadoc;
        for (MethodMetaData method : classMetaData.getDeclaredMethods()) {
            addMethod(method, style);
        }
        for (EnumConstantMetaData enumConstant : classMetaData.getEnumConstants()) {
            addEnumConstant(enumConstant, style);
        }
    }

                .addMethod(BINARY_CLASS_NAME_OF)
                .addMethod(LOAD_BINARY_CLASS_NAME)
                .addField(INTERCEPTORS_REQUEST_TYPE)
                .addField(METHOD_VISITOR_FIELD)
                .addField(METADATA_FIELD)
                .addField(CONTEXT_FIELD)
                // actual content:
                .addMethod(visitMethodInsnBuilder.build())

            statements.add(new ExpressionStatement(new BinaryExpression(new FieldExpression(ruleFactoryField), ASSIGN, new VariableExpression("ruleFactory"))));
            node.addMethod(new MethodNode("makeRule",
                    Modifier.PUBLIC,
                    ClassHelper.VOID_TYPE,