*/

package org.gradle.language.scala.tasks;

import org.gradle.api.Incubating;

/**
 * Describes whether a Scala compiler daemon should be reused.
 *
 * @since 7.6
 */
@Incubating
public enum KeepAliveMode {
    /**
     * The compiler is kept alive for a session.
     */
    SESSION,

    /**
     * The compiler is kept alive across builds.
     */
    DAEMON

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.workers.internal;

public enum KeepAliveMode {
    /**
     * Keep alive until the end of the build session
     */
    SESSION,
    /**
     * Keep alive until the daemon stops
     */
    DAEMON

    private final KeepAliveMode keepAliveMode;
    private final ClassLoaderStructure classLoaderStructure;

    DaemonForkOptions(JavaForkOptionsInternal forkOptions,
                      KeepAliveMode keepAliveMode,
                      ClassLoaderStructure classLoaderStructure) {
        this.forkOptions = forkOptions;
        this.keepAliveMode = keepAliveMode;

    private List<String> loggingPhases;
    private MinimalScalaCompilerDaemonForkOptions forkOptions;
    private transient IncrementalCompileOptions incrementalOptions;
    private final KeepAliveMode keepAliveMode;

    public MinimalScalaCompileOptions(BaseScalaCompileOptions compileOptions) {
        this.failOnError = compileOptions.isFailOnError();
        this.deprecation = compileOptions.isDeprecation();

            .withClassLoaderStructure(new HierarchicalClassLoaderStructure(spec1).withChild(spec2))
            .keepAliveMode(KeepAliveMode.SESSION)
            .build()
        def settings2 = daemonForkOptionsBuilder()
            .withClassLoaderStructure(new HierarchicalClassLoaderStructure(spec1).withChild(spec2))
            .keepAliveMode(KeepAliveMode.SESSION)
            .build()

        expect:
        settings1.isCompatibleWith(settings2)

    }

    public DaemonForkOptionsBuilder keepAliveMode(KeepAliveMode keepAliveMode) {
        this.keepAliveMode = keepAliveMode;
        return this;
    }

    public DaemonForkOptionsBuilder javaForkOptions(JavaForkOptions javaForkOptions) {
        javaForkOptions.copyTo(this.javaForkOptions);
        return this;
    }

        return new DaemonForkOptionsBuilder(forkOptionsFactory)
            .javaForkOptions(javaForkOptions)
            .withClassLoaderStructure(classLoaderStructure)
            .keepAliveMode(KeepAliveMode.DAEMON)
            .build();
    }

    public static class JavaCompilerParameters extends CompilerWorkerExecutor.CompilerParameters {
        private final JavaCompileSpec compileSpec;

        return new DaemonForkOptionsBuilder(forkOptionsFactory)
            .javaForkOptions(javaForkOptions)
            .withClassLoaderStructure(classLoaderStructure)
            .keepAliveMode(KeepAliveMode.valueOf(compileOptions.getKeepAliveMode().name()))
            .build();
    }

    private FilteringClassLoader.Spec getScalaFilterSpec() {

    private ScalaForkOptions forkOptions = getObjectFactory().newInstance(ScalaForkOptions.class);

    private IncrementalCompileOptions incrementalOptions;

    private final Property<KeepAliveMode> keepAliveMode = getObjectFactory().property(KeepAliveMode.class);

    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();
    }

    /**
     * Fail the build on compilation errors.

        buildDir.file("build.gradle") << """
            allprojects {
                tasks.withType(${compileTaskType}) {
                    scalaCompileOptions.keepAliveMode = KeepAliveMode.DAEMON
                }
            }
        """
    }