From a4c8cc64715506634bd84f82cf373c9a8df9a57d Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Thu, 25 Jun 2020 17:13:36 -0700 Subject: [PATCH] Support kotlin multiplatform sources Add a common_srcs property and propagate it to the module.xml file passed to kotlinc. Test: m checkbuild Change-Id: Ief768bafb943513c9ffbc01e829abc078f0a72bc --- java/java.go | 17 +++++++++++--- java/kotlin.go | 64 ++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 63 insertions(+), 18 deletions(-) diff --git a/java/java.go b/java/java.go index 0d4667268..46ef98be9 100644 --- a/java/java.go +++ b/java/java.go @@ -140,10 +140,15 @@ func (j *Module) checkPlatformAPI(ctx android.ModuleContext) { // Findbugs type CompilerProperties struct { - // list of source files used to compile the Java module. May be .java, .logtags, .proto, + // list of source files used to compile the Java module. May be .java, .kt, .logtags, .proto, // or .aidl files. Srcs []string `android:"path,arch_variant"` + // list Kotlin of source files containing Kotlin code that should be treated as common code in + // a codebase that supports Kotlin multiplatform. See + // https://kotlinlang.org/docs/reference/multiplatform.html. May be only be .kt files. + Common_srcs []string `android:"path,arch_variant"` + // list of source files that should not be used to build the Java module. // This is most useful in the arch/multilib variants to remove non-common files Exclude_srcs []string `android:"path,arch_variant"` @@ -1300,6 +1305,11 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { flags = protoFlags(ctx, &j.properties, &j.protoProperties, flags) } + kotlinCommonSrcFiles := android.PathsForModuleSrcExcludes(ctx, j.properties.Common_srcs, nil) + if len(kotlinCommonSrcFiles.FilterOutByExt(".kt")) > 0 { + ctx.PropertyErrorf("common_srcs", "common_srcs must be .kt files") + } + srcFiles = j.genSources(ctx, srcFiles, flags) srcJars := srcFiles.FilterByExt(".srcjar") @@ -1353,6 +1363,7 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { // Collect .kt files for AIDEGen j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, srcFiles.FilterByExt(".kt").Strings()...) + j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, kotlinCommonSrcFiles.Strings()...) flags.classpath = append(flags.classpath, deps.kotlinStdlib...) flags.classpath = append(flags.classpath, deps.kotlinAnnotations...) @@ -1364,7 +1375,7 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { // Use kapt for annotation processing kaptSrcJar := android.PathForModuleOut(ctx, "kapt", "kapt-sources.jar") kaptResJar := android.PathForModuleOut(ctx, "kapt", "kapt-res.jar") - kotlinKapt(ctx, kaptSrcJar, kaptResJar, kotlinSrcFiles, srcJars, flags) + 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 @@ -1373,7 +1384,7 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { } kotlinJar := android.PathForModuleOut(ctx, "kotlin", jarName) - kotlinCompile(ctx, kotlinJar, kotlinSrcFiles, srcJars, flags) + kotlinCompile(ctx, kotlinJar, kotlinSrcFiles, kotlinCommonSrcFiles, srcJars, flags) if ctx.Failed() { return } diff --git a/java/kotlin.go b/java/kotlin.go index e3356be78..e8c030aa7 100644 --- a/java/kotlin.go +++ b/java/kotlin.go @@ -33,7 +33,7 @@ var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports `${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"` + - ` --out "$kotlinBuildFile" && ` + + ` $commonSrcFilesArg --out "$kotlinBuildFile" && ` + `${config.KotlincCmd} ${config.JavacHeapFlags} $kotlincFlags ` + `-jvm-target $kotlinJvmTarget -Xbuild-file=$kotlinBuildFile -kotlin-home $emptyDir && ` + `${config.SoongZipCmd} -jar -o $out -C $classesDir -D $classesDir && ` + @@ -54,21 +54,43 @@ var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports Rspfile: "$out.rsp", RspfileContent: `$in`, }, - "kotlincFlags", "classpath", "srcJars", "srcJarDir", "classesDir", "kotlinJvmTarget", "kotlinBuildFile", - "emptyDir", "name") + "kotlincFlags", "classpath", "srcJars", "commonSrcFilesArg", "srcJarDir", "classesDir", + "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() + rule.Command().Text("cp").FlagWithRspFileInputList("", commonSrcFiles).Output(commonSrcsList) + rule.Build(pctx, ctx, "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 android.WritablePath, - srcFiles, srcJars android.Paths, + srcFiles, commonSrcFiles, srcJars android.Paths, flags javaBuilderFlags) { var deps android.Paths deps = append(deps, flags.kotlincClasspath...) 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", @@ -76,13 +98,14 @@ func kotlinCompile(ctx android.ModuleContext, outputFile android.WritablePath, Inputs: srcFiles, Implicits: deps, Args: map[string]string{ - "classpath": flags.kotlincClasspath.FormJavaClassPath(""), - "kotlincFlags": flags.kotlincFlags, - "srcJars": strings.Join(srcJars.Strings(), " "), - "classesDir": android.PathForModuleOut(ctx, "kotlinc", "classes").String(), - "srcJarDir": android.PathForModuleOut(ctx, "kotlinc", "srcJars").String(), - "kotlinBuildFile": android.PathForModuleOut(ctx, "kotlinc-build.xml").String(), - "emptyDir": android.PathForModuleOut(ctx, "kotlinc", "empty").String(), + "classpath": flags.kotlincClasspath.FormJavaClassPath(""), + "kotlincFlags": flags.kotlincFlags, + "commonSrcFilesArg": commonSrcFilesArg, + "srcJars": strings.Join(srcJars.Strings(), " "), + "classesDir": android.PathForModuleOut(ctx, "kotlinc", "classes").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, @@ -97,7 +120,7 @@ var kapt = pctx.AndroidRemoteStaticRule("kapt", android.RemoteRuleSupports{Goma: `${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` + `${config.GenKotlinBuildFileCmd} --classpath "$classpath" --name "$name"` + ` --srcs "$out.rsp" --srcs "$srcJarDir/list"` + - ` --out "$kotlinBuildFile" && ` + + ` $commonSrcFilesArg --out "$kotlinBuildFile" && ` + `${config.KotlincCmd} ${config.KotlincSuppressJDK9Warnings} ${config.JavacHeapFlags} $kotlincFlags ` + `-Xplugin=${config.KotlinKaptJar} ` + `-P plugin:org.jetbrains.kotlin.kapt3:sources=$kaptDir/sources ` + @@ -124,21 +147,31 @@ var kapt = pctx.AndroidRemoteStaticRule("kapt", android.RemoteRuleSupports{Goma: RspfileContent: `$in`, }, "kotlincFlags", "encodedJavacFlags", "kaptProcessorPath", "kaptProcessor", - "classpath", "srcJars", "srcJarDir", "kaptDir", "kotlinJvmTarget", "kotlinBuildFile", "name", - "classesJarOut") + "classpath", "srcJars", "commonSrcFilesArg", "srcJarDir", "kaptDir", "kotlinJvmTarget", + "kotlinBuildFile", "name", "classesJarOut") // 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 kotlinKapt(ctx android.ModuleContext, srcJarOutputFile, resJarOutputFile android.WritablePath, - srcFiles, srcJars android.Paths, + 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=") @@ -168,6 +201,7 @@ func kotlinKapt(ctx android.ModuleContext, srcJarOutputFile, resJarOutputFile an 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(),