Revert "Use turbine instead of kapt for kotlin annotation processors"
* not the most ideal, but aosp broke compilation of kotlin with an insanely obscure error. Till that is fixed
This reverts commit f61766e98797a00d06071e5120d0b67aa3014ebd.
diff --git a/java/builder.go b/java/builder.go
index c0fadd4..1a115a4 100644
--- a/java/builder.go
+++ b/java/builder.go
@@ -131,11 +131,11 @@
turbine, turbineRE = pctx.RemoteStaticRules("turbine",
blueprint.RuleParams{
- Command: `$reTemplate${config.JavaCmd} ${config.JavaVmFlags} -jar ${config.TurbineJar} $outputFlags ` +
+ Command: `$reTemplate${config.JavaCmd} ${config.JavaVmFlags} -jar ${config.TurbineJar} --output $out.tmp ` +
`--sources @$out.rsp --source_jars $srcJars ` +
`--javacopts ${config.CommonJdkFlags} ` +
- `$javacFlags -source $javaVersion -target $javaVersion -- $turbineFlags && ` +
- `(for o in $outputs; do if cmp -s $${o}.tmp $${o} ; then rm $${o}.tmp ; else mv $${o}.tmp $${o} ; fi; done )`,
+ `$javacFlags -source $javaVersion -target $javaVersion -- $bootClasspath $classpath && ` +
+ `(if cmp -s $out.tmp $out ; then rm $out.tmp ; else mv $out.tmp $out ; fi )`,
CommandDeps: []string{
"${config.TurbineJar}",
"${config.JavaCmd}",
@@ -148,11 +148,10 @@
ExecStrategy: "${config.RETurbineExecStrategy}",
Inputs: []string{"${config.TurbineJar}", "${out}.rsp", "$implicits"},
RSPFiles: []string{"${out}.rsp"},
- OutputFiles: []string{"$rbeOutputs"},
+ OutputFiles: []string{"$out.tmp"},
ToolchainInputs: []string{"${config.JavaCmd}"},
Platform: map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
- },
- []string{"javacFlags", "turbineFlags", "outputFlags", "javaVersion", "outputs", "rbeOutputs", "srcJars"}, []string{"implicits"})
+ }, []string{"javacFlags", "bootClasspath", "classpath", "srcJars", "javaVersion"}, []string{"implicits"})
jar, jarRE = pctx.RemoteStaticRules("jar",
blueprint.RuleParams{
@@ -355,8 +354,11 @@
})
}
-func turbineFlags(ctx android.ModuleContext, flags javaBuilderFlags) (string, android.Paths) {
+func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.WritablePath,
+ srcFiles, srcJars android.Paths, flags javaBuilderFlags) {
+
var deps android.Paths
+ deps = append(deps, srcJars...)
classpath := flags.classpath
@@ -378,31 +380,19 @@
}
deps = append(deps, classpath...)
- turbineFlags := bootClasspath + " " + classpath.FormTurbineClassPath("--classpath ")
-
- return turbineFlags, deps
-}
-
-func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.WritablePath,
- srcFiles, srcJars android.Paths, flags javaBuilderFlags) {
-
- turbineFlags, deps := turbineFlags(ctx, flags)
-
- deps = append(deps, srcJars...)
+ deps = append(deps, flags.processorPath...)
rule := turbine
args := map[string]string{
- "javacFlags": flags.javacFlags,
- "srcJars": strings.Join(srcJars.Strings(), " "),
- "javaVersion": flags.javaVersion.String(),
- "turbineFlags": turbineFlags,
- "outputFlags": "--output " + outputFile.String() + ".tmp",
- "outputs": outputFile.String(),
+ "javacFlags": flags.javacFlags,
+ "bootClasspath": bootClasspath,
+ "srcJars": strings.Join(srcJars.Strings(), " "),
+ "classpath": classpath.FormTurbineClassPath("--classpath "),
+ "javaVersion": flags.javaVersion.String(),
}
if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_TURBINE") {
rule = turbineRE
args["implicits"] = strings.Join(deps.Strings(), ",")
- args["rbeOutputs"] = outputFile.String() + ".tmp"
}
ctx.Build(pctx, android.BuildParams{
Rule: rule,
@@ -414,47 +404,6 @@
})
}
-// TurbineApt produces a rule to run annotation processors using turbine.
-func TurbineApt(ctx android.ModuleContext, outputSrcJar, outputResJar android.WritablePath,
- srcFiles, srcJars android.Paths, flags javaBuilderFlags) {
-
- turbineFlags, deps := turbineFlags(ctx, flags)
-
- deps = append(deps, srcJars...)
-
- deps = append(deps, flags.processorPath...)
- turbineFlags += " " + flags.processorPath.FormTurbineClassPath("--processorpath ")
- turbineFlags += " --processors " + strings.Join(flags.processors, " ")
-
- outputs := android.WritablePaths{outputSrcJar, outputResJar}
- outputFlags := "--gensrc_output " + outputSrcJar.String() + ".tmp " +
- "--resource_output " + outputResJar.String() + ".tmp"
-
- rule := turbine
- args := map[string]string{
- "javacFlags": flags.javacFlags,
- "srcJars": strings.Join(srcJars.Strings(), " "),
- "javaVersion": flags.javaVersion.String(),
- "turbineFlags": turbineFlags,
- "outputFlags": outputFlags,
- "outputs": strings.Join(outputs.Strings(), " "),
- }
- if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_TURBINE") {
- rule = turbineRE
- args["implicits"] = strings.Join(deps.Strings(), ",")
- args["rbeOutputs"] = outputSrcJar.String() + ".tmp," + outputResJar.String() + ".tmp"
- }
- ctx.Build(pctx, android.BuildParams{
- Rule: rule,
- Description: "turbine apt",
- Output: outputs[0],
- ImplicitOutputs: outputs[1:],
- Inputs: srcFiles,
- Implicits: deps,
- Args: args,
- })
-}
-
// transformJavaToClasses takes source files and converts them to a jar containing .class files.
// srcFiles is a list of paths to sources, srcJars is a list of paths to jar files that contain
// sources. flags contains various command line flags to be passed to the compiler.
@@ -716,6 +665,6 @@
} else if forceEmpty {
return `--bootclasspath ""`, nil
} else {
- return "--system ${config.JavaHome}", nil
+ return "", nil
}
}
diff --git a/java/java_test.go b/java/java_test.go
index af889cc..5b6062c 100644
--- a/java/java_test.go
+++ b/java/java_test.go
@@ -973,7 +973,7 @@
fooHeaderJar := filepath.Join("out", "soong", ".intermediates", "foo", "android_common", "turbine-combined", "foo.jar")
barTurbineJar := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine", "bar.jar")
- android.AssertStringDoesContain(t, "bar turbine classpath", barTurbine.Args["turbineFlags"], fooHeaderJar)
+ android.AssertStringDoesContain(t, "bar turbine classpath", barTurbine.Args["classpath"], fooHeaderJar)
android.AssertStringDoesContain(t, "bar javac classpath", barJavac.Args["classpath"], fooHeaderJar)
android.AssertPathsRelativeToTopEquals(t, "bar turbine combineJar", []string{barTurbineJar, fooHeaderJar}, barTurbineCombined.Inputs)
android.AssertStringDoesContain(t, "baz javac classpath", bazJavac.Args["classpath"], "prebuilts/sdk/14/public/android.jar")
diff --git a/java/kotlin.go b/java/kotlin.go
index 903c624..053b832 100644
--- a/java/kotlin.go
+++ b/java/kotlin.go
@@ -126,7 +126,7 @@
})
}
-var kaptStubs = pctx.AndroidRemoteStaticRule("kaptStubs", android.RemoteRuleSupports{Goma: true},
+var kapt = pctx.AndroidRemoteStaticRule("kapt", android.RemoteRuleSupports{Goma: true},
blueprint.RuleParams{
Command: `rm -rf "$srcJarDir" "$kotlinBuildFile" "$kaptDir" && ` +
`mkdir -p "$srcJarDir" "$kaptDir/sources" "$kaptDir/classes" && ` +
@@ -141,12 +141,13 @@
`-P plugin:org.jetbrains.kotlin.kapt3:classes=$kaptDir/classes ` +
`-P plugin:org.jetbrains.kotlin.kapt3:stubs=$kaptDir/stubs ` +
`-P plugin:org.jetbrains.kotlin.kapt3:correctErrorTypes=true ` +
- `-P plugin:org.jetbrains.kotlin.kapt3:aptMode=stubs ` +
+ `-P plugin:org.jetbrains.kotlin.kapt3:aptMode=stubsAndApt ` +
`-P plugin:org.jetbrains.kotlin.kapt3:javacArguments=$encodedJavacFlags ` +
`$kaptProcessorPath ` +
`$kaptProcessor ` +
`-Xbuild-file=$kotlinBuildFile && ` +
- `${config.SoongZipCmd} -jar -o $out -C $kaptDir/stubs -D $kaptDir/stubs && ` +
+ `${config.SoongZipCmd} -jar -o $out -C $kaptDir/sources -D $kaptDir/sources && ` +
+ `${config.SoongZipCmd} -jar -o $classesJarOut -C $kaptDir/classes -D $kaptDir/classes && ` +
`rm -rf "$srcJarDir"`,
CommandDeps: []string{
"${config.KotlincCmd}",
@@ -205,14 +206,13 @@
kotlinName := filepath.Join(ctx.ModuleDir(), ctx.ModuleSubDir(), ctx.ModuleName())
kotlinName = strings.ReplaceAll(kotlinName, "/", "__")
- // First run kapt to generate .java stubs from .kt files
- kaptStubsJar := android.PathForModuleOut(ctx, "kapt", "stubs.jar")
ctx.Build(pctx, android.BuildParams{
- Rule: kaptStubs,
- Description: "kapt stubs",
- Output: kaptStubsJar,
- Inputs: srcFiles,
- Implicits: deps,
+ Rule: kapt,
+ Description: "kapt",
+ Output: srcJarOutputFile,
+ ImplicitOutput: resJarOutputFile,
+ Inputs: srcFiles,
+ Implicits: deps,
Args: map[string]string{
"classpath": flags.kotlincClasspath.FormJavaClassPath(""),
"kotlincFlags": flags.kotlincFlags,
@@ -228,11 +228,6 @@
"classesJarOut": resJarOutputFile.String(),
},
})
-
- // Then run turbine to perform annotation processing on the stubs and any .java srcFiles.
- javaSrcFiles := srcFiles.FilterByExt(".java")
- turbineSrcJars := append(android.Paths{kaptStubsJar}, srcJars...)
- TurbineApt(ctx, srcJarOutputFile, resJarOutputFile, javaSrcFiles, turbineSrcJars, flags)
}
// kapt converts a list of key, value pairs into a base64 encoded Java serialization, which is what kapt expects.
diff --git a/java/kotlin_test.go b/java/kotlin_test.go
index 435d782..628bf99 100644
--- a/java/kotlin_test.go
+++ b/java/kotlin_test.go
@@ -125,71 +125,51 @@
buildOS := ctx.Config().BuildOS.String()
- foo := ctx.ModuleForTests("foo", "android_common")
- kaptStubs := foo.Rule("kapt")
- turbineApt := foo.Description("turbine apt")
- kotlinc := foo.Rule("kotlinc")
- javac := foo.Rule("javac")
+ kapt := ctx.ModuleForTests("foo", "android_common").Rule("kapt")
+ kotlinc := ctx.ModuleForTests("foo", "android_common").Rule("kotlinc")
+ javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
bar := ctx.ModuleForTests("bar", buildOS+"_common").Rule("javac").Output.String()
baz := ctx.ModuleForTests("baz", buildOS+"_common").Rule("javac").Output.String()
// Test that the kotlin and java sources are passed to kapt and kotlinc
- if len(kaptStubs.Inputs) != 2 || kaptStubs.Inputs[0].String() != "a.java" || kaptStubs.Inputs[1].String() != "b.kt" {
- t.Errorf(`foo kapt inputs %v != ["a.java", "b.kt"]`, kaptStubs.Inputs)
+ if len(kapt.Inputs) != 2 || kapt.Inputs[0].String() != "a.java" || kapt.Inputs[1].String() != "b.kt" {
+ t.Errorf(`foo kapt inputs %v != ["a.java", "b.kt"]`, kapt.Inputs)
}
if len(kotlinc.Inputs) != 2 || kotlinc.Inputs[0].String() != "a.java" || kotlinc.Inputs[1].String() != "b.kt" {
t.Errorf(`foo kotlinc inputs %v != ["a.java", "b.kt"]`, kotlinc.Inputs)
}
- // Test that only the java sources are passed to turbine-apt and javac
- if len(turbineApt.Inputs) != 1 || turbineApt.Inputs[0].String() != "a.java" {
- t.Errorf(`foo turbine apt inputs %v != ["a.java"]`, turbineApt.Inputs)
- }
+ // Test that only the java sources are passed to javac
if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
}
- // Test that the kapt stubs jar is a dependency of turbine-apt
- if !inList(kaptStubs.Output.String(), turbineApt.Implicits.Strings()) {
- t.Errorf("expected %q in turbine-apt implicits %v", kaptStubs.Output.String(), kotlinc.Implicits.Strings())
+ // Test that the kapt srcjar is a dependency of kotlinc and javac rules
+ if !inList(kapt.Output.String(), kotlinc.Implicits.Strings()) {
+ t.Errorf("expected %q in kotlinc implicits %v", kapt.Output.String(), kotlinc.Implicits.Strings())
+ }
+ if !inList(kapt.Output.String(), javac.Implicits.Strings()) {
+ t.Errorf("expected %q in javac implicits %v", kapt.Output.String(), javac.Implicits.Strings())
}
- // Test that the turbine-apt srcjar is a dependency of kotlinc and javac rules
- if !inList(turbineApt.Output.String(), kotlinc.Implicits.Strings()) {
- t.Errorf("expected %q in kotlinc implicits %v", turbineApt.Output.String(), kotlinc.Implicits.Strings())
+ // Test that the kapt srcjar is extracted by the kotlinc and javac rules
+ if kotlinc.Args["srcJars"] != kapt.Output.String() {
+ t.Errorf("expected %q in kotlinc srcjars %v", kapt.Output.String(), kotlinc.Args["srcJars"])
}
- if !inList(turbineApt.Output.String(), javac.Implicits.Strings()) {
- t.Errorf("expected %q in javac implicits %v", turbineApt.Output.String(), javac.Implicits.Strings())
- }
-
- // Test that the turbine-apt srcjar is extracted by the kotlinc and javac rules
- if kotlinc.Args["srcJars"] != turbineApt.Output.String() {
- t.Errorf("expected %q in kotlinc srcjars %v", turbineApt.Output.String(), kotlinc.Args["srcJars"])
- }
- if javac.Args["srcJars"] != turbineApt.Output.String() {
- t.Errorf("expected %q in javac srcjars %v", turbineApt.Output.String(), kotlinc.Args["srcJars"])
+ if javac.Args["srcJars"] != kapt.Output.String() {
+ t.Errorf("expected %q in javac srcjars %v", kapt.Output.String(), kotlinc.Args["srcJars"])
}
// Test that the processors are passed to kapt
expectedProcessorPath := "-P plugin:org.jetbrains.kotlin.kapt3:apclasspath=" + bar +
" -P plugin:org.jetbrains.kotlin.kapt3:apclasspath=" + baz
- if kaptStubs.Args["kaptProcessorPath"] != expectedProcessorPath {
- t.Errorf("expected kaptProcessorPath %q, got %q", expectedProcessorPath, kaptStubs.Args["kaptProcessorPath"])
+ if kapt.Args["kaptProcessorPath"] != expectedProcessorPath {
+ t.Errorf("expected kaptProcessorPath %q, got %q", expectedProcessorPath, kapt.Args["kaptProcessorPath"])
}
expectedProcessor := "-P plugin:org.jetbrains.kotlin.kapt3:processors=com.bar -P plugin:org.jetbrains.kotlin.kapt3:processors=com.baz"
- if kaptStubs.Args["kaptProcessor"] != expectedProcessor {
- t.Errorf("expected kaptProcessor %q, got %q", expectedProcessor, kaptStubs.Args["kaptProcessor"])
- }
-
- // Test that the processors are passed to turbine-apt
- expectedProcessorPath = "--processorpath " + bar + " " + baz
- if !strings.Contains(turbineApt.Args["turbineFlags"], expectedProcessorPath) {
- t.Errorf("expected turbine-apt processorpath %q, got %q", expectedProcessorPath, turbineApt.Args["turbineFlags"])
- }
- expectedProcessor = "--processors com.bar com.baz"
- if !strings.Contains(turbineApt.Args["turbineFlags"], expectedProcessor) {
- t.Errorf("expected turbine-apt processor %q, got %q", expectedProcessor, turbineApt.Args["turbineFlags"])
+ if kapt.Args["kaptProcessor"] != expectedProcessor {
+ t.Errorf("expected kaptProcessor %q, got %q", expectedProcessor, kapt.Args["kaptProcessor"])
}
// Test that the processors are not passed to javac