CallableInfo interceptedCallable = request.getInterceptedCallable();
        ClassName className = ClassName.bestGuess(interceptedCallable.getOwner().getType().getClassName());
        String callableNameForDocComment = interceptedCallable.getKind() == CallableKindInfo.AFTER_CONSTRUCTOR ? className.simpleName() : interceptedCallable.getCallableName();
        List<ParameterInfo> params = request.getInterceptedCallable().getParameters();

                CallableInfo callable = request.getInterceptedCallable();
                CallableKindInfo kind = callable.getKind();
                if (kind == CallableKindInfo.AFTER_CONSTRUCTOR) {
                    Type constructedType = request.getInterceptedCallable().getOwner().getType();

    private CodeBlock prepareInvocationArgs(CallInterceptionRequest request) {
        boolean hasKotlinDefaultMask = request.getInterceptedCallable().getParameters().stream().anyMatch(it -> it.getKind() == ParameterKindInfo.KOTLIN_DEFAULT_MASK);
        boolean hasCallerClassName = hasCallerClassName(request.getInterceptedCallable());
        Stream<CodeBlock> maybeZeroForKotlinDefault = hasKotlinDefaultMask ? Stream.of(CodeBlock.of("0")) : Stream.empty();

        requests.stream().filter(it -> it.getInterceptedCallable().getKind() == GROOVY_PROPERTY_GETTER).forEach(request -> {
            String propertyName = request.getInterceptedCallable().getCallableName();
            String getterName = NameUtil.getterName(request.getInterceptedCallable().getCallableName(), request.getInterceptedCallable().getReturnType().getType());

    public Collection<CallInterceptionRequest> filterRequestsForResource(Collection<CallInterceptionRequest> interceptionRequests) {
        return interceptionRequests.stream()
            .filter(request -> request.getInterceptedCallable().getOwner().isInterceptSubtypes())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {

            .filter(it -> !it.isEmpty())
            .orElse(NameUtil.interceptedJvmMethodName(originalRequest.getInterceptedCallable()));
    }

    private static boolean shouldPostProcess(CallInterceptionRequest request) {
        CallableKindInfo kind = request.getInterceptedCallable().getKind();

        String callableName = request.getInterceptedCallable().getCallableName();
        CallableInfo interceptedCallable = request.getInterceptedCallable();
        String interceptedCallableDescriptor = standardCallableDescriptor(interceptedCallable);
        validateSignature(request.getInterceptedCallable());

        CodeBlock matchOpcodeExpression = matchOpcodeExpression(interceptedCallable);

        String containingType = firstRequest.getInterceptedCallable().getOwner().getType().getClassName();
        List<ReplacedAccessor> upgradedAccessors = requests.stream()
            .map(request -> {
                PropertyUpgradeRequestExtra requestExtra = request.getRequestExtras().getByType(PropertyUpgradeRequestExtra.class).get();
                CallableInfo intercepted = request.getInterceptedCallable();

 * limitations under the License.
 */

package org.gradle.internal.instrumentation.model;

public interface CallInterceptionRequest {
    CallableInfo getInterceptedCallable();
    ImplementationInfo getImplementationInfo();
    RequestExtrasContainer getRequestExtras();

        this.requestExtras = new RequestExtrasContainer();
        requestExtras.forEach(this.requestExtras::add);
    }

    @Override
    public CallableInfo getInterceptedCallable() {
        return interceptedCallable;
    }

    @Override
    public ImplementationInfo getImplementationInfo() {
        return implementationInfo;
    }

    @Override