1100 lines
30 KiB
Java
1100 lines
30 KiB
Java
/*
|
|
* Copyright 2023-2025 the original author or authors.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package rife.bld.extension.kotlin;
|
|
|
|
import rife.bld.extension.CompileKotlinOperation;
|
|
|
|
import java.io.File;
|
|
import java.nio.file.Path;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
|
|
import static rife.bld.extension.CompileKotlinOperation.isNotBlank;
|
|
|
|
/**
|
|
* Configuration for the Kotlin compiler options.
|
|
*
|
|
* @author <a href="https://erik.thauvin.net/">Erik C. Thauvin</a>
|
|
* @since 1.0
|
|
*/
|
|
public class CompileOptions {
|
|
private final Collection<String> advancedOptions_ = new ArrayList<>();
|
|
private final Collection<File> argFile_ = new ArrayList<>();
|
|
private final Collection<File> classpath_ = new ArrayList<>();
|
|
private final JvmOptions jvmOptions_ = new JvmOptions();
|
|
private final Collection<String> optIn_ = new ArrayList<>();
|
|
private final Collection<String> options_ = new ArrayList<>();
|
|
private final Collection<String> plugin_ = new ArrayList<>();
|
|
private final Collection<String> scriptTemplates_ = new ArrayList<>();
|
|
private String apiVersion_;
|
|
private String expression_;
|
|
private boolean includeRuntime_;
|
|
private boolean javaParameters_;
|
|
private File jdkHome_;
|
|
private String jdkRelease_;
|
|
private String jvmTarget_;
|
|
private File kotlinHome_;
|
|
private String languageVersion_;
|
|
private String moduleName_;
|
|
private boolean noJdk_;
|
|
private boolean noReflect_;
|
|
private boolean noStdLib_;
|
|
private boolean noWarn_;
|
|
private File path_;
|
|
private boolean progressive_;
|
|
private boolean verbose_;
|
|
private boolean wError_;
|
|
private boolean wExtra_;
|
|
|
|
/**
|
|
* Specify advanced compiler options.
|
|
*
|
|
* @param options one or more advanced options
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions advancedOptions(String... options) {
|
|
return advancedOptions(List.of(options));
|
|
}
|
|
|
|
/**
|
|
* Specify advanced compiler options.
|
|
*
|
|
* @param options the compiler options
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions advancedOptions(Collection<String> options) {
|
|
advancedOptions_.addAll(options);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves advanced compiler options.
|
|
*
|
|
* @return the advanced compiler options
|
|
*/
|
|
public Collection<String> advancedOptions() {
|
|
return advancedOptions_;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the version of Kotlin bundled libraries.
|
|
*
|
|
* @return the API version
|
|
*/
|
|
public String apiVersion() {
|
|
return apiVersion_;
|
|
}
|
|
|
|
/**
|
|
* Allow using declarations only from the specified version of Kotlin bundled libraries.
|
|
*
|
|
* @param version the API version
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions apiVersion(String version) {
|
|
apiVersion_ = version;
|
|
return this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Allow using declarations only from the specified version of Kotlin bundled libraries.
|
|
*
|
|
* @param version the API version
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions apiVersion(int version) {
|
|
return apiVersion(String.valueOf(version));
|
|
}
|
|
|
|
/**
|
|
* Read the compiler options from the given files.
|
|
* <p>
|
|
* Such a file can contain compiler options with values and paths to the source files.
|
|
* Options and paths should be separated by whitespaces. For example:
|
|
* <ul>
|
|
* <li>{@code -include-runtime -d hello.jar hello.kt}</li>
|
|
* </ul>
|
|
* To pass values that contain whitespaces, surround them with single ({@code '}) or double ({@code "}) quotes.
|
|
* If a value contains quotation marks in it, escape them with a backslash (\).
|
|
* <ul>
|
|
* <li>{@code -include-runtime -d 'My folder'}</li>
|
|
* </ul>
|
|
* If the files reside in locations different from the current directory, use relative paths.
|
|
*
|
|
* @param files one or more files
|
|
* @return this operation instance
|
|
* @see #argFileStrings(Collection)
|
|
*/
|
|
public CompileOptions argFile(String... files) {
|
|
return argFileStrings(List.of(files));
|
|
}
|
|
|
|
/**
|
|
* Read the compiler options from the given files.
|
|
*
|
|
* @param files the compiler options files
|
|
* @return this operation instance
|
|
* @see #argFile(File...)
|
|
*/
|
|
public CompileOptions argFile(Collection<File> files) {
|
|
argFile_.addAll(files);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Read the compiler options from the given files.
|
|
* <p>
|
|
* Such a file can contain compiler options with values and paths to the source files.
|
|
* Options and paths should be separated by whitespaces. For example:
|
|
* <ul>
|
|
* <li>{@code -include-runtime -d hello.jar hello.kt}</li>
|
|
* </ul>
|
|
* To pass values that contain whitespaces, surround them with single ({@code '}) or double ({@code "}) quotes.
|
|
* If a value contains quotation marks in it, escape them with a backslash (\).
|
|
* <ul>
|
|
* <li>{@code -include-runtime -d 'My folder'}</li>
|
|
* </ul>
|
|
* If the files reside in locations different from the current directory, use relative paths.
|
|
*
|
|
* @param files one or more files
|
|
* @return this operation instance
|
|
* @see #argFile(Collection)
|
|
*/
|
|
public CompileOptions argFile(File... files) {
|
|
return argFile(List.of(files));
|
|
}
|
|
|
|
/**
|
|
* Read the compiler options from the given files.
|
|
* <p>
|
|
* Such a file can contain compiler options with values and paths to the source files.
|
|
* Options and paths should be separated by whitespaces. For example:
|
|
* <ul>
|
|
* <li>{@code -include-runtime -d hello.jar hello.kt}</li>
|
|
* </ul>
|
|
* To pass values that contain whitespaces, surround them with single ({@code '}) or double ({@code "}) quotes.
|
|
* If a value contains quotation marks in it, escape them with a backslash (\).
|
|
* <ul>
|
|
* <li>{@code -include-runtime -d 'My folder'}</li>
|
|
* </ul>
|
|
* If the files reside in locations different from the current directory, use relative paths.
|
|
*
|
|
* @param files one or more files
|
|
* @return this operation instance
|
|
* @see #argFilePaths(Collection)
|
|
*/
|
|
public CompileOptions argFile(Path... files) {
|
|
return argFilePaths(List.of(files));
|
|
}
|
|
|
|
/**
|
|
* Retrieves the files containing compiler options.
|
|
*
|
|
* @return the compiler options files
|
|
*/
|
|
public Collection<File> argFile() {
|
|
return argFile_;
|
|
}
|
|
|
|
/**
|
|
* Read the compiler options from the given files.
|
|
*
|
|
* @param files the compiler options files
|
|
* @return this operation instance
|
|
* @see #argFile(Path...)
|
|
*/
|
|
public CompileOptions argFilePaths(Collection<Path> files) {
|
|
return argFile(files.stream().map(Path::toFile).toList());
|
|
}
|
|
|
|
/**
|
|
* Read the compiler options from the given files.
|
|
*
|
|
* @param files the compiler options files
|
|
* @return this operation instance
|
|
* @see #argFile(String...)
|
|
*/
|
|
public CompileOptions argFileStrings(Collection<String> files) {
|
|
return argFile(files.stream().map(File::new).toList());
|
|
}
|
|
|
|
/**
|
|
* Returns the formatted arguments.
|
|
*
|
|
* @return the arguments
|
|
*/
|
|
public List<String> args() {
|
|
var args = new ArrayList<String>();
|
|
|
|
// api-version
|
|
if (isNotBlank(apiVersion_)) {
|
|
args.add("-api-version");
|
|
args.add(apiVersion_);
|
|
}
|
|
|
|
// @argfile
|
|
if (!argFile_.isEmpty()) {
|
|
argFile_.forEach(f -> args.add("@" + f.getAbsolutePath()));
|
|
}
|
|
|
|
// classpath
|
|
if (!classpath_.isEmpty()) {
|
|
args.add("-classpath");
|
|
args.add(classpath_.stream().map(File::getAbsolutePath).collect(Collectors.joining(File.pathSeparator)));
|
|
}
|
|
|
|
// expression
|
|
if (isNotBlank(expression_)) {
|
|
args.add("-expression");
|
|
args.add(expression_);
|
|
}
|
|
|
|
// java-parameters
|
|
if (javaParameters_) {
|
|
args.add("-java-parameters");
|
|
}
|
|
|
|
// jvm-target
|
|
if (isNotBlank(jvmTarget_)) {
|
|
args.add("-jvm-target");
|
|
args.add(jvmTarget_);
|
|
}
|
|
|
|
// include-runtime
|
|
if (includeRuntime_) {
|
|
args.add("-include-runtime");
|
|
}
|
|
|
|
// jdk-home
|
|
if (jdkHome_ != null) {
|
|
args.add("-jdk-home");
|
|
args.add(jdkHome_.getAbsolutePath());
|
|
}
|
|
|
|
// jdk-release
|
|
if (isNotBlank(jdkRelease_)) {
|
|
args.add("-Xjdk-release=" + jdkRelease_);
|
|
}
|
|
|
|
// JVM options
|
|
if (!jvmOptions_.isEmpty()) {
|
|
jvmOptions_.forEach(s -> args.add("-J" + s));
|
|
}
|
|
|
|
// kotlin-home
|
|
if (kotlinHome_ != null) {
|
|
args.add("-kotlin-home");
|
|
args.add(kotlinHome_.getAbsolutePath());
|
|
}
|
|
|
|
// language-version
|
|
if (isNotBlank(languageVersion_)) {
|
|
args.add("-language-version");
|
|
args.add(languageVersion_);
|
|
}
|
|
|
|
// module-name
|
|
if (isNotBlank(moduleName_)) {
|
|
args.add("-module-name");
|
|
args.add(moduleName_);
|
|
}
|
|
|
|
// no-jdk
|
|
if (noJdk_) {
|
|
args.add("-no-jdk");
|
|
}
|
|
|
|
// no-reflect
|
|
if (noReflect_) {
|
|
args.add("-no-reflect");
|
|
}
|
|
|
|
// no-std-lib
|
|
if (noStdLib_) {
|
|
args.add("-no-stdlib");
|
|
}
|
|
|
|
// no-warn
|
|
if (noWarn_) {
|
|
args.add("-nowarn");
|
|
}
|
|
|
|
// opt-in
|
|
optIn_.stream().filter(CompileKotlinOperation::isNotBlank).forEach(o -> {
|
|
args.add("-opt-in");
|
|
args.add(o);
|
|
});
|
|
|
|
// options
|
|
if (!options_.isEmpty()) {
|
|
args.addAll(options_);
|
|
}
|
|
|
|
// path
|
|
if (path_ != null) {
|
|
args.add("-d");
|
|
args.add(path_.getAbsolutePath());
|
|
}
|
|
|
|
// plugin
|
|
plugin_.stream().filter(CompileKotlinOperation::isNotBlank).forEach(p -> {
|
|
args.add("-P");
|
|
args.add("plugin:" + p);
|
|
});
|
|
|
|
// progressive
|
|
if (progressive_) {
|
|
args.add("-progressive");
|
|
}
|
|
|
|
// script-templates
|
|
if (!scriptTemplates_.isEmpty()) {
|
|
args.add("-script-templates");
|
|
args.add(String.join(",", scriptTemplates_));
|
|
}
|
|
|
|
// verbose
|
|
if (verbose_) {
|
|
args.add("-verbose");
|
|
}
|
|
|
|
// Wwrror
|
|
if (wError_) {
|
|
args.add("-Werror");
|
|
}
|
|
|
|
// Wextra
|
|
if (wExtra_) {
|
|
args.add("-Wextra");
|
|
}
|
|
|
|
// advanced option (X)
|
|
if (!advancedOptions_.isEmpty()) {
|
|
advancedOptions_.forEach(it -> args.add("-X" + it));
|
|
}
|
|
|
|
return args;
|
|
}
|
|
|
|
/**
|
|
* Search for class files in the specified paths.
|
|
* <p>
|
|
* The classpath can contain file and directory paths, ZIP, or JAR files.
|
|
*
|
|
* @param paths one pr more paths
|
|
* @return this operation instance
|
|
* @see #classpathStrings(Collection)
|
|
*/
|
|
public CompileOptions classpath(String... paths) {
|
|
return classpathStrings(List.of(paths));
|
|
}
|
|
|
|
/**
|
|
* Search for class files in the specified paths.
|
|
* <p>
|
|
* The classpath can contain file and directory paths, ZIP, or JAR files.
|
|
*
|
|
* @param paths one or more path
|
|
* @return this operation instance
|
|
* @see #classpath(Collection)
|
|
*/
|
|
public CompileOptions classpath(File... paths) {
|
|
return classpath(List.of(paths));
|
|
}
|
|
|
|
/**
|
|
* Search for class files in the specified paths.
|
|
* <p>
|
|
* The classpath can contain file and directory paths, ZIP, or JAR files.
|
|
*
|
|
* @param paths one or more path
|
|
* @return this operation instance
|
|
* @see #classpathPaths(Collection)
|
|
*/
|
|
public CompileOptions classpath(Path... paths) {
|
|
return classpathPaths(List.of(paths));
|
|
}
|
|
|
|
/**
|
|
* Search for class files in the specified paths.
|
|
* <p>
|
|
* The classpath can contain file and directory paths, ZIP, or JAR files.
|
|
*
|
|
* @param paths the search paths
|
|
* @return this operation instance
|
|
* @see #classpath(File...)
|
|
*/
|
|
public CompileOptions classpath(Collection<File> paths) {
|
|
classpath_.addAll(paths);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the class files classpath.
|
|
*
|
|
* @return the class files classpath
|
|
*/
|
|
public Collection<File> classpath() {
|
|
return classpath_;
|
|
}
|
|
|
|
/**
|
|
* Search for class files in the specified paths.
|
|
* <p>
|
|
* The classpath can contain file and directory paths, ZIP, or JAR files.
|
|
*
|
|
* @param paths one pr more paths
|
|
* @return this operation instance
|
|
* @see #classpath(Path...)
|
|
*/
|
|
public CompileOptions classpathPaths(Collection<Path> paths) {
|
|
return classpath(paths.stream().map(Path::toFile).toList());
|
|
}
|
|
|
|
/**
|
|
* Search for class files in the specified paths.
|
|
* <p>
|
|
* The classpath can contain file and directory paths, ZIP, or JAR files.
|
|
*
|
|
* @param paths one pr more paths
|
|
* @return this operation instance
|
|
* @see #classpath(String...)
|
|
*/
|
|
public CompileOptions classpathStrings(Collection<String> paths) {
|
|
return classpath(paths.stream().map(File::new).toList());
|
|
}
|
|
|
|
/**
|
|
* Retrieves the string to evaluate as a Kotlin script.
|
|
*
|
|
* @return the expression
|
|
*/
|
|
public String expression() {
|
|
return expression_;
|
|
}
|
|
|
|
/**
|
|
* Evaluate the given string as a Kotlin script.
|
|
*
|
|
* @param expression the expression
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions expression(String expression) {
|
|
expression_ = expression;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether the {@link #jdkRelease(String) jdkRelease} was set.
|
|
*
|
|
* @return {@code true} if the release was set; or {@code false} otherwise
|
|
*/
|
|
public boolean hasRelease() {
|
|
return jdkRelease_ != null;
|
|
}
|
|
|
|
/**
|
|
* Include the Kotlin runtime into the resulting JAR file. Makes the resulting archive runnable on any Java-enabled
|
|
* environment.
|
|
*
|
|
* @param includeRuntime {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions includeRuntime(boolean includeRuntime) {
|
|
includeRuntime_ = includeRuntime;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether the {@link #includeRuntime(boolean)} was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isIncludeRuntime() {
|
|
return includeRuntime_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #javaParameters(boolean)} was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isJavaParameters() {
|
|
return javaParameters_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #noJdk(boolean) noJdk} was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isNoJdk() {
|
|
return noJdk_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #noReflect(boolean) noRflect} was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isNoReflect() {
|
|
return noReflect_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #noStdLib(boolean) noStdLib} +was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isNoStdLib() {
|
|
return noStdLib_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #noWarn(boolean) noWarn} was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isNoWarn() {
|
|
return noWarn_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #progressive(boolean) progressive} was set.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isProgressive() {
|
|
return progressive_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether {@link #verbose(boolean)} was set.
|
|
*
|
|
* @return {@code true} if verbose was set; or {@code false} otherwise
|
|
*/
|
|
public boolean isVerbose() {
|
|
return verbose_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether warnings are turned into a compilation error.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isWError() {
|
|
return wError_;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether additional declaration, expression, and type compiler checks emit warnings.
|
|
*
|
|
* @return {@code true} or {@code false}
|
|
*/
|
|
public boolean isWExtra() {
|
|
return wExtra_;
|
|
}
|
|
|
|
/**
|
|
* Generate metadata for Java 1.8 reflection on method parameters.
|
|
*
|
|
* @param javaParameters {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions javaParameters(boolean javaParameters) {
|
|
javaParameters_ = javaParameters;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Use a custom JDK home directory to include into the classpath if it differs from the default {@code JAVA_HOME}.
|
|
*
|
|
* @param jdkHome the JDK home path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jdkHome(File jdkHome) {
|
|
jdkHome_ = jdkHome;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Use a custom JDK home directory to include into the classpath if it differs from the default {@code JAVA_HOME}.
|
|
*
|
|
* @param jdkHome the JDK home path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jdkHome(String jdkHome) {
|
|
return jdkHome(new File(jdkHome));
|
|
}
|
|
|
|
/**
|
|
* Use a custom JDK home directory to include into the classpath if it differs from the default {@code JAVA_HOME}.
|
|
*
|
|
* @param jdkHome the JDK home path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jdkHome(Path jdkHome) {
|
|
return jdkHome(jdkHome.toFile());
|
|
}
|
|
|
|
/**
|
|
* Retrieves the custom JDK home directory.
|
|
*
|
|
* @return the JDK home path.
|
|
*/
|
|
public File jdkHome() {
|
|
return jdkHome_;
|
|
}
|
|
|
|
/**
|
|
* Return the specified JDK API version.
|
|
*
|
|
* @return the API version
|
|
*/
|
|
public String jdkRelease() {
|
|
return jdkRelease_;
|
|
}
|
|
|
|
/**
|
|
* Compile against the specified JDK API version.
|
|
* <p>
|
|
* Limit the API of the JDK in the classpath to the specified Java version. Automatically sets
|
|
* {@link #jvmTarget(String) JVM target} version.
|
|
* <p>
|
|
* Possible values are 1.8, 9, 10, ..., 22. The default value is 1.8.
|
|
*
|
|
* @param version the target version
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jdkRelease(String version) {
|
|
jdkRelease_ = version;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Compile against the specified JDK API version.
|
|
* <p>
|
|
* Limit the API of the JDK in the classpath to the specified Java version. Automatically sets
|
|
* {@link #jvmTarget(String) JVM target} version.
|
|
* <p>
|
|
* Possible values are 1.8, 9, 10, ..., 22. The default value is 1.8.
|
|
*
|
|
* @param version the target version
|
|
* @return this operation instance
|
|
* @see #jdkRelease(String)
|
|
*/
|
|
public CompileOptions jdkRelease(int version) {
|
|
return jdkRelease(String.valueOf(version));
|
|
}
|
|
|
|
/**
|
|
* Retrieves the Java Virtual Machine options.
|
|
*
|
|
* @return the JVM options
|
|
*/
|
|
public JvmOptions jvmOptions() {
|
|
return jvmOptions_;
|
|
}
|
|
|
|
/**
|
|
* Pass an option directly to the Java Virtual Machine
|
|
*
|
|
* @param jvmOptions the JVM options
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jvmOptions(Collection<String> jvmOptions) {
|
|
jvmOptions_.addAll(jvmOptions);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Pass an option directly to the Java Virtual Machine
|
|
*
|
|
* @param jvmOptions one or more JVM option
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jvmOptions(String... jvmOptions) {
|
|
return jvmOptions(List.of(jvmOptions));
|
|
}
|
|
|
|
/**
|
|
* Specify the target version of the generated JVM bytecode.
|
|
*
|
|
* @param target the target version
|
|
* @return this operation instance
|
|
* @see #jvmTarget(String)
|
|
*/
|
|
public CompileOptions jvmTarget(int target) {
|
|
return jvmTarget(String.valueOf(target));
|
|
}
|
|
|
|
/**
|
|
* Specify the target version of the generated JVM bytecode.
|
|
* <p>
|
|
* Possible values are 1.8, 9, 10, ..., 22. The default value is 1.8.
|
|
*
|
|
* @param target the target version
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions jvmTarget(String target) {
|
|
jvmTarget_ = target;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the target version of the generated JVM bytecode.
|
|
*
|
|
* @return the target version
|
|
*/
|
|
public String jvmTarget() {
|
|
return jvmTarget_;
|
|
}
|
|
|
|
/**
|
|
* Specify a custom path to the Kotlin compiler used for the discovery of runtime libraries.
|
|
*
|
|
* @param path the Kotlin home path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions kotlinHome(File path) {
|
|
kotlinHome_ = path;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the custom path of the Kotlin compiler.
|
|
*
|
|
* @return the Kotlin home path
|
|
*/
|
|
public File kotlinHome() {
|
|
return kotlinHome_;
|
|
}
|
|
|
|
/**
|
|
* Specify a custom path to the Kotlin compiler used for the discovery of runtime libraries.
|
|
*
|
|
* @param path the Kotlin home path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions kotlinHome(Path path) {
|
|
return kotlinHome(path.toFile());
|
|
}
|
|
|
|
/**
|
|
* Specify a custom path to the Kotlin compiler used for the discovery of runtime libraries.
|
|
*
|
|
* @param path the Kotlin home path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions kotlinHome(String path) {
|
|
return kotlinHome(new File(path));
|
|
}
|
|
|
|
/**
|
|
* Provide source compatibility with the specified version of Kotlin.
|
|
*
|
|
* @param version the language version
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions languageVersion(String version) {
|
|
languageVersion_ = version;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the {@link #languageVersion(String) language version}.
|
|
*
|
|
* @return the language version
|
|
*/
|
|
public String languageVersion() {
|
|
return languageVersion_;
|
|
}
|
|
|
|
/**
|
|
* Set a custom name for the generated {@code .kotlin_module} file.
|
|
*
|
|
* @param name the module name
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions moduleName(String name) {
|
|
moduleName_ = name;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the {@link #moduleName(String) module name}.
|
|
*
|
|
* @return the module name
|
|
*/
|
|
public String moduleName() {
|
|
return moduleName_;
|
|
}
|
|
|
|
/**
|
|
* Don't automatically include the Java runtime into the classpath.
|
|
*
|
|
* @param noJdk {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions noJdk(boolean noJdk) {
|
|
noJdk_ = noJdk;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Don't automatically include the Kotlin reflection ({@code kotlin-reflect.jar}) into the classpath.
|
|
*
|
|
* @param noReflect {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions noReflect(boolean noReflect) {
|
|
noReflect_ = noReflect;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Don't automatically include the Kotlin/JVM stdlib ({@code kotlin-stdlib.jar}) and Kotlin reflection
|
|
* ({@code kotlin-reflect.jar}) into the classpath.
|
|
*
|
|
* @param noStdLib {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions noStdLib(boolean noStdLib) {
|
|
noStdLib_ = noStdLib;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Suppress the compiler from displaying warnings during compilation.
|
|
*
|
|
* @param noWarn {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions noWarn(boolean noWarn) {
|
|
noWarn_ = noWarn;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Enable usages of API that requires opt-in with a requirement annotation with the given fully qualified name.
|
|
*
|
|
* @param annotations one or more annotation names
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions optIn(String... annotations) {
|
|
return optIn(List.of(annotations));
|
|
}
|
|
|
|
/**
|
|
* Retrieves the opt-in fully qualified names.
|
|
*
|
|
* @return the fully qualified names
|
|
*/
|
|
public Collection<String> optIn() {
|
|
return optIn_;
|
|
}
|
|
|
|
/**
|
|
* Enable usages of API that requires opt-in with a requirement annotation with the given fully qualified name.
|
|
*
|
|
* @param annotations the annotation names
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions optIn(Collection<String> annotations) {
|
|
optIn_.addAll(annotations);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specify additional compiler options.
|
|
*
|
|
* @param options one or more compiler options
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions options(String... options) {
|
|
return options(List.of(options));
|
|
}
|
|
|
|
/**
|
|
* Retrieves additional compiler options.
|
|
*
|
|
* @return the compiler options
|
|
*/
|
|
public Collection<String> options() {
|
|
return options_;
|
|
}
|
|
|
|
/**
|
|
* Specify additional compiler options.
|
|
*
|
|
* @param options the compiler options
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions options(Collection<String> options) {
|
|
options_.addAll(options);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Place the generated class files into the specified location.
|
|
* <p>
|
|
* The location can be a directory, a ZIP, or a JAR file.
|
|
*
|
|
* @param path the location path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions path(File path) {
|
|
path_ = path;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the location to place generated class files into.
|
|
*
|
|
* @return the location path.
|
|
*/
|
|
public File path() {
|
|
return path_;
|
|
}
|
|
|
|
/**
|
|
* Place the generated class files into the specified location.
|
|
* <p>
|
|
* The location can be a directory, a ZIP, or a JAR file.
|
|
*
|
|
* @param path the location path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions path(Path path) {
|
|
return path(path.toFile());
|
|
}
|
|
|
|
/**
|
|
* Place the generated class files into the specified location.
|
|
* <p>
|
|
* The location can be a directory, a ZIP, or a JAR file.
|
|
*
|
|
* @param path the location path
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions path(String path) {
|
|
return path(new File(path));
|
|
}
|
|
|
|
/**
|
|
* Pass an option to a plugin.
|
|
*
|
|
* @param id the plugin ID
|
|
* @param optionName the plugin option name
|
|
* @param value the plugin option value
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions plugin(String id, String optionName, String value) {
|
|
plugin_.add(id + ':' + optionName + ':' + value);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the plugin options.
|
|
*
|
|
* @return the plugin options.
|
|
*/
|
|
public Collection<String> plugin() {
|
|
return plugin_;
|
|
}
|
|
|
|
/**
|
|
* Allow using declarations only from the specified version of Kotlin bundled libraries.
|
|
*
|
|
* @param progressive {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions progressive(boolean progressive) {
|
|
progressive_ = progressive;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Script definition template classes.
|
|
* <p>
|
|
* Use fully qualified class names.
|
|
*
|
|
* @param classNames one or more class names
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions scriptTemplates(String... classNames) {
|
|
return scriptTemplates(List.of(classNames));
|
|
}
|
|
|
|
/**
|
|
* Retrieves the script templates.
|
|
*
|
|
* @return the script templates.
|
|
*/
|
|
public Collection<String> scriptTemplates() {
|
|
return scriptTemplates_;
|
|
}
|
|
|
|
/**
|
|
* Script definition template classes.
|
|
* <p>
|
|
* Use fully qualified class names.
|
|
*
|
|
* @param classNames the class names
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions scriptTemplates(Collection<String> classNames) {
|
|
scriptTemplates_.addAll(classNames);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Enable verbose logging output which includes details of the compilation process.
|
|
*
|
|
* @param verbose {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions verbose(boolean verbose) {
|
|
verbose_ = verbose;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Turn any warnings into a compilation error.
|
|
*
|
|
* @param wError {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions wError(boolean wError) {
|
|
wError_ = wError;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Enable additional declaration, expression, and type compiler checks that emit warnings if {@code true}.
|
|
*
|
|
* @param wExtra {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public CompileOptions wExtra(boolean wExtra) {
|
|
wExtra_ = wExtra;
|
|
return this;
|
|
}
|
|
}
|