Snap for 8426163 from e59efdaf6be220d41a4092c4e87dc273a6e10776 to mainline-tzdata2-release
Change-Id: I87a3dadf645e1f326d82c3f101a9ef69022d6122
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
deleted file mode 100644
index deb261d..0000000
--- a/.github/workflows/build.yml
+++ /dev/null
@@ -1,47 +0,0 @@
-name: build
-
-on:
- push:
- branches: [ master ]
- pull_request:
- branches: [ master ]
-
-jobs:
-
- build:
- runs-on: ubuntu-latest
- strategy:
- matrix:
- go: [ '1.14', '1.13' ]
- name: Build and test on go ${{ matrix.go }}
- steps:
-
- - name: Set up Go ${{ matrix.go }}
- uses: actions/setup-go@v2
- with:
- go-version: ${{ matrix.go }}
- id: go
-
- - name: Check out code
- uses: actions/checkout@v2
-
- - name: Install ninja
- run: |
- mkdir -p ${GITHUB_WORKSPACE}/ninja-bin; cd ${GITHUB_WORKSPACE}/ninja-bin
- wget https://github.com/ninja-build/ninja/releases/download/v1.7.2/ninja-linux.zip
- unzip ninja-linux.zip
- rm ninja-linux.zip
- echo "${GITHUB_WORKSPACE}/ninja-bin" >> $GITHUB_PATH
-
- - name: Run gofmt
- run: ./.gofmt.sh
-
- - name: Test
- run: go test ./...
-
- - name: Test with race detector
- run: go test -race -short ./...
-
- - run: ./tests/test.sh
- - run: ./tests/test_tree_tests.sh
- - run: ./tests/test_tree_tests.sh -t
diff --git a/.travis.fix-fork.sh b/.travis.fix-fork.sh
new file mode 100755
index 0000000..af26716
--- /dev/null
+++ b/.travis.fix-fork.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+if echo $TRAVIS_BUILD_DIR | grep -vq "github.com/google/blueprint$" ; then
+ cd ../..
+ mkdir -p google
+ mv $TRAVIS_BUILD_DIR google/blueprint
+ cd google/blueprint
+ export TRAVIS_BUILD_DIR=$PWD
+fi
diff --git a/.gofmt.sh b/.travis.gofmt.sh
similarity index 100%
rename from .gofmt.sh
rename to .travis.gofmt.sh
diff --git a/.travis.install-ninja.sh b/.travis.install-ninja.sh
new file mode 100755
index 0000000..5309945
--- /dev/null
+++ b/.travis.install-ninja.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# Version of ninja to build -- can be any git revision
+VERSION="v1.7.1"
+
+set -ev
+
+SCRIPT_HASH=$(sha1sum ${BASH_SOURCE[0]} | awk '{print $1}')
+
+cd ~
+if [[ -d ninjabin && "$SCRIPT_HASH" == "$(cat ninjabin/script_hash)" ]]; then
+ exit 0
+fi
+
+git clone https://github.com/martine/ninja
+cd ninja
+./configure.py --bootstrap
+
+mkdir -p ../ninjabin
+rm -f ../ninjabin/ninja
+echo -n $SCRIPT_HASH >../ninjabin/script_hash
+mv ninja ../ninjabin/
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..706e469
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,27 @@
+language: go
+
+go:
+ - "1.10"
+ - "1.11"
+ - "1.12"
+ - "1.13"
+
+cache:
+ directories:
+ - $HOME/ninjabin
+
+install:
+ - ./.travis.install-ninja.sh
+ - export PATH=$PATH:~/ninjabin
+
+before_script:
+ - source .travis.fix-fork.sh
+
+script:
+ - export GOROOT=$(go env GOROOT)
+ - ./.travis.gofmt.sh
+ - go test ./...
+ - go test -race -short ./...
+ - ./tests/test.sh
+ - ./tests/test_tree_tests.sh
+ - ./tests/test_tree_tests.sh -t
diff --git a/Blueprints b/Blueprints
index ab9fd3c..ecc0792 100644
--- a/Blueprints
+++ b/Blueprints
@@ -17,7 +17,6 @@
"ninja_strings.go",
"ninja_writer.go",
"package_ctx.go",
- "provider.go",
"scope.go",
"singleton_ctx.go",
],
@@ -27,7 +26,6 @@
"module_ctx_test.go",
"ninja_strings_test.go",
"ninja_writer_test.go",
- "provider_test.go",
"splice_modules_test.go",
"visit_test.go",
],
@@ -47,7 +45,6 @@
"parser/modify_test.go",
"parser/parser_test.go",
"parser/printer_test.go",
- "parser/sort_test.go",
],
}
@@ -71,7 +68,6 @@
testSrcs: [
"pathtools/fs_test.go",
"pathtools/glob_test.go",
- "pathtools/lists_test.go",
],
}
diff --git a/CODEOWNERS b/CODEOWNERS
deleted file mode 100644
index 8cf6944..0000000
--- a/CODEOWNERS
+++ /dev/null
@@ -1 +0,0 @@
-* @google/blueprint
diff --git a/OWNERS b/OWNERS
index 1ee860c..5dca797 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1,2 +1,4 @@
-include platform/build/soong:/OWNERS
-
+asmundak@google.com
+ccross@android.com
+dwillemsen@google.com
+jungjw@google.com
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
deleted file mode 100644
index 317f5c4..0000000
--- a/PREUPLOAD.cfg
+++ /dev/null
@@ -1,6 +0,0 @@
-[Builtin Hooks]
-gofmt = true
-bpfmt = true
-
-[Hook Scripts]
-do_not_use_DO_NOT_MERGE = ${REPO_ROOT}/build/soong/scripts/check_do_not_merge.sh ${PREUPLOAD_COMMIT}
diff --git a/README.md b/README.md
index 961bc64..5370c05 100644
--- a/README.md
+++ b/README.md
@@ -1,25 +1,14 @@
Blueprint Build System
======================
+[](https://travis-ci.org/google/blueprint)
-Blueprint is being archived on 2021 May 3.
-
-On 2021 May 3, we will be archiving the Blueprint project. This means it will
-not be possible to file new issues or open new pull requests for this GitHub
-project. As the project is being archived, patches -- including security
-patches -- will not be applied after May 3. The source tree will remain
-available, but changes to Blueprint in AOSP will not be merged here and
-Blueprint's source tree in AOSP will eventually stop being usable outside of
-Android.
-
-Whereas there are no meta-build systems one can use as a drop-in replacement for
-Blueprint, there are a number of build systems that can be used:
-
-* [Bazel](https://bazel.build), Google's multi-language build tool to build and
- test software of any size, quickly and reliably
-* [Soong](https://source.android.com/setup/build), for building the Android
- operating system itself
-* [CMake](https://cmake.org), an open-source, cross-platform family of tools
- designed to build, test and package software
-* [Buck](https://buck.build), a fast build system that encourages the creation
- of small, reusable modules over a variety of platforms and languages
-* The venerable [GNU Make](https://www.gnu.org/software/make/)
+Blueprint is a meta-build system that reads in Blueprints files that describe
+modules that need to be built, and produces a
+[Ninja](https://ninja-build.org/) manifest describing the commands that
+need to be run and their dependencies. Where most build systems use built-in
+rules or a domain-specific language to describe the logic for converting module
+descriptions to build rules, Blueprint delegates this to per-project build
+logic written in Go. For large, heterogenous projects this allows the inherent
+complexity of the build logic to be maintained in a high-level language, while
+still allowing simple changes to individual modules by modifying easy to
+understand Blueprints files.
diff --git a/bootstrap.bash b/bootstrap.bash
index b08bf1e..08b85b5 100755
--- a/bootstrap.bash
+++ b/bootstrap.bash
@@ -67,14 +67,12 @@
echo " -h: print a help message and exit"
echo " -b <builddir>: set the build directory"
echo " -t: run tests"
- echo " -n: use validations to depend on tests"
}
# Parse the command line flags.
-while getopts ":b:hnt" opt; do
+while getopts ":b:ht" opt; do
case $opt in
b) BUILDDIR="$OPTARG";;
- n) USE_VALIDATIONS=true;;
t) RUN_TESTS=true;;
h)
usage
@@ -95,9 +93,6 @@
# If RUN_TESTS is set, behave like -t was passed in as an option.
[ ! -z "$RUN_TESTS" ] && EXTRA_ARGS="${EXTRA_ARGS} -t"
-# If $USE_VALIDATIONS is set, pass --use-validations.
-[ ! -z "$USE_VALIDATIONS" ] && EXTRA_ARGS="${EXTRA_ARGS} --use-validations"
-
# If EMPTY_NINJA_FILE is set, have the primary build write out a 0-byte ninja
# file instead of a full length one. Useful if you don't plan on executing the
# build, but want to verify the primary builder execution.
diff --git a/bootstrap/bootstrap.go b/bootstrap/bootstrap.go
index d5befd9..79e5c8e 100644
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -17,6 +17,8 @@
import (
"fmt"
"go/build"
+ "io/ioutil"
+ "os"
"path/filepath"
"runtime"
"strings"
@@ -57,7 +59,7 @@
compile = pctx.StaticRule("compile",
blueprint.RuleParams{
Command: "GOROOT='$goRoot' $compileCmd $parallelCompile -o $out.tmp " +
- "$debugFlags -p $pkgPath -complete $incFlags -pack $in && " +
+ "-p $pkgPath -complete $incFlags -pack $in && " +
"if cmp --quiet $out.tmp $out; then rm $out.tmp; else mv -f $out.tmp $out; fi",
CommandDeps: []string{"$compileCmd"},
Description: "compile $out",
@@ -123,27 +125,14 @@
generateBuildNinja = pctx.StaticRule("build.ninja",
blueprint.RuleParams{
- // TODO: it's kinda ugly that some parameters are computed from
- // environment variables and some from Ninja parameters, but it's probably
- // better to not to touch that while Blueprint and Soong are separate
- // NOTE: The spaces at EOL are important because otherwise Ninja would
- // omit all spaces between the different options.
- Command: `cd "$$(dirname "$builder")" && ` +
- `BUILDER="$$PWD/$$(basename "$builder")" && ` +
- `cd / && ` +
- `env -i "$$BUILDER" ` +
- ` --top "$$TOP" ` +
- ` --out "$buildDir" ` +
- ` -n "$ninjaBuildDir" ` +
- ` -d "$out.d" ` +
- ` $extra`,
+ Command: "$builder $extra -b $buildDir -n $ninjaBuildDir -d $out.d -globFile $globFile -o $out $in",
CommandDeps: []string{"$builder"},
Description: "$builder $out",
Deps: blueprint.DepsGCC,
Depfile: "$out.d",
Restat: true,
},
- "builder", "extra")
+ "builder", "extra", "generator", "globFile")
// Work around a Ninja issue. See https://github.com/martine/ninja/pull/634
phony = pctx.StaticRule("phony",
@@ -155,7 +144,7 @@
"depfile")
_ = pctx.VariableFunc("BinDir", func(config interface{}) (string, error) {
- return bootstrapBinDir(config), nil
+ return bootstrapBinDir(), nil
})
_ = pctx.VariableFunc("ToolDir", func(config interface{}) (string, error) {
@@ -178,23 +167,21 @@
isGoBinary()
}
-func bootstrapBinDir(config interface{}) string {
- return filepath.Join(config.(BootstrapConfig).BuildDir(), bootstrapSubDir, "bin")
+func bootstrapBinDir() string {
+ return filepath.Join(BuildDir, bootstrapSubDir, "bin")
}
func toolDir(config interface{}) string {
if c, ok := config.(ConfigBlueprintToolLocation); ok {
return filepath.Join(c.BlueprintToolLocation())
}
- return filepath.Join(config.(BootstrapConfig).BuildDir(), "bin")
+ return filepath.Join(BuildDir, "bin")
}
func pluginDeps(ctx blueprint.BottomUpMutatorContext) {
if pkg, ok := ctx.Module().(*goPackage); ok {
- if ctx.PrimaryModule() == ctx.Module() {
- for _, plugin := range pkg.properties.PluginFor {
- ctx.AddReverseDependency(ctx.Module(), nil, plugin)
- }
+ for _, plugin := range pkg.properties.PluginFor {
+ ctx.AddReverseDependency(ctx.Module(), nil, plugin)
}
}
}
@@ -224,7 +211,7 @@
}
}
-func IsBootstrapModule(module blueprint.Module) bool {
+func isBootstrapModule(module blueprint.Module) bool {
_, isPackage := module.(*goPackage)
_, isBinary := module.(*goBinary)
return isPackage || isBinary
@@ -281,9 +268,6 @@
}
func (g *goPackage) DynamicDependencies(ctx blueprint.DynamicDependerModuleContext) []string {
- if ctx.Module() != ctx.PrimaryModule() {
- return nil
- }
return g.properties.Deps
}
@@ -313,16 +297,6 @@
}
func (g *goPackage) GenerateBuildActions(ctx blueprint.ModuleContext) {
- // Allow the primary builder to create multiple variants. Any variants after the first
- // will copy outputs from the first.
- if ctx.Module() != ctx.PrimaryModule() {
- primary := ctx.PrimaryModule().(*goPackage)
- g.pkgRoot = primary.pkgRoot
- g.archiveFile = primary.archiveFile
- g.testResultFile = primary.testResultFile
- return
- }
-
var (
name = ctx.ModuleName()
hasPlugins = false
@@ -359,13 +333,11 @@
testSrcs = append(g.properties.TestSrcs, g.properties.Linux.TestSrcs...)
}
- if g.config.runGoTests {
- testArchiveFile := filepath.Join(testRoot(ctx, g.config),
- filepath.FromSlash(g.properties.PkgPath)+".a")
- g.testResultFile = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
- g.properties.PkgPath, srcs, genSrcs,
- testSrcs, g.config.useValidations)
- }
+ testArchiveFile := filepath.Join(testRoot(ctx, g.config),
+ filepath.FromSlash(g.properties.PkgPath)+".a")
+ g.testResultFile = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
+ g.properties.PkgPath, srcs, genSrcs,
+ testSrcs)
buildGoPackage(ctx, g.pkgRoot, g.properties.PkgPath, g.archiveFile,
srcs, genSrcs)
@@ -412,9 +384,6 @@
}
func (g *goBinary) DynamicDependencies(ctx blueprint.DynamicDependerModuleContext) []string {
- if ctx.Module() != ctx.PrimaryModule() {
- return nil
- }
return g.properties.Deps
}
@@ -424,14 +393,6 @@
}
func (g *goBinary) GenerateBuildActions(ctx blueprint.ModuleContext) {
- // Allow the primary builder to create multiple variants. Any variants after the first
- // will copy outputs from the first.
- if ctx.Module() != ctx.PrimaryModule() {
- primary := ctx.PrimaryModule().(*goBinary)
- g.installPath = primary.installPath
- return
- }
-
var (
name = ctx.ModuleName()
objDir = moduleObjDir(ctx, g.config)
@@ -445,8 +406,10 @@
if g.properties.Tool_dir {
g.installPath = filepath.Join(toolDir(ctx.Config()), name)
+ } else if g.config.stage == StageMain {
+ g.installPath = filepath.Join(mainDir, "bin", name)
} else {
- g.installPath = filepath.Join(stageDir(g.config), "bin", name)
+ g.installPath = filepath.Join(bootstrapDir, "bin", name)
}
ctx.VisitDepsDepthFirstIf(isGoPluginFor(name),
@@ -456,7 +419,7 @@
genSrcs = append(genSrcs, pluginSrc)
}
- var testDeps []string
+ var deps []string
if hasPlugins && !buildGoPluginLoader(ctx, "main", pluginSrc) {
return
@@ -471,9 +434,10 @@
testSrcs = append(g.properties.TestSrcs, g.properties.Linux.TestSrcs...)
}
+ testDeps := buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
+ name, srcs, genSrcs, testSrcs)
if g.config.runGoTests {
- testDeps = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
- name, srcs, genSrcs, testSrcs, g.config.useValidations)
+ deps = append(deps, testDeps...)
}
buildGoPackage(ctx, objDir, "main", archiveFile, srcs, genSrcs)
@@ -486,7 +450,9 @@
linkDeps = append(linkDeps, dep.GoPackageTarget())
libDir := dep.GoPkgRoot()
libDirFlags = append(libDirFlags, "-L "+libDir)
- testDeps = append(testDeps, dep.GoTestTargets()...)
+ if g.config.runGoTests {
+ deps = append(deps, dep.GoTestTargets()...)
+ }
})
linkArgs := map[string]string{}
@@ -503,20 +469,12 @@
Optional: true,
})
- var orderOnlyDeps, validationDeps []string
- if g.config.useValidations {
- validationDeps = testDeps
- } else {
- orderOnlyDeps = testDeps
- }
-
ctx.Build(pctx, blueprint.BuildParams{
- Rule: cp,
- Outputs: []string{g.installPath},
- Inputs: []string{aoutFile},
- OrderOnly: orderOnlyDeps,
- Validations: validationDeps,
- Optional: !g.properties.Default,
+ Rule: cp,
+ Outputs: []string{g.installPath},
+ Inputs: []string{aoutFile},
+ OrderOnly: deps,
+ Optional: !g.properties.Default,
})
}
@@ -581,7 +539,7 @@
}
func buildGoTest(ctx blueprint.ModuleContext, testRoot, testPkgArchive,
- pkgPath string, srcs, genSrcs, testSrcs []string, useValidations bool) []string {
+ pkgPath string, srcs, genSrcs, testSrcs []string) []string {
if len(testSrcs) == 0 {
return nil
@@ -643,19 +601,11 @@
Optional: true,
})
- var orderOnlyDeps, validationDeps []string
- if useValidations {
- validationDeps = testDeps
- } else {
- orderOnlyDeps = testDeps
- }
-
ctx.Build(pctx, blueprint.BuildParams{
- Rule: test,
- Outputs: []string{testPassed},
- Inputs: []string{testFile},
- OrderOnly: orderOnlyDeps,
- Validations: validationDeps,
+ Rule: test,
+ Outputs: []string{testPassed},
+ Inputs: []string{testFile},
+ OrderOnly: testDeps,
Args: map[string]string{
"pkg": pkgPath,
"pkgSrcDir": filepath.Dir(testFiles[0]),
@@ -686,62 +636,89 @@
var primaryBuilders []*goBinary
// blueprintTools contains blueprint go binaries that will be built in StageMain
var blueprintTools []string
- ctx.VisitAllModulesIf(isBootstrapBinaryModule,
- func(module blueprint.Module) {
- if ctx.PrimaryModule(module) == module {
- binaryModule := module.(*goBinary)
-
- if binaryModule.properties.Tool_dir {
- blueprintTools = append(blueprintTools, binaryModule.InstallPath())
- }
- if binaryModule.properties.PrimaryBuilder {
- primaryBuilders = append(primaryBuilders, binaryModule)
- }
+ // blueprintTests contains the result files from the tests
+ var blueprintTests []string
+ ctx.VisitAllModules(func(module blueprint.Module) {
+ if binaryModule, ok := module.(*goBinary); ok {
+ if binaryModule.properties.Tool_dir {
+ blueprintTools = append(blueprintTools, binaryModule.InstallPath())
}
- })
+ if binaryModule.properties.PrimaryBuilder {
+ primaryBuilders = append(primaryBuilders, binaryModule)
+ }
+ }
- var primaryBuilderCmdlinePrefix []string
- var primaryBuilderName string
+ if packageModule, ok := module.(goPackageProducer); ok {
+ blueprintTests = append(blueprintTests, packageModule.GoTestTargets()...)
+ }
+ })
- if len(primaryBuilders) == 0 {
+ var extraSharedFlagArray []string
+ if s.config.runGoTests {
+ extraSharedFlagArray = append(extraSharedFlagArray, "-t")
+ }
+ if s.config.moduleListFile != "" {
+ extraSharedFlagArray = append(extraSharedFlagArray, "-l", s.config.moduleListFile)
+ }
+ if s.config.emptyNinjaFile {
+ extraSharedFlagArray = append(extraSharedFlagArray, "--empty-ninja-file")
+ }
+ extraSharedFlagString := strings.Join(extraSharedFlagArray, " ")
+
+ var primaryBuilderName, primaryBuilderExtraFlags string
+ switch len(primaryBuilders) {
+ case 0:
// If there's no primary builder module then that means we'll use minibp
// as the primary builder. We can trigger its primary builder mode with
// the -p flag.
primaryBuilderName = "minibp"
- primaryBuilderCmdlinePrefix = append(primaryBuilderCmdlinePrefix, "-p")
- } else if len(primaryBuilders) > 1 {
+ primaryBuilderExtraFlags = "-p " + extraSharedFlagString
+
+ case 1:
+ primaryBuilderName = ctx.ModuleName(primaryBuilders[0])
+ primaryBuilderExtraFlags = extraSharedFlagString
+
+ default:
ctx.Errorf("multiple primary builder modules present:")
for _, primaryBuilder := range primaryBuilders {
ctx.ModuleErrorf(primaryBuilder, "<-- module %s",
ctx.ModuleName(primaryBuilder))
}
return
- } else {
- primaryBuilderName = ctx.ModuleName(primaryBuilders[0])
}
primaryBuilderFile := filepath.Join("$BinDir", primaryBuilderName)
+
+ // Get the filename of the top-level Blueprints file to pass to minibp.
+ topLevelBlueprints := filepath.Join("$srcDir",
+ filepath.Base(s.config.topLevelBlueprintsFile))
+
ctx.SetNinjaBuildDir(pctx, "${ninjaBuildDir}")
if s.config.stage == StagePrimary {
- ctx.AddSubninja(s.config.globFile)
+ mainNinjaFile := filepath.Join("$buildDir", "build.ninja")
+ primaryBuilderNinjaGlobFile := absolutePath(filepath.Join(BuildDir, bootstrapSubDir, "build-globs.ninja"))
- for _, i := range s.config.primaryBuilderInvocations {
- flags := make([]string, 0)
- flags = append(flags, primaryBuilderCmdlinePrefix...)
- flags = append(flags, i.Args...)
-
- // Build the main build.ninja
- ctx.Build(pctx, blueprint.BuildParams{
- Rule: generateBuildNinja,
- Outputs: i.Outputs,
- Inputs: i.Inputs,
- Args: map[string]string{
- "builder": primaryBuilderFile,
- "extra": strings.Join(flags, " "),
- },
- })
+ if _, err := os.Stat(primaryBuilderNinjaGlobFile); os.IsNotExist(err) {
+ err = ioutil.WriteFile(primaryBuilderNinjaGlobFile, nil, 0666)
+ if err != nil {
+ ctx.Errorf("Failed to create empty ninja file: %s", err)
+ }
}
+
+ ctx.AddSubninja(primaryBuilderNinjaGlobFile)
+
+ // Build the main build.ninja
+ ctx.Build(pctx, blueprint.BuildParams{
+ Rule: generateBuildNinja,
+ Outputs: []string{mainNinjaFile},
+ Inputs: []string{topLevelBlueprints},
+ Args: map[string]string{
+ "builder": primaryBuilderFile,
+ "extra": primaryBuilderExtraFlags,
+ "globFile": primaryBuilderNinjaGlobFile,
+ },
+ })
}
if s.config.stage == StageMain {
@@ -764,8 +741,8 @@
docsFile := filepath.Join(docsDir, primaryBuilderName+".html")
bigbpDocs := ctx.Rule(pctx, "bigbpDocs",
blueprint.RuleParams{
- Command: fmt.Sprintf("%s -b $buildDir --docs $out %s", primaryBuilderFile,
- s.config.topLevelBlueprintsFile),
+ Command: fmt.Sprintf("%s %s -b $buildDir --docs $out %s", primaryBuilderFile,
+ primaryBuilderExtraFlags, topLevelBlueprints),
CommandDeps: []string{primaryBuilderFile},
Description: fmt.Sprintf("%s docs $out", primaryBuilderName),
})
@@ -788,6 +765,14 @@
Outputs: []string{"blueprint_tools"},
Inputs: blueprintTools,
})
+
+ // Add a phony target for running all of the tests
+ ctx.Build(pctx, blueprint.BuildParams{
+ Rule: blueprint.Phony,
+ Outputs: []string{"blueprint_tests"},
+ Inputs: blueprintTests,
+ })
+
}
}
diff --git a/bootstrap/bpdoc/bpdoc.go b/bootstrap/bpdoc/bpdoc.go
index 8ed02c2..4abf2e7 100644
--- a/bootstrap/bpdoc/bpdoc.go
+++ b/bootstrap/bpdoc/bpdoc.go
@@ -5,7 +5,6 @@
"html/template"
"reflect"
"sort"
- "strings"
"github.com/google/blueprint/proptools"
)
@@ -59,7 +58,6 @@
OtherTexts []template.HTML
Properties []Property
Default string
- Anonymous bool
}
func AllPackages(pkgFiles map[string][]string, moduleTypeNameFactories map[string]reflect.Value,
@@ -77,7 +75,6 @@
return nil, err
}
// Some pruning work
- removeAnonymousProperties(mtInfo)
removeEmptyPropertyStructs(mtInfo)
collapseDuplicatePropertyStructs(mtInfo)
collapseNestedPropertyStructs(mtInfo)
@@ -131,9 +128,7 @@
}
ps.ExcludeByTag("blueprint", "mutated")
- for _, nestedProperty := range nestedPropertyStructs(v) {
- nestedName := nestedProperty.nestPoint
- nestedValue := nestedProperty.value
+ for nestedName, nestedValue := range nestedPropertyStructs(v) {
nestedType := nestedValue.Type()
// Ignore property structs with unexported or unnamed types
@@ -145,28 +140,12 @@
return nil, err
}
nested.ExcludeByTag("blueprint", "mutated")
- if nestedName == "" {
- ps.Nest(nested)
- } else {
- nestPoint := ps.GetByName(nestedName)
- if nestPoint == nil {
- return nil, fmt.Errorf("nesting point %q not found", nestedName)
- }
- nestPoint.Nest(nested)
+ nestPoint := ps.GetByName(nestedName)
+ if nestPoint == nil {
+ return nil, fmt.Errorf("nesting point %q not found", nestedName)
}
- if nestedProperty.anonymous {
- if nestedName != "" {
- nestedName += "."
- }
- nestedName += proptools.PropertyNameForField(nested.Name)
- nestedProp := ps.GetByName(nestedName)
- // Anonymous properties may have already been omitted, no need to ensure they are filtered later
- if nestedProp != nil {
- // Set property to anonymous to allow future filtering
- nestedProp.SetAnonymous()
- }
- }
+ nestPoint.Nest(nested)
}
mt.PropertyStructs = append(mt.PropertyStructs, ps)
}
@@ -174,31 +153,10 @@
return mt, nil
}
-type nestedProperty struct {
- nestPoint string
- value reflect.Value
- anonymous bool
-}
-
-func nestedPropertyStructs(s reflect.Value) []nestedProperty {
- ret := make([]nestedProperty, 0)
+func nestedPropertyStructs(s reflect.Value) map[string]reflect.Value {
+ ret := make(map[string]reflect.Value)
var walk func(structValue reflect.Value, prefix string)
walk = func(structValue reflect.Value, prefix string) {
- var nestStruct func(field reflect.StructField, value reflect.Value, fieldName string)
- nestStruct = func(field reflect.StructField, value reflect.Value, fieldName string) {
- nestPoint := prefix
- if field.Anonymous {
- nestPoint = strings.TrimSuffix(nestPoint, ".")
- } else {
- nestPoint = nestPoint + proptools.PropertyNameForField(fieldName)
- }
- ret = append(ret, nestedProperty{nestPoint: nestPoint, value: value, anonymous: field.Anonymous})
- if nestPoint != "" {
- nestPoint += "."
- }
- walk(value, nestPoint)
- }
-
typ := structValue.Type()
for i := 0; i < structValue.NumField(); i++ {
field := typ.Field(i)
@@ -216,9 +174,8 @@
case reflect.Bool, reflect.String, reflect.Slice, reflect.Int, reflect.Uint:
// Nothing
case reflect.Struct:
- nestStruct(field, fieldValue, field.Name)
+ walk(fieldValue, prefix+proptools.PropertyNameForField(field.Name)+".")
case reflect.Ptr, reflect.Interface:
-
if !fieldValue.IsNil() {
// We leave the pointer intact and zero out the struct that's
// pointed to.
@@ -231,7 +188,9 @@
elem = elem.Elem()
}
if elem.Kind() == reflect.Struct {
- nestStruct(field, elem, field.Name)
+ nestPoint := prefix + proptools.PropertyNameForField(field.Name)
+ ret[nestPoint] = elem
+ walk(elem, nestPoint+".")
}
}
default:
@@ -255,27 +214,6 @@
}
}
-// Remove any property structs that are anonymous
-func removeAnonymousProperties(mt *ModuleType) {
- var removeAnonymousProps func(props []Property) []Property
- removeAnonymousProps = func(props []Property) []Property {
- newProps := make([]Property, 0, len(props))
- for _, p := range props {
- if p.Anonymous {
- continue
- }
- if len(p.Properties) > 0 {
- p.Properties = removeAnonymousProps(p.Properties)
- }
- newProps = append(newProps, p)
- }
- return newProps
- }
- for _, ps := range mt.PropertyStructs {
- ps.Properties = removeAnonymousProps(ps.Properties)
- }
-}
-
// Squashes duplicates of the same property struct into single entries
func collapseDuplicatePropertyStructs(mt *ModuleType) {
var collapsed []*PropertyStruct
diff --git a/bootstrap/bpdoc/bpdoc_test.go b/bootstrap/bpdoc/bpdoc_test.go
index 67ad783..687d97b 100644
--- a/bootstrap/bpdoc/bpdoc_test.go
+++ b/bootstrap/bpdoc/bpdoc_test.go
@@ -1,16 +1,10 @@
package bpdoc
import (
- "fmt"
"reflect"
"testing"
)
-type propInfo struct {
- name string
- typ string
-}
-
type parentProps struct {
A string
@@ -41,133 +35,12 @@
// mutated shouldn't be found because it's a mutated property.
expected := []string{"child", "child.child"}
if len(allStructs) != len(expected) {
- t.Fatalf("expected %d structs, got %d, all entries: %v",
+ t.Errorf("expected %d structs, got %d, all entries: %q",
len(expected), len(allStructs), allStructs)
}
- got := []string{}
- for _, s := range allStructs {
- got = append(got, s.nestPoint)
- }
-
- if !reflect.DeepEqual(got, expected) {
- t.Errorf("Expected nested properties:\n\t %q,\n but got\n\t %q", expected, got)
- }
-}
-
-func TestAllPackages(t *testing.T) {
- packages, err := AllPackages(pkgFiles, moduleTypeNameFactories, moduleTypeNamePropertyStructs)
- if err != nil {
- t.Fatalf("expected nil error for AllPackages(%v, %v, %v), got %s", pkgFiles, moduleTypeNameFactories, moduleTypeNamePropertyStructs, err)
- }
-
- if numPackages := len(packages); numPackages != 1 {
- t.Errorf("Expected %d package, got %d packages %v instead", len(pkgFiles), numPackages, packages)
- }
-
- pkg := packages[0]
-
- expectedProps := map[string][]propInfo{
- "bar": []propInfo{
- propInfo{
- name: "a",
- typ: "string",
- },
- propInfo{
- name: "nested",
- typ: "",
- },
- propInfo{
- name: "nested.c",
- typ: "string",
- },
- propInfo{
- name: "nested_struct",
- typ: "structToNest",
- },
- propInfo{
- name: "nested_struct.e",
- typ: "string",
- },
- propInfo{
- name: "struct_has_embed",
- typ: "StructWithEmbedded",
- },
- propInfo{
- name: "struct_has_embed.nested_in_embedded",
- typ: "structToNest",
- },
- propInfo{
- name: "struct_has_embed.nested_in_embedded.e",
- typ: "string",
- },
- propInfo{
- name: "struct_has_embed.f",
- typ: "string",
- },
- propInfo{
- name: "list_of_ints",
- typ: "list of int",
- },
- propInfo{
- name: "list_of_nested",
- typ: "list of structToNest",
- },
- propInfo{
- name: "nested_in_other_embedded",
- typ: "otherStructToNest",
- },
- propInfo{
- name: "nested_in_other_embedded.g",
- typ: "string",
- },
- propInfo{
- name: "h",
- typ: "string",
- },
- },
- "foo": []propInfo{
- propInfo{
- name: "a",
- typ: "string",
- },
- },
- }
-
- for _, m := range pkg.ModuleTypes {
- foundProps := []propInfo{}
-
- for _, p := range m.PropertyStructs {
- nestedProps, errs := findAllProperties("", p.Properties)
- foundProps = append(foundProps, nestedProps...)
- for _, err := range errs {
- t.Errorf("%s", err)
- }
- }
- if wanted, ok := expectedProps[m.Name]; ok {
- if !reflect.DeepEqual(foundProps, wanted) {
- t.Errorf("For %s, expected\n\t %q,\nbut got\n\t %q", m.Name, wanted, foundProps)
- }
+ for _, e := range expected {
+ if _, ok := allStructs[e]; !ok {
+ t.Errorf("missing entry %q, all entries: %q", e, allStructs)
}
}
}
-
-func findAllProperties(prefix string, properties []Property) ([]propInfo, []error) {
- foundProps := []propInfo{}
- errs := []error{}
- for _, p := range properties {
- prop := propInfo{
- name: prefix + p.Name,
- typ: p.Type,
- }
- foundProps = append(foundProps, prop)
- if hasTag(p.Tag, "blueprint", "mutated") {
- err := fmt.Errorf("Property %s has `blueprint:\"mutated\" tag but should have been excluded.", p.Name)
- errs = append(errs, err)
- }
-
- nestedProps, nestedErrs := findAllProperties(prefix+p.Name+".", p.Properties)
- foundProps = append(foundProps, nestedProps...)
- errs = append(errs, nestedErrs...)
- }
- return foundProps, errs
-}
diff --git a/bootstrap/bpdoc/properties.go b/bootstrap/bpdoc/properties.go
index 2ca8e65..9256d8e 100644
--- a/bootstrap/bpdoc/properties.go
+++ b/bootstrap/bpdoc/properties.go
@@ -142,10 +142,6 @@
return getByName(name, "", &ps.Properties)
}
-func (ps *PropertyStruct) Nest(nested *PropertyStruct) {
- ps.Properties = append(ps.Properties, nested.Properties...)
-}
-
func getByName(name string, prefix string, props *[]Property) *Property {
for i := range *props {
if prefix+(*props)[i].Name == name {
@@ -161,10 +157,6 @@
p.Properties = append(p.Properties, nested.Properties...)
}
-func (p *Property) SetAnonymous() {
- p.Anonymous = true
-}
-
func newPropertyStruct(t *doc.Type) (*PropertyStruct, error) {
typeSpec := t.Decl.Specs[0].(*ast.TypeSpec)
ps := PropertyStruct{
@@ -197,7 +189,8 @@
}
}
for _, n := range names {
- var name, tag, text string
+ var name, typ, tag, text string
+ var innerProps []Property
if n != nil {
name = proptools.PropertyNameForField(n.Name)
}
@@ -210,9 +203,25 @@
return nil, err
}
}
- typ, innerProps, err := getType(f.Type)
- if err != nil {
- return nil, err
+
+ t := f.Type
+ if star, ok := t.(*ast.StarExpr); ok {
+ t = star.X
+ }
+ switch a := t.(type) {
+ case *ast.ArrayType:
+ typ = "list of strings"
+ case *ast.InterfaceType:
+ typ = "interface"
+ case *ast.Ident:
+ typ = a.Name
+ case *ast.StructType:
+ innerProps, err = structProperties(a)
+ if err != nil {
+ return nil, err
+ }
+ default:
+ typ = fmt.Sprintf("%T", f.Type)
}
props = append(props, Property{
@@ -228,37 +237,6 @@
return props, nil
}
-func getType(expr ast.Expr) (typ string, innerProps []Property, err error) {
- var t ast.Expr
- if star, ok := expr.(*ast.StarExpr); ok {
- t = star.X
- } else {
- t = expr
- }
- switch a := t.(type) {
- case *ast.ArrayType:
- var elt string
- elt, innerProps, err = getType(a.Elt)
- if err != nil {
- return "", nil, err
- }
- typ = "list of " + elt
- case *ast.InterfaceType:
- typ = "interface"
- case *ast.Ident:
- typ = a.Name
- case *ast.StructType:
- innerProps, err = structProperties(a)
- if err != nil {
- return "", nil, err
- }
- default:
- typ = fmt.Sprintf("%T", expr)
- }
-
- return typ, innerProps, nil
-}
-
func (ps *PropertyStruct) ExcludeByTag(key, value string) {
filterPropsByTag(&ps.Properties, key, value, true)
}
@@ -273,7 +251,6 @@
filtered := (*props)[:0]
for _, x := range *props {
if hasTag(x.Tag, key, value) == !exclude {
- filterPropsByTag(&x.Properties, key, value, exclude)
filtered = append(filtered, x)
}
}
diff --git a/bootstrap/bpdoc/properties_test.go b/bootstrap/bpdoc/properties_test.go
index 085bcdf..4045cb1 100644
--- a/bootstrap/bpdoc/properties_test.go
+++ b/bootstrap/bpdoc/properties_test.go
@@ -28,8 +28,11 @@
ps.ExcludeByTag("tag1", "a")
- expected := []string{"c", "d", "g"}
- actual := actualProperties(t, ps.Properties)
+ expected := []string{"c"}
+ actual := []string{}
+ for _, p := range ps.Properties {
+ actual = append(actual, p.Name)
+ }
if !reflect.DeepEqual(expected, actual) {
t.Errorf("unexpected ExcludeByTag result, expected: %q, actual: %q", expected, actual)
}
@@ -44,20 +47,12 @@
ps.IncludeByTag("tag1", "c")
- expected := []string{"b", "c", "d", "f", "g"}
- actual := actualProperties(t, ps.Properties)
+ expected := []string{"b", "c"}
+ actual := []string{}
+ for _, p := range ps.Properties {
+ actual = append(actual, p.Name)
+ }
if !reflect.DeepEqual(expected, actual) {
t.Errorf("unexpected IncludeByTag result, expected: %q, actual: %q", expected, actual)
}
}
-
-func actualProperties(t *testing.T, props []Property) []string {
- t.Helper()
-
- actual := []string{}
- for _, p := range props {
- actual = append(actual, p.Name)
- actual = append(actual, actualProperties(t, p.Properties)...)
- }
- return actual
-}
diff --git a/bootstrap/bpdoc/reader_test.go b/bootstrap/bpdoc/reader_test.go
index bf324bf..0d608b3 100644
--- a/bootstrap/bpdoc/reader_test.go
+++ b/bootstrap/bpdoc/reader_test.go
@@ -16,7 +16,6 @@
package bpdoc
import (
- "html/template"
"reflect"
"runtime"
"testing"
@@ -24,65 +23,11 @@
"github.com/google/blueprint"
)
-type factoryFn func() (blueprint.Module, []interface{})
-
// foo docs.
func fooFactory() (blueprint.Module, []interface{}) {
return nil, []interface{}{&props{}}
}
-// bar docs.
-func barFactory() (blueprint.Module, []interface{}) {
- return nil, []interface{}{&complexProps{}}
-}
-
-type structToNest struct {
- E string
-}
-
-type StructToEmbed struct {
- Nested_in_embedded structToNest
-
- // F string
- F string
-}
-
-type otherStructToNest struct {
- G string
-}
-
-type OtherStructToEmbed struct {
- Nested_in_other_embedded otherStructToNest
-
- // F string
- H string
-}
-
-type StructWithEmbedded struct {
- StructToEmbed
-}
-
-// for bpdoc_test.go
-type complexProps struct {
- A string
- B_mutated string `blueprint:"mutated"`
-
- Nested struct {
- C string
- D_mutated string `blueprint:"mutated"`
- }
-
- Nested_struct structToNest
-
- Struct_has_embed StructWithEmbedded
-
- OtherStructToEmbed
-
- List_of_ints []int
-
- List_of_nested []structToNest
-}
-
// props docs.
type props struct {
// A docs.
@@ -94,18 +39,10 @@
A string `tag1:"a,b" tag2:"c"`
B string `tag1:"a,c"`
C string `tag1:"b,c"`
-
- D struct {
- E string `tag1:"a,b" tag2:"c"`
- F string `tag1:"a,c"`
- G string `tag1:"b,c"`
- } `tag1:"b,c"`
}
var pkgPath string
var pkgFiles map[string][]string
-var moduleTypeNameFactories map[string]reflect.Value
-var moduleTypeNamePropertyStructs map[string][]interface{}
func init() {
pc, filename, _, _ := runtime.Caller(0)
@@ -120,34 +57,21 @@
pkgFiles = map[string][]string{
pkgPath: {filename},
}
-
- factories := map[string]factoryFn{"foo": fooFactory, "bar": barFactory}
-
- moduleTypeNameFactories = make(map[string]reflect.Value, len(factories))
- moduleTypeNamePropertyStructs = make(map[string][]interface{}, len(factories))
- for name, factory := range factories {
- moduleTypeNameFactories[name] = reflect.ValueOf(factory)
- _, structs := factory()
- moduleTypeNamePropertyStructs[name] = structs
- }
}
func TestModuleTypeDocs(t *testing.T) {
r := NewReader(pkgFiles)
- for m := range moduleTypeNameFactories {
- mt, err := r.ModuleType(m+"_module", moduleTypeNameFactories[m])
- if err != nil {
- t.Fatal(err)
- }
+ mt, err := r.ModuleType("foo_module", reflect.ValueOf(fooFactory))
+ if err != nil {
+ t.Fatal(err)
+ }
- expectedText := template.HTML(m + " docs.\n\n")
- if mt.Text != expectedText {
- t.Errorf("unexpected docs %q", mt.Text)
- }
+ if mt.Text != "foo docs.\n\n" {
+ t.Errorf("unexpected docs %q", mt.Text)
+ }
- if mt.PkgPath != pkgPath {
- t.Errorf("expected pkgpath %q, got %q", pkgPath, mt.PkgPath)
- }
+ if mt.PkgPath != pkgPath {
+ t.Errorf("expected pkgpath %q, got %q", pkgPath, mt.PkgPath)
}
}
diff --git a/bootstrap/bpglob/bpglob.go b/bootstrap/bpglob/bpglob.go
index 81c0dd0..fe47b6f 100644
--- a/bootstrap/bpglob/bpglob.go
+++ b/bootstrap/bpglob/bpglob.go
@@ -19,206 +19,69 @@
package main
import (
- "bytes"
- "errors"
"flag"
"fmt"
"io/ioutil"
"os"
- "strconv"
"time"
- "github.com/google/blueprint/deptools"
"github.com/google/blueprint/pathtools"
)
var (
- // flagSet is a flag.FlagSet with flag.ContinueOnError so that we can handle the versionMismatchError
- // error from versionArg.
- flagSet = flag.NewFlagSet("bpglob", flag.ContinueOnError)
+ out = flag.String("o", "", "file to write list of files that match glob")
- out = flagSet.String("o", "", "file to write list of files that match glob")
-
- versionMatch versionArg
- globs []globArg
+ excludes multiArg
)
func init() {
- flagSet.Var(&versionMatch, "v", "version number the command line was generated for")
- flagSet.Var((*patternsArgs)(&globs), "p", "pattern to include in results")
- flagSet.Var((*excludeArgs)(&globs), "e", "pattern to exclude from results from the most recent pattern")
+ flag.Var(&excludes, "e", "pattern to exclude from results")
}
-// bpglob is executed through the rules in build-globs.ninja to determine whether soong_build
-// needs to rerun. That means when the arguments accepted by bpglob change it will be called
-// with the old arguments, then soong_build will rerun and update build-globs.ninja with the new
-// arguments.
-//
-// To avoid having to maintain backwards compatibility with old arguments across the transition,
-// a version argument is used to detect the transition in order to stop parsing arguments, touch the
-// output file and exit immediately. Aborting parsing arguments is necessary to handle parsing
-// errors that would be fatal, for example the removal of a flag. The version number in
-// pathtools.BPGlobArgumentVersion should be manually incremented when the bpglob argument format
-// changes.
-//
-// If the version argument is not passed then a version mismatch is assumed.
+type multiArg []string
-// versionArg checks the argument against pathtools.BPGlobArgumentVersion, returning a
-// versionMismatchError error if it does not match.
-type versionArg bool
+func (m *multiArg) String() string {
+ return `""`
+}
-var versionMismatchError = errors.New("version mismatch")
-
-func (v *versionArg) String() string { return "" }
-
-func (v *versionArg) Set(s string) error {
- vers, err := strconv.Atoi(s)
- if err != nil {
- return fmt.Errorf("error parsing version argument: %w", err)
- }
-
- // Force the -o argument to come before the -v argument so that the output file can be
- // updated on error.
- if *out == "" {
- return fmt.Errorf("-o argument must be passed before -v")
- }
-
- if vers != pathtools.BPGlobArgumentVersion {
- return versionMismatchError
- }
-
- *v = true
-
+func (m *multiArg) Set(s string) error {
+ *m = append(*m, s)
return nil
}
-// A glob arg holds a single -p argument with zero or more following -e arguments.
-type globArg struct {
- pattern string
- excludes []string
-}
-
-// patternsArgs implements flag.Value to handle -p arguments by adding a new globArg to the list.
-type patternsArgs []globArg
-
-func (p *patternsArgs) String() string { return `""` }
-
-func (p *patternsArgs) Set(s string) error {
- globs = append(globs, globArg{
- pattern: s,
- })
- return nil
-}
-
-// excludeArgs implements flag.Value to handle -e arguments by adding to the last globArg in the
-// list.
-type excludeArgs []globArg
-
-func (e *excludeArgs) String() string { return `""` }
-
-func (e *excludeArgs) Set(s string) error {
- if len(*e) == 0 {
- return fmt.Errorf("-p argument is required before the first -e argument")
- }
-
- glob := &(*e)[len(*e)-1]
- glob.excludes = append(glob.excludes, s)
- return nil
+func (m *multiArg) Get() interface{} {
+ return m
}
func usage() {
- fmt.Fprintln(os.Stderr, "usage: bpglob -o out -v version -p glob [-e excludes ...] [-p glob ...]")
- flagSet.PrintDefaults()
+ fmt.Fprintln(os.Stderr, "usage: bpglob -o out glob")
+ flag.PrintDefaults()
os.Exit(2)
}
func main() {
- // Save the command line flag error output to a buffer, the flag package unconditionally
- // writes an error message to the output on error, and we want to hide the error for the
- // version mismatch case.
- flagErrorBuffer := &bytes.Buffer{}
- flagSet.SetOutput(flagErrorBuffer)
-
- err := flagSet.Parse(os.Args[1:])
-
- if !versionMatch {
- // A version mismatch error occurs when the arguments written into build-globs.ninja
- // don't match the format expected by the bpglob binary. This happens during the
- // first incremental build after bpglob is changed. Handle this case by aborting
- // argument parsing and updating the output file with something that will always cause
- // the primary builder to rerun.
- // This can happen when there is no -v argument or if the -v argument doesn't match
- // pathtools.BPGlobArgumentVersion.
- writeErrorOutput(*out, versionMismatchError)
- os.Exit(0)
- }
-
- if err != nil {
- os.Stderr.Write(flagErrorBuffer.Bytes())
- fmt.Fprintln(os.Stderr, "error:", err.Error())
- usage()
- }
+ flag.Parse()
if *out == "" {
fmt.Fprintln(os.Stderr, "error: -o is required")
usage()
}
- if flagSet.NArg() > 0 {
+ if flag.NArg() != 1 {
usage()
}
- err = globsWithDepFile(*out, *out+".d", globs)
+ _, err := pathtools.GlobWithDepFile(flag.Arg(0), *out, *out+".d", excludes)
if err != nil {
// Globs here were already run in the primary builder without error. The only errors here should be if the glob
// pattern was made invalid by a change in the pathtools glob implementation, in which case the primary builder
// needs to be rerun anyways. Update the output file with something that will always cause the primary builder
// to rerun.
- writeErrorOutput(*out, err)
- }
-}
-
-// writeErrorOutput writes an error to the output file with a timestamp to ensure that it is
-// considered dirty by ninja.
-func writeErrorOutput(path string, globErr error) {
- s := fmt.Sprintf("%s: error: %s\n", time.Now().Format(time.StampNano), globErr.Error())
- err := ioutil.WriteFile(path, []byte(s), 0666)
- if err != nil {
- fmt.Fprintf(os.Stderr, "error: %s\n", err.Error())
- os.Exit(1)
- }
-}
-
-// globsWithDepFile finds all files and directories that match glob. Directories
-// will have a trailing '/'. It compares the list of matches against the
-// contents of fileListFile, and rewrites fileListFile if it has changed. It
-// also writes all of the directories it traversed as dependencies on fileListFile
-// to depFile.
-//
-// The format of glob is either path/*.ext for a single directory glob, or
-// path/**/*.ext for a recursive glob.
-func globsWithDepFile(fileListFile, depFile string, globs []globArg) error {
- var results pathtools.MultipleGlobResults
- for _, glob := range globs {
- result, err := pathtools.Glob(glob.pattern, glob.excludes, pathtools.FollowSymlinks)
+ s := fmt.Sprintf("%s: error: %s\n", time.Now().Format(time.StampNano), err.Error())
+ err := ioutil.WriteFile(*out, []byte(s), 0666)
if err != nil {
- return err
+ fmt.Fprintf(os.Stderr, "error: %s\n", err.Error())
+ os.Exit(1)
}
- results = append(results, result)
}
-
- // Only write the output file if it has changed.
- err := pathtools.WriteFileIfChanged(fileListFile, results.FileList(), 0666)
- if err != nil {
- return fmt.Errorf("failed to write file list to %q: %w", fileListFile, err)
- }
-
- // The depfile can be written unconditionally as its timestamp doesn't affect ninja's restat
- // feature.
- err = deptools.WriteDepFile(depFile, fileListFile, results.Deps())
- if err != nil {
- return fmt.Errorf("failed to write dep file to %q: %w", depFile, err)
- }
-
- return nil
}
diff --git a/bootstrap/cleanup.go b/bootstrap/cleanup.go
index 9dbea2a..6444081 100644
--- a/bootstrap/cleanup.go
+++ b/bootstrap/cleanup.go
@@ -31,8 +31,8 @@
// removeAbandonedFilesUnder removes any files that appear in the Ninja log, and
// are prefixed with one of the `under` entries, but that are not currently
// build targets, or in `exempt`
-func removeAbandonedFilesUnder(ctx *blueprint.Context,
- srcDir, buildDir string, under, exempt []string) error {
+func removeAbandonedFilesUnder(ctx *blueprint.Context, config *Config,
+ srcDir string, under, exempt []string) error {
if len(under) == 0 {
return nil
@@ -50,7 +50,7 @@
replacer := strings.NewReplacer(
"@@SrcDir@@", srcDir,
- "@@BuildDir@@", buildDir)
+ "@@BuildDir@@", BuildDir)
ninjaBuildDir = replacer.Replace(ninjaBuildDir)
targets := make(map[string]bool)
for target := range targetRules {
diff --git a/bootstrap/command.go b/bootstrap/command.go
index 4a938db..cbbd32d 100644
--- a/bootstrap/command.go
+++ b/bootstrap/command.go
@@ -31,123 +31,57 @@
"github.com/google/blueprint/deptools"
)
-type Args struct {
- OutFile string
- GlobFile string
- DepFile string
- DocFile string
- Cpuprofile string
- Memprofile string
- DelveListen string
- DelvePath string
- TraceFile string
- RunGoTests bool
- UseValidations bool
- NoGC bool
- EmptyNinjaFile bool
- BuildDir string
- ModuleListFile string
- NinjaBuildDir string
- TopFile string
- GeneratingPrimaryBuilder bool
-
- PrimaryBuilderInvocations []PrimaryBuilderInvocation
-}
-
var (
- CmdlineArgs Args
- absSrcDir string
+ outFile string
+ globFile string
+ depFile string
+ docFile string
+ cpuprofile string
+ memprofile string
+ traceFile string
+ runGoTests bool
+ noGC bool
+ moduleListFile string
+ emptyNinjaFile bool
+
+ BuildDir string
+ NinjaBuildDir string
+ SrcDir string
+
+ absSrcDir string
)
func init() {
- flag.StringVar(&CmdlineArgs.OutFile, "o", "build.ninja", "the Ninja file to output")
- flag.StringVar(&CmdlineArgs.GlobFile, "globFile", "build-globs.ninja", "the Ninja file of globs to output")
- flag.StringVar(&CmdlineArgs.BuildDir, "b", ".", "the build output directory")
- flag.StringVar(&CmdlineArgs.NinjaBuildDir, "n", "", "the ninja builddir directory")
- flag.StringVar(&CmdlineArgs.DepFile, "d", "", "the dependency file to output")
- flag.StringVar(&CmdlineArgs.DocFile, "docs", "", "build documentation file to output")
- flag.StringVar(&CmdlineArgs.Cpuprofile, "cpuprofile", "", "write cpu profile to file")
- flag.StringVar(&CmdlineArgs.TraceFile, "trace", "", "write trace to file")
- flag.StringVar(&CmdlineArgs.Memprofile, "memprofile", "", "write memory profile to file")
- flag.BoolVar(&CmdlineArgs.NoGC, "nogc", false, "turn off GC for debugging")
- flag.BoolVar(&CmdlineArgs.RunGoTests, "t", false, "build and run go tests during bootstrap")
- flag.BoolVar(&CmdlineArgs.UseValidations, "use-validations", false, "use validations to depend on go tests")
- flag.StringVar(&CmdlineArgs.ModuleListFile, "l", "", "file that lists filepaths to parse")
- flag.BoolVar(&CmdlineArgs.EmptyNinjaFile, "empty-ninja-file", false, "write out a 0-byte ninja file")
+ flag.StringVar(&outFile, "o", "build.ninja", "the Ninja file to output")
+ flag.StringVar(&globFile, "globFile", "build-globs.ninja", "the Ninja file of globs to output")
+ flag.StringVar(&BuildDir, "b", ".", "the build output directory")
+ flag.StringVar(&NinjaBuildDir, "n", "", "the ninja builddir directory")
+ flag.StringVar(&depFile, "d", "", "the dependency file to output")
+ flag.StringVar(&docFile, "docs", "", "build documentation file to output")
+ flag.StringVar(&cpuprofile, "cpuprofile", "", "write cpu profile to file")
+ flag.StringVar(&traceFile, "trace", "", "write trace to file")
+ flag.StringVar(&memprofile, "memprofile", "", "write memory profile to file")
+ flag.BoolVar(&noGC, "nogc", false, "turn off GC for debugging")
+ flag.BoolVar(&runGoTests, "t", false, "build and run go tests during bootstrap")
+ flag.StringVar(&moduleListFile, "l", "", "file that lists filepaths to parse")
+ flag.BoolVar(&emptyNinjaFile, "empty-ninja-file", false, "write out a 0-byte ninja file")
}
-func Main(ctx *blueprint.Context, config interface{}, generatingPrimaryBuilder bool) {
+func Main(ctx *blueprint.Context, config interface{}, extraNinjaFileDeps ...string) {
if !flag.Parsed() {
flag.Parse()
}
- if flag.NArg() != 1 {
- fatalf("no Blueprints file specified")
- }
-
- CmdlineArgs.TopFile = flag.Arg(0)
- CmdlineArgs.GeneratingPrimaryBuilder = generatingPrimaryBuilder
- ninjaDeps := RunBlueprint(CmdlineArgs, ctx, config)
- err := deptools.WriteDepFile(CmdlineArgs.DepFile, CmdlineArgs.OutFile, ninjaDeps)
- if err != nil {
- fatalf("Cannot write depfile '%s': %s", CmdlineArgs.DepFile, err)
- }
-}
-
-func PrimaryBuilderExtraFlags(args Args, globFile, mainNinjaFile string) []string {
- result := make([]string, 0)
-
- if args.RunGoTests {
- result = append(result, "-t")
- }
-
- result = append(result, "-l", args.ModuleListFile)
- result = append(result, "-globFile", globFile)
- result = append(result, "-o", mainNinjaFile)
-
- if args.EmptyNinjaFile {
- result = append(result, "--empty-ninja-file")
- }
-
- if args.DelveListen != "" {
- result = append(result, "--delve_listen", args.DelveListen)
- }
-
- if args.DelvePath != "" {
- result = append(result, "--delve_path", args.DelvePath)
- }
-
- return result
-}
-
-func writeEmptyGlobFile(path string) {
- err := os.MkdirAll(filepath.Dir(path), 0777)
- if err != nil {
- fatalf("Failed to create parent directories of empty ninja glob file '%s': %s", path, err)
- }
-
- if _, err := os.Stat(path); os.IsNotExist(err) {
- err = ioutil.WriteFile(path, nil, 0666)
- if err != nil {
- fatalf("Failed to create empty ninja glob file '%s': %s", path, err)
- }
- }
-}
-
-// Returns the list of dependencies the emitted Ninja files has. These can be
-// written to the .d file for the output so that it is correctly rebuilt when
-// needed in case Blueprint is itself invoked from Ninja
-func RunBlueprint(args Args, ctx *blueprint.Context, config interface{}) []string {
runtime.GOMAXPROCS(runtime.NumCPU())
- if args.NoGC {
+ if noGC {
debug.SetGCPercent(-1)
}
absSrcDir = ctx.SrcDir()
- if args.Cpuprofile != "" {
- f, err := os.Create(absolutePath(args.Cpuprofile))
+ if cpuprofile != "" {
+ f, err := os.Create(absolutePath(cpuprofile))
if err != nil {
fatalf("error opening cpuprofile: %s", err)
}
@@ -156,8 +90,8 @@
defer pprof.StopCPUProfile()
}
- if args.TraceFile != "" {
- f, err := os.Create(absolutePath(args.TraceFile))
+ if traceFile != "" {
+ f, err := os.Create(absolutePath(traceFile))
if err != nil {
fatalf("error opening trace: %s", err)
}
@@ -166,56 +100,40 @@
defer trace.Stop()
}
- srcDir := filepath.Dir(args.TopFile)
+ if flag.NArg() != 1 {
+ fatalf("no Blueprints file specified")
+ }
- ninjaDeps := make([]string, 0)
-
- if args.ModuleListFile != "" {
- ctx.SetModuleListFile(args.ModuleListFile)
- ninjaDeps = append(ninjaDeps, args.ModuleListFile)
+ SrcDir = filepath.Dir(flag.Arg(0))
+ if moduleListFile != "" {
+ ctx.SetModuleListFile(moduleListFile)
+ extraNinjaFileDeps = append(extraNinjaFileDeps, moduleListFile)
} else {
fatalf("-l <moduleListFile> is required and must be nonempty")
}
- filesToParse, err := ctx.ListModulePaths(srcDir)
+ filesToParse, err := ctx.ListModulePaths(SrcDir)
if err != nil {
fatalf("could not enumerate files: %v\n", err.Error())
}
- buildDir := config.(BootstrapConfig).BuildDir()
-
- stage := StageMain
- if args.GeneratingPrimaryBuilder {
- stage = StagePrimary
+ if NinjaBuildDir == "" {
+ NinjaBuildDir = BuildDir
}
- primaryBuilderNinjaGlobFile := absolutePath(filepath.Join(args.BuildDir, bootstrapSubDir, "build-globs.ninja"))
- mainNinjaFile := filepath.Join("$buildDir", "build.ninja")
-
- writeEmptyGlobFile(primaryBuilderNinjaGlobFile)
-
- var invocations []PrimaryBuilderInvocation
-
- if args.PrimaryBuilderInvocations != nil {
- invocations = args.PrimaryBuilderInvocations
- } else {
- primaryBuilderArgs := PrimaryBuilderExtraFlags(args, primaryBuilderNinjaGlobFile, mainNinjaFile)
- primaryBuilderArgs = append(primaryBuilderArgs, args.TopFile)
-
- invocations = []PrimaryBuilderInvocation{{
- Inputs: []string{args.TopFile},
- Outputs: []string{mainNinjaFile},
- Args: primaryBuilderArgs,
- }}
+ stage := StageMain
+ if c, ok := config.(ConfigInterface); ok {
+ if c.GeneratingPrimaryBuilder() {
+ stage = StagePrimary
+ }
}
bootstrapConfig := &Config{
stage: stage,
- topLevelBlueprintsFile: args.TopFile,
- globFile: primaryBuilderNinjaGlobFile,
- runGoTests: args.RunGoTests,
- useValidations: args.UseValidations,
- primaryBuilderInvocations: invocations,
+ topLevelBlueprintsFile: flag.Arg(0),
+ emptyNinjaFile: emptyNinjaFile,
+ runGoTests: runGoTests,
+ moduleListFile: moduleListFile,
}
ctx.RegisterBottomUpMutator("bootstrap_plugin_deps", pluginDeps)
@@ -224,33 +142,33 @@
ctx.RegisterModuleType("blueprint_go_binary", newGoBinaryModuleFactory(bootstrapConfig, true))
ctx.RegisterSingletonType("bootstrap", newSingletonFactory(bootstrapConfig))
- ctx.RegisterSingletonType("glob", globSingletonFactory(bootstrapConfig, ctx))
+ ctx.RegisterSingletonType("glob", globSingletonFactory(ctx))
- blueprintFiles, errs := ctx.ParseFileList(filepath.Dir(args.TopFile), filesToParse, config)
+ deps, errs := ctx.ParseFileList(filepath.Dir(bootstrapConfig.topLevelBlueprintsFile), filesToParse, config)
if len(errs) > 0 {
fatalErrors(errs)
}
// Add extra ninja file dependencies
- ninjaDeps = append(ninjaDeps, blueprintFiles...)
+ deps = append(deps, extraNinjaFileDeps...)
extraDeps, errs := ctx.ResolveDependencies(config)
if len(errs) > 0 {
fatalErrors(errs)
}
- ninjaDeps = append(ninjaDeps, extraDeps...)
+ deps = append(deps, extraDeps...)
- if args.DocFile != "" {
- err := writeDocs(ctx, config, absolutePath(args.DocFile))
+ if docFile != "" {
+ err := writeDocs(ctx, absolutePath(docFile))
if err != nil {
fatalErrors([]error{err})
}
- return nil
+ return
}
if c, ok := config.(ConfigStopBefore); ok {
if c.StopBefore() == StopBeforePrepareBuildActions {
- return ninjaDeps
+ return
}
}
@@ -258,45 +176,46 @@
if len(errs) > 0 {
fatalErrors(errs)
}
- ninjaDeps = append(ninjaDeps, extraDeps...)
-
- if c, ok := config.(ConfigStopBefore); ok {
- if c.StopBefore() == StopBeforeWriteNinja {
- return ninjaDeps
- }
- }
+ deps = append(deps, extraDeps...)
const outFilePermissions = 0666
- var out io.StringWriter
+ var out io.Writer
var f *os.File
var buf *bufio.Writer
- if args.EmptyNinjaFile {
- if err := ioutil.WriteFile(absolutePath(args.OutFile), []byte(nil), outFilePermissions); err != nil {
+ if emptyNinjaFile {
+ if err := ioutil.WriteFile(absolutePath(outFile), []byte(nil), outFilePermissions); err != nil {
fatalf("error writing empty Ninja file: %s", err)
}
}
- if stage != StageMain || !args.EmptyNinjaFile {
- f, err = os.OpenFile(absolutePath(args.OutFile), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, outFilePermissions)
+ if stage != StageMain || !emptyNinjaFile {
+ f, err = os.OpenFile(absolutePath(outFile), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, outFilePermissions)
if err != nil {
fatalf("error opening Ninja file: %s", err)
}
- buf = bufio.NewWriterSize(f, 16*1024*1024)
+ buf = bufio.NewWriter(f)
out = buf
} else {
- out = ioutil.Discard.(io.StringWriter)
+ out = ioutil.Discard
}
- if args.GlobFile != "" {
- buffer, errs := generateGlobNinjaFile(bootstrapConfig, config, ctx.Globs)
+ if globFile != "" {
+ buffer, errs := generateGlobNinjaFile(ctx.Globs)
if len(errs) > 0 {
fatalErrors(errs)
}
- err = ioutil.WriteFile(absolutePath(args.GlobFile), buffer, outFilePermissions)
+ err = ioutil.WriteFile(absolutePath(globFile), buffer, outFilePermissions)
if err != nil {
- fatalf("error writing %s: %s", args.GlobFile, err)
+ fatalf("error writing %s: %s", globFile, err)
+ }
+ }
+
+ if depFile != "" {
+ err := deptools.WriteDepFile(absolutePath(depFile), outFile, deps)
+ if err != nil {
+ fatalf("error writing depfile: %s", err)
}
}
@@ -320,23 +239,21 @@
}
if c, ok := config.(ConfigRemoveAbandonedFilesUnder); ok {
- under, except := c.RemoveAbandonedFilesUnder(buildDir)
- err := removeAbandonedFilesUnder(ctx, srcDir, buildDir, under, except)
+ under, except := c.RemoveAbandonedFilesUnder()
+ err := removeAbandonedFilesUnder(ctx, bootstrapConfig, SrcDir, under, except)
if err != nil {
fatalf("error removing abandoned files: %s", err)
}
}
- if args.Memprofile != "" {
- f, err := os.Create(absolutePath(args.Memprofile))
+ if memprofile != "" {
+ f, err := os.Create(absolutePath(memprofile))
if err != nil {
fatalf("error opening memprofile: %s", err)
}
defer f.Close()
pprof.WriteHeapProfile(f)
}
-
- return ninjaDeps
}
func fatalf(format string, args ...interface{}) {
diff --git a/bootstrap/config.go b/bootstrap/config.go
index a29ba76..9499aeb 100644
--- a/bootstrap/config.go
+++ b/bootstrap/config.go
@@ -15,7 +15,6 @@
package bootstrap
import (
- "fmt"
"os"
"path/filepath"
"runtime"
@@ -24,30 +23,25 @@
"github.com/google/blueprint"
)
-func bootstrapVariable(name string, value func(BootstrapConfig) string) blueprint.Variable {
+func bootstrapVariable(name string, value func() string) blueprint.Variable {
return pctx.VariableFunc(name, func(config interface{}) (string, error) {
- c, ok := config.(BootstrapConfig)
- if !ok {
- panic(fmt.Sprintf("Bootstrap rules were passed a configuration that does not include theirs, config=%q",
- config))
- }
- return value(c), nil
+ return value(), nil
})
}
var (
// These variables are the only configuration needed by the bootstrap
// modules.
- srcDirVariable = bootstrapVariable("srcDir", func(c BootstrapConfig) string {
- return c.SrcDir()
+ srcDir = bootstrapVariable("srcDir", func() string {
+ return SrcDir
})
- buildDirVariable = bootstrapVariable("buildDir", func(c BootstrapConfig) string {
- return c.BuildDir()
+ buildDir = bootstrapVariable("buildDir", func() string {
+ return BuildDir
})
- ninjaBuildDirVariable = bootstrapVariable("ninjaBuildDir", func(c BootstrapConfig) string {
- return c.NinjaBuildDir()
+ ninjaBuildDir = bootstrapVariable("ninjaBuildDir", func() string {
+ return NinjaBuildDir
})
- goRootVariable = bootstrapVariable("goRoot", func(c BootstrapConfig) string {
+ goRoot = bootstrapVariable("goRoot", func() string {
goroot := runtime.GOROOT()
// Prefer to omit absolute paths from the ninja file
if cwd, err := os.Getwd(); err == nil {
@@ -59,35 +53,19 @@
}
return goroot
})
- compileCmdVariable = bootstrapVariable("compileCmd", func(c BootstrapConfig) string {
+ compileCmd = bootstrapVariable("compileCmd", func() string {
return "$goRoot/pkg/tool/" + runtime.GOOS + "_" + runtime.GOARCH + "/compile"
})
- linkCmdVariable = bootstrapVariable("linkCmd", func(c BootstrapConfig) string {
+ linkCmd = bootstrapVariable("linkCmd", func() string {
return "$goRoot/pkg/tool/" + runtime.GOOS + "_" + runtime.GOARCH + "/link"
})
- debugFlagsVariable = bootstrapVariable("debugFlags", func(c BootstrapConfig) string {
- if c.DebugCompilation() {
- // -N: disable optimizations, -l: disable inlining
- return "-N -l"
- } else {
- return ""
- }
- })
)
-type BootstrapConfig interface {
- // The top-level directory of the source tree
- SrcDir() string
-
- // The directory where files emitted during bootstrapping are located.
- // Usually NinjaBuildDir() + "/soong".
- BuildDir() string
-
- // The output directory for the build.
- NinjaBuildDir() string
-
- // Whether to compile Go code in such a way that it can be debugged
- DebugCompilation() bool
+type ConfigInterface interface {
+ // GeneratingPrimaryBuilder should return true if this build invocation is
+ // creating a .bootstrap/build.ninja file to be used to build the
+ // primary builder
+ GeneratingPrimaryBuilder() bool
}
type ConfigRemoveAbandonedFilesUnder interface {
@@ -95,7 +73,7 @@
// - a slice of path prefixes that will be cleaned of files that are no
// longer active targets, but are listed in the .ninja_log.
// - a slice of paths that are exempt from cleaning
- RemoveAbandonedFilesUnder(buildDir string) (under, except []string)
+ RemoveAbandonedFilesUnder() (under, except []string)
}
type ConfigBlueprintToolLocation interface {
@@ -109,7 +87,6 @@
const (
StopBeforePrepareBuildActions StopBefore = 1
- StopBeforeWriteNinja StopBefore = 2
)
type ConfigStopBefore interface {
@@ -123,20 +100,12 @@
StageMain
)
-type PrimaryBuilderInvocation struct {
- Inputs []string
- Outputs []string
- Args []string
-}
-
type Config struct {
stage Stage
topLevelBlueprintsFile string
- globFile string
+ emptyNinjaFile bool
runGoTests bool
- useValidations bool
-
- primaryBuilderInvocations []PrimaryBuilderInvocation
+ moduleListFile string
}
diff --git a/bootstrap/glob.go b/bootstrap/glob.go
index 39c662b..52dbf2f 100644
--- a/bootstrap/glob.go
+++ b/bootstrap/glob.go
@@ -17,13 +17,11 @@
import (
"bytes"
"fmt"
- "hash/fnv"
- "io"
"path/filepath"
- "strconv"
"strings"
"github.com/google/blueprint"
+ "github.com/google/blueprint/deptools"
"github.com/google/blueprint/pathtools"
)
@@ -49,71 +47,36 @@
// and writes it to $out if it has changed, and writes the directories to $out.d
GlobRule = pctx.StaticRule("GlobRule",
blueprint.RuleParams{
- Command: fmt.Sprintf(`%s -o $out -v %d $args`,
- globCmd, pathtools.BPGlobArgumentVersion),
+ Command: fmt.Sprintf(`%s -o $out $excludes "$glob"`, globCmd),
CommandDeps: []string{globCmd},
- Description: "glob",
+ Description: "glob $glob",
Restat: true,
Deps: blueprint.DepsGCC,
Depfile: "$out.d",
},
- "args")
+ "glob", "excludes")
)
// GlobFileContext is the subset of ModuleContext and SingletonContext needed by GlobFile
type GlobFileContext interface {
- Config() interface{}
Build(pctx blueprint.PackageContext, params blueprint.BuildParams)
}
// GlobFile creates a rule to write to fileListFile a list of the files that match the specified
// pattern but do not match any of the patterns specified in excludes. The file will include
-// appropriate dependencies to regenerate the file if and only if the list of matching files has
-// changed.
-func GlobFile(ctx GlobFileContext, pattern string, excludes []string, fileListFile string) {
- args := `-p "` + pattern + `"`
- if len(excludes) > 0 {
- args += " " + joinWithPrefixAndQuote(excludes, "-e ")
- }
- ctx.Build(pctx, blueprint.BuildParams{
- Rule: GlobRule,
- Outputs: []string{fileListFile},
- Args: map[string]string{
- "args": args,
- },
- Description: "glob " + pattern,
- })
-}
-
-// multipleGlobFilesRule creates a rule to write to fileListFile a list of the files that match the specified
-// pattern but do not match any of the patterns specified in excludes. The file will include
-// appropriate dependencies to regenerate the file if and only if the list of matching files has
-// changed.
-func multipleGlobFilesRule(ctx GlobFileContext, fileListFile string, shard int, globs pathtools.MultipleGlobResults) {
- args := strings.Builder{}
-
- for i, glob := range globs {
- if i != 0 {
- args.WriteString(" ")
- }
- args.WriteString(`-p "`)
- args.WriteString(glob.Pattern)
- args.WriteString(`"`)
- for _, exclude := range glob.Excludes {
- args.WriteString(` -e "`)
- args.WriteString(exclude)
- args.WriteString(`"`)
- }
- }
+// appropriate dependencies written to depFile to regenerate the file if and only if the list of
+// matching files has changed.
+func GlobFile(ctx GlobFileContext, pattern string, excludes []string,
+ fileListFile, depFile string) {
ctx.Build(pctx, blueprint.BuildParams{
Rule: GlobRule,
Outputs: []string{fileListFile},
Args: map[string]string{
- "args": args.String(),
+ "glob": pattern,
+ "excludes": joinWithPrefixAndQuote(excludes, "-e "),
},
- Description: fmt.Sprintf("regenerate globs shard %d of %d", shard, numGlobBuckets),
})
}
@@ -148,76 +111,53 @@
// re-evaluate them whenever the contents of the searched directories change, and retrigger the
// primary builder if the results change.
type globSingleton struct {
- config *Config
- globLister func() pathtools.MultipleGlobResults
+ globLister func() []blueprint.GlobPath
writeRule bool
}
-func globSingletonFactory(config *Config, ctx *blueprint.Context) func() blueprint.Singleton {
+func globSingletonFactory(ctx *blueprint.Context) func() blueprint.Singleton {
return func() blueprint.Singleton {
return &globSingleton{
- config: config,
globLister: ctx.Globs,
}
}
}
func (s *globSingleton) GenerateBuildActions(ctx blueprint.SingletonContext) {
- // Sort the list of globs into buckets. A hash function is used instead of sharding so that
- // adding a new glob doesn't force rerunning all the buckets by shifting them all by 1.
- globBuckets := make([]pathtools.MultipleGlobResults, numGlobBuckets)
for _, g := range s.globLister() {
- bucket := globToBucket(g)
- globBuckets[bucket] = append(globBuckets[bucket], g)
- }
-
- // The directory for the intermediates needs to be different for bootstrap and the primary
- // builder.
- globsDir := globsDir(ctx.Config().(BootstrapConfig), s.config.stage)
-
- for i, globs := range globBuckets {
- fileListFile := filepath.Join(globsDir, strconv.Itoa(i))
+ fileListFile := filepath.Join(BuildDir, ".glob", g.Name)
if s.writeRule {
- // Called from generateGlobNinjaFile. Write out the file list to disk, and add a ninja
- // rule to run bpglob if any of the dependencies (usually directories that contain
- // globbed files) have changed. The file list produced by bpglob should match exactly
- // with the file written here so that restat can prevent rerunning the primary builder.
- //
- // We need to write the file list here so that it has an older modified date
- // than the build.ninja (otherwise we'd run the primary builder twice on
- // every new glob)
- //
- // We don't need to write the depfile because we're guaranteed that ninja
- // will run the command at least once (to record it into the ninja_log), so
- // the depfile will be loaded from that execution.
- err := pathtools.WriteFileIfChanged(absolutePath(fileListFile), globs.FileList(), 0666)
+ depFile := fileListFile + ".d"
+
+ fileList := strings.Join(g.Files, "\n") + "\n"
+ err := pathtools.WriteFileIfChanged(absolutePath(fileListFile), []byte(fileList), 0666)
if err != nil {
panic(fmt.Errorf("error writing %s: %s", fileListFile, err))
}
+ err = deptools.WriteDepFile(absolutePath(depFile), fileListFile, g.Deps)
+ if err != nil {
+ panic(fmt.Errorf("error writing %s: %s", depFile, err))
+ }
- // Write out the ninja rule to run bpglob.
- multipleGlobFilesRule(ctx, fileListFile, i, globs)
+ GlobFile(ctx, g.Pattern, g.Excludes, fileListFile, depFile)
} else {
- // Called from the main Context, make build.ninja depend on the fileListFile.
+ // Make build.ninja depend on the fileListFile
ctx.AddNinjaFileDeps(fileListFile)
}
}
}
-func generateGlobNinjaFile(bootstrapConfig *Config, config interface{},
- globLister func() pathtools.MultipleGlobResults) ([]byte, []error) {
-
+func generateGlobNinjaFile(globLister func() []blueprint.GlobPath) ([]byte, []error) {
ctx := blueprint.NewContext()
ctx.RegisterSingletonType("glob", func() blueprint.Singleton {
return &globSingleton{
- config: bootstrapConfig,
globLister: globLister,
writeRule: true,
}
})
- extraDeps, errs := ctx.ResolveDependencies(config)
+ extraDeps, errs := ctx.ResolveDependencies(nil)
if len(extraDeps) > 0 {
return nil, []error{fmt.Errorf("shouldn't have extra deps")}
}
@@ -225,7 +165,7 @@
return nil, errs
}
- extraDeps, errs = ctx.PrepareBuildActions(config)
+ extraDeps, errs = ctx.PrepareBuildActions(nil)
if len(extraDeps) > 0 {
return nil, []error{fmt.Errorf("shouldn't have extra deps")}
}
@@ -241,37 +181,3 @@
return buf.Bytes(), nil
}
-
-// globsDir returns a different directory to store glob intermediates for the bootstrap and
-// primary builder executions.
-func globsDir(config BootstrapConfig, stage Stage) string {
- buildDir := config.BuildDir()
- if stage == StageMain {
- return filepath.Join(buildDir, mainSubDir, "globs")
- } else {
- return filepath.Join(buildDir, bootstrapSubDir, "globs")
- }
-}
-
-// GlobFileListFiles returns the list of sharded glob file list files for the main stage.
-func GlobFileListFiles(config BootstrapConfig) []string {
- globsDir := globsDir(config, StageMain)
- var fileListFiles []string
- for i := 0; i < numGlobBuckets; i++ {
- fileListFiles = append(fileListFiles, filepath.Join(globsDir, strconv.Itoa(i)))
- }
- return fileListFiles
-}
-
-const numGlobBuckets = 1024
-
-// globToBucket converts a pathtools.GlobResult into a hashed bucket number in the range
-// [0, numGlobBuckets).
-func globToBucket(g pathtools.GlobResult) int {
- hash := fnv.New32a()
- io.WriteString(hash, g.Pattern)
- for _, e := range g.Excludes {
- io.WriteString(hash, e)
- }
- return int(hash.Sum32() % numGlobBuckets)
-}
diff --git a/bootstrap/minibp/main.go b/bootstrap/minibp/main.go
index 165f058..1714739 100644
--- a/bootstrap/minibp/main.go
+++ b/bootstrap/minibp/main.go
@@ -23,22 +23,24 @@
)
var runAsPrimaryBuilder bool
+var buildPrimaryBuilder bool
func init() {
flag.BoolVar(&runAsPrimaryBuilder, "p", false, "run as a primary builder")
}
type Config struct {
+ generatingPrimaryBuilder bool
}
-func (c Config) SrcDir() string {
- return bootstrap.CmdlineArgs.BuildDir
+func (c Config) GeneratingPrimaryBuilder() bool {
+ return c.generatingPrimaryBuilder
}
-func (c Config) RemoveAbandonedFilesUnder(buildDir string) (under, exempt []string) {
- if !runAsPrimaryBuilder {
- under = []string{filepath.Join(buildDir, ".bootstrap")}
- exempt = []string{filepath.Join(buildDir, ".bootstrap", "build.ninja")}
+func (c Config) RemoveAbandonedFilesUnder() (under, exempt []string) {
+ if c.generatingPrimaryBuilder {
+ under = []string{filepath.Join(bootstrap.BuildDir, ".bootstrap")}
+ exempt = []string{filepath.Join(bootstrap.BuildDir, ".bootstrap", "build.ninja")}
}
return
}
@@ -51,6 +53,9 @@
ctx.SetIgnoreUnknownModuleTypes(true)
}
- config := Config{}
- bootstrap.Main(ctx, config, !runAsPrimaryBuilder)
+ config := Config{
+ generatingPrimaryBuilder: !runAsPrimaryBuilder,
+ }
+
+ bootstrap.Main(ctx, config)
}
diff --git a/bootstrap/writedocs.go b/bootstrap/writedocs.go
index 99df32f..4edbcab 100644
--- a/bootstrap/writedocs.go
+++ b/bootstrap/writedocs.go
@@ -15,7 +15,7 @@
// ModuleTypeDocs returns a list of bpdoc.ModuleType objects that contain information relevant
// to generating documentation for module types supported by the primary builder.
-func ModuleTypeDocs(ctx *blueprint.Context, config interface{}, factories map[string]reflect.Value) ([]*bpdoc.Package, error) {
+func ModuleTypeDocs(ctx *blueprint.Context, factories map[string]reflect.Value) ([]*bpdoc.Package, error) {
// Find the module that's marked as the "primary builder", which means it's
// creating the binary that we'll use to generate the non-bootstrap
// build.ninja file.
@@ -55,7 +55,7 @@
switch m := module.(type) {
case (*goPackage):
pkgFiles[m.properties.PkgPath] = pathtools.PrefixPaths(m.properties.Srcs,
- filepath.Join(config.(BootstrapConfig).SrcDir(), ctx.ModuleDir(m)))
+ filepath.Join(SrcDir, ctx.ModuleDir(m)))
default:
panic(fmt.Errorf("unknown dependency type %T", module))
}
@@ -75,8 +75,8 @@
return bpdoc.AllPackages(pkgFiles, mergedFactories, ctx.ModuleTypePropertyStructs())
}
-func writeDocs(ctx *blueprint.Context, config interface{}, filename string) error {
- moduleTypeList, err := ModuleTypeDocs(ctx, config, nil)
+func writeDocs(ctx *blueprint.Context, filename string) error {
+ moduleTypeList, err := ModuleTypeDocs(ctx, nil)
if err != nil {
return err
}
diff --git a/bpfmt/bpfmt.go b/bpfmt/bpfmt.go
index 4e6bd1e..c287ea2 100644
--- a/bpfmt/bpfmt.go
+++ b/bpfmt/bpfmt.go
@@ -141,7 +141,7 @@
if err := processReader("<standard input>", os.Stdin, os.Stdout); err != nil {
report(err)
}
- os.Exit(exitCode)
+ return
}
for i := 0; i < flag.NArg(); i++ {
diff --git a/bpmodify/bpmodify.go b/bpmodify/bpmodify.go
index 29d28f0..29e97d1 100644
--- a/bpmodify/bpmodify.go
+++ b/bpmodify/bpmodify.go
@@ -22,25 +22,20 @@
var (
// main operation modes
- list = flag.Bool("l", false, "list files that would be modified by bpmodify")
- write = flag.Bool("w", false, "write result to (source) file instead of stdout")
- doDiff = flag.Bool("d", false, "display diffs instead of rewriting files")
- sortLists = flag.Bool("s", false, "sort touched lists, even if they were unsorted")
- targetedModules = new(identSet)
- targetedProperty = new(qualifiedProperty)
- addIdents = new(identSet)
- removeIdents = new(identSet)
-
- setString *string
+ list = flag.Bool("l", false, "list files that would be modified by bpmodify")
+ write = flag.Bool("w", false, "write result to (source) file instead of stdout")
+ doDiff = flag.Bool("d", false, "display diffs instead of rewriting files")
+ sortLists = flag.Bool("s", false, "sort touched lists, even if they were unsorted")
+ parameter = flag.String("parameter", "deps", "name of parameter to modify on each module")
+ targetedModules = new(identSet)
+ addIdents = new(identSet)
+ removeIdents = new(identSet)
)
func init() {
flag.Var(targetedModules, "m", "comma or whitespace separated list of modules on which to operate")
- flag.Var(targetedProperty, "parameter", "alias to -property=`name`")
- flag.Var(targetedProperty, "property", "fully qualified `name` of property to modify (default \"deps\")")
flag.Var(addIdents, "a", "comma or whitespace separated list of identifiers to add")
flag.Var(removeIdents, "r", "comma or whitespace separated list of identifiers to remove")
- flag.Var(stringPtrFlag{&setString}, "str", "set a string property")
flag.Usage = usage
}
@@ -145,80 +140,24 @@
func processModule(module *parser.Module, moduleName string,
file *parser.File) (modified bool, errs []error) {
- prop, err := getRecursiveProperty(module, targetedProperty.name(), targetedProperty.prefixes())
- if err != nil {
- return false, []error{err}
- }
- if prop == nil {
- if len(addIdents.idents) > 0 {
- // We are adding something to a non-existing list prop, so we need to create it first.
- prop, modified, err = createRecursiveProperty(module, targetedProperty.name(), targetedProperty.prefixes(), &parser.List{})
- } else if setString != nil {
- // We setting a non-existent string property, so we need to create it first.
- prop, modified, err = createRecursiveProperty(module, targetedProperty.name(), targetedProperty.prefixes(), &parser.String{})
- } else {
- // We cannot find an existing prop, and we aren't adding anything to the prop,
- // which means we must be removing something from a non-existing prop,
- // which means this is a noop.
- return false, nil
- }
- if err != nil {
- // Here should be unreachable, but still handle it for completeness.
- return false, []error{err}
+
+ for _, prop := range module.Properties {
+ if prop.Name == *parameter {
+ modified, errs = processParameter(prop.Value, *parameter, moduleName, file)
+ return
}
}
- m, errs := processParameter(prop.Value, targetedProperty.String(), moduleName, file)
- modified = modified || m
+
+ prop := parser.Property{Name: *parameter, Value: &parser.List{}}
+ modified, errs = processParameter(prop.Value, *parameter, moduleName, file)
+
+ if modified {
+ module.Properties = append(module.Properties, &prop)
+ }
+
return modified, errs
}
-func getRecursiveProperty(module *parser.Module, name string, prefixes []string) (prop *parser.Property, err error) {
- prop, _, err = getOrCreateRecursiveProperty(module, name, prefixes, nil)
- return prop, err
-}
-
-func createRecursiveProperty(module *parser.Module, name string, prefixes []string,
- empty parser.Expression) (prop *parser.Property, modified bool, err error) {
-
- return getOrCreateRecursiveProperty(module, name, prefixes, empty)
-}
-
-func getOrCreateRecursiveProperty(module *parser.Module, name string, prefixes []string,
- empty parser.Expression) (prop *parser.Property, modified bool, err error) {
- m := &module.Map
- for i, prefix := range prefixes {
- if prop, found := m.GetProperty(prefix); found {
- if mm, ok := prop.Value.Eval().(*parser.Map); ok {
- m = mm
- } else {
- // We've found a property in the AST and such property is not of type
- // *parser.Map, which must mean we didn't modify the AST.
- return nil, false, fmt.Errorf("Expected property %q to be a map, found %s",
- strings.Join(prefixes[:i+1], "."), prop.Value.Type())
- }
- } else if empty != nil {
- mm := &parser.Map{}
- m.Properties = append(m.Properties, &parser.Property{Name: prefix, Value: mm})
- m = mm
- // We've created a new node in the AST. This means the m.GetProperty(name)
- // check after this for loop must fail, because the node we inserted is an
- // empty parser.Map, thus this function will return |modified| is true.
- } else {
- return nil, false, nil
- }
- }
- if prop, found := m.GetProperty(name); found {
- // We've found a property in the AST, which must mean we didn't modify the AST.
- return prop, false, nil
- } else if empty != nil {
- prop = &parser.Property{Name: name, Value: empty}
- m.Properties = append(m.Properties, prop)
- return prop, true, nil
- } else {
- return nil, false, nil
- }
-}
-
func processParameter(value parser.Expression, paramName, moduleName string,
file *parser.File) (modified bool, errs []error) {
if _, ok := value.(*parser.Variable); ok {
@@ -231,37 +170,26 @@
paramName, moduleName)}
}
- if len(addIdents.idents) > 0 || len(removeIdents.idents) > 0 {
- list, ok := value.(*parser.List)
- if !ok {
- return false, []error{fmt.Errorf("expected parameter %s in module %s to be list, found %s",
- paramName, moduleName, value.Type().String())}
- }
+ list, ok := value.(*parser.List)
+ if !ok {
+ return false, []error{fmt.Errorf("expected parameter %s in module %s to be list, found %s",
+ paramName, moduleName, value.Type().String())}
+ }
- wasSorted := parser.ListIsSorted(list)
+ wasSorted := parser.ListIsSorted(list)
- for _, a := range addIdents.idents {
- m := parser.AddStringToList(list, a)
- modified = modified || m
- }
+ for _, a := range addIdents.idents {
+ m := parser.AddStringToList(list, a)
+ modified = modified || m
+ }
- for _, r := range removeIdents.idents {
- m := parser.RemoveStringFromList(list, r)
- modified = modified || m
- }
+ for _, r := range removeIdents.idents {
+ m := parser.RemoveStringFromList(list, r)
+ modified = modified || m
+ }
- if (wasSorted || *sortLists) && modified {
- parser.SortList(file, list)
- }
- } else if setString != nil {
- str, ok := value.(*parser.String)
- if !ok {
- return false, []error{fmt.Errorf("expected parameter %s in module %s to be string, found %s",
- paramName, moduleName, value.Type().String())}
- }
-
- str.Value = *setString
- modified = true
+ if (wasSorted || *sortLists) && modified {
+ parser.SortList(file, list)
}
return modified, nil
@@ -304,10 +232,6 @@
flag.Parse()
- if len(targetedProperty.parts) == 0 {
- targetedProperty.Set("deps")
- }
-
if flag.NArg() == 0 {
if *write {
report(fmt.Errorf("error: cannot use -w with standard input"))
@@ -324,8 +248,8 @@
return
}
- if len(addIdents.idents) == 0 && len(removeIdents.idents) == 0 && setString == nil {
- report(fmt.Errorf("-a, -r or -str parameter is required"))
+ if len(addIdents.idents) == 0 && len(removeIdents.idents) == 0 {
+ report(fmt.Errorf("-a or -r parameter is required"))
return
}
@@ -372,22 +296,6 @@
}
-type stringPtrFlag struct {
- s **string
-}
-
-func (f stringPtrFlag) Set(s string) error {
- *f.s = &s
- return nil
-}
-
-func (f stringPtrFlag) String() string {
- if f.s == nil || *f.s == nil {
- return ""
- }
- return **f.s
-}
-
type identSet struct {
idents []string
all bool
@@ -410,38 +318,3 @@
func (m *identSet) Get() interface{} {
return m.idents
}
-
-type qualifiedProperty struct {
- parts []string
-}
-
-var _ flag.Getter = (*qualifiedProperty)(nil)
-
-func (p *qualifiedProperty) name() string {
- return p.parts[len(p.parts)-1]
-}
-
-func (p *qualifiedProperty) prefixes() []string {
- return p.parts[:len(p.parts)-1]
-}
-
-func (p *qualifiedProperty) String() string {
- return strings.Join(p.parts, ".")
-}
-
-func (p *qualifiedProperty) Set(s string) error {
- p.parts = strings.Split(s, ".")
- if len(p.parts) == 0 {
- return fmt.Errorf("%q is not a valid property name", s)
- }
- for _, part := range p.parts {
- if part == "" {
- return fmt.Errorf("%q is not a valid property name", s)
- }
- }
- return nil
-}
-
-func (p *qualifiedProperty) Get() interface{} {
- return p.parts
-}
diff --git a/bpmodify/bpmodify_test.go b/bpmodify/bpmodify_test.go
deleted file mode 100644
index a92d439..0000000
--- a/bpmodify/bpmodify_test.go
+++ /dev/null
@@ -1,338 +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 main
-
-import (
- "strings"
- "testing"
-
- "github.com/google/blueprint/parser"
- "github.com/google/blueprint/proptools"
-)
-
-var testCases = []struct {
- name string
- input string
- output string
- property string
- addSet string
- removeSet string
- setString *string
-}{
- {
- name: "add",
- input: `
- cc_foo {
- name: "foo",
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- deps: ["bar"],
- }
- `,
- property: "deps",
- addSet: "bar",
- },
- {
- name: "remove",
- input: `
- cc_foo {
- name: "foo",
- deps: ["bar"],
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- deps: [],
- }
- `,
- property: "deps",
- removeSet: "bar",
- },
- {
- name: "nested add",
- input: `
- cc_foo {
- name: "foo",
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- "dep2",
- "nested_dep",],
- },
- },
- }
- `,
- property: "arch.arm.deps",
- addSet: "nested_dep,dep2",
- },
- {
- name: "nested remove",
- input: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- "dep2",
- "nested_dep",
- ],
- },
- },
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- ],
- },
- },
- }
- `,
- property: "arch.arm.deps",
- removeSet: "nested_dep,dep2",
- },
- {
- name: "add existing",
- input: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- "nested_dep",
- "dep2",
- ],
- },
- },
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- "nested_dep",
- "dep2",
- ],
- },
- },
- }
- `,
- property: "arch.arm.deps",
- addSet: "dep2,dep2",
- },
- {
- name: "remove missing",
- input: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- "nested_dep",
- "dep2",
- ],
- },
- },
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- arch: {
- arm: {
- deps: [
- "nested_dep",
- "dep2",
- ],
- },
- },
- }
- `,
- property: "arch.arm.deps",
- removeSet: "dep3,dep4",
- },
- {
- name: "remove non existent",
- input: `
- cc_foo {
- name: "foo",
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- }
- `,
- property: "deps",
- removeSet: "bar",
- },
- {
- name: "remove non existent nested",
- input: `
- cc_foo {
- name: "foo",
- arch: {},
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- arch: {},
- }
- `,
- property: "arch.arm.deps",
- removeSet: "dep3,dep4",
- },
- {
- name: "add numeric sorted",
- input: `
- cc_foo {
- name: "foo",
- versions: ["1", "2"],
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- versions: [
- "1",
- "2",
- "10",
- ],
- }
- `,
- property: "versions",
- addSet: "10",
- },
- {
- name: "add mixed sorted",
- input: `
- cc_foo {
- name: "foo",
- deps: ["bar-v1-bar", "bar-v2-bar"],
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- deps: [
- "bar-v1-bar",
- "bar-v2-bar",
- "bar-v10-bar",
- ],
- }
- `,
- property: "deps",
- addSet: "bar-v10-bar",
- },
- {
- name: "set string",
- input: `
- cc_foo {
- name: "foo",
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- foo: "bar",
- }
- `,
- property: "foo",
- setString: proptools.StringPtr("bar"),
- },
- {
- name: "set existing string",
- input: `
- cc_foo {
- name: "foo",
- foo: "baz",
- }
- `,
- output: `
- cc_foo {
- name: "foo",
- foo: "bar",
- }
- `,
- property: "foo",
- setString: proptools.StringPtr("bar"),
- },
-}
-
-func simplifyModuleDefinition(def string) string {
- var result string
- for _, line := range strings.Split(def, "\n") {
- result += strings.TrimSpace(line)
- }
- return result
-}
-
-func TestProcessModule(t *testing.T) {
- for i, testCase := range testCases {
- t.Run(testCase.name, func(t *testing.T) {
- targetedProperty.Set(testCase.property)
- addIdents.Set(testCase.addSet)
- removeIdents.Set(testCase.removeSet)
- setString = testCase.setString
-
- inAst, errs := parser.ParseAndEval("", strings.NewReader(testCase.input), parser.NewScope(nil))
- if len(errs) > 0 {
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- t.Errorf("failed to parse:")
- t.Errorf("%+v", testCase)
- t.FailNow()
- }
-
- if inModule, ok := inAst.Defs[0].(*parser.Module); !ok {
- t.Fatalf(" input must only contain a single module definition: %s", testCase.input)
- } else {
- _, errs := processModule(inModule, "", inAst)
- if len(errs) > 0 {
- t.Errorf("test case %d:", i)
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- }
- inModuleText, _ := parser.Print(inAst)
- inModuleString := string(inModuleText)
- if simplifyModuleDefinition(inModuleString) != simplifyModuleDefinition(testCase.output) {
- t.Errorf("test case %d:", i)
- t.Errorf("expected module definition:")
- t.Errorf(" %s", testCase.output)
- t.Errorf("actual module definition:")
- t.Errorf(" %s", inModuleString)
- }
- }
- })
- }
-
-}
diff --git a/context.go b/context.go
index e891c23..3018209 100644
--- a/context.go
+++ b/context.go
@@ -17,7 +17,6 @@
import (
"bytes"
"context"
- "encoding/json"
"errors"
"fmt"
"io"
@@ -111,28 +110,13 @@
// set lazily by sortedModuleGroups
cachedSortedModuleGroups []*moduleGroup
- // cache deps modified to determine whether cachedSortedModuleGroups needs to be recalculated
- cachedDepsModified bool
- globs map[globKey]pathtools.GlobResult
+ globs map[string]GlobPath
globLock sync.Mutex
srcDir string
fs pathtools.FileSystem
moduleListFile string
-
- // Mutators indexed by the ID of the provider associated with them. Not all mutators will
- // have providers, and not all providers will have a mutator, or if they do the mutator may
- // not be registered in this Context.
- providerMutators []*mutatorInfo
-
- // The currently running mutator
- startedMutator *mutatorInfo
- // True for any mutators that have already run over all modules
- finishedMutators map[*mutatorInfo]bool
-
- // Can be set by tests to avoid invalidating Module values after mutators.
- skipCloneModulesAfterMutators bool
}
// An Error describes a problem that was encountered that is related to a
@@ -175,69 +159,22 @@
}
type moduleAlias struct {
- variant variant
- target *moduleInfo
-}
-
-func (m *moduleAlias) alias() *moduleAlias { return m }
-func (m *moduleAlias) module() *moduleInfo { return nil }
-func (m *moduleAlias) moduleOrAliasTarget() *moduleInfo { return m.target }
-func (m *moduleAlias) moduleOrAliasVariant() variant { return m.variant }
-
-func (m *moduleInfo) alias() *moduleAlias { return nil }
-func (m *moduleInfo) module() *moduleInfo { return m }
-func (m *moduleInfo) moduleOrAliasTarget() *moduleInfo { return m }
-func (m *moduleInfo) moduleOrAliasVariant() variant { return m.variant }
-
-type moduleOrAlias interface {
- alias() *moduleAlias
- module() *moduleInfo
- moduleOrAliasTarget() *moduleInfo
- moduleOrAliasVariant() variant
-}
-
-type modulesOrAliases []moduleOrAlias
-
-func (l modulesOrAliases) firstModule() *moduleInfo {
- for _, moduleOrAlias := range l {
- if m := moduleOrAlias.module(); m != nil {
- return m
- }
- }
- panic(fmt.Errorf("no first module!"))
-}
-
-func (l modulesOrAliases) lastModule() *moduleInfo {
- for i := range l {
- if m := l[len(l)-1-i].module(); m != nil {
- return m
- }
- }
- panic(fmt.Errorf("no last module!"))
+ variantName string
+ variant variationMap
+ dependencyVariant variationMap
+ target *moduleInfo
}
type moduleGroup struct {
name string
ninjaName string
- modules modulesOrAliases
+ modules []*moduleInfo
+ aliases []*moduleAlias
namespace Namespace
}
-func (group *moduleGroup) moduleOrAliasByVariantName(name string) moduleOrAlias {
- for _, module := range group.modules {
- if module.moduleOrAliasVariant().name == name {
- return module
- }
- }
- return nil
-}
-
-func (group *moduleGroup) moduleByVariantName(name string) *moduleInfo {
- return group.moduleOrAliasByVariantName(name).module()
-}
-
type moduleInfo struct {
// set during Parse
typeName string
@@ -247,7 +184,9 @@
propertyPos map[string]scanner.Position
createdBy *moduleInfo
- variant variant
+ variantName string
+ variant variationMap
+ dependencyVariant variationMap
logicModule Module
group *moduleGroup
@@ -262,28 +201,15 @@
forwardDeps []*moduleInfo
directDeps []depInfo
- // used by parallelVisit
+ // used by parallelVisitAllBottomUp
waitingCount int
// set during each runMutator
- splitModules modulesOrAliases
+ splitModules []*moduleInfo
+ aliasTarget *moduleInfo
// set during PrepareBuildActions
actionDefs localBuildActions
-
- providers []interface{}
-
- startedMutator *mutatorInfo
- finishedMutator *mutatorInfo
-
- startedGenerateBuildActions bool
- finishedGenerateBuildActions bool
-}
-
-type variant struct {
- name string
- variations variationMap
- dependencyVariations variationMap
}
type depInfo struct {
@@ -306,8 +232,8 @@
func (module *moduleInfo) String() string {
s := fmt.Sprintf("module %q", module.Name())
- if module.variant.name != "" {
- s += fmt.Sprintf(" variant %q", module.variant.name)
+ if module.variantName != "" {
+ s += fmt.Sprintf(" variant %q", module.variantName)
}
if module.createdBy != nil {
s += fmt.Sprintf(" (created by %s)", module.createdBy)
@@ -347,10 +273,10 @@
}
// Compare this variationMap to another one. Returns true if the every entry in this map
-// exists and has the same value in the other map.
-func (vm variationMap) subsetOf(other variationMap) bool {
+// is either the same in the other map or doesn't exist in the other map.
+func (vm variationMap) subset(other variationMap) bool {
for k, v1 := range vm {
- if v2, ok := other[k]; !ok || v1 != v2 {
+ if v2, ok := other[k]; ok && v1 != v2 {
return false
}
}
@@ -385,9 +311,8 @@
moduleFactories: make(map[string]ModuleFactory),
nameInterface: NewSimpleNameInterface(),
moduleInfo: make(map[Module]*moduleInfo),
- globs: make(map[globKey]pathtools.GlobResult),
+ globs: make(map[string]GlobPath),
fs: pathtools.OsFs,
- finishedMutators: make(map[*mutatorInfo]bool),
ninjaBuildDir: nil,
requiredNinjaMajor: 1,
requiredNinjaMinor: 7,
@@ -747,7 +672,6 @@
type newModuleInfo struct {
*moduleInfo
- deps []string
added chan<- struct{}
}
@@ -773,12 +697,12 @@
// registered by name. This allows load hooks to set and/or modify any aspect
// of the module (including names) using information that is not available when
// the module factory is called.
- newModules, newDeps, errs := runAndRemoveLoadHooks(c, config, module, &scopedModuleFactories)
+ newModules, errs := runAndRemoveLoadHooks(c, config, module, &scopedModuleFactories)
if len(errs) > 0 {
return errs
}
- moduleCh <- newModuleInfo{module, newDeps, addedCh}
+ moduleCh <- newModuleInfo{module, addedCh}
<-addedCh
for _, n := range newModules {
errs = addModule(n)
@@ -821,7 +745,6 @@
doneCh <- struct{}{}
}()
- var hookDeps []string
loop:
for {
select {
@@ -829,7 +752,6 @@
errs = append(errs, newErrs...)
case module := <-moduleCh:
newErrs := c.addModule(module.moduleInfo)
- hookDeps = append(hookDeps, module.deps...)
if module.added != nil {
module.added <- struct{}{}
}
@@ -844,7 +766,6 @@
}
}
- deps = append(deps, hookDeps...)
return deps, errs
}
@@ -1303,44 +1224,15 @@
return newLogicModule, newProperties
}
-func newVariant(module *moduleInfo, mutatorName string, variationName string,
- local bool) variant {
-
- newVariantName := module.variant.name
- if variationName != "" {
- if newVariantName == "" {
- newVariantName = variationName
- } else {
- newVariantName += "_" + variationName
- }
- }
-
- newVariations := module.variant.variations.clone()
- if newVariations == nil {
- newVariations = make(variationMap)
- }
- newVariations[mutatorName] = variationName
-
- newDependencyVariations := module.variant.dependencyVariations.clone()
- if !local {
- if newDependencyVariations == nil {
- newDependencyVariations = make(variationMap)
- }
- newDependencyVariations[mutatorName] = variationName
- }
-
- return variant{newVariantName, newVariations, newDependencyVariations}
-}
-
func (c *Context) createVariations(origModule *moduleInfo, mutatorName string,
- defaultVariationName *string, variationNames []string, local bool) (modulesOrAliases, []error) {
+ defaultVariationName *string, variationNames []string) ([]*moduleInfo, []error) {
if len(variationNames) == 0 {
panic(fmt.Errorf("mutator %q passed zero-length variation list for module %q",
mutatorName, origModule.Name()))
}
- var newModules modulesOrAliases
+ newModules := []*moduleInfo{}
var errs []error
@@ -1357,15 +1249,27 @@
newLogicModule, newProperties = c.cloneLogicModule(origModule)
}
+ newVariant := origModule.variant.clone()
+ if newVariant == nil {
+ newVariant = make(variationMap)
+ }
+ newVariant[mutatorName] = variationName
+
m := *origModule
newModule := &m
- newModule.directDeps = append([]depInfo(nil), origModule.directDeps...)
- newModule.reverseDeps = nil
- newModule.forwardDeps = nil
+ newModule.directDeps = append([]depInfo{}, origModule.directDeps...)
newModule.logicModule = newLogicModule
- newModule.variant = newVariant(origModule, mutatorName, variationName, local)
+ newModule.variant = newVariant
+ newModule.dependencyVariant = origModule.dependencyVariant.clone()
newModule.properties = newProperties
- newModule.providers = append([]interface{}(nil), origModule.providers...)
+
+ if variationName != "" {
+ if newModule.variantName == "" {
+ newModule.variantName = variationName
+ } else {
+ newModule.variantName += "_" + variationName
+ }
+ }
newModules = append(newModules, newModule)
@@ -1392,16 +1296,16 @@
if dep.module.logicModule == nil {
var newDep *moduleInfo
for _, m := range dep.module.splitModules {
- if m.moduleOrAliasVariant().variations[mutatorName] == variationName {
- newDep = m.moduleOrAliasTarget()
+ if m.variant[mutatorName] == variationName {
+ newDep = m
break
}
}
if newDep == nil && defaultVariationName != nil {
// give it a second chance; match with defaultVariationName
for _, m := range dep.module.splitModules {
- if m.moduleOrAliasVariant().variations[mutatorName] == *defaultVariationName {
- newDep = m.moduleOrAliasTarget()
+ if m.variant[mutatorName] == *defaultVariationName {
+ newDep = m
break
}
}
@@ -1421,27 +1325,27 @@
return errs
}
-func (c *Context) prettyPrintVariant(variations variationMap) string {
- names := make([]string, 0, len(variations))
+func (c *Context) prettyPrintVariant(variant variationMap) string {
+ names := make([]string, 0, len(variant))
for _, m := range c.variantMutatorNames {
- if v, ok := variations[m]; ok {
+ if v, ok := variant[m]; ok {
names = append(names, m+":"+v)
}
}
- return strings.Join(names, ",")
+ return strings.Join(names, ", ")
}
func (c *Context) prettyPrintGroupVariants(group *moduleGroup) string {
var variants []string
- for _, moduleOrAlias := range group.modules {
- if mod := moduleOrAlias.module(); mod != nil {
- variants = append(variants, c.prettyPrintVariant(mod.variant.variations))
- } else if alias := moduleOrAlias.alias(); alias != nil {
- variants = append(variants, c.prettyPrintVariant(alias.variant.variations)+
- " (alias to "+c.prettyPrintVariant(alias.target.variant.variations)+")")
- }
+ for _, mod := range group.modules {
+ variants = append(variants, c.prettyPrintVariant(mod.variant))
}
+ for _, mod := range group.aliases {
+ variants = append(variants, c.prettyPrintVariant(mod.variant)+
+ "(alias to "+c.prettyPrintVariant(mod.target.variant)+")")
+ }
+ sort.Strings(variants)
return strings.Join(variants, "\n ")
}
@@ -1520,7 +1424,7 @@
group := &moduleGroup{
name: name,
- modules: modulesOrAliases{module},
+ modules: []*moduleInfo{module},
}
module.group = group
namespace, errs := c.nameInterface.NewModule(
@@ -1550,8 +1454,6 @@
func (c *Context) resolveDependencies(ctx context.Context, config interface{}) (deps []string, errs []error) {
pprof.Do(ctx, pprof.Labels("blueprint", "ResolveDependencies"), func(ctx context.Context) {
- c.initProviders()
-
c.liveGlobals = newLiveTracker(config)
deps, errs = c.generateSingletonBuildActions(config, c.preSingletonInfo, c.liveGlobals)
@@ -1571,9 +1473,7 @@
}
deps = append(deps, mutatorDeps...)
- if !c.skipCloneModulesAfterMutators {
- c.cloneModules()
- }
+ c.cloneModules()
c.dependenciesReady = true
})
@@ -1608,32 +1508,43 @@
}
}
-// findExactVariantOrSingle searches the moduleGroup for a module with the same variant as module,
-// and returns the matching module, or nil if one is not found. A group with exactly one module
-// is always considered matching.
-func findExactVariantOrSingle(module *moduleInfo, possible *moduleGroup, reverse bool) *moduleInfo {
- found, _ := findVariant(module, possible, nil, false, reverse)
- if found == nil {
- for _, moduleOrAlias := range possible.modules {
- if m := moduleOrAlias.module(); m != nil {
- if found != nil {
- // more than one possible match, give up
- return nil
- }
- found = m
+// findMatchingVariant searches the moduleGroup for a module with the same variant as module,
+// and returns the matching module, or nil if one is not found.
+func (c *Context) findMatchingVariant(module *moduleInfo, possible *moduleGroup, reverse bool) *moduleInfo {
+ if len(possible.modules) == 1 {
+ return possible.modules[0]
+ } else {
+ var variantToMatch variationMap
+ if !reverse {
+ // For forward dependency, ignore local variants by matching against
+ // dependencyVariant which doesn't have the local variants
+ variantToMatch = module.dependencyVariant
+ } else {
+ // For reverse dependency, use all the variants
+ variantToMatch = module.variant
+ }
+ for _, m := range possible.modules {
+ if m.variant.equal(variantToMatch) {
+ return m
+ }
+ }
+ for _, m := range possible.aliases {
+ if m.variant.equal(variantToMatch) {
+ return m.target
}
}
}
- return found
+
+ return nil
}
-func (c *Context) addDependency(module *moduleInfo, tag DependencyTag, depName string) (*moduleInfo, []error) {
+func (c *Context) addDependency(module *moduleInfo, tag DependencyTag, depName string) []error {
if _, ok := tag.(BaseDependencyTag); ok {
panic("BaseDependencyTag is not allowed to be used directly!")
}
if depName == module.Name() {
- return nil, []error{&BlueprintError{
+ return []error{&BlueprintError{
Err: fmt.Errorf("%q depends on itself", depName),
Pos: module.pos,
}}
@@ -1641,24 +1552,24 @@
possibleDeps := c.moduleGroupFromName(depName, module.namespace())
if possibleDeps == nil {
- return nil, c.discoveredMissingDependencies(module, depName, nil)
+ return c.discoveredMissingDependencies(module, depName)
}
- if m := findExactVariantOrSingle(module, possibleDeps, false); m != nil {
+ if m := c.findMatchingVariant(module, possibleDeps, false); m != nil {
module.newDirectDeps = append(module.newDirectDeps, depInfo{m, tag})
atomic.AddUint32(&c.depsModified, 1)
- return m, nil
+ return nil
}
if c.allowMissingDependencies {
// Allow missing variants.
- return nil, c.discoveredMissingDependencies(module, depName, module.variant.dependencyVariations)
+ return c.discoveredMissingDependencies(module, depName+c.prettyPrintVariant(module.dependencyVariant))
}
- return nil, []error{&BlueprintError{
+ return []error{&BlueprintError{
Err: fmt.Errorf("dependency %q of %q missing variant:\n %s\navailable variants:\n %s",
depName, module.Name(),
- c.prettyPrintVariant(module.variant.dependencyVariations),
+ c.prettyPrintVariant(module.dependencyVariant),
c.prettyPrintGroupVariants(possibleDeps)),
Pos: module.pos,
}}
@@ -1681,38 +1592,41 @@
}}
}
- if m := findExactVariantOrSingle(module, possibleDeps, true); m != nil {
+ if m := c.findMatchingVariant(module, possibleDeps, true); m != nil {
return m, nil
}
if c.allowMissingDependencies {
// Allow missing variants.
- return module, c.discoveredMissingDependencies(module, destName, module.variant.dependencyVariations)
+ return module, c.discoveredMissingDependencies(module, destName+c.prettyPrintVariant(module.dependencyVariant))
}
return nil, []error{&BlueprintError{
Err: fmt.Errorf("reverse dependency %q of %q missing variant:\n %s\navailable variants:\n %s",
destName, module.Name(),
- c.prettyPrintVariant(module.variant.dependencyVariations),
+ c.prettyPrintVariant(module.dependencyVariant),
c.prettyPrintGroupVariants(possibleDeps)),
Pos: module.pos,
}}
}
-func findVariant(module *moduleInfo, possibleDeps *moduleGroup, variations []Variation, far bool, reverse bool) (*moduleInfo, variationMap) {
- // We can't just append variant.Variant to module.dependencyVariant.variantName and
+func (c *Context) addVariationDependency(module *moduleInfo, variations []Variation,
+ tag DependencyTag, depName string, far bool) []error {
+ if _, ok := tag.(BaseDependencyTag); ok {
+ panic("BaseDependencyTag is not allowed to be used directly!")
+ }
+
+ possibleDeps := c.moduleGroupFromName(depName, module.namespace())
+ if possibleDeps == nil {
+ return c.discoveredMissingDependencies(module, depName)
+ }
+
+ // We can't just append variant.Variant to module.dependencyVariants.variantName and
// compare the strings because the result won't be in mutator registration order.
// Create a new map instead, and then deep compare the maps.
var newVariant variationMap
if !far {
- if !reverse {
- // For forward dependency, ignore local variants by matching against
- // dependencyVariant which doesn't have the local variants
- newVariant = module.variant.dependencyVariations.clone()
- } else {
- // For reverse dependency, use all the variants
- newVariant = module.variant.variations.clone()
- }
+ newVariant = module.dependencyVariant.clone()
}
for _, v := range variations {
if newVariant == nil {
@@ -1723,7 +1637,7 @@
check := func(variant variationMap) bool {
if far {
- return newVariant.subsetOf(variant)
+ return variant.subset(newVariant)
} else {
return variant.equal(newVariant)
}
@@ -1731,34 +1645,27 @@
var foundDep *moduleInfo
for _, m := range possibleDeps.modules {
- if check(m.moduleOrAliasVariant().variations) {
- foundDep = m.moduleOrAliasTarget()
+ if check(m.variant) {
+ foundDep = m
break
}
}
- return foundDep, newVariant
-}
-
-func (c *Context) addVariationDependency(module *moduleInfo, variations []Variation,
- tag DependencyTag, depName string, far bool) (*moduleInfo, []error) {
- if _, ok := tag.(BaseDependencyTag); ok {
- panic("BaseDependencyTag is not allowed to be used directly!")
+ if foundDep == nil {
+ for _, m := range possibleDeps.aliases {
+ if check(m.variant) {
+ foundDep = m.target
+ break
+ }
+ }
}
- possibleDeps := c.moduleGroupFromName(depName, module.namespace())
- if possibleDeps == nil {
- return nil, c.discoveredMissingDependencies(module, depName, nil)
- }
-
- foundDep, newVariant := findVariant(module, possibleDeps, variations, far, false)
-
if foundDep == nil {
if c.allowMissingDependencies {
// Allow missing variants.
- return nil, c.discoveredMissingDependencies(module, depName, newVariant)
+ return c.discoveredMissingDependencies(module, depName+c.prettyPrintVariant(newVariant))
}
- return nil, []error{&BlueprintError{
+ return []error{&BlueprintError{
Err: fmt.Errorf("dependency %q of %q missing variant:\n %s\navailable variants:\n %s",
depName, module.Name(),
c.prettyPrintVariant(newVariant),
@@ -1768,7 +1675,7 @@
}
if module == foundDep {
- return nil, []error{&BlueprintError{
+ return []error{&BlueprintError{
Err: fmt.Errorf("%q depends on itself", depName),
Pos: module.pos,
}}
@@ -1777,33 +1684,31 @@
// that module is earlier in the module list than this one, since we always
// run GenerateBuildActions in order for the variants of a module
if foundDep.group == module.group && beforeInModuleList(module, foundDep, module.group.modules) {
- return nil, []error{&BlueprintError{
+ return []error{&BlueprintError{
Err: fmt.Errorf("%q depends on later version of itself", depName),
Pos: module.pos,
}}
}
module.newDirectDeps = append(module.newDirectDeps, depInfo{foundDep, tag})
atomic.AddUint32(&c.depsModified, 1)
- return foundDep, nil
+ return nil
}
func (c *Context) addInterVariantDependency(origModule *moduleInfo, tag DependencyTag,
- from, to Module) *moduleInfo {
+ from, to Module) {
if _, ok := tag.(BaseDependencyTag); ok {
panic("BaseDependencyTag is not allowed to be used directly!")
}
var fromInfo, toInfo *moduleInfo
- for _, moduleOrAlias := range origModule.splitModules {
- if m := moduleOrAlias.module(); m != nil {
- if m.logicModule == from {
- fromInfo = m
- }
- if m.logicModule == to {
- toInfo = m
- if fromInfo != nil {
- panic(fmt.Errorf("%q depends on later version of itself", origModule.Name()))
- }
+ for _, m := range origModule.splitModules {
+ if m.logicModule == from {
+ fromInfo = m
+ }
+ if m.logicModule == to {
+ toInfo = m
+ if fromInfo != nil {
+ panic(fmt.Errorf("%q depends on later version of itself", origModule.Name()))
}
}
}
@@ -1815,7 +1720,6 @@
fromInfo.newDirectDeps = append(fromInfo.newDirectDeps, depInfo{toInfo, tag})
atomic.AddUint32(&c.depsModified, 1)
- return toInfo
}
// findBlueprintDescendants returns a map linking parent Blueprints files to child Blueprints files
@@ -1864,7 +1768,7 @@
// returns the list of modules that are waiting for this module
propagate(module *moduleInfo) []*moduleInfo
// visit modules in order
- visit(modules []*moduleInfo, visit func(*moduleInfo, chan<- pauseSpec) bool)
+ visit(modules []*moduleInfo, visit func(*moduleInfo) bool)
}
type unorderedVisitorImpl struct{}
@@ -1877,9 +1781,9 @@
return nil
}
-func (unorderedVisitorImpl) visit(modules []*moduleInfo, visit func(*moduleInfo, chan<- pauseSpec) bool) {
+func (unorderedVisitorImpl) visit(modules []*moduleInfo, visit func(*moduleInfo) bool) {
for _, module := range modules {
- if visit(module, nil) {
+ if visit(module) {
return
}
}
@@ -1895,9 +1799,9 @@
return module.reverseDeps
}
-func (bottomUpVisitorImpl) visit(modules []*moduleInfo, visit func(*moduleInfo, chan<- pauseSpec) bool) {
+func (bottomUpVisitorImpl) visit(modules []*moduleInfo, visit func(*moduleInfo) bool) {
for _, module := range modules {
- if visit(module, nil) {
+ if visit(module) {
return
}
}
@@ -1913,10 +1817,10 @@
return module.forwardDeps
}
-func (topDownVisitorImpl) visit(modules []*moduleInfo, visit func(*moduleInfo, chan<- pauseSpec) bool) {
+func (topDownVisitorImpl) visit(modules []*moduleInfo, visit func(*moduleInfo) bool) {
for i := 0; i < len(modules); i++ {
module := modules[len(modules)-1-i]
- if visit(module, nil) {
+ if visit(module) {
return
}
}
@@ -1927,50 +1831,25 @@
topDownVisitor topDownVisitorImpl
)
-// pauseSpec describes a pause that a module needs to occur until another module has been visited,
-// at which point the unpause channel will be closed.
-type pauseSpec struct {
- paused *moduleInfo
- until *moduleInfo
- unpause unpause
-}
-
-type unpause chan struct{}
-
-const parallelVisitLimit = 1000
-
// Calls visit on each module, guaranteeing that visit is not called on a module until visit on all
-// of its dependencies has finished. A visit function can write a pauseSpec to the pause channel
-// to wait for another dependency to be visited. If a visit function returns true to cancel
-// while another visitor is paused, the paused visitor will never be resumed and its goroutine
-// will stay paused forever.
-func parallelVisit(modules []*moduleInfo, order visitOrderer, limit int,
- visit func(module *moduleInfo, pause chan<- pauseSpec) bool) []error {
-
+// of its dependencies has finished.
+func (c *Context) parallelVisit(order visitOrderer, visit func(group *moduleInfo) bool) {
doneCh := make(chan *moduleInfo)
cancelCh := make(chan bool)
- pauseCh := make(chan pauseSpec)
+ count := 0
cancel := false
+ var backlog []*moduleInfo
+ const limit = 1000
- var backlog []*moduleInfo // Visitors that are ready to start but backlogged due to limit.
- var unpauseBacklog []pauseSpec // Visitors that are ready to unpause but backlogged due to limit.
-
- active := 0 // Number of visitors running, not counting paused visitors.
- visited := 0 // Number of finished visitors.
-
- pauseMap := make(map[*moduleInfo][]pauseSpec)
-
- for _, module := range modules {
+ for _, module := range c.modulesSorted {
module.waitingCount = order.waitCount(module)
}
- // Call the visitor on a module if there are fewer active visitors than the parallelism
- // limit, otherwise add it to the backlog.
- startOrBacklog := func(module *moduleInfo) {
- if active < limit {
- active++
+ visitOne := func(module *moduleInfo) {
+ if count < limit {
+ count++
go func() {
- ret := visit(module, pauseCh)
+ ret := visit(module)
if ret {
cancelCh <- true
}
@@ -1981,195 +1860,34 @@
}
}
- // Unpause the already-started but paused visitor on a module if there are fewer active
- // visitors than the parallelism limit, otherwise add it to the backlog.
- unpauseOrBacklog := func(pauseSpec pauseSpec) {
- if active < limit {
- active++
- close(pauseSpec.unpause)
- } else {
- unpauseBacklog = append(unpauseBacklog, pauseSpec)
- }
- }
-
- // Start any modules in the backlog up to the parallelism limit. Unpause paused modules first
- // since they may already be holding resources.
- unpauseOrStartFromBacklog := func() {
- for active < limit && len(unpauseBacklog) > 0 {
- unpause := unpauseBacklog[0]
- unpauseBacklog = unpauseBacklog[1:]
- unpauseOrBacklog(unpause)
- }
- for active < limit && len(backlog) > 0 {
- toVisit := backlog[0]
- backlog = backlog[1:]
- startOrBacklog(toVisit)
- }
- }
-
- toVisit := len(modules)
-
- // Start or backlog any modules that are not waiting for any other modules.
- for _, module := range modules {
+ for _, module := range c.modulesSorted {
if module.waitingCount == 0 {
- startOrBacklog(module)
+ visitOne(module)
}
}
- for active > 0 {
+ for count > 0 || len(backlog) > 0 {
select {
case <-cancelCh:
cancel = true
backlog = nil
case doneModule := <-doneCh:
- active--
+ count--
if !cancel {
- // Mark this module as done.
- doneModule.waitingCount = -1
- visited++
-
- // Unpause or backlog any modules that were waiting for this one.
- if unpauses, ok := pauseMap[doneModule]; ok {
- delete(pauseMap, doneModule)
- for _, unpause := range unpauses {
- unpauseOrBacklog(unpause)
- }
+ for count < limit && len(backlog) > 0 {
+ toVisit := backlog[0]
+ backlog = backlog[1:]
+ visitOne(toVisit)
}
-
- // Start any backlogged modules up to limit.
- unpauseOrStartFromBacklog()
-
- // Decrement waitingCount on the next modules in the tree based
- // on propagation order, and start or backlog them if they are
- // ready to start.
for _, module := range order.propagate(doneModule) {
module.waitingCount--
if module.waitingCount == 0 {
- startOrBacklog(module)
+ visitOne(module)
}
}
}
- case pauseSpec := <-pauseCh:
- if pauseSpec.until.waitingCount == -1 {
- // Module being paused for is already finished, resume immediately.
- close(pauseSpec.unpause)
- } else {
- // Register for unpausing.
- pauseMap[pauseSpec.until] = append(pauseMap[pauseSpec.until], pauseSpec)
-
- // Don't count paused visitors as active so that this can't deadlock
- // if 1000 visitors are paused simultaneously.
- active--
- unpauseOrStartFromBacklog()
- }
}
}
-
- if !cancel {
- // Invariant check: no backlogged modules, these weren't waiting on anything except
- // the parallelism limit so they should have run.
- if len(backlog) > 0 {
- panic(fmt.Errorf("parallelVisit finished with %d backlogged visitors", len(backlog)))
- }
-
- // Invariant check: no backlogged paused modules, these weren't waiting on anything
- // except the parallelism limit so they should have run.
- if len(unpauseBacklog) > 0 {
- panic(fmt.Errorf("parallelVisit finished with %d backlogged unpaused visitors", len(unpauseBacklog)))
- }
-
- if len(pauseMap) > 0 {
- // Probably a deadlock due to a newly added dependency cycle. Start from each module in
- // the order of the input modules list and perform a depth-first search for the module
- // it is paused on, ignoring modules that are marked as done. Note this traverses from
- // modules to the modules that would have been unblocked when that module finished, i.e
- // the reverse of the visitOrderer.
-
- // In order to reduce duplicated work, once a module has been checked and determined
- // not to be part of a cycle add it and everything that depends on it to the checked
- // map.
- checked := make(map[*moduleInfo]struct{})
-
- var check func(module, end *moduleInfo) []*moduleInfo
- check = func(module, end *moduleInfo) []*moduleInfo {
- if module.waitingCount == -1 {
- // This module was finished, it can't be part of a loop.
- return nil
- }
- if module == end {
- // This module is the end of the loop, start rolling up the cycle.
- return []*moduleInfo{module}
- }
-
- if _, alreadyChecked := checked[module]; alreadyChecked {
- return nil
- }
-
- for _, dep := range order.propagate(module) {
- cycle := check(dep, end)
- if cycle != nil {
- return append([]*moduleInfo{module}, cycle...)
- }
- }
- for _, depPauseSpec := range pauseMap[module] {
- cycle := check(depPauseSpec.paused, end)
- if cycle != nil {
- return append([]*moduleInfo{module}, cycle...)
- }
- }
-
- checked[module] = struct{}{}
- return nil
- }
-
- // Iterate over the modules list instead of pauseMap to provide deterministic ordering.
- for _, module := range modules {
- for _, pauseSpec := range pauseMap[module] {
- cycle := check(pauseSpec.paused, pauseSpec.until)
- if len(cycle) > 0 {
- return cycleError(cycle)
- }
- }
- }
- }
-
- // Invariant check: if there was no deadlock and no cancellation every module
- // should have been visited.
- if visited != toVisit {
- panic(fmt.Errorf("parallelVisit ran %d visitors, expected %d", visited, toVisit))
- }
-
- // Invariant check: if there was no deadlock and no cancellation every module
- // should have been visited, so there is nothing left to be paused on.
- if len(pauseMap) > 0 {
- panic(fmt.Errorf("parallelVisit finished with %d paused visitors", len(pauseMap)))
- }
- }
-
- return nil
-}
-
-func cycleError(cycle []*moduleInfo) (errs []error) {
- // The cycle list is in reverse order because all the 'check' calls append
- // their own module to the list.
- errs = append(errs, &BlueprintError{
- Err: fmt.Errorf("encountered dependency cycle:"),
- Pos: cycle[len(cycle)-1].pos,
- })
-
- // Iterate backwards through the cycle list.
- curModule := cycle[0]
- for i := len(cycle) - 1; i >= 0; i-- {
- nextModule := cycle[i]
- errs = append(errs, &BlueprintError{
- Err: fmt.Errorf(" %s depends on %s",
- curModule, nextModule),
- Pos: curModule.pos,
- })
- curModule = nextModule
- }
-
- return errs
}
// updateDependencies recursively walks the module dependency graph and updates
@@ -2179,7 +1897,6 @@
// it encounters dependency cycles. This should called after resolveDependencies,
// as well as after any mutator pass has called addDependency
func (c *Context) updateDependencies() (errs []error) {
- c.cachedDepsModified = true
visited := make(map[*moduleInfo]bool) // modules that were already checked
checking := make(map[*moduleInfo]bool) // modules actively being checked
@@ -2187,37 +1904,53 @@
var check func(group *moduleInfo) []*moduleInfo
+ cycleError := func(cycle []*moduleInfo) {
+ // We are the "start" of the cycle, so we're responsible
+ // for generating the errors. The cycle list is in
+ // reverse order because all the 'check' calls append
+ // their own module to the list.
+ errs = append(errs, &BlueprintError{
+ Err: fmt.Errorf("encountered dependency cycle:"),
+ Pos: cycle[len(cycle)-1].pos,
+ })
+
+ // Iterate backwards through the cycle list.
+ curModule := cycle[0]
+ for i := len(cycle) - 1; i >= 0; i-- {
+ nextModule := cycle[i]
+ errs = append(errs, &BlueprintError{
+ Err: fmt.Errorf(" %q depends on %q",
+ curModule.Name(),
+ nextModule.Name()),
+ Pos: curModule.pos,
+ })
+ curModule = nextModule
+ }
+ }
+
check = func(module *moduleInfo) []*moduleInfo {
visited[module] = true
checking[module] = true
defer delete(checking, module)
- // Reset the forward and reverse deps without reducing their capacity to avoid reallocation.
- module.reverseDeps = module.reverseDeps[:0]
- module.forwardDeps = module.forwardDeps[:0]
+ deps := make(map[*moduleInfo]bool)
// Add an implicit dependency ordering on all earlier modules in the same module group
for _, dep := range module.group.modules {
if dep == module {
break
}
- if depModule := dep.module(); depModule != nil {
- module.forwardDeps = append(module.forwardDeps, depModule)
- }
+ deps[dep] = true
}
- outer:
for _, dep := range module.directDeps {
- // use a loop to check for duplicates, average number of directDeps measured to be 9.5.
- for _, exists := range module.forwardDeps {
- if dep.module == exists {
- continue outer
- }
- }
- module.forwardDeps = append(module.forwardDeps, dep.module)
+ deps[dep.module] = true
}
- for _, dep := range module.forwardDeps {
+ module.reverseDeps = []*moduleInfo{}
+ module.forwardDeps = []*moduleInfo{}
+
+ for dep := range deps {
if checking[dep] {
// This is a cycle.
return []*moduleInfo{dep, module}
@@ -2228,8 +1961,10 @@
if cycle != nil {
if cycle[0] == module {
// We are the "start" of the cycle, so we're responsible
- // for generating the errors.
- errs = append(errs, cycleError(cycle)...)
+ // for generating the errors. The cycle list is in
+ // reverse order because all the 'check' calls append
+ // their own module to the list.
+ cycleError(cycle)
// We can continue processing this module's children to
// find more cycles. Since all the modules that were
@@ -2243,6 +1978,7 @@
}
}
+ module.forwardDeps = append(module.forwardDeps, dep)
dep.reverseDeps = append(dep.reverseDeps, module)
}
@@ -2258,7 +1994,7 @@
if cycle[len(cycle)-1] != module {
panic("inconceivable!")
}
- errs = append(errs, cycleError(cycle)...)
+ cycleError(cycle)
}
}
}
@@ -2268,64 +2004,6 @@
return
}
-type jsonVariationMap map[string]string
-
-type jsonModuleName struct {
- Name string
- Variations jsonVariationMap
- DependencyVariations jsonVariationMap
-}
-
-type jsonDep struct {
- jsonModuleName
- Tag string
-}
-
-type jsonModule struct {
- jsonModuleName
- Deps []jsonDep
- Type string
- Blueprint string
-}
-
-func toJsonVariationMap(vm variationMap) jsonVariationMap {
- return jsonVariationMap(vm)
-}
-
-func jsonModuleNameFromModuleInfo(m *moduleInfo) *jsonModuleName {
- return &jsonModuleName{
- Name: m.Name(),
- Variations: toJsonVariationMap(m.variant.variations),
- DependencyVariations: toJsonVariationMap(m.variant.dependencyVariations),
- }
-}
-
-func jsonModuleFromModuleInfo(m *moduleInfo) *jsonModule {
- return &jsonModule{
- jsonModuleName: *jsonModuleNameFromModuleInfo(m),
- Deps: make([]jsonDep, 0),
- Type: m.typeName,
- Blueprint: m.relBlueprintsFile,
- }
-}
-
-func (c *Context) PrintJSONGraph(w io.Writer) {
- modules := make([]*jsonModule, 0)
- for _, m := range c.modulesSorted {
- jm := jsonModuleFromModuleInfo(m)
- for _, d := range m.directDeps {
- jm.Deps = append(jm.Deps, jsonDep{
- jsonModuleName: *jsonModuleNameFromModuleInfo(d.module),
- Tag: fmt.Sprintf("%T %+v", d.tag, d.tag),
- })
- }
-
- modules = append(modules, jm)
- }
-
- json.NewEncoder(w).Encode(modules)
-}
-
// PrepareBuildActions generates an internal representation of all the build
// actions that need to be performed. This process involves invoking the
// GenerateBuildActions method on each of the Module objects created during the
@@ -2344,7 +2022,6 @@
// by the modules and singletons via the ModuleContext.AddNinjaFileDeps(),
// SingletonContext.AddNinjaFileDeps(), and PackageContext.AddNinjaFileDeps()
// methods.
-
func (c *Context) PrepareBuildActions(config interface{}) (deps []string, errs []error) {
pprof.Do(c.Context, pprof.Labels("blueprint", "PrepareBuildActions"), func(ctx context.Context) {
c.buildActionsReady = false
@@ -2385,8 +2062,6 @@
deps = append(deps, depsPackages...)
- c.memoizeFullNames(c.liveGlobals, pkgNames)
-
// This will panic if it finds a problem since it's a programming error.
c.checkForVariableReferenceCycles(c.liveGlobals.variables, pkgNames)
@@ -2507,12 +2182,12 @@
errsCh := make(chan []error)
globalStateCh := make(chan globalStateChange)
- newVariationsCh := make(chan modulesOrAliases)
+ newVariationsCh := make(chan []*moduleInfo)
done := make(chan bool)
c.depsModified = 0
- visit := func(module *moduleInfo, pause chan<- pauseSpec) bool {
+ visit := func(module *moduleInfo) bool {
if module.splitModules != nil {
panic("split module found in sorted module list")
}
@@ -2523,12 +2198,9 @@
config: config,
module: module,
},
- name: mutator.name,
- pauseCh: pause,
+ name: mutator.name,
}
- module.startedMutator = mutator
-
func() {
defer func() {
if r := recover(); r != nil {
@@ -2544,8 +2216,6 @@
direction.run(mutator, mctx)
}()
- module.finishedMutator = mutator
-
if len(mctx.errs) > 0 {
errsCh <- mctx.errs
return true
@@ -2583,10 +2253,8 @@
newModules = append(newModules, globalStateChange.newModules...)
deps = append(deps, globalStateChange.deps...)
case newVariations := <-newVariationsCh:
- for _, moduleOrAlias := range newVariations {
- if m := moduleOrAlias.module(); m != nil {
- newModuleInfo[m.logicModule] = m
- }
+ for _, m := range newVariations {
+ newModuleInfo[m.logicModule] = m
}
case <-done:
return
@@ -2594,21 +2262,12 @@
}
}()
- c.startedMutator = mutator
-
- var visitErrs []error
if mutator.parallel {
- visitErrs = parallelVisit(c.modulesSorted, direction.orderer(), parallelVisitLimit, visit)
+ c.parallelVisit(direction.orderer(), visit)
} else {
direction.orderer().visit(c.modulesSorted, visit)
}
- if len(visitErrs) > 0 {
- return nil, visitErrs
- }
-
- c.finishedMutators[mutator] = true
-
done <- true
if len(errs) > 0 {
@@ -2619,27 +2278,33 @@
for _, group := range c.moduleGroups {
for i := 0; i < len(group.modules); i++ {
- module := group.modules[i].module()
- if module == nil {
- // Existing alias, skip it
- continue
- }
+ module := group.modules[i]
// Update module group to contain newly split variants
if module.splitModules != nil {
group.modules, i = spliceModules(group.modules, i, module.splitModules)
}
+ // Create any new aliases.
+ if module.aliasTarget != nil {
+ group.aliases = append(group.aliases, &moduleAlias{
+ variantName: module.variantName,
+ variant: module.variant,
+ dependencyVariant: module.dependencyVariant,
+ target: module.aliasTarget,
+ })
+ }
+
// Fix up any remaining dependencies on modules that were split into variants
// by replacing them with the first variant
for j, dep := range module.directDeps {
if dep.module.logicModule == nil {
- module.directDeps[j].module = dep.module.splitModules.firstModule()
+ module.directDeps[j].module = dep.module.splitModules[0]
}
}
if module.createdBy != nil && module.createdBy.logicModule == nil {
- module.createdBy = module.createdBy.splitModules.firstModule()
+ module.createdBy = module.createdBy.splitModules[0]
}
// Add in any new direct dependencies that were added by the mutator
@@ -2647,31 +2312,17 @@
module.newDirectDeps = nil
}
- findAliasTarget := func(variant variant) *moduleInfo {
- for _, moduleOrAlias := range group.modules {
- if alias := moduleOrAlias.alias(); alias != nil {
- if alias.variant.variations.equal(variant.variations) {
- return alias.target
- }
- }
- }
- return nil
- }
-
// Forward or delete any dangling aliases.
- // Use a manual loop instead of range because len(group.modules) can
- // change inside the loop
- for i := 0; i < len(group.modules); i++ {
- if alias := group.modules[i].alias(); alias != nil {
- if alias.target.logicModule == nil {
- newTarget := findAliasTarget(alias.target.variant)
- if newTarget != nil {
- alias.target = newTarget
- } else {
- // The alias was left dangling, remove it.
- group.modules = append(group.modules[:i], group.modules[i+1:]...)
- i--
- }
+ for i := 0; i < len(group.aliases); i++ {
+ alias := group.aliases[i]
+
+ if alias.target.logicModule == nil {
+ if alias.target.aliasTarget != nil {
+ alias.target = alias.target.aliasTarget
+ } else {
+ // The alias was left dangling, remove it.
+ group.aliases = append(group.aliases[:i], group.aliases[i+1:]...)
+ i--
}
}
}
@@ -2723,16 +2374,12 @@
ch := make(chan update)
doneCh := make(chan bool)
go func() {
- errs := parallelVisit(c.modulesSorted, unorderedVisitorImpl{}, parallelVisitLimit,
- func(m *moduleInfo, pause chan<- pauseSpec) bool {
- origLogicModule := m.logicModule
- m.logicModule, m.properties = c.cloneLogicModule(m)
- ch <- update{origLogicModule, m}
- return false
- })
- if len(errs) > 0 {
- panic(errs)
- }
+ c.parallelVisit(unorderedVisitorImpl{}, func(m *moduleInfo) bool {
+ origLogicModule := m.logicModule
+ m.logicModule, m.properties = c.cloneLogicModule(m)
+ ch <- update{origLogicModule, m}
+ return false
+ })
doneCh <- true
}()
@@ -2750,15 +2397,15 @@
// Removes modules[i] from the list and inserts newModules... where it was located, returning
// the new slice and the index of the last inserted element
-func spliceModules(modules modulesOrAliases, i int, newModules modulesOrAliases) (modulesOrAliases, int) {
+func spliceModules(modules []*moduleInfo, i int, newModules []*moduleInfo) ([]*moduleInfo, int) {
spliceSize := len(newModules)
newLen := len(modules) + spliceSize - 1
- var dest modulesOrAliases
+ var dest []*moduleInfo
if cap(modules) >= len(modules)-1+len(newModules) {
// We can fit the splice in the existing capacity, do everything in place
dest = modules[:newLen]
} else {
- dest = make(modulesOrAliases, newLen)
+ dest = make([]*moduleInfo, newLen)
copy(dest, modules[:i])
}
@@ -2796,77 +2443,71 @@
}
}()
- visitErrs := parallelVisit(c.modulesSorted, bottomUpVisitor, parallelVisitLimit,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- uniqueName := c.nameInterface.UniqueName(newNamespaceContext(module), module.group.name)
- sanitizedName := toNinjaName(uniqueName)
+ c.parallelVisit(bottomUpVisitor, func(module *moduleInfo) bool {
- prefix := moduleNamespacePrefix(sanitizedName + "_" + module.variant.name)
+ uniqueName := c.nameInterface.UniqueName(newNamespaceContext(module), module.group.name)
+ sanitizedName := toNinjaName(uniqueName)
- // The parent scope of the moduleContext's local scope gets overridden to be that of the
- // calling Go package on a per-call basis. Since the initial parent scope doesn't matter we
- // just set it to nil.
- scope := newLocalScope(nil, prefix)
+ prefix := moduleNamespacePrefix(sanitizedName + "_" + module.variantName)
- mctx := &moduleContext{
- baseModuleContext: baseModuleContext{
- context: c,
- config: config,
- module: module,
- },
- scope: scope,
- handledMissingDeps: module.missingDeps == nil,
- }
+ // The parent scope of the moduleContext's local scope gets overridden to be that of the
+ // calling Go package on a per-call basis. Since the initial parent scope doesn't matter we
+ // just set it to nil.
+ scope := newLocalScope(nil, prefix)
- mctx.module.startedGenerateBuildActions = true
+ mctx := &moduleContext{
+ baseModuleContext: baseModuleContext{
+ context: c,
+ config: config,
+ module: module,
+ },
+ scope: scope,
+ handledMissingDeps: module.missingDeps == nil,
+ }
- func() {
- defer func() {
- if r := recover(); r != nil {
- in := fmt.Sprintf("GenerateBuildActions for %s", module)
- if err, ok := r.(panicError); ok {
- err.addIn(in)
- mctx.error(err)
- } else {
- mctx.error(newPanicErrorf(r, in))
- }
+ func() {
+ defer func() {
+ if r := recover(); r != nil {
+ in := fmt.Sprintf("GenerateBuildActions for %s", module)
+ if err, ok := r.(panicError); ok {
+ err.addIn(in)
+ mctx.error(err)
+ } else {
+ mctx.error(newPanicErrorf(r, in))
}
- }()
- mctx.module.logicModule.GenerateBuildActions(mctx)
- }()
-
- mctx.module.finishedGenerateBuildActions = true
-
- if len(mctx.errs) > 0 {
- errsCh <- mctx.errs
- return true
- }
-
- if module.missingDeps != nil && !mctx.handledMissingDeps {
- var errs []error
- for _, depName := range module.missingDeps {
- errs = append(errs, c.missingDependencyError(module, depName))
}
- errsCh <- errs
- return true
- }
+ }()
+ mctx.module.logicModule.GenerateBuildActions(mctx)
+ }()
- depsCh <- mctx.ninjaFileDeps
+ if len(mctx.errs) > 0 {
+ errsCh <- mctx.errs
+ return true
+ }
- newErrs := c.processLocalBuildActions(&module.actionDefs,
- &mctx.actionDefs, liveGlobals)
- if len(newErrs) > 0 {
- errsCh <- newErrs
- return true
+ if module.missingDeps != nil && !mctx.handledMissingDeps {
+ var errs []error
+ for _, depName := range module.missingDeps {
+ errs = append(errs, c.missingDependencyError(module, depName))
}
- return false
- })
+ errsCh <- errs
+ return true
+ }
+
+ depsCh <- mctx.ninjaFileDeps
+
+ newErrs := c.processLocalBuildActions(&module.actionDefs,
+ &mctx.actionDefs, liveGlobals)
+ if len(newErrs) > 0 {
+ errsCh <- newErrs
+ return true
+ }
+ return false
+ })
cancelCh <- struct{}{}
<-cancelCh
- errs = append(errs, visitErrs...)
-
return deps, errs
}
@@ -3004,8 +2645,7 @@
}
type replace struct {
- from, to *moduleInfo
- predicate ReplaceDependencyPredicate
+ from, to *moduleInfo
}
type rename struct {
@@ -3021,8 +2661,14 @@
}
for _, m := range group.modules {
- if module.variant.name == m.moduleOrAliasVariant().name {
- return m.moduleOrAliasTarget()
+ if module.variantName == m.variantName {
+ return m
+ }
+ }
+
+ for _, m := range group.aliases {
+ if module.variantName == m.variantName {
+ return m.target
}
}
@@ -3045,32 +2691,22 @@
func (c *Context) handleReplacements(replacements []replace) []error {
var errs []error
- changedDeps := false
for _, replace := range replacements {
for _, m := range replace.from.reverseDeps {
for i, d := range m.directDeps {
if d.module == replace.from {
- // If the replacement has a predicate then check it.
- if replace.predicate == nil || replace.predicate(m.logicModule, d.tag, d.module.logicModule) {
- m.directDeps[i].module = replace.to
- changedDeps = true
- }
+ m.directDeps[i].module = replace.to
}
}
}
- }
-
- if changedDeps {
atomic.AddUint32(&c.depsModified, 1)
}
+
return errs
}
-func (c *Context) discoveredMissingDependencies(module *moduleInfo, depName string, depVariations variationMap) (errs []error) {
- if depVariations != nil {
- depName = depName + "{" + c.prettyPrintVariant(depVariations) + "}"
- }
+func (c *Context) discoveredMissingDependencies(module *moduleInfo, depName string) (errs []error) {
if c.allowMissingDependencies {
module.missingDeps = append(module.missingDeps, depName)
return nil
@@ -3096,7 +2732,7 @@
}
func (c *Context) sortedModuleGroups() []*moduleGroup {
- if c.cachedSortedModuleGroups == nil || c.cachedDepsModified {
+ if c.cachedSortedModuleGroups == nil {
unwrap := func(wrappers []ModuleGroup) []*moduleGroup {
result := make([]*moduleGroup, 0, len(wrappers))
for _, group := range wrappers {
@@ -3106,7 +2742,6 @@
}
c.cachedSortedModuleGroups = unwrap(c.nameInterface.AllModules())
- c.cachedDepsModified = false
}
return c.cachedSortedModuleGroups
@@ -3123,10 +2758,8 @@
}()
for _, moduleGroup := range c.sortedModuleGroups() {
- for _, moduleOrAlias := range moduleGroup.modules {
- if module = moduleOrAlias.module(); module != nil {
- visit(module.logicModule)
- }
+ for _, module = range moduleGroup.modules {
+ visit(module.logicModule)
}
}
}
@@ -3144,11 +2777,9 @@
}()
for _, moduleGroup := range c.sortedModuleGroups() {
- for _, moduleOrAlias := range moduleGroup.modules {
- if module = moduleOrAlias.module(); module != nil {
- if pred(module.logicModule) {
- visit(module.logicModule)
- }
+ for _, module := range moduleGroup.modules {
+ if pred(module.logicModule) {
+ visit(module.logicModule)
}
}
}
@@ -3166,10 +2797,8 @@
}
}()
- for _, moduleOrAlias := range module.group.modules {
- if variant = moduleOrAlias.module(); variant != nil {
- visit(variant.logicModule)
- }
+ for _, variant = range module.group.modules {
+ visit(variant.logicModule)
}
}
@@ -3251,21 +2880,6 @@
return pkgNames, deps
}
-// memoizeFullNames stores the full name of each live global variable, rule and pool since each is
-// guaranteed to be used at least twice, once in the definition and once for each usage, and many
-// are used much more than once.
-func (c *Context) memoizeFullNames(liveGlobals *liveTracker, pkgNames map[*packageContext]string) {
- for v := range liveGlobals.variables {
- v.memoizeFullName(pkgNames)
- }
- for r := range liveGlobals.rules {
- r.memoizeFullName(pkgNames)
- }
- for p := range liveGlobals.pools {
- p.memoizeFullName(pkgNames)
- }
-}
-
func (c *Context) checkForVariableReferenceCycles(
variables map[Variable]ninjaString, pkgNames map[*packageContext]string) {
@@ -3412,13 +3026,18 @@
return module.Name()
}
+func (c *Context) ModulePath(logicModule Module) string {
+ module := c.moduleInfo[logicModule]
+ return module.relBlueprintsFile
+}
+
func (c *Context) ModuleDir(logicModule Module) string {
- return filepath.Dir(c.BlueprintFile(logicModule))
+ return filepath.Dir(c.ModulePath(logicModule))
}
func (c *Context) ModuleSubDir(logicModule Module) string {
module := c.moduleInfo[logicModule]
- return module.variant.name
+ return module.variantName
}
func (c *Context) ModuleType(logicModule Module) string {
@@ -3426,25 +3045,6 @@
return module.typeName
}
-// ModuleProvider returns the value, if any, for the provider for a module. If the value for the
-// provider was not set it returns the zero value of the type of the provider, which means the
-// return value can always be type-asserted to the type of the provider. The return value should
-// always be considered read-only. It panics if called before the appropriate mutator or
-// GenerateBuildActions pass for the provider on the module. The value returned may be a deep
-// copy of the value originally passed to SetProvider.
-func (c *Context) ModuleProvider(logicModule Module, provider ProviderKey) interface{} {
- module := c.moduleInfo[logicModule]
- value, _ := c.provider(module, provider)
- return value
-}
-
-// ModuleHasProvider returns true if the provider for the given module has been set.
-func (c *Context) ModuleHasProvider(logicModule Module, provider ProviderKey) bool {
- module := c.moduleInfo[logicModule]
- _, ok := c.provider(module, provider)
- return ok
-}
-
func (c *Context) BlueprintFile(logicModule Module) string {
module := c.moduleInfo[logicModule]
return module.relBlueprintsFile
@@ -3547,11 +3147,12 @@
}
func (c *Context) PrimaryModule(module Module) Module {
- return c.moduleInfo[module].group.modules.firstModule().logicModule
+ return c.moduleInfo[module].group.modules[0].logicModule
}
func (c *Context) FinalModule(module Module) Module {
- return c.moduleInfo[module].group.modules.lastModule().logicModule
+ modules := c.moduleInfo[module].group.modules
+ return modules[len(modules)-1].logicModule
}
func (c *Context) VisitAllModuleVariants(module Module,
@@ -3582,7 +3183,7 @@
// WriteBuildFile writes the Ninja manifeset text for the generated build
// actions to w. If this is called before PrepareBuildActions successfully
// completes then ErrBuildActionsNotReady is returned.
-func (c *Context) WriteBuildFile(w io.StringWriter) error {
+func (c *Context) WriteBuildFile(w io.Writer) error {
var err error
pprof.Do(c.Context, pprof.Labels("blueprint", "WriteBuildFile"), func(ctx context.Context) {
if !c.buildActionsReady {
@@ -3882,8 +3483,8 @@
iName := s[i].module.Name()
jName := s[j].module.Name()
if iName == jName {
- iName = s[i].module.variant.name
- jName = s[j].module.variant.name
+ iName = s[i].module.variantName
+ jName = s[j].module.variantName
}
return iName < jName
}
@@ -3907,17 +3508,14 @@
iName := s.nameInterface.UniqueName(newNamespaceContext(iMod), iMod.group.name)
jName := s.nameInterface.UniqueName(newNamespaceContext(jMod), jMod.group.name)
if iName == jName {
- iVariantName := s.modules[i].variant.name
- jVariantName := s.modules[j].variant.name
- if iVariantName == jVariantName {
- panic(fmt.Sprintf("duplicate module name: %s %s: %#v and %#v\n",
- iName, iVariantName, iMod.variant.variations, jMod.variant.variations))
- } else {
- return iVariantName < jVariantName
- }
- } else {
- return iName < jName
+ iName = s.modules[i].variantName
+ jName = s.modules[j].variantName
}
+
+ if iName == jName {
+ panic(fmt.Sprintf("duplicate module name: %s: %#v and %#v\n", iName, iMod, jMod))
+ }
+ return iName < jName
}
func (s moduleSorter) Swap(i, j int) {
@@ -3962,7 +3560,7 @@
"typeName": module.typeName,
"goFactory": factoryName,
"pos": relPos,
- "variant": module.variant.name,
+ "variant": module.variantName,
}
err = headerTemplate.Execute(buf, infoMap)
if err != nil {
@@ -4111,15 +3709,15 @@
return nil
}
-func beforeInModuleList(a, b *moduleInfo, list modulesOrAliases) bool {
+func beforeInModuleList(a, b *moduleInfo, list []*moduleInfo) bool {
found := false
if a == b {
return false
}
for _, l := range list {
- if l.module() == a {
+ if l == a {
found = true
- } else if l.module() == b {
+ } else if l == b {
return found
}
}
diff --git a/context_test.go b/context_test.go
index d91b89d..0541c06 100644
--- a/context_test.go
+++ b/context_test.go
@@ -238,7 +238,7 @@
t.FailNow()
}
- topModule := ctx.moduleGroupFromName("A", nil).modules.firstModule()
+ topModule := ctx.moduleGroupFromName("A", nil).modules[0]
outputDown, outputUp := walkDependencyGraph(ctx, topModule, false)
if outputDown != "BCEFG" {
t.Errorf("unexpected walkDeps behaviour: %s\ndown should be: BCEFG", outputDown)
@@ -319,7 +319,7 @@
t.FailNow()
}
- topModule := ctx.moduleGroupFromName("A", nil).modules.firstModule()
+ topModule := ctx.moduleGroupFromName("A", nil).modules[0]
outputDown, outputUp := walkDependencyGraph(ctx, topModule, true)
if outputDown != "BCEGHFGG" {
t.Errorf("unexpected walkDeps behaviour: %s\ndown should be: BCEGHFGG", outputDown)
@@ -386,7 +386,7 @@
t.FailNow()
}
- topModule := ctx.moduleGroupFromName("A", nil).modules.firstModule()
+ topModule := ctx.moduleGroupFromName("A", nil).modules[0]
outputDown, outputUp := walkDependencyGraph(ctx, topModule, true)
expectedDown := "BDCDE"
if outputDown != expectedDown {
@@ -432,10 +432,10 @@
t.FailNow()
}
- a := ctx.moduleGroupFromName("A", nil).modules.firstModule().logicModule.(*fooModule)
- b := ctx.moduleGroupFromName("B", nil).modules.firstModule().logicModule.(*barModule)
- c := ctx.moduleGroupFromName("C", nil).modules.firstModule().logicModule.(*barModule)
- d := ctx.moduleGroupFromName("D", nil).modules.firstModule().logicModule.(*fooModule)
+ a := ctx.moduleGroupFromName("A", nil).modules[0].logicModule.(*fooModule)
+ b := ctx.moduleGroupFromName("B", nil).modules[0].logicModule.(*barModule)
+ c := ctx.moduleGroupFromName("C", nil).modules[0].logicModule.(*barModule)
+ d := ctx.moduleGroupFromName("D", nil).modules[0].logicModule.(*fooModule)
checkDeps := func(m Module, expected string) {
var deps []string
@@ -606,481 +606,3 @@
t.Errorf("Incorrect errors; expected:\n%s\ngot:\n%s", expectedErrs, errs)
}
}
-
-func Test_findVariant(t *testing.T) {
- module := &moduleInfo{
- variant: variant{
- name: "normal_local",
- variations: variationMap{
- "normal": "normal",
- "local": "local",
- },
- dependencyVariations: variationMap{
- "normal": "normal",
- },
- },
- }
-
- type alias struct {
- variant variant
- target int
- }
-
- makeDependencyGroup := func(in ...interface{}) *moduleGroup {
- group := &moduleGroup{
- name: "dep",
- }
- for _, x := range in {
- switch m := x.(type) {
- case *moduleInfo:
- m.group = group
- group.modules = append(group.modules, m)
- case alias:
- // aliases may need to target modules that haven't been processed
- // yet, put an empty alias in for now.
- group.modules = append(group.modules, nil)
- default:
- t.Fatalf("unexpected type %T", x)
- }
- }
-
- for i, x := range in {
- switch m := x.(type) {
- case *moduleInfo:
- // already added in the first pass
- case alias:
- group.modules[i] = &moduleAlias{
- variant: m.variant,
- target: group.modules[m.target].moduleOrAliasTarget(),
- }
- default:
- t.Fatalf("unexpected type %T", x)
- }
- }
-
- return group
- }
-
- tests := []struct {
- name string
- possibleDeps *moduleGroup
- variations []Variation
- far bool
- reverse bool
- want string
- }{
- {
- name: "AddVariationDependencies(nil)",
- // A dependency that matches the non-local variations of the module
- possibleDeps: makeDependencyGroup(
- &moduleInfo{
- variant: variant{
- name: "normal",
- variations: variationMap{
- "normal": "normal",
- },
- },
- },
- ),
- variations: nil,
- far: false,
- reverse: false,
- want: "normal",
- },
- {
- name: "AddVariationDependencies(nil) to alias",
- // A dependency with an alias that matches the non-local variations of the module
- possibleDeps: makeDependencyGroup(
- alias{
- variant: variant{
- name: "normal",
- variations: variationMap{
- "normal": "normal",
- },
- },
- target: 1,
- },
- &moduleInfo{
- variant: variant{
- name: "normal_a",
- variations: variationMap{
- "normal": "normal",
- "a": "a",
- },
- },
- },
- ),
- variations: nil,
- far: false,
- reverse: false,
- want: "normal_a",
- },
- {
- name: "AddVariationDependencies(a)",
- // A dependency with local variations
- possibleDeps: makeDependencyGroup(
- &moduleInfo{
- variant: variant{
- name: "normal_a",
- variations: variationMap{
- "normal": "normal",
- "a": "a",
- },
- },
- },
- ),
- variations: []Variation{{"a", "a"}},
- far: false,
- reverse: false,
- want: "normal_a",
- },
- {
- name: "AddFarVariationDependencies(far)",
- // A dependency with far variations
- possibleDeps: makeDependencyGroup(
- &moduleInfo{
- variant: variant{
- name: "",
- variations: nil,
- },
- },
- &moduleInfo{
- variant: variant{
- name: "far",
- variations: variationMap{
- "far": "far",
- },
- },
- },
- ),
- variations: []Variation{{"far", "far"}},
- far: true,
- reverse: false,
- want: "far",
- },
- {
- name: "AddFarVariationDependencies(far) to alias",
- // A dependency with far variations and aliases
- possibleDeps: makeDependencyGroup(
- alias{
- variant: variant{
- name: "far",
- variations: variationMap{
- "far": "far",
- },
- },
- target: 2,
- },
- &moduleInfo{
- variant: variant{
- name: "far_a",
- variations: variationMap{
- "far": "far",
- "a": "a",
- },
- },
- },
- &moduleInfo{
- variant: variant{
- name: "far_b",
- variations: variationMap{
- "far": "far",
- "b": "b",
- },
- },
- },
- ),
- variations: []Variation{{"far", "far"}},
- far: true,
- reverse: false,
- want: "far_b",
- },
- {
- name: "AddFarVariationDependencies(far, b) to missing",
- // A dependency with far variations and aliases
- possibleDeps: makeDependencyGroup(
- alias{
- variant: variant{
- name: "far",
- variations: variationMap{
- "far": "far",
- },
- },
- target: 1,
- },
- &moduleInfo{
- variant: variant{
- name: "far_a",
- variations: variationMap{
- "far": "far",
- "a": "a",
- },
- },
- },
- ),
- variations: []Variation{{"far", "far"}, {"a", "b"}},
- far: true,
- reverse: false,
- want: "nil",
- },
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- got, _ := findVariant(module, tt.possibleDeps, tt.variations, tt.far, tt.reverse)
- if g, w := got == nil, tt.want == "nil"; g != w {
- t.Fatalf("findVariant() got = %v, want %v", got, tt.want)
- }
- if got != nil {
- if g, w := got.String(), fmt.Sprintf("module %q variant %q", "dep", tt.want); g != w {
- t.Errorf("findVariant() got = %v, want %v", g, w)
- }
- }
- })
- }
-}
-
-func Test_parallelVisit(t *testing.T) {
- addDep := func(from, to *moduleInfo) {
- from.directDeps = append(from.directDeps, depInfo{to, nil})
- from.forwardDeps = append(from.forwardDeps, to)
- to.reverseDeps = append(to.reverseDeps, from)
- }
-
- create := func(name string) *moduleInfo {
- m := &moduleInfo{
- group: &moduleGroup{
- name: name,
- },
- }
- m.group.modules = modulesOrAliases{m}
- return m
- }
- moduleA := create("A")
- moduleB := create("B")
- moduleC := create("C")
- moduleD := create("D")
- moduleE := create("E")
- moduleF := create("F")
- moduleG := create("G")
-
- // A depends on B, B depends on C. Nothing depends on D through G, and they don't depend on
- // anything.
- addDep(moduleA, moduleB)
- addDep(moduleB, moduleC)
-
- t.Run("no modules", func(t *testing.T) {
- errs := parallelVisit(nil, bottomUpVisitorImpl{}, 1,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- panic("unexpected call to visitor")
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- })
- t.Run("bottom up", func(t *testing.T) {
- order := ""
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC}, bottomUpVisitorImpl{}, 1,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- order += module.group.name
- return false
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- if g, w := order, "CBA"; g != w {
- t.Errorf("expected order %q, got %q", w, g)
- }
- })
- t.Run("pause", func(t *testing.T) {
- order := ""
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC, moduleD}, bottomUpVisitorImpl{}, 1,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- if module == moduleC {
- // Pause module C on module D
- unpause := make(chan struct{})
- pause <- pauseSpec{moduleC, moduleD, unpause}
- <-unpause
- }
- order += module.group.name
- return false
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- if g, w := order, "DCBA"; g != w {
- t.Errorf("expected order %q, got %q", w, g)
- }
- })
- t.Run("cancel", func(t *testing.T) {
- order := ""
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC}, bottomUpVisitorImpl{}, 1,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- order += module.group.name
- // Cancel in module B
- return module == moduleB
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- if g, w := order, "CB"; g != w {
- t.Errorf("expected order %q, got %q", w, g)
- }
- })
- t.Run("pause and cancel", func(t *testing.T) {
- order := ""
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC, moduleD}, bottomUpVisitorImpl{}, 1,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- if module == moduleC {
- // Pause module C on module D
- unpause := make(chan struct{})
- pause <- pauseSpec{moduleC, moduleD, unpause}
- <-unpause
- }
- order += module.group.name
- // Cancel in module D
- return module == moduleD
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- if g, w := order, "D"; g != w {
- t.Errorf("expected order %q, got %q", w, g)
- }
- })
- t.Run("parallel", func(t *testing.T) {
- order := ""
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC}, bottomUpVisitorImpl{}, 3,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- order += module.group.name
- return false
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- if g, w := order, "CBA"; g != w {
- t.Errorf("expected order %q, got %q", w, g)
- }
- })
- t.Run("pause existing", func(t *testing.T) {
- order := ""
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC}, bottomUpVisitorImpl{}, 3,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- if module == moduleA {
- // Pause module A on module B (an existing dependency)
- unpause := make(chan struct{})
- pause <- pauseSpec{moduleA, moduleB, unpause}
- <-unpause
- }
- order += module.group.name
- return false
- })
- if errs != nil {
- t.Errorf("expected no errors, got %q", errs)
- }
- if g, w := order, "CBA"; g != w {
- t.Errorf("expected order %q, got %q", w, g)
- }
- })
- t.Run("cycle", func(t *testing.T) {
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC}, bottomUpVisitorImpl{}, 3,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- if module == moduleC {
- // Pause module C on module A (a dependency cycle)
- unpause := make(chan struct{})
- pause <- pauseSpec{moduleC, moduleA, unpause}
- <-unpause
- }
- return false
- })
- want := []string{
- `encountered dependency cycle`,
- `module "C" depends on module "A"`,
- `module "A" depends on module "B"`,
- `module "B" depends on module "C"`,
- }
- for i := range want {
- if len(errs) <= i {
- t.Errorf("missing error %s", want[i])
- } else if !strings.Contains(errs[i].Error(), want[i]) {
- t.Errorf("expected error %s, got %s", want[i], errs[i])
- }
- }
- if len(errs) > len(want) {
- for _, err := range errs[len(want):] {
- t.Errorf("unexpected error %s", err.Error())
- }
- }
- })
- t.Run("pause cycle", func(t *testing.T) {
- errs := parallelVisit([]*moduleInfo{moduleA, moduleB, moduleC, moduleD}, bottomUpVisitorImpl{}, 3,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- if module == moduleC {
- // Pause module C on module D
- unpause := make(chan struct{})
- pause <- pauseSpec{moduleC, moduleD, unpause}
- <-unpause
- }
- if module == moduleD {
- // Pause module D on module C (a pause cycle)
- unpause := make(chan struct{})
- pause <- pauseSpec{moduleD, moduleC, unpause}
- <-unpause
- }
- return false
- })
- want := []string{
- `encountered dependency cycle`,
- `module "D" depends on module "C"`,
- `module "C" depends on module "D"`,
- }
- for i := range want {
- if len(errs) <= i {
- t.Errorf("missing error %s", want[i])
- } else if !strings.Contains(errs[i].Error(), want[i]) {
- t.Errorf("expected error %s, got %s", want[i], errs[i])
- }
- }
- if len(errs) > len(want) {
- for _, err := range errs[len(want):] {
- t.Errorf("unexpected error %s", err.Error())
- }
- }
- })
- t.Run("pause cycle with deps", func(t *testing.T) {
- pauseDeps := map[*moduleInfo]*moduleInfo{
- // F and G form a pause cycle
- moduleF: moduleG,
- moduleG: moduleF,
- // D depends on E which depends on the pause cycle, making E the first alphabetical
- // entry in pauseMap, which is not part of the cycle.
- moduleD: moduleE,
- moduleE: moduleF,
- }
- errs := parallelVisit([]*moduleInfo{moduleD, moduleE, moduleF, moduleG}, bottomUpVisitorImpl{}, 4,
- func(module *moduleInfo, pause chan<- pauseSpec) bool {
- if dep, ok := pauseDeps[module]; ok {
- unpause := make(chan struct{})
- pause <- pauseSpec{module, dep, unpause}
- <-unpause
- }
- return false
- })
- want := []string{
- `encountered dependency cycle`,
- `module "G" depends on module "F"`,
- `module "F" depends on module "G"`,
- }
- for i := range want {
- if len(errs) <= i {
- t.Errorf("missing error %s", want[i])
- } else if !strings.Contains(errs[i].Error(), want[i]) {
- t.Errorf("expected error %s, got %s", want[i], errs[i])
- }
- }
- if len(errs) > len(want) {
- for _, err := range errs[len(want):] {
- t.Errorf("unexpected error %s", err.Error())
- }
- }
- })
-}
diff --git a/glob.go b/glob.go
index 91ae723..4f7e978 100644
--- a/glob.go
+++ b/glob.go
@@ -15,6 +15,7 @@
package blueprint
import (
+ "crypto/md5"
"fmt"
"sort"
"strings"
@@ -22,95 +23,108 @@
"github.com/google/blueprint/pathtools"
)
-func verifyGlob(key globKey, pattern string, excludes []string, g pathtools.GlobResult) {
+type GlobPath struct {
+ Pattern string
+ Excludes []string
+ Files []string
+ Deps []string
+ Name string
+}
+
+func verifyGlob(fileName, pattern string, excludes []string, g GlobPath) {
if pattern != g.Pattern {
- panic(fmt.Errorf("Mismatched patterns %q and %q for glob key %q", pattern, g.Pattern, key))
+ panic(fmt.Errorf("Mismatched patterns %q and %q for glob file %q", pattern, g.Pattern, fileName))
}
if len(excludes) != len(g.Excludes) {
- panic(fmt.Errorf("Mismatched excludes %v and %v for glob key %q", excludes, g.Excludes, key))
+ panic(fmt.Errorf("Mismatched excludes %v and %v for glob file %q", excludes, g.Excludes, fileName))
}
for i := range excludes {
if g.Excludes[i] != excludes[i] {
- panic(fmt.Errorf("Mismatched excludes %v and %v for glob key %q", excludes, g.Excludes, key))
+ panic(fmt.Errorf("Mismatched excludes %v and %v for glob file %q", excludes, g.Excludes, fileName))
}
}
}
func (c *Context) glob(pattern string, excludes []string) ([]string, error) {
- // Sort excludes so that two globs with the same excludes in a different order reuse the same
- // key. Make a copy first to avoid modifying the caller's version.
- excludes = append([]string(nil), excludes...)
- sort.Strings(excludes)
-
- key := globToKey(pattern, excludes)
+ fileName := globToFileName(pattern, excludes)
// Try to get existing glob from the stored results
c.globLock.Lock()
- g, exists := c.globs[key]
+ g, exists := c.globs[fileName]
c.globLock.Unlock()
if exists {
// Glob has already been done, double check it is identical
- verifyGlob(key, pattern, excludes, g)
- // Return a copy so that modifications don't affect the cached value.
- return append([]string(nil), g.Matches...), nil
+ verifyGlob(fileName, pattern, excludes, g)
+ return g.Files, nil
}
// Get a globbed file list
- result, err := c.fs.Glob(pattern, excludes, pathtools.FollowSymlinks)
+ files, deps, err := c.fs.Glob(pattern, excludes, pathtools.FollowSymlinks)
if err != nil {
return nil, err
}
// Store the results
c.globLock.Lock()
- if g, exists = c.globs[key]; !exists {
- c.globs[key] = result
+ if g, exists = c.globs[fileName]; !exists {
+ c.globs[fileName] = GlobPath{pattern, excludes, files, deps, fileName}
}
c.globLock.Unlock()
+ // Getting the list raced with another goroutine, throw away the results and use theirs
if exists {
- // Getting the list raced with another goroutine, throw away the results and use theirs
- verifyGlob(key, pattern, excludes, g)
- // Return a copy so that modifications don't affect the cached value.
- return append([]string(nil), g.Matches...), nil
+ verifyGlob(fileName, pattern, excludes, g)
+ return g.Files, nil
}
- // Return a copy so that modifications don't affect the cached value.
- return append([]string(nil), result.Matches...), nil
+ return files, nil
}
-func (c *Context) Globs() pathtools.MultipleGlobResults {
- keys := make([]globKey, 0, len(c.globs))
+func (c *Context) Globs() []GlobPath {
+ fileNames := make([]string, 0, len(c.globs))
for k := range c.globs {
- keys = append(keys, k)
+ fileNames = append(fileNames, k)
}
+ sort.Strings(fileNames)
- sort.Slice(keys, func(i, j int) bool {
- if keys[i].pattern != keys[j].pattern {
- return keys[i].pattern < keys[j].pattern
- }
- return keys[i].excludes < keys[j].excludes
- })
-
- globs := make(pathtools.MultipleGlobResults, len(keys))
- for i, key := range keys {
- globs[i] = c.globs[key]
+ globs := make([]GlobPath, len(fileNames))
+ for i, fileName := range fileNames {
+ globs[i] = c.globs[fileName]
}
return globs
}
-// globKey combines a pattern and a list of excludes into a hashable struct to be used as a key in
-// a map.
-type globKey struct {
- pattern string
- excludes string
+func globToString(pattern string) string {
+ ret := ""
+ for _, c := range pattern {
+ switch {
+ case c >= 'a' && c <= 'z',
+ c >= 'A' && c <= 'Z',
+ c >= '0' && c <= '9',
+ c == '_', c == '-', c == '/':
+ ret += string(c)
+ default:
+ ret += "_"
+ }
+ }
+
+ return ret
}
-// globToKey converts a pattern and an excludes list into a globKey struct that is hashable and
-// usable as a key in a map.
-func globToKey(pattern string, excludes []string) globKey {
- return globKey{pattern, strings.Join(excludes, "|")}
+func globToFileName(pattern string, excludes []string) string {
+ name := globToString(pattern)
+ excludeName := ""
+ for _, e := range excludes {
+ excludeName += "__" + globToString(e)
+ }
+
+ // Prevent file names from reaching ninja's path component limit
+ if strings.Count(name, "/")+strings.Count(excludeName, "/") > 30 {
+ excludeName = fmt.Sprintf("___%x", md5.Sum([]byte(excludeName)))
+ }
+
+ return name + excludeName + ".glob"
}
diff --git a/live_tracker.go b/live_tracker.go
index 1d48e58..40e1930 100644
--- a/live_tracker.go
+++ b/live_tracker.go
@@ -68,11 +68,6 @@
return err
}
- err = l.addNinjaStringListDeps(def.Validations)
- if err != nil {
- return err
- }
-
for _, value := range def.Variables {
err = l.addNinjaStringDeps(value)
if err != nil {
diff --git a/microfactory/microfactory.go b/microfactory/microfactory.go
index a0c9a14..a70d3c5 100644
--- a/microfactory/microfactory.go
+++ b/microfactory/microfactory.go
@@ -397,7 +397,6 @@
fmt.Fprintln(hash, runtime.GOOS, runtime.GOARCH, goVersion)
cmd := exec.Command(filepath.Join(goToolDir, "compile"),
- "-N", "-l", // Disable optimization and inlining so that debugging works better
"-o", p.output,
"-p", p.Name,
"-complete", "-pack", "-nolocalimports")
diff --git a/module_ctx.go b/module_ctx.go
index a074e37..36e05a4 100644
--- a/module_ctx.go
+++ b/module_ctx.go
@@ -246,24 +246,6 @@
// invalidated by future mutators.
WalkDeps(visit func(Module, Module) bool)
- // PrimaryModule returns the first variant of the current module. Variants of a module are always visited in
- // order by mutators and GenerateBuildActions, so the data created by the current mutator can be read from the
- // Module returned by PrimaryModule without data races. This can be used to perform singleton actions that are
- // only done once for all variants of a module.
- PrimaryModule() Module
-
- // FinalModule returns the last variant of the current module. Variants of a module are always visited in
- // order by mutators and GenerateBuildActions, so the data created by the current mutator can be read from all
- // variants using VisitAllModuleVariants if the current module == FinalModule(). This can be used to perform
- // singleton actions that are only done once for all variants of a module.
- FinalModule() Module
-
- // VisitAllModuleVariants calls visit for each variant of the current module. Variants of a module are always
- // visited in order by mutators and GenerateBuildActions, so the data created by the current mutator can be read
- // from all variants if the current module == FinalModule(). Otherwise, care must be taken to not access any
- // data modified by the current mutator.
- VisitAllModuleVariants(visit func(Module))
-
// OtherModuleName returns the name of another Module. See BaseModuleContext.ModuleName for more information.
// It is intended for use inside the visit functions of Visit* and WalkDeps.
OtherModuleName(m Module) string
@@ -293,51 +275,6 @@
// OtherModuleExists returns true if a module with the specified name exists, as determined by the NameInterface
// passed to Context.SetNameInterface, or SimpleNameInterface if it was not called.
OtherModuleExists(name string) bool
-
- // OtherModuleDependencyVariantExists returns true if a module with the
- // specified name and variant exists. The variant must match the given
- // variations. It must also match all the non-local variations of the current
- // module. In other words, it checks for the module that AddVariationDependencies
- // would add a dependency on with the same arguments.
- OtherModuleDependencyVariantExists(variations []Variation, name string) bool
-
- // OtherModuleFarDependencyVariantExists returns true if a module with the
- // specified name and variant exists. The variant must match the given
- // variations, but not the non-local variations of the current module. In
- // other words, it checks for the module that AddFarVariationDependencies
- // would add a dependency on with the same arguments.
- OtherModuleFarDependencyVariantExists(variations []Variation, name string) bool
-
- // OtherModuleReverseDependencyVariantExists returns true if a module with the
- // specified name exists with the same variations as the current module. In
- // other words, it checks for the module that AddReverseDependency would add a
- // dependency on with the same argument.
- OtherModuleReverseDependencyVariantExists(name string) bool
-
- // OtherModuleProvider returns the value for a provider for the given module. If the value is
- // not set it returns the zero value of the type of the provider, so the return value can always
- // be type asserted to the type of the provider. The value returned may be a deep copy of the
- // value originally passed to SetProvider.
- OtherModuleProvider(m Module, provider ProviderKey) interface{}
-
- // OtherModuleHasProvider returns true if the provider for the given module has been set.
- OtherModuleHasProvider(m Module, provider ProviderKey) bool
-
- // Provider returns the value for a provider for the current module. If the value is
- // not set it returns the zero value of the type of the provider, so the return value can always
- // be type asserted to the type of the provider. It panics if called before the appropriate
- // mutator or GenerateBuildActions pass for the provider. The value returned may be a deep
- // copy of the value originally passed to SetProvider.
- Provider(provider ProviderKey) interface{}
-
- // HasProvider returns true if the provider for the current module has been set.
- HasProvider(provider ProviderKey) bool
-
- // SetProvider sets the value for a provider for the current module. It panics if not called
- // during the appropriate mutator or GenerateBuildActions pass for the provider, if the value
- // is not of the appropriate type, or if the value has already been set. The value should not
- // be modified after being passed to SetProvider.
- SetProvider(provider ProviderKey, value interface{})
}
type DynamicDependerModuleContext BottomUpMutatorContext
@@ -359,6 +296,24 @@
// Build creates a new ninja build statement.
Build(pctx PackageContext, params BuildParams)
+ // PrimaryModule returns the first variant of the current module. Variants of a module are always visited in
+ // order by mutators and GenerateBuildActions, so the data created by the current mutator can be read from the
+ // Module returned by PrimaryModule without data races. This can be used to perform singleton actions that are
+ // only done once for all variants of a module.
+ PrimaryModule() Module
+
+ // FinalModule returns the last variant of the current module. Variants of a module are always visited in
+ // order by mutators and GenerateBuildActions, so the data created by the current mutator can be read from all
+ // variants using VisitAllModuleVariants if the current module == FinalModule(). This can be used to perform
+ // singleton actions that are only done once for all variants of a module.
+ FinalModule() Module
+
+ // VisitAllModuleVariants calls visit for each variant of the current module. Variants of a module are always
+ // visited in order by mutators and GenerateBuildActions, so the data created by the current mutator can be read
+ // from all variants if the current module == FinalModule(). Otherwise, care must be taken to not access any
+ // data modified by the current mutator.
+ VisitAllModuleVariants(visit func(Module))
+
// GetMissingDependencies returns the list of dependencies that were passed to AddDependencies or related methods,
// but do not exist. It can be used with Context.SetAllowMissingDependencies to allow the primary builder to
// handle missing dependencies on its own instead of having Blueprint treat them as an error.
@@ -496,7 +451,7 @@
func (m *baseModuleContext) OtherModuleSubDir(logicModule Module) string {
module := m.context.moduleInfo[logicModule]
- return module.variant.name
+ return module.variantName
}
func (m *baseModuleContext) OtherModuleType(logicModule Module) string {
@@ -537,59 +492,6 @@
return exists
}
-func (m *baseModuleContext) OtherModuleDependencyVariantExists(variations []Variation, name string) bool {
- possibleDeps := m.context.moduleGroupFromName(name, m.module.namespace())
- if possibleDeps == nil {
- return false
- }
- found, _ := findVariant(m.module, possibleDeps, variations, false, false)
- return found != nil
-}
-
-func (m *baseModuleContext) OtherModuleFarDependencyVariantExists(variations []Variation, name string) bool {
- possibleDeps := m.context.moduleGroupFromName(name, m.module.namespace())
- if possibleDeps == nil {
- return false
- }
- found, _ := findVariant(m.module, possibleDeps, variations, true, false)
- return found != nil
-}
-
-func (m *baseModuleContext) OtherModuleReverseDependencyVariantExists(name string) bool {
- possibleDeps := m.context.moduleGroupFromName(name, m.module.namespace())
- if possibleDeps == nil {
- return false
- }
- found, _ := findVariant(m.module, possibleDeps, nil, false, true)
- return found != nil
-}
-
-func (m *baseModuleContext) OtherModuleProvider(logicModule Module, provider ProviderKey) interface{} {
- module := m.context.moduleInfo[logicModule]
- value, _ := m.context.provider(module, provider)
- return value
-}
-
-func (m *baseModuleContext) OtherModuleHasProvider(logicModule Module, provider ProviderKey) bool {
- module := m.context.moduleInfo[logicModule]
- _, ok := m.context.provider(module, provider)
- return ok
-}
-
-func (m *baseModuleContext) Provider(provider ProviderKey) interface{} {
- value, _ := m.context.provider(m.module, provider)
- return value
-}
-
-func (m *baseModuleContext) HasProvider(provider ProviderKey) bool {
- _, ok := m.context.provider(m.module, provider)
- return ok
-}
-
-func (m *baseModuleContext) SetProvider(provider ProviderKey, value interface{}) {
- m.context.setProvider(m.module, provider, value)
-}
-
func (m *baseModuleContext) GetDirectDep(name string) (Module, DependencyTag) {
for _, dep := range m.module.directDeps {
if dep.module.Name() == name {
@@ -709,18 +611,6 @@
m.visitingDep = depInfo{}
}
-func (m *baseModuleContext) PrimaryModule() Module {
- return m.module.group.modules.firstModule().logicModule
-}
-
-func (m *baseModuleContext) FinalModule() Module {
- return m.module.group.modules.lastModule().logicModule
-}
-
-func (m *baseModuleContext) VisitAllModuleVariants(visit func(Module)) {
- m.context.visitAllModuleVariants(m.module, visit)
-}
-
func (m *baseModuleContext) AddNinjaFileDeps(deps ...string) {
m.ninjaFileDeps = append(m.ninjaFileDeps, deps...)
}
@@ -734,7 +624,7 @@
}
func (m *moduleContext) ModuleSubDir() string {
- return m.module.variant.name
+ return m.module.variantName
}
func (m *moduleContext) Variable(pctx PackageContext, name, value string) {
@@ -774,6 +664,18 @@
m.actionDefs.buildDefs = append(m.actionDefs.buildDefs, def)
}
+func (m *moduleContext) PrimaryModule() Module {
+ return m.module.group.modules[0].logicModule
+}
+
+func (m *moduleContext) FinalModule() Module {
+ return m.module.group.modules[len(m.module.group.modules)-1].logicModule
+}
+
+func (m *moduleContext) VisitAllModuleVariants(visit func(Module)) {
+ m.context.visitAllModuleVariants(m.module, visit)
+}
+
func (m *moduleContext) GetMissingDependencies() []string {
m.handledMissingDeps = true
return m.module.missingDeps
@@ -789,10 +691,9 @@
reverseDeps []reverseDep
rename []rename
replace []replace
- newVariations modulesOrAliases // new variants of existing modules
- newModules []*moduleInfo // brand new modules
+ newVariations []*moduleInfo // new variants of existing modules
+ newModules []*moduleInfo // brand new modules
defaultVariation *string
- pauseCh chan<- pauseSpec
}
type BaseMutatorContext interface {
@@ -843,15 +744,10 @@
type BottomUpMutatorContext interface {
BaseMutatorContext
- // AddDependency adds a dependency to the given module. It returns a slice of modules for each
- // dependency (some entries may be nil). Does not affect the ordering of the current mutator
- // pass, but will be ordered correctly for all future mutator passes.
- //
- // If the mutator is parallel (see MutatorHandle.Parallel), this method will pause until the
- // new dependencies have had the current mutator called on them. If the mutator is not
- // parallel this method does not affect the ordering of the current mutator pass, but will
- // be ordered correctly for all future mutator passes.
- AddDependency(module Module, tag DependencyTag, name ...string) []Module
+ // AddDependency adds a dependency to the given module.
+ // Does not affect the ordering of the current mutator pass, but will be ordered
+ // correctly for all future mutator passes.
+ AddDependency(module Module, tag DependencyTag, name ...string)
// AddReverseDependency adds a dependency from the destination to the given module.
// Does not affect the ordering of the current mutator pass, but will be ordered
@@ -891,30 +787,19 @@
SetDefaultDependencyVariation(*string)
// AddVariationDependencies adds deps as dependencies of the current module, but uses the variations
- // argument to select which variant of the dependency to use. It returns a slice of modules for
- // each dependency (some entries may be nil). A variant of the dependency must exist that matches
- // the all of the non-local variations of the current module, plus the variations argument.
- //
- // If the mutator is parallel (see MutatorHandle.Parallel), this method will pause until the
- // new dependencies have had the current mutator called on them. If the mutator is not
- // parallel this method does not affect the ordering of the current mutator pass, but will
- // be ordered correctly for all future mutator passes.
- AddVariationDependencies([]Variation, DependencyTag, ...string) []Module
+ // argument to select which variant of the dependency to use. A variant of the dependency must
+ // exist that matches the all of the non-local variations of the current module, plus the variations
+ // argument.
+ AddVariationDependencies([]Variation, DependencyTag, ...string)
// AddFarVariationDependencies adds deps as dependencies of the current module, but uses the
- // variations argument to select which variant of the dependency to use. It returns a slice of
- // modules for each dependency (some entries may be nil). A variant of the dependency must
- // exist that matches the variations argument, but may also have other variations.
+ // variations argument to select which variant of the dependency to use. A variant of the
+ // dependency must exist that matches the variations argument, but may also have other variations.
// For any unspecified variation the first variant will be used.
//
// Unlike AddVariationDependencies, the variations of the current module are ignored - the
// dependency only needs to match the supplied variations.
- //
- // If the mutator is parallel (see MutatorHandle.Parallel), this method will pause until the
- // new dependencies have had the current mutator called on them. If the mutator is not
- // parallel this method does not affect the ordering of the current mutator pass, but will
- // be ordered correctly for all future mutator passes.
- AddFarVariationDependencies([]Variation, DependencyTag, ...string) []Module
+ AddFarVariationDependencies([]Variation, DependencyTag, ...string)
// AddInterVariantDependency adds a dependency between two variants of the same module. Variants are always
// ordered in the same orderas they were listed in CreateVariations, and AddInterVariantDependency does not change
@@ -927,36 +812,12 @@
// after the mutator pass is finished.
ReplaceDependencies(string)
- // ReplaceDependencies replaces all dependencies on the identical variant of the module with the
- // specified name with the current variant of this module as long as the supplied predicate returns
- // true.
- //
- // Replacements don't take effect until after the mutator pass is finished.
- ReplaceDependenciesIf(string, ReplaceDependencyPredicate)
-
- // AliasVariation takes a variationName that was passed to CreateVariations for this module,
- // and creates an alias from the current variant (before the mutator has run) to the new
- // variant. The alias will be valid until the next time a mutator calls CreateVariations or
- // CreateLocalVariations on this module without also calling AliasVariation. The alias can
- // be used to add dependencies on the newly created variant using the variant map from
- // before CreateVariations was run.
+ // AliasVariation takes a variationName that was passed to CreateVariations for this module, and creates an
+ // alias from the current variant to the new variant. The alias will be valid until the next time a mutator
+ // calls CreateVariations or CreateLocalVariations on this module without also calling AliasVariation. The
+ // alias can be used to add dependencies on the newly created variant using the variant map from before
+ // CreateVariations was run.
AliasVariation(variationName string)
-
- // CreateAliasVariation takes a toVariationName that was passed to CreateVariations for this
- // module, and creates an alias from a new fromVariationName variant the toVariationName
- // variant. The alias will be valid until the next time a mutator calls CreateVariations or
- // CreateLocalVariations on this module without also calling AliasVariation. The alias can
- // be used to add dependencies on the toVariationName variant using the fromVariationName
- // variant.
- CreateAliasVariation(fromVariationName, toVariationName string)
-
- // SetVariationProvider sets the value for a provider for the given newly created variant of
- // the current module, i.e. one of the Modules returned by CreateVariations.. It panics if
- // not called during the appropriate mutator or GenerateBuildActions pass for the provider,
- // if the value is not of the appropriate type, or if the module is not a newly created
- // variant of the current module. The value should not be modified after being passed to
- // SetVariationProvider.
- SetVariationProvider(module Module, provider ProviderKey, value interface{})
}
// A Mutator function is called for each Module, and can use
@@ -1000,30 +861,21 @@
return mctx.createVariations(variationNames, true)
}
-func (mctx *mutatorContext) SetVariationProvider(module Module, provider ProviderKey, value interface{}) {
- for _, variant := range mctx.newVariations {
- if m := variant.module(); m != nil && m.logicModule == module {
- mctx.context.setProvider(m, provider, value)
- return
- }
- }
- panic(fmt.Errorf("module %q is not a newly created variant of %q", module, mctx.module))
-}
-
-type pendingAlias struct {
- fromVariant variant
- target *moduleInfo
-}
-
func (mctx *mutatorContext) createVariations(variationNames []string, local bool) []Module {
ret := []Module{}
- modules, errs := mctx.context.createVariations(mctx.module, mctx.name, mctx.defaultVariation, variationNames, local)
+ modules, errs := mctx.context.createVariations(mctx.module, mctx.name, mctx.defaultVariation, variationNames)
if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...)
}
- for _, module := range modules {
- ret = append(ret, module.module().logicModule)
+ for i, module := range modules {
+ ret = append(ret, module.logicModule)
+ if !local {
+ if module.dependencyVariant == nil {
+ module.dependencyVariant = make(variationMap)
+ }
+ module.dependencyVariant[mctx.name] = variationNames[i]
+ }
}
if mctx.newVariations != nil {
@@ -1039,65 +891,24 @@
}
func (mctx *mutatorContext) AliasVariation(variationName string) {
- for _, moduleOrAlias := range mctx.module.splitModules {
- if alias := moduleOrAlias.alias(); alias != nil {
- if alias.variant.variations.equal(mctx.module.variant.variations) {
- panic(fmt.Errorf("AliasVariation already called"))
- }
- }
+ if mctx.module.aliasTarget != nil {
+ panic(fmt.Errorf("AliasVariation already called"))
}
for _, variant := range mctx.newVariations {
- if variant.moduleOrAliasVariant().variations[mctx.name] == variationName {
- alias := &moduleAlias{
- variant: mctx.module.variant,
- target: variant.moduleOrAliasTarget(),
- }
- // Prepend the alias so that AddFarVariationDependencies subset match matches
- // the alias before matching the first variation.
- mctx.module.splitModules = append(modulesOrAliases{alias}, mctx.module.splitModules...)
+ if variant.variant[mctx.name] == variationName {
+ mctx.module.aliasTarget = variant
return
}
}
var foundVariations []string
for _, variant := range mctx.newVariations {
- foundVariations = append(foundVariations, variant.moduleOrAliasVariant().variations[mctx.name])
+ foundVariations = append(foundVariations, variant.variant[mctx.name])
}
panic(fmt.Errorf("no %q variation in module variations %q", variationName, foundVariations))
}
-func (mctx *mutatorContext) CreateAliasVariation(aliasVariationName, targetVariationName string) {
- newVariant := newVariant(mctx.module, mctx.name, aliasVariationName, false)
-
- for _, moduleOrAlias := range mctx.module.splitModules {
- if moduleOrAlias.moduleOrAliasVariant().variations.equal(newVariant.variations) {
- if alias := moduleOrAlias.alias(); alias != nil {
- panic(fmt.Errorf("can't alias %q to %q, already aliased to %q", aliasVariationName, targetVariationName, alias.target.variant.name))
- } else {
- panic(fmt.Errorf("can't alias %q to %q, there is already a variant with that name", aliasVariationName, targetVariationName))
- }
- }
- }
-
- for _, variant := range mctx.newVariations {
- if variant.moduleOrAliasVariant().variations[mctx.name] == targetVariationName {
- // Append the alias here so that it comes after any aliases created by AliasVariation.
- mctx.module.splitModules = append(mctx.module.splitModules, &moduleAlias{
- variant: newVariant,
- target: variant.moduleOrAliasTarget(),
- })
- return
- }
- }
-
- var foundVariations []string
- for _, variant := range mctx.newVariations {
- foundVariations = append(foundVariations, variant.moduleOrAliasVariant().variations[mctx.name])
- }
- panic(fmt.Errorf("no %q variation in module variations %q", targetVariationName, foundVariations))
-}
-
func (mctx *mutatorContext) SetDependencyVariation(variationName string) {
mctx.context.convertDepsToVariation(mctx.module, mctx.name, variationName, nil)
}
@@ -1110,21 +921,14 @@
return mctx.module.logicModule
}
-func (mctx *mutatorContext) AddDependency(module Module, tag DependencyTag, deps ...string) []Module {
- depInfos := make([]Module, 0, len(deps))
+func (mctx *mutatorContext) AddDependency(module Module, tag DependencyTag, deps ...string) {
for _, dep := range deps {
modInfo := mctx.context.moduleInfo[module]
- depInfo, errs := mctx.context.addDependency(modInfo, tag, dep)
+ errs := mctx.context.addDependency(modInfo, tag, dep)
if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...)
}
- if !mctx.pause(depInfo) {
- // Pausing not supported by this mutator, new dependencies can't be returned.
- depInfo = nil
- }
- depInfos = append(depInfos, maybeLogicModule(depInfo))
}
- return depInfos
}
func (mctx *mutatorContext) AddReverseDependency(module Module, tag DependencyTag, destName string) {
@@ -1145,39 +949,25 @@
}
func (mctx *mutatorContext) AddVariationDependencies(variations []Variation, tag DependencyTag,
- deps ...string) []Module {
+ deps ...string) {
- depInfos := make([]Module, 0, len(deps))
for _, dep := range deps {
- depInfo, errs := mctx.context.addVariationDependency(mctx.module, variations, tag, dep, false)
+ errs := mctx.context.addVariationDependency(mctx.module, variations, tag, dep, false)
if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...)
}
- if !mctx.pause(depInfo) {
- // Pausing not supported by this mutator, new dependencies can't be returned.
- depInfo = nil
- }
- depInfos = append(depInfos, maybeLogicModule(depInfo))
}
- return depInfos
}
func (mctx *mutatorContext) AddFarVariationDependencies(variations []Variation, tag DependencyTag,
- deps ...string) []Module {
+ deps ...string) {
- depInfos := make([]Module, 0, len(deps))
for _, dep := range deps {
- depInfo, errs := mctx.context.addVariationDependency(mctx.module, variations, tag, dep, true)
+ errs := mctx.context.addVariationDependency(mctx.module, variations, tag, dep, true)
if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...)
}
- if !mctx.pause(depInfo) {
- // Pausing not supported by this mutator, new dependencies can't be returned.
- depInfo = nil
- }
- depInfos = append(depInfos, maybeLogicModule(depInfo))
}
- return depInfos
}
func (mctx *mutatorContext) AddInterVariantDependency(tag DependencyTag, from, to Module) {
@@ -1185,23 +975,14 @@
}
func (mctx *mutatorContext) ReplaceDependencies(name string) {
- mctx.ReplaceDependenciesIf(name, nil)
-}
-
-type ReplaceDependencyPredicate func(from Module, tag DependencyTag, to Module) bool
-
-func (mctx *mutatorContext) ReplaceDependenciesIf(name string, predicate ReplaceDependencyPredicate) {
target := mctx.context.moduleMatchingVariant(mctx.module, name)
if target == nil {
- panic(fmt.Errorf("ReplaceDependencies could not find identical variant {%s} for module %s\n"+
- "available variants:\n %s",
- mctx.context.prettyPrintVariant(mctx.module.variant.variations),
- name,
- mctx.context.prettyPrintGroupVariants(mctx.context.moduleGroupFromName(name, mctx.module.namespace()))))
+ panic(fmt.Errorf("ReplaceDependencies could not find identical variant %q for module %q",
+ mctx.module.variantName, name))
}
- mctx.replace = append(mctx.replace, replace{target, mctx.module, predicate})
+ mctx.replace = append(mctx.replace, replace{target, mctx.module})
}
func (mctx *mutatorContext) Rename(name string) {
@@ -1228,26 +1009,6 @@
return module.logicModule
}
-// pause waits until the given dependency has been visited by the mutator's parallelVisit call.
-// It returns true if the pause was supported, false if the pause was not supported and did not
-// occur, which will happen when the mutator is not parallelizable. If the dependency is nil
-// it returns true if pausing is supported or false if it is not.
-func (mctx *mutatorContext) pause(dep *moduleInfo) bool {
- if mctx.pauseCh != nil {
- if dep != nil {
- unpause := make(unpause)
- mctx.pauseCh <- pauseSpec{
- paused: mctx.module,
- until: dep,
- unpause: unpause,
- }
- <-unpause
- }
- return true
- }
- return false
-}
-
// SimpleName is an embeddable object to implement the ModuleContext.Name method using a property
// called "name". Modules that embed it must also add SimpleName.Properties to their property
// structure list.
@@ -1339,7 +1100,7 @@
}
func runAndRemoveLoadHooks(ctx *Context, config interface{}, module *moduleInfo,
- scopedModuleFactories *map[string]ModuleFactory) (newModules []*moduleInfo, deps []string, errs []error) {
+ scopedModuleFactories *map[string]ModuleFactory) (newModules []*moduleInfo, errs []error) {
if v, exists := pendingHooks.Load(module.logicModule); exists {
hooks := v.(*[]LoadHook)
@@ -1355,21 +1116,21 @@
for _, hook := range *hooks {
hook(mctx)
newModules = append(newModules, mctx.newModules...)
- deps = append(deps, mctx.ninjaFileDeps...)
errs = append(errs, mctx.errs...)
}
pendingHooks.Delete(module.logicModule)
- return newModules, deps, errs
+ return newModules, errs
}
- return nil, nil, nil
+ return nil, nil
}
// Check the syntax of a generated blueprint file.
//
-// This is intended to perform a quick syntactic check for generated blueprint
-// code, where syntactically correct means:
+// This is intended to perform a quick sanity check for generated blueprint
+// code to ensure that it is syntactically correct, where syntactically correct
+// means:
// * No variable definitions.
// * Valid module types.
// * Valid property names.
@@ -1405,11 +1166,3 @@
return errs
}
-
-func maybeLogicModule(module *moduleInfo) Module {
- if module != nil {
- return module.logicModule
- } else {
- return nil
- }
-}
diff --git a/module_ctx_test.go b/module_ctx_test.go
index d57982e..e98ae82 100644
--- a/module_ctx_test.go
+++ b/module_ctx_test.go
@@ -32,7 +32,7 @@
func (f *moduleCtxTestModule) GenerateBuildActions(ModuleContext) {
}
-func noAliasMutator(name string) func(ctx BottomUpMutatorContext) {
+func noCreateAliasMutator(name string) func(ctx BottomUpMutatorContext) {
return func(ctx BottomUpMutatorContext) {
if ctx.ModuleName() == name {
ctx.CreateVariations("a", "b")
@@ -40,22 +40,11 @@
}
}
-func aliasMutator(name string) func(ctx BottomUpMutatorContext) {
- return func(ctx BottomUpMutatorContext) {
- if ctx.ModuleName() == name {
- ctx.CreateVariations("a", "b")
- ctx.AliasVariation("b")
- }
- }
-}
-
func createAliasMutator(name string) func(ctx BottomUpMutatorContext) {
return func(ctx BottomUpMutatorContext) {
if ctx.ModuleName() == name {
ctx.CreateVariations("a", "b")
- ctx.CreateAliasVariation("c", "a")
- ctx.CreateAliasVariation("d", "b")
- ctx.CreateAliasVariation("e", "a")
+ ctx.AliasVariation("b")
}
}
}
@@ -68,16 +57,7 @@
}
}
-func addVariantDepsResultMutator(variants []Variation, tag DependencyTag, from, to string, results map[string][]Module) func(ctx BottomUpMutatorContext) {
- return func(ctx BottomUpMutatorContext) {
- if ctx.ModuleName() == from {
- ret := ctx.AddVariationDependencies(variants, tag, to)
- results[ctx.ModuleName()] = ret
- }
- }
-}
-
-func TestAliasVariation(t *testing.T) {
+func TestAliases(t *testing.T) {
runWithFailures := func(ctx *Context, expectedErr string) {
t.Helper()
bp := `
@@ -135,13 +115,17 @@
// Tests a dependency from "foo" to "bar" variant "b" through alias "".
ctx := NewContext()
ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", aliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
ctx.RegisterBottomUpMutator("2", addVariantDepsMutator(nil, nil, "foo", "bar"))
run(ctx)
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- barB := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("b")
+ foo := ctx.moduleGroupFromName("foo", nil).modules[0]
+ barB := ctx.moduleGroupFromName("bar", nil).modules[1]
+
+ if g, w := barB.variantName, "b"; g != w {
+ t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g)
+ }
if g, w := foo.forwardDeps, []*moduleInfo{barB}; !reflect.DeepEqual(g, w) {
t.Fatalf("expected foo deps to be %q, got %q", w, g)
@@ -154,14 +138,18 @@
// Tests a dependency from "foo" to "bar" variant "b_b" through alias "".
ctx := NewContext()
ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", aliasMutator("bar"))
- ctx.RegisterBottomUpMutator("2", aliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("2", createAliasMutator("bar"))
ctx.RegisterBottomUpMutator("3", addVariantDepsMutator(nil, nil, "foo", "bar"))
run(ctx)
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- barBB := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("b_b")
+ foo := ctx.moduleGroupFromName("foo", nil).modules[0]
+ barBB := ctx.moduleGroupFromName("bar", nil).modules[3]
+
+ if g, w := barBB.variantName, "b_b"; g != w {
+ t.Fatalf("expected bar.modules[3] variant to be %q, got %q", w, g)
+ }
if g, w := foo.forwardDeps, []*moduleInfo{barBB}; !reflect.DeepEqual(g, w) {
t.Fatalf("expected foo deps to be %q, got %q", w, g)
@@ -174,14 +162,18 @@
// Tests a dependency from "foo" to "bar" variant "a_b" through alias "a".
ctx := NewContext()
ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", aliasMutator("bar"))
- ctx.RegisterBottomUpMutator("2", aliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("2", createAliasMutator("bar"))
ctx.RegisterBottomUpMutator("3", addVariantDepsMutator([]Variation{{"1", "a"}}, nil, "foo", "bar"))
run(ctx)
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- barAB := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("a_b")
+ foo := ctx.moduleGroupFromName("foo", nil).modules[0]
+ barAB := ctx.moduleGroupFromName("bar", nil).modules[1]
+
+ if g, w := barAB.variantName, "a_b"; g != w {
+ t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g)
+ }
if g, w := foo.forwardDeps, []*moduleInfo{barAB}; !reflect.DeepEqual(g, w) {
t.Fatalf("expected foo deps to be %q, got %q", w, g)
@@ -194,120 +186,13 @@
// Tests a dependency from "foo" to removed "bar" alias "" fails.
ctx := NewContext()
ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", aliasMutator("bar"))
- ctx.RegisterBottomUpMutator("2", noAliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+ ctx.RegisterBottomUpMutator("2", noCreateAliasMutator("bar"))
ctx.RegisterBottomUpMutator("3", addVariantDepsMutator(nil, nil, "foo", "bar"))
runWithFailures(ctx, `dependency "bar" of "foo" missing variant:`+"\n \n"+
"available variants:"+
- "\n 1:a,2:a\n 1:a,2:b\n 1:b,2:a\n 1:b,2:b")
- })
-}
-
-func TestCreateAliasVariations(t *testing.T) {
- runWithFailures := func(ctx *Context, expectedErr string) {
- t.Helper()
- bp := `
- test {
- name: "foo",
- }
-
- test {
- name: "bar",
- }
- `
-
- mockFS := map[string][]byte{
- "Blueprints": []byte(bp),
- }
-
- ctx.MockFileSystem(mockFS)
-
- _, errs := ctx.ParseFileList(".", []string{"Blueprints"}, nil)
- if len(errs) > 0 {
- t.Errorf("unexpected parse errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- }
-
- _, errs = ctx.ResolveDependencies(nil)
- if len(errs) > 0 {
- if expectedErr == "" {
- t.Errorf("unexpected dep errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- } else {
- for _, err := range errs {
- if strings.Contains(err.Error(), expectedErr) {
- continue
- } else {
- t.Errorf("unexpected dep error: %s", err)
- }
- }
- }
- } else if expectedErr != "" {
- t.Errorf("missing dep error: %s", expectedErr)
- }
- }
-
- run := func(ctx *Context) {
- t.Helper()
- runWithFailures(ctx, "")
- }
-
- t.Run("simple", func(t *testing.T) {
- // Creates a module "bar" with variants "a" and "b" and alias "c" -> "a", "d" -> "b", and "e" -> "a".
- // Tests a dependency from "foo" to "bar" variant "b" through alias "d".
- ctx := NewContext()
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
- ctx.RegisterBottomUpMutator("2", addVariantDepsMutator([]Variation{{"1", "d"}}, nil, "foo", "bar"))
-
- run(ctx)
-
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- barB := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("b")
-
- if g, w := foo.forwardDeps, []*moduleInfo{barB}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected foo deps to be %q, got %q", w, g)
- }
- })
-
- t.Run("chained", func(t *testing.T) {
- // Creates a module "bar" with variants "a_a", "a_b", "b_a" and "b_b" and aliases "c" -> "a_b",
- // "d" -> "b_b", and "d" -> "a_b".
- // Tests a dependency from "foo" to "bar" variant "b_b" through alias "d".
- ctx := NewContext()
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
- ctx.RegisterBottomUpMutator("2", aliasMutator("bar"))
- ctx.RegisterBottomUpMutator("3", addVariantDepsMutator([]Variation{{"1", "d"}}, nil, "foo", "bar"))
-
- run(ctx)
-
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- barBB := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("b_b")
-
- if g, w := foo.forwardDeps, []*moduleInfo{barBB}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected foo deps to be %q, got %q", w, g)
- }
- })
-
- t.Run("removed dangling alias", func(t *testing.T) {
- // Creates a module "bar" with variants "a" and "b" and alias "c" -> "a", "d" -> "b", and "e" -> "a",
- // then splits the variants into "a_a", "a_b", "b_a" and "b_b" without creating new aliases.
- // Tests a dependency from "foo" to removed "bar" alias "d" fails.
- ctx := NewContext()
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
- ctx.RegisterBottomUpMutator("2", noAliasMutator("bar"))
- ctx.RegisterBottomUpMutator("3", addVariantDepsMutator([]Variation{{"1", "d"}}, nil, "foo", "bar"))
-
- runWithFailures(ctx, `dependency "bar" of "foo" missing variant:`+"\n 1:d\n"+
- "available variants:"+
- "\n 1:a,2:a\n 1:a,2:b\n 1:b,2:a\n 1:b,2:b")
+ "\n 1:a, 2:a\n 1:a, 2:b\n 1:b, 2:a\n 1:b, 2:b")
})
}
@@ -325,141 +210,6 @@
}
}
-func TestAddVariationDependencies(t *testing.T) {
- runWithFailures := func(ctx *Context, expectedErr string) {
- t.Helper()
- bp := `
- test {
- name: "foo",
- }
-
- test {
- name: "bar",
- }
- `
-
- mockFS := map[string][]byte{
- "Blueprints": []byte(bp),
- }
-
- ctx.MockFileSystem(mockFS)
-
- _, errs := ctx.ParseFileList(".", []string{"Blueprints"}, nil)
- if len(errs) > 0 {
- t.Errorf("unexpected parse errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- }
-
- _, errs = ctx.ResolveDependencies(nil)
- if len(errs) > 0 {
- if expectedErr == "" {
- t.Errorf("unexpected dep errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- } else {
- for _, err := range errs {
- if strings.Contains(err.Error(), expectedErr) {
- continue
- } else {
- t.Errorf("unexpected dep error: %s", err)
- }
- }
- }
- } else if expectedErr != "" {
- t.Errorf("missing dep error: %s", expectedErr)
- }
- }
-
- run := func(ctx *Context) {
- t.Helper()
- runWithFailures(ctx, "")
- }
-
- t.Run("parallel", func(t *testing.T) {
- ctx := NewContext()
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- results := make(map[string][]Module)
- depsMutator := addVariantDepsResultMutator(nil, nil, "foo", "bar", results)
- ctx.RegisterBottomUpMutator("deps", depsMutator).Parallel()
-
- run(ctx)
-
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- bar := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("")
-
- if g, w := foo.forwardDeps, []*moduleInfo{bar}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected foo deps to be %q, got %q", w, g)
- }
-
- if g, w := results["foo"], []Module{bar.logicModule}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected AddVariationDependencies return value to be %q, got %q", w, g)
- }
- })
-
- t.Run("non-parallel", func(t *testing.T) {
- ctx := NewContext()
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- results := make(map[string][]Module)
- depsMutator := addVariantDepsResultMutator(nil, nil, "foo", "bar", results)
- ctx.RegisterBottomUpMutator("deps", depsMutator)
- run(ctx)
-
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
- bar := ctx.moduleGroupFromName("bar", nil).moduleByVariantName("")
-
- if g, w := foo.forwardDeps, []*moduleInfo{bar}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected foo deps to be %q, got %q", w, g)
- }
-
- if g, w := results["foo"], []Module{nil}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected AddVariationDependencies return value to be %q, got %q", w, g)
- }
- })
-
- t.Run("missing", func(t *testing.T) {
- ctx := NewContext()
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- results := make(map[string][]Module)
- depsMutator := addVariantDepsResultMutator(nil, nil, "foo", "baz", results)
- ctx.RegisterBottomUpMutator("deps", depsMutator).Parallel()
- runWithFailures(ctx, `"foo" depends on undefined module "baz"`)
-
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
-
- if g, w := foo.forwardDeps, []*moduleInfo(nil); !reflect.DeepEqual(g, w) {
- t.Fatalf("expected foo deps to be %q, got %q", w, g)
- }
-
- if g, w := results["foo"], []Module{nil}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected AddVariationDependencies return value to be %q, got %q", w, g)
- }
- })
-
- t.Run("allow missing", func(t *testing.T) {
- ctx := NewContext()
- ctx.SetAllowMissingDependencies(true)
- ctx.RegisterModuleType("test", newModuleCtxTestModule)
- results := make(map[string][]Module)
- depsMutator := addVariantDepsResultMutator(nil, nil, "foo", "baz", results)
- ctx.RegisterBottomUpMutator("deps", depsMutator).Parallel()
- run(ctx)
-
- foo := ctx.moduleGroupFromName("foo", nil).moduleByVariantName("")
-
- if g, w := foo.forwardDeps, []*moduleInfo(nil); !reflect.DeepEqual(g, w) {
- t.Fatalf("expected foo deps to be %q, got %q", w, g)
- }
-
- if g, w := results["foo"], []Module{nil}; !reflect.DeepEqual(g, w) {
- t.Fatalf("expected AddVariationDependencies return value to be %q, got %q", w, g)
- }
- })
-
-}
-
func TestCheckBlueprintSyntax(t *testing.T) {
factories := map[string]ModuleFactory{
"test": newModuleCtxTestModule,
diff --git a/name_interface.go b/name_interface.go
index 5e7e16e..1849e9d 100644
--- a/name_interface.go
+++ b/name_interface.go
@@ -109,7 +109,7 @@
return nil, []error{
// seven characters at the start of the second line to align with the string "error: "
fmt.Errorf("module %q already defined\n"+
- " %s <-- previous definition here", name, group.modules.firstModule().pos),
+ " %s <-- previous definition here", name, group.modules[0].pos),
}
}
@@ -130,7 +130,7 @@
// seven characters at the start of the second line to align with the string "error: "
fmt.Errorf("renaming module %q to %q conflicts with existing module\n"+
" %s <-- existing module defined here",
- oldName, newName, existingGroup.modules.firstModule().pos),
+ oldName, newName, existingGroup.modules[0].pos),
}
}
diff --git a/ninja_defs.go b/ninja_defs.go
index 69233c2..c5d0e4b 100644
--- a/ninja_defs.go
+++ b/ninja_defs.go
@@ -56,16 +56,15 @@
// definition.
type RuleParams struct {
// These fields correspond to a Ninja variable of the same name.
- Command string // The command that Ninja will run for the rule.
- Depfile string // The dependency file name.
- Deps Deps // The format of the dependency file.
- Description string // The description that Ninja will print for the rule.
- Generator bool // Whether the rule generates the Ninja manifest file.
- Pool Pool // The Ninja pool to which the rule belongs.
- Restat bool // Whether Ninja should re-stat the rule's outputs.
- Rspfile string // The response file.
- RspfileContent string // The response file content.
- SymlinkOutputs []string // The list of Outputs or ImplicitOutputs that are symlinks.
+ Command string // The command that Ninja will run for the rule.
+ Depfile string // The dependency file name.
+ Deps Deps // The format of the dependency file.
+ Description string // The description that Ninja will print for the rule.
+ Generator bool // Whether the rule generates the Ninja manifest file.
+ Pool Pool // The Ninja pool to which the rule belongs.
+ Restat bool // Whether Ninja should re-stat the rule's outputs.
+ Rspfile string // The response file.
+ RspfileContent string // The response file content.
// These fields are used internally in Blueprint
CommandDeps []string // Command-specific implicit dependencies to prepend to builds
@@ -85,11 +84,9 @@
Rule Rule // The rule to invoke.
Outputs []string // The list of explicit output targets.
ImplicitOutputs []string // The list of implicit output targets.
- SymlinkOutputs []string // The list of Outputs or ImplicitOutputs that are symlinks.
Inputs []string // The list of explicit input dependencies.
Implicits []string // The list of implicit input dependencies.
OrderOnly []string // The list of order-only dependencies.
- Validations []string // The list of validations to run when this rule runs.
Args map[string]string // The variable/value pairs to set.
Optional bool // Skip outputting a default statement
}
@@ -207,15 +204,6 @@
r.Variables["rspfile_content"] = value
}
- if len(params.SymlinkOutputs) > 0 {
- value, err = parseNinjaString(scope, strings.Join(params.SymlinkOutputs, " "))
- if err != nil {
- return nil, fmt.Errorf("error parsing SymlinkOutputs param: %s",
- err)
- }
- r.Variables["symlink_outputs"] = value
- }
-
r.CommandDeps, err = parseNinjaStrings(scope, params.CommandDeps)
if err != nil {
return nil, fmt.Errorf("error parsing CommandDeps param: %s", err)
@@ -269,7 +257,6 @@
Inputs []ninjaString
Implicits []ninjaString
OrderOnly []ninjaString
- Validations []ninjaString
Args map[Variable]ninjaString
Variables map[string]ninjaString
Optional bool
@@ -327,11 +314,6 @@
return nil, fmt.Errorf("error parsing OrderOnly param: %s", err)
}
- b.Validations, err = parseNinjaStrings(scope, params.Validations)
- if err != nil {
- return nil, fmt.Errorf("error parsing Validations param: %s", err)
- }
-
b.Optional = params.Optional
if params.Depfile != "" {
@@ -354,12 +336,6 @@
setVariable("description", value)
}
- if len(params.SymlinkOutputs) > 0 {
- setVariable(
- "symlink_outputs",
- simpleNinjaString(strings.Join(params.SymlinkOutputs, " ")))
- }
-
argNameScope := rule.scope()
if len(params.Args) > 0 {
@@ -392,50 +368,49 @@
var (
comment = b.Comment
rule = b.Rule.fullName(pkgNames)
- outputs = b.Outputs
- implicitOuts = b.ImplicitOutputs
- explicitDeps = b.Inputs
- implicitDeps = b.Implicits
- orderOnlyDeps = b.OrderOnly
- validations = b.Validations
+ outputs = valueList(b.Outputs, pkgNames, outputEscaper)
+ implicitOuts = valueList(b.ImplicitOutputs, pkgNames, outputEscaper)
+ explicitDeps = valueList(b.Inputs, pkgNames, inputEscaper)
+ implicitDeps = valueList(b.Implicits, pkgNames, inputEscaper)
+ orderOnlyDeps = valueList(b.OrderOnly, pkgNames, inputEscaper)
)
if b.RuleDef != nil {
- implicitDeps = append(b.RuleDef.CommandDeps, implicitDeps...)
- orderOnlyDeps = append(b.RuleDef.CommandOrderOnly, orderOnlyDeps...)
+ implicitDeps = append(valueList(b.RuleDef.CommandDeps, pkgNames, inputEscaper), implicitDeps...)
+ orderOnlyDeps = append(valueList(b.RuleDef.CommandOrderOnly, pkgNames, inputEscaper), orderOnlyDeps...)
}
- err := nw.Build(comment, rule, outputs, implicitOuts, explicitDeps, implicitDeps, orderOnlyDeps, validations, pkgNames)
+ err := nw.Build(comment, rule, outputs, implicitOuts, explicitDeps, implicitDeps, orderOnlyDeps)
if err != nil {
return err
}
+ args := make(map[string]string)
+
+ for argVar, value := range b.Args {
+ args[argVar.fullName(pkgNames)] = value.Value(pkgNames)
+ }
+
err = writeVariables(nw, b.Variables, pkgNames)
if err != nil {
return err
}
- type nameValuePair struct {
- name, value string
+ var keys []string
+ for k := range args {
+ keys = append(keys, k)
}
+ sort.Strings(keys)
- args := make([]nameValuePair, 0, len(b.Args))
-
- for argVar, value := range b.Args {
- fullName := argVar.fullName(pkgNames)
- args = append(args, nameValuePair{fullName, value.Value(pkgNames)})
- }
- sort.Slice(args, func(i, j int) bool { return args[i].name < args[j].name })
-
- for _, pair := range args {
- err = nw.ScopedAssign(pair.name, pair.value)
+ for _, name := range keys {
+ err = nw.ScopedAssign(name, args[name])
if err != nil {
return err
}
}
if !b.Optional {
- err = nw.Default(pkgNames, outputs...)
+ err = nw.Default(outputs...)
if err != nil {
return err
}
@@ -444,6 +419,16 @@
return nw.BlankLine()
}
+func valueList(list []ninjaString, pkgNames map[*packageContext]string,
+ escaper *strings.Replacer) []string {
+
+ result := make([]string, len(list))
+ for i, ninjaStr := range list {
+ result[i] = ninjaStr.ValueWithEscaper(pkgNames, escaper)
+ }
+ return result
+}
+
func writeVariables(nw *ninjaWriter, variables map[string]ninjaString,
pkgNames map[*packageContext]string) error {
var keys []string
diff --git a/ninja_strings.go b/ninja_strings.go
index 51a167d..190cae9 100644
--- a/ninja_strings.go
+++ b/ninja_strings.go
@@ -17,7 +17,6 @@
import (
"bytes"
"fmt"
- "io"
"strings"
)
@@ -37,7 +36,7 @@
type ninjaString interface {
Value(pkgNames map[*packageContext]string) string
- ValueWithEscaper(w io.StringWriter, pkgNames map[*packageContext]string, escaper *strings.Replacer)
+ ValueWithEscaper(pkgNames map[*packageContext]string, escaper *strings.Replacer) string
Eval(variables map[Variable]ninjaString) (string, error)
Variables() []Variable
}
@@ -285,24 +284,26 @@
}
func (n varNinjaString) Value(pkgNames map[*packageContext]string) string {
- if len(n.strings) == 1 {
- return defaultEscaper.Replace(n.strings[0])
- }
- str := &strings.Builder{}
- n.ValueWithEscaper(str, pkgNames, defaultEscaper)
- return str.String()
+ return n.ValueWithEscaper(pkgNames, defaultEscaper)
}
-func (n varNinjaString) ValueWithEscaper(w io.StringWriter, pkgNames map[*packageContext]string,
- escaper *strings.Replacer) {
+func (n varNinjaString) ValueWithEscaper(pkgNames map[*packageContext]string,
+ escaper *strings.Replacer) string {
- w.WriteString(escaper.Replace(n.strings[0]))
- for i, v := range n.variables {
- w.WriteString("${")
- w.WriteString(v.fullName(pkgNames))
- w.WriteString("}")
- w.WriteString(escaper.Replace(n.strings[i+1]))
+ if len(n.strings) == 1 {
+ return escaper.Replace(n.strings[0])
}
+
+ str := strings.Builder{}
+ str.WriteString(escaper.Replace(n.strings[0]))
+ for i, v := range n.variables {
+ str.WriteString("${")
+ str.WriteString(v.fullName(pkgNames))
+ str.WriteString("}")
+ str.WriteString(escaper.Replace(n.strings[i+1]))
+ }
+
+ return str.String()
}
func (n varNinjaString) Eval(variables map[Variable]ninjaString) (string, error) {
@@ -326,12 +327,12 @@
}
func (l literalNinjaString) Value(pkgNames map[*packageContext]string) string {
- return defaultEscaper.Replace(string(l))
+ return l.ValueWithEscaper(pkgNames, defaultEscaper)
}
-func (l literalNinjaString) ValueWithEscaper(w io.StringWriter, pkgNames map[*packageContext]string,
- escaper *strings.Replacer) {
- w.WriteString(escaper.Replace(string(l)))
+func (l literalNinjaString) ValueWithEscaper(pkgNames map[*packageContext]string,
+ escaper *strings.Replacer) string {
+ return escaper.Replace(string(l))
}
func (l literalNinjaString) Eval(variables map[Variable]ninjaString) (string, error) {
diff --git a/ninja_writer.go b/ninja_writer.go
index f9951b4..5366f3f 100644
--- a/ninja_writer.go
+++ b/ninja_writer.go
@@ -15,6 +15,7 @@
package blueprint
import (
+ "fmt"
"io"
"strings"
"unicode"
@@ -28,18 +29,13 @@
var indentString = strings.Repeat(" ", indentWidth*maxIndentDepth)
-type StringWriterWriter interface {
- io.StringWriter
- io.Writer
-}
-
type ninjaWriter struct {
- writer io.StringWriter
+ writer io.Writer
justDidBlankLine bool // true if the last operation was a BlankLine
}
-func newNinjaWriter(writer io.StringWriter) *ninjaWriter {
+func newNinjaWriter(writer io.Writer) *ninjaWriter {
return &ninjaWriter{
writer: writer,
}
@@ -76,7 +72,7 @@
if writeLine {
line = strings.TrimSpace("# "+line) + "\n"
- _, err := n.writer.WriteString(line)
+ _, err := io.WriteString(n.writer, line)
if err != nil {
return err
}
@@ -86,15 +82,7 @@
if lineStart != len(comment) {
line := strings.TrimSpace(comment[lineStart:])
- _, err := n.writer.WriteString("# ")
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(line)
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString("\n")
+ _, err := fmt.Fprintf(n.writer, "# %s\n", line)
if err != nil {
return err
}
@@ -105,24 +93,25 @@
func (n *ninjaWriter) Pool(name string) error {
n.justDidBlankLine = false
- return n.writeStatement("pool", name)
+ _, err := fmt.Fprintf(n.writer, "pool %s\n", name)
+ return err
}
func (n *ninjaWriter) Rule(name string) error {
n.justDidBlankLine = false
- return n.writeStatement("rule", name)
+ _, err := fmt.Fprintf(n.writer, "rule %s\n", name)
+ return err
}
func (n *ninjaWriter) Build(comment string, rule string, outputs, implicitOuts,
- explicitDeps, implicitDeps, orderOnlyDeps, validations []ninjaString,
- pkgNames map[*packageContext]string) error {
+ explicitDeps, implicitDeps, orderOnlyDeps []string) error {
n.justDidBlankLine = false
const lineWrapLen = len(" $")
const maxLineLen = lineWidth - lineWrapLen
- wrapper := &ninjaWriterWithWrap{
+ wrapper := ninjaWriterWithWrap{
ninjaWriter: n,
maxLineLen: maxLineLen,
}
@@ -137,16 +126,14 @@
wrapper.WriteString("build")
for _, output := range outputs {
- wrapper.Space()
- output.ValueWithEscaper(wrapper, pkgNames, outputEscaper)
+ wrapper.WriteStringWithSpace(output)
}
if len(implicitOuts) > 0 {
wrapper.WriteStringWithSpace("|")
for _, out := range implicitOuts {
- wrapper.Space()
- out.ValueWithEscaper(wrapper, pkgNames, outputEscaper)
+ wrapper.WriteStringWithSpace(out)
}
}
@@ -155,16 +142,14 @@
wrapper.WriteStringWithSpace(rule)
for _, dep := range explicitDeps {
- wrapper.Space()
- dep.ValueWithEscaper(wrapper, pkgNames, inputEscaper)
+ wrapper.WriteStringWithSpace(dep)
}
if len(implicitDeps) > 0 {
wrapper.WriteStringWithSpace("|")
for _, dep := range implicitDeps {
- wrapper.Space()
- dep.ValueWithEscaper(wrapper, pkgNames, inputEscaper)
+ wrapper.WriteStringWithSpace(dep)
}
}
@@ -172,17 +157,7 @@
wrapper.WriteStringWithSpace("||")
for _, dep := range orderOnlyDeps {
- wrapper.Space()
- dep.ValueWithEscaper(wrapper, pkgNames, inputEscaper)
- }
- }
-
- if len(validations) > 0 {
- wrapper.WriteStringWithSpace("|@")
-
- for _, dep := range validations {
- wrapper.Space()
- dep.ValueWithEscaper(wrapper, pkgNames, inputEscaper)
+ wrapper.WriteStringWithSpace(dep)
}
}
@@ -191,57 +166,23 @@
func (n *ninjaWriter) Assign(name, value string) error {
n.justDidBlankLine = false
- _, err := n.writer.WriteString(name)
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(" = ")
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(value)
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString("\n")
- if err != nil {
- return err
- }
- return nil
+ _, err := fmt.Fprintf(n.writer, "%s = %s\n", name, value)
+ return err
}
func (n *ninjaWriter) ScopedAssign(name, value string) error {
n.justDidBlankLine = false
- _, err := n.writer.WriteString(indentString[:indentWidth])
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(name)
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(" = ")
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(value)
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString("\n")
- if err != nil {
- return err
- }
- return nil
+ _, err := fmt.Fprintf(n.writer, "%s%s = %s\n", indentString[:indentWidth], name, value)
+ return err
}
-func (n *ninjaWriter) Default(pkgNames map[*packageContext]string, targets ...ninjaString) error {
+func (n *ninjaWriter) Default(targets ...string) error {
n.justDidBlankLine = false
const lineWrapLen = len(" $")
const maxLineLen = lineWidth - lineWrapLen
- wrapper := &ninjaWriterWithWrap{
+ wrapper := ninjaWriterWithWrap{
ninjaWriter: n,
maxLineLen: maxLineLen,
}
@@ -249,8 +190,7 @@
wrapper.WriteString("default")
for _, target := range targets {
- wrapper.Space()
- target.ValueWithEscaper(wrapper, pkgNames, outputEscaper)
+ wrapper.WriteString(" " + target)
}
return wrapper.Flush()
@@ -258,157 +198,71 @@
func (n *ninjaWriter) Subninja(file string) error {
n.justDidBlankLine = false
- return n.writeStatement("subninja", file)
+ _, err := fmt.Fprintf(n.writer, "subninja %s\n", file)
+ return err
}
func (n *ninjaWriter) BlankLine() (err error) {
// We don't output multiple blank lines in a row.
if !n.justDidBlankLine {
n.justDidBlankLine = true
- _, err = n.writer.WriteString("\n")
+ _, err = io.WriteString(n.writer, "\n")
}
return err
}
-func (n *ninjaWriter) writeStatement(directive, name string) error {
- _, err := n.writer.WriteString(directive + " ")
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString(name)
- if err != nil {
- return err
- }
- _, err = n.writer.WriteString("\n")
- if err != nil {
- return err
- }
- return nil
-}
-
-// ninjaWriterWithWrap is an io.StringWriter that writes through to a ninjaWriter, but supports
-// user-readable line wrapping on boundaries when ninjaWriterWithWrap.Space is called.
-// It collects incoming calls to WriteString until either the line length is exceeded, in which case
-// it inserts a wrap before the pending strings and then writes them, or the next call to Space, in
-// which case it writes out the pending strings.
-//
-// WriteString never returns an error, all errors are held until Flush is called. Once an error has
-// occurred all writes become noops.
type ninjaWriterWithWrap struct {
*ninjaWriter
- // pending lists the strings that have been written since the last call to Space.
- pending []string
-
- // pendingLen accumulates the lengths of the strings in pending.
- pendingLen int
-
- // lineLen accumulates the number of bytes on the current line.
- lineLen int
-
- // maxLineLen is the length of the line before wrapping.
maxLineLen int
-
- // space is true if the strings in pending should be preceded by a space.
- space bool
-
- // err holds any error that has occurred to return in Flush.
- err error
+ writtenLen int
+ err error
}
-// WriteString writes the string to buffer, wrapping on a previous Space call if necessary.
-// It never returns an error, all errors are held until Flush is called.
-func (n *ninjaWriterWithWrap) WriteString(s string) (written int, noError error) {
- // Always return the full length of the string and a nil error.
- // ninjaWriterWithWrap doesn't return errors to the caller, it saves them until Flush()
- written = len(s)
-
+func (n *ninjaWriterWithWrap) writeString(s string, space bool) {
if n.err != nil {
return
}
- const spaceLen = 1
- if !n.space {
- // No space is pending, so a line wrap can't be inserted before this, so just write
- // the string.
- n.lineLen += len(s)
- _, n.err = n.writer.WriteString(s)
- } else if n.lineLen+len(s)+spaceLen > n.maxLineLen {
- // A space is pending, and the pending strings plus the current string would exceed the
- // maximum line length. Wrap and indent before the pending space and strings, then write
- // the pending and current strings.
- _, n.err = n.writer.WriteString(" $\n")
+ spaceLen := 0
+ if space {
+ spaceLen = 1
+ }
+
+ if n.writtenLen+len(s)+spaceLen > n.maxLineLen {
+ _, n.err = io.WriteString(n.writer, " $\n")
if n.err != nil {
return
}
- _, n.err = n.writer.WriteString(indentString[:indentWidth*2])
+ _, n.err = io.WriteString(n.writer, indentString[:indentWidth*2])
if n.err != nil {
return
}
- n.lineLen = indentWidth*2 + n.pendingLen
+ n.writtenLen = indentWidth * 2
s = strings.TrimLeftFunc(s, unicode.IsSpace)
- n.pending = append(n.pending, s)
- n.writePending()
-
- n.space = false
- } else {
- // A space is pending but the current string would not reach the maximum line length,
- // add it to the pending list.
- n.pending = append(n.pending, s)
- n.pendingLen += len(s)
- n.lineLen += len(s)
- }
-
- return
-}
-
-// Space inserts a space that is also a possible wrapping point into the string.
-func (n *ninjaWriterWithWrap) Space() {
- if n.err != nil {
- return
- }
- if n.space {
- // A space was already pending, and the space plus any strings written after the space did
- // not reach the maxmimum line length, so write out the old space and pending strings.
- _, n.err = n.writer.WriteString(" ")
- n.lineLen++
- n.writePending()
- }
- n.space = true
-}
-
-// writePending writes out all the strings stored in pending and resets it.
-func (n *ninjaWriterWithWrap) writePending() {
- if n.err != nil {
- return
- }
- for _, pending := range n.pending {
- _, n.err = n.writer.WriteString(pending)
+ } else if space {
+ _, n.err = io.WriteString(n.writer, " ")
if n.err != nil {
return
}
+ n.writtenLen++
}
- // Reset the length of pending back to 0 without reducing its capacity to avoid reallocating
- // the backing array.
- n.pending = n.pending[:0]
- n.pendingLen = 0
+
+ _, n.err = io.WriteString(n.writer, s)
+ n.writtenLen += len(s)
}
-// WriteStringWithSpace is a helper that calls Space and WriteString.
+func (n *ninjaWriterWithWrap) WriteString(s string) {
+ n.writeString(s, false)
+}
+
func (n *ninjaWriterWithWrap) WriteStringWithSpace(s string) {
- n.Space()
- _, _ = n.WriteString(s)
+ n.writeString(s, true)
}
-// Flush writes out any pending space or strings and then a newline. It also returns any errors
-// that have previously occurred.
func (n *ninjaWriterWithWrap) Flush() error {
- if n.space {
- _, n.err = n.writer.WriteString(" ")
- }
- n.writePending()
if n.err != nil {
return n.err
}
- _, err := n.writer.WriteString("\n")
+ _, err := io.WriteString(n.writer, "\n")
return err
}
diff --git a/ninja_writer_test.go b/ninja_writer_test.go
index 82eeee5..cc880e5 100644
--- a/ninja_writer_test.go
+++ b/ninja_writer_test.go
@@ -16,7 +16,6 @@
import (
"bytes"
- "strings"
"testing"
)
@@ -50,26 +49,14 @@
},
{
input: func(w *ninjaWriter) {
- ck(w.Build("foo comment", "foo", testNinjaStrings("o1", "o2"),
- testNinjaStrings("io1", "io2"), testNinjaStrings("e1", "e2"),
- testNinjaStrings("i1", "i2"), testNinjaStrings("oo1", "oo2"),
- testNinjaStrings("v1", "v2"), nil))
+ ck(w.Build("foo comment", "foo", []string{"o1", "o2"}, []string{"io1", "io2"},
+ []string{"e1", "e2"}, []string{"i1", "i2"}, []string{"oo1", "oo2"}))
},
- output: "# foo comment\nbuild o1 o2 | io1 io2: foo e1 e2 | i1 i2 || oo1 oo2 |@ v1 v2\n",
+ output: "# foo comment\nbuild o1 o2 | io1 io2: foo e1 e2 | i1 i2 || oo1 oo2\n",
},
{
input: func(w *ninjaWriter) {
- ck(w.Build("foo comment", "foo",
- testNinjaStrings(strings.Repeat("o", lineWidth)),
- nil,
- testNinjaStrings(strings.Repeat("i", lineWidth)),
- nil, nil, nil, nil))
- },
- output: "# foo comment\nbuild $\n " + strings.Repeat("o", lineWidth) + ": foo $\n " + strings.Repeat("i", lineWidth) + "\n",
- },
- {
- input: func(w *ninjaWriter) {
- ck(w.Default(nil, testNinjaStrings("foo")...))
+ ck(w.Default("foo"))
},
output: "default foo\n",
},
@@ -107,8 +94,7 @@
ck(w.ScopedAssign("command", "echo out: $out in: $in _arg: $_arg"))
ck(w.ScopedAssign("pool", "p"))
ck(w.BlankLine())
- ck(w.Build("r comment", "r", testNinjaStrings("foo.o"),
- nil, testNinjaStrings("foo.in"), nil, nil, nil, nil))
+ ck(w.Build("r comment", "r", []string{"foo.o"}, nil, []string{"foo.in"}, nil, nil))
ck(w.ScopedAssign("_arg", "arg value"))
},
output: `pool p
@@ -138,8 +124,3 @@
}
}
}
-
-func testNinjaStrings(s ...string) []ninjaString {
- ret, _ := parseNinjaStrings(nil, s)
- return ret
-}
diff --git a/package_ctx.go b/package_ctx.go
index af78772..088239e 100644
--- a/package_ctx.go
+++ b/package_ctx.go
@@ -250,10 +250,9 @@
}
type staticVariable struct {
- pctx *packageContext
- name_ string
- value_ string
- fullName_ string
+ pctx *packageContext
+ name_ string
+ value_ string
}
// StaticVariable returns a Variable whose value does not depend on any
@@ -272,11 +271,7 @@
panic(err)
}
- v := &staticVariable{
- pctx: p,
- name_: name,
- value_: value,
- }
+ v := &staticVariable{p, name, value}
err = p.scope.AddVariable(v)
if err != nil {
panic(err)
@@ -294,16 +289,9 @@
}
func (v *staticVariable) fullName(pkgNames map[*packageContext]string) string {
- if v.fullName_ != "" {
- return v.fullName_
- }
return packageNamespacePrefix(pkgNames[v.pctx]) + v.name_
}
-func (v *staticVariable) memoizeFullName(pkgNames map[*packageContext]string) {
- v.fullName_ = v.fullName(pkgNames)
-}
-
func (v *staticVariable) value(interface{}) (ninjaString, error) {
ninjaStr, err := parseNinjaString(v.pctx.scope, v.value_)
if err != nil {
@@ -318,10 +306,9 @@
}
type variableFunc struct {
- pctx *packageContext
- name_ string
- value_ func(interface{}) (string, error)
- fullName_ string
+ pctx *packageContext
+ name_ string
+ value_ func(interface{}) (string, error)
}
// VariableFunc returns a Variable whose value is determined by a function that
@@ -345,11 +332,7 @@
panic(err)
}
- v := &variableFunc{
- pctx: p,
- name_: name,
- value_: f,
- }
+ v := &variableFunc{p, name, f}
err = p.scope.AddVariable(v)
if err != nil {
panic(err)
@@ -388,11 +371,7 @@
return resultStr, nil
}
- v := &variableFunc{
- pctx: p,
- name_: name,
- value_: fun,
- }
+ v := &variableFunc{p, name, fun}
err = p.scope.AddVariable(v)
if err != nil {
panic(err)
@@ -410,16 +389,9 @@
}
func (v *variableFunc) fullName(pkgNames map[*packageContext]string) string {
- if v.fullName_ != "" {
- return v.fullName_
- }
return packageNamespacePrefix(pkgNames[v.pctx]) + v.name_
}
-func (v *variableFunc) memoizeFullName(pkgNames map[*packageContext]string) {
- v.fullName_ = v.fullName(pkgNames)
-}
-
func (v *variableFunc) value(config interface{}) (ninjaString, error) {
value, err := v.value_(config)
if err != nil {
@@ -480,10 +452,6 @@
return v.name_
}
-func (v *argVariable) memoizeFullName(pkgNames map[*packageContext]string) {
- // Nothing to do, full name is known at initialization.
-}
-
func (v *argVariable) value(config interface{}) (ninjaString, error) {
return nil, errVariableIsArg
}
@@ -493,10 +461,9 @@
}
type staticPool struct {
- pctx *packageContext
- name_ string
- params PoolParams
- fullName_ string
+ pctx *packageContext
+ name_ string
+ params PoolParams
}
// StaticPool returns a Pool whose value does not depend on any configuration
@@ -516,11 +483,7 @@
panic(err)
}
- pool := &staticPool{
- pctx: p,
- name_: name,
- params: params,
- }
+ pool := &staticPool{p, name, params}
err = p.scope.AddPool(pool)
if err != nil {
panic(err)
@@ -538,16 +501,9 @@
}
func (p *staticPool) fullName(pkgNames map[*packageContext]string) string {
- if p.fullName_ != "" {
- return p.fullName_
- }
return packageNamespacePrefix(pkgNames[p.pctx]) + p.name_
}
-func (p *staticPool) memoizeFullName(pkgNames map[*packageContext]string) {
- p.fullName_ = p.fullName(pkgNames)
-}
-
func (p *staticPool) def(config interface{}) (*poolDef, error) {
def, err := parsePoolParams(p.pctx.scope, &p.params)
if err != nil {
@@ -564,7 +520,6 @@
pctx *packageContext
name_ string
paramsFunc func(interface{}) (PoolParams, error)
- fullName_ string
}
// PoolFunc returns a Pool whose value is determined by a function that takes a
@@ -587,11 +542,7 @@
panic(err)
}
- pool := &poolFunc{
- pctx: p,
- name_: name,
- paramsFunc: f,
- }
+ pool := &poolFunc{p, name, f}
err = p.scope.AddPool(pool)
if err != nil {
panic(err)
@@ -609,16 +560,9 @@
}
func (p *poolFunc) fullName(pkgNames map[*packageContext]string) string {
- if p.fullName_ != "" {
- return p.fullName_
- }
return packageNamespacePrefix(pkgNames[p.pctx]) + p.name_
}
-func (p *poolFunc) memoizeFullName(pkgNames map[*packageContext]string) {
- p.fullName_ = p.fullName(pkgNames)
-}
-
func (p *poolFunc) def(config interface{}) (*poolDef, error) {
params, err := p.paramsFunc(config)
if err != nil {
@@ -651,10 +595,6 @@
return p.name_
}
-func (p *builtinPool) memoizeFullName(pkgNames map[*packageContext]string) {
- // Nothing to do, full name is known at initialization.
-}
-
func (p *builtinPool) def(config interface{}) (*poolDef, error) {
return nil, errPoolIsBuiltin
}
@@ -676,7 +616,6 @@
params RuleParams
argNames map[string]bool
scope_ *basicScope
- fullName_ string
sync.Mutex // protects scope_ during lazy creation
}
@@ -744,16 +683,9 @@
}
func (r *staticRule) fullName(pkgNames map[*packageContext]string) string {
- if r.fullName_ != "" {
- return r.fullName_
- }
return packageNamespacePrefix(pkgNames[r.pctx]) + r.name_
}
-func (r *staticRule) memoizeFullName(pkgNames map[*packageContext]string) {
- r.fullName_ = r.fullName(pkgNames)
-}
-
func (r *staticRule) def(interface{}) (*ruleDef, error) {
def, err := parseRuleParams(r.scope(), &r.params)
if err != nil {
@@ -789,7 +721,6 @@
paramsFunc func(interface{}) (RuleParams, error)
argNames map[string]bool
scope_ *basicScope
- fullName_ string
sync.Mutex // protects scope_ during lazy creation
}
@@ -858,16 +789,9 @@
}
func (r *ruleFunc) fullName(pkgNames map[*packageContext]string) string {
- if r.fullName_ != "" {
- return r.fullName_
- }
return packageNamespacePrefix(pkgNames[r.pctx]) + r.name_
}
-func (r *ruleFunc) memoizeFullName(pkgNames map[*packageContext]string) {
- r.fullName_ = r.fullName(pkgNames)
-}
-
func (r *ruleFunc) def(config interface{}) (*ruleDef, error) {
params, err := r.paramsFunc(config)
if err != nil {
@@ -919,10 +843,6 @@
return r.name_
}
-func (r *builtinRule) memoizeFullName(pkgNames map[*packageContext]string) {
- // Nothing to do, full name is known at initialization.
-}
-
func (r *builtinRule) def(config interface{}) (*ruleDef, error) {
return nil, errRuleIsBuiltin
}
diff --git a/parser/sort.go b/parser/sort.go
index 0379d45..da594db 100644
--- a/parser/sort.go
+++ b/parser/sort.go
@@ -15,105 +15,10 @@
package parser
import (
- "fmt"
"sort"
- "strconv"
- "strings"
"text/scanner"
)
-// numericStringLess compares two strings, returning a lexicographical comparison unless the first
-// difference occurs in a sequence of 1 or more numeric characters, in which case it returns the
-// numerical comparison of the two numbers.
-func numericStringLess(a, b string) bool {
- isNumeric := func(r rune) bool { return r >= '0' && r <= '9' }
- isNotNumeric := func(r rune) bool { return !isNumeric(r) }
-
- minLength := len(a)
- if len(b) < minLength {
- minLength = len(b)
- }
-
- byteIndex := 0
- numberStartIndex := -1
-
- var aByte, bByte byte
-
- // Start with a byte comparison to find where the strings differ.
- for ; byteIndex < minLength; byteIndex++ {
- aByte, bByte = a[byteIndex], b[byteIndex]
- if aByte != bByte {
- break
- }
- byteIsNumeric := isNumeric(rune(aByte))
- if numberStartIndex != -1 && !byteIsNumeric {
- numberStartIndex = -1
- } else if numberStartIndex == -1 && byteIsNumeric {
- numberStartIndex = byteIndex
- }
- }
-
- // Handle the case where we reached the end of one or both strings without finding a difference.
- if byteIndex == minLength {
- if len(a) < len(b) {
- // Reached the end of a. a is a prefix of b.
- return true
- } else {
- // Reached the end of b. b is a prefix of a or b is equal to a.
- return false
- }
- }
-
- aByteNumeric := isNumeric(rune(aByte))
- bByteNumeric := isNumeric(rune(bByte))
-
- if (aByteNumeric || bByteNumeric) && !(aByteNumeric && bByteNumeric) && numberStartIndex != -1 {
- // Only one of aByte and bByte is a number, but the previous byte was a number. That means
- // one is a longer number with the same prefix, which must be numerically larger. If bByte
- // is a number then the number in b is numerically larger than the number in a.
- return bByteNumeric
- }
-
- // If the bytes are both numbers do a numeric comparison.
- if aByteNumeric && bByteNumeric {
- // Extract the numbers from each string, starting from the first number after the last
- // non-number. This won't be invalid utf8 because we are only looking for the bytes
- //'0'-'9', which can only occur as single-byte runes in utf8.
- if numberStartIndex == -1 {
- numberStartIndex = byteIndex
- }
- aNumberString := a[numberStartIndex:]
- bNumberString := b[numberStartIndex:]
-
- // Find the first non-number in each, using the full length if there isn't one.
- endANumbers := strings.IndexFunc(aNumberString, isNotNumeric)
- endBNumbers := strings.IndexFunc(bNumberString, isNotNumeric)
- if endANumbers == -1 {
- endANumbers = len(aNumberString)
- }
- if endBNumbers == -1 {
- endBNumbers = len(bNumberString)
- }
-
- // Convert each to an int.
- aNumber, err := strconv.Atoi(aNumberString[:endANumbers])
- if err != nil {
- panic(fmt.Errorf("failed to convert %q from %q to number: %w",
- aNumberString[:endANumbers], a, err))
- }
- bNumber, err := strconv.Atoi(bNumberString[:endBNumbers])
- if err != nil {
- panic(fmt.Errorf("failed to convert %q from %q to number: %w",
- bNumberString[:endBNumbers], b, err))
- }
- // Do a numeric comparison.
- return aNumber < bNumber
- }
-
- // At least one is not a number, do a byte comparison.
- return aByte < bByte
-}
-
func SortLists(file *File) {
for _, def := range file.Defs {
if assignment, ok := def.(*Assignment); ok {
@@ -192,7 +97,7 @@
if !isListOfPrimitives(values) {
return
}
- l := make([]elem, len(values))
+ l := make(elemList, len(values))
for i, v := range values {
s, ok := v.(*String)
if !ok {
@@ -205,9 +110,7 @@
l[i] = elem{s.Value, i, v.Pos(), n}
}
- sort.SliceStable(l, func(i, j int) bool {
- return numericStringLess(l[i].s, l[j].s)
- })
+ sort.Sort(l)
copyValues := append([]Expression{}, values...)
copyComments := make([]*CommentGroup, len(file.Comments))
@@ -247,7 +150,7 @@
if !ok {
panic("list contains non-string element")
}
- if prev != "" && numericStringLess(s.Value, prev) {
+ if prev > s.Value {
return false
}
prev = s.Value
@@ -263,6 +166,20 @@
nextPos scanner.Position
}
+type elemList []elem
+
+func (l elemList) Len() int {
+ return len(l)
+}
+
+func (l elemList) Swap(i, j int) {
+ l[i], l[j] = l[j], l[i]
+}
+
+func (l elemList) Less(i, j int) bool {
+ return l[i].s < l[j].s
+}
+
type commentsByOffset []*CommentGroup
func (l commentsByOffset) Len() int {
diff --git a/parser/sort_test.go b/parser/sort_test.go
deleted file mode 100644
index 0a9e7fc..0000000
--- a/parser/sort_test.go
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2021 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 parser
-
-import "testing"
-
-func Test_numericStringLess(t *testing.T) {
- type args struct {
- a string
- b string
- }
- tests := []struct {
- a, b string
- }{
- {"a", "b"},
- {"aa", "ab"},
- {"aaa", "aba"},
-
- {"1", "2"},
- {"1", "11"},
- {"2", "11"},
- {"1", "12"},
-
- {"12", "101"},
- {"11", "102"},
-
- {"0", "1"},
- {"0", "01"},
- {"1", "02"},
- {"01", "002"},
- {"001", "02"},
- }
-
- oneTest := func(a, b string, want bool) {
- t.Helper()
- if got := numericStringLess(a, b); got != want {
- t.Errorf("want numericStringLess(%v, %v) = %v, got %v", a, b, want, got)
- }
- }
-
- for _, tt := range tests {
- t.Run(tt.a+"<"+tt.b, func(t *testing.T) {
- // a should be less than b
- oneTest(tt.a, tt.b, true)
- // b should not be less than a
- oneTest(tt.b, tt.a, false)
- // a should not be less than a
- oneTest(tt.a, tt.a, false)
- // b should not be less than b
- oneTest(tt.b, tt.b, false)
-
- // The same should be true both strings are prefixed with an "a"
- oneTest("a"+tt.a, "a"+tt.b, true)
- oneTest("a"+tt.b, "a"+tt.a, false)
- oneTest("a"+tt.a, "a"+tt.a, false)
- oneTest("a"+tt.b, "a"+tt.b, false)
-
- // The same should be true both strings are suffixed with an "a"
- oneTest(tt.a+"a", tt.b+"a", true)
- oneTest(tt.b+"a", tt.a+"a", false)
- oneTest(tt.a+"a", tt.a+"a", false)
- oneTest(tt.b+"a", tt.b+"a", false)
-
- // The same should be true both strings are suffixed with a "1"
- oneTest(tt.a+"1", tt.b+"1", true)
- oneTest(tt.b+"1", tt.a+"1", false)
- oneTest(tt.a+"1", tt.a+"1", false)
- oneTest(tt.b+"1", tt.b+"1", false)
-
- // The same should be true both strings are prefixed with a "0"
- oneTest("0"+tt.a, "0"+tt.b, true)
- oneTest("0"+tt.b, "0"+tt.a, false)
- oneTest("0"+tt.a, "0"+tt.a, false)
- oneTest("0"+tt.b, "0"+tt.b, false)
-
- // The same should be true both strings are suffixed with a "0"
- oneTest(tt.a+"0", tt.b+"0", true)
- oneTest(tt.b+"0", tt.a+"0", false)
- oneTest(tt.a+"0", tt.a+"0", false)
- oneTest(tt.b+"0", tt.b+"0", false)
-
- })
- }
-}
diff --git a/pathtools/fs.go b/pathtools/fs.go
index 806f466..21754d0 100644
--- a/pathtools/fs.go
+++ b/pathtools/fs.go
@@ -95,7 +95,7 @@
// Exists returns whether the file exists and whether it is a directory. Follows symlinks.
Exists(name string) (bool, bool, error)
- Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (GlobResult, error)
+ Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, dirs []string, err error)
glob(pattern string) (matches []string, err error)
// IsDir returns true if the path points to a directory, false it it points to a file. Follows symlinks.
@@ -194,7 +194,7 @@
}
}
-func (fs *osFs) Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (GlobResult, error) {
+func (fs *osFs) Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, dirs []string, err error) {
return startGlob(fs, pattern, excludes, follow)
}
@@ -346,7 +346,7 @@
return false, os.ErrNotExist
}
-func (m *mockFs) Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (GlobResult, error) {
+func (m *mockFs) Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, dirs []string, err error) {
return startGlob(m, pattern, excludes, follow)
}
@@ -538,22 +538,10 @@
continue
}
f = filepath.Join(name, f)
- var info os.FileInfo
- if follow == DontFollowSymlinks {
- info, err = fs.Lstat(f)
- if err != nil {
- continue
- }
- if info.Mode()&os.ModeSymlink != 0 {
- continue
- }
- } else {
- info, err = fs.Stat(f)
- if err != nil {
- continue
- }
+ if isSymlink, _ := fs.IsSymlink(f); isSymlink && follow == DontFollowSymlinks {
+ continue
}
- if info.IsDir() {
+ if isDir, _ := fs.IsDir(f); isDir {
dirs = append(dirs, f)
subDirs, err := listDirsRecursiveRelative(fs, f, follow, depth)
if err != nil {
diff --git a/pathtools/glob.go b/pathtools/glob.go
index 14cdacf..727b725 100644
--- a/pathtools/glob.go
+++ b/pathtools/glob.go
@@ -15,69 +15,20 @@
package pathtools
import (
- "encoding/json"
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
-)
-// BPGlobArgumentVersion is used to abort argument parsing early when the bpglob argument format
-// has changed but soong_build hasn't had a chance to rerun yet to update build-globs.ninja.
-// Increment it manually when changing the bpglob argument format. It is located here because
-// pathtools is the only package that is shared between bpglob and bootstrap.
-const BPGlobArgumentVersion = 2
+ "github.com/google/blueprint/deptools"
+)
var GlobMultipleRecursiveErr = errors.New("pattern contains multiple '**'")
var GlobLastRecursiveErr = errors.New("pattern has '**' as last path element")
var GlobInvalidRecursiveErr = errors.New("pattern contains other characters between '**' and path separator")
-// GlobResult is a container holding the results of a call to Glob.
-type GlobResult struct {
- // Pattern is the pattern that was passed to Glob.
- Pattern string
- // Excludes is the list of excludes that were passed to Glob.
- Excludes []string
-
- // Matches is the list of files or directories that matched the pattern but not the excludes.
- Matches []string
-
- // Deps is the list of files or directories that must be depended on to regenerate the glob.
- Deps []string
-}
-
-// FileList returns the list of files matched by a glob for writing to an output file.
-func (result GlobResult) FileList() []byte {
- return []byte(strings.Join(result.Matches, "\n") + "\n")
-}
-
-// MultipleGlobResults is a list of GlobResult structs.
-type MultipleGlobResults []GlobResult
-
-// FileList returns the list of files matched by a list of multiple globs for writing to an output file.
-func (results MultipleGlobResults) FileList() []byte {
- multipleMatches := make([][]string, len(results))
- for i, result := range results {
- multipleMatches[i] = result.Matches
- }
- buf, err := json.Marshal(multipleMatches)
- if err != nil {
- panic(fmt.Errorf("failed to marshal glob results to json: %w", err))
- }
- return buf
-}
-
-// Deps returns the deps from all of the GlobResults.
-func (results MultipleGlobResults) Deps() []string {
- var deps []string
- for _, result := range results {
- deps = append(deps, result.Deps...)
- }
- return deps
-}
-
// Glob returns the list of files and directories that match the given pattern
// but do not match the given exclude patterns, along with the list of
// directories and other dependencies that were searched to construct the file
@@ -89,26 +40,26 @@
// In general ModuleContext.GlobWithDeps or SingletonContext.GlobWithDeps
// should be used instead, as they will automatically set up dependencies
// to rerun the primary builder when the list of matching files changes.
-func Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (GlobResult, error) {
+func Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, deps []string, err error) {
return startGlob(OsFs, pattern, excludes, follow)
}
func startGlob(fs FileSystem, pattern string, excludes []string,
- follow ShouldFollowSymlinks) (GlobResult, error) {
+ follow ShouldFollowSymlinks) (matches, deps []string, err error) {
if filepath.Base(pattern) == "**" {
- return GlobResult{}, GlobLastRecursiveErr
+ return nil, nil, GlobLastRecursiveErr
+ } else {
+ matches, deps, err = glob(fs, pattern, false, follow)
}
- matches, deps, err := glob(fs, pattern, false, follow)
-
if err != nil {
- return GlobResult{}, err
+ return nil, nil, err
}
matches, err = filterExcludes(matches, excludes)
if err != nil {
- return GlobResult{}, err
+ return nil, nil, err
}
// If the pattern has wildcards, we added dependencies on the
@@ -125,27 +76,28 @@
}
for i, match := range matches {
- var info os.FileInfo
- if follow == DontFollowSymlinks {
- info, err = fs.Lstat(match)
- } else {
- info, err = fs.Stat(match)
- }
+ isSymlink, err := fs.IsSymlink(match)
if err != nil {
- return GlobResult{}, err
+ return nil, nil, err
}
+ if !(isSymlink && follow == DontFollowSymlinks) {
+ isDir, err := fs.IsDir(match)
+ if os.IsNotExist(err) {
+ if isSymlink {
+ return nil, nil, fmt.Errorf("%s: dangling symlink", match)
+ }
+ }
+ if err != nil {
+ return nil, nil, fmt.Errorf("%s: %s", match, err.Error())
+ }
- if info.IsDir() {
- matches[i] = match + "/"
+ if isDir {
+ matches[i] = match + "/"
+ }
}
}
- return GlobResult{
- Pattern: pattern,
- Excludes: excludes,
- Matches: matches,
- Deps: deps,
- }, nil
+ return matches, deps, nil
}
// glob is a recursive helper function to handle globbing each level of the pattern individually,
@@ -352,6 +304,30 @@
}
}
+func GlobPatternList(patterns []string, prefix string) (globedList []string, depDirs []string, err error) {
+ var (
+ matches []string
+ deps []string
+ )
+
+ globedList = make([]string, 0)
+ depDirs = make([]string, 0)
+
+ for _, pattern := range patterns {
+ if isWild(pattern) {
+ matches, deps, err = Glob(filepath.Join(prefix, pattern), nil, FollowSymlinks)
+ if err != nil {
+ return nil, nil, err
+ }
+ globedList = append(globedList, matches...)
+ depDirs = append(depDirs, deps...)
+ } else {
+ globedList = append(globedList, filepath.Join(prefix, pattern))
+ }
+ }
+ return globedList, depDirs, nil
+}
+
// IsGlob returns true if the pattern contains any glob characters (*, ?, or [).
func IsGlob(pattern string) bool {
return strings.IndexAny(pattern, "*?[") >= 0
@@ -368,6 +344,34 @@
return false
}
+// GlobWithDepFile finds all files and directories that match glob. Directories
+// will have a trailing '/'. It compares the list of matches against the
+// contents of fileListFile, and rewrites fileListFile if it has changed. It
+// also writes all of the the directories it traversed as dependencies on
+// fileListFile to depFile.
+//
+// The format of glob is either path/*.ext for a single directory glob, or
+// path/**/*.ext for a recursive glob.
+//
+// Returns a list of file paths, and an error.
+//
+// In general ModuleContext.GlobWithDeps or SingletonContext.GlobWithDeps
+// should be used instead, as they will automatically set up dependencies
+// to rerun the primary builder when the list of matching files changes.
+func GlobWithDepFile(glob, fileListFile, depFile string, excludes []string) (files []string, err error) {
+ files, deps, err := Glob(glob, excludes, FollowSymlinks)
+ if err != nil {
+ return nil, err
+ }
+
+ fileList := strings.Join(files, "\n") + "\n"
+
+ WriteFileIfChanged(fileListFile, []byte(fileList), 0666)
+ deptools.WriteDepFile(depFile, fileListFile, deps)
+
+ return
+}
+
// WriteFileIfChanged wraps ioutil.WriteFile, but only writes the file if
// the files does not already exist with identical contents. This can be used
// along with ninja restat rules to skip rebuilding downstream rules if no
diff --git a/pathtools/glob_test.go b/pathtools/glob_test.go
index d847bad..a3a36ff 100644
--- a/pathtools/glob_test.go
+++ b/pathtools/glob_test.go
@@ -723,7 +723,7 @@
func testGlob(t *testing.T, fs FileSystem, testCase globTestCase, follow ShouldFollowSymlinks) {
t.Helper()
- result, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
+ matches, deps, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
if err != testCase.err {
if err == nil {
t.Fatalf("missing error: %s", testCase.err)
@@ -733,22 +733,22 @@
return
}
- if !reflect.DeepEqual(result.Matches, testCase.matches) {
+ if !reflect.DeepEqual(matches, testCase.matches) {
t.Errorf("incorrect matches list:")
t.Errorf(" pattern: %q", testCase.pattern)
if testCase.excludes != nil {
t.Errorf("excludes: %q", testCase.excludes)
}
- t.Errorf(" got: %#v", result.Matches)
+ t.Errorf(" got: %#v", matches)
t.Errorf("expected: %#v", testCase.matches)
}
- if !reflect.DeepEqual(result.Deps, testCase.deps) {
+ if !reflect.DeepEqual(deps, testCase.deps) {
t.Errorf("incorrect deps list:")
t.Errorf(" pattern: %q", testCase.pattern)
if testCase.excludes != nil {
t.Errorf("excludes: %q", testCase.excludes)
}
- t.Errorf(" got: %#v", result.Deps)
+ t.Errorf(" got: %#v", deps)
t.Errorf("expected: %#v", testCase.deps)
}
}
@@ -904,14 +904,14 @@
mock := MockFs(mockFiles)
- result, err := mock.Glob(test.pattern, nil, DontFollowSymlinks)
- t.Log(test.name, test.pattern, result.Matches)
+ matches, _, err := mock.Glob(test.pattern, nil, DontFollowSymlinks)
+ t.Log(test.name, test.pattern, matches)
if err != nil {
t.Fatal(err)
}
match := false
- for _, x := range result.Matches {
+ for _, x := range matches {
if x == test.name {
match = true
}
diff --git a/pathtools/lists.go b/pathtools/lists.go
index e1838b3..fbde88a 100644
--- a/pathtools/lists.go
+++ b/pathtools/lists.go
@@ -38,12 +38,10 @@
return result
}
-// ReplaceExtension changes the file extension. If the file does not have an
-// extension, the new extension is appended.
func ReplaceExtension(path string, extension string) string {
- oldExt := filepath.Ext(path)
- if oldExt != "" {
- path = strings.TrimSuffix(path, oldExt)
+ dot := strings.LastIndex(path, ".")
+ if dot == -1 {
+ return path
}
- return path + "." + extension
+ return path[:dot+1] + extension
}
diff --git a/pathtools/lists_test.go b/pathtools/lists_test.go
deleted file mode 100644
index cce8786..0000000
--- a/pathtools/lists_test.go
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2021 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 pathtools
-
-import (
- "testing"
-)
-
-func TestLists_ReplaceExtension(t *testing.T) {
-
- testCases := []struct {
- from, ext, to string
- }{
- {"1.jpg", "png", "1.png"},
- {"1", "png", "1.png"},
- {"1.", "png", "1.png"},
- {"2.so", "so.1", "2.so.1"},
- {"/out/.test/1.png", "jpg", "/out/.test/1.jpg"},
- {"/out/.test/1", "jpg", "/out/.test/1.jpg"},
- }
-
- for _, test := range testCases {
- t.Run(test.from, func(t *testing.T) {
- got := ReplaceExtension(test.from, test.ext)
- if got != test.to {
- t.Errorf("ReplaceExtension(%v, %v) = %v; want: %v", test.from, test.ext, got, test.to)
- }
- })
- }
-}
diff --git a/proptools/escape.go b/proptools/escape.go
index b8790b5..e7f0456 100644
--- a/proptools/escape.go
+++ b/proptools/escape.go
@@ -56,44 +56,30 @@
}
-func shellUnsafeChar(r rune) bool {
- switch {
- case 'A' <= r && r <= 'Z',
- 'a' <= r && r <= 'z',
- '0' <= r && r <= '9',
- r == '_',
- r == '+',
- r == '-',
- r == '=',
- r == '.',
- r == ',',
- r == '/':
- return false
- default:
- return true
- }
-}
-
-// ShellEscape takes string that may contain characters that are meaningful to bash and
+// ShellEscapeList takes string that may contain characters that are meaningful to bash and
// escapes it if necessary by wrapping it in single quotes, and replacing internal single quotes with
// '\'' (one single quote to end the quoting, a shell-escaped single quote to insert a real single
// quote, and then a single quote to restarting quoting.
func ShellEscape(s string) string {
- shellUnsafeCharNotSpace := func(r rune) bool {
- return r != ' ' && shellUnsafeChar(r)
+ shellUnsafeChar := func(r rune) bool {
+ switch {
+ case 'A' <= r && r <= 'Z',
+ 'a' <= r && r <= 'z',
+ '0' <= r && r <= '9',
+ r == '_',
+ r == '+',
+ r == '-',
+ r == '=',
+ r == '.',
+ r == ',',
+ r == '/',
+ r == ' ':
+ return false
+ default:
+ return true
+ }
}
- if strings.IndexFunc(s, shellUnsafeCharNotSpace) == -1 {
- // No escaping necessary
- return s
- }
-
- return `'` + singleQuoteReplacer.Replace(s) + `'`
-}
-
-// ShellEscapeIncludingSpaces escapes the input `s` in a similar way to ShellEscape except that
-// this treats spaces as meaningful characters.
-func ShellEscapeIncludingSpaces(s string) string {
if strings.IndexFunc(s, shellUnsafeChar) == -1 {
// No escaping necessary
return s
diff --git a/proptools/escape_test.go b/proptools/escape_test.go
index 5823a05..633d711 100644
--- a/proptools/escape_test.go
+++ b/proptools/escape_test.go
@@ -91,24 +91,6 @@
},
}
-var shellEscapeIncludingSpacesTestCase = []escapeTestCase{
- {
- name: "no escaping",
- in: `test`,
- out: `test`,
- },
- {
- name: "spacing",
- in: `arg1 arg2`,
- out: `'arg1 arg2'`,
- },
- {
- name: "single quote",
- in: `'arg'`,
- out: `''\''arg'\'''`,
- },
-}
-
func TestNinjaEscaping(t *testing.T) {
for _, testCase := range ninjaEscapeTestCase {
got := NinjaEscape(testCase.in)
@@ -127,15 +109,6 @@
}
}
-func TestShellEscapeIncludingSpaces(t *testing.T) {
- for _, testCase := range shellEscapeIncludingSpacesTestCase {
- got := ShellEscapeIncludingSpaces(testCase.in)
- if got != testCase.out {
- t.Errorf("%s: expected `%s` got `%s`", testCase.name, testCase.out, got)
- }
- }
-}
-
func TestExternalShellEscaping(t *testing.T) {
if testing.Short() {
return
@@ -151,19 +124,3 @@
}
}
}
-
-func TestExternalShellEscapeIncludingSpaces(t *testing.T) {
- if testing.Short() {
- return
- }
- for _, testCase := range shellEscapeIncludingSpacesTestCase {
- cmd := "echo -n " + ShellEscapeIncludingSpaces(testCase.in)
- got, err := exec.Command("/bin/sh", "-c", cmd).Output()
- if err != nil {
- t.Error(err)
- }
- if string(got) != testCase.in {
- t.Errorf("%s: expected `%s` got `%s`", testCase.name, testCase.in, got)
- }
- }
-}
diff --git a/proptools/filter.go b/proptools/filter.go
index 54a20d5..e6b3336 100644
--- a/proptools/filter.go
+++ b/proptools/filter.go
@@ -173,13 +173,7 @@
return nil, true
}
- // If the predicate selected all fields in the structure then it is generally better to reuse the
- // original type as it avoids the footprint of creating another type. Also, if the original type
- // is a named type then it will reduce the size of any structs the caller may create that include
- // fields of this type. However, the original type should only be reused if it does not exceed
- // maxNameSize. That is, of course, more likely for an anonymous type than a named one but this
- // treats them the same.
- if !filtered && (maxNameSize < 0 || len(prop.String()) < maxNameSize) {
+ if !filtered {
if ptr {
return []reflect.Type{reflect.PtrTo(prop)}, false
}
diff --git a/proptools/filter_test.go b/proptools/filter_test.go
index 1c27cb2..0ea04bb 100644
--- a/proptools/filter_test.go
+++ b/proptools/filter_test.go
@@ -240,12 +240,6 @@
}
func TestFilterPropertyStructSharded(t *testing.T) {
- type KeepAllWithAReallyLongNameThatExceedsTheMaxNameSize struct {
- A *string `keep:"true"`
- B *string `keep:"true"`
- C *string `keep:"true"`
- }
-
tests := []struct {
name string
maxNameSize int
@@ -272,44 +266,6 @@
},
filtered: true,
},
- {
- name: "anonymous where all match but still needs sharding",
- maxNameSize: 20,
- in: &struct {
- A *string `keep:"true"`
- B *string `keep:"true"`
- C *string `keep:"true"`
- }{},
- out: []interface{}{
- &struct {
- A *string
- }{},
- &struct {
- B *string
- }{},
- &struct {
- C *string
- }{},
- },
- filtered: true,
- },
- {
- name: "named where all match but still needs sharding",
- maxNameSize: 20,
- in: &KeepAllWithAReallyLongNameThatExceedsTheMaxNameSize{},
- out: []interface{}{
- &struct {
- A *string
- }{},
- &struct {
- B *string
- }{},
- &struct {
- C *string
- }{},
- },
- filtered: true,
- },
}
for _, test := range tests {
diff --git a/proptools/proptools.go b/proptools/proptools.go
index 1da3ba4..2aa6e32 100644
--- a/proptools/proptools.go
+++ b/proptools/proptools.go
@@ -125,7 +125,3 @@
func isSlice(t reflect.Type) bool {
return t.Kind() == reflect.Slice
}
-
-func isSliceOfStruct(t reflect.Type) bool {
- return isSlice(t) && isStruct(t.Elem())
-}
diff --git a/proptools/tag.go b/proptools/tag.go
index b078894..d69853a 100644
--- a/proptools/tag.go
+++ b/proptools/tag.go
@@ -23,17 +23,10 @@
// HasTag returns true if a StructField has a tag in the form `name:"foo,value"`.
func HasTag(field reflect.StructField, name, value string) bool {
tag := field.Tag.Get(name)
- for len(tag) > 0 {
- idx := strings.Index(tag, ",")
-
- if idx < 0 {
- return tag == value
- }
- if tag[:idx] == value {
+ for _, entry := range strings.Split(tag, ",") {
+ if entry == value {
return true
}
-
- tag = tag[idx+1:]
}
return false
@@ -56,8 +49,8 @@
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
ft := field.Type
- if isStruct(ft) || isStructPtr(ft) || isSliceOfStruct(ft) {
- if ft.Kind() == reflect.Ptr || ft.Kind() == reflect.Slice {
+ if isStruct(ft) || isStructPtr(ft) {
+ if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
subIndexes := propertyIndexesWithTag(ft, key, value)
diff --git a/proptools/tag_test.go b/proptools/tag_test.go
index d466859..0041c54 100644
--- a/proptools/tag_test.go
+++ b/proptools/tag_test.go
@@ -19,16 +19,16 @@
"testing"
)
-type testType struct {
- NoTag string
- EmptyTag string ``
- OtherTag string `foo:"bar"`
- MatchingTag string `name:"value"`
- ExtraValues string `name:"foo,value,bar"`
- ExtraTags string `foo:"bar" name:"value"`
-}
-
func TestHasTag(t *testing.T) {
+ type testType struct {
+ NoTag string
+ EmptyTag string ``
+ OtherTag string `foo:"bar"`
+ MatchingTag string `name:"value"`
+ ExtraValues string `name:"foo,value,bar"`
+ ExtraTags string `foo:"bar" name:"value"`
+ }
+
tests := []struct {
field string
want bool
@@ -68,39 +68,6 @@
}
}
-func BenchmarkHasTag(b *testing.B) {
- tests := []struct {
- field string
- }{
- {
- field: "NoTag",
- },
- {
- field: "EmptyTag",
- },
- {
- field: "OtherTag",
- },
- {
- field: "MatchingTag",
- },
- {
- field: "ExtraValues",
- },
- {
- field: "ExtraTags",
- },
- }
- for _, test := range tests {
- b.Run(test.field, func(b *testing.B) {
- field, _ := reflect.TypeOf(testType{}).FieldByName(test.field)
- for i := 0; i < b.N; i++ {
- HasTag(field, "name", "value")
- }
- })
- }
-}
-
func TestPropertyIndexesWithTag(t *testing.T) {
tests := []struct {
name string
@@ -156,31 +123,6 @@
want: [][]int{{0, 0}},
},
{
- name: "slice of struct",
- ps: &struct {
- Other int
- Foo []struct {
- Other int
- Bar string `name:"value"`
- }
- }{},
- want: [][]int{{1, 1}},
- },
- {
- name: "slice^2 of struct",
- ps: &struct {
- Other int
- Foo []struct {
- Other int
- Bar []struct {
- Other int
- Baz string `name:"value"`
- }
- }
- }{},
- want: [][]int{{1, 1, 1}},
- },
- {
name: "nil",
ps: (*struct {
Foo string `name:"value"`
diff --git a/proptools/unpack.go b/proptools/unpack.go
index f6d9e95..4a0858c 100644
--- a/proptools/unpack.go
+++ b/proptools/unpack.go
@@ -280,14 +280,6 @@
}
if isStruct(fieldValue.Type()) {
- if property.Value.Eval().Type() != parser.MapType {
- ctx.addError(&UnpackError{
- fmt.Errorf("can't assign %s value to map property %q",
- property.Value.Type(), property.Name),
- property.Value.Pos(),
- })
- continue
- }
ctx.unpackToStruct(propertyName, fieldValue)
if len(ctx.errs) >= maxUnpackErrors {
return
@@ -315,11 +307,8 @@
sliceName string, property *parser.Property, sliceType reflect.Type) (reflect.Value, bool) {
propValueAsList, ok := property.Value.Eval().(*parser.List)
if !ok {
- ctx.addError(&UnpackError{
- fmt.Errorf("can't assign %s value to list property %q",
- property.Value.Type(), property.Name),
- property.Value.Pos(),
- })
+ ctx.addError(fmt.Errorf("%s: can't assign %s value to list property %q",
+ property.Value.Pos(), property.Value.Type(), property.Name))
return reflect.MakeSlice(sliceType, 0, 0), false
}
exprs := propValueAsList.Values
@@ -398,33 +387,24 @@
case reflect.Bool:
b, ok := property.Value.Eval().(*parser.Bool)
if !ok {
- return value, &UnpackError{
- fmt.Errorf("can't assign %s value to bool property %q",
- property.Value.Type(), property.Name),
- property.Value.Pos(),
- }
+ return value, fmt.Errorf("%s: can't assign %s value to bool property %q",
+ property.Value.Pos(), property.Value.Type(), property.Name)
}
value = reflect.ValueOf(b.Value)
case reflect.Int64:
b, ok := property.Value.Eval().(*parser.Int64)
if !ok {
- return value, &UnpackError{
- fmt.Errorf("can't assign %s value to int64 property %q",
- property.Value.Type(), property.Name),
- property.Value.Pos(),
- }
+ return value, fmt.Errorf("%s: can't assign %s value to int64 property %q",
+ property.Value.Pos(), property.Value.Type(), property.Name)
}
value = reflect.ValueOf(b.Value)
case reflect.String:
s, ok := property.Value.Eval().(*parser.String)
if !ok {
- return value, &UnpackError{
- fmt.Errorf("can't assign %s value to string property %q",
- property.Value.Type(), property.Name),
- property.Value.Pos(),
- }
+ return value, fmt.Errorf("%s: can't assign %s value to string property %q",
+ property.Value.Pos(), property.Value.Type(), property.Name)
}
value = reflect.ValueOf(s.Value)
diff --git a/proptools/unpack_test.go b/proptools/unpack_test.go
index 7e2751d..6a4d7b4 100644
--- a/proptools/unpack_test.go
+++ b/proptools/unpack_test.go
@@ -24,14 +24,12 @@
)
var validUnpackTestCases = []struct {
- name string
input string
output []interface{}
empty []interface{}
errs []error
}{
{
- name: "blank and unset",
input: `
m {
s: "abc",
@@ -52,7 +50,6 @@
},
{
- name: "string",
input: `
m {
s: "abc",
@@ -68,7 +65,6 @@
},
{
- name: "bool",
input: `
m {
isGood: true,
@@ -84,7 +80,6 @@
},
{
- name: "boolptr",
input: `
m {
isGood: true,
@@ -105,7 +100,6 @@
},
{
- name: "slice",
input: `
m {
stuff: ["asdf", "jkl;", "qwert",
@@ -129,35 +123,6 @@
},
{
- name: "double nested",
- input: `
- m {
- nested: {
- nested: {
- s: "abc",
- },
- },
- }
- `,
- output: []interface{}{
- &struct {
- Nested struct {
- Nested struct {
- S string
- }
- }
- }{
- Nested: struct{ Nested struct{ S string } }{
- Nested: struct{ S string }{
- S: "abc",
- },
- },
- },
- },
- },
-
- {
- name: "nested",
input: `
m {
nested: {
@@ -179,7 +144,6 @@
},
{
- name: "nested interface",
input: `
m {
nested: {
@@ -199,7 +163,6 @@
},
{
- name: "mixed",
input: `
m {
nested: {
@@ -227,7 +190,6 @@
},
{
- name: "filter",
input: `
m {
nested: {
@@ -258,7 +220,6 @@
// List of maps
{
- name: "list of structs",
input: `
m {
mapslist: [
@@ -293,7 +254,6 @@
// List of pointers to structs
{
- name: "list of pointers to structs",
input: `
m {
mapslist: [
@@ -328,7 +288,6 @@
// List of lists
{
- name: "list of lists",
input: `
m {
listoflists: [
@@ -351,7 +310,6 @@
// Multilevel
{
- name: "multilevel",
input: `
m {
name: "mymodule",
@@ -400,7 +358,6 @@
},
// Anonymous struct
{
- name: "embedded struct",
input: `
m {
s: "abc",
@@ -432,7 +389,6 @@
// Anonymous interface
{
- name: "embedded interface",
input: `
m {
s: "abc",
@@ -464,7 +420,6 @@
// Anonymous struct with name collision
{
- name: "embedded name collision",
input: `
m {
s: "abc",
@@ -501,7 +456,6 @@
// Anonymous interface with name collision
{
- name: "embeded interface name collision",
input: `
m {
s: "abc",
@@ -538,7 +492,6 @@
// Variables
{
- name: "variables",
input: `
list = ["abc"]
string = "def"
@@ -574,7 +527,6 @@
// Multiple property structs
{
- name: "multiple",
input: `
m {
nested: {
@@ -608,7 +560,6 @@
// Nil pointer to struct
{
- name: "nil struct pointer",
input: `
m {
nested: {
@@ -638,7 +589,6 @@
// Interface containing nil pointer to struct
{
- name: "interface nil struct pointer",
input: `
m {
nested: {
@@ -666,7 +616,6 @@
// Factory set properties
{
- name: "factory properties",
input: `
m {
string: "abc",
@@ -726,291 +675,61 @@
func TestUnpackProperties(t *testing.T) {
for _, testCase := range validUnpackTestCases {
- t.Run(testCase.name, func(t *testing.T) {
- r := bytes.NewBufferString(testCase.input)
- file, errs := parser.ParseAndEval("", r, parser.NewScope(nil))
- if len(errs) != 0 {
- t.Errorf("test case: %s", testCase.input)
- t.Errorf("unexpected parse errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- t.FailNow()
+ r := bytes.NewBufferString(testCase.input)
+ file, errs := parser.ParseAndEval("", r, parser.NewScope(nil))
+ if len(errs) != 0 {
+ t.Errorf("test case: %s", testCase.input)
+ t.Errorf("unexpected parse errors:")
+ for _, err := range errs {
+ t.Errorf(" %s", err)
+ }
+ t.FailNow()
+ }
+
+ for _, def := range file.Defs {
+ module, ok := def.(*parser.Module)
+ if !ok {
+ continue
}
- for _, def := range file.Defs {
- module, ok := def.(*parser.Module)
- if !ok {
- continue
- }
-
- var output []interface{}
- if len(testCase.empty) > 0 {
- for _, p := range testCase.empty {
- output = append(output, CloneProperties(reflect.ValueOf(p)).Interface())
- }
- } else {
- for _, p := range testCase.output {
- output = append(output, CloneEmptyProperties(reflect.ValueOf(p)).Interface())
- }
- }
-
- _, errs = UnpackProperties(module.Properties, output...)
- if len(errs) != 0 && len(testCase.errs) == 0 {
- t.Errorf("test case: %s", testCase.input)
- t.Errorf("unexpected unpack errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- t.FailNow()
- } else if !reflect.DeepEqual(errs, testCase.errs) {
- t.Errorf("test case: %s", testCase.input)
- t.Errorf("incorrect errors:")
- t.Errorf(" expected: %+v", testCase.errs)
- t.Errorf(" got: %+v", errs)
- }
-
- if len(output) != len(testCase.output) {
- t.Fatalf("incorrect number of property structs, expected %d got %d",
- len(testCase.output), len(output))
- }
-
- for i := range output {
- got := reflect.ValueOf(output[i]).Interface()
- if !reflect.DeepEqual(got, testCase.output[i]) {
- t.Errorf("test case: %s", testCase.input)
- t.Errorf("incorrect output:")
- t.Errorf(" expected: %+v", testCase.output[i])
- t.Errorf(" got: %+v", got)
- }
- }
- }
- })
- }
-}
-
-func TestUnpackErrors(t *testing.T) {
- testCases := []struct {
- name string
- input string
- output []interface{}
- errors []string
- }{
- {
- name: "missing",
- input: `
- m {
- missing: true,
- }
- `,
- output: []interface{}{},
- errors: []string{`<input>:3:13: unrecognized property "missing"`},
- },
- {
- name: "missing nested",
- input: `
- m {
- nested: {
- missing: true,
- },
- }
- `,
- output: []interface{}{
- &struct {
- Nested struct{}
- }{},
- },
- errors: []string{`<input>:4:14: unrecognized property "nested.missing"`},
- },
- {
- name: "mutated",
- input: `
- m {
- mutated: true,
- }
- `,
- output: []interface{}{
- &struct {
- Mutated bool `blueprint:"mutated"`
- }{},
- },
- errors: []string{`<input>:3:13: mutated field mutated cannot be set in a Blueprint file`},
- },
- {
- name: "nested mutated",
- input: `
- m {
- nested: {
- mutated: true,
- },
- }
- `,
- output: []interface{}{
- &struct {
- Nested struct {
- Mutated bool `blueprint:"mutated"`
- }
- }{},
- },
- errors: []string{`<input>:4:14: mutated field nested.mutated cannot be set in a Blueprint file`},
- },
- {
- name: "duplicate",
- input: `
- m {
- exists: true,
- exists: true,
- }
- `,
- output: []interface{}{
- &struct {
- Exists bool
- }{},
- },
- errors: []string{
- `<input>:4:12: property "exists" already defined`,
- `<input>:3:12: <-- previous definition here`,
- },
- },
- {
- name: "nested duplicate",
- input: `
- m {
- nested: {
- exists: true,
- exists: true,
- },
- }
- `,
- output: []interface{}{
- &struct {
- Nested struct {
- Exists bool
- }
- }{},
- },
- errors: []string{
- `<input>:5:13: property "nested.exists" already defined`,
- `<input>:4:13: <-- previous definition here`,
- },
- },
- {
- name: "wrong type",
- input: `
- m {
- int: "foo",
- }
- `,
- output: []interface{}{
- &struct {
- Int *int64
- }{},
- },
- errors: []string{
- `<input>:3:11: can't assign string value to int64 property "int"`,
- },
- },
- {
- name: "wrong type for map",
- input: `
- m {
- map: "foo",
- }
- `,
- output: []interface{}{
- &struct {
- Map struct {
- S string
- }
- }{},
- },
- errors: []string{
- `<input>:3:11: can't assign string value to map property "map"`,
- },
- },
- {
- name: "wrong type for list",
- input: `
- m {
- list: "foo",
- }
- `,
- output: []interface{}{
- &struct {
- List []string
- }{},
- },
- errors: []string{
- `<input>:3:12: can't assign string value to list property "list"`,
- },
- },
- {
- name: "wrong type for list of maps",
- input: `
- m {
- map_list: "foo",
- }
- `,
- output: []interface{}{
- &struct {
- Map_list []struct {
- S string
- }
- }{},
- },
- errors: []string{
- `<input>:3:16: can't assign string value to list property "map_list"`,
- },
- },
- }
-
- for _, testCase := range testCases {
- t.Run(testCase.name, func(t *testing.T) {
- r := bytes.NewBufferString(testCase.input)
- file, errs := parser.ParseAndEval("", r, parser.NewScope(nil))
- if len(errs) != 0 {
- t.Errorf("test case: %s", testCase.input)
- t.Errorf("unexpected parse errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- t.FailNow()
- }
-
- for _, def := range file.Defs {
- module, ok := def.(*parser.Module)
- if !ok {
- continue
- }
-
- var output []interface{}
+ var output []interface{}
+ if len(testCase.empty) > 0 {
+ output = testCase.empty
+ } else {
for _, p := range testCase.output {
output = append(output, CloneEmptyProperties(reflect.ValueOf(p)).Interface())
}
-
- _, errs = UnpackProperties(module.Properties, output...)
-
- printErrors := false
- for _, expectedErr := range testCase.errors {
- foundError := false
- for _, err := range errs {
- if err.Error() == expectedErr {
- foundError = true
- }
- }
- if !foundError {
- t.Errorf("expected error %s", expectedErr)
- printErrors = true
- }
+ }
+ _, errs = UnpackProperties(module.Properties, output...)
+ if len(errs) != 0 && len(testCase.errs) == 0 {
+ t.Errorf("test case: %s", testCase.input)
+ t.Errorf("unexpected unpack errors:")
+ for _, err := range errs {
+ t.Errorf(" %s", err)
}
- if printErrors {
- t.Errorf("got errors:")
- for _, err := range errs {
- t.Errorf(" %s", err.Error())
- }
+ t.FailNow()
+ } else if !reflect.DeepEqual(errs, testCase.errs) {
+ t.Errorf("test case: %s", testCase.input)
+ t.Errorf("incorrect errors:")
+ t.Errorf(" expected: %+v", testCase.errs)
+ t.Errorf(" got: %+v", errs)
+ }
+
+ if len(output) != len(testCase.output) {
+ t.Fatalf("incorrect number of property structs, expected %d got %d",
+ len(testCase.output), len(output))
+ }
+
+ for i := range output {
+ got := reflect.ValueOf(output[i]).Interface()
+ if !reflect.DeepEqual(got, testCase.output[i]) {
+ t.Errorf("test case: %s", testCase.input)
+ t.Errorf("incorrect output:")
+ t.Errorf(" expected: %+v", testCase.output[i])
+ t.Errorf(" got: %+v", got)
}
}
- })
+ }
}
}
diff --git a/provider.go b/provider.go
deleted file mode 100644
index b83e1d4..0000000
--- a/provider.go
+++ /dev/null
@@ -1,216 +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 blueprint
-
-import (
- "fmt"
- "reflect"
-)
-
-// This file implements Providers, modelled after Bazel
-// (https://docs.bazel.build/versions/master/skylark/rules.html#providers).
-// Each provider can be associated with a mutator, in which case the value for the provider for a
-// module can only be set during the mutator call for the module, and the value can only be
-// retrieved after the mutator call for the module. For providers not associated with a mutator, the
-// value can for the provider for a module can only be set during GenerateBuildActions for the
-// module, and the value can only be retrieved after GenerateBuildActions for the module.
-//
-// Providers are globally registered during init() and given a unique ID. The value of a provider
-// for a module is stored in an []interface{} indexed by the ID. If the value of a provider has
-// not been set, the value in the []interface{} will be nil.
-//
-// If the storage used by the provider value arrays becomes too large:
-// sizeof([]interface) * number of providers * number of modules that have a provider value set
-// then the storage can be replaced with something like a bitwise trie.
-//
-// The purpose of providers is to provide a serializable checkpoint between modules to enable
-// Blueprint to skip parts of the analysis phase when inputs haven't changed. To that end,
-// values passed to providers should be treated as immutable by callers to both the getters and
-// setters. Go doesn't provide any way to enforce immutability on arbitrary types, so it may be
-// necessary for the getters and setters to make deep copies of the values, likely extending
-// proptools.CloneProperties to do so.
-
-type provider struct {
- id int
- typ reflect.Type
- zero interface{}
- mutator string
-}
-
-type ProviderKey *provider
-
-var providerRegistry []ProviderKey
-
-// NewProvider returns a ProviderKey for the type of the given example value. The example value
-// is otherwise unused.
-//
-// The returned ProviderKey can be used to set a value of the ProviderKey's type for a module
-// inside GenerateBuildActions for the module, and to get the value from GenerateBuildActions from
-// any module later in the build graph.
-//
-// Once Go has generics the exampleValue parameter will not be necessary:
-// NewProvider(type T)() ProviderKey(T)
-func NewProvider(exampleValue interface{}) ProviderKey {
- return NewMutatorProvider(exampleValue, "")
-}
-
-// NewMutatorProvider returns a ProviderKey for the type of the given example value. The example
-// value is otherwise unused.
-//
-// The returned ProviderKey can be used to set a value of the ProviderKey's type for a module inside
-// the given mutator for the module, and to get the value from GenerateBuildActions from any
-// module later in the build graph in the same mutator, or any module in a later mutator or during
-// GenerateBuildActions.
-//
-// Once Go has generics the exampleValue parameter will not be necessary:
-// NewMutatorProvider(type T)(mutator string) ProviderKey(T)
-func NewMutatorProvider(exampleValue interface{}, mutator string) ProviderKey {
- checkCalledFromInit()
-
- typ := reflect.TypeOf(exampleValue)
- zero := reflect.Zero(typ).Interface()
-
- provider := &provider{
- id: len(providerRegistry),
- typ: typ,
- zero: zero,
- mutator: mutator,
- }
-
- providerRegistry = append(providerRegistry, provider)
-
- return provider
-}
-
-// initProviders fills c.providerMutators with the *mutatorInfo associated with each provider ID,
-// if any.
-func (c *Context) initProviders() {
- c.providerMutators = make([]*mutatorInfo, len(providerRegistry))
- for _, provider := range providerRegistry {
- for _, mutator := range c.mutatorInfo {
- if mutator.name == provider.mutator {
- c.providerMutators[provider.id] = mutator
- }
- }
- }
-}
-
-// setProvider sets the value for a provider on a moduleInfo. Verifies that it is called during the
-// appropriate mutator or GenerateBuildActions pass for the provider, and that the value is of the
-// appropriate type. The value should not be modified after being passed to setProvider.
-//
-// Once Go has generics the value parameter can be typed:
-// setProvider(type T)(m *moduleInfo, provider ProviderKey(T), value T)
-func (c *Context) setProvider(m *moduleInfo, provider ProviderKey, value interface{}) {
- if provider.mutator == "" {
- if !m.startedGenerateBuildActions {
- panic(fmt.Sprintf("Can't set value of provider %s before GenerateBuildActions started",
- provider.typ))
- } else if m.finishedGenerateBuildActions {
- panic(fmt.Sprintf("Can't set value of provider %s after GenerateBuildActions finished",
- provider.typ))
- }
- } else {
- expectedMutator := c.providerMutators[provider.id]
- if expectedMutator == nil {
- panic(fmt.Sprintf("Can't set value of provider %s associated with unregistered mutator %s",
- provider.typ, provider.mutator))
- } else if c.mutatorFinishedForModule(expectedMutator, m) {
- panic(fmt.Sprintf("Can't set value of provider %s after mutator %s finished",
- provider.typ, provider.mutator))
- } else if !c.mutatorStartedForModule(expectedMutator, m) {
- panic(fmt.Sprintf("Can't set value of provider %s before mutator %s started",
- provider.typ, provider.mutator))
- }
- }
-
- if typ := reflect.TypeOf(value); typ != provider.typ {
- panic(fmt.Sprintf("Value for provider has incorrect type, wanted %s, got %s",
- provider.typ, typ))
- }
-
- if m.providers == nil {
- m.providers = make([]interface{}, len(providerRegistry))
- }
-
- if m.providers[provider.id] != nil {
- panic(fmt.Sprintf("Value of provider %s is already set", provider.typ))
- }
-
- m.providers[provider.id] = value
-}
-
-// provider returns the value, if any, for a given provider for a module. Verifies that it is
-// called after the appropriate mutator or GenerateBuildActions pass for the provider on the module.
-// If the value for the provider was not set it returns the zero value of the type of the provider,
-// which means the return value can always be type-asserted to the type of the provider. The return
-// value should always be considered read-only.
-//
-// Once Go has generics the return value can be typed and the type assert by callers can be dropped:
-// provider(type T)(m *moduleInfo, provider ProviderKey(T)) T
-func (c *Context) provider(m *moduleInfo, provider ProviderKey) (interface{}, bool) {
- if provider.mutator == "" {
- if !m.finishedGenerateBuildActions {
- panic(fmt.Sprintf("Can't get value of provider %s before GenerateBuildActions finished",
- provider.typ))
- }
- } else {
- expectedMutator := c.providerMutators[provider.id]
- if expectedMutator != nil && !c.mutatorFinishedForModule(expectedMutator, m) {
- panic(fmt.Sprintf("Can't get value of provider %s before mutator %s finished",
- provider.typ, provider.mutator))
- }
- }
-
- if len(m.providers) > provider.id {
- if p := m.providers[provider.id]; p != nil {
- return p, true
- }
- }
-
- return provider.zero, false
-}
-
-func (c *Context) mutatorFinishedForModule(mutator *mutatorInfo, m *moduleInfo) bool {
- if c.finishedMutators[mutator] {
- // mutator pass finished for all modules
- return true
- }
-
- if c.startedMutator == mutator {
- // mutator pass started, check if it is finished for this module
- return m.finishedMutator == mutator
- }
-
- // mutator pass hasn't started
- return false
-}
-
-func (c *Context) mutatorStartedForModule(mutator *mutatorInfo, m *moduleInfo) bool {
- if c.finishedMutators[mutator] {
- // mutator pass finished for all modules
- return true
- }
-
- if c.startedMutator == mutator {
- // mutator pass is currently running
- if m.startedMutator == mutator {
- // mutator has started for this module
- return true
- }
- }
-
- return false
-}
diff --git a/provider_test.go b/provider_test.go
deleted file mode 100644
index 8f8def4..0000000
--- a/provider_test.go
+++ /dev/null
@@ -1,420 +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 blueprint
-
-import (
- "fmt"
- "reflect"
- "strings"
- "testing"
-)
-
-type providerTestModule struct {
- SimpleName
- properties struct {
- Deps []string
- }
-
- mutatorProviderValues []string
- generateBuildActionsProviderValues []string
-}
-
-func newProviderTestModule() (Module, []interface{}) {
- m := &providerTestModule{}
- return m, []interface{}{&m.properties, &m.SimpleName.Properties}
-}
-
-type providerTestMutatorInfo struct {
- Values []string
-}
-
-type providerTestGenerateBuildActionsInfo struct {
- Value string
-}
-
-type providerTestUnsetInfo string
-
-var providerTestMutatorInfoProvider = NewMutatorProvider(&providerTestMutatorInfo{}, "provider_mutator")
-var providerTestGenerateBuildActionsInfoProvider = NewProvider(&providerTestGenerateBuildActionsInfo{})
-var providerTestUnsetInfoProvider = NewMutatorProvider((providerTestUnsetInfo)(""), "provider_mutator")
-var providerTestUnusedMutatorProvider = NewMutatorProvider(&struct{ unused string }{}, "nonexistent_mutator")
-
-func (p *providerTestModule) GenerateBuildActions(ctx ModuleContext) {
- unset := ctx.Provider(providerTestUnsetInfoProvider).(providerTestUnsetInfo)
- if unset != "" {
- panic(fmt.Sprintf("expected zero value for providerTestGenerateBuildActionsInfoProvider before it was set, got %q",
- unset))
- }
-
- _ = ctx.Provider(providerTestUnusedMutatorProvider)
-
- ctx.SetProvider(providerTestGenerateBuildActionsInfoProvider, &providerTestGenerateBuildActionsInfo{
- Value: ctx.ModuleName(),
- })
-
- mp := ctx.Provider(providerTestMutatorInfoProvider).(*providerTestMutatorInfo)
- if mp != nil {
- p.mutatorProviderValues = mp.Values
- }
-
- ctx.VisitDirectDeps(func(module Module) {
- gbap := ctx.OtherModuleProvider(module, providerTestGenerateBuildActionsInfoProvider).(*providerTestGenerateBuildActionsInfo)
- if gbap != nil {
- p.generateBuildActionsProviderValues = append(p.generateBuildActionsProviderValues, gbap.Value)
- }
- })
-}
-
-func providerTestDepsMutator(ctx BottomUpMutatorContext) {
- if p, ok := ctx.Module().(*providerTestModule); ok {
- ctx.AddDependency(ctx.Module(), nil, p.properties.Deps...)
- }
-}
-
-func providerTestMutator(ctx BottomUpMutatorContext) {
- values := []string{strings.ToLower(ctx.ModuleName())}
-
- ctx.VisitDirectDeps(func(module Module) {
- mp := ctx.OtherModuleProvider(module, providerTestMutatorInfoProvider).(*providerTestMutatorInfo)
- if mp != nil {
- values = append(values, mp.Values...)
- }
- })
-
- ctx.SetProvider(providerTestMutatorInfoProvider, &providerTestMutatorInfo{
- Values: values,
- })
-}
-
-func providerTestAfterMutator(ctx BottomUpMutatorContext) {
- _ = ctx.Provider(providerTestMutatorInfoProvider)
-}
-
-func TestProviders(t *testing.T) {
- ctx := NewContext()
- ctx.RegisterModuleType("provider_module", newProviderTestModule)
- ctx.RegisterBottomUpMutator("provider_deps_mutator", providerTestDepsMutator)
- ctx.RegisterBottomUpMutator("provider_mutator", providerTestMutator)
- ctx.RegisterBottomUpMutator("provider_after_mutator", providerTestAfterMutator)
-
- ctx.MockFileSystem(map[string][]byte{
- "Blueprints": []byte(`
- provider_module {
- name: "A",
- deps: ["B"],
- }
-
- provider_module {
- name: "B",
- deps: ["C", "D"],
- }
-
- provider_module {
- name: "C",
- deps: ["D"],
- }
-
- provider_module {
- name: "D",
- }
- `),
- })
-
- _, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
- if len(errs) == 0 {
- _, errs = ctx.ResolveDependencies(nil)
- }
- if len(errs) == 0 {
- _, errs = ctx.PrepareBuildActions(nil)
- }
- if len(errs) > 0 {
- t.Errorf("unexpected errors:")
- for _, err := range errs {
- t.Errorf(" %s", err)
- }
- t.FailNow()
- }
-
- aModule := ctx.moduleGroupFromName("A", nil).moduleByVariantName("").logicModule.(*providerTestModule)
- if g, w := aModule.generateBuildActionsProviderValues, []string{"B"}; !reflect.DeepEqual(g, w) {
- t.Errorf("expected A.generateBuildActionsProviderValues %q, got %q", w, g)
- }
- if g, w := aModule.mutatorProviderValues, []string{"a", "b", "c", "d", "d"}; !reflect.DeepEqual(g, w) {
- t.Errorf("expected A.mutatorProviderValues %q, got %q", w, g)
- }
-
- bModule := ctx.moduleGroupFromName("B", nil).moduleByVariantName("").logicModule.(*providerTestModule)
- if g, w := bModule.generateBuildActionsProviderValues, []string{"C", "D"}; !reflect.DeepEqual(g, w) {
- t.Errorf("expected B.generateBuildActionsProviderValues %q, got %q", w, g)
- }
- if g, w := bModule.mutatorProviderValues, []string{"b", "c", "d", "d"}; !reflect.DeepEqual(g, w) {
- t.Errorf("expected B.mutatorProviderValues %q, got %q", w, g)
- }
-}
-
-type invalidProviderUsageMutatorInfo string
-type invalidProviderUsageGenerateBuildActionsInfo string
-
-var invalidProviderUsageMutatorInfoProvider = NewMutatorProvider(invalidProviderUsageMutatorInfo(""), "mutator_under_test")
-var invalidProviderUsageGenerateBuildActionsInfoProvider = NewProvider(invalidProviderUsageGenerateBuildActionsInfo(""))
-
-type invalidProviderUsageTestModule struct {
- parent *invalidProviderUsageTestModule
-
- SimpleName
- properties struct {
- Deps []string
-
- Early_mutator_set_of_mutator_provider bool
- Late_mutator_set_of_mutator_provider bool
- Late_build_actions_set_of_mutator_provider bool
- Early_mutator_set_of_build_actions_provider bool
-
- Early_mutator_get_of_mutator_provider bool
- Early_module_get_of_mutator_provider bool
- Early_mutator_get_of_build_actions_provider bool
- Early_module_get_of_build_actions_provider bool
-
- Duplicate_set bool
- }
-}
-
-func invalidProviderUsageDepsMutator(ctx BottomUpMutatorContext) {
- if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
- ctx.AddDependency(ctx.Module(), nil, i.properties.Deps...)
- }
-}
-
-func invalidProviderUsageParentMutator(ctx TopDownMutatorContext) {
- if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
- ctx.VisitDirectDeps(func(module Module) {
- module.(*invalidProviderUsageTestModule).parent = i
- })
- }
-}
-
-func invalidProviderUsageBeforeMutator(ctx BottomUpMutatorContext) {
- if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
- if i.properties.Early_mutator_set_of_mutator_provider {
- // A mutator attempting to set the value of a provider associated with a later mutator.
- ctx.SetProvider(invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
- }
- if i.properties.Early_mutator_get_of_mutator_provider {
- // A mutator attempting to get the value of a provider associated with a later mutator.
- _ = ctx.Provider(invalidProviderUsageMutatorInfoProvider)
- }
- }
-}
-
-func invalidProviderUsageMutatorUnderTest(ctx TopDownMutatorContext) {
- if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
- if i.properties.Early_mutator_set_of_build_actions_provider {
- // A mutator attempting to set the value of a non-mutator provider.
- ctx.SetProvider(invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
- }
- if i.properties.Early_mutator_get_of_build_actions_provider {
- // A mutator attempting to get the value of a non-mutator provider.
- _ = ctx.Provider(invalidProviderUsageGenerateBuildActionsInfoProvider)
- }
- if i.properties.Early_module_get_of_mutator_provider {
- // A mutator attempting to get the value of a provider associated with this mutator on
- // a module for which this mutator hasn't run. This is a top down mutator so
- // dependencies haven't run yet.
- ctx.VisitDirectDeps(func(module Module) {
- _ = ctx.OtherModuleProvider(module, invalidProviderUsageMutatorInfoProvider)
- })
- }
- }
-}
-
-func invalidProviderUsageAfterMutator(ctx BottomUpMutatorContext) {
- if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
- if i.properties.Late_mutator_set_of_mutator_provider {
- // A mutator trying to set the value of a provider associated with an earlier mutator.
- ctx.SetProvider(invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
- }
- if i.properties.Late_mutator_set_of_mutator_provider {
- // A mutator trying to set the value of a provider associated with an earlier mutator.
- ctx.SetProvider(invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
- }
- }
-}
-
-func (i *invalidProviderUsageTestModule) GenerateBuildActions(ctx ModuleContext) {
- if i.properties.Late_build_actions_set_of_mutator_provider {
- // A GenerateBuildActions trying to set the value of a provider associated with a mutator.
- ctx.SetProvider(invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
- }
- if i.properties.Early_module_get_of_build_actions_provider {
- // A GenerateBuildActions trying to get the value of a provider on a module for which
- // GenerateBuildActions hasn't run.
- _ = ctx.OtherModuleProvider(i.parent, invalidProviderUsageGenerateBuildActionsInfoProvider)
- }
- if i.properties.Duplicate_set {
- ctx.SetProvider(invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
- ctx.SetProvider(invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
- }
-}
-
-func TestInvalidProvidersUsage(t *testing.T) {
- run := func(t *testing.T, module string, prop string, panicMsg string) {
- t.Helper()
- ctx := NewContext()
- ctx.RegisterModuleType("invalid_provider_usage_test_module", func() (Module, []interface{}) {
- m := &invalidProviderUsageTestModule{}
- return m, []interface{}{&m.properties, &m.SimpleName.Properties}
- })
- ctx.RegisterBottomUpMutator("deps", invalidProviderUsageDepsMutator)
- ctx.RegisterBottomUpMutator("before", invalidProviderUsageBeforeMutator)
- ctx.RegisterTopDownMutator("mutator_under_test", invalidProviderUsageMutatorUnderTest)
- ctx.RegisterBottomUpMutator("after", invalidProviderUsageAfterMutator)
- ctx.RegisterTopDownMutator("parent", invalidProviderUsageParentMutator)
-
- // Don't invalidate the parent pointer and before GenerateBuildActions.
- ctx.skipCloneModulesAfterMutators = true
-
- var parentBP, moduleUnderTestBP, childBP string
-
- prop += ": true,"
-
- switch module {
- case "parent":
- parentBP = prop
- case "module_under_test":
- moduleUnderTestBP = prop
- case "child":
- childBP = prop
- }
-
- bp := fmt.Sprintf(`
- invalid_provider_usage_test_module {
- name: "parent",
- deps: ["module_under_test"],
- %s
- }
-
- invalid_provider_usage_test_module {
- name: "module_under_test",
- deps: ["child"],
- %s
- }
-
- invalid_provider_usage_test_module {
- name: "child",
- %s
- }
-
- `,
- parentBP,
- moduleUnderTestBP,
- childBP)
-
- ctx.MockFileSystem(map[string][]byte{
- "Blueprints": []byte(bp),
- })
-
- _, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
-
- if len(errs) == 0 {
- _, errs = ctx.ResolveDependencies(nil)
- }
-
- if len(errs) == 0 {
- _, errs = ctx.PrepareBuildActions(nil)
- }
-
- if len(errs) == 0 {
- t.Fatal("expected an error")
- }
-
- if len(errs) > 1 {
- t.Errorf("expected a single error, got %d:", len(errs))
- for i, err := range errs {
- t.Errorf("%d: %s", i, err)
- }
- t.FailNow()
- }
-
- if panicErr, ok := errs[0].(panicError); ok {
- if panicErr.panic != panicMsg {
- t.Fatalf("expected panic %q, got %q", panicMsg, panicErr.panic)
- }
- } else {
- t.Fatalf("expected a panicError, got %T: %s", errs[0], errs[0].Error())
- }
-
- }
-
- tests := []struct {
- prop string
- module string
-
- panicMsg string
- skip string
- }{
- {
- prop: "early_mutator_set_of_mutator_provider",
- module: "module_under_test",
- panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test started",
- },
- {
- prop: "late_mutator_set_of_mutator_provider",
- module: "module_under_test",
- panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo after mutator mutator_under_test finished",
- },
- {
- prop: "late_build_actions_set_of_mutator_provider",
- module: "module_under_test",
- panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo after mutator mutator_under_test finished",
- },
- {
- prop: "early_mutator_set_of_build_actions_provider",
- module: "module_under_test",
- panicMsg: "Can't set value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions started",
- },
-
- {
- prop: "early_mutator_get_of_mutator_provider",
- module: "module_under_test",
- panicMsg: "Can't get value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test finished",
- },
- {
- prop: "early_module_get_of_mutator_provider",
- module: "module_under_test",
- panicMsg: "Can't get value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test finished",
- },
- {
- prop: "early_mutator_get_of_build_actions_provider",
- module: "module_under_test",
- panicMsg: "Can't get value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions finished",
- },
- {
- prop: "early_module_get_of_build_actions_provider",
- module: "module_under_test",
- panicMsg: "Can't get value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions finished",
- },
- {
- prop: "duplicate_set",
- module: "module_under_test",
- panicMsg: "Value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo is already set",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.prop, func(t *testing.T) {
- run(t, tt.module, tt.prop, tt.panicMsg)
- })
- }
-}
diff --git a/scope.go b/scope.go
index 3f39eb7..0a520d9 100644
--- a/scope.go
+++ b/scope.go
@@ -28,7 +28,6 @@
packageContext() *packageContext
name() string // "foo"
fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
- memoizeFullName(pkgNames map[*packageContext]string) // precompute fullName if desired
value(config interface{}) (ninjaString, error)
String() string
}
@@ -39,7 +38,6 @@
packageContext() *packageContext
name() string // "foo"
fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
- memoizeFullName(pkgNames map[*packageContext]string) // precompute fullName if desired
def(config interface{}) (*poolDef, error)
String() string
}
@@ -50,7 +48,6 @@
packageContext() *packageContext
name() string // "foo"
fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
- memoizeFullName(pkgNames map[*packageContext]string) // precompute fullName if desired
def(config interface{}) (*ruleDef, error)
scope() *basicScope
isArg(argName string) bool
@@ -297,9 +294,9 @@
}
v := &localVariable{
- fullName_: s.namePrefix + name,
- name_: name,
- value_: ninjaValue,
+ namePrefix: s.namePrefix,
+ name_: name,
+ value_: ninjaValue,
}
err = s.scope.AddVariable(v)
@@ -336,11 +333,11 @@
}
r := &localRule{
- fullName_: s.namePrefix + name,
- name_: name,
- def_: def,
- argNames: argNamesSet,
- scope_: ruleScope,
+ namePrefix: s.namePrefix,
+ name_: name,
+ def_: def,
+ argNames: argNamesSet,
+ scope_: ruleScope,
}
err = s.scope.AddRule(r)
@@ -352,9 +349,9 @@
}
type localVariable struct {
- fullName_ string
- name_ string
- value_ ninjaString
+ namePrefix string
+ name_ string
+ value_ ninjaString
}
func (l *localVariable) packageContext() *packageContext {
@@ -366,11 +363,7 @@
}
func (l *localVariable) fullName(pkgNames map[*packageContext]string) string {
- return l.fullName_
-}
-
-func (l *localVariable) memoizeFullName(pkgNames map[*packageContext]string) {
- // Nothing to do, full name is known at initialization.
+ return l.namePrefix + l.name_
}
func (l *localVariable) value(interface{}) (ninjaString, error) {
@@ -378,15 +371,15 @@
}
func (l *localVariable) String() string {
- return "<local var>:" + l.fullName_
+ return "<local var>:" + l.namePrefix + l.name_
}
type localRule struct {
- fullName_ string
- name_ string
- def_ *ruleDef
- argNames map[string]bool
- scope_ *basicScope
+ namePrefix string
+ name_ string
+ def_ *ruleDef
+ argNames map[string]bool
+ scope_ *basicScope
}
func (l *localRule) packageContext() *packageContext {
@@ -398,11 +391,7 @@
}
func (l *localRule) fullName(pkgNames map[*packageContext]string) string {
- return l.fullName_
-}
-
-func (l *localRule) memoizeFullName(pkgNames map[*packageContext]string) {
- // Nothing to do, full name is known at initialization.
+ return l.namePrefix + l.name_
}
func (l *localRule) def(interface{}) (*ruleDef, error) {
@@ -418,5 +407,5 @@
}
func (r *localRule) String() string {
- return "<local rule>:" + r.fullName_
+ return "<local rule>:" + r.namePrefix + r.name_
}
diff --git a/singleton_ctx.go b/singleton_ctx.go
index a4e7153..3c0a24c 100644
--- a/singleton_ctx.go
+++ b/singleton_ctx.go
@@ -47,16 +47,6 @@
// BlueprintFile returns the path of the Blueprint file that defined the given module.
BlueprintFile(module Module) string
- // ModuleProvider returns the value, if any, for the provider for a module. If the value for the
- // provider was not set it returns the zero value of the type of the provider, which means the
- // return value can always be type-asserted to the type of the provider. The return value should
- // always be considered read-only. It panics if called before the appropriate mutator or
- // GenerateBuildActions pass for the provider on the module.
- ModuleProvider(module Module, provider ProviderKey) interface{}
-
- // ModuleHasProvider returns true if the provider for the given module has been set.
- ModuleHasProvider(m Module, provider ProviderKey) bool
-
// ModuleErrorf reports an error at the line number of the module type in the module definition.
ModuleErrorf(module Module, format string, args ...interface{})
@@ -198,15 +188,6 @@
return s.context.ModuleType(logicModule)
}
-func (s *singletonContext) ModuleProvider(logicModule Module, provider ProviderKey) interface{} {
- return s.context.ModuleProvider(logicModule, provider)
-}
-
-// ModuleHasProvider returns true if the provider for the given module has been set.
-func (s *singletonContext) ModuleHasProvider(logicModule Module, provider ProviderKey) bool {
- return s.context.ModuleHasProvider(logicModule, provider)
-}
-
func (s *singletonContext) BlueprintFile(logicModule Module) string {
return s.context.BlueprintFile(logicModule)
}
diff --git a/splice_modules_test.go b/splice_modules_test.go
index 473999a..a67aeb1 100644
--- a/splice_modules_test.go
+++ b/splice_modules_test.go
@@ -20,91 +20,91 @@
)
var (
- testModuleA = &moduleInfo{variant: variant{name: "testModuleA"}}
- testModuleB = &moduleInfo{variant: variant{name: "testModuleB"}}
- testModuleC = &moduleInfo{variant: variant{name: "testModuleC"}}
- testModuleD = &moduleInfo{variant: variant{name: "testModuleD"}}
- testModuleE = &moduleInfo{variant: variant{name: "testModuleE"}}
- testModuleF = &moduleInfo{variant: variant{name: "testModuleF"}}
+ testModuleA = &moduleInfo{variantName: "testModuleA"}
+ testModuleB = &moduleInfo{variantName: "testModuleB"}
+ testModuleC = &moduleInfo{variantName: "testModuleC"}
+ testModuleD = &moduleInfo{variantName: "testModuleD"}
+ testModuleE = &moduleInfo{variantName: "testModuleE"}
+ testModuleF = &moduleInfo{variantName: "testModuleF"}
)
var spliceModulesTestCases = []struct {
- in modulesOrAliases
+ in []*moduleInfo
at int
- with modulesOrAliases
- out modulesOrAliases
+ with []*moduleInfo
+ out []*moduleInfo
outAt int
reallocate bool
}{
{
// Insert at the beginning
- in: modulesOrAliases{testModuleA, testModuleB, testModuleC},
+ in: []*moduleInfo{testModuleA, testModuleB, testModuleC},
at: 0,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleD, testModuleE, testModuleB, testModuleC},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleD, testModuleE, testModuleB, testModuleC},
outAt: 1,
reallocate: true,
},
{
// Insert in the middle
- in: modulesOrAliases{testModuleA, testModuleB, testModuleC},
+ in: []*moduleInfo{testModuleA, testModuleB, testModuleC},
at: 1,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleA, testModuleD, testModuleE, testModuleC},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleA, testModuleD, testModuleE, testModuleC},
outAt: 2,
reallocate: true,
},
{
// Insert at the end
- in: modulesOrAliases{testModuleA, testModuleB, testModuleC},
+ in: []*moduleInfo{testModuleA, testModuleB, testModuleC},
at: 2,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleA, testModuleB, testModuleD, testModuleE},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleA, testModuleB, testModuleD, testModuleE},
outAt: 3,
reallocate: true,
},
{
// Insert over a single element
- in: modulesOrAliases{testModuleA},
+ in: []*moduleInfo{testModuleA},
at: 0,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleD, testModuleE},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleD, testModuleE},
outAt: 1,
reallocate: true,
},
{
// Insert at the beginning without reallocating
- in: modulesOrAliases{testModuleA, testModuleB, testModuleC, nil}[0:3],
+ in: []*moduleInfo{testModuleA, testModuleB, testModuleC, nil}[0:3],
at: 0,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleD, testModuleE, testModuleB, testModuleC},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleD, testModuleE, testModuleB, testModuleC},
outAt: 1,
reallocate: false,
},
{
// Insert in the middle without reallocating
- in: modulesOrAliases{testModuleA, testModuleB, testModuleC, nil}[0:3],
+ in: []*moduleInfo{testModuleA, testModuleB, testModuleC, nil}[0:3],
at: 1,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleA, testModuleD, testModuleE, testModuleC},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleA, testModuleD, testModuleE, testModuleC},
outAt: 2,
reallocate: false,
},
{
// Insert at the end without reallocating
- in: modulesOrAliases{testModuleA, testModuleB, testModuleC, nil}[0:3],
+ in: []*moduleInfo{testModuleA, testModuleB, testModuleC, nil}[0:3],
at: 2,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleA, testModuleB, testModuleD, testModuleE},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleA, testModuleB, testModuleD, testModuleE},
outAt: 3,
reallocate: false,
},
{
// Insert over a single element without reallocating
- in: modulesOrAliases{testModuleA, nil}[0:1],
+ in: []*moduleInfo{testModuleA, nil}[0:1],
at: 0,
- with: modulesOrAliases{testModuleD, testModuleE},
- out: modulesOrAliases{testModuleD, testModuleE},
+ with: []*moduleInfo{testModuleD, testModuleE},
+ out: []*moduleInfo{testModuleD, testModuleE},
outAt: 1,
reallocate: false,
},
@@ -112,7 +112,7 @@
func TestSpliceModules(t *testing.T) {
for _, testCase := range spliceModulesTestCases {
- in := make(modulesOrAliases, len(testCase.in), cap(testCase.in))
+ in := make([]*moduleInfo, len(testCase.in), cap(testCase.in))
copy(in, testCase.in)
origIn := in
got, gotAt := spliceModules(in, testCase.at, testCase.with)
@@ -139,6 +139,6 @@
}
}
-func sameArray(a, b modulesOrAliases) bool {
+func sameArray(a, b []*moduleInfo) bool {
return &a[0:cap(a)][cap(a)-1] == &b[0:cap(b)][cap(b)-1]
}
diff --git a/visit_test.go b/visit_test.go
index 1c74b93..efaadba 100644
--- a/visit_test.go
+++ b/visit_test.go
@@ -149,13 +149,13 @@
func TestVisit(t *testing.T) {
ctx := setupVisitTest(t)
- topModule := ctx.moduleGroupFromName("A", nil).modules.firstModule().logicModule.(*visitModule)
+ topModule := ctx.moduleGroupFromName("A", nil).modules[0].logicModule.(*visitModule)
assertString(t, topModule.properties.VisitDepsDepthFirst, "FEDCB")
assertString(t, topModule.properties.VisitDepsDepthFirstIf, "FEDC")
assertString(t, topModule.properties.VisitDirectDeps, "B")
assertString(t, topModule.properties.VisitDirectDepsIf, "")
- eModule := ctx.moduleGroupFromName("E", nil).modules.firstModule().logicModule.(*visitModule)
+ eModule := ctx.moduleGroupFromName("E", nil).modules[0].logicModule.(*visitModule)
assertString(t, eModule.properties.VisitDepsDepthFirst, "F")
assertString(t, eModule.properties.VisitDepsDepthFirstIf, "F")
assertString(t, eModule.properties.VisitDirectDeps, "FF")
