c6ef485370
When compling kotlin code with annotation processors we are generating java stubs for the kotlin sources using kapt, and parsing them in turbine when running the annotation processors. Passing --output to turbine will also compile the stubs into a header jar that can be used as a dependency to javac, allowing the javac and kotlinc rules to run in parallel. The turbine-apt header jar can't be used as the header jar for downstream modules as it doesn't contain the kotlin metadata needed by kotlinc rules, so the kotlinc gen-jvm-abi plugin output is still used for the module's final header jar. Test: TestKapt Bug: 222095735 Change-Id: I82d0900f3dc30f3e3ebd7cab0693dfe741d9b955
262 lines
11 KiB
Go
262 lines
11 KiB
Go
// Copyright 2019 Google Inc. All rights reserved.
|
|
//
|
|
// 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
|
|
//
|
|
// http://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 java
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"android/soong/android"
|
|
|
|
"github.com/google/blueprint"
|
|
)
|
|
|
|
var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports{Goma: true},
|
|
blueprint.RuleParams{
|
|
Command: `rm -rf "$classesDir" "$headerClassesDir" "$srcJarDir" "$kotlinBuildFile" "$emptyDir" && ` +
|
|
`mkdir -p "$classesDir" "$headerClassesDir" "$srcJarDir" "$emptyDir" && ` +
|
|
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
|
|
`${config.GenKotlinBuildFileCmd} --classpath "$classpath" --name "$name"` +
|
|
` --out_dir "$classesDir" --srcs "$out.rsp" --srcs "$srcJarDir/list"` +
|
|
` $commonSrcFilesArg --out "$kotlinBuildFile" && ` +
|
|
`${config.KotlincCmd} ${config.KotlincGlobalFlags} ` +
|
|
` ${config.KotlincSuppressJDK9Warnings} ${config.JavacHeapFlags} ` +
|
|
` $kotlincFlags -jvm-target $kotlinJvmTarget -Xbuild-file=$kotlinBuildFile ` +
|
|
` -kotlin-home $emptyDir ` +
|
|
` -Xplugin=${config.KotlinAbiGenPluginJar} ` +
|
|
` -P plugin:org.jetbrains.kotlin.jvm.abi:outputDir=$headerClassesDir && ` +
|
|
`${config.SoongZipCmd} -jar -o $out -C $classesDir -D $classesDir -write_if_changed && ` +
|
|
`${config.SoongZipCmd} -jar -o $headerJar -C $headerClassesDir -D $headerClassesDir -write_if_changed && ` +
|
|
`rm -rf "$srcJarDir"`,
|
|
CommandDeps: []string{
|
|
"${config.KotlincCmd}",
|
|
"${config.KotlinCompilerJar}",
|
|
"${config.KotlinPreloaderJar}",
|
|
"${config.KotlinReflectJar}",
|
|
"${config.KotlinScriptRuntimeJar}",
|
|
"${config.KotlinStdlibJar}",
|
|
"${config.KotlinTrove4jJar}",
|
|
"${config.KotlinAnnotationJar}",
|
|
"${config.KotlinAbiGenPluginJar}",
|
|
"${config.GenKotlinBuildFileCmd}",
|
|
"${config.SoongZipCmd}",
|
|
"${config.ZipSyncCmd}",
|
|
},
|
|
Rspfile: "$out.rsp",
|
|
RspfileContent: `$in`,
|
|
Restat: true,
|
|
},
|
|
"kotlincFlags", "classpath", "srcJars", "commonSrcFilesArg", "srcJarDir", "classesDir",
|
|
"headerClassesDir", "headerJar", "kotlinJvmTarget", "kotlinBuildFile", "emptyDir", "name")
|
|
|
|
func kotlinCommonSrcsList(ctx android.ModuleContext, commonSrcFiles android.Paths) android.OptionalPath {
|
|
if len(commonSrcFiles) > 0 {
|
|
// The list of common_srcs may be too long to put on the command line, but
|
|
// we can't use the rsp file because it is already being used for srcs.
|
|
// Insert a second rule to write out the list of resources to a file.
|
|
commonSrcsList := android.PathForModuleOut(ctx, "kotlinc_common_srcs.list")
|
|
rule := android.NewRuleBuilder(pctx, ctx)
|
|
rule.Command().Text("cp").
|
|
FlagWithRspFileInputList("", commonSrcsList.ReplaceExtension(ctx, "rsp"), commonSrcFiles).
|
|
Output(commonSrcsList)
|
|
rule.Build("kotlin_common_srcs_list", "kotlin common_srcs list")
|
|
return android.OptionalPathForPath(commonSrcsList)
|
|
}
|
|
return android.OptionalPath{}
|
|
}
|
|
|
|
// kotlinCompile takes .java and .kt sources and srcJars, and compiles the .kt sources into a classes jar in outputFile.
|
|
func kotlinCompile(ctx android.ModuleContext, outputFile, headerOutputFile android.WritablePath,
|
|
srcFiles, commonSrcFiles, srcJars android.Paths,
|
|
flags javaBuilderFlags) {
|
|
|
|
var deps android.Paths
|
|
deps = append(deps, flags.kotlincClasspath...)
|
|
deps = append(deps, flags.kotlincDeps...)
|
|
deps = append(deps, srcJars...)
|
|
deps = append(deps, commonSrcFiles...)
|
|
|
|
kotlinName := filepath.Join(ctx.ModuleDir(), ctx.ModuleSubDir(), ctx.ModuleName())
|
|
kotlinName = strings.ReplaceAll(kotlinName, "/", "__")
|
|
|
|
commonSrcsList := kotlinCommonSrcsList(ctx, commonSrcFiles)
|
|
commonSrcFilesArg := ""
|
|
if commonSrcsList.Valid() {
|
|
deps = append(deps, commonSrcsList.Path())
|
|
commonSrcFilesArg = "--common_srcs " + commonSrcsList.String()
|
|
}
|
|
|
|
ctx.Build(pctx, android.BuildParams{
|
|
Rule: kotlinc,
|
|
Description: "kotlinc",
|
|
Output: outputFile,
|
|
ImplicitOutput: headerOutputFile,
|
|
Inputs: srcFiles,
|
|
Implicits: deps,
|
|
Args: map[string]string{
|
|
"classpath": flags.kotlincClasspath.FormJavaClassPath(""),
|
|
"kotlincFlags": flags.kotlincFlags,
|
|
"commonSrcFilesArg": commonSrcFilesArg,
|
|
"srcJars": strings.Join(srcJars.Strings(), " "),
|
|
"classesDir": android.PathForModuleOut(ctx, "kotlinc", "classes").String(),
|
|
"headerClassesDir": android.PathForModuleOut(ctx, "kotlinc", "header_classes").String(),
|
|
"headerJar": headerOutputFile.String(),
|
|
"srcJarDir": android.PathForModuleOut(ctx, "kotlinc", "srcJars").String(),
|
|
"kotlinBuildFile": android.PathForModuleOut(ctx, "kotlinc-build.xml").String(),
|
|
"emptyDir": android.PathForModuleOut(ctx, "kotlinc", "empty").String(),
|
|
// http://b/69160377 kotlinc only supports -jvm-target 1.6 and 1.8
|
|
"kotlinJvmTarget": "1.8",
|
|
"name": kotlinName,
|
|
},
|
|
})
|
|
}
|
|
|
|
var kaptStubs = pctx.AndroidRemoteStaticRule("kaptStubs", android.RemoteRuleSupports{Goma: true},
|
|
blueprint.RuleParams{
|
|
Command: `rm -rf "$srcJarDir" "$kotlinBuildFile" "$kaptDir" && ` +
|
|
`mkdir -p "$srcJarDir" "$kaptDir/sources" "$kaptDir/classes" && ` +
|
|
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
|
|
`${config.GenKotlinBuildFileCmd} --classpath "$classpath" --name "$name"` +
|
|
` --srcs "$out.rsp" --srcs "$srcJarDir/list"` +
|
|
` $commonSrcFilesArg --out "$kotlinBuildFile" && ` +
|
|
`${config.KotlincCmd} ${config.KotlincGlobalFlags} ` +
|
|
`${config.KaptSuppressJDK9Warnings} ${config.KotlincSuppressJDK9Warnings} ` +
|
|
`${config.JavacHeapFlags} $kotlincFlags -Xplugin=${config.KotlinKaptJar} ` +
|
|
`-P plugin:org.jetbrains.kotlin.kapt3:sources=$kaptDir/sources ` +
|
|
`-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:javacArguments=$encodedJavacFlags ` +
|
|
`$kaptProcessorPath ` +
|
|
`$kaptProcessor ` +
|
|
`-Xbuild-file=$kotlinBuildFile && ` +
|
|
`${config.SoongZipCmd} -jar -o $out -C $kaptDir/stubs -D $kaptDir/stubs && ` +
|
|
`rm -rf "$srcJarDir"`,
|
|
CommandDeps: []string{
|
|
"${config.KotlincCmd}",
|
|
"${config.KotlinCompilerJar}",
|
|
"${config.KotlinKaptJar}",
|
|
"${config.GenKotlinBuildFileCmd}",
|
|
"${config.SoongZipCmd}",
|
|
"${config.ZipSyncCmd}",
|
|
},
|
|
Rspfile: "$out.rsp",
|
|
RspfileContent: `$in`,
|
|
},
|
|
"kotlincFlags", "encodedJavacFlags", "kaptProcessorPath", "kaptProcessor",
|
|
"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
|
|
// 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,
|
|
srcFiles, commonSrcFiles, srcJars android.Paths,
|
|
flags javaBuilderFlags) {
|
|
|
|
srcFiles = append(android.Paths(nil), srcFiles...)
|
|
|
|
var deps android.Paths
|
|
deps = append(deps, flags.kotlincClasspath...)
|
|
deps = append(deps, srcJars...)
|
|
deps = append(deps, flags.processorPath...)
|
|
deps = append(deps, commonSrcFiles...)
|
|
|
|
commonSrcsList := kotlinCommonSrcsList(ctx, commonSrcFiles)
|
|
commonSrcFilesArg := ""
|
|
if commonSrcsList.Valid() {
|
|
deps = append(deps, commonSrcsList.Path())
|
|
commonSrcFilesArg = "--common_srcs " + commonSrcsList.String()
|
|
}
|
|
|
|
kaptProcessorPath := flags.processorPath.FormRepeatedClassPath("-P plugin:org.jetbrains.kotlin.kapt3:apclasspath=")
|
|
|
|
kaptProcessor := ""
|
|
for i, p := range flags.processors {
|
|
if i > 0 {
|
|
kaptProcessor += " "
|
|
}
|
|
kaptProcessor += "-P plugin:org.jetbrains.kotlin.kapt3:processors=" + p
|
|
}
|
|
|
|
encodedJavacFlags := kaptEncodeFlags([][2]string{
|
|
{"-source", flags.javaVersion.String()},
|
|
{"-target", flags.javaVersion.String()},
|
|
})
|
|
|
|
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,
|
|
Args: map[string]string{
|
|
"classpath": flags.kotlincClasspath.FormJavaClassPath(""),
|
|
"kotlincFlags": flags.kotlincFlags,
|
|
"commonSrcFilesArg": commonSrcFilesArg,
|
|
"srcJars": strings.Join(srcJars.Strings(), " "),
|
|
"srcJarDir": android.PathForModuleOut(ctx, "kapt", "srcJars").String(),
|
|
"kotlinBuildFile": android.PathForModuleOut(ctx, "kapt", "build.xml").String(),
|
|
"kaptProcessorPath": strings.Join(kaptProcessorPath, " "),
|
|
"kaptProcessor": kaptProcessor,
|
|
"kaptDir": android.PathForModuleOut(ctx, "kapt/gen").String(),
|
|
"encodedJavacFlags": encodedJavacFlags,
|
|
"name": kotlinName,
|
|
"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, headerJarOutputFile, srcJarOutputFile, resJarOutputFile, javaSrcFiles, turbineSrcJars, flags)
|
|
}
|
|
|
|
// kapt converts a list of key, value pairs into a base64 encoded Java serialization, which is what kapt expects.
|
|
func kaptEncodeFlags(options [][2]string) string {
|
|
buf := &bytes.Buffer{}
|
|
|
|
binary.Write(buf, binary.BigEndian, uint32(len(options)))
|
|
for _, option := range options {
|
|
binary.Write(buf, binary.BigEndian, uint16(len(option[0])))
|
|
buf.WriteString(option[0])
|
|
binary.Write(buf, binary.BigEndian, uint16(len(option[1])))
|
|
buf.WriteString(option[1])
|
|
}
|
|
|
|
header := &bytes.Buffer{}
|
|
header.Write([]byte{0xac, 0xed, 0x00, 0x05}) // java serialization header
|
|
|
|
if buf.Len() < 256 {
|
|
header.WriteByte(0x77) // blockdata
|
|
header.WriteByte(byte(buf.Len()))
|
|
} else {
|
|
header.WriteByte(0x7a) // blockdatalong
|
|
binary.Write(header, binary.BigEndian, uint32(buf.Len()))
|
|
}
|
|
|
|
return base64.StdEncoding.EncodeToString(append(header.Bytes(), buf.Bytes()...))
|
|
}
|