From a23d994022ed7452beafe42cd91f55f0bb283f63 Mon Sep 17 00:00:00 2001 From: Isaac Chiou Date: Wed, 6 Apr 2022 06:14:38 +0000 Subject: [PATCH] Revert "Use kapt stubs for kotlin header jar for javac" This reverts commit c6ef4853704080b1340170c5c30046cc4dacd418. Reason for revert: Multiple systemui presubmits are broken due to this change Bug: 228262695 Change-Id: I1efed519c49d8d0583815c7bf2b3801bf0ba12fa --- java/base.go | 30 +++++++++--------------------- java/builder.go | 11 ++++------- java/kotlin.go | 6 +++--- java/kotlin_test.go | 28 ++++++++-------------------- 4 files changed, 24 insertions(+), 51 deletions(-) diff --git a/java/base.go b/java/base.go index cc55394cb..5802099ae 100644 --- a/java/base.go +++ b/java/base.go @@ -1108,23 +1108,13 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { flags.kotlincClasspath = append(flags.kotlincClasspath, flags.bootClasspath...) flags.kotlincClasspath = append(flags.kotlincClasspath, flags.classpath...) - useTurbineApt := len(flags.processorPath) > 0 - if useTurbineApt { + if len(flags.processorPath) > 0 { // Use kapt for annotation processing - kotlinTurbineAptHeaderJar := android.PathForModuleOut(ctx, "turbine-apt", "stubs-header.jar") - kotlinTurbineAptSrcJar := android.PathForModuleOut(ctx, "turbine-apt", "anno-sources.jar") - kotlinTurbineAptResJar := android.PathForModuleOut(ctx, "turbine-apt", "anno-res.jar") - kotlinTurbineApt(ctx, kotlinTurbineAptHeaderJar, kotlinTurbineAptSrcJar, kotlinTurbineAptResJar, - kotlinSrcFiles, kotlinCommonSrcFiles, srcJars, flags) - srcJars = append(srcJars, kotlinTurbineAptSrcJar) - kotlinJars = append(kotlinJars, kotlinTurbineAptResJar) - // When annotation processors are enabled we've already created java stubs for - // kotlin files using kapt and compiled them in turbine-apt while running the - // annotation processors, reuse the result as the kotlin header jar for the javac - // action. It can't be used as the header jar for downstream modules to compile - // against because it doesn't contain the kotlin-specific metadata that kotlinc - // needs. - flags.classpath = append(classpath{kotlinTurbineAptHeaderJar}, flags.classpath...) + kaptSrcJar := android.PathForModuleOut(ctx, "kapt", "kapt-sources.jar") + kaptResJar := android.PathForModuleOut(ctx, "kapt", "kapt-res.jar") + kotlinKapt(ctx, kaptSrcJar, kaptResJar, kotlinSrcFiles, kotlinCommonSrcFiles, srcJars, flags) + srcJars = append(srcJars, kaptSrcJar) + kotlinJars = append(kotlinJars, kaptResJar) // Disable annotation processing in javac, it's already been handled by kapt flags.processorPath = nil flags.processors = nil @@ -1137,13 +1127,11 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { return } + // Make javac rule depend on the kotlinc rule + flags.classpath = append(classpath{kotlinHeaderJar}, flags.classpath...) + kotlinJars = append(kotlinJars, kotlinJar) kotlinHeaderJars = append(kotlinHeaderJars, kotlinHeaderJar) - if !useTurbineApt { - // When annotation processors are not enabled use the kotlinc gen-jvm-abi plugin - // output as the header jar for javac in this module. - flags.classpath = append(classpath{kotlinHeaderJar}, flags.classpath...) - } // Jar kotlin classes into the final jar after javac if BoolDefault(j.properties.Static_kotlin_stdlib, true) { diff --git a/java/builder.go b/java/builder.go index 0f6876ecd..c0fadd42c 100644 --- a/java/builder.go +++ b/java/builder.go @@ -415,7 +415,7 @@ func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android. } // TurbineApt produces a rule to run annotation processors using turbine. -func TurbineApt(ctx android.ModuleContext, outputJar, outputSrcJar, outputResJar android.WritablePath, +func TurbineApt(ctx android.ModuleContext, outputSrcJar, outputResJar android.WritablePath, srcFiles, srcJars android.Paths, flags javaBuilderFlags) { turbineFlags, deps := turbineFlags(ctx, flags) @@ -426,9 +426,8 @@ func TurbineApt(ctx android.ModuleContext, outputJar, outputSrcJar, outputResJar turbineFlags += " " + flags.processorPath.FormTurbineClassPath("--processorpath ") turbineFlags += " --processors " + strings.Join(flags.processors, " ") - outputs := android.WritablePaths{outputJar, outputSrcJar, outputResJar} - outputFlags := "--output " + outputJar.String() + ".tmp " + - "--gensrc_output " + outputSrcJar.String() + ".tmp " + + outputs := android.WritablePaths{outputSrcJar, outputResJar} + outputFlags := "--gensrc_output " + outputSrcJar.String() + ".tmp " + "--resource_output " + outputResJar.String() + ".tmp" rule := turbine @@ -443,9 +442,7 @@ func TurbineApt(ctx android.ModuleContext, outputJar, outputSrcJar, outputResJar if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_TURBINE") { rule = turbineRE args["implicits"] = strings.Join(deps.Strings(), ",") - args["rbeOutputs"] = outputJar.String() + ".tmp," + - outputSrcJar.String() + ".tmp," + - outputResJar.String() + ".tmp" + args["rbeOutputs"] = outputSrcJar.String() + ".tmp," + outputResJar.String() + ".tmp" } ctx.Build(pctx, android.BuildParams{ Rule: rule, diff --git a/java/kotlin.go b/java/kotlin.go index 818bbd5aa..eff5bb53f 100644 --- a/java/kotlin.go +++ b/java/kotlin.go @@ -163,11 +163,11 @@ var kaptStubs = pctx.AndroidRemoteStaticRule("kaptStubs", android.RemoteRuleSupp "classpath", "srcJars", "commonSrcFilesArg", "srcJarDir", "kaptDir", "kotlinJvmTarget", "kotlinBuildFile", "name", "classesJarOut") -// kotlinTurbineApt performs Kotlin-compatible annotation processing. It takes .kt and .java sources and srcjars, and runs +// kotlinKapt performs Kotlin-compatible annotation processing. It takes .kt and .java sources and srcjars, and runs // annotation processors over all of them, producing a srcjar of generated code in outputFile. The srcjar should be // added as an additional input to kotlinc and javac rules, and the javac rule should have annotation processing // disabled. -func kotlinTurbineApt(ctx android.ModuleContext, headerJarOutputFile, srcJarOutputFile, resJarOutputFile android.WritablePath, +func kotlinKapt(ctx android.ModuleContext, srcJarOutputFile, resJarOutputFile android.WritablePath, srcFiles, commonSrcFiles, srcJars android.Paths, flags javaBuilderFlags) { @@ -231,7 +231,7 @@ func kotlinTurbineApt(ctx android.ModuleContext, headerJarOutputFile, srcJarOutp // 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, headerJarOutputFile, srcJarOutputFile, resJarOutputFile, javaSrcFiles, turbineSrcJars, flags) + 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 f67a9653c..f9ff98229 100644 --- a/java/kotlin_test.go +++ b/java/kotlin_test.go @@ -155,34 +155,22 @@ func TestKapt(t *testing.T) { t.Errorf("expected %q in turbine-apt implicits %v", kaptStubs.Output.String(), kotlinc.Implicits.Strings()) } - turbineAptSrcjarOutput := turbineApt.ImplicitOutputs[0] - // Test that the turbine-apt srcjar is a dependency of kotlinc and javac rules - if !inList(turbineAptSrcjarOutput.String(), kotlinc.Implicits.Strings()) { - t.Errorf("expected %q in kotlinc implicits %v", turbineAptSrcjarOutput.String(), kotlinc.Implicits.Strings()) + if !inList(turbineApt.Output.String(), kotlinc.Implicits.Strings()) { + t.Errorf("expected %q in kotlinc implicits %v", turbineApt.Output.String(), kotlinc.Implicits.Strings()) } - if !inList(turbineAptSrcjarOutput.String(), javac.Implicits.Strings()) { - t.Errorf("expected %q in javac implicits %v", turbineAptSrcjarOutput.String(), javac.Implicits.Strings()) + 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"] != turbineAptSrcjarOutput.String() { - t.Errorf("expected %q in kotlinc srcjars %v", turbineAptSrcjarOutput.String(), kotlinc.Args["srcJars"]) + 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"] != turbineAptSrcjarOutput.String() { - t.Errorf("expected %q in javac srcjars %v", turbineAptSrcjarOutput.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"]) } - // Test that the turbine-apt header jar is a dependency of the javac rules - turbineAptHeaderjarOutput := turbineApt.Output - android.AssertStringListContains(t, "javac dependency", javac.Implicits.Strings(), turbineAptHeaderjarOutput.String()) - android.AssertStringDoesContain(t, "javac classpath", javac.Args["classpath"], turbineAptHeaderjarOutput.String()) - - // Test that the kotlinc header jar is a not a dependency of the javac rules - kotlincHeaderJarOutput := kotlinc.ImplicitOutput - android.AssertStringListDoesNotContain(t, "javac dependency", javac.Implicits.Strings(), kotlincHeaderJarOutput.String()) - android.AssertStringDoesNotContain(t, "javac classpath", javac.Args["classpath"], kotlincHeaderJarOutput.String()) - // 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