Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 220a9a12 authored by Colin Cross's avatar Colin Cross
Browse files

Enable kotlin's jvm-abi-gen plugin to generate header jars 

Kotlin's jvm-abi-gen plugin can generate header jars similar to the
turbine output for java sources, which can be used to avoid recompiling
downstream modules when the ABI hasn't changed.  Unlike turbine, the
plugin runs as part of the main kotlinc invocation, so it doesn't allow
the downstream modules to start compiling any sooner.

A future possible optimization is to use turbine to compile the kapt
stubs, at least for the  kotlin+annotation processor modules that already
generate them, which would allow compiling downstream modules before
invoking kotlinc or javac, as well as invoking kotlinc and javac in
parallel with each other.

Bug: 222095735
Test: TestKotlin
Test: m SystemUI
Change-Id: Ib1bb2ecea47c851a108a26f9ed4f827f289d1321
parent e52c2ac7

java/base.go

+8 −3
Original line number Diff line number Diff line
@@ -1052,6 +1052,7 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { 
	j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, uniqueSrcFiles.Strings()...)



	var kotlinJars android.Paths

	var kotlinHeaderJars android.Paths



	if srcFiles.HasExt(".kt") {

		// user defined kotlin flags.
@@ -1109,18 +1110,22 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { 
		}



		kotlinJar := android.PathForModuleOut(ctx, "kotlin", jarName)

		kotlinCompile(ctx, kotlinJar, kotlinSrcFiles, kotlinCommonSrcFiles, srcJars, flags)

		kotlinHeaderJar := android.PathForModuleOut(ctx, "kotlin_headers", jarName)

		kotlinCompile(ctx, kotlinJar, kotlinHeaderJar, kotlinSrcFiles, kotlinCommonSrcFiles, srcJars, flags)

		if ctx.Failed() {

			return

		}



		// Make javac rule depend on the kotlinc rule

		flags.classpath = append(flags.classpath, kotlinJar)

		flags.classpath = append(classpath{kotlinHeaderJar}, flags.classpath...)



		kotlinJars = append(kotlinJars, kotlinJar)

		kotlinHeaderJars = append(kotlinHeaderJars, kotlinHeaderJar)



		// Jar kotlin classes into the final jar after javac

		if BoolDefault(j.properties.Static_kotlin_stdlib, true) {

			kotlinJars = append(kotlinJars, deps.kotlinStdlib...)

			kotlinHeaderJars = append(kotlinHeaderJars, deps.kotlinStdlib...)

		} else {

			flags.dexClasspath = append(flags.dexClasspath, deps.kotlinStdlib...)

		}
@@ -1144,7 +1149,7 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { 
			// with sharding enabled. See: b/77284273.

		}

		headerJarFileWithoutDepsOrJarjar, j.headerJarFile =

			j.compileJavaHeader(ctx, uniqueSrcFiles, srcJars, deps, flags, jarName, kotlinJars)

			j.compileJavaHeader(ctx, uniqueSrcFiles, srcJars, deps, flags, jarName, kotlinHeaderJars)

		if ctx.Failed() {

			return

		}

java/config/kotlin.go

+1 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ func init() { 
	pctx.SourcePathVariable("KotlinKaptJar", "external/kotlinc/lib/kotlin-annotation-processing.jar")

	pctx.SourcePathVariable("KotlinAnnotationJar", "external/kotlinc/lib/annotations-13.0.jar")

	pctx.SourcePathVariable("KotlinStdlibJar", KotlinStdlibJar)

	pctx.SourcePathVariable("KotlinAbiGenPluginJar", "external/kotlinc/lib/jvm-abi-gen.jar")



	// These flags silence "Illegal reflective access" warnings when running kapt in OpenJDK9+

	pctx.StaticVariable("KaptSuppressJDK9Warnings", strings.Join([]string{

java/kotlin.go

+21 −13
Original line number Diff line number Diff line
@@ -28,8 +28,8 @@ import ( 


var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports{Goma: true},

	blueprint.RuleParams{

		Command: `rm -rf "$classesDir" "$srcJarDir" "$kotlinBuildFile" "$emptyDir" && ` +

			`mkdir -p "$classesDir" "$srcJarDir" "$emptyDir" && ` +

		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"` +
@@ -37,8 +37,11 @@ var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports 
			`${config.KotlincCmd} ${config.KotlincGlobalFlags} ` +

			` ${config.KotlincSuppressJDK9Warnings} ${config.JavacHeapFlags} ` +

			` $kotlincFlags -jvm-target $kotlinJvmTarget -Xbuild-file=$kotlinBuildFile ` +

			`-kotlin-home $emptyDir && ` +

			`${config.SoongZipCmd} -jar -o $out -C $classesDir -D $classesDir && ` +

			` -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}",
@@ -49,15 +52,17 @@ var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports 
			"${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",

	"kotlinJvmTarget", "kotlinBuildFile", "emptyDir", "name")

	"headerClassesDir", "headerJar", "kotlinJvmTarget", "kotlinBuildFile", "emptyDir", "name")



func kotlinCommonSrcsList(ctx android.ModuleContext, commonSrcFiles android.Paths) android.OptionalPath {

	if len(commonSrcFiles) > 0 {
@@ -76,7 +81,7 @@ func kotlinCommonSrcsList(ctx android.ModuleContext, commonSrcFiles android.Path 
}



// 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,

func kotlinCompile(ctx android.ModuleContext, outputFile, headerOutputFile android.WritablePath,

	srcFiles, commonSrcFiles, srcJars android.Paths,

	flags javaBuilderFlags) {
@@ -100,6 +105,7 @@ func kotlinCompile(ctx android.ModuleContext, outputFile android.WritablePath, 
		Rule:           kotlinc,

		Description:    "kotlinc",

		Output:         outputFile,

		ImplicitOutput: headerOutputFile,

		Inputs:         srcFiles,

		Implicits:      deps,

		Args: map[string]string{
@@ -108,6 +114,8 @@ func kotlinCompile(ctx android.ModuleContext, outputFile android.WritablePath, 
			"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(),

java/kotlin_test.go

+13 −5
Original line number Diff line number Diff line
@@ -45,6 +45,10 @@ func TestKotlin(t *testing.T) { 
	fooKotlinc := ctx.ModuleForTests("foo", "android_common").Rule("kotlinc")

	fooJavac := ctx.ModuleForTests("foo", "android_common").Rule("javac")

	fooJar := ctx.ModuleForTests("foo", "android_common").Output("combined/foo.jar")

	fooHeaderJar := ctx.ModuleForTests("foo", "android_common").Output("turbine-combined/foo.jar")



	fooKotlincClasses := fooKotlinc.Output

	fooKotlincHeaderClasses := fooKotlinc.ImplicitOutput



	if len(fooKotlinc.Inputs) != 2 || fooKotlinc.Inputs[0].String() != "a.java" ||

		fooKotlinc.Inputs[1].String() != "b.kt" {
@@ -55,17 +59,21 @@ func TestKotlin(t *testing.T) { 
		t.Errorf(`foo inputs %v != ["a.java"]`, fooJavac.Inputs)

	}



	if !strings.Contains(fooJavac.Args["classpath"], fooKotlinc.Output.String()) {

	if !strings.Contains(fooJavac.Args["classpath"], fooKotlincHeaderClasses.String()) {

		t.Errorf("foo classpath %v does not contain %q",

			fooJavac.Args["classpath"], fooKotlinc.Output.String())

			fooJavac.Args["classpath"], fooKotlincHeaderClasses.String())

	}



	if !inList(fooKotlinc.Output.String(), fooJar.Inputs.Strings()) {

	if !inList(fooKotlincClasses.String(), fooJar.Inputs.Strings()) {

		t.Errorf("foo jar inputs %v does not contain %q",

			fooJar.Inputs.Strings(), fooKotlinc.Output.String())

			fooJar.Inputs.Strings(), fooKotlincClasses.String())

	}



	if !inList(fooKotlincHeaderClasses.String(), fooHeaderJar.Inputs.Strings()) {

		t.Errorf("foo header jar inputs %v does not contain %q",

			fooHeaderJar.Inputs.Strings(), fooKotlincHeaderClasses.String())

	}



	fooHeaderJar := ctx.ModuleForTests("foo", "android_common").Output("turbine-combined/foo.jar")

	bazHeaderJar := ctx.ModuleForTests("baz", "android_common").Output("turbine-combined/baz.jar")

	barKotlinc := ctx.ModuleForTests("bar", "android_common").Rule("kotlinc")