}

    public static class CachedConstructor {
        private final ClassGenerator.GeneratedConstructor<?> constructor;
        private final RuntimeException error;

        private CachedConstructor(ClassGenerator.GeneratedConstructor<?> constructor, RuntimeException error) {
            this.constructor = constructor;
            this.error = error;
        }

        public ClassGenerator.GeneratedConstructor<?> getConstructor() {

     * It may however contain more than one entry if module hierarchy was detected,
     * in which case there is one key per sub-directory.
     *
     * <p>This map may contain null values if the constructor was invoked with {@code resolve}
     * parameter set to false. This is more efficient when only the module existence needs to
     * be tested, and module descriptors are not needed.</p>
     *
     * @see #getModuleNames()

                .takes(method.getGenericParameterTypes());
    }

    public static MethodDescription of(Constructor<?> constructor) {
        return name("<init>")
                .owner(constructor.getDeclaringClass())
                .takes(constructor.getGenericParameterTypes());
    }

    private String typeName(Type type) {
        if (type == null) {
            return null;
        }

    }

    @Override
    public void add(Method method, String role, String problem) {
        collector.add(method, role, problem);
    }

    @Override
    public void add(Constructor<?> constructor, String problem) {
        collector.add(constructor, problem);
    }

// tag::inject-task-constructor[]
abstract class CustomTask extends DefaultTask {
    private final String message
    private final int number

    @Inject
    CustomTask(String message, int number) {
        this.message = message
        this.number = number
    }
// end::inject-task-constructor[]

    @TaskAction
    void printIt() {
        println("$message $number")
    }
// tag::inject-task-constructor[]
}

/**
 * State might be corrupted and should be discarded.
 */
@Contextual
class ConfigurationCacheError internal constructor(
    error: String,
    cause: Throwable? = null
) : ConfigurationCacheThrowable, Exception(error, cause)


@Contextual
sealed class ConfigurationCacheException protected constructor(
    message: () -> String,
    causes: Iterable<Throwable>

// tag::inject-task-constructor[]
abstract class CustomTask @Inject constructor(
    private val message: String,
    private val number: Int
) : DefaultTask()
// end::inject-task-constructor[]

{
    @TaskAction
    fun run() =
        println("$message $number")
}

// tag::on-task-container[]
tasks.register<CustomTask>("myTask", "hello", 42)

  let summary = "Optimize tf_saved_model.global_tensor's.";

  let constructor = "mlir::tf_saved_model::CreateOptimizeGlobalTensorsPass()";
}

def RemoveVariablesInSessionInitializerPass : Pass<"tf-saved-model-remove-vars-in-session-initializer", "ModuleOp"> {
  let summary = "Remove variables in tf saved model's session initializer.";

  let constructor = "mlir::tf_saved_model::CreateRemoveVariablesInSessionInitializerPass()";
}

    def "can construct a task in Kotlin with @Inject services constructor arg"() {
        given:
        settingsFile << "rootProject.buildFileName = 'build.gradle.kts'"
        file("build.gradle.kts") << """
            import org.gradle.api.*
            import org.gradle.api.tasks.*
            import org.gradle.workers.WorkerExecutor

            open class CustomTask @Inject constructor(private val executor: WorkerExecutor) : DefaultTask() {

    /**
     * Allows this selector to veto the parameters to use with the given constructor.
     */
    void vetoParameters(ClassGenerator.GeneratedConstructor<?> constructor, Object[] parameters);

    /**
     * Locates the constructor that should be used to create instances of the given type with the given params.
     *