if (parameterInfo.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER && renderVararg) {
            return CodeBlock.of("$T...", typeName(parameterInfo.getParameterType().getElementType()));
        }
        return CodeBlock.of("$T", typeName(parameterInfo.getParameterType()));
    }

        if (problems.hasProblems()) {
            return null;
        }

        ModelType<S> binaryType = dataCollector.getParameterType(BINARY_SPEC);
        ModelType<C> componentType = dataCollector.getParameterType(COMPONENT_SPEC);
        return new ExtractedComponentBinariesRule<S, C>(componentType, binaryType, ruleDefinition);
    }

import org.gradle.api.Project;

/**
 * A {@link ToolingModelBuilder} which can be parameterized by the client.
 *
 * <p>The parameter type {@code T} must be an interface and must follow a contract described in {@link #getParameterType()}.
 * </p>
 *
 * <p>The parameter type {@code T} does not need to implement the interface defined in the client side, but it does need to have the same structure.

        final Builder delegate;

        public DelegatingBuilder(Builder delegate) {
            this.delegate = delegate;
        }

        @Override
        public Class<?> getParameterType() {
            return delegate.getParameterType();
        }
    }

    private static class BuilderWithNoParameter implements Builder {
        private final String modelName;
        private final ProjectInternal project;

                ? Stream.of(new ParameterMatchEntry(callable.getParameters().get(0).getParameterType(), RECEIVER))
                : Stream.<ParameterMatchEntry>empty(),
            // Then match the "normal" method parameters
            callable.getParameters().stream().filter(it -> it.getKind() == ParameterKindInfo.METHOD_PARAMETER).map(it -> new ParameterMatchEntry(it.getParameterType(), PARAMETER)),

        this.parameterType = parameterType;
        this.kind = kind;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Type getParameterType() {
        return parameterType;
    }

    @Override
    public ParameterKindInfo getKind() {
        return kind;
    }

 */
@NonNullApi
public class IsolatedIdeaModuleInternalBuilder implements ParameterizedToolingModelBuilder<IdeaModelParameter> {

    @Override
    public Class<IdeaModelParameter> getParameterType() {
        return IdeaModelParameter.class;
    }

    @Override
    public boolean canBuild(String modelName) {
        return modelName.equals(IsolatedIdeaModuleInternal.class.getName());
    }

        ToolingModelBuilder getBuilder();

        @Nullable
        UserCodeApplicationContext.Application getRegisteredBy();
    }

    interface Builder {
        @Nullable
        Class<?> getParameterType();

        Object build(@Nullable Object parameter);
    }

 * limitations under the License.
 */

package org.gradle.internal.instrumentation.model;

import org.objectweb.asm.Type;

public interface ParameterInfo {
    String getName();
    Type getParameterType();
    ParameterKindInfo getKind();

 */
@NonNullApi
public class IsolatedGradleProjectInternalBuilder implements ParameterizedToolingModelBuilder<IsolatedGradleProjectParameter> {

    @Override
    public Class<IsolatedGradleProjectParameter> getParameterType() {
        return IsolatedGradleProjectParameter.class;
    }

    @Override
    public boolean canBuild(String modelName) {
        return modelName.equals(IsolatedGradleProjectInternal.class.getName());
    }