feat: allow for specifying ATs for upstream sources

These changes provide fork developers with a way to specify an AT file (or have it detected automatically) for upstream sources,
such as `paper-server` and `paper-api` for a fork of Paper.
This allows fork developers to benefit from using ATs while modifying these sources without needing to clutter patches,
with lots of manual access transforms, and as such this greatly improves the overall comfort of making more involving changes,
in the sources. It also allows for fork devs to be able to organize ATs in one place which makes it easier to review later.

The implementation proposed in this commit works as follows:
1. Derive the location of the build-data dir from the output dir specified in the PatchRepo/Directory's config.
2. Search for an AT file, by the name of the patch repo/directory as specified.
3. Apply them before applying source patches.

The locations in steps 1 and 2 can be overriden per patch repo/directory by just overriding the val.

In order to achieve this change, we introduce a new task, with its implementation sitting in SetupForkUpstreamSources which applies those ATs.
Everything else not explained here or even explained should follow the behaviour of AT application for minecraft sources.

The change has been tested in production in an organisation fork of paperweight for over 6 months with both a nested fork project that uses them heavily and then fork projects depending on the nested fork project,
and no issues have been reported or arose, so i'm confident that this implementation will work properly.

Author: Toffikk

paperweight-core/src/main/kotlin/io/papermc/paperweight/core/extension/UpstreamConfig.kt

@@ -35,6 +35,7 @@ import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
+import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.provider.SetProperty
 import org.gradle.kotlin.dsl.*
 
@@ -93,6 +94,7 @@ abstract class UpstreamConfig @Inject constructor(
 
     abstract class DirectoryPatchSet @Inject constructor(
         objects: ObjectFactory,
+        providers: ProviderFactory,
         private val setName: String,
     ) : Named {
         override fun getName(): String = setName
@@ -101,6 +103,8 @@ abstract class UpstreamConfig @Inject constructor(
         abstract val excludes: SetProperty<String>
 
         abstract val outputDir: DirectoryProperty
+        val buildDataDir: DirectoryProperty = objects.directoryProperty().convention(outputDir.dir("../build-data"))
+        val additionalAts: RegularFileProperty = objects.fileFrom(buildDataDir, providers.provider { "$name.at" })
 
         abstract val patchesDir: DirectoryProperty
         val rejectsDir: DirectoryProperty = objects.dirFrom(patchesDir, "rejected")
@@ -110,8 +114,9 @@ abstract class UpstreamConfig @Inject constructor(
 
     abstract class RepoPatchSet @Inject constructor(
         objects: ObjectFactory,
+        providers: ProviderFactory,
         name: String,
-    ) : DirectoryPatchSet(objects, name) {
+    ) : DirectoryPatchSet(objects, providers, name) {
         abstract val upstreamRepo: Property<DirectoryPatchSet>
 
         fun Provider<ForkConfig>.patchedRepo(name: String): Provider<DirectoryPatchSet> =

paperweight-core/src/main/kotlin/io/papermc/paperweight/core/taskcontainers/PatchingTasks.kt

@@ -22,19 +22,22 @@
 
 package io.papermc.paperweight.core.taskcontainers
 
+import io.papermc.paperweight.core.tasks.SetupForkUpstreamSources
 import io.papermc.paperweight.core.tasks.patching.ApplyFeaturePatches
 import io.papermc.paperweight.core.tasks.patching.ApplyFilePatches
 import io.papermc.paperweight.core.tasks.patching.ApplyFilePatchesFuzzy
 import io.papermc.paperweight.core.tasks.patching.FixupFilePatches
 import io.papermc.paperweight.core.tasks.patching.RebuildFilePatches
 import io.papermc.paperweight.tasks.*
 import io.papermc.paperweight.util.*
+import io.papermc.paperweight.util.constants.JST_CONFIG
 import io.papermc.paperweight.util.constants.paperTaskOutput
 import java.nio.file.Path
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskContainer
 import org.gradle.kotlin.dsl.*
@@ -48,6 +51,7 @@ class PatchingTasks(
     private val filePatchDir: DirectoryProperty,
     private val rejectsDir: DirectoryProperty,
     private val featurePatchDir: DirectoryProperty,
+    private val additionalAts: RegularFileProperty,
     private val baseDir: Provider<Directory>,
     private val gitFilePatches: Provider<Boolean>,
     private val filterPatches: Provider<Boolean>,
@@ -110,6 +114,40 @@ class PatchingTasks(
         }
     }
 
+    fun setupUpstream() {
+        val collectAccessTransform = tasks.register<CollectATsFromPatches>("collect${namePart}ATsFromPatches") {
+            patchDir.set(this@PatchingTasks.featurePatchDir.fileExists())
+        }
+
+        val mergeCollectedAts = tasks.register<MergeAccessTransforms>("merge${namePart}ATs") {
+            firstFile.set(additionalAts.fileExists())
+            secondFile.set(collectAccessTransform.flatMap { it.outputFile })
+        }
+
+        val setup = tasks.register<SetupForkUpstreamSources>("run${namePart}Setup") {
+            description = "Applies $forkName ATs to $namePart sources"
+            inputDir.set(baseDir)
+            outputDir.set(layout.cache.resolve(paperTaskOutput()))
+            identifier.set(namePart)
+            atFile.set(mergeCollectedAts.flatMap { it.outputFile })
+            ats.jst.from(project.configurations.named(JST_CONFIG))
+        }
+
+        applyFilePatches.configure {
+            input.set(setup.flatMap { it.outputDir })
+        }
+
+        applyFilePatchesFuzzy.configure {
+            input.set(setup.flatMap { it.outputDir })
+        }
+        val name = "rebuild${namePart}FilePatches"
+        if (name in tasks.names) {
+            tasks.named<RebuildFilePatches>(name) {
+                base.set(setup.flatMap { it.outputDir })
+            }
+        }
+    }
+
     private fun setupWritable() {
         listOf(
             applyFilePatches,

paperweight-core/src/main/kotlin/io/papermc/paperweight/core/taskcontainers/UpstreamConfigTasks.kt

@@ -118,7 +118,7 @@ class UpstreamConfigTasks(
             createBaseFromDirectoryInRepo(cfg)
         }
 
-        return PatchingTasks(
+        val tasks = PatchingTasks(
             target,
             forkName,
             cfg.name,
@@ -127,11 +127,14 @@ class UpstreamConfigTasks(
             cfg.filePatchDir,
             cfg.rejectsDir,
             cfg.featurePatchDir,
+            cfg.additionalAts,
             base,
             gitFilePatches,
             filterPatches,
             cfg.outputDir.path,
         )
+        tasks.setupUpstream()
+        return tasks
     }
 
     private fun createBaseFromRepo(cfg: UpstreamConfig.RepoPatchSet): Provider<Directory> {

paperweight-core/src/main/kotlin/io/papermc/paperweight/core/tasks/SetupForkUpstreamSources.kt

@@ -0,0 +1,85 @@
+/*
+ * paperweight is a Gradle plugin for the PaperMC project.
+ *
+ * Copyright (c) 2023 Kyle Wood (DenWav)
+ *                    Contributors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 only, no later versions.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+ * USA
+ */
+
+package io.papermc.paperweight.core.tasks
+
+import io.papermc.paperweight.core.util.ApplySourceATs
+import io.papermc.paperweight.tasks.*
+import io.papermc.paperweight.util.*
+import kotlin.io.path.*
+import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.lib.PersonIdent
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Nested
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.gradle.kotlin.dsl.*
+
+abstract class SetupForkUpstreamSources : JavaLauncherTask() {
+
+    @get:InputDirectory
+    abstract val inputDir: DirectoryProperty
+
+    @get:OutputDirectory
+    abstract val outputDir: DirectoryProperty
+
+    @get:Nested
+    val ats: ApplySourceATs = objects.newInstance()
+
+    @get:InputFile
+    @get:Optional
+    abstract val atFile: RegularFileProperty
+
+    @get:Input
+    abstract val identifier: Property<String>
+
+    @TaskAction
+    fun run() {
+        val out = outputDir.path.cleanDir()
+        inputDir.path.copyRecursivelyTo(out)
+
+        val git = Git.open(outputDir.path.toFile())
+
+        if (atFile.isPresent && atFile.path.readText().isNotBlank()) {
+            println("Applying access transformers...")
+            ats.run(
+                launcher.get(),
+                inputDir.path,
+                outputDir.path,
+                atFile.path,
+                temporaryDir.toPath(),
+            )
+            commitAndTag(git, "ATs", "${identifier.get()} ATs")
+        }
+        val ident = PersonIdent("base", "noreply+automated@papermc.io")
+        git.tagDelete().setTags("base").call()
+        git.tag().setName("base").setTagger(ident).setSigned(false).call()
+
+        git.close()
+    }
+}