Merge "Remove "flattened" apexes"
diff --git a/aconfig/Android.bp b/aconfig/Android.bp
new file mode 100644
index 0000000..d19b543
--- /dev/null
+++ b/aconfig/Android.bp
@@ -0,0 +1,32 @@
+package {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+bootstrap_go_package {
+ name: "soong-aconfig",
+ pkgPath: "android/soong/aconfig",
+ deps: [
+ "blueprint",
+ "blueprint-pathtools",
+ "sbox_proto",
+ "soong",
+ "soong-android",
+ "soong-bazel",
+ "soong-android",
+ "soong-java",
+ ],
+ srcs: [
+ "aconfig_declarations.go",
+ "aconfig_values.go",
+ "aconfig_value_set.go",
+ "init.go",
+ "java_aconfig_library.go",
+ "testing.go",
+ ],
+ testSrcs: [
+ "aconfig_declarations_test.go",
+ "aconfig_values_test.go",
+ "aconfig_value_set_test.go",
+ ],
+ pluginFor: ["soong_build"],
+}
diff --git a/device_config/device_config_definitions.go b/aconfig/aconfig_declarations.go
similarity index 62%
rename from device_config/device_config_definitions.go
rename to aconfig/aconfig_declarations.go
index bb78695..007d529 100644
--- a/device_config/device_config_definitions.go
+++ b/aconfig/aconfig_declarations.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
@@ -21,27 +21,27 @@
"strings"
)
-type DefinitionsModule struct {
+type DeclarationsModule struct {
android.ModuleBase
android.DefaultableModuleBase
- // Properties for "device_config_definitions"
+ // Properties for "aconfig_declarations"
properties struct {
// aconfig files, relative to this Android.bp file
Srcs []string `android:"path"`
- // Release config flag namespace
- Namespace string
+ // Release config flag package
+ Package string
- // Values from TARGET_RELEASE / RELEASE_DEVICE_CONFIG_VALUE_SETS
+ // Values from TARGET_RELEASE / RELEASE_ACONFIG_VALUE_SETS
Values []string `blueprint:"mutated"`
}
intermediatePath android.WritablePath
}
-func DefinitionsFactory() android.Module {
- module := &DefinitionsModule{}
+func DeclarationsFactory() android.Module {
+ module := &DeclarationsModule{}
android.InitAndroidModule(module)
android.InitDefaultableModule(module)
@@ -58,24 +58,24 @@
var implicitValuesTag = implicitValuesTagType{}
-func (module *DefinitionsModule) DepsMutator(ctx android.BottomUpMutatorContext) {
+func (module *DeclarationsModule) DepsMutator(ctx android.BottomUpMutatorContext) {
// Validate Properties
if len(module.properties.Srcs) == 0 {
ctx.PropertyErrorf("srcs", "missing source files")
return
}
- if len(module.properties.Namespace) == 0 {
- ctx.PropertyErrorf("namespace", "missing namespace property")
+ if len(module.properties.Package) == 0 {
+ ctx.PropertyErrorf("package", "missing package property")
}
- // Add a dependency on the device_config_value_sets defined in
- // RELEASE_DEVICE_CONFIG_VALUE_SETS, and add any device_config_values that
- // match our namespace.
- valuesFromConfig := ctx.Config().ReleaseDeviceConfigValueSets()
+ // Add a dependency on the aconfig_value_sets defined in
+ // RELEASE_ACONFIG_VALUE_SETS, and add any aconfig_values that
+ // match our package.
+ valuesFromConfig := ctx.Config().ReleaseAconfigValueSets()
ctx.AddDependency(ctx.Module(), implicitValuesTag, valuesFromConfig...)
}
-func (module *DefinitionsModule) OutputFiles(tag string) (android.Paths, error) {
+func (module *DeclarationsModule) OutputFiles(tag string) (android.Paths, error) {
switch tag {
case "":
// The default output of this module is the intermediates format, which is
@@ -83,7 +83,7 @@
// correctly.
return []android.Path{module.intermediatePath}, nil
default:
- return nil, fmt.Errorf("unsupported device_config_definitions module reference tag %q", tag)
+ return nil, fmt.Errorf("unsupported aconfig_declarations module reference tag %q", tag)
}
}
@@ -96,23 +96,23 @@
return sb.String()
}
-// Provider published by device_config_value_set
-type definitionsProviderData struct {
- namespace string
- intermediatePath android.WritablePath
+// Provider published by aconfig_value_set
+type declarationsProviderData struct {
+ Package string
+ IntermediatePath android.WritablePath
}
-var definitionsProviderKey = blueprint.NewProvider(definitionsProviderData{})
+var declarationsProviderKey = blueprint.NewProvider(declarationsProviderData{})
-func (module *DefinitionsModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- // Get the values that came from the global RELEASE_DEVICE_CONFIG_VALUE_SETS flag
+func (module *DeclarationsModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+ // Get the values that came from the global RELEASE_ACONFIG_VALUE_SETS flag
ctx.VisitDirectDeps(func(dep android.Module) {
if !ctx.OtherModuleHasProvider(dep, valueSetProviderKey) {
// Other modules get injected as dependencies too, for example the license modules
return
}
depData := ctx.OtherModuleProvider(dep, valueSetProviderKey).(valueSetProviderData)
- valuesFiles, ok := depData.AvailableNamespaces[module.properties.Namespace]
+ valuesFiles, ok := depData.AvailablePackages[module.properties.Package]
if ok {
for _, path := range valuesFiles {
module.properties.Values = append(module.properties.Values, path.String())
@@ -122,22 +122,22 @@
// Intermediate format
inputFiles := android.PathsForModuleSrc(ctx, module.properties.Srcs)
- intermediatePath := android.PathForModuleOut(ctx, "intermediate.json")
+ intermediatePath := android.PathForModuleOut(ctx, "intermediate.pb")
ctx.Build(pctx, android.BuildParams{
Rule: aconfigRule,
Inputs: inputFiles,
Output: intermediatePath,
- Description: "device_config_definitions",
+ Description: "aconfig_declarations",
Args: map[string]string{
"release_version": ctx.Config().ReleaseVersion(),
- "namespace": module.properties.Namespace,
+ "package": module.properties.Package,
"values": joinAndPrefix(" --values ", module.properties.Values),
},
})
- ctx.SetProvider(definitionsProviderKey, definitionsProviderData{
- namespace: module.properties.Namespace,
- intermediatePath: intermediatePath,
+ ctx.SetProvider(declarationsProviderKey, declarationsProviderData{
+ Package: module.properties.Package,
+ IntermediatePath: intermediatePath,
})
}
diff --git a/device_config/device_config_definitions_test.go b/aconfig/aconfig_declarations_test.go
similarity index 68%
rename from device_config/device_config_definitions_test.go
rename to aconfig/aconfig_declarations_test.go
index 49afcc4..e14ca38 100644
--- a/device_config/device_config_definitions_test.go
+++ b/aconfig/aconfig_declarations_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"strings"
@@ -21,22 +21,22 @@
"android/soong/android"
)
-func TestDeviceConfigDefinitions(t *testing.T) {
+func TestAconfigDeclarations(t *testing.T) {
bp := `
- device_config_definitions {
+ aconfig_declarations {
name: "module_name",
- namespace: "com.example.package",
+ package: "com.example.package",
srcs: ["foo.aconfig"],
}
`
result := runTest(t, android.FixtureExpectsNoErrors, bp)
- module := result.ModuleForTests("module_name", "").Module().(*DefinitionsModule)
+ module := result.ModuleForTests("module_name", "").Module().(*DeclarationsModule)
// Check that the provider has the right contents
- depData := result.ModuleProvider(module, definitionsProviderKey).(definitionsProviderData)
- android.AssertStringEquals(t, "namespace", depData.namespace, "com.example.package")
- if !strings.HasSuffix(depData.intermediatePath.String(), "/intermediate.json") {
- t.Errorf("Missing intermediates path in provider: %s", depData.intermediatePath.String())
+ depData := result.ModuleProvider(module, declarationsProviderKey).(declarationsProviderData)
+ android.AssertStringEquals(t, "package", depData.Package, "com.example.package")
+ if !strings.HasSuffix(depData.IntermediatePath.String(), "/intermediate.pb") {
+ t.Errorf("Missing intermediates path in provider: %s", depData.IntermediatePath.String())
}
}
diff --git a/device_config/device_config_value_set.go b/aconfig/aconfig_value_set.go
similarity index 76%
rename from device_config/device_config_value_set.go
rename to aconfig/aconfig_value_set.go
index e406d20..252908f 100644
--- a/device_config/device_config_value_set.go
+++ b/aconfig/aconfig_value_set.go
@@ -12,20 +12,20 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
"github.com/google/blueprint"
)
-// Properties for "device_config_value_set"
+// Properties for "aconfig_value_set"
type ValueSetModule struct {
android.ModuleBase
android.DefaultableModuleBase
properties struct {
- // device_config_values modules
+ // aconfig_values modules
Values []string
}
}
@@ -49,11 +49,11 @@
var valueSetTag = valueSetType{}
-// Provider published by device_config_value_set
+// Provider published by aconfig_value_set
type valueSetProviderData struct {
- // The namespace of each of the
- // (map of namespace --> device_config_module)
- AvailableNamespaces map[string]android.Paths
+ // The package of each of the
+ // (map of package --> aconfig_module)
+ AvailablePackages map[string]android.Paths
}
var valueSetProviderKey = blueprint.NewProvider(valueSetProviderData{})
@@ -63,17 +63,17 @@
for _, dep := range deps {
_, ok := dep.(*ValuesModule)
if !ok {
- ctx.PropertyErrorf("values", "values must be a device_config_values module")
+ ctx.PropertyErrorf("values", "values must be a aconfig_values module")
return
}
}
}
func (module *ValueSetModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- // Accumulate the namespaces of the values modules listed, and set that as an
- // valueSetProviderKey provider that device_config modules can read and use
+ // Accumulate the packages of the values modules listed, and set that as an
+ // valueSetProviderKey provider that aconfig modules can read and use
// to append values to their aconfig actions.
- namespaces := make(map[string]android.Paths)
+ packages := make(map[string]android.Paths)
ctx.VisitDirectDeps(func(dep android.Module) {
if !ctx.OtherModuleHasProvider(dep, valuesProviderKey) {
// Other modules get injected as dependencies too, for example the license modules
@@ -83,10 +83,10 @@
srcs := make([]android.Path, len(depData.Values))
copy(srcs, depData.Values)
- namespaces[depData.Namespace] = srcs
+ packages[depData.Package] = srcs
})
ctx.SetProvider(valueSetProviderKey, valueSetProviderData{
- AvailableNamespaces: namespaces,
+ AvailablePackages: packages,
})
}
diff --git a/device_config/device_config_value_set_test.go b/aconfig/aconfig_value_set_test.go
similarity index 78%
rename from device_config/device_config_value_set_test.go
rename to aconfig/aconfig_value_set_test.go
index f9e7c38..9127872 100644
--- a/device_config/device_config_value_set_test.go
+++ b/aconfig/aconfig_value_set_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"testing"
@@ -20,15 +20,15 @@
"android/soong/android"
)
-func TestDeviceConfigValueSet(t *testing.T) {
+func TestAconfigValueSet(t *testing.T) {
bp := `
- device_config_values {
+ aconfig_values {
name: "one",
srcs: [ "blah.aconfig_values" ],
- namespace: "foo.namespace"
+ package: "foo.package"
}
- device_config_value_set {
+ aconfig_value_set {
name: "module_name",
values: [ "one" ],
}
@@ -39,5 +39,5 @@
// Check that the provider has the right contents
depData := result.ModuleProvider(module, valueSetProviderKey).(valueSetProviderData)
- android.AssertStringEquals(t, "AvailableNamespaces", "blah.aconfig_values", depData.AvailableNamespaces["foo.namespace"][0].String())
+ android.AssertStringEquals(t, "AvailablePackages", "blah.aconfig_values", depData.AvailablePackages["foo.package"][0].String())
}
diff --git a/device_config/device_config_values.go b/aconfig/aconfig_values.go
similarity index 73%
rename from device_config/device_config_values.go
rename to aconfig/aconfig_values.go
index 110f12a..91f1c90 100644
--- a/device_config/device_config_values.go
+++ b/aconfig/aconfig_values.go
@@ -12,14 +12,14 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
"github.com/google/blueprint"
)
-// Properties for "device_config_value"
+// Properties for "aconfig_value"
type ValuesModule struct {
android.ModuleBase
android.DefaultableModuleBase
@@ -28,8 +28,8 @@
// aconfig files, relative to this Android.bp file
Srcs []string `android:"path"`
- // Release config flag namespace
- Namespace string
+ // Release config flag package
+ Package string
}
}
@@ -45,10 +45,10 @@
return module
}
-// Provider published by device_config_value_set
+// Provider published by aconfig_value_set
type valuesProviderData struct {
- // The namespace that this values module values
- Namespace string
+ // The package that this values module values
+ Package string
// The values aconfig files, relative to the root of the tree
Values android.Paths
@@ -57,14 +57,14 @@
var valuesProviderKey = blueprint.NewProvider(valuesProviderData{})
func (module *ValuesModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- if len(module.properties.Namespace) == 0 {
- ctx.PropertyErrorf("namespace", "missing namespace property")
+ if len(module.properties.Package) == 0 {
+ ctx.PropertyErrorf("package", "missing package property")
}
- // Provide the our source files list to the device_config_value_set as a list of files
+ // Provide the our source files list to the aconfig_value_set as a list of files
providerData := valuesProviderData{
- Namespace: module.properties.Namespace,
- Values: android.PathsForModuleSrc(ctx, module.properties.Srcs),
+ Package: module.properties.Package,
+ Values: android.PathsForModuleSrc(ctx, module.properties.Srcs),
}
ctx.SetProvider(valuesProviderKey, providerData)
}
diff --git a/device_config/device_config_values_test.go b/aconfig/aconfig_values_test.go
similarity index 83%
rename from device_config/device_config_values_test.go
rename to aconfig/aconfig_values_test.go
index 64c57eb..ab457f0 100644
--- a/device_config/device_config_values_test.go
+++ b/aconfig/aconfig_values_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"testing"
@@ -20,12 +20,12 @@
"android/soong/android"
)
-func TestDeviceConfigValues(t *testing.T) {
+func TestAconfigValues(t *testing.T) {
bp := `
- device_config_values {
+ aconfig_values {
name: "module_name",
srcs: [ "blah.aconfig_values" ],
- namespace: "foo.namespace"
+ package: "foo.package"
}
`
result := runTest(t, android.FixtureExpectsNoErrors, bp)
@@ -34,6 +34,6 @@
// Check that the provider has the right contents
depData := result.ModuleProvider(module, valuesProviderKey).(valuesProviderData)
- android.AssertStringEquals(t, "namespace", "foo.namespace", depData.Namespace)
+ android.AssertStringEquals(t, "package", "foo.package", depData.Package)
android.AssertPathsEndWith(t, "srcs", []string{"blah.aconfig_values"}, depData.Values)
}
diff --git a/device_config/init.go b/aconfig/init.go
similarity index 74%
rename from device_config/init.go
rename to aconfig/init.go
index 04bbab6..6b433c9 100644
--- a/device_config/init.go
+++ b/aconfig/init.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
@@ -20,13 +20,13 @@
)
var (
- pctx = android.NewPackageContext("android/soong/device_config")
+ pctx = android.NewPackageContext("android/soong/aconfig")
- // For device_config_definitions: Generate cache file
+ // For aconfig_declarations: Generate cache file
aconfigRule = pctx.AndroidStaticRule("aconfig",
blueprint.RuleParams{
Command: `${aconfig} create-cache` +
- ` --package ${namespace}` +
+ ` --package ${package}` +
` --declarations ${in}` +
` ${values}` +
` --cache ${out}.tmp` +
@@ -36,9 +36,9 @@
"${aconfig}",
},
Restat: true,
- }, "release_version", "namespace", "values")
+ }, "release_version", "package", "values")
- // For java_device_config_definitions_library: Generate java file
+ // For java_aconfig_library: Generate java file
srcJarRule = pctx.AndroidStaticRule("aconfig_srcjar",
blueprint.RuleParams{
Command: `rm -rf ${out}.tmp` +
@@ -63,8 +63,8 @@
}
func registerBuildComponents(ctx android.RegistrationContext) {
- ctx.RegisterModuleType("device_config_definitions", DefinitionsFactory)
- ctx.RegisterModuleType("device_config_values", ValuesFactory)
- ctx.RegisterModuleType("device_config_value_set", ValueSetFactory)
- ctx.RegisterModuleType("java_device_config_definitions_library", JavaDefinitionsLibraryFactory)
+ ctx.RegisterModuleType("aconfig_declarations", DeclarationsFactory)
+ ctx.RegisterModuleType("aconfig_values", ValuesFactory)
+ ctx.RegisterModuleType("aconfig_value_set", ValueSetFactory)
+ ctx.RegisterModuleType("java_aconfig_library", JavaDeclarationsLibraryFactory)
}
diff --git a/aconfig/java_aconfig_library.go b/aconfig/java_aconfig_library.go
new file mode 100644
index 0000000..0eeb14f
--- /dev/null
+++ b/aconfig/java_aconfig_library.go
@@ -0,0 +1,71 @@
+// Copyright 2023 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 aconfig
+
+import (
+ "android/soong/android"
+ "android/soong/java"
+ "fmt"
+ "github.com/google/blueprint"
+)
+
+type declarationsTagType struct {
+ blueprint.BaseDependencyTag
+}
+
+var declarationsTag = declarationsTagType{}
+
+type JavaAconfigDeclarationsLibraryProperties struct {
+ // name of the aconfig_declarations module to generate a library for
+ Aconfig_declarations string
+}
+
+type JavaAconfigDeclarationsLibraryCallbacks struct {
+ properties JavaAconfigDeclarationsLibraryProperties
+}
+
+func JavaDeclarationsLibraryFactory() android.Module {
+ callbacks := &JavaAconfigDeclarationsLibraryCallbacks{}
+ return java.GeneratedJavaLibraryModuleFactory("java_aconfig_library", callbacks, &callbacks.properties)
+}
+
+func (callbacks *JavaAconfigDeclarationsLibraryCallbacks) DepsMutator(module *java.GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext) {
+ declarations := callbacks.properties.Aconfig_declarations
+ if len(declarations) == 0 {
+ // TODO: Add test for this case
+ ctx.PropertyErrorf("aconfig_declarations", "aconfig_declarations property required")
+ } else {
+ ctx.AddDependency(ctx.Module(), declarationsTag, declarations)
+ }
+}
+
+func (callbacks *JavaAconfigDeclarationsLibraryCallbacks) GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path {
+ // Get the values that came from the global RELEASE_ACONFIG_VALUE_SETS flag
+ declarationsModules := ctx.GetDirectDepsWithTag(declarationsTag)
+ if len(declarationsModules) != 1 {
+ panic(fmt.Errorf("Exactly one aconfig_declarations property required"))
+ }
+ declarations := ctx.OtherModuleProvider(declarationsModules[0], declarationsProviderKey).(declarationsProviderData)
+
+ srcJarPath := android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar")
+ ctx.Build(pctx, android.BuildParams{
+ Rule: srcJarRule,
+ Input: declarations.IntermediatePath,
+ Output: srcJarPath,
+ Description: "aconfig.srcjar",
+ })
+
+ return srcJarPath
+}
diff --git a/device_config/testing.go b/aconfig/testing.go
similarity index 78%
rename from device_config/testing.go
rename to aconfig/testing.go
index 284a7fa..60cefeb 100644
--- a/device_config/testing.go
+++ b/aconfig/testing.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"testing"
@@ -20,10 +20,10 @@
"android/soong/android"
)
-var PrepareForTestWithDeviceConfigBuildComponents = android.FixtureRegisterWithContext(registerBuildComponents)
+var PrepareForTestWithAconfigBuildComponents = android.FixtureRegisterWithContext(registerBuildComponents)
func runTest(t *testing.T, errorHandler android.FixtureErrorHandler, bp string) *android.TestResult {
- return android.GroupFixturePreparers(PrepareForTestWithDeviceConfigBuildComponents).
+ return android.GroupFixturePreparers(PrepareForTestWithAconfigBuildComponents).
ExtendWithErrorHandler(errorHandler).
RunTestWithBp(t, bp)
}
diff --git a/aidl_library/aidl_library.go b/aidl_library/aidl_library.go
index 5985103..7449d67 100644
--- a/aidl_library/aidl_library.go
+++ b/aidl_library/aidl_library.go
@@ -108,17 +108,17 @@
// The direct aidl files of the module
Srcs android.Paths
// The include dirs to the direct aidl files and those provided from transitive aidl_library deps
- IncludeDirs android.DepSet
+ IncludeDirs android.DepSet[android.Path]
// The direct hdrs and hdrs from transitive deps
- Hdrs android.DepSet
+ Hdrs android.DepSet[android.Path]
}
// AidlLibraryProvider provides the srcs and the transitive include dirs
var AidlLibraryProvider = blueprint.NewProvider(AidlLibraryInfo{})
func (lib *AidlLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- includeDirsDepSetBuilder := android.NewDepSetBuilder(android.PREORDER)
- hdrsDepSetBuilder := android.NewDepSetBuilder(android.PREORDER)
+ includeDirsDepSetBuilder := android.NewDepSetBuilder[android.Path](android.PREORDER)
+ hdrsDepSetBuilder := android.NewDepSetBuilder[android.Path](android.PREORDER)
if len(lib.properties.Srcs) == 0 && len(lib.properties.Hdrs) == 0 {
ctx.ModuleErrorf("at least srcs or hdrs prop must be non-empty")
diff --git a/aidl_library/aidl_library_test.go b/aidl_library/aidl_library_test.go
index d9dd245..0205629 100644
--- a/aidl_library/aidl_library_test.go
+++ b/aidl_library/aidl_library_test.go
@@ -52,7 +52,7 @@
t,
"aidl include dirs",
[]string{"package_foo/a", "package_bar/x"},
- actualInfo.IncludeDirs.ToList().Strings(),
+ android.Paths(actualInfo.IncludeDirs.ToList()).Strings(),
)
android.AssertPathsRelativeToTopEquals(
@@ -101,7 +101,7 @@
t,
"aidl include dirs",
[]string{"package_foo", "package_bar"},
- actualInfo.IncludeDirs.ToList().Strings(),
+ android.Paths(actualInfo.IncludeDirs.ToList()).Strings(),
)
android.AssertPathsRelativeToTopEquals(
diff --git a/android/Android.bp b/android/Android.bp
index 2ccccf0..fc5198f 100644
--- a/android/Android.bp
+++ b/android/Android.bp
@@ -49,7 +49,6 @@
"defaults.go",
"defs.go",
"depset_generic.go",
- "depset_paths.go",
"deptag.go",
"expand.go",
"filegroup.go",
diff --git a/android/allowlists/allowlists.go b/android/allowlists/allowlists.go
index 34a6860..4a7c925 100644
--- a/android/allowlists/allowlists.go
+++ b/android/allowlists/allowlists.go
@@ -429,6 +429,7 @@
// e.g. ERROR: Analysis of target '@soong_injection//mixed_builds:buildroot' failed
"external/bazelbuild-rules_android":/* recursive = */ true,
"external/bazelbuild-rules_license":/* recursive = */ true,
+ "external/bazelbuild-rules_go":/* recursive = */ true,
"external/bazelbuild-kotlin-rules":/* recursive = */ true,
"external/bazel-skylib":/* recursive = */ true,
"external/protobuf":/* recursive = */ false,
diff --git a/android/config.go b/android/config.go
index 9330705..839ff05 100644
--- a/android/config.go
+++ b/android/config.go
@@ -184,8 +184,8 @@
}
// The flag values files passed to aconfig, derived from RELEASE_VERSION
-func (c Config) ReleaseDeviceConfigValueSets() []string {
- return c.config.productVariables.ReleaseDeviceConfigValueSets
+func (c Config) ReleaseAconfigValueSets() []string {
+ return c.config.productVariables.ReleaseAconfigValueSets
}
// A DeviceConfig object represents the configuration for a particular device
diff --git a/android/depset_generic.go b/android/depset_generic.go
index f00e462..ae14d32 100644
--- a/android/depset_generic.go
+++ b/android/depset_generic.go
@@ -16,10 +16,9 @@
import (
"fmt"
- "reflect"
)
-// depSet is designed to be conceptually compatible with Bazel's depsets:
+// DepSet is designed to be conceptually compatible with Bazel's depsets:
// https://docs.bazel.build/versions/master/skylark/depsets.html
type DepSetOrder int
@@ -43,142 +42,114 @@
}
}
-// A depSet efficiently stores a slice of an arbitrary type from transitive dependencies without
-// copying. It is stored as a DAG of depSet nodes, each of which has some direct contents and a list
-// of dependency depSet nodes.
+type depSettableType comparable
+
+// A DepSet efficiently stores a slice of an arbitrary type from transitive dependencies without
+// copying. It is stored as a DAG of DepSet nodes, each of which has some direct contents and a list
+// of dependency DepSet nodes.
//
-// A depSet has an order that will be used to walk the DAG when ToList() is called. The order
+// A DepSet has an order that will be used to walk the DAG when ToList() is called. The order
// can be POSTORDER, PREORDER, or TOPOLOGICAL. POSTORDER and PREORDER orders return a postordered
// or preordered left to right flattened list. TOPOLOGICAL returns a list that guarantees that
// elements of children are listed after all of their parents (unless there are duplicate direct
-// elements in the depSet or any of its transitive dependencies, in which case the ordering of the
+// elements in the DepSet or any of its transitive dependencies, in which case the ordering of the
// duplicated element is not guaranteed).
//
-// A depSet is created by newDepSet or newDepSetBuilder.Build from the slice for direct contents
-// and the *depSets of dependencies. A depSet is immutable once created.
-//
-// This object uses reflection to remain agnostic to the type it contains. It should be replaced
-// with generics once those exist in Go. Callers should generally use a thin wrapper around depSet
-// that provides type-safe methods like DepSet for Paths.
-type depSet struct {
+// A DepSet is created by NewDepSet or NewDepSetBuilder.Build from the slice for direct contents
+// and the *DepSets of dependencies. A DepSet is immutable once created.
+type DepSet[T depSettableType] struct {
preorder bool
reverse bool
order DepSetOrder
- direct interface{}
- transitive []*depSet
+ direct []T
+ transitive []*DepSet[T]
}
-type depSetInterface interface {
- embeddedDepSet() *depSet
-}
-
-func (d *depSet) embeddedDepSet() *depSet {
- return d
-}
-
-var _ depSetInterface = (*depSet)(nil)
-
-// newDepSet returns an immutable depSet with the given order, direct and transitive contents.
-// direct must be a slice, but is not type-safe due to the lack of generics in Go. It can be a
-// nil slice, but not a nil interface{}, i.e. []string(nil) but not nil.
-func newDepSet(order DepSetOrder, direct interface{}, transitive interface{}) *depSet {
- var directCopy interface{}
- transitiveDepSet := sliceToDepSets(transitive, order)
-
- if order == TOPOLOGICAL {
- directCopy = reverseSlice(direct)
- reverseSliceInPlace(transitiveDepSet)
- } else {
- directCopy = copySlice(direct)
+// NewDepSet returns an immutable DepSet with the given order, direct and transitive contents.
+func NewDepSet[T depSettableType](order DepSetOrder, direct []T, transitive []*DepSet[T]) *DepSet[T] {
+ var directCopy []T
+ var transitiveCopy []*DepSet[T]
+ for _, t := range transitive {
+ if t.order != order {
+ panic(fmt.Errorf("incompatible order, new DepSet is %s but transitive DepSet is %s",
+ order, t.order))
+ }
}
- return &depSet{
+ if order == TOPOLOGICAL {
+ // TOPOLOGICAL is implemented as a postorder traversal followed by reversing the output.
+ // Pre-reverse the inputs here so their order is maintained in the output.
+ directCopy = reverseSlice(direct)
+ transitiveCopy = reverseSlice(transitive)
+ } else {
+ directCopy = append([]T(nil), direct...)
+ transitiveCopy = append([]*DepSet[T](nil), transitive...)
+ }
+
+ return &DepSet[T]{
preorder: order == PREORDER,
reverse: order == TOPOLOGICAL,
order: order,
direct: directCopy,
- transitive: transitiveDepSet,
+ transitive: transitiveCopy,
}
}
-// depSetBuilder is used to create an immutable depSet.
-type depSetBuilder struct {
+// DepSetBuilder is used to create an immutable DepSet.
+type DepSetBuilder[T depSettableType] struct {
order DepSetOrder
- direct reflect.Value
- transitive []*depSet
+ direct []T
+ transitive []*DepSet[T]
}
-// newDepSetBuilder returns a depSetBuilder to create an immutable depSet with the given order and
-// type, represented by a slice of type that will be in the depSet.
-func newDepSetBuilder(order DepSetOrder, typ interface{}) *depSetBuilder {
- empty := reflect.Zero(reflect.TypeOf(typ))
- return &depSetBuilder{
- order: order,
- direct: empty,
+// NewDepSetBuilder returns a DepSetBuilder to create an immutable DepSet with the given order and
+// type, represented by a slice of type that will be in the DepSet.
+func NewDepSetBuilder[T depSettableType](order DepSetOrder) *DepSetBuilder[T] {
+ return &DepSetBuilder[T]{
+ order: order,
}
}
-// sliceToDepSets converts a slice of any type that implements depSetInterface (by having a depSet
-// embedded in it) into a []*depSet.
-func sliceToDepSets(in interface{}, order DepSetOrder) []*depSet {
- slice := reflect.ValueOf(in)
- length := slice.Len()
- out := make([]*depSet, length)
- for i := 0; i < length; i++ {
- vi := slice.Index(i)
- depSetIntf, ok := vi.Interface().(depSetInterface)
- if !ok {
- panic(fmt.Errorf("element %d is a %s, not a depSetInterface", i, vi.Type()))
- }
- depSet := depSetIntf.embeddedDepSet()
- if depSet.order != order {
- panic(fmt.Errorf("incompatible order, new depSet is %s but transitive depSet is %s",
- order, depSet.order))
- }
- out[i] = depSet
- }
- return out
-}
-
-// DirectSlice adds direct contents to the depSet being built by a depSetBuilder. Newly added direct
-// contents are to the right of any existing direct contents. The argument must be a slice, but
-// is not type-safe due to the lack of generics in Go.
-func (b *depSetBuilder) DirectSlice(direct interface{}) *depSetBuilder {
- b.direct = reflect.AppendSlice(b.direct, reflect.ValueOf(direct))
+// DirectSlice adds direct contents to the DepSet being built by a DepSetBuilder. Newly added direct
+// contents are to the right of any existing direct contents.
+func (b *DepSetBuilder[T]) DirectSlice(direct []T) *DepSetBuilder[T] {
+ b.direct = append(b.direct, direct...)
return b
}
-// Direct adds direct contents to the depSet being built by a depSetBuilder. Newly added direct
-// contents are to the right of any existing direct contents. The argument must be the same type
-// as the element of the slice passed to newDepSetBuilder, but is not type-safe due to the lack of
-// generics in Go.
-func (b *depSetBuilder) Direct(direct interface{}) *depSetBuilder {
- b.direct = reflect.Append(b.direct, reflect.ValueOf(direct))
+// Direct adds direct contents to the DepSet being built by a DepSetBuilder. Newly added direct
+// contents are to the right of any existing direct contents.
+func (b *DepSetBuilder[T]) Direct(direct ...T) *DepSetBuilder[T] {
+ b.direct = append(b.direct, direct...)
return b
}
// Transitive adds transitive contents to the DepSet being built by a DepSetBuilder. Newly added
-// transitive contents are to the right of any existing transitive contents. The argument can
-// be any slice of type that has depSet embedded in it.
-func (b *depSetBuilder) Transitive(transitive interface{}) *depSetBuilder {
- depSets := sliceToDepSets(transitive, b.order)
- b.transitive = append(b.transitive, depSets...)
+// transitive contents are to the right of any existing transitive contents.
+func (b *DepSetBuilder[T]) Transitive(transitive ...*DepSet[T]) *DepSetBuilder[T] {
+ for _, t := range transitive {
+ if t.order != b.order {
+ panic(fmt.Errorf("incompatible order, new DepSet is %s but transitive DepSet is %s",
+ b.order, t.order))
+ }
+ }
+ b.transitive = append(b.transitive, transitive...)
return b
}
-// Returns the depSet being built by this depSetBuilder. The depSetBuilder retains its contents
+// Returns the DepSet being built by this DepSetBuilder. The DepSetBuilder retains its contents
// for creating more depSets.
-func (b *depSetBuilder) Build() *depSet {
- return newDepSet(b.order, b.direct.Interface(), b.transitive)
+func (b *DepSetBuilder[T]) Build() *DepSet[T] {
+ return NewDepSet(b.order, b.direct, b.transitive)
}
// walk calls the visit method in depth-first order on a DepSet, preordered if d.preorder is set,
// otherwise postordered.
-func (d *depSet) walk(visit func(interface{})) {
- visited := make(map[*depSet]bool)
+func (d *DepSet[T]) walk(visit func([]T)) {
+ visited := make(map[*DepSet[T]]bool)
- var dfs func(d *depSet)
- dfs = func(d *depSet) {
+ var dfs func(d *DepSet[T])
+ dfs = func(d *DepSet[T]) {
visited[d] = true
if d.preorder {
visit(d.direct)
@@ -197,155 +168,33 @@
dfs(d)
}
-// ToList returns the depSet flattened to a list. The order in the list is based on the order
-// of the depSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
+// ToList returns the DepSet flattened to a list. The order in the list is based on the order
+// of the DepSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
// flattened list. TOPOLOGICAL returns a list that guarantees that elements of children are listed
// after all of their parents (unless there are duplicate direct elements in the DepSet or any of
// its transitive dependencies, in which case the ordering of the duplicated element is not
// guaranteed).
-//
-// This method uses a reflection-based implementation to find the unique elements in slice, which
-// is around 3x slower than a concrete implementation. Type-safe wrappers around depSet can
-// provide their own implementation of ToList that calls depSet.toList with a method that
-// uses a concrete implementation.
-func (d *depSet) ToList() interface{} {
- return d.toList(firstUnique)
+func (d *DepSet[T]) ToList() []T {
+ return d.toList(firstUnique[T])
}
-// toList returns the depSet flattened to a list. The order in the list is based on the order
-// of the depSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
+// toList returns the DepSet flattened to a list. The order in the list is based on the order
+// of the DepSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
// flattened list. TOPOLOGICAL returns a list that guarantees that elements of children are listed
// after all of their parents (unless there are duplicate direct elements in the DepSet or any of
// its transitive dependencies, in which case the ordering of the duplicated element is not
// guaranteed). The firstUniqueFunc is used to remove duplicates from the list.
-func (d *depSet) toList(firstUniqueFunc func(interface{}) interface{}) interface{} {
+func (d *DepSet[T]) toList(firstUniqueFunc func([]T) []T) []T {
if d == nil {
return nil
}
- slice := reflect.Zero(reflect.TypeOf(d.direct))
- d.walk(func(paths interface{}) {
- slice = reflect.AppendSlice(slice, reflect.ValueOf(paths))
+ var list []T
+ d.walk(func(paths []T) {
+ list = append(list, paths...)
})
- list := slice.Interface()
list = firstUniqueFunc(list)
if d.reverse {
reverseSliceInPlace(list)
}
return list
}
-
-// firstUnique returns all unique elements of a slice, keeping the first copy of each. It
-// modifies the slice contents in place, and returns a subslice of the original slice. The
-// argument must be a slice, but is not type-safe due to the lack of reflection in Go.
-//
-// Performance of the reflection-based firstUnique is up to 3x slower than a concrete type
-// version such as FirstUniqueStrings.
-func firstUnique(slice interface{}) interface{} {
- // 4 was chosen based on Benchmark_firstUnique results.
- if reflect.ValueOf(slice).Len() > 4 {
- return firstUniqueMap(slice)
- }
- return firstUniqueList(slice)
-}
-
-// firstUniqueList is an implementation of firstUnique using an O(N^2) list comparison to look for
-// duplicates.
-func firstUniqueList(in interface{}) interface{} {
- writeIndex := 0
- slice := reflect.ValueOf(in)
- length := slice.Len()
-outer:
- for readIndex := 0; readIndex < length; readIndex++ {
- readValue := slice.Index(readIndex)
- for compareIndex := 0; compareIndex < writeIndex; compareIndex++ {
- compareValue := slice.Index(compareIndex)
- // These two Interface() calls seem to cause an allocation and significantly
- // slow down this list-based implementation. The map implementation below doesn't
- // have this issue because reflect.Value.MapIndex takes a Value and appears to be
- // able to do the map lookup without an allocation.
- if readValue.Interface() == compareValue.Interface() {
- // The value at readIndex already exists somewhere in the output region
- // of the slice before writeIndex, skip it.
- continue outer
- }
- }
- if readIndex != writeIndex {
- writeValue := slice.Index(writeIndex)
- writeValue.Set(readValue)
- }
- writeIndex++
- }
- return slice.Slice(0, writeIndex).Interface()
-}
-
-var trueValue = reflect.ValueOf(true)
-
-// firstUniqueList is an implementation of firstUnique using an O(N) hash set lookup to look for
-// duplicates.
-func firstUniqueMap(in interface{}) interface{} {
- writeIndex := 0
- slice := reflect.ValueOf(in)
- length := slice.Len()
- seen := reflect.MakeMapWithSize(reflect.MapOf(slice.Type().Elem(), trueValue.Type()), slice.Len())
- for readIndex := 0; readIndex < length; readIndex++ {
- readValue := slice.Index(readIndex)
- if seen.MapIndex(readValue).IsValid() {
- continue
- }
- seen.SetMapIndex(readValue, trueValue)
- if readIndex != writeIndex {
- writeValue := slice.Index(writeIndex)
- writeValue.Set(readValue)
- }
- writeIndex++
- }
- return slice.Slice(0, writeIndex).Interface()
-}
-
-// reverseSliceInPlace reverses the elements of a slice in place. The argument must be a slice, but
-// is not type-safe due to the lack of reflection in Go.
-func reverseSliceInPlace(in interface{}) {
- swapper := reflect.Swapper(in)
- slice := reflect.ValueOf(in)
- length := slice.Len()
- for i, j := 0, length-1; i < j; i, j = i+1, j-1 {
- swapper(i, j)
- }
-}
-
-// reverseSlice returns a copy of a slice in reverse order. The argument must be a slice, but is
-// not type-safe due to the lack of reflection in Go.
-func reverseSlice(in interface{}) interface{} {
- slice := reflect.ValueOf(in)
- if !slice.IsValid() || slice.IsNil() {
- return in
- }
- if slice.Kind() != reflect.Slice {
- panic(fmt.Errorf("%t is not a slice", in))
- }
- length := slice.Len()
- if length == 0 {
- return in
- }
- out := reflect.MakeSlice(slice.Type(), length, length)
- for i := 0; i < length; i++ {
- out.Index(i).Set(slice.Index(length - 1 - i))
- }
- return out.Interface()
-}
-
-// copySlice returns a copy of a slice. The argument must be a slice, but is not type-safe due to
-// the lack of reflection in Go.
-func copySlice(in interface{}) interface{} {
- slice := reflect.ValueOf(in)
- if !slice.IsValid() || slice.IsNil() {
- return in
- }
- length := slice.Len()
- if length == 0 {
- return in
- }
- out := reflect.MakeSlice(slice.Type(), length, length)
- reflect.Copy(out, slice)
- return out.Interface()
-}
diff --git a/android/depset_paths.go b/android/depset_paths.go
deleted file mode 100644
index ed561ba..0000000
--- a/android/depset_paths.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2020 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 android
-
-// This file implements DepSet, a thin type-safe wrapper around depSet that contains Paths.
-
-// A DepSet efficiently stores Paths from transitive dependencies without copying. It is stored
-// as a DAG of DepSet nodes, each of which has some direct contents and a list of dependency
-// DepSet nodes.
-//
-// A DepSet has an order that will be used to walk the DAG when ToList() is called. The order
-// can be POSTORDER, PREORDER, or TOPOLOGICAL. POSTORDER and PREORDER orders return a postordered
-// or preordered left to right flattened list. TOPOLOGICAL returns a list that guarantees that
-// elements of children are listed after all of their parents (unless there are duplicate direct
-// elements in the DepSet or any of its transitive dependencies, in which case the ordering of the
-// duplicated element is not guaranteed).
-//
-// A DepSet is created by NewDepSet or NewDepSetBuilder.Build from the Paths for direct contents
-// and the *DepSets of dependencies. A DepSet is immutable once created.
-type DepSet struct {
- depSet
-}
-
-// DepSetBuilder is used to create an immutable DepSet.
-type DepSetBuilder struct {
- depSetBuilder
-}
-
-// NewDepSet returns an immutable DepSet with the given order, direct and transitive contents.
-func NewDepSet(order DepSetOrder, direct Paths, transitive []*DepSet) *DepSet {
- return &DepSet{*newDepSet(order, direct, transitive)}
-}
-
-// NewDepSetBuilder returns a DepSetBuilder to create an immutable DepSet with the given order.
-func NewDepSetBuilder(order DepSetOrder) *DepSetBuilder {
- return &DepSetBuilder{*newDepSetBuilder(order, Paths(nil))}
-}
-
-// Direct adds direct contents to the DepSet being built by a DepSetBuilder. Newly added direct
-// contents are to the right of any existing direct contents.
-func (b *DepSetBuilder) Direct(direct ...Path) *DepSetBuilder {
- b.depSetBuilder.DirectSlice(direct)
- return b
-}
-
-// Transitive adds transitive contents to the DepSet being built by a DepSetBuilder. Newly added
-// transitive contents are to the right of any existing transitive contents.
-func (b *DepSetBuilder) Transitive(transitive ...*DepSet) *DepSetBuilder {
- b.depSetBuilder.Transitive(transitive)
- return b
-}
-
-// Returns the DepSet being built by this DepSetBuilder. The DepSetBuilder retains its contents
-// for creating more DepSets.
-func (b *DepSetBuilder) Build() *DepSet {
- return &DepSet{*b.depSetBuilder.Build()}
-}
-
-// ToList returns the DepSet flattened to a list. The order in the list is based on the order
-// of the DepSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
-// flattened list. TOPOLOGICAL returns a list that guarantees that elements of children are listed
-// after all of their parents (unless there are duplicate direct elements in the DepSet or any of
-// its transitive dependencies, in which case the ordering of the duplicated element is not
-// guaranteed).
-func (d *DepSet) ToList() Paths {
- if d == nil {
- return nil
- }
- return d.toList(func(paths interface{}) interface{} {
- return FirstUniquePaths(paths.(Paths))
- }).(Paths)
-}
-
-// ToSortedList returns the direct and transitive contents of a DepSet in lexically sorted order
-// with duplicates removed.
-func (d *DepSet) ToSortedList() Paths {
- if d == nil {
- return nil
- }
- paths := d.ToList()
- return SortedUniquePaths(paths)
-}
diff --git a/android/depset_test.go b/android/depset_test.go
index 955ccb0..376dffa 100644
--- a/android/depset_test.go
+++ b/android/depset_test.go
@@ -17,51 +17,40 @@
import (
"fmt"
"reflect"
- "strconv"
"strings"
"testing"
)
func ExampleDepSet_ToList_postordered() {
- a := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
+ a := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("a")).Build()
+ b := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("b")).Transitive(a).Build()
+ c := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("c")).Transitive(a).Build()
+ d := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
- fmt.Println(d.ToList().Strings())
+ fmt.Println(Paths(d.ToList()).Strings())
// Output: [a b c d]
}
func ExampleDepSet_ToList_preordered() {
- a := NewDepSetBuilder(PREORDER).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(PREORDER).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(PREORDER).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(PREORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
+ a := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("a")).Build()
+ b := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("b")).Transitive(a).Build()
+ c := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("c")).Transitive(a).Build()
+ d := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
- fmt.Println(d.ToList().Strings())
+ fmt.Println(Paths(d.ToList()).Strings())
// Output: [d b a c]
}
func ExampleDepSet_ToList_topological() {
- a := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("d")).Transitive(b, c).Build()
+ a := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("a")).Build()
+ b := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("b")).Transitive(a).Build()
+ c := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("c")).Transitive(a).Build()
+ d := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("d")).Transitive(b, c).Build()
- fmt.Println(d.ToList().Strings())
+ fmt.Println(Paths(d.ToList()).Strings())
// Output: [d b c a]
}
-func ExampleDepSet_ToSortedList() {
- a := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
-
- fmt.Println(d.ToSortedList().Strings())
- // Output: [a b c d]
-}
-
// Tests based on Bazel's ExpanderTestBase.java to ensure compatibility
// https://github.com/bazelbuild/bazel/blob/master/src/test/java/com/google/devtools/build/lib/collect/nestedset/ExpanderTestBase.java
func TestDepSet(t *testing.T) {
@@ -74,13 +63,13 @@
tests := []struct {
name string
- depSet func(t *testing.T, order DepSetOrder) *DepSet
+ depSet func(t *testing.T, order DepSetOrder) *DepSet[Path]
postorder, preorder, topological []string
}{
{
name: "simple",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- return NewDepSet(order, Paths{c, a, b}, nil)
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ return NewDepSet[Path](order, Paths{c, a, b}, nil)
},
postorder: []string{"c", "a", "b"},
preorder: []string{"c", "a", "b"},
@@ -88,8 +77,8 @@
},
{
name: "simpleNoDuplicates",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- return NewDepSet(order, Paths{c, a, a, a, b}, nil)
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ return NewDepSet[Path](order, Paths{c, a, a, a, b}, nil)
},
postorder: []string{"c", "a", "b"},
preorder: []string{"c", "a", "b"},
@@ -97,9 +86,9 @@
},
{
name: "nesting",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- subset := NewDepSet(order, Paths{c, a, e}, nil)
- return NewDepSet(order, Paths{b, d}, []*DepSet{subset})
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ subset := NewDepSet[Path](order, Paths{c, a, e}, nil)
+ return NewDepSet[Path](order, Paths{b, d}, []*DepSet[Path]{subset})
},
postorder: []string{"c", "a", "e", "b", "d"},
preorder: []string{"b", "d", "c", "a", "e"},
@@ -107,14 +96,14 @@
},
{
name: "builderReuse",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
assertEquals := func(t *testing.T, w, g Paths) {
t.Helper()
if !reflect.DeepEqual(w, g) {
t.Errorf("want %q, got %q", w, g)
}
}
- builder := NewDepSetBuilder(order)
+ builder := NewDepSetBuilder[Path](order)
assertEquals(t, nil, builder.Build().ToList())
builder.Direct(b)
@@ -123,7 +112,7 @@
builder.Direct(d)
assertEquals(t, Paths{b, d}, builder.Build().ToList())
- child := NewDepSetBuilder(order).Direct(c, a, e).Build()
+ child := NewDepSetBuilder[Path](order).Direct(c, a, e).Build()
builder.Transitive(child)
return builder.Build()
},
@@ -133,9 +122,9 @@
},
{
name: "builderChaining",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- return NewDepSetBuilder(order).Direct(b).Direct(d).
- Transitive(NewDepSetBuilder(order).Direct(c, a, e).Build()).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ return NewDepSetBuilder[Path](order).Direct(b).Direct(d).
+ Transitive(NewDepSetBuilder[Path](order).Direct(c, a, e).Build()).Build()
},
postorder: []string{"c", "a", "e", "b", "d"},
preorder: []string{"b", "d", "c", "a", "e"},
@@ -143,9 +132,9 @@
},
{
name: "transitiveDepsHandledSeparately",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- subset := NewDepSetBuilder(order).Direct(c, a, e).Build()
- builder := NewDepSetBuilder(order)
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ subset := NewDepSetBuilder[Path](order).Direct(c, a, e).Build()
+ builder := NewDepSetBuilder[Path](order)
// The fact that we add the transitive subset between the Direct(b) and Direct(d)
// calls should not change the result.
builder.Direct(b)
@@ -159,9 +148,9 @@
},
{
name: "nestingNoDuplicates",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- subset := NewDepSetBuilder(order).Direct(c, a, e).Build()
- return NewDepSetBuilder(order).Direct(b, d, e).Transitive(subset).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ subset := NewDepSetBuilder[Path](order).Direct(c, a, e).Build()
+ return NewDepSetBuilder[Path](order).Direct(b, d, e).Transitive(subset).Build()
},
postorder: []string{"c", "a", "e", "b", "d"},
preorder: []string{"b", "d", "e", "c", "a"},
@@ -169,10 +158,10 @@
},
{
name: "chain",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- c := NewDepSetBuilder(order).Direct(c).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(c).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ c := NewDepSetBuilder[Path](order).Direct(c).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(c).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Build()
return a
},
@@ -182,11 +171,11 @@
},
{
name: "diamond",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- d := NewDepSetBuilder(order).Direct(d).Build()
- c := NewDepSetBuilder(order).Direct(c).Transitive(d).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(d).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Transitive(c).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ d := NewDepSetBuilder[Path](order).Direct(d).Build()
+ c := NewDepSetBuilder[Path](order).Direct(c).Transitive(d).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(d).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Transitive(c).Build()
return a
},
@@ -196,12 +185,12 @@
},
{
name: "extendedDiamond",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- d := NewDepSetBuilder(order).Direct(d).Build()
- e := NewDepSetBuilder(order).Direct(e).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(d).Transitive(e).Build()
- c := NewDepSetBuilder(order).Direct(c).Transitive(e).Transitive(d).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Transitive(c).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ d := NewDepSetBuilder[Path](order).Direct(d).Build()
+ e := NewDepSetBuilder[Path](order).Direct(e).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(d).Transitive(e).Build()
+ c := NewDepSetBuilder[Path](order).Direct(c).Transitive(e).Transitive(d).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Transitive(c).Build()
return a
},
postorder: []string{"d", "e", "b", "c", "a"},
@@ -210,13 +199,13 @@
},
{
name: "extendedDiamondRightArm",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- d := NewDepSetBuilder(order).Direct(d).Build()
- e := NewDepSetBuilder(order).Direct(e).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(d).Transitive(e).Build()
- c2 := NewDepSetBuilder(order).Direct(c2).Transitive(e).Transitive(d).Build()
- c := NewDepSetBuilder(order).Direct(c).Transitive(c2).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Transitive(c).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ d := NewDepSetBuilder[Path](order).Direct(d).Build()
+ e := NewDepSetBuilder[Path](order).Direct(e).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(d).Transitive(e).Build()
+ c2 := NewDepSetBuilder[Path](order).Direct(c2).Transitive(e).Transitive(d).Build()
+ c := NewDepSetBuilder[Path](order).Direct(c).Transitive(c2).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Transitive(c).Build()
return a
},
postorder: []string{"d", "e", "b", "c2", "c", "a"},
@@ -225,10 +214,10 @@
},
{
name: "orderConflict",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- child1 := NewDepSetBuilder(order).Direct(a, b).Build()
- child2 := NewDepSetBuilder(order).Direct(b, a).Build()
- parent := NewDepSetBuilder(order).Transitive(child1).Transitive(child2).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ child1 := NewDepSetBuilder[Path](order).Direct(a, b).Build()
+ child2 := NewDepSetBuilder[Path](order).Direct(b, a).Build()
+ parent := NewDepSetBuilder[Path](order).Transitive(child1).Transitive(child2).Build()
return parent
},
postorder: []string{"a", "b"},
@@ -237,12 +226,12 @@
},
{
name: "orderConflictNested",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- a := NewDepSetBuilder(order).Direct(a).Build()
- b := NewDepSetBuilder(order).Direct(b).Build()
- child1 := NewDepSetBuilder(order).Transitive(a).Transitive(b).Build()
- child2 := NewDepSetBuilder(order).Transitive(b).Transitive(a).Build()
- parent := NewDepSetBuilder(order).Transitive(child1).Transitive(child2).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ a := NewDepSetBuilder[Path](order).Direct(a).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Build()
+ child1 := NewDepSetBuilder[Path](order).Transitive(a).Transitive(b).Build()
+ child2 := NewDepSetBuilder[Path](order).Transitive(b).Transitive(a).Build()
+ parent := NewDepSetBuilder[Path](order).Transitive(child1).Transitive(child2).Build()
return parent
},
postorder: []string{"a", "b"},
@@ -255,19 +244,19 @@
t.Run(tt.name, func(t *testing.T) {
t.Run("postorder", func(t *testing.T) {
depSet := tt.depSet(t, POSTORDER)
- if g, w := depSet.ToList().Strings(), tt.postorder; !reflect.DeepEqual(g, w) {
+ if g, w := Paths(depSet.ToList()).Strings(), tt.postorder; !reflect.DeepEqual(g, w) {
t.Errorf("expected ToList() = %q, got %q", w, g)
}
})
t.Run("preorder", func(t *testing.T) {
depSet := tt.depSet(t, PREORDER)
- if g, w := depSet.ToList().Strings(), tt.preorder; !reflect.DeepEqual(g, w) {
+ if g, w := Paths(depSet.ToList()).Strings(), tt.preorder; !reflect.DeepEqual(g, w) {
t.Errorf("expected ToList() = %q, got %q", w, g)
}
})
t.Run("topological", func(t *testing.T) {
depSet := tt.depSet(t, TOPOLOGICAL)
- if g, w := depSet.ToList().Strings(), tt.topological; !reflect.DeepEqual(g, w) {
+ if g, w := Paths(depSet.ToList()).Strings(), tt.topological; !reflect.DeepEqual(g, w) {
t.Errorf("expected ToList() = %q, got %q", w, g)
}
})
@@ -288,7 +277,7 @@
}
}
}()
- NewDepSet(order1, nil, []*DepSet{NewDepSet(order2, nil, nil)})
+ NewDepSet(order1, nil, []*DepSet[Path]{NewDepSet[Path](order2, nil, nil)})
t.Fatal("expected panic")
}
@@ -304,87 +293,3 @@
})
}
}
-
-func Test_firstUnique(t *testing.T) {
- f := func(t *testing.T, imp func([]string) []string, in, want []string) {
- t.Helper()
- out := imp(in)
- if !reflect.DeepEqual(out, want) {
- t.Errorf("incorrect output:")
- t.Errorf(" input: %#v", in)
- t.Errorf(" expected: %#v", want)
- t.Errorf(" got: %#v", out)
- }
- }
-
- for _, testCase := range firstUniqueStringsTestCases {
- t.Run("list", func(t *testing.T) {
- f(t, func(s []string) []string {
- return firstUniqueList(s).([]string)
- }, testCase.in, testCase.out)
- })
- t.Run("map", func(t *testing.T) {
- f(t, func(s []string) []string {
- return firstUniqueMap(s).([]string)
- }, testCase.in, testCase.out)
- })
- }
-}
-
-func Benchmark_firstUnique(b *testing.B) {
- implementations := []struct {
- name string
- f func([]string) []string
- }{
- {
- name: "list",
- f: func(slice []string) []string {
- return firstUniqueList(slice).([]string)
- },
- },
- {
- name: "map",
- f: func(slice []string) []string {
- return firstUniqueMap(slice).([]string)
- },
- },
- {
- name: "optimal",
- f: func(slice []string) []string {
- return firstUnique(slice).([]string)
- },
- },
- }
- const maxSize = 1024
- uniqueStrings := make([]string, maxSize)
- for i := range uniqueStrings {
- uniqueStrings[i] = strconv.Itoa(i)
- }
- sameString := make([]string, maxSize)
- for i := range sameString {
- sameString[i] = uniqueStrings[0]
- }
-
- f := func(b *testing.B, imp func([]string) []string, s []string) {
- for i := 0; i < b.N; i++ {
- b.ReportAllocs()
- s = append([]string(nil), s...)
- imp(s)
- }
- }
-
- for n := 1; n <= maxSize; n <<= 1 {
- b.Run(strconv.Itoa(n), func(b *testing.B) {
- for _, implementation := range implementations {
- b.Run(implementation.name, func(b *testing.B) {
- b.Run("same", func(b *testing.B) {
- f(b, implementation.f, sameString[:n])
- })
- b.Run("unique", func(b *testing.B) {
- f(b, implementation.f, uniqueStrings[:n])
- })
- })
- }
- })
- }
-}
diff --git a/android/license_metadata.go b/android/license_metadata.go
index 73000a9..8933bd5 100644
--- a/android/license_metadata.go
+++ b/android/license_metadata.go
@@ -55,7 +55,7 @@
var allDepMetadataFiles Paths
var allDepMetadataArgs []string
var allDepOutputFiles Paths
- var allDepMetadataDepSets []*PathsDepSet
+ var allDepMetadataDepSets []*DepSet[Path]
ctx.VisitDirectDepsBlueprint(func(bpdep blueprint.Module) {
dep, _ := bpdep.(Module)
@@ -127,7 +127,7 @@
JoinWithPrefix(proptools.NinjaAndShellEscapeListIncludingSpaces(base.commonProperties.Effective_license_text.Strings()), "-n "))
if isContainer {
- transitiveDeps := newPathsDepSet(nil, allDepMetadataDepSets).ToList()
+ transitiveDeps := Paths(NewDepSet[Path](TOPOLOGICAL, nil, allDepMetadataDepSets).ToList())
args = append(args,
JoinWithPrefix(proptools.NinjaAndShellEscapeListIncludingSpaces(transitiveDeps.Strings()), "-d "))
orderOnlyDeps = append(orderOnlyDeps, transitiveDeps...)
@@ -170,7 +170,7 @@
ctx.SetProvider(LicenseMetadataProvider, &LicenseMetadataInfo{
LicenseMetadataPath: licenseMetadataFile,
- LicenseMetadataDepSet: newPathsDepSet(Paths{licenseMetadataFile}, allDepMetadataDepSets),
+ LicenseMetadataDepSet: NewDepSet(TOPOLOGICAL, Paths{licenseMetadataFile}, allDepMetadataDepSets),
})
}
@@ -198,7 +198,7 @@
// LicenseMetadataInfo stores the license metadata path for a module.
type LicenseMetadataInfo struct {
LicenseMetadataPath Path
- LicenseMetadataDepSet *PathsDepSet
+ LicenseMetadataDepSet *DepSet[Path]
}
// licenseAnnotationsFromTag returns the LicenseAnnotations for a tag (if any) converted into
diff --git a/android/module.go b/android/module.go
index 726fa85..384776a 100644
--- a/android/module.go
+++ b/android/module.go
@@ -1525,10 +1525,10 @@
noAddressSanitizer bool
installFiles InstallPaths
- installFilesDepSet *installPathsDepSet
+ installFilesDepSet *DepSet[InstallPath]
checkbuildFiles Paths
packagingSpecs []PackagingSpec
- packagingSpecsDepSet *packagingSpecsDepSet
+ packagingSpecsDepSet *DepSet[PackagingSpec]
// katiInstalls tracks the install rules that were created by Soong but are being exported
// to Make to convert to ninja rules so that Make can add additional dependencies.
katiInstalls katiInstalls
@@ -2108,9 +2108,9 @@
// computeInstallDeps finds the installed paths of all dependencies that have a dependency
// tag that is annotated as needing installation via the isInstallDepNeeded method.
-func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]*installPathsDepSet, []*packagingSpecsDepSet) {
- var installDeps []*installPathsDepSet
- var packagingSpecs []*packagingSpecsDepSet
+func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]*DepSet[InstallPath], []*DepSet[PackagingSpec]) {
+ var installDeps []*DepSet[InstallPath]
+ var packagingSpecs []*DepSet[PackagingSpec]
ctx.VisitDirectDeps(func(dep Module) {
if isInstallDepNeeded(dep, ctx.OtherModuleDependencyTag(dep)) {
// Installation is still handled by Make, so anything hidden from Make is not
@@ -2405,7 +2405,7 @@
// set m.installFilesDepSet to only the transitive dependencies to be used as the dependencies
// of installed files of this module. It will be replaced by a depset including the installed
// files of this module at the end for use by modules that depend on this one.
- m.installFilesDepSet = newInstallPathsDepSet(nil, dependencyInstallFiles)
+ m.installFilesDepSet = NewDepSet[InstallPath](TOPOLOGICAL, nil, dependencyInstallFiles)
// Temporarily continue to call blueprintCtx.GetMissingDependencies() to maintain the previous behavior of never
// reporting missing dependency errors in Blueprint when AllowMissingDependencies == true.
@@ -2512,8 +2512,8 @@
}
}
- m.installFilesDepSet = newInstallPathsDepSet(m.installFiles, dependencyInstallFiles)
- m.packagingSpecsDepSet = newPackagingSpecsDepSet(m.packagingSpecs, dependencyPackagingSpecs)
+ m.installFilesDepSet = NewDepSet[InstallPath](TOPOLOGICAL, m.installFiles, dependencyInstallFiles)
+ m.packagingSpecsDepSet = NewDepSet[PackagingSpec](TOPOLOGICAL, m.packagingSpecs, dependencyPackagingSpecs)
buildLicenseMetadata(ctx, m.licenseMetadataFile)
@@ -3394,7 +3394,7 @@
m.module.base().hooks.runInstallHooks(m, srcPath, fullInstallPath, false)
if !m.skipInstall() {
- deps = append(deps, m.module.base().installFilesDepSet.ToList().Paths()...)
+ deps = append(deps, InstallPaths(m.module.base().installFilesDepSet.ToList()).Paths()...)
var implicitDeps, orderOnlyDeps Paths
@@ -3969,26 +3969,6 @@
return blueprint.CheckBlueprintSyntax(bpctx.ModuleFactories(), filename, contents)
}
-// installPathsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
-// topological order.
-type installPathsDepSet struct {
- depSet
-}
-
-// newInstallPathsDepSet returns an immutable packagingSpecsDepSet with the given direct and
-// transitive contents.
-func newInstallPathsDepSet(direct InstallPaths, transitive []*installPathsDepSet) *installPathsDepSet {
- return &installPathsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
-}
-
-// ToList returns the installPathsDepSet flattened to a list in topological order.
-func (d *installPathsDepSet) ToList() InstallPaths {
- if d == nil {
- return nil
- }
- return d.depSet.ToList().(InstallPaths)
-}
-
func registerSoongConfigTraceMutator(ctx RegisterMutatorsContext) {
ctx.BottomUp("soongconfigtrace", soongConfigTraceMutator).Parallel()
}
diff --git a/android/neverallow.go b/android/neverallow.go
index f2e8c85..41105e6 100644
--- a/android/neverallow.go
+++ b/android/neverallow.go
@@ -239,7 +239,9 @@
func createInitFirstStageRules() []Rule {
return []Rule{
NeverAllow().
+ Without("name", "init_first_stage_defaults").
Without("name", "init_first_stage").
+ Without("name", "init_first_stage.microdroid").
With("install_in_root", "true").
Because("install_in_root is only for init_first_stage."),
}
diff --git a/android/packaging.go b/android/packaging.go
index c764a6d..503bb97 100644
--- a/android/packaging.go
+++ b/android/packaging.go
@@ -282,23 +282,3 @@
builder.Build("zip_deps", fmt.Sprintf("Zipping deps for %s", ctx.ModuleName()))
return entries
}
-
-// packagingSpecsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
-// topological order.
-type packagingSpecsDepSet struct {
- depSet
-}
-
-// newPackagingSpecsDepSet returns an immutable packagingSpecsDepSet with the given direct and
-// transitive contents.
-func newPackagingSpecsDepSet(direct []PackagingSpec, transitive []*packagingSpecsDepSet) *packagingSpecsDepSet {
- return &packagingSpecsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
-}
-
-// ToList returns the packagingSpecsDepSet flattened to a list in topological order.
-func (d *packagingSpecsDepSet) ToList() []PackagingSpec {
- if d == nil {
- return nil
- }
- return d.depSet.ToList().([]PackagingSpec)
-}
diff --git a/android/paths.go b/android/paths.go
index 94fa89c..fda4d2f 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -2196,23 +2196,3 @@
}
return false
}
-
-// PathsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
-// topological order.
-type PathsDepSet struct {
- depSet
-}
-
-// newPathsDepSet returns an immutable PathsDepSet with the given direct and
-// transitive contents.
-func newPathsDepSet(direct Paths, transitive []*PathsDepSet) *PathsDepSet {
- return &PathsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
-}
-
-// ToList returns the PathsDepSet flattened to a list in topological order.
-func (d *PathsDepSet) ToList() Paths {
- if d == nil {
- return nil
- }
- return d.depSet.ToList().(Paths)
-}
diff --git a/android/util.go b/android/util.go
index 08a3521..c4ce71a 100644
--- a/android/util.go
+++ b/android/util.go
@@ -284,38 +284,74 @@
list = CopyOf(list)
// 128 was chosen based on BenchmarkFirstUniqueStrings results.
if len(list) > 128 {
- return firstUniqueStringsMap(list)
+ return firstUnique(list)
}
- return firstUniqueStringsList(list)
+ return firstUnique(list)
}
-func firstUniqueStringsList(list []string) []string {
- k := 0
+// firstUnique returns all unique elements of a slice, keeping the first copy of each. It
+// modifies the slice contents in place, and returns a subslice of the original slice.
+func firstUnique[T comparable](slice []T) []T {
+ // 4 was chosen based on Benchmark_firstUnique results.
+ if len(slice) > 4 {
+ return firstUniqueMap(slice)
+ }
+ return firstUniqueList(slice)
+}
+
+// firstUniqueList is an implementation of firstUnique using an O(N^2) list comparison to look for
+// duplicates.
+func firstUniqueList[T any](in []T) []T {
+ writeIndex := 0
outer:
- for i := 0; i < len(list); i++ {
- for j := 0; j < k; j++ {
- if list[i] == list[j] {
+ for readIndex := 0; readIndex < len(in); readIndex++ {
+ for compareIndex := 0; compareIndex < writeIndex; compareIndex++ {
+ if interface{}(in[readIndex]) == interface{}(in[compareIndex]) {
+ // The value at readIndex already exists somewhere in the output region
+ // of the slice before writeIndex, skip it.
continue outer
}
}
- list[k] = list[i]
- k++
+ if readIndex != writeIndex {
+ in[writeIndex] = in[readIndex]
+ }
+ writeIndex++
}
- return list[:k]
+ return in[0:writeIndex]
}
-func firstUniqueStringsMap(list []string) []string {
- k := 0
- seen := make(map[string]bool, len(list))
- for i := 0; i < len(list); i++ {
- if seen[list[i]] {
+// firstUniqueMap is an implementation of firstUnique using an O(N) hash set lookup to look for
+// duplicates.
+func firstUniqueMap[T comparable](in []T) []T {
+ writeIndex := 0
+ seen := make(map[T]bool, len(in))
+ for readIndex := 0; readIndex < len(in); readIndex++ {
+ if _, exists := seen[in[readIndex]]; exists {
continue
}
- seen[list[i]] = true
- list[k] = list[i]
- k++
+ seen[in[readIndex]] = true
+ if readIndex != writeIndex {
+ in[writeIndex] = in[readIndex]
+ }
+ writeIndex++
}
- return list[:k]
+ return in[0:writeIndex]
+}
+
+// reverseSliceInPlace reverses the elements of a slice in place.
+func reverseSliceInPlace[T any](in []T) {
+ for i, j := 0, len(in)-1; i < j; i, j = i+1, j-1 {
+ in[i], in[j] = in[j], in[i]
+ }
+}
+
+// reverseSlice returns a copy of a slice in reverse order.
+func reverseSlice[T any](in []T) []T {
+ out := make([]T, len(in))
+ for i := 0; i < len(in); i++ {
+ out[i] = in[len(in)-1-i]
+ }
+ return out
}
// LastUniqueStrings returns all unique elements of a slice of strings, keeping the last copy of
diff --git a/android/util_test.go b/android/util_test.go
index a2ef589..bee31a9 100644
--- a/android/util_test.go
+++ b/android/util_test.go
@@ -74,10 +74,10 @@
for _, testCase := range firstUniqueStringsTestCases {
t.Run("list", func(t *testing.T) {
- f(t, firstUniqueStringsList, testCase.in, testCase.out)
+ f(t, firstUniqueList[string], testCase.in, testCase.out)
})
t.Run("map", func(t *testing.T) {
- f(t, firstUniqueStringsMap, testCase.in, testCase.out)
+ f(t, firstUniqueMap[string], testCase.in, testCase.out)
})
}
}
@@ -604,11 +604,11 @@
}{
{
name: "list",
- f: firstUniqueStringsList,
+ f: firstUniqueList[string],
},
{
name: "map",
- f: firstUniqueStringsMap,
+ f: firstUniqueMap[string],
},
{
name: "optimal",
diff --git a/android/variable.go b/android/variable.go
index 3f83482..3bec854 100644
--- a/android/variable.go
+++ b/android/variable.go
@@ -472,8 +472,8 @@
ProductBrand string `json:",omitempty"`
BuildVersionTags []string `json:",omitempty"`
- ReleaseVersion string `json:",omitempty"`
- ReleaseDeviceConfigValueSets []string `json:",omitempty"`
+ ReleaseVersion string `json:",omitempty"`
+ ReleaseAconfigValueSets []string `json:",omitempty"`
}
func boolPtr(v bool) *bool {
diff --git a/cc/cc.go b/cc/cc.go
index d67f3ad..7bc8341 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -151,7 +151,7 @@
StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
// Transitive static library dependencies of static libraries for use in ordering.
- TranstiveStaticLibrariesForOrdering *android.DepSet
+ TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
// Paths to .o files
Objs Objects
@@ -3550,8 +3550,8 @@
// to match the topological order of the dependency tree, including any static analogues of
// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
// of the transitive dependencies.
-func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
- transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
+func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
+ transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
var staticPaths android.Paths
for _, staticDep := range staticDeps {
staticPaths = append(staticPaths, staticDep.StaticLibrary)
diff --git a/cc/cc_test.go b/cc/cc_test.go
index 859059e..7534db2 100644
--- a/cc/cc_test.go
+++ b/cc/cc_test.go
@@ -2700,8 +2700,8 @@
variant := "android_arm64_armv8-a_static"
moduleA := ctx.ModuleForTests("a", variant).Module().(*Module)
- actual := ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
- TransitiveStaticLibrariesForOrdering.ToList().RelativeToTop()
+ actual := android.Paths(ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
+ TransitiveStaticLibrariesForOrdering.ToList()).RelativeToTop()
expected := GetOutputPaths(ctx, variant, []string{"a", "c", "b", "d"})
if !reflect.DeepEqual(actual, expected) {
@@ -2736,8 +2736,8 @@
variant := "android_arm64_armv8-a_static"
moduleA := ctx.ModuleForTests("a", variant).Module().(*Module)
- actual := ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
- TransitiveStaticLibrariesForOrdering.ToList().RelativeToTop()
+ actual := android.Paths(ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
+ TransitiveStaticLibrariesForOrdering.ToList()).RelativeToTop()
expected := GetOutputPaths(ctx, variant, []string{"a", "c", "b"})
if !reflect.DeepEqual(actual, expected) {
diff --git a/cc/library.go b/cc/library.go
index 47df53e..aec6433 100644
--- a/cc/library.go
+++ b/cc/library.go
@@ -892,7 +892,7 @@
// TODO(b/190524881): Include transitive static libraries in this provider to support
// static libraries with deps.
- TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
+ TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
Direct(outputFilePath).
Build(),
})
@@ -1649,7 +1649,7 @@
Objects: library.objects,
WholeStaticLibsFromPrebuilts: library.wholeStaticLibsFromPrebuilts,
- TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
+ TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
Direct(outputFile).
Transitive(deps.TranstiveStaticLibrariesForOrdering).
Build(),
@@ -1794,7 +1794,7 @@
library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
- var transitiveStaticLibrariesForOrdering *android.DepSet
+ var transitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
transitiveStaticLibrariesForOrdering = s.TransitiveStaticLibrariesForOrdering
diff --git a/cc/linkable.go b/cc/linkable.go
index 976a382..19e6501 100644
--- a/cc/linkable.go
+++ b/cc/linkable.go
@@ -345,7 +345,7 @@
TableOfContents android.OptionalPath
// should be obtained from static analogue
- TransitiveStaticLibrariesForOrdering *android.DepSet
+ TransitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
}
var SharedLibraryInfoProvider = blueprint.NewProvider(SharedLibraryInfo{})
@@ -387,7 +387,7 @@
// This isn't the actual transitive DepSet, shared library dependencies have been
// converted into static library analogues. It is only used to order the static
// library dependencies that were specified for the current module.
- TransitiveStaticLibrariesForOrdering *android.DepSet
+ TransitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
}
var StaticLibraryInfoProvider = blueprint.NewProvider(StaticLibraryInfo{})
diff --git a/cc/ndk_prebuilt.go b/cc/ndk_prebuilt.go
index 1d15cf8..d3a0a00 100644
--- a/cc/ndk_prebuilt.go
+++ b/cc/ndk_prebuilt.go
@@ -113,7 +113,7 @@
ndk.libraryDecorator.flagExporter.setProvider(ctx)
if ndk.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(lib).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(lib).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: lib,
diff --git a/cc/prebuilt.go b/cc/prebuilt.go
index 44cd0d7..a4ca590 100644
--- a/cc/prebuilt.go
+++ b/cc/prebuilt.go
@@ -140,7 +140,7 @@
}
if p.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(in).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(in).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: in,
@@ -508,7 +508,7 @@
h.module.outputFile = android.OptionalPathForPath(outputPath)
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(outputPath).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(outputPath).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: outputPath,
TransitiveStaticLibrariesForOrdering: depSet,
diff --git a/cc/sanitize.go b/cc/sanitize.go
index d391cf5..7dedd60 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -38,11 +38,11 @@
}
asanLdflags = []string{"-Wl,-u,__asan_preinit"}
+ // DO NOT ADD MLLVM FLAGS HERE! ADD THEM BELOW TO hwasanCommonFlags.
hwasanCflags = []string{
"-fno-omit-frame-pointer",
"-Wno-frame-larger-than=",
"-fsanitize-hwaddress-abi=platform",
- "-mllvm", "-hwasan-use-after-scope=1",
}
// ThinLTO performs codegen during link time, thus these flags need to
@@ -60,6 +60,8 @@
// GlobalISel is the default at -O0 on aarch64.
"--aarch64-enable-global-isel-at-O=-1",
"-fast-isel=false",
+ "-hwasan-use-after-scope=1",
+ "-dom-tree-reachability-max-bbs-to-explore=128",
}
sanitizeIgnorelistPrefix = "-fsanitize-ignorelist="
@@ -882,13 +884,8 @@
if Bool(sanProps.Memtag_stack) {
flags.Local.CFlags = append(flags.Local.CFlags, memtagStackCommonFlags...)
- // TODO(fmayer): remove -Wno-error once https://reviews.llvm.org/D127917 is in Android toolchain.
- flags.Local.CFlags = append(flags.Local.CFlags, "-Wno-error=frame-larger-than")
flags.Local.AsFlags = append(flags.Local.AsFlags, memtagStackCommonFlags...)
flags.Local.LdFlags = append(flags.Local.LdFlags, memtagStackCommonFlags...)
- // This works around LLD complaining about the stack frame size.
- // TODO(fmayer): remove once https://reviews.llvm.org/D127917 is in Android toolchain.
- flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--no-fatal-warnings")
}
if (Bool(sanProps.Memtag_heap) || Bool(sanProps.Memtag_stack)) && ctx.binary() {
diff --git a/cc/snapshot_prebuilt.go b/cc/snapshot_prebuilt.go
index bb6e257..a5729df 100644
--- a/cc/snapshot_prebuilt.go
+++ b/cc/snapshot_prebuilt.go
@@ -499,7 +499,7 @@
}
if p.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(in).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(in).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: in,
diff --git a/cmd/multiproduct_kati/main.go b/cmd/multiproduct_kati/main.go
index b897bb5..c3b0381 100644
--- a/cmd/multiproduct_kati/main.go
+++ b/cmd/multiproduct_kati/main.go
@@ -399,6 +399,9 @@
var wg sync.WaitGroup
for i := 0; i < jobs; i++ {
wg.Add(1)
+ // To smooth out the spikes in memory usage, skew the
+ // initial starting time of the jobs by a small amount.
+ time.Sleep(15 * time.Second)
go func() {
defer wg.Done()
for {
diff --git a/cmd/soong_build/main.go b/cmd/soong_build/main.go
index 989dd7f..10a5762 100644
--- a/cmd/soong_build/main.go
+++ b/cmd/soong_build/main.go
@@ -124,7 +124,8 @@
return ctx.Config().BazelContext.InvokeBazel(ctx.Config(), ctx)
}
ctx.SetBeforePrepareBuildActionsHook(bazelHook)
- ninjaDeps := bootstrap.RunBlueprint(cmdlineArgs.Args, bootstrap.DoEverything, ctx.Context, ctx.Config())
+ ninjaDeps, err := bootstrap.RunBlueprint(cmdlineArgs.Args, bootstrap.DoEverything, ctx.Context, ctx.Config())
+ maybeQuit(err, "")
ninjaDeps = append(ninjaDeps, extraNinjaDeps...)
bazelPaths, err := readFileLines(ctx.Config().Getenv("BAZEL_DEPS_FILE"))
@@ -185,10 +186,11 @@
}
// Run the loading and analysis phase
- ninjaDeps := bootstrap.RunBlueprint(cmdlineArgs.Args,
+ ninjaDeps, err := bootstrap.RunBlueprint(cmdlineArgs.Args,
bootstrap.StopBeforePrepareBuildActions,
ctx.Context,
ctx.Config())
+ maybeQuit(err, "")
ninjaDeps = append(ninjaDeps, extraNinjaDeps...)
// Add the globbed dependencies
@@ -218,7 +220,7 @@
// }
//
// If we don't generate f/b/api/BUILD, foo.contribution will be unbuildable.
- err := createBazelWorkspace(codegenContext, absoluteApiBp2buildDir, true)
+ err = createBazelWorkspace(codegenContext, absoluteApiBp2buildDir, true)
maybeQuit(err, "")
ninjaDeps = append(ninjaDeps, codegenContext.AdditionalNinjaDeps()...)
@@ -412,12 +414,13 @@
defer ctx.EventHandler.End("globs_ninja_file")
globDir := bootstrap.GlobDirectory(ctx.Config().SoongOutDir(), globListDir)
- bootstrap.WriteBuildGlobsNinjaFile(&bootstrap.GlobSingleton{
+ err := bootstrap.WriteBuildGlobsNinjaFile(&bootstrap.GlobSingleton{
GlobLister: ctx.Globs,
GlobFile: globFile,
GlobDir: globDir,
SrcDir: ctx.SrcDir(),
}, ctx.Config())
+ maybeQuit(err, "")
return bootstrap.GlobFileListFiles(globDir)
}
@@ -444,7 +447,8 @@
stopBefore = bootstrap.DoEverything
}
- ninjaDeps := bootstrap.RunBlueprint(cmdlineArgs.Args, stopBefore, ctx.Context, ctx.Config())
+ ninjaDeps, err := bootstrap.RunBlueprint(cmdlineArgs.Args, stopBefore, ctx.Context, ctx.Config())
+ maybeQuit(err, "")
ninjaDeps = append(ninjaDeps, extraNinjaDeps...)
globListFiles := writeBuildGlobsNinjaFile(ctx)
@@ -803,8 +807,9 @@
// from the regular Modules.
ctx.EventHandler.Do("bootstrap", func() {
blueprintArgs := cmdlineArgs
- bootstrapDeps := bootstrap.RunBlueprint(blueprintArgs.Args,
+ bootstrapDeps, err := bootstrap.RunBlueprint(blueprintArgs.Args,
bootstrap.StopBeforePrepareBuildActions, ctx.Context, ctx.Config())
+ maybeQuit(err, "")
ninjaDeps = append(ninjaDeps, bootstrapDeps...)
})
diff --git a/device_config/Android.bp b/device_config/Android.bp
deleted file mode 100644
index 6c44454..0000000
--- a/device_config/Android.bp
+++ /dev/null
@@ -1,32 +0,0 @@
-package {
- default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-bootstrap_go_package {
- name: "soong-device_config",
- pkgPath: "android/soong/device_config",
- deps: [
- "blueprint",
- "blueprint-pathtools",
- "sbox_proto",
- "soong",
- "soong-android",
- "soong-bazel",
- "soong-android",
- "soong-java",
- ],
- srcs: [
- "device_config_definitions.go",
- "device_config_values.go",
- "device_config_value_set.go",
- "init.go",
- "java_device_config_definitions_library.go",
- "testing.go",
- ],
- testSrcs: [
- "device_config_definitions_test.go",
- "device_config_values_test.go",
- "device_config_value_set_test.go",
- ],
- pluginFor: ["soong_build"],
-}
diff --git a/device_config/java_device_config_definitions_library.go b/device_config/java_device_config_definitions_library.go
deleted file mode 100644
index 6e48ece..0000000
--- a/device_config/java_device_config_definitions_library.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2023 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 device_config
-
-import (
- "android/soong/android"
- "android/soong/java"
- "fmt"
- "github.com/google/blueprint"
-)
-
-type definitionsTagType struct {
- blueprint.BaseDependencyTag
-}
-
-var definitionsTag = definitionsTagType{}
-
-type JavaDeviceConfigDefinitionsLibraryProperties struct {
- // name of the device_config_definitions module to generate a library for
- Device_config_definitions string
-}
-
-type JavaDeviceConfigDefinitionsLibraryCallbacks struct {
- properties JavaDeviceConfigDefinitionsLibraryProperties
-}
-
-func JavaDefinitionsLibraryFactory() android.Module {
- callbacks := &JavaDeviceConfigDefinitionsLibraryCallbacks{}
- return java.GeneratedJavaLibraryModuleFactory("java_device_config_definitions_library", callbacks, &callbacks.properties)
-}
-
-func (callbacks *JavaDeviceConfigDefinitionsLibraryCallbacks) DepsMutator(module *java.GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext) {
- definitions := callbacks.properties.Device_config_definitions
- if len(definitions) == 0 {
- // TODO: Add test for this case
- ctx.PropertyErrorf("device_config_definitions", "device_config_definitions property required")
- } else {
- ctx.AddDependency(ctx.Module(), definitionsTag, definitions)
- }
-}
-
-func (callbacks *JavaDeviceConfigDefinitionsLibraryCallbacks) GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path {
- // Get the values that came from the global RELEASE_DEVICE_CONFIG_VALUE_SETS flag
- definitionsModules := ctx.GetDirectDepsWithTag(definitionsTag)
- if len(definitionsModules) != 1 {
- panic(fmt.Errorf("Exactly one device_config_definitions property required"))
- }
- definitions := ctx.OtherModuleProvider(definitionsModules[0], definitionsProviderKey).(definitionsProviderData)
-
- srcJarPath := android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar")
- ctx.Build(pctx, android.BuildParams{
- Rule: srcJarRule,
- Input: definitions.intermediatePath,
- Output: srcJarPath,
- Description: "device_config.srcjar",
- })
-
- return srcJarPath
-}
diff --git a/dexpreopt/config.go b/dexpreopt/config.go
index e61ebe6..bb83dc8 100644
--- a/dexpreopt/config.go
+++ b/dexpreopt/config.go
@@ -321,7 +321,7 @@
missingDepsCtx.AddMissingDependencies([]string{err.Error()})
}
} else {
- android.ReportPathErrorf(ctx, "%w", err)
+ android.ReportPathErrorf(ctx, "%s", err)
}
}
diff --git a/go.mod b/go.mod
index 4a511c5..0a11bd2 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
module android/soong
-go 1.19
+go 1.20
require (
github.com/google/blueprint v0.0.0
diff --git a/java/base.go b/java/base.go
index f9c9e1e..75e25e3 100644
--- a/java/base.go
+++ b/java/base.go
@@ -1756,24 +1756,24 @@
type providesTransitiveHeaderJars struct {
// set of header jars for all transitive libs deps
- transitiveLibsHeaderJars *android.DepSet
+ transitiveLibsHeaderJars *android.DepSet[android.Path]
// set of header jars for all transitive static libs deps
- transitiveStaticLibsHeaderJars *android.DepSet
+ transitiveStaticLibsHeaderJars *android.DepSet[android.Path]
}
-func (j *providesTransitiveHeaderJars) TransitiveLibsHeaderJars() *android.DepSet {
+func (j *providesTransitiveHeaderJars) TransitiveLibsHeaderJars() *android.DepSet[android.Path] {
return j.transitiveLibsHeaderJars
}
-func (j *providesTransitiveHeaderJars) TransitiveStaticLibsHeaderJars() *android.DepSet {
+func (j *providesTransitiveHeaderJars) TransitiveStaticLibsHeaderJars() *android.DepSet[android.Path] {
return j.transitiveStaticLibsHeaderJars
}
func (j *providesTransitiveHeaderJars) collectTransitiveHeaderJars(ctx android.ModuleContext) {
directLibs := android.Paths{}
directStaticLibs := android.Paths{}
- transitiveLibs := []*android.DepSet{}
- transitiveStaticLibs := []*android.DepSet{}
+ transitiveLibs := []*android.DepSet[android.Path]{}
+ transitiveStaticLibs := []*android.DepSet[android.Path]{}
ctx.VisitDirectDeps(func(module android.Module) {
// don't add deps of the prebuilt version of the same library
if ctx.ModuleName() == android.RemoveOptionalPrebuiltPrefix(module.Name()) {
diff --git a/java/java.go b/java/java.go
index a026610..3e6b96b 100644
--- a/java/java.go
+++ b/java/java.go
@@ -231,10 +231,10 @@
HeaderJars android.Paths
// set of header jars for all transitive libs deps
- TransitiveLibsHeaderJars *android.DepSet
+ TransitiveLibsHeaderJars *android.DepSet[android.Path]
// set of header jars for all transitive static libs deps
- TransitiveStaticLibsHeaderJars *android.DepSet
+ TransitiveStaticLibsHeaderJars *android.DepSet[android.Path]
// ImplementationAndResourceJars is a list of jars that contain the implementations of classes
// in the module as well as any resources included in the module.
diff --git a/java/lint.go b/java/lint.go
index a0f9970..f84f1c0 100644
--- a/java/lint.go
+++ b/java/lint.go
@@ -117,18 +117,18 @@
}
type LintDepSets struct {
- HTML, Text, XML *android.DepSet
+ HTML, Text, XML *android.DepSet[android.Path]
}
type LintDepSetsBuilder struct {
- HTML, Text, XML *android.DepSetBuilder
+ HTML, Text, XML *android.DepSetBuilder[android.Path]
}
func NewLintDepSetBuilder() LintDepSetsBuilder {
return LintDepSetsBuilder{
- HTML: android.NewDepSetBuilder(android.POSTORDER),
- Text: android.NewDepSetBuilder(android.POSTORDER),
- XML: android.NewDepSetBuilder(android.POSTORDER),
+ HTML: android.NewDepSetBuilder[android.Path](android.POSTORDER),
+ Text: android.NewDepSetBuilder[android.Path](android.POSTORDER),
+ XML: android.NewDepSetBuilder[android.Path](android.POSTORDER),
}
}
@@ -553,9 +553,9 @@
}
func BuildModuleLintReportZips(ctx android.ModuleContext, depSets LintDepSets) android.Paths {
- htmlList := depSets.HTML.ToSortedList()
- textList := depSets.Text.ToSortedList()
- xmlList := depSets.XML.ToSortedList()
+ htmlList := android.SortedUniquePaths(depSets.HTML.ToList())
+ textList := android.SortedUniquePaths(depSets.Text.ToList())
+ xmlList := android.SortedUniquePaths(depSets.XML.ToList())
if len(htmlList) == 0 && len(textList) == 0 && len(xmlList) == 0 {
return nil
diff --git a/java/sdk_library.go b/java/sdk_library.go
index 3de8238..a3d81ce 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -25,6 +25,7 @@
"sync"
"android/soong/ui/metrics/bp2build_metrics_proto"
+
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
@@ -1698,7 +1699,6 @@
"MissingPermission",
"SdkConstant",
"Todo",
- "Typo",
"UnavailableSymbol",
}
droidstubsArgs = append(droidstubsArgs, android.JoinWithPrefix(disabledWarnings, "--hide "))
diff --git a/rust/library.go b/rust/library.go
index ca5ad14..331763a 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -566,7 +566,7 @@
}
if library.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(outputFile).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(outputFile).Build()
ctx.SetProvider(cc.StaticLibraryInfoProvider, cc.StaticLibraryInfo{
StaticLibrary: outputFile,
diff --git a/tests/lib.sh b/tests/lib.sh
index b5dea99..4aaf272 100644
--- a/tests/lib.sh
+++ b/tests/lib.sh
@@ -144,6 +144,7 @@
symlink_directory prebuilts/jdk
symlink_directory external/bazel-skylib
symlink_directory external/bazelbuild-rules_android
+ symlink_directory external/bazelbuild-rules_go
symlink_directory external/bazelbuild-rules_license
symlink_directory external/bazelbuild-kotlin-rules
diff --git a/third_party/zip/android_test.go b/third_party/zip/android_test.go
index 46588d4..3911dd4 100644
--- a/third_party/zip/android_test.go
+++ b/third_party/zip/android_test.go
@@ -190,7 +190,9 @@
t.Errorf("wanted directoryRecords %d, got %d", w, g)
}
- if g, w := d.directorySize, uint64(uint32max); g != w {
+ zip64ExtraBuf := 48 // 4x uint16 + 5x uint64
+ expectedDirSize := directoryHeaderLen + zip64ExtraBuf + len("large") // name of header
+ if g, w := d.directorySize, uint64(expectedDirSize); g != w {
t.Errorf("wanted directorySize %d, got %d", w, g)
}
diff --git a/tradefed/autogen.go b/tradefed/autogen.go
index 3c55c51..ddd0a80 100644
--- a/tradefed/autogen.go
+++ b/tradefed/autogen.go
@@ -167,7 +167,6 @@
for _, c := range options.OptionsForAutogenerated {
configs = append(configs, c)
}
- testRunnerConfigs := append([]Option{}, options.TestRunnerOptions...)
name := options.Name
if name == "" {
name = ctx.ModuleName()
@@ -176,15 +175,15 @@
if autogenPath != nil {
templatePath := getTestConfigTemplate(ctx, options.TestConfigTemplateProp)
if templatePath.Valid() {
- autogenTemplate(ctx, name, autogenPath, templatePath.String(), configs, testRunnerConfigs, options.OutputFileName, options.TestInstallBase)
+ autogenTemplate(ctx, name, autogenPath, templatePath.String(), configs, options.TestRunnerOptions, options.OutputFileName, options.TestInstallBase)
} else {
if ctx.Device() {
- autogenTemplate(ctx, name, autogenPath, options.DeviceTemplate, configs, testRunnerConfigs, options.OutputFileName, options.TestInstallBase)
+ autogenTemplate(ctx, name, autogenPath, options.DeviceTemplate, configs, options.TestRunnerOptions, options.OutputFileName, options.TestInstallBase)
} else {
if Bool(options.UnitTest) {
- autogenTemplate(ctx, name, autogenPath, options.HostUnitTestTemplate, configs, testRunnerConfigs, options.OutputFileName, options.TestInstallBase)
+ autogenTemplate(ctx, name, autogenPath, options.HostUnitTestTemplate, configs, options.TestRunnerOptions, options.OutputFileName, options.TestInstallBase)
} else {
- autogenTemplate(ctx, name, autogenPath, options.HostTemplate, configs, testRunnerConfigs, options.OutputFileName, options.TestInstallBase)
+ autogenTemplate(ctx, name, autogenPath, options.HostTemplate, configs, options.TestRunnerOptions, options.OutputFileName, options.TestInstallBase)
}
}
}
diff --git a/ui/build/bazel_metrics.go b/ui/build/bazel_metrics.go
index c0690c1..3f9fbb1 100644
--- a/ui/build/bazel_metrics.go
+++ b/ui/build/bazel_metrics.go
@@ -121,6 +121,7 @@
}
}
bazelMetrics.PhaseTimings = phaseTimings
+ bazelMetrics.BesId = proto.String(config.besId)
return bazelMetrics
}
diff --git a/ui/build/config.go b/ui/build/config.go
index d825754..0259009 100644
--- a/ui/build/config.go
+++ b/ui/build/config.go
@@ -90,8 +90,9 @@
skipMetricsUpload bool
buildStartedTime int64 // For metrics-upload-only - manually specify a build-started time
buildFromTextStub bool
- ensureAllowlistIntegrity bool // For CI builds - make sure modules are mixed-built
- bazelExitCode int32 // For b-runs - necessary for updating NonZeroExit
+ ensureAllowlistIntegrity bool // For CI builds - make sure modules are mixed-built
+ bazelExitCode int32 // For b runs - necessary for updating NonZeroExit
+ besId string // For b runs, to identify the BuildEventService logs
// From the product config
katiArgs []string
@@ -908,6 +909,8 @@
} else {
ctx.Fatalf("Error parsing bazel-exit-code", err)
}
+ } else if strings.HasPrefix(arg, "--bes-id=") {
+ c.besId = strings.TrimPrefix(arg, "--bes-id=")
} else if len(arg) > 0 && arg[0] == '-' {
parseArgNum := func(def int) int {
if len(arg) > 2 {
@@ -1511,7 +1514,7 @@
if googleProdCredsExistCache {
return googleProdCredsExistCache
}
- if _, err := exec.Command("/usr/bin/gcertstatus").Output(); err != nil {
+ if _, err := exec.Command("/usr/bin/gcertstatus", "-nocheck_ssh").Output(); err != nil {
return false
}
googleProdCredsExistCache = true
diff --git a/ui/build/soong.go b/ui/build/soong.go
index 59a3242..07d6188 100644
--- a/ui/build/soong.go
+++ b/ui/build/soong.go
@@ -445,7 +445,10 @@
// since `bootstrap.ninja` is regenerated unconditionally, we ignore the deps, i.e. little
// reason to write a `bootstrap.ninja.d` file
- _ = bootstrap.RunBlueprint(blueprintArgs, bootstrap.DoEverything, blueprintCtx, blueprintConfig)
+ _, err := bootstrap.RunBlueprint(blueprintArgs, bootstrap.DoEverything, blueprintCtx, blueprintConfig)
+ if err != nil {
+ ctx.Fatal(err)
+ }
}
func checkEnvironmentFile(ctx Context, currentEnv *Environment, envFile string) {
diff --git a/ui/metrics/bazel_metrics_proto/bazel_metrics.pb.go b/ui/metrics/bazel_metrics_proto/bazel_metrics.pb.go
index 17a6b91..8b97b83 100644
--- a/ui/metrics/bazel_metrics_proto/bazel_metrics.pb.go
+++ b/ui/metrics/bazel_metrics_proto/bazel_metrics.pb.go
@@ -42,7 +42,7 @@
PhaseTimings []*PhaseTiming `protobuf:"bytes,1,rep,name=phase_timings,json=phaseTimings,proto3" json:"phase_timings,omitempty"`
Total *int64 `protobuf:"varint,2,opt,name=total,proto3,oneof" json:"total,omitempty"`
ExitCode *int32 `protobuf:"varint,3,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"`
- SpongeId *string `protobuf:"bytes,4,opt,name=sponge_id,json=spongeId,proto3,oneof" json:"sponge_id,omitempty"`
+ BesId *string `protobuf:"bytes,4,opt,name=bes_id,json=besId,proto3,oneof" json:"bes_id,omitempty"`
}
func (x *BazelMetrics) Reset() {
@@ -98,9 +98,9 @@
return 0
}
-func (x *BazelMetrics) GetSpongeId() string {
- if x != nil && x.SpongeId != nil {
- return *x.SpongeId
+func (x *BazelMetrics) GetBesId() string {
+ if x != nil && x.BesId != nil {
+ return *x.BesId
}
return ""
}
@@ -177,7 +177,7 @@
0x0a, 0x13, 0x62, 0x61, 0x7a, 0x65, 0x6c, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x73, 0x6f, 0x6f, 0x6e, 0x67, 0x5f, 0x62, 0x75, 0x69,
0x6c, 0x64, 0x5f, 0x62, 0x61, 0x7a, 0x65, 0x6c, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73,
- 0x22, 0xe0, 0x01, 0x0a, 0x0c, 0x42, 0x61, 0x7a, 0x65, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63,
+ 0x22, 0xd7, 0x01, 0x0a, 0x0c, 0x42, 0x61, 0x7a, 0x65, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63,
0x73, 0x12, 0x4b, 0x0a, 0x0d, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x69, 0x6e,
0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x6f, 0x6f, 0x6e, 0x67,
0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x62, 0x61, 0x7a, 0x65, 0x6c, 0x5f, 0x6d, 0x65, 0x74,
@@ -186,28 +186,28 @@
0x0a, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52,
0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x09, 0x65, 0x78, 0x69,
0x74, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x48, 0x01, 0x52, 0x08,
- 0x65, 0x78, 0x69, 0x74, 0x43, 0x6f, 0x64, 0x65, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x09, 0x73,
- 0x70, 0x6f, 0x6e, 0x67, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x02,
- 0x52, 0x08, 0x73, 0x70, 0x6f, 0x6e, 0x67, 0x65, 0x49, 0x64, 0x88, 0x01, 0x01, 0x42, 0x08, 0x0a,
- 0x06, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x65, 0x78, 0x69, 0x74,
- 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x73, 0x70, 0x6f, 0x6e, 0x67, 0x65,
- 0x5f, 0x69, 0x64, 0x22, 0xd1, 0x01, 0x0a, 0x0b, 0x50, 0x68, 0x61, 0x73, 0x65, 0x54, 0x69, 0x6d,
- 0x69, 0x6e, 0x67, 0x12, 0x22, 0x0a, 0x0a, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
- 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x09, 0x70, 0x68, 0x61, 0x73, 0x65,
- 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x2a, 0x0a, 0x0e, 0x64, 0x75, 0x72, 0x61, 0x74,
- 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48,
- 0x01, 0x52, 0x0d, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6e, 0x6f, 0x73,
- 0x88, 0x01, 0x01, 0x12, 0x36, 0x0a, 0x15, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f,
- 0x66, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01,
- 0x28, 0x05, 0x48, 0x02, 0x52, 0x12, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x66, 0x42,
- 0x75, 0x69, 0x6c, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f,
- 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x64,
- 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42, 0x18, 0x0a,
- 0x16, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x66, 0x5f, 0x62, 0x75, 0x69,
- 0x6c, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x2e, 0x5a, 0x2c, 0x61, 0x6e, 0x64, 0x72, 0x6f,
- 0x69, 0x64, 0x2f, 0x73, 0x6f, 0x6f, 0x6e, 0x67, 0x2f, 0x75, 0x69, 0x2f, 0x6d, 0x65, 0x74, 0x72,
- 0x69, 0x63, 0x73, 0x2f, 0x62, 0x61, 0x7a, 0x65, 0x6c, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63,
- 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+ 0x65, 0x78, 0x69, 0x74, 0x43, 0x6f, 0x64, 0x65, 0x88, 0x01, 0x01, 0x12, 0x1a, 0x0a, 0x06, 0x62,
+ 0x65, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x02, 0x52, 0x05, 0x62,
+ 0x65, 0x73, 0x49, 0x64, 0x88, 0x01, 0x01, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x74, 0x6f, 0x74, 0x61,
+ 0x6c, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x65, 0x78, 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x42,
+ 0x09, 0x0a, 0x07, 0x5f, 0x62, 0x65, 0x73, 0x5f, 0x69, 0x64, 0x22, 0xd1, 0x01, 0x0a, 0x0b, 0x50,
+ 0x68, 0x61, 0x73, 0x65, 0x54, 0x69, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x22, 0x0a, 0x0a, 0x70, 0x68,
+ 0x61, 0x73, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00,
+ 0x52, 0x09, 0x70, 0x68, 0x61, 0x73, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x2a,
+ 0x0a, 0x0e, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6e, 0x6f, 0x73,
+ 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x01, 0x52, 0x0d, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 0x4e, 0x61, 0x6e, 0x6f, 0x73, 0x88, 0x01, 0x01, 0x12, 0x36, 0x0a, 0x15, 0x70, 0x6f,
+ 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x66, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x74,
+ 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x48, 0x02, 0x52, 0x12, 0x70, 0x6f, 0x72,
+ 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x66, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88,
+ 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
+ 0x65, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e,
+ 0x61, 0x6e, 0x6f, 0x73, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e,
+ 0x5f, 0x6f, 0x66, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x2e,
+ 0x5a, 0x2c, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f, 0x73, 0x6f, 0x6f, 0x6e, 0x67, 0x2f,
+ 0x75, 0x69, 0x2f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2f, 0x62, 0x61, 0x7a, 0x65, 0x6c,
+ 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
diff --git a/ui/metrics/bazel_metrics_proto/bazel_metrics.proto b/ui/metrics/bazel_metrics_proto/bazel_metrics.proto
index e7e1015..e45d2bf 100644
--- a/ui/metrics/bazel_metrics_proto/bazel_metrics.proto
+++ b/ui/metrics/bazel_metrics_proto/bazel_metrics.proto
@@ -21,7 +21,7 @@
repeated PhaseTiming phase_timings = 1;
optional int64 total = 2;
optional int32 exit_code = 3;
- optional string sponge_id = 4;
+ optional string bes_id = 4;
}
message PhaseTiming {
diff --git a/ui/metrics/metrics.go b/ui/metrics/metrics.go
index 6d60316..d68ced8 100644
--- a/ui/metrics/metrics.go
+++ b/ui/metrics/metrics.go
@@ -230,7 +230,7 @@
func (m *Metrics) UpdateTotalRealTimeAndNonZeroExit(data []byte, bazelExitCode int32) error {
if err := proto.Unmarshal(data, &m.metrics); err != nil {
- return fmt.Errorf("Failed to unmarshal proto", err)
+ return fmt.Errorf("Failed to unmarshal proto: %w", err)
}
startTime := *m.metrics.Total.StartTime
endTime := uint64(time.Now().UnixNano())
diff --git a/ui/status/ninja.go b/ui/status/ninja.go
index fc0e21a..fb760ac 100644
--- a/ui/status/ninja.go
+++ b/ui/status/ninja.go
@@ -174,6 +174,7 @@
IOOutputKB: msg.EdgeFinished.GetIoOutputKb(),
VoluntaryContextSwitches: msg.EdgeFinished.GetVoluntaryContextSwitches(),
InvoluntaryContextSwitches: msg.EdgeFinished.GetInvoluntaryContextSwitches(),
+ Tags: msg.EdgeFinished.GetTags(),
},
})
}
diff --git a/ui/status/ninja_frontend/frontend.pb.go b/ui/status/ninja_frontend/frontend.pb.go
index bcadc67..d0c4953 100644
--- a/ui/status/ninja_frontend/frontend.pb.go
+++ b/ui/status/ninja_frontend/frontend.pb.go
@@ -14,8 +14,8 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
-// protoc-gen-go v1.26.0
-// protoc v3.9.1
+// protoc-gen-go v1.28.1
+// protoc v3.21.12
// source: frontend.proto
package ninja_frontend
@@ -459,6 +459,9 @@
VoluntaryContextSwitches *uint64 `protobuf:"varint,12,opt,name=voluntary_context_switches,json=voluntaryContextSwitches" json:"voluntary_context_switches,omitempty"`
// Involuntary context switches
InvoluntaryContextSwitches *uint64 `protobuf:"varint,13,opt,name=involuntary_context_switches,json=involuntaryContextSwitches" json:"involuntary_context_switches,omitempty"`
+ // Arbitrary tags for build system profiling (module names and types, rule
+ // names, etc). Format of the string is implementation defined.
+ Tags *string `protobuf:"bytes,14,opt,name=tags" json:"tags,omitempty"`
}
func (x *Status_EdgeFinished) Reset() {
@@ -584,6 +587,13 @@
return 0
}
+func (x *Status_EdgeFinished) GetTags() string {
+ if x != nil && x.Tags != nil {
+ return *x.Tags
+ }
+ return ""
+}
+
type Status_Message struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
@@ -650,7 +660,7 @@
var file_frontend_proto_rawDesc = []byte{
0x0a, 0x0e, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x12, 0x05, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x22, 0xb4, 0x0a, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74,
+ 0x12, 0x05, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x22, 0xc8, 0x0a, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74,
0x75, 0x73, 0x12, 0x39, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x65, 0x64, 0x67, 0x65,
0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x2e,
0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x45, 0x64, 0x67, 0x65,
@@ -694,7 +704,7 @@
0x65, 0x73, 0x63, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x06,
0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x18, 0x0a,
0x07, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07,
- 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x1a, 0xdf, 0x03, 0x0a, 0x0c, 0x45, 0x64, 0x67, 0x65,
+ 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x1a, 0xf3, 0x03, 0x0a, 0x0c, 0x45, 0x64, 0x67, 0x65,
0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f,
0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54,
@@ -724,19 +734,20 @@
0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x73,
0x77, 0x69, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1a, 0x69,
0x6e, 0x76, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
- 0x74, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x65, 0x73, 0x1a, 0x92, 0x01, 0x0a, 0x07, 0x4d, 0x65,
- 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x01,
- 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x2e, 0x53, 0x74, 0x61,
- 0x74, 0x75, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4c, 0x65, 0x76, 0x65,
- 0x6c, 0x3a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x18,
- 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x34, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65,
- 0x6c, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x57,
- 0x41, 0x52, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x52, 0x52, 0x4f,
- 0x52, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x45, 0x42, 0x55, 0x47, 0x10, 0x03, 0x42, 0x2a,
- 0x48, 0x03, 0x5a, 0x26, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f, 0x73, 0x6f, 0x6f, 0x6e,
- 0x67, 0x2f, 0x75, 0x69, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f, 0x6e, 0x69, 0x6e, 0x6a,
- 0x61, 0x5f, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64,
+ 0x74, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67,
+ 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x1a, 0x92, 0x01,
+ 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x05, 0x6c, 0x65, 0x76,
+ 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6e, 0x69, 0x6e, 0x6a, 0x61,
+ 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e,
+ 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x52, 0x05, 0x6c, 0x65, 0x76,
+ 0x65, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x34, 0x0a, 0x05,
+ 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x10, 0x00, 0x12,
+ 0x0b, 0x0a, 0x07, 0x57, 0x41, 0x52, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05,
+ 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x45, 0x42, 0x55, 0x47,
+ 0x10, 0x03, 0x42, 0x2a, 0x48, 0x03, 0x5a, 0x26, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f,
+ 0x73, 0x6f, 0x6f, 0x6e, 0x67, 0x2f, 0x75, 0x69, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f,
+ 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x5f, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64,
}
var (
diff --git a/ui/status/ninja_frontend/frontend.proto b/ui/status/ninja_frontend/frontend.proto
index 5730388..6cb4a0d 100644
--- a/ui/status/ninja_frontend/frontend.proto
+++ b/ui/status/ninja_frontend/frontend.proto
@@ -79,6 +79,9 @@
optional uint64 voluntary_context_switches = 12;
// Involuntary context switches
optional uint64 involuntary_context_switches = 13;
+ // Arbitrary tags for build system profiling (module names and types, rule
+ // names, etc). Format of the string is implementation defined.
+ optional string tags = 14;
}
message Message {
diff --git a/ui/status/status.go b/ui/status/status.go
index a5b4a28..f3e58b6 100644
--- a/ui/status/status.go
+++ b/ui/status/status.go
@@ -85,6 +85,8 @@
// Involuntary context switches
InvoluntaryContextSwitches uint64
+
+ Tags string
}
// Counts describes the number of actions in each state
diff --git a/ui/tracer/status.go b/ui/tracer/status.go
index a8b4e62..f973613 100644
--- a/ui/tracer/status.go
+++ b/ui/tracer/status.go
@@ -16,6 +16,7 @@
import (
"android/soong/ui/status"
+ "strings"
"time"
)
@@ -60,6 +61,24 @@
}
}
+func (s *statusOutput) parseTags(rawTags string) map[string]string {
+ if rawTags == "" {
+ return nil
+ }
+
+ tags := map[string]string{}
+ for _, pair := range strings.Split(rawTags, ";") {
+ if pair == "" {
+ // Ignore empty tag pairs. It's hard to generate these cleanly from
+ // make so some tag strings might be something like ";key=value".
+ continue
+ }
+ parts := strings.SplitN(pair, "=", 2)
+ tags[parts[0]] = parts[1]
+ }
+ return tags
+}
+
func (s *statusOutput) FinishAction(result status.ActionResult, counts status.Counts) {
start, ok := s.running[result.Action]
if !ok {
@@ -90,20 +109,22 @@
IOOutputKB: result.Stats.IOOutputKB,
VoluntaryContextSwitches: result.Stats.VoluntaryContextSwitches,
InvoluntaryContextSwitches: result.Stats.InvoluntaryContextSwitches,
+ Tags: s.parseTags(result.Stats.Tags),
},
})
}
type statsArg struct {
- UserTime uint32 `json:"user_time"`
- SystemTime uint32 `json:"system_time_ms"`
- MaxRssKB uint64 `json:"max_rss_kb"`
- MinorPageFaults uint64 `json:"minor_page_faults"`
- MajorPageFaults uint64 `json:"major_page_faults"`
- IOInputKB uint64 `json:"io_input_kb"`
- IOOutputKB uint64 `json:"io_output_kb"`
- VoluntaryContextSwitches uint64 `json:"voluntary_context_switches"`
- InvoluntaryContextSwitches uint64 `json:"involuntary_context_switches"`
+ UserTime uint32 `json:"user_time"`
+ SystemTime uint32 `json:"system_time_ms"`
+ MaxRssKB uint64 `json:"max_rss_kb"`
+ MinorPageFaults uint64 `json:"minor_page_faults"`
+ MajorPageFaults uint64 `json:"major_page_faults"`
+ IOInputKB uint64 `json:"io_input_kb"`
+ IOOutputKB uint64 `json:"io_output_kb"`
+ VoluntaryContextSwitches uint64 `json:"voluntary_context_switches"`
+ InvoluntaryContextSwitches uint64 `json:"involuntary_context_switches"`
+ Tags map[string]string `json:"tags"`
}
func (s *statusOutput) Flush() {}