From 0c4ce21615a7e7515c92ae91ac9fef7fc1397839 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 3 May 2019 15:28:19 -0700 Subject: [PATCH] Track sources for srcjars across modules Robolectric coverage needs a srcjar that sometimes needs to include sources of dependencies. Track the arguments and dependencies necessary to jar the sources. Test: TestIncludeSrcs Change-Id: I9979d2b8350923a2237e743c232e6e548f54ba3b --- java/aar.go | 4 ++ java/device_host_converter.go | 11 ++++++ java/java.go | 46 ++++++++++++++++------- java/java_resources.go | 8 ---- java/java_test.go | 69 ++++++++++++++++++++++++++++++++--- 5 files changed, 111 insertions(+), 27 deletions(-) diff --git a/java/aar.go b/java/aar.go index 5e1f88e71..7332e76b2 100644 --- a/java/aar.go +++ b/java/aar.go @@ -647,6 +647,10 @@ func (a *AARImport) ExportedSdkLibs() []string { return nil } +func (a *AARImport) SrcJarArgs() ([]string, android.Paths) { + return nil, nil +} + var _ android.PrebuiltInterface = (*Import)(nil) // android_library_import imports an `.aar` file into the build graph as if it was built with android_library. diff --git a/java/device_host_converter.go b/java/device_host_converter.go index 9c883e50a..b92f4d73e 100644 --- a/java/device_host_converter.go +++ b/java/device_host_converter.go @@ -34,6 +34,9 @@ type DeviceHostConverter struct { implementationAndResourceJars android.Paths resourceJars android.Paths + srcJarArgs []string + srcJarDeps android.Paths + combinedHeaderJar android.Path combinedImplementationJar android.Path } @@ -100,6 +103,10 @@ func (d *DeviceHostConverter) GenerateAndroidBuildActions(ctx android.ModuleCont d.implementationJars = append(d.implementationJars, dep.ImplementationJars()...) d.implementationAndResourceJars = append(d.implementationAndResourceJars, dep.ImplementationAndResourcesJars()...) d.resourceJars = append(d.resourceJars, dep.ResourceJars()...) + + srcJarArgs, srcJarDeps := dep.SrcJarArgs() + d.srcJarArgs = append(d.srcJarArgs, srcJarArgs...) + d.srcJarDeps = append(d.srcJarDeps, srcJarDeps...) } else { ctx.PropertyErrorf("libs", "module %q cannot be used as a dependency", ctx.OtherModuleName(m)) } @@ -157,6 +164,10 @@ func (d *DeviceHostConverter) ExportedSdkLibs() []string { return nil } +func (d *DeviceHostConverter) SrcJarArgs() ([]string, android.Paths) { + return d.srcJarArgs, d.srcJarDeps +} + func (d *DeviceHostConverter) AndroidMk() android.AndroidMkData { return android.AndroidMkData{ Class: "JAVA_LIBRARIES", diff --git a/java/java.go b/java/java.go index b9c06a8e9..e764ec303 100644 --- a/java/java.go +++ b/java/java.go @@ -290,6 +290,10 @@ type Module struct { // jar file containing only resources including from static library dependencies resourceJar android.Path + // args and dependencies to package source files into a srcjar + srcJarArgs []string + srcJarDeps android.Paths + // jar file containing implementation classes and resources including static library // dependencies implementationAndResourcesJar android.Path @@ -365,6 +369,7 @@ type Dependency interface { DexJar() android.Path AidlIncludeDirs() android.Paths ExportedSdkLibs() []string + SrcJarArgs() ([]string, android.Paths) } type SdkLibraryDependency interface { @@ -1113,6 +1118,14 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path } } + j.srcJarArgs, j.srcJarDeps = resourcePathsToJarArgs(srcFiles), srcFiles + + var includeSrcJar android.WritablePath + if Bool(j.properties.Include_srcs) { + includeSrcJar = android.PathForModuleOut(ctx, ctx.ModuleName()+".srcjar") + TransformResourcesToJar(ctx, includeSrcJar, j.srcJarArgs, j.srcJarDeps) + } + dirArgs, dirDeps := ResourceDirsToJarArgs(ctx, j.properties.Java_resource_dirs, j.properties.Exclude_java_resource_dirs, j.properties.Exclude_java_resources) fileArgs, fileDeps := ResourceFilesToJarArgs(ctx, j.properties.Java_resources, j.properties.Exclude_java_resources) @@ -1130,12 +1143,6 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path resArgs = append(resArgs, extraArgs...) resDeps = append(resDeps, extraDeps...) - if Bool(j.properties.Include_srcs) { - srcArgs, srcDeps := SourceFilesToJarArgs(ctx, j.properties.Srcs, j.properties.Exclude_srcs) - resArgs = append(resArgs, srcArgs...) - resDeps = append(resDeps, srcDeps...) - } - if len(resArgs) > 0 { resourceJar := android.PathForModuleOut(ctx, "res", jarName) TransformResourcesToJar(ctx, resourceJar, resArgs, resDeps) @@ -1145,17 +1152,22 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path } } - if len(deps.staticResourceJars) > 0 { - var jars android.Paths - if j.resourceJar != nil { - jars = append(jars, j.resourceJar) - } - jars = append(jars, deps.staticResourceJars...) + var resourceJars android.Paths + if j.resourceJar != nil { + resourceJars = append(resourceJars, j.resourceJar) + } + if Bool(j.properties.Include_srcs) { + resourceJars = append(resourceJars, includeSrcJar) + } + resourceJars = append(resourceJars, deps.staticResourceJars...) + if len(resourceJars) > 1 { combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName) - TransformJarsToJar(ctx, combinedJar, "for resources", jars, android.OptionalPath{}, + TransformJarsToJar(ctx, combinedJar, "for resources", resourceJars, android.OptionalPath{}, false, nil, nil) j.resourceJar = combinedJar + } else if len(resourceJars) == 1 { + j.resourceJar = resourceJars[0] } jars = append(jars, deps.staticJars...) @@ -1443,6 +1455,10 @@ func (j *Module) ExportedSdkLibs() []string { return j.exportedSdkLibs } +func (j *Module) SrcJarArgs() ([]string, android.Paths) { + return j.srcJarArgs, j.srcJarDeps +} + var _ logtagsProducer = (*Module)(nil) func (j *Module) logtags() android.Paths { @@ -1920,6 +1936,10 @@ func (j *Import) ExportedSdkLibs() []string { return j.exportedSdkLibs } +func (j *Import) SrcJarArgs() ([]string, android.Paths) { + return nil, nil +} + // Add compile time check for interface implementation var _ android.IDEInfo = (*Import)(nil) var _ android.IDECustomizedModuleName = (*Import)(nil) diff --git a/java/java_resources.go b/java/java_resources.go index 1bbeb9a6c..787d74a0d 100644 --- a/java/java_resources.go +++ b/java/java_resources.go @@ -85,14 +85,6 @@ func ResourceFilesToJarArgs(ctx android.ModuleContext, return resourceFilesToJarArgs(ctx, res, exclude) } -// Convert java_resources properties to arguments to soong_zip -jar, keeping files that should -// normally not used as resources like *.java -func SourceFilesToJarArgs(ctx android.ModuleContext, - res, exclude []string) (args []string, deps android.Paths) { - - return resourceFilesToJarArgs(ctx, res, exclude) -} - func resourceFilesToJarArgs(ctx android.ModuleContext, res, exclude []string) (args []string, deps android.Paths) { diff --git a/java/java_test.go b/java/java_test.go index 5335d7897..53df6f486 100644 --- a/java/java_test.go +++ b/java/java_test.go @@ -481,12 +481,6 @@ func TestResources(t *testing.T) { }`, args: "-C java-res -f java-res/a/a -f java-res/b/b", }, - { - // Test that a module with "include_srcs: true" includes its source files in the resources jar - name: "include sources", - prop: `include_srcs: true`, - args: "-C . -f a.java -f b.java -f c.java", - }, { // Test that a module with wildcards in java_resource_dirs has the correct path prefixes name: "wildcard dirs", @@ -555,6 +549,69 @@ func TestResources(t *testing.T) { } } +func TestIncludeSrcs(t *testing.T) { + ctx := testJava(t, ` + java_library { + name: "foo", + srcs: [ + "a.java", + "b.java", + "c.java", + ], + include_srcs: true, + } + + java_library { + name: "bar", + srcs: [ + "a.java", + "b.java", + "c.java", + ], + java_resource_dirs: ["java-res"], + include_srcs: true, + } + `) + + // Test a library with include_srcs: true + foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar") + fooSrcJar := ctx.ModuleForTests("foo", "android_common").Output("foo.srcjar") + + if g, w := fooSrcJar.Output.String(), foo.Inputs.Strings(); !inList(g, w) { + t.Errorf("foo combined jars %v does not contain %q", w, g) + } + + if g, w := fooSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w { + t.Errorf("foo source jar args %q is not %q", w, g) + } + + // Test a library with include_srcs: true and resources + bar := ctx.ModuleForTests("bar", "android_common").Output("withres/bar.jar") + barResCombined := ctx.ModuleForTests("bar", "android_common").Output("res-combined/bar.jar") + barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar") + barSrcJar := ctx.ModuleForTests("bar", "android_common").Output("bar.srcjar") + + if g, w := barSrcJar.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) { + t.Errorf("bar combined resource jars %v does not contain %q", w, g) + } + + if g, w := barRes.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) { + t.Errorf("bar combined resource jars %v does not contain %q", w, g) + } + + if g, w := barResCombined.Output.String(), bar.Inputs.Strings(); !inList(g, w) { + t.Errorf("bar combined jars %v does not contain %q", w, g) + } + + if g, w := barSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w { + t.Errorf("bar source jar args %q is not %q", w, g) + } + + if g, w := barRes.Args["jarArgs"], "-C java-res -f java-res/a/a -f java-res/b/b"; g != w { + t.Errorf("bar resource jar args %q is not %q", w, g) + } +} + func TestGeneratedSources(t *testing.T) { ctx := testJava(t, ` java_library {