ronantakizawa/codereview-bench huggingface dataset:
Repository: apple/pkl
File: pkl-gradle/src/test/kotlin/org/pkl/gradle/KotlinCodeGeneratorsTest.kt (Kotlin)

Code before:
      dependencies {
        implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
      }

      pkl {
        kotlinCodeGenerators {
          configClasses {
            sourceModules = ["mod.pkl"]
            outputDir = file("build/generated")
            settingsModule = "pkl:settings"
          }
        }
      }
    """
    )
  }
  
  private fun writePklFile() {
    writeFile(
      "mod.pkl", """
      module org.mod

      class Person {
        name: String
        addresses: List<Address>
      }

      // "open" to test generating regular class
      open class Address {
        street: String
        zip: Int
      }

      other = 42
    """
    )
  }
}


Review comment (suggestion):
and you used the more kotlinesque way above ;)
```suggestion
            ${kotlinPackage?.let { "kotlinPackage = \"$it\"" } ?: ""}
```

Code after:
            exclude module: "kotlin-android-extensions"
          }
        }
      }

      plugins {
        id "org.pkl-lang"
      }

      apply plugin: "kotlin"

      repositories {
        mavenCentral()
      }

      dependencies {
        implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
      }

      pkl {
        kotlinCodeGenerators {
          configClasses {
            sourceModules = ["mod.pkl"]
            outputDir = file("build/generated")
            settingsModule = "pkl:settings"
            ${kotlinPackage?.let { "kotlinPackage = \"$it\"" } ?: ""}
          }
        }
      }
    """
    )
  }
  
  private fun writePklFile() {
    writeFile(
      "mod.pkl", """
      module org.mod

      class Person {
        name: String
        addresses: List<Address>
      }

      // "open" to test generating regular class
      open class Address {
        street: String
        zip: Int
      }

      other = 42
    """
Repository: apple/pkl
File: pkl-core/src/test/kotlin/org/pkl/core/RepositoryHygiene.kt (Kotlin)

Code before:
    val inputs = input.walk().filter {
      it.extension == "pkl"
    }.map {
      val path = input.relativize(it).toString()
      inputRegex.replace(path, "$1$2")
    }.collect(Collectors.toSet())

    val output = snippetsFolder.resolve("output")
    output.walk().filter { it.isRegularFile() }.forEach {
      val out = output.relativize(it).toString()
      checkOutputHasInput(inputs, out)
    }
  }

  private fun checkOutputHasInput(inputs: Set<String>, output: String) {
    val fileTocheck = outputRegex.replace(output, "$1.pkl")
    assertThat(inputs).contains(fileTocheck)
  }

  private val snippetsFolder: Path by lazy {
    FileTestUtils.rootProjectDir.resolve("pkl-core/src/test/files/LanguageSnippetTests")
  }

  companion object {
    private val inputRegex = Regex("(.*)[.][^.]*([.]pkl)")
    private val outputRegex = Regex("(.*)[.][^.]+$")
  }
}


Review comment (suggestion):
[nit] this seems a little easier to understand

```suggestion
    private val inputRegex = Regex("(.*)\\.[^.]*(\\.pkl)")
    private val outputRegex = Regex("(.*)\\.[^.]+$")
```

Code after:
    val inputs = input.walk().filter {
      it.extension == "pkl"
    }.map {
      val path = input.relativize(it).toString()
      inputRegex.replace(path, "$1$2")
    }.collect(Collectors.toSet())

    val output = snippetsFolder.resolve("output")
    output.walk().filter { it.isRegularFile() }.forEach {
      val out = output.relativize(it).toString()
      checkOutputHasInput(inputs, out)
    }
  }

  private fun checkOutputHasInput(inputs: Set<String>, output: String) {
    val fileTocheck = outputRegex.replace(output, "$1.pkl")
    assertThat(inputs).contains(fileTocheck)
  }

  private val snippetsFolder: Path by lazy {
    FileTestUtils.rootProjectDir.resolve("pkl-core/src/test/files/LanguageSnippetTests")
  }

  companion object {
    private val inputRegex = Regex("(.*)\\.[^.]*(\\.pkl)")
    private val outputRegex = Regex("(.*)\\.[^.]+$")
  }
}
Repository: apple/pkl
File: pkl-commons-test/pkl-commons-test.gradle.kts (Kotlin)

Code before:
  outputs.file(outputFile)
  mainClass.set("sun.security.tools.keytool.Main")
  args = listOf(
    "-genkeypair",
    "-keyalg", "RSA",
    "-alias", "integ_tests",
    "-keystore", "localhost.p12",
    "-storepass", "password",
    "-dname", "CN=localhost"
  )
  workingDir = file("$buildDir/keystore/")
  onlyIf { !outputFile.exists() }
  doFirst {
    workingDir.mkdirs()
  }
}

val generateCerts by tasks.registering(JavaExec::class) {
  dependsOn("generateKeys")
  val outputFile = file("$buildDir/keystore/localhost.pem")
  outputs.file(outputFile)
  mainClass.set("sun.security.tools.keytool.Main")
  args = listOf(
    "-exportcert",
    "-alias", "integ_tests",
    "-storepass", "password",
    "-keystore", "localhost.p12",
    "-rfc",
    "-file", "localhost.pem"
  )
  workingDir = file("$buildDir/keystore/")
  onlyIf { !outputFile.exists() }
  doFirst {
    workingDir.mkdirs()
  }
}


Review comment (suggestion):
While we are here changing things:

```suggestion
fun toHex(hash: ByteArray): String {
  val hexDigitTable = charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f')
  return buildString(hash.size * 2) {
    for (b in hash) {
      append(hexDigitTable[b.toInt() shr 4 and 0xF])
      append(hexDigitTable[b.toInt() and 0xF])
    }
  }
}
```

Code after:
  outputs.file(outputFile)
  mainClass.set("sun.security.tools.keytool.Main")
  args = listOf(
    "-exportcert",
    "-alias", "integ_tests",
    "-storepass", "password",
    "-keystore", keystoreName,
    "-rfc",
    "-file", certsFileName
  )
  workingDir = keystoreDir
  doFirst {
    workingDir.mkdirs()
    outputFile.delete()
  }
}

fun toHex(hash: ByteArray): String {
  val hexDigitTable = charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f')
  return buildString(hash.size * 2) {
    for (b in hash) {
      append(hexDigitTable[b.toInt() shr 4 and 0xF])
      append(hexDigitTable[b.toInt() and 0xF])
    }
  }
}

fun File.computeChecksum(): String {
  val md = MessageDigest.getInstance("SHA-256")
  val hash = md.digest(readBytes())
  return toHex(hash)
}
Repository: apple/pkl
File: pkl-executor/pkl-executor.gradle.kts (Kotlin)

Code before:
tasks.named<Jar>("sourcesJar") {
  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

publishing {
  publications {
    named<MavenPublication>("library") {
      pom {
        url.set("https://github.com/apple/pkl/tree/main/pkl-executor")
        description.set("""
          Library for executing Pkl code in a sandboxed environment.
        """.trimIndent())
      }
    }
  }
}

sourceSets {
  main {
    java {
      srcDir("src/main/java")
    }
  }
}

val copyHistoricalDistribution by tasks.registering(Copy::class) {
  from(pklDistribution025)
  into(layout.buildDirectory.dir("pklDistributions"))
}

// this task could be folded into tasks.test by switching to IntelliJ's Gradle test runner
val prepareTest by tasks.registering {
  // used by EmbeddedExecutorTest
  dependsOn(pklDistributionCurrent, copyHistoricalDistribution)
}

tasks.test {
  dependsOn(prepareTest)
  systemProperty("pklDistributionCurrent", pklDistributionCurrent.singleFile)
  systemProperty("pklDistribution025", pklDistribution025.singleFile)
}


Review comment (suggestion):
Should match the configuration name (which can of course be renamed). What's needed is a distribution that doesn't have ExecutorSpiOptions2. That's why I used the overly specific name `025`.

Code after:
// `Entry org/pkl/executor/EmbeddedExecutor.java is a duplicate but no duplicate handling strategy has been set.`
// However, we do not have multiple of these Java files.
tasks.named<Jar>("sourcesJar") {
  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

publishing {
  publications {
    named<MavenPublication>("library") {
      pom {
        url.set("https://github.com/apple/pkl/tree/main/pkl-executor")
        description.set("""
          Library for executing Pkl code in a sandboxed environment.
        """.trimIndent())
      }
    }
  }
}

sourceSets {
  main {
    java {
      srcDir("src/main/java")
    }
  }
}

val prepareHistoricalDistributions by tasks.registering {
  val outputDir = layout.buildDirectory.dir("pklHistoricalDistributions")
  inputs.files(pklHistoricalDistributions.files())
  outputs.dir(outputDir)
  doLast {
    val distributionDir = outputDir.get().asFile.toPath()
      .also(Files::createDirectories)
    for (file in pklHistoricalDistributions.files) {
      val link = distributionDir.resolve(file.name)
      if (!Files.isSymbolicLink(link)) {
        if (Files.exists(link)) {
          Files.delete(link)
        }
        Files.createSymbolicLink(link, file.toPath())
      }
    }
  }
}

val prepareTest by tasks.registering {
  dependsOn(pklDistributionCurrent, prepareHistoricalDistributions)
}

tasks.test {
Repository: apple/pkl
File: pkl-config-java/pkl-config-java.gradle.kts (Kotlin)

Code before:
plugins {
  pklAllProjects
  pklJavaLibrary
  pklFatJar
  pklPublishLibrary
  signing
}

val pklCodegenJava: Configuration by configurations.creating
val firstPartySourcesJars by configurations.existing

val generateTestConfigClasses by tasks.registering(JavaExec::class) {
  val outputDir = layout.buildDirectory.dir("testConfigClasses")
  outputs.dir(outputDir)
  inputs.dir("src/test/resources/codegenPkl")

  classpath = pklCodegenJava
  mainClass.set("org.pkl.codegen.java.Main")
  argumentProviders.add(CommandLineArgumentProvider {
    listOf(
      "--output-dir", outputDir.get().asFile.absolutePath,
      "--generate-javadoc"
    ) + fileTree("src/test/resources/codegenPkl").map { it.absolutePath }
  })
}

tasks.processTestResources {
  dependsOn(generateTestConfigClasses)
}

tasks.compileTestKotlin {
  dependsOn(generateTestConfigClasses)
}

val bundleTests by tasks.registering(Jar::class) {
  from(sourceSets.test.get().output)
}

// Runs unit tests using jar'd class files as a source.
// This is to test loading the ClassRegistry from within a jar, as opposed to directly from the file system.
val testFromJar by tasks.registering(Test::class) {
  dependsOn(bundleTests)

  testClassesDirs = files(tasks.test.get().testClassesDirs)

Review comment (suggestion):
Using an argument provider has no real benefits here.
This should be good enough:
```
args("--output-dir", outputDir.get().asFile)
args("--generate-javadoc")
args(fileTree("src/test/resources/codegenPkl"))
```

By the way, I don't think these files belong into `src/test/resources`.

Code after:
plugins {
  pklAllProjects
  pklJavaLibrary
  pklFatJar
  pklPublishLibrary
  signing
}

val pklCodegenJava: Configuration by configurations.creating
val firstPartySourcesJars by configurations.existing

val generateTestConfigClasses by tasks.registering(JavaExec::class) {
  val outputDir = layout.buildDirectory.dir("testConfigClasses")
  outputs.dir(outputDir)
  inputs.dir("src/test/resources/codegenPkl")

  classpath = pklCodegenJava
  mainClass.set("org.pkl.codegen.java.Main")
  argumentProviders.add(CommandLineArgumentProvider {
    listOf(
      "--output-dir", outputDir.get().asFile.path,
      "--generate-javadoc"
    ) + fileTree("src/test/resources/codegenPkl").map { it.path }
  })
}

tasks.processTestResources {
  dependsOn(generateTestConfigClasses)
}

tasks.compileTestKotlin {
  dependsOn(generateTestConfigClasses)
}

val bundleTests by tasks.registering(Jar::class) {
  from(sourceSets.test.get().output)
}

// Runs unit tests using jar'd class files as a source.
// This is to test loading the ClassRegistry from within a jar, as opposed to directly from the file system.
val testFromJar by tasks.registering(Test::class) {
  dependsOn(bundleTests)

  testClassesDirs = files(tasks.test.get().testClassesDirs)
Repository: apple/pkl
File: pkl-config-java/pkl-config-java.gradle.kts (Kotlin)

Code before:
plugins {
  pklAllProjects
  pklJavaLibrary
  pklFatJar
  pklPublishLibrary
  signing
}

val pklCodegenJava: Configuration by configurations.creating
val firstPartySourcesJars by configurations.existing

val generateTestConfigClasses by tasks.registering(JavaExec::class) {
  val outputDir = layout.buildDirectory.dir("testConfigClasses")
  outputs.dir(outputDir)
  inputs.dir("src/test/resources/codegenPkl")

  classpath = pklCodegenJava
  mainClass.set("org.pkl.codegen.java.Main")
  argumentProviders.add(CommandLineArgumentProvider {
    listOf(
      "--output-dir", outputDir.get().asFile.absolutePath,
      "--generate-javadoc"
    ) + fileTree("src/test/resources/codegenPkl").map { it.absolutePath }
  })
}

tasks.processTestResources {
  dependsOn(generateTestConfigClasses)
}

tasks.compileTestKotlin {
  dependsOn(generateTestConfigClasses)
}

val bundleTests by tasks.registering(Jar::class) {
  from(sourceSets.test.get().output)
}

// Runs unit tests using jar'd class files as a source.
// This is to test loading the ClassRegistry from within a jar, as opposed to directly from the file system.
val testFromJar by tasks.registering(Test::class) {
  dependsOn(bundleTests)

  testClassesDirs = files(tasks.test.get().testClassesDirs)

  classpath =

Review comment (bug):
It's always safe to use `.path` instead of `.absolutePath` in Gradle build scripts.
If a build script mistakenly creates a relative `File` by using `File("relative/path")` instead of `file("relative/path")`,
and Gradle doesn't get a chance to convert it to an absolute `File`,
`.absolutePath` won't save the day because it will use the wrong base path (current working dir instead of `project.dir`).

Code after:
plugins {
  pklAllProjects
  pklJavaLibrary
  pklFatJar
  pklPublishLibrary
  signing
}

val pklCodegenJava: Configuration by configurations.creating
val firstPartySourcesJars by configurations.existing

val generateTestConfigClasses by tasks.registering(JavaExec::class) {
  val outputDir = layout.buildDirectory.dir("testConfigClasses")
  outputs.dir(outputDir)
  inputs.dir("src/test/resources/codegenPkl")

  classpath = pklCodegenJava
  mainClass.set("org.pkl.codegen.java.Main")
  argumentProviders.add(CommandLineArgumentProvider {
    listOf(
      "--output-dir", outputDir.get().asFile.path,
      "--generate-javadoc"
    ) + fileTree("src/test/resources/codegenPkl").map { it.path }
  })
}

tasks.processTestResources {
  dependsOn(generateTestConfigClasses)
}

tasks.compileTestKotlin {
  dependsOn(generateTestConfigClasses)
}

val bundleTests by tasks.registering(Jar::class) {
  from(sourceSets.test.get().output)
}

// Runs unit tests using jar'd class files as a source.
// This is to test loading the ClassRegistry from within a jar, as opposed to directly from the file system.
val testFromJar by tasks.registering(Test::class) {
  dependsOn(bundleTests)

  testClassesDirs = files(tasks.test.get().testClassesDirs)

  classpath =
Repository: apple/pkl
File: pkl-gradle/src/main/java/org/pkl/gradle/task/EvalTask.java (Java)

Code before:

  @Input
  @Optional
  public abstract Property<String> getModuleOutputSeparator();

  @Input
  @Optional
  public abstract Property<String> getExpression();

  @Inject
  public abstract ObjectFactory getObjectFactory();

  private CliEvaluator getCliEvaluator() {
    return new CliEvaluator(
        new CliEvaluatorOptions(
            getCliBaseOptions(),
            getOutputFile().get().getAsFile().getAbsolutePath(),
            getOutputFormat().get(),
            getModuleOutputSeparator().get(),
            mapAndGetOrNull(getMultipleFileOutputDir(), (it) -> it.getAsFile().getAbsolutePath()),
            getExpression().get()));
  }

  @OutputFiles
  @Optional
  public SetProperty<File> getOutputPaths() {
    var ret = getObjectFactory().setProperty(File.class);
    ret.value(getCliEvaluator().getOutputFiles()).disallowChanges();
    return ret;
  }

  @OutputDirectories
  @Optional
  public SetProperty<File> getMultipleFileOutputPaths() {
    var ret = getObjectFactory().setProperty(File.class);
    ret.value(getCliEvaluator().getOutputDirectories()).disallowChanges();
    return ret;
  }

  @Override
  protected void doRunTask() {
    //noinspection ResultOfMethodCallIgnored
    getOutputs().getPreviousOutputFiles().forEach(File::delete);
    getCliEvaluator().run();
  }
}


Review comment (suggestion):
Would `getEffectiveOutputFiles()` be a better name? Makes clear that it’s related to `getOutputFile()` and not meant to be configured directly.

Code after:

  @Input
  public abstract Property<String> getOutputFormat();

  @Input
  public abstract Property<String> getModuleOutputSeparator();

  @Input
  public abstract Property<String> getExpression();

  private final Provider<CliEvaluator> cliEvaluator =
      getProviders()
          .provider(
              () ->
                  new CliEvaluator(
                      new CliEvaluatorOptions(
                          getCliBaseOptions(),
                          getOutputFile().get().getAsFile().getAbsolutePath(),
                          getOutputFormat().get(),
                          getModuleOutputSeparator().get(),
                          mapAndGetOrNull(
                              getMultipleFileOutputDir(), it -> it.getAsFile().getAbsolutePath()),
                          getExpression().get())));

  @SuppressWarnings("unused")
  @OutputFiles
  @Optional
  public FileCollection getEffectiveOutputFiles() {
    return getObjects()
        .fileCollection()
        .from(cliEvaluator.map(e -> nullToEmpty(e.getOutputFiles())));
  }

  @OutputDirectories
  @Optional
  public FileCollection getEffectiveOutputDirs() {
    return getObjects()
        .fileCollection()
        .from(cliEvaluator.map(e -> nullToEmpty(e.getOutputDirectories())));
  }

  private static <T> Set<T> nullToEmpty(@Nullable Set<T> set) {
    return set == null ? Collections.emptySet() : set;
  }

  @Override
  protected void doRunTask() {
    //noinspection ResultOfMethodCallIgnored
    getOutputs().getPreviousOutputFiles().forEach(File::delete);
    cliEvaluator.get().run();
  }
Repository: apple/pkl
File: pkl-gradle/src/test/kotlin/org/pkl/gradle/EvaluatorsTest.kt (Kotlin)

Code before:
        baseUri = "package://localhost:0/\(name)"
        version = "1.0.0"
        packageZipUrl = "https://localhost:0/\(name)@\(version).zip"
      }
    """
        .trimIndent()
    )

    writeFile(
      "proj2/PklProject",
      """
      amends "pkl:Project"
      
      package {
        name = "proj2"
        baseUri = "package://localhost:0/\(name)"
        version = "1.0.0"
        packageZipUrl = "https://localhost:0/\(name)@\(version).zip"
      }
    """
        .trimIndent()
    )

    writeFile(
      "proj1/PklProject.deps.json",
      """
      {
        "schemaVersion": 1,
        "resolvedDependencies": {
          "package://localhost:0/proj2@1": {
            "type": "local",
            "uri": "projectpackage://localhost:0/proj2@1.0.0",
            "path": "../proj2"
          }
        }
      }
    """
        .trimIndent()
    )

    writeFile(
      "proj2/PklProject.deps.json",
      """
      {
        "schemaVersion": 1,
        "resolvedDependencies": {}
      }
    """
        .trimIndent()
    )


Review comment (suggestion):
This should not be necessary - it is idiomatic to depend on a task rather than on a specific output property, and also it is not really possible for these properties to be non-empty at the same time, so there is no ambiguity.

Code after:
      package {
        name = "proj1"
        baseUri = "package://localhost:0/\(name)"
        version = "1.0.0"
        packageZipUrl = "https://localhost:0/\(name)@\(version).zip"
      }
    """
        .trimIndent()
    )

    writeFile(
      "proj2/PklProject",
      """
      amends "pkl:Project"
      
      package {
        name = "proj2"
        baseUri = "package://localhost:0/\(name)"
        version = "1.0.0"
        packageZipUrl = "https://localhost:0/\(name)@\(version).zip"
      }
    """
        .trimIndent()
    )

    writeFile(
      "proj1/PklProject.deps.json",
      """
      {
        "schemaVersion": 1,
        "resolvedDependencies": {
          "package://localhost:0/proj2@1": {
            "type": "local",
            "uri": "projectpackage://localhost:0/proj2@1.0.0",
            "path": "../proj2"
          }
        }
      }
    """
        .trimIndent()
    )

    writeFile(
      "proj2/PklProject.deps.json",
      """
      {
        "schemaVersion": 1,
        "resolvedDependencies": {}
      }
    """
        .trimIndent()
Repository: apple/pkl
File: pkl-core/pkl-core.gradle.kts (Kotlin)

Code before:
  classpath = tasks.test.get().classpath

  useJUnitPlatform {
    includeEngines("LinuxAarch64LanguageSnippetTestsEngine")
  }
}

val testAlpineExecutableAmd64 by tasks.registering(Test::class) {
  enabled = buildInfo.os.isLinux && buildInfo.arch == "amd64" && buildInfo.hasMuslToolchain
  dependsOn(":pkl-cli:alpineExecutableAmd64")

  inputs.dir("src/test/files/LanguageSnippetTests/input")
  inputs.dir("src/test/files/LanguageSnippetTests/input-helper")
  inputs.dir("src/test/files/LanguageSnippetTests/output")

  testClassesDirs = files(tasks.test.get().testClassesDirs)
  classpath = tasks.test.get().classpath

  useJUnitPlatform {
    includeEngines("AlpineLanguageSnippetTestsEngine")
  }
}

tasks.testNative {
  dependsOn(testLinuxExecutableAmd64)
  dependsOn(testLinuxExecutableAarch64)
  dependsOn(testMacExecutableAmd64)
  dependsOn(testMacExecutableAarch64)
  dependsOn(testAlpineExecutableAmd64)
}

tasks.clean {
  delete("generated/")
  delete(layout.buildDirectory.dir("test-packages"))
}

spotless {
  antlr4 {
    licenseHeaderFile(rootProject.file("buildSrc/src/main/resources/license-header.star-block.txt"))
    target(files("src/main/antlr/PklParser.g4", "src/main/antlr/PklLexer.g4"))
  }
}


Review comment (suggestion):
```suggestion
    buildInfo.os.isMacOsX -> {
      dependsOn(testMacExecutableAarch64)
      dependsOn(testMacExecutableAmd64)
    }
```

Code after:
  }
}

val testAlpineExecutableAmd64 by tasks.registering(Test::class) {
  dependsOn(":pkl-cli:alpineExecutableAmd64")

  inputs.dir("src/test/files/LanguageSnippetTests/input")
  inputs.dir("src/test/files/LanguageSnippetTests/input-helper")
  inputs.dir("src/test/files/LanguageSnippetTests/output")

  testClassesDirs = files(tasks.test.get().testClassesDirs)
  classpath = tasks.test.get().classpath

  useJUnitPlatform {
    includeEngines("AlpineLanguageSnippetTestsEngine")
  }
}

tasks.testNative {
  when {
    buildInfo.os.isMacOsX -> {
      dependsOn(testMacExecutableAmd64)
      if (buildInfo.arch == "aarch64") {
        dependsOn(testMacExecutableAarch64)
      }
    }
    buildInfo.os.isLinux && buildInfo.arch == "aarch64" -> {
      dependsOn(testLinuxExecutableAarch64)
    }
    buildInfo.os.isLinux && buildInfo.arch == "amd64" -> {
      dependsOn(testLinuxExecutableAmd64)
      if (buildInfo.hasMuslToolchain) {
        dependsOn(testAlpineExecutableAmd64)
      }
    }
  }
}

tasks.clean {
  delete("generated/")
  delete(layout.buildDirectory.dir("test-packages"))
}

spotless {
  antlr4 {
    licenseHeaderFile(rootProject.file("buildSrc/src/main/resources/license-header.star-block.txt"))
    target(files("src/main/antlr/PklParser.g4", "src/main/antlr/PklLexer.g4"))
  }
}