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();

    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 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

        return new CallInterceptionRequestImpl(
            modifiedCallableInfo(originalRequest.getInterceptedCallable(), extra),
            originalRequest.getImplementationInfo(),
            modifiedExtras(originalRequest.getRequestExtras())
        );
    }

        return childrenByMatchEntry != null ? childrenByMatchEntry : Collections.emptyMap();
    }

    void add(CallInterceptionRequest request) {
        CallableInfo callable = request.getInterceptedCallable();
        List<ParameterMatchEntry> matchEntries = parameterMatchEntries(callable);

        SignatureTree current = this;
        for (ParameterMatchEntry matchEntry : matchEntries) {