Merge "Move sh_binary tests for bp2build into their own file."
diff --git a/android/paths.go b/android/paths.go
index 44221be..c3fa61a 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -1949,3 +1949,28 @@
// The install path of the data file, relative to the install root.
RelativeInstallPath string
}
+
+// PathsIfNonNil returns a Paths containing only the non-nil input arguments.
+func PathsIfNonNil(paths ...Path) Paths {
+ if len(paths) == 0 {
+ // Fast path for empty argument list
+ return nil
+ } else if len(paths) == 1 {
+ // Fast path for a single argument
+ if paths[0] != nil {
+ return paths
+ } else {
+ return nil
+ }
+ }
+ ret := make(Paths, 0, len(paths))
+ for _, path := range paths {
+ if path != nil {
+ ret = append(ret, path)
+ }
+ }
+ if len(ret) == 0 {
+ return nil
+ }
+ return ret
+}
diff --git a/apex/apex_test.go b/apex/apex_test.go
index 83eb56a..181946b 100644
--- a/apex/apex_test.go
+++ b/apex/apex_test.go
@@ -4364,7 +4364,7 @@
checkDexJarBuildPath := func(t *testing.T, ctx *android.TestContext, name string) {
// Make sure the import has been given the correct path to the dex jar.
- p := ctx.ModuleForTests(name, "android_common_myapex").Module().(java.Dependency)
+ p := ctx.ModuleForTests(name, "android_common_myapex").Module().(java.UsesLibraryDependency)
dexJarBuildPath := p.DexJarBuildPath()
if expected, actual := ".intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar", android.NormalizePathForTesting(dexJarBuildPath); actual != expected {
t.Errorf("Incorrect DexJarBuildPath value '%s', expected '%s'", actual, expected)
diff --git a/dexpreopt/class_loader_context.go b/dexpreopt/class_loader_context.go
index ec62eb3..ad52b00 100644
--- a/dexpreopt/class_loader_context.go
+++ b/dexpreopt/class_loader_context.go
@@ -489,20 +489,16 @@
}
// Class loader contexts that come from Make via JSON dexpreopt.config. JSON CLC representation is
-// slightly different: it uses a map of library names to their CLC (instead of a list of structs
-// that including the name, as in the Soong CLC representation). The difference is insubstantial, it
-// is caused only by the language differerences between Go and JSON.
+// the same as Soong representation except that SDK versions and paths are represented with strings.
type jsonClassLoaderContext struct {
+ Name string
Host string
Device string
- Subcontexts map[string]*jsonClassLoaderContext
+ Subcontexts []*jsonClassLoaderContext
}
-// A map of <uses-library> name to its on-host and on-device build paths and CLC.
-type jsonClassLoaderContexts map[string]*jsonClassLoaderContext
-
// A map from SDK version (represented with a JSON string) to JSON CLCs.
-type jsonClassLoaderContextMap map[string]map[string]*jsonClassLoaderContext
+type jsonClassLoaderContextMap map[string][]*jsonClassLoaderContext
// Convert JSON CLC map to Soong represenation.
func fromJsonClassLoaderContext(ctx android.PathContext, jClcMap jsonClassLoaderContextMap) ClassLoaderContextMap {
@@ -522,11 +518,11 @@
}
// Recursive helper for fromJsonClassLoaderContext.
-func fromJsonClassLoaderContextRec(ctx android.PathContext, jClcs map[string]*jsonClassLoaderContext) []*ClassLoaderContext {
+func fromJsonClassLoaderContextRec(ctx android.PathContext, jClcs []*jsonClassLoaderContext) []*ClassLoaderContext {
clcs := make([]*ClassLoaderContext, 0, len(jClcs))
- for lib, clc := range jClcs {
+ for _, clc := range jClcs {
clcs = append(clcs, &ClassLoaderContext{
- Name: lib,
+ Name: clc.Name,
Host: constructPath(ctx, clc.Host),
Device: clc.Device,
Subcontexts: fromJsonClassLoaderContextRec(ctx, clc.Subcontexts),
@@ -546,14 +542,15 @@
}
// Recursive helper for toJsonClassLoaderContext.
-func toJsonClassLoaderContextRec(clcs []*ClassLoaderContext) map[string]*jsonClassLoaderContext {
- jClcs := make(map[string]*jsonClassLoaderContext, len(clcs))
+func toJsonClassLoaderContextRec(clcs []*ClassLoaderContext) []*jsonClassLoaderContext {
+ jClcs := make([]*jsonClassLoaderContext, len(clcs))
for _, clc := range clcs {
- jClcs[clc.Name] = &jsonClassLoaderContext{
+ jClcs = append(jClcs, &jsonClassLoaderContext{
+ Name: clc.Name,
Host: clc.Host.String(),
Device: clc.Device,
Subcontexts: toJsonClassLoaderContextRec(clc.Subcontexts),
- }
+ })
}
return jClcs
}
diff --git a/java/aar.go b/java/aar.go
index e3ad252..ac7ae25 100644
--- a/java/aar.go
+++ b/java/aar.go
@@ -28,7 +28,6 @@
)
type AndroidLibraryDependency interface {
- Dependency
ExportPackage() android.Path
ExportedProguardFlagFiles() android.Paths
ExportedRRODirs() []rroDir
@@ -796,9 +795,13 @@
aapt2Link(ctx, a.exportPackage, srcJar, proguardOptionsFile, rTxt, a.extraAaptPackagesFile,
linkFlags, linkDeps, nil, overlayRes, transitiveAssets, nil)
-}
-var _ Dependency = (*AARImport)(nil)
+ ctx.SetProvider(JavaInfoProvider, JavaInfo{
+ HeaderJars: android.PathsIfNonNil(a.classpathFile),
+ ImplementationAndResourcesJars: android.PathsIfNonNil(a.classpathFile),
+ ImplementationJars: android.PathsIfNonNil(a.classpathFile),
+ })
+}
func (a *AARImport) HeaderJars() android.Paths {
return android.Paths{a.classpathFile}
diff --git a/java/device_host_converter.go b/java/device_host_converter.go
index 4914d74..ee7d018 100644
--- a/java/device_host_converter.go
+++ b/java/device_host_converter.go
@@ -97,15 +97,15 @@
}
ctx.VisitDirectDepsWithTag(deviceHostConverterDepTag, func(m android.Module) {
- if dep, ok := m.(Dependency); ok {
- d.headerJars = append(d.headerJars, dep.HeaderJars()...)
- d.implementationJars = append(d.implementationJars, dep.ImplementationJars()...)
- d.implementationAndResourceJars = append(d.implementationAndResourceJars, dep.ImplementationAndResourcesJars()...)
- d.resourceJars = append(d.resourceJars, dep.ResourceJars()...)
+ if ctx.OtherModuleHasProvider(m, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(m, JavaInfoProvider).(JavaInfo)
+ d.headerJars = append(d.headerJars, dep.HeaderJars...)
+ 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...)
+ d.srcJarArgs = append(d.srcJarArgs, dep.SrcJarArgs...)
+ d.srcJarDeps = append(d.srcJarDeps, dep.SrcJarDeps...)
} else {
ctx.PropertyErrorf("libs", "module %q cannot be used as a dependency", ctx.OtherModuleName(m))
}
@@ -131,9 +131,16 @@
d.combinedHeaderJar = d.headerJars[0]
}
-}
+ ctx.SetProvider(JavaInfoProvider, JavaInfo{
+ HeaderJars: d.headerJars,
+ ImplementationAndResourcesJars: d.implementationAndResourceJars,
+ ImplementationJars: d.implementationJars,
+ ResourceJars: d.resourceJars,
+ SrcJarArgs: d.srcJarArgs,
+ SrcJarDeps: d.srcJarDeps,
+ })
-var _ Dependency = (*DeviceHostConverter)(nil)
+}
func (d *DeviceHostConverter) HeaderJars() android.Paths {
return d.headerJars
diff --git a/java/dex.go b/java/dex.go
index 24600c2..e52fdb5 100644
--- a/java/dex.go
+++ b/java/dex.go
@@ -204,8 +204,9 @@
// - prevent ProGuard stripping subclass in the support library that extends class added in the higher SDK version.
// See b/20667396
var proguardRaiseDeps classpath
- ctx.VisitDirectDepsWithTag(proguardRaiseTag, func(dep android.Module) {
- proguardRaiseDeps = append(proguardRaiseDeps, dep.(Dependency).HeaderJars()...)
+ ctx.VisitDirectDepsWithTag(proguardRaiseTag, func(m android.Module) {
+ dep := ctx.OtherModuleProvider(m, JavaInfoProvider).(JavaInfo)
+ proguardRaiseDeps = append(proguardRaiseDeps, dep.HeaderJars...)
})
r8Flags = append(r8Flags, proguardRaiseDeps.FormJavaClassPath("-libraryjars"))
diff --git a/java/droiddoc.go b/java/droiddoc.go
index c74009e..8f1644c 100644
--- a/java/droiddoc.go
+++ b/java/droiddoc.go
@@ -470,8 +470,9 @@
switch tag {
case bootClasspathTag:
- if dep, ok := module.(Dependency); ok {
- deps.bootClasspath = append(deps.bootClasspath, dep.ImplementationJars()...)
+ if ctx.OtherModuleHasProvider(module, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
+ deps.bootClasspath = append(deps.bootClasspath, dep.ImplementationJars...)
} else if sm, ok := module.(SystemModulesProvider); ok {
// A system modules dependency has been added to the bootclasspath
// so add its libs to the bootclasspath.
@@ -480,23 +481,23 @@
panic(fmt.Errorf("unknown dependency %q for %q", otherName, ctx.ModuleName()))
}
case libTag:
- switch dep := module.(type) {
- case SdkLibraryDependency:
+ if dep, ok := module.(SdkLibraryDependency); ok {
deps.classpath = append(deps.classpath, dep.SdkHeaderJars(ctx, j.sdkVersion())...)
- case Dependency:
- deps.classpath = append(deps.classpath, dep.HeaderJars()...)
- deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
- case android.SourceFileProducer:
+ } else if ctx.OtherModuleHasProvider(module, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
+ deps.classpath = append(deps.classpath, dep.HeaderJars...)
+ deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs...)
+ } else if dep, ok := module.(android.SourceFileProducer); ok {
checkProducesJars(ctx, dep)
deps.classpath = append(deps.classpath, dep.Srcs()...)
- default:
+ } else {
ctx.ModuleErrorf("depends on non-java module %q", otherName)
}
case java9LibTag:
- switch dep := module.(type) {
- case Dependency:
- deps.java9Classpath = append(deps.java9Classpath, dep.HeaderJars()...)
- default:
+ if ctx.OtherModuleHasProvider(module, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
+ deps.java9Classpath = append(deps.java9Classpath, dep.HeaderJars...)
+ } else {
ctx.ModuleErrorf("depends on non-java module %q", otherName)
}
case systemModulesTag:
diff --git a/java/hiddenapi.go b/java/hiddenapi.go
index 069595e..1651c1c 100644
--- a/java/hiddenapi.go
+++ b/java/hiddenapi.go
@@ -28,9 +28,27 @@
}, "outFlag", "stubAPIFlags")
type hiddenAPI struct {
- // True if the module containing this structure contributes to the hiddenapi information.
+ // The name of the module as it would be used in the boot jars configuration, e.g. without any
+ // prebuilt_ prefix (if it is a prebuilt), without any "-hiddenapi" suffix if it just provides
+ // annotations and without any ".impl" suffix if it is a java_sdk_library implementation library.
+ configurationName string
+
+ // True if the module containing this structure contributes to the hiddenapi information or has
+ // that information encoded within it.
active bool
+ // Identifies the active module variant which will be used as the source of hiddenapi information.
+ //
+ // A class may be compiled into a number of different module variants each of which will need the
+ // hiddenapi information encoded into it and so will be marked as active. However, only one of
+ // them must be used as a source of information by hiddenapi otherwise it will end up with
+ // duplicate entries. That module will have primary=true.
+ //
+ // Note, that modules <x>-hiddenapi that provide additional annotation information for module <x>
+ // that is on the bootclasspath are marked as primary=true as they are the primary source of that
+ // annotation information.
+ primary bool
+
// True if the module only contains additional annotations and so does not require hiddenapi
// information to be encoded in its dex file and should not be used to generate the
// hiddenAPISingletonPathsStruct.stubFlags file.
@@ -109,18 +127,45 @@
// Modules whose names are of the format <x>-hiddenapi provide hiddenapi information for the boot
// jar module <x>. Otherwise, the module provides information for itself. Either way extract the
- // name of the boot jar module.
- bootJarName := strings.TrimSuffix(name, "-hiddenapi")
+ // configurationName of the boot jar module.
+ configurationName := strings.TrimSuffix(name, "-hiddenapi")
+ h.configurationName = configurationName
// It is important that hiddenapi information is only gathered for/from modules that are actually
// on the boot jars list because the runtime only enforces access to the hidden API for the
// bootclassloader. If information is gathered for modules not on the list then that will cause
// failures in the CtsHiddenApiBlocklist... tests.
- h.active = inList(bootJarName, ctx.Config().BootJars())
+ h.active = inList(configurationName, ctx.Config().BootJars())
+ if !h.active {
+ // The rest of the properties will be ignored if active is false.
+ return
+ }
// If this module has a suffix of -hiddenapi then it only provides additional annotation
// information for a module on the boot jars list.
h.annotationsOnly = strings.HasSuffix(name, "-hiddenapi")
+
+ // Determine whether this module is the primary module or not.
+ primary := true
+
+ // A prebuilt module is only primary if it is preferred and conversely a source module is only
+ // primary if it has not been replaced by a prebuilt module.
+ module := ctx.Module()
+ if pi, ok := module.(android.PrebuiltInterface); ok {
+ if p := pi.Prebuilt(); p != nil {
+ primary = p.UsePrebuilt()
+ }
+ } else {
+ // The only module that will pass a different name to its module name to this method is the
+ // implementation library of a java_sdk_library. It has a configuration name of <x> the same
+ // as its parent java_sdk_library but a module name of <x>.impl. It is not the primary module,
+ // the java_sdk_library with the name of <x> is.
+ primary = name == ctx.ModuleName()
+
+ // A source module that has been replaced by a prebuilt can never be the primary module.
+ primary = primary && !module.IsReplacedByPrebuilt()
+ }
+ h.primary = primary
}
// hiddenAPIExtractAndEncode is called by any module that could contribute to the hiddenapi
@@ -137,17 +182,17 @@
// 3. Conditionally creates a copy of the supplied dex file into which it has encoded the hiddenapi
// flags and returns this instead of the supplied dex jar, otherwise simply returns the supplied
// dex jar.
-func (h *hiddenAPI) hiddenAPIExtractAndEncode(ctx android.ModuleContext, name string, primary bool, dexJar android.OutputPath,
+func (h *hiddenAPI) hiddenAPIExtractAndEncode(ctx android.ModuleContext, dexJar android.OutputPath,
implementationJar android.Path, uncompressDex bool) android.OutputPath {
if !h.active {
return dexJar
}
- h.hiddenAPIExtractInformation(ctx, dexJar, implementationJar, primary)
+ h.hiddenAPIExtractInformation(ctx, dexJar, implementationJar)
if !h.annotationsOnly {
- hiddenAPIJar := android.PathForModuleOut(ctx, "hiddenapi", name+".jar").OutputPath
+ hiddenAPIJar := android.PathForModuleOut(ctx, "hiddenapi", h.configurationName+".jar").OutputPath
// Create a copy of the dex jar which has been encoded with hiddenapi flags.
hiddenAPIEncodeDex(ctx, hiddenAPIJar, dexJar, uncompressDex)
@@ -164,7 +209,7 @@
//
// It also makes the dex jar available for use when generating the
// hiddenAPISingletonPathsStruct.stubFlags.
-func (h *hiddenAPI) hiddenAPIExtractInformation(ctx android.ModuleContext, dexJar, classesJar android.Path, primary bool) {
+func (h *hiddenAPI) hiddenAPIExtractInformation(ctx android.ModuleContext, dexJar, classesJar android.Path) {
if !h.active {
return
}
@@ -172,7 +217,7 @@
// More than one library with the same classes may need to be encoded but only one should be
// used as a source of information for hidden API processing otherwise it will result in
// duplicate entries in the files.
- if !primary {
+ if !h.primary {
return
}
diff --git a/java/hiddenapi_singleton.go b/java/hiddenapi_singleton.go
index 568d15f..6341a34 100644
--- a/java/hiddenapi_singleton.go
+++ b/java/hiddenapi_singleton.go
@@ -223,7 +223,7 @@
ctx.VisitAllModules(func(module android.Module) {
// Collect dex jar paths for the modules listed above.
- if j, ok := module.(Dependency); ok {
+ if j, ok := module.(UsesLibraryDependency); ok {
name := ctx.ModuleName(module)
for moduleList, pathList := range moduleListToPathList {
if i := android.IndexList(name, *moduleList); i != -1 {
diff --git a/java/hiddenapi_singleton_test.go b/java/hiddenapi_singleton_test.go
index 77cfff4..df825bb 100644
--- a/java/hiddenapi_singleton_test.go
+++ b/java/hiddenapi_singleton_test.go
@@ -84,6 +84,12 @@
compile_dex: true,
}
+ java_library {
+ name: "foo-hiddenapi",
+ srcs: ["a.java"],
+ compile_dex: true,
+ }
+
java_import {
name: "foo",
jars: ["a.jar"],
@@ -102,6 +108,7 @@
indexRule := hiddenAPIIndex.Rule("singleton-merged-hiddenapi-index")
CheckHiddenAPIRuleInputs(t, `
.intermediates/bar/android_common/hiddenapi/index.csv
+.intermediates/foo-hiddenapi/android_common/hiddenapi/index.csv
.intermediates/foo/android_common/hiddenapi/index.csv
`,
indexRule)
diff --git a/java/java.go b/java/java.go
index 8cf4ee5..338140b 100644
--- a/java/java.go
+++ b/java/java.go
@@ -533,6 +533,53 @@
var _ android.OutputFileProducer = (*Module)(nil)
+// JavaInfo contains information about a java module for use by modules that depend on it.
+type JavaInfo struct {
+ // HeaderJars is a list of jars that can be passed as the javac classpath in order to link
+ // against this module. If empty, ImplementationJars should be used instead.
+ HeaderJars android.Paths
+
+ // ImplementationAndResourceJars is a list of jars that contain the implementations of classes
+ // in the module as well as any resources included in the module.
+ ImplementationAndResourcesJars android.Paths
+
+ // ImplementationJars is a list of jars that contain the implementations of classes in the
+ //module.
+ ImplementationJars android.Paths
+
+ // ResourceJars is a list of jars that contain the resources included in the module.
+ ResourceJars android.Paths
+
+ // AidlIncludeDirs is a list of directories that should be passed to the aidl tool when
+ // depending on this module.
+ AidlIncludeDirs android.Paths
+
+ // SrcJarArgs is a list of arguments to pass to soong_zip to package the sources of this
+ // module.
+ SrcJarArgs []string
+
+ // SrcJarDeps is a list of paths to depend on when packaging the sources of this module.
+ SrcJarDeps android.Paths
+
+ // ExportedPlugins is a list of paths that should be used as annotation processors for any
+ // module that depends on this module.
+ ExportedPlugins android.Paths
+
+ // ExportedPluginClasses is a list of classes that should be run as annotation processors for
+ // any module that depends on this module.
+ ExportedPluginClasses []string
+
+ // ExportedPluginDisableTurbine is true if this module's annotation processors generate APIs,
+ // requiring disbling turbine for any modules that depend on it.
+ ExportedPluginDisableTurbine bool
+
+ // JacocoReportClassesFile is the path to a jar containing uninstrumented classes that will be
+ // instrumented by jacoco.
+ JacocoReportClassesFile android.Path
+}
+
+var JavaInfoProvider = blueprint.NewProvider(JavaInfo{})
+
// Methods that need to be implemented for a module that is added to apex java_libs property.
type ApexDependency interface {
HeaderJars() android.Paths
@@ -546,18 +593,6 @@
ClassLoaderContexts() dexpreopt.ClassLoaderContextMap
}
-type Dependency interface {
- ApexDependency
- UsesLibraryDependency
- ImplementationJars() android.Paths
- ResourceJars() android.Paths
- AidlIncludeDirs() android.Paths
- ExportedPlugins() (android.Paths, []string, bool)
- SrcJarArgs() ([]string, android.Paths)
- BaseModuleName() string
- JacocoReportClassesFile() android.Path
-}
-
type xref interface {
XrefJavaFiles() android.Paths
}
@@ -1111,44 +1146,42 @@
return
}
- switch dep := module.(type) {
- case SdkLibraryDependency:
+ if dep, ok := module.(SdkLibraryDependency); ok {
switch tag {
case libTag:
deps.classpath = append(deps.classpath, dep.SdkHeaderJars(ctx, j.sdkVersion())...)
case staticLibTag:
ctx.ModuleErrorf("dependency on java_sdk_library %q can only be in libs", otherName)
}
- case Dependency:
+ } else if ctx.OtherModuleHasProvider(module, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
switch tag {
case bootClasspathTag:
- deps.bootClasspath = append(deps.bootClasspath, dep.HeaderJars()...)
+ deps.bootClasspath = append(deps.bootClasspath, dep.HeaderJars...)
case libTag, instrumentationForTag:
- deps.classpath = append(deps.classpath, dep.HeaderJars()...)
- deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
- pluginJars, pluginClasses, disableTurbine := dep.ExportedPlugins()
- addPlugins(&deps, pluginJars, pluginClasses...)
- deps.disableTurbine = deps.disableTurbine || disableTurbine
+ deps.classpath = append(deps.classpath, dep.HeaderJars...)
+ deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs...)
+ addPlugins(&deps, dep.ExportedPlugins, dep.ExportedPluginClasses...)
+ deps.disableTurbine = deps.disableTurbine || dep.ExportedPluginDisableTurbine
case java9LibTag:
- deps.java9Classpath = append(deps.java9Classpath, dep.HeaderJars()...)
+ deps.java9Classpath = append(deps.java9Classpath, dep.HeaderJars...)
case staticLibTag:
- deps.classpath = append(deps.classpath, dep.HeaderJars()...)
- deps.staticJars = append(deps.staticJars, dep.ImplementationJars()...)
- deps.staticHeaderJars = append(deps.staticHeaderJars, dep.HeaderJars()...)
- deps.staticResourceJars = append(deps.staticResourceJars, dep.ResourceJars()...)
- deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
- pluginJars, pluginClasses, disableTurbine := dep.ExportedPlugins()
- addPlugins(&deps, pluginJars, pluginClasses...)
+ deps.classpath = append(deps.classpath, dep.HeaderJars...)
+ deps.staticJars = append(deps.staticJars, dep.ImplementationJars...)
+ deps.staticHeaderJars = append(deps.staticHeaderJars, dep.HeaderJars...)
+ deps.staticResourceJars = append(deps.staticResourceJars, dep.ResourceJars...)
+ deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs...)
+ addPlugins(&deps, dep.ExportedPlugins, dep.ExportedPluginClasses...)
// Turbine doesn't run annotation processors, so any module that uses an
// annotation processor that generates API is incompatible with the turbine
// optimization.
- deps.disableTurbine = deps.disableTurbine || disableTurbine
+ deps.disableTurbine = deps.disableTurbine || dep.ExportedPluginDisableTurbine
case pluginTag:
- if plugin, ok := dep.(*Plugin); ok {
+ if plugin, ok := module.(*Plugin); ok {
if plugin.pluginProperties.Processor_class != nil {
- addPlugins(&deps, plugin.ImplementationAndResourcesJars(), *plugin.pluginProperties.Processor_class)
+ addPlugins(&deps, dep.ImplementationAndResourcesJars, *plugin.pluginProperties.Processor_class)
} else {
- addPlugins(&deps, plugin.ImplementationAndResourcesJars())
+ addPlugins(&deps, dep.ImplementationAndResourcesJars)
}
// Turbine doesn't run annotation processors, so any module that uses an
// annotation processor that generates API is incompatible with the turbine
@@ -1158,14 +1191,14 @@
ctx.PropertyErrorf("plugins", "%q is not a java_plugin module", otherName)
}
case errorpronePluginTag:
- if plugin, ok := dep.(*Plugin); ok {
- deps.errorProneProcessorPath = append(deps.errorProneProcessorPath, plugin.ImplementationAndResourcesJars()...)
+ if _, ok := module.(*Plugin); ok {
+ deps.errorProneProcessorPath = append(deps.errorProneProcessorPath, dep.ImplementationAndResourcesJars...)
} else {
ctx.PropertyErrorf("plugins", "%q is not a java_plugin module", otherName)
}
case exportedPluginTag:
- if plugin, ok := dep.(*Plugin); ok {
- j.exportedPluginJars = append(j.exportedPluginJars, plugin.ImplementationAndResourcesJars()...)
+ if plugin, ok := module.(*Plugin); ok {
+ j.exportedPluginJars = append(j.exportedPluginJars, dep.ImplementationAndResourcesJars...)
if plugin.pluginProperties.Processor_class != nil {
j.exportedPluginClasses = append(j.exportedPluginClasses, *plugin.pluginProperties.Processor_class)
}
@@ -1177,12 +1210,11 @@
ctx.PropertyErrorf("exported_plugins", "%q is not a java_plugin module", otherName)
}
case kotlinStdlibTag:
- deps.kotlinStdlib = append(deps.kotlinStdlib, dep.HeaderJars()...)
+ deps.kotlinStdlib = append(deps.kotlinStdlib, dep.HeaderJars...)
case kotlinAnnotationsTag:
- deps.kotlinAnnotations = dep.HeaderJars()
+ deps.kotlinAnnotations = dep.HeaderJars
}
-
- case android.SourceFileProducer:
+ } else if dep, ok := module.(android.SourceFileProducer); ok {
switch tag {
case libTag:
checkProducesJars(ctx, dep)
@@ -1193,7 +1225,7 @@
deps.staticJars = append(deps.staticJars, dep.Srcs()...)
deps.staticHeaderJars = append(deps.staticHeaderJars, dep.Srcs()...)
}
- default:
+ } else {
switch tag {
case bootClasspathTag:
// If a system modules dependency has been added to the bootclasspath
@@ -1798,14 +1830,8 @@
return
}
- configurationName := j.ConfigurationName()
- primary := configurationName == ctx.ModuleName()
- // If the prebuilt is being used rather than the from source, skip this
- // module to prevent duplicated classes
- primary = primary && !j.IsReplacedByPrebuilt()
-
// Hidden API CSV generation and dex encoding
- dexOutputFile = j.hiddenAPIExtractAndEncode(ctx, configurationName, primary, dexOutputFile, j.implementationJarFile,
+ dexOutputFile = j.hiddenAPIExtractAndEncode(ctx, dexOutputFile, j.implementationJarFile,
proptools.Bool(j.dexProperties.Uncompress_dex))
// merge dex jar with resources if necessary
@@ -1866,6 +1892,20 @@
ctx.CheckbuildFile(outputFile)
+ ctx.SetProvider(JavaInfoProvider, JavaInfo{
+ HeaderJars: android.PathsIfNonNil(j.headerJarFile),
+ ImplementationAndResourcesJars: android.PathsIfNonNil(j.implementationAndResourcesJar),
+ ImplementationJars: android.PathsIfNonNil(j.implementationJarFile),
+ ResourceJars: android.PathsIfNonNil(j.resourceJar),
+ AidlIncludeDirs: j.exportAidlIncludeDirs,
+ SrcJarArgs: j.srcJarArgs,
+ SrcJarDeps: j.srcJarDeps,
+ ExportedPlugins: j.exportedPluginJars,
+ ExportedPluginClasses: j.exportedPluginClasses,
+ ExportedPluginDisableTurbine: j.exportedDisableTurbine,
+ JacocoReportClassesFile: j.jacocoReportClassesFile,
+ })
+
// Save the output file with no relative path so that it doesn't end up in a subdirectory when used as a resource
j.outputFile = outputFile.WithoutRel()
}
@@ -1973,8 +2013,6 @@
return instrumentedJar
}
-var _ Dependency = (*Module)(nil)
-
func (j *Module) HeaderJars() android.Paths {
if j.headerJarFile == nil {
return nil
@@ -2886,15 +2924,15 @@
ctx.VisitDirectDeps(func(module android.Module) {
tag := ctx.OtherModuleDependencyTag(module)
- switch dep := module.(type) {
- case Dependency:
+ if ctx.OtherModuleHasProvider(module, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
switch tag {
case libTag, staticLibTag:
- flags.classpath = append(flags.classpath, dep.HeaderJars()...)
+ flags.classpath = append(flags.classpath, dep.HeaderJars...)
case bootClasspathTag:
- flags.bootClasspath = append(flags.bootClasspath, dep.HeaderJars()...)
+ flags.bootClasspath = append(flags.bootClasspath, dep.HeaderJars...)
}
- case SdkLibraryDependency:
+ } else if dep, ok := module.(SdkLibraryDependency); ok {
switch tag {
case libTag:
flags.classpath = append(flags.classpath, dep.SdkHeaderJars(ctx, j.sdkVersion())...)
@@ -2917,9 +2955,6 @@
j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.properties.Aidl.Export_include_dirs)
if ctx.Device() {
- configurationName := j.BaseModuleName()
- primary := j.Prebuilt().UsePrebuilt()
-
// If this is a variant created for a prebuilt_apex then use the dex implementation jar
// obtained from the associated deapexer module.
ai := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
@@ -2935,7 +2970,7 @@
di := ctx.OtherModuleProvider(deapexerModule, android.DeapexerProvider).(android.DeapexerInfo)
if dexOutputPath := di.PrebuiltExportPath(j.BaseModuleName(), ".dexjar"); dexOutputPath != nil {
j.dexJarFile = dexOutputPath
- j.hiddenAPI.hiddenAPIExtractInformation(ctx, dexOutputPath, outputFile, primary)
+ j.hiddenAPIExtractInformation(ctx, dexOutputPath, outputFile)
} else {
// This should never happen as a variant for a prebuilt_apex is only created if the
// prebuilt_apex has been configured to export the java library dex file.
@@ -2967,12 +3002,19 @@
}
// Hidden API CSV generation and dex encoding
- dexOutputFile = j.hiddenAPIExtractAndEncode(ctx, configurationName, primary, dexOutputFile, outputFile,
+ dexOutputFile = j.hiddenAPIExtractAndEncode(ctx, dexOutputFile, outputFile,
proptools.Bool(j.dexProperties.Uncompress_dex))
j.dexJarFile = dexOutputFile
}
}
+
+ ctx.SetProvider(JavaInfoProvider, JavaInfo{
+ HeaderJars: android.PathsIfNonNil(j.combinedClasspathFile),
+ ImplementationAndResourcesJars: android.PathsIfNonNil(j.combinedClasspathFile),
+ ImplementationJars: android.PathsIfNonNil(j.combinedClasspathFile),
+ AidlIncludeDirs: j.exportAidlIncludeDirs,
+ })
}
func (j *Import) OutputFiles(tag string) (android.Paths, error) {
@@ -2986,8 +3028,6 @@
var _ android.OutputFileProducer = (*Import)(nil)
-var _ Dependency = (*Import)(nil)
-
func (j *Import) HeaderJars() android.Paths {
if j.combinedClasspathFile == nil {
return nil
diff --git a/java/jdeps.go b/java/jdeps.go
index 2b5ee74..0ab2e42 100644
--- a/java/jdeps.go
+++ b/java/jdeps.go
@@ -87,8 +87,9 @@
dpInfo.Classes = append(dpInfo.Classes, data.Class)
}
- if dep, ok := module.(Dependency); ok {
- dpInfo.Installed_paths = append(dpInfo.Installed_paths, dep.ImplementationJars().Strings()...)
+ if ctx.ModuleHasProvider(module, JavaInfoProvider) {
+ dep := ctx.ModuleProvider(module, JavaInfoProvider).(JavaInfo)
+ dpInfo.Installed_paths = append(dpInfo.Installed_paths, dep.ImplementationJars.Strings()...)
}
dpInfo.Classes = android.FirstUniqueStrings(dpInfo.Classes)
dpInfo.Installed_paths = android.FirstUniqueStrings(dpInfo.Installed_paths)
diff --git a/java/lint.go b/java/lint.go
index cd2a904..c9e0cdd 100644
--- a/java/lint.go
+++ b/java/lint.go
@@ -276,8 +276,9 @@
extraLintCheckModules := ctx.GetDirectDepsWithTag(extraLintCheckTag)
for _, extraLintCheckModule := range extraLintCheckModules {
- if dep, ok := extraLintCheckModule.(Dependency); ok {
- l.extraLintCheckJars = append(l.extraLintCheckJars, dep.ImplementationAndResourcesJars()...)
+ if ctx.OtherModuleHasProvider(extraLintCheckModule, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(extraLintCheckModule, JavaInfoProvider).(JavaInfo)
+ l.extraLintCheckJars = append(l.extraLintCheckJars, dep.ImplementationAndResourcesJars...)
} else {
ctx.PropertyErrorf("lint.extra_check_modules",
"%s is not a java module", ctx.OtherModuleName(extraLintCheckModule))
diff --git a/java/robolectric.go b/java/robolectric.go
index c821e5b..98bb710 100644
--- a/java/robolectric.go
+++ b/java/robolectric.go
@@ -148,10 +148,10 @@
}
for _, dep := range ctx.GetDirectDepsWithTag(libTag) {
- m := dep.(Dependency)
- r.libs = append(r.libs, m.BaseModuleName())
- if !android.InList(m.BaseModuleName(), config.FrameworkLibraries) {
- combinedJarJars = append(combinedJarJars, m.ImplementationAndResourcesJars()...)
+ m := ctx.OtherModuleProvider(dep, JavaInfoProvider).(JavaInfo)
+ r.libs = append(r.libs, ctx.OtherModuleName(dep))
+ if !android.InList(ctx.OtherModuleName(dep), config.FrameworkLibraries) {
+ combinedJarJars = append(combinedJarJars, m.ImplementationAndResourcesJars...)
}
}
@@ -245,10 +245,10 @@
srcJarDeps := append(android.Paths(nil), instrumentedApp.srcJarDeps...)
for _, m := range ctx.GetDirectDepsWithTag(roboCoverageLibsTag) {
- if dep, ok := m.(Dependency); ok {
- depSrcJarArgs, depSrcJarDeps := dep.SrcJarArgs()
- srcJarArgs = append(srcJarArgs, depSrcJarArgs...)
- srcJarDeps = append(srcJarDeps, depSrcJarDeps...)
+ if ctx.OtherModuleHasProvider(m, JavaInfoProvider) {
+ dep := ctx.OtherModuleProvider(m, JavaInfoProvider).(JavaInfo)
+ srcJarArgs = append(srcJarArgs, dep.SrcJarArgs...)
+ srcJarDeps = append(srcJarDeps, dep.SrcJarDeps...)
}
}
diff --git a/java/sdk.go b/java/sdk.go
index a68abfb..74d5a81 100644
--- a/java/sdk.go
+++ b/java/sdk.go
@@ -566,10 +566,11 @@
ctx.VisitAllModules(func(module android.Module) {
// Collect dex jar paths for the modules listed above.
- if j, ok := module.(Dependency); ok {
+ if ctx.ModuleHasProvider(module, JavaInfoProvider) {
+ j := ctx.ModuleProvider(module, JavaInfoProvider).(JavaInfo)
name := ctx.ModuleName(module)
if i := android.IndexList(name, stubsModules); i != -1 {
- stubsJars[i] = j.HeaderJars()
+ stubsJars[i] = j.HeaderJars
}
}
})
@@ -640,14 +641,26 @@
if ctx.Config().PlatformSdkCodename() == "REL" {
cmd.Text("echo REL >").Output(out)
- } else if !ctx.Config().AlwaysUsePrebuiltSdks() {
- in, err := ctx.GlobWithDeps("frameworks/base/api/*current.txt", nil)
- if err != nil {
- ctx.Errorf("error globbing API files: %s", err)
+ } else if ctx.Config().FrameworksBaseDirExists(ctx) && !ctx.Config().AlwaysUsePrebuiltSdks() {
+ cmd.Text("cat")
+ apiTxtFileModules := []string{
+ "frameworks-base-api-current.txt",
+ "frameworks-base-api-system-current.txt",
+ "frameworks-base-api-module-lib-current.txt",
}
-
- cmd.Text("cat").
- Inputs(android.PathsForSource(ctx, in)).
+ count := 0
+ ctx.VisitAllModules(func(module android.Module) {
+ name := ctx.ModuleName(module)
+ if android.InList(name, apiTxtFileModules) {
+ cmd.Inputs(android.OutputFilesForModule(ctx, module, ""))
+ count++
+ }
+ })
+ if count != len(apiTxtFileModules) {
+ ctx.Errorf("Could not find all the expected API modules %v, found %d\n", apiTxtFileModules, count)
+ return
+ }
+ cmd.Input(android.PathForSource(ctx, "frameworks/base/services/api/current.txt")).
Text("| md5sum | cut -d' ' -f1 >").
Output(out)
} else {
diff --git a/java/sdk_library.go b/java/sdk_library.go
index 638740f..aa96e0d 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -60,12 +60,12 @@
apiScope *apiScope
// Function for extracting appropriate path information from the dependency.
- depInfoExtractor func(paths *scopePaths, dep android.Module) error
+ depInfoExtractor func(paths *scopePaths, ctx android.ModuleContext, dep android.Module) error
}
// Extract tag specific information from the dependency.
func (tag scopeDependencyTag) extractDepInfo(ctx android.ModuleContext, dep android.Module, paths *scopePaths) {
- err := tag.depInfoExtractor(paths, dep)
+ err := tag.depInfoExtractor(paths, ctx, dep)
if err != nil {
ctx.ModuleErrorf("has an invalid {scopeDependencyTag: %s} dependency on module %s: %s", tag.name, ctx.OtherModuleName(dep), err.Error())
}
@@ -539,13 +539,14 @@
stubsSrcJar android.OptionalPath
}
-func (paths *scopePaths) extractStubsLibraryInfoFromDependency(dep android.Module) error {
- if lib, ok := dep.(Dependency); ok {
- paths.stubsHeaderPath = lib.HeaderJars()
- paths.stubsImplPath = lib.ImplementationJars()
+func (paths *scopePaths) extractStubsLibraryInfoFromDependency(ctx android.ModuleContext, dep android.Module) error {
+ if ctx.OtherModuleHasProvider(dep, JavaInfoProvider) {
+ lib := ctx.OtherModuleProvider(dep, JavaInfoProvider).(JavaInfo)
+ paths.stubsHeaderPath = lib.HeaderJars
+ paths.stubsImplPath = lib.ImplementationJars
return nil
} else {
- return fmt.Errorf("expected module that implements Dependency, e.g. java_library")
+ return fmt.Errorf("expected module that has JavaInfoProvider, e.g. java_library")
}
}
@@ -572,7 +573,7 @@
paths.removedApiFilePath = android.OptionalPathForPath(provider.RemovedApiFilePath())
}
-func (paths *scopePaths) extractApiInfoFromDep(dep android.Module) error {
+func (paths *scopePaths) extractApiInfoFromDep(ctx android.ModuleContext, dep android.Module) error {
return paths.treatDepAsApiStubsProvider(dep, func(provider ApiStubsProvider) {
paths.extractApiInfoFromApiStubsProvider(provider)
})
@@ -582,13 +583,13 @@
paths.stubsSrcJar = android.OptionalPathForPath(provider.StubsSrcJar())
}
-func (paths *scopePaths) extractStubsSourceInfoFromDep(dep android.Module) error {
+func (paths *scopePaths) extractStubsSourceInfoFromDep(ctx android.ModuleContext, dep android.Module) error {
return paths.treatDepAsApiStubsSrcProvider(dep, func(provider ApiStubsSrcProvider) {
paths.extractStubsSourceInfoFromApiStubsProviders(provider)
})
}
-func (paths *scopePaths) extractStubsSourceAndApiInfoFromApiStubsProvider(dep android.Module) error {
+func (paths *scopePaths) extractStubsSourceAndApiInfoFromApiStubsProvider(ctx android.ModuleContext, dep android.Module) error {
return paths.treatDepAsApiStubsProvider(dep, func(provider ApiStubsProvider) {
paths.extractApiInfoFromApiStubsProvider(provider)
paths.extractStubsSourceInfoFromApiStubsProviders(provider)
@@ -951,7 +952,6 @@
commonToSdkLibraryAndImport
}
-var _ Dependency = (*SdkLibrary)(nil)
var _ SdkLibraryDependency = (*SdkLibrary)(nil)
func (module *SdkLibrary) generateTestAndSystemScopesByDefault() bool {
diff --git a/java/system_modules.go b/java/system_modules.go
index 5cc546d..95f71b8 100644
--- a/java/system_modules.go
+++ b/java/system_modules.go
@@ -160,8 +160,8 @@
var jars android.Paths
ctx.VisitDirectDepsWithTag(systemModulesLibsTag, func(module android.Module) {
- dep, _ := module.(Dependency)
- jars = append(jars, dep.HeaderJars()...)
+ dep, _ := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
+ jars = append(jars, dep.HeaderJars...)
})
system.headerJars = jars
diff --git a/rust/compiler.go b/rust/compiler.go
index 586063e..c26f208 100644
--- a/rust/compiler.go
+++ b/rust/compiler.go
@@ -232,6 +232,10 @@
flags.LinkFlags = append(flags.LinkFlags, "-Wl,-rpath,"+rpathPrefix+"../"+rpath)
}
+ if ctx.RustModule().UseVndk() {
+ flags.RustFlags = append(flags.RustFlags, "--cfg 'android_vndk'")
+ }
+
return flags
}
@@ -254,7 +258,7 @@
if !Bool(compiler.Properties.No_stdlibs) {
for _, stdlib := range config.Stdlibs {
// If we're building for the primary arch of the build host, use the compiler's stdlibs
- if ctx.Target().Os == android.BuildOs && ctx.TargetPrimary() {
+ if ctx.Target().Os == android.BuildOs {
stdlib = stdlib + "_" + ctx.toolchain().RustTriple()
}
diff --git a/rust/image_test.go b/rust/image_test.go
index 1515aa2..e40599c 100644
--- a/rust/image_test.go
+++ b/rust/image_test.go
@@ -15,6 +15,7 @@
package rust
import (
+ "strings"
"testing"
"android/soong/android"
@@ -23,7 +24,7 @@
// Test that cc modules can link against vendor_available rust_ffi_static libraries.
func TestVendorLinkage(t *testing.T) {
- ctx := testRust(t, `
+ ctx := testRustVndk(t, `
cc_binary {
name: "fizz_vendor",
static_libs: ["libfoo_vendor"],
@@ -37,16 +38,34 @@
}
`)
- vendorBinary := ctx.ModuleForTests("fizz_vendor", "android_arm64_armv8-a").Module().(*cc.Module)
+ vendorBinary := ctx.ModuleForTests("fizz_vendor", "android_vendor.VER_arm64_armv8-a").Module().(*cc.Module)
if !android.InList("libfoo_vendor", vendorBinary.Properties.AndroidMkStaticLibs) {
t.Errorf("vendorBinary should have a dependency on libfoo_vendor")
}
}
+// Test that variants which use the vndk emit the appropriate cfg flag.
+func TestImageVndkCfgFlag(t *testing.T) {
+ ctx := testRustVndk(t, `
+ rust_ffi_static {
+ name: "libfoo",
+ crate_name: "foo",
+ srcs: ["foo.rs"],
+ vendor_available: true,
+ }
+ `)
+
+ vendor := ctx.ModuleForTests("libfoo", "android_vendor.VER_arm64_armv8-a_static").Rule("rustc")
+
+ if !strings.Contains(vendor.Args["rustcFlags"], "--cfg 'android_vndk'") {
+ t.Errorf("missing \"--cfg 'android_vndk'\" for libfoo vendor variant, rustcFlags: %#v", vendor.Args["rustcFlags"])
+ }
+}
+
// Test that cc modules can link against vendor_ramdisk_available rust_ffi_static libraries.
func TestVendorRamdiskLinkage(t *testing.T) {
- ctx := testRust(t, `
+ ctx := testRustVndk(t, `
cc_library_static {
name: "libcc_vendor_ramdisk",
static_libs: ["libfoo_vendor_ramdisk"],
diff --git a/rust/rust_test.go b/rust/rust_test.go
index 88d9643..a0ed534 100644
--- a/rust/rust_test.go
+++ b/rust/rust_test.go
@@ -64,6 +64,14 @@
return tctx.parse(t)
}
+func testRustVndk(t *testing.T, bp string) *android.TestContext {
+ tctx := newTestRustCtx(t, bp)
+ tctx.useMockedFs()
+ tctx.generateConfig()
+ tctx.setVndk(t)
+ return tctx.parse(t)
+}
+
// testRustCov returns a TestContext in which a basic environment has been
// setup. This environment explicitly enables coverage.
func testRustCov(t *testing.T, bp string) *android.TestContext {
@@ -140,6 +148,15 @@
tctx.config.TestProductVariables.NativeCoveragePaths = []string{"*"}
}
+func (tctx *testRustCtx) setVndk(t *testing.T) {
+ if tctx.config == nil {
+ t.Fatalf("tctx.config not been generated yet. Please call generateConfig first.")
+ }
+ tctx.config.TestProductVariables.DeviceVndkVersion = StringPtr("current")
+ tctx.config.TestProductVariables.ProductVndkVersion = StringPtr("current")
+ tctx.config.TestProductVariables.Platform_vndk_version = StringPtr("VER")
+}
+
// parse validates the configuration and parses the Blueprint file. It returns
// a TestContext which can be used to retrieve the generated modules via
// ModuleForTests.
diff --git a/rust/testing.go b/rust/testing.go
index 4c4df4a..1afe27e 100644
--- a/rust/testing.go
+++ b/rust/testing.go
@@ -46,6 +46,30 @@
sysroot: true,
}
rust_prebuilt_library {
+ name: "libstd_i686-unknown-linux-gnu",
+ crate_name: "std",
+ rlib: {
+ srcs: ["libstd.rlib"],
+ },
+ dylib: {
+ srcs: ["libstd.so"],
+ },
+ host_supported: true,
+ sysroot: true,
+ }
+ rust_prebuilt_library {
+ name: "libtest_i686-unknown-linux-gnu",
+ crate_name: "test",
+ rlib: {
+ srcs: ["libtest.rlib"],
+ },
+ dylib: {
+ srcs: ["libtest.so"],
+ },
+ host_supported: true,
+ sysroot: true,
+ }
+ rust_prebuilt_library {
name: "libstd_x86_64-apple-darwin",
crate_name: "std",
rlib: {
diff --git a/scripts/build-mainline-modules.sh b/scripts/build-mainline-modules.sh
index b8485ea..ac67438 100755
--- a/scripts/build-mainline-modules.sh
+++ b/scripts/build-mainline-modules.sh
@@ -26,6 +26,8 @@
platform-mainline-test-exports
runtime-module-host-exports
runtime-module-sdk
+ stats-log-api-gen-exports
+ statsd-module-sdk
tzdata-module-test-exports
)