diff --git a/.gitignore b/.gitignore
index d2cc8ff..3a9ef96 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,2 @@
 out.test
 src.test
-*.iml
-.idea/
diff --git a/Android.bp b/Blueprints
similarity index 78%
rename from Android.bp
rename to Blueprints
index c84d04a..ab9fd3c 100644
--- a/Android.bp
+++ b/Blueprints
@@ -1,37 +1,6 @@
-package {
-    default_applicable_licenses: ["build_blueprint_license"],
-}
-
-// Added automatically by a large-scale-change that took the approach of
-// 'apply every license found to every target'. While this makes sure we respect
-// every license restriction, it may not be entirely correct.
-//
-// e.g. GPL in an MIT project might only apply to the contrib/ directory.
-//
-// Please consider splitting the single license below into multiple licenses,
-// taking care not to lose any license_kind information, and overriding the
-// default license using the 'licenses: [...]' property on targets as needed.
-//
-// For unused files, consider creating a 'fileGroup' with "//visibility:private"
-// to attach the license to, and including a comment whether the files may be
-// used in the current project.
-// See: http://go/android-license-faq
-license {
-    name: "build_blueprint_license",
-    visibility: [":__subpackages__"],
-    license_kinds: [
-        "SPDX-license-identifier-Apache-2.0",
-        "SPDX-license-identifier-BSD",
-    ],
-    license_text: [
-        "LICENSE",
-    ],
-}
-
 bootstrap_go_package {
     name: "blueprint",
     deps: [
-        "blueprint-metrics",
         "blueprint-parser",
         "blueprint-pathtools",
         "blueprint-proptools",
@@ -78,7 +47,7 @@
         "parser/modify_test.go",
         "parser/parser_test.go",
         "parser/printer_test.go",
-        "parser/sort_test.go",
+	"parser/sort_test.go",
     ],
 }
 
@@ -144,8 +113,10 @@
     pkgPath: "github.com/google/blueprint/bootstrap",
     srcs: [
         "bootstrap/bootstrap.go",
+        "bootstrap/cleanup.go",
         "bootstrap/command.go",
         "bootstrap/config.go",
+        "bootstrap/doc.go",
         "bootstrap/glob.go",
         "bootstrap/writedocs.go",
     ],
@@ -170,7 +141,17 @@
     ],
 }
 
-blueprint_go_binary {
+bootstrap_go_binary {
+    name: "minibp",
+    deps: [
+        "blueprint",
+        "blueprint-bootstrap",
+        "gotestmain-tests",
+    ],
+    srcs: ["bootstrap/minibp/main.go"],
+}
+
+bootstrap_go_binary {
     name: "bpglob",
     deps: ["blueprint-pathtools"],
     srcs: ["bootstrap/bpglob/bpglob.go"],
@@ -188,7 +169,7 @@
     srcs: ["bpmodify/bpmodify.go"],
 }
 
-blueprint_go_binary {
+bootstrap_go_binary {
     name: "gotestmain",
     srcs: ["gotestmain/gotestmain.go"],
 }
@@ -206,12 +187,12 @@
     ],
 }
 
-blueprint_go_binary {
+bootstrap_go_binary {
     name: "gotestrunner",
     srcs: ["gotestrunner/gotestrunner.go"],
 }
 
-blueprint_go_binary {
+bootstrap_go_binary {
     name: "loadplugins",
     srcs: ["loadplugins/loadplugins.go"],
 }
diff --git a/blueprint.bash b/blueprint.bash
new file mode 100755
index 0000000..1c6e896
--- /dev/null
+++ b/blueprint.bash
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# This script is intented to wrap the execution of ninja so that we
+# can do some checks before each ninja run.
+#
+# It can either be run with a standalone Blueprint checkout to generate
+# the minibp binary, or can be used by another script as part of a custom
+# Blueprint-based build system. When used by another script, the following
+# environment variables can be set to configure this script, which are
+# documented below:
+#
+#   BUILDDIR
+#   NINJA
+#   SKIP_NINJA
+#
+# When run in a standalone Blueprint checkout, bootstrap.bash will install
+# this script into the $BUILDDIR, where it may be executed.
+#
+# For embedding into a custom build system, the current directory when this
+# script executes should be the same directory that $BOOTSTRAP should be
+# called from.
+
+set -e
+
+# BUILDDIR should be set to the path to store build results. By default,
+# this is the directory containing this script, but can be set explicitly
+# if the custom build system only wants to install their own wrapper.
+[ -z "$BUILDDIR" ] && BUILDDIR=`dirname "${BASH_SOURCE[0]}"`
+
+# NINJA should be set to the path of the ninja executable. By default, this
+# is just "ninja", and will be looked up in $PATH.
+[ -z "$NINJA" ] && NINJA=ninja
+
+
+if [ ! -f "${BUILDDIR}/.blueprint.bootstrap" ]; then
+    echo "Please run bootstrap.bash (.blueprint.bootstrap missing)" >&2
+    exit 1
+fi
+
+# .blueprint.bootstrap provides saved values from the bootstrap.bash script:
+#
+#   BLUEPRINT_BOOTSTRAP_VERSION
+#   BLUEPRINTDIR
+#   SRCDIR
+#   GOROOT
+#
+source "${BUILDDIR}/.blueprint.bootstrap"
+
+if [ -z "$BLUEPRINTDIR" ]; then
+    echo "Please run bootstrap.bash (.blueprint.bootstrap outdated)" >&2
+    exit 1
+fi
+
+source "${BLUEPRINTDIR}/blueprint_impl.bash"
diff --git a/blueprint_impl.bash b/blueprint_impl.bash
new file mode 100644
index 0000000..6f5abba
--- /dev/null
+++ b/blueprint_impl.bash
@@ -0,0 +1,44 @@
+if [ ! "${BLUEPRINT_BOOTSTRAP_VERSION}" -eq "2" ]; then
+  echo "Please run bootstrap.bash again (out of date)" >&2
+  exit 1
+fi
+
+
+# Allow the caller to pass in a list of module files
+if [ -z "$BLUEPRINT_LIST_FILE" ]; then
+  # If the caller does not pass a list of module files, then do a search now
+  OUR_LIST_FILE="${BUILDDIR}/.bootstrap/bplist"
+  TEMP_LIST_FILE="${OUR_FILES_LIST}.tmp"
+  mkdir -p "$(dirname ${OUR_LIST_FILE})"
+  (cd "$SRCDIR";
+    find . -mindepth 1 -type d \( -name ".*" -o -execdir test -e {}/.out-dir \; \) -prune \
+      -o -name $TOPNAME -print | sort) >"${TEMP_LIST_FILE}"
+  if cmp -s "${OUR_LIST_FILE}" "${TEMP_LIST_FILE}"; then
+    rm "${TEMP_LIST_FILE}"
+  else
+    mv "${TEMP_LIST_FILE}" "${OUR_LIST_FILE}"
+  fi
+  BLUEPRINT_LIST_FILE="${OUR_LIST_FILE}"
+fi
+
+export GOROOT
+export BLUEPRINT_LIST_FILE
+
+source "${BLUEPRINTDIR}/microfactory/microfactory.bash"
+
+BUILDDIR="${BUILDDIR}/.minibootstrap" build_go minibp github.com/google/blueprint/bootstrap/minibp
+
+BUILDDIR="${BUILDDIR}/.minibootstrap" build_go bpglob github.com/google/blueprint/bootstrap/bpglob
+
+# Build the bootstrap build.ninja
+"${NINJA}" -w dupbuild=err -f "${BUILDDIR}/.minibootstrap/build.ninja"
+
+# Build the primary builder and the main build.ninja
+"${NINJA}" -w dupbuild=err -f "${BUILDDIR}/.bootstrap/build.ninja"
+
+# SKIP_NINJA can be used by wrappers that wish to run ninja themselves.
+if [ -z "$SKIP_NINJA" ]; then
+    "${NINJA}" -w dupbuild=err -f "${BUILDDIR}/build.ninja" "$@"
+else
+    exit 0
+fi
diff --git a/bootstrap.bash b/bootstrap.bash
new file mode 100755
index 0000000..b08bf1e
--- /dev/null
+++ b/bootstrap.bash
@@ -0,0 +1,135 @@
+#!/bin/bash
+
+# This script serves two purposes.  First, it can bootstrap the standalone
+# Blueprint to generate the minibp binary.  To do this simply run the script
+# with no arguments from the desired build directory.
+#
+# It can also be invoked from another script to bootstrap a custom Blueprint-
+# based build system.  To do this, the invoking script must first set some or
+# all of the following environment variables, which are documented below where
+# their default values are set:
+#
+#   BOOTSTRAP
+#   WRAPPER
+#   SRCDIR
+#   BLUEPRINTDIR
+#   BUILDDIR
+#   NINJA_BUILDDIR
+#   GOROOT
+#
+# The invoking script should then run this script, passing along all of its
+# command line arguments.
+
+set -e
+
+EXTRA_ARGS=""
+
+# BOOTSTRAP should be set to the path of the bootstrap script.  It can be
+# either an absolute path or one relative to the build directory (which of
+# these is used should probably match what's used for SRCDIR).
+if [ -z "$BOOTSTRAP" ]; then
+    BOOTSTRAP="${BASH_SOURCE[0]}"
+
+    # WRAPPER should only be set if you want a ninja wrapper script to be
+    # installed into the builddir. It is set to blueprint's blueprint.bash
+    # only if BOOTSTRAP and WRAPPER are unset.
+    [ -z "$WRAPPER" ] && WRAPPER="`dirname "${BOOTSTRAP}"`/blueprint.bash"
+fi
+
+# SRCDIR should be set to the path of the root source directory.  It can be
+# either an absolute path or a path relative to the build directory.  Whether
+# its an absolute or relative path determines whether the build directory can
+# be moved relative to or along with the source directory without re-running
+# the bootstrap script.
+[ -z "$SRCDIR" ] && SRCDIR=`dirname "${BOOTSTRAP}"`
+
+# BLUEPRINTDIR should be set to the path to the blueprint source. It generally
+# should start with SRCDIR.
+[ -z "$BLUEPRINTDIR" ] && BLUEPRINTDIR="${SRCDIR}"
+
+# BUILDDIR should be set to the path to store build results. By default, this
+# is the current directory, but it may be set to an absolute or relative path.
+[ -z "$BUILDDIR" ] && BUILDDIR=.
+
+# NINJA_BUILDDIR should be set to the path to store the .ninja_log/.ninja_deps
+# files. By default this is the same as $BUILDDIR.
+[ -z "$NINJA_BUILDDIR" ] && NINJA_BUILDDIR="${BUILDDIR}"
+
+# TOPNAME should be set to the name of the top-level Blueprints file
+[ -z "$TOPNAME" ] && TOPNAME="Blueprints"
+
+# These variables should be set by auto-detecting or knowing a priori the host
+# Go toolchain properties.
+[ -z "$GOROOT" ] && GOROOT=`go env GOROOT`
+
+usage() {
+    echo "Usage of ${BOOTSTRAP}:"
+    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
+    case $opt in
+        b) BUILDDIR="$OPTARG";;
+        n) USE_VALIDATIONS=true;;
+        t) RUN_TESTS=true;;
+        h)
+            usage
+            exit 1
+            ;;
+        \?)
+            echo "Invalid option: -$OPTARG" >&2
+            usage
+            exit 1
+            ;;
+        :)
+            echo "Option -$OPTARG requires an argument." >&2
+            exit 1
+            ;;
+    esac
+done
+
+# 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.
+[ ! -z "$EMPTY_NINJA_FILE" ] && EXTRA_ARGS="${EXTRA_ARGS} --empty-ninja-file"
+
+# Allow the caller to pass in a list of module files
+if [ -z "${BLUEPRINT_LIST_FILE}" ]; then
+  BLUEPRINT_LIST_FILE="${BUILDDIR}/.bootstrap/bplist"
+fi
+EXTRA_ARGS="${EXTRA_ARGS} -l ${BLUEPRINT_LIST_FILE}"
+
+mkdir -p $BUILDDIR/.minibootstrap
+
+echo "bootstrapBuildDir = $BUILDDIR" > $BUILDDIR/.minibootstrap/build.ninja
+echo "topFile = $SRCDIR/$TOPNAME" >> $BUILDDIR/.minibootstrap/build.ninja
+echo "extraArgs = $EXTRA_ARGS" >> $BUILDDIR/.minibootstrap/build.ninja
+echo "builddir = $NINJA_BUILDDIR" >> $BUILDDIR/.minibootstrap/build.ninja
+echo "include $BLUEPRINTDIR/bootstrap/build.ninja" >> $BUILDDIR/.minibootstrap/build.ninja
+
+if [ ! -f "$BUILDDIR/.minibootstrap/build-globs.ninja" ]; then
+    touch "$BUILDDIR/.minibootstrap/build-globs.ninja"
+fi
+
+echo "BLUEPRINT_BOOTSTRAP_VERSION=2" > $BUILDDIR/.blueprint.bootstrap
+echo "SRCDIR=\"${SRCDIR}\"" >> $BUILDDIR/.blueprint.bootstrap
+echo "BLUEPRINTDIR=\"${BLUEPRINTDIR}\"" >> $BUILDDIR/.blueprint.bootstrap
+echo "NINJA_BUILDDIR=\"${NINJA_BUILDDIR}\"" >> $BUILDDIR/.blueprint.bootstrap
+echo "GOROOT=\"${GOROOT}\"" >> $BUILDDIR/.blueprint.bootstrap
+echo "TOPNAME=\"${TOPNAME}\"" >> $BUILDDIR/.blueprint.bootstrap
+
+touch "${BUILDDIR}/.out-dir"
+
+if [ ! -z "$WRAPPER" ]; then
+    cp $WRAPPER $BUILDDIR/
+fi
diff --git a/bootstrap/bootstrap.go b/bootstrap/bootstrap.go
index ceeee19..d5befd9 100644
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -25,12 +25,16 @@
 	"github.com/google/blueprint/pathtools"
 )
 
+const mainSubDir = ".primary"
+const bootstrapSubDir = ".bootstrap"
+const miniBootstrapSubDir = ".minibootstrap"
+
 var (
 	pctx = blueprint.NewPackageContext("github.com/google/blueprint/bootstrap")
 
-	goTestMainCmd   = pctx.StaticVariable("goTestMainCmd", filepath.Join("$ToolDir", "gotestmain"))
-	goTestRunnerCmd = pctx.StaticVariable("goTestRunnerCmd", filepath.Join("$ToolDir", "gotestrunner"))
-	pluginGenSrcCmd = pctx.StaticVariable("pluginGenSrcCmd", filepath.Join("$ToolDir", "loadplugins"))
+	goTestMainCmd   = pctx.StaticVariable("goTestMainCmd", filepath.Join(bootstrapDir, "bin", "gotestmain"))
+	goTestRunnerCmd = pctx.StaticVariable("goTestRunnerCmd", filepath.Join(bootstrapDir, "bin", "gotestrunner"))
+	pluginGenSrcCmd = pctx.StaticVariable("pluginGenSrcCmd", filepath.Join(bootstrapDir, "bin", "loadplugins"))
 
 	parallelCompile = pctx.StaticVariable("parallelCompile", func() string {
 		// Parallel compilation is only supported on >= go1.9
@@ -104,7 +108,7 @@
 
 	bootstrap = pctx.StaticRule("bootstrap",
 		blueprint.RuleParams{
-			Command:     "BUILDDIR=$soongOutDir $bootstrapCmd -i $in",
+			Command:     "BUILDDIR=$buildDir $bootstrapCmd -i $in",
 			CommandDeps: []string{"$bootstrapCmd"},
 			Description: "bootstrap $in",
 			Generator:   true,
@@ -127,10 +131,11 @@
 			Command: `cd "$$(dirname "$builder")" && ` +
 				`BUILDER="$$PWD/$$(basename "$builder")" && ` +
 				`cd / && ` +
-				`env -i $env "$$BUILDER" ` +
+				`env -i "$$BUILDER" ` +
 				`    --top "$$TOP" ` +
-				`    --soong_out "$soongOutDir" ` +
-				`    --out "$outDir" ` +
+				`    --out "$buildDir" ` +
+				`    -n "$ninjaBuildDir" ` +
+				`    -d "$out.d" ` +
 				`    $extra`,
 			CommandDeps: []string{"$builder"},
 			Description: "$builder $out",
@@ -138,7 +143,7 @@
 			Depfile:     "$out.d",
 			Restat:      true,
 		},
-		"builder", "env", "extra", "pool")
+		"builder", "extra")
 
 	// Work around a Ninja issue.  See https://github.com/martine/ninja/pull/634
 	phony = pctx.StaticRule("phony",
@@ -149,9 +154,21 @@
 		},
 		"depfile")
 
-	_ = pctx.VariableFunc("ToolDir", func(config interface{}) (string, error) {
-		return config.(BootstrapConfig).HostToolDir(), nil
+	_ = pctx.VariableFunc("BinDir", func(config interface{}) (string, error) {
+		return bootstrapBinDir(config), nil
 	})
+
+	_ = pctx.VariableFunc("ToolDir", func(config interface{}) (string, error) {
+		return toolDir(config), nil
+	})
+
+	docsDir = filepath.Join(mainDir, "docs")
+
+	mainDir          = filepath.Join("$buildDir", mainSubDir)
+	bootstrapDir     = filepath.Join("$buildDir", bootstrapSubDir)
+	miniBootstrapDir = filepath.Join("$buildDir", miniBootstrapSubDir)
+
+	minibpFile = filepath.Join(miniBootstrapDir, "minibp")
 )
 
 type GoBinaryTool interface {
@@ -161,6 +178,17 @@
 	isGoBinary()
 }
 
+func bootstrapBinDir(config interface{}) string {
+	return filepath.Join(config.(BootstrapConfig).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")
+}
+
 func pluginDeps(ctx blueprint.BottomUpMutatorContext) {
 	if pkg, ok := ctx.Module().(*goPackage); ok {
 		if ctx.PrimaryModule() == ctx.Module() {
@@ -236,13 +264,18 @@
 
 	// The path of the test result file.
 	testResultFile []string
+
+	// The bootstrap Config
+	config *Config
 }
 
 var _ goPackageProducer = (*goPackage)(nil)
 
-func newGoPackageModuleFactory() func() (blueprint.Module, []interface{}) {
+func newGoPackageModuleFactory(config *Config) func() (blueprint.Module, []interface{}) {
 	return func() (blueprint.Module, []interface{}) {
-		module := &goPackage{}
+		module := &goPackage{
+			config: config,
+		}
 		return module, []interface{}{&module.properties, &module.SimpleName.Properties}
 	}
 }
@@ -302,14 +335,14 @@
 		return
 	}
 
-	g.pkgRoot = packageRoot(ctx)
+	g.pkgRoot = packageRoot(ctx, g.config)
 	g.archiveFile = filepath.Join(g.pkgRoot,
 		filepath.FromSlash(g.properties.PkgPath)+".a")
 
 	ctx.VisitDepsDepthFirstIf(isGoPluginFor(name),
 		func(module blueprint.Module) { hasPlugins = true })
 	if hasPlugins {
-		pluginSrc = filepath.Join(moduleGenSrcDir(ctx), "plugin.go")
+		pluginSrc = filepath.Join(moduleGenSrcDir(ctx, g.config), "plugin.go")
 		genSrcs = append(genSrcs, pluginSrc)
 	}
 
@@ -326,21 +359,12 @@
 		testSrcs = append(g.properties.TestSrcs, g.properties.Linux.TestSrcs...)
 	}
 
-	if ctx.Config().(BootstrapConfig).RunGoTests() {
-		testArchiveFile := filepath.Join(testRoot(ctx),
+	if g.config.runGoTests {
+		testArchiveFile := filepath.Join(testRoot(ctx, g.config),
 			filepath.FromSlash(g.properties.PkgPath)+".a")
-		g.testResultFile = buildGoTest(ctx, testRoot(ctx), testArchiveFile,
-			g.properties.PkgPath, srcs, genSrcs, testSrcs)
-	}
-
-	// Don't build for test-only packages
-	if len(srcs) == 0 && len(genSrcs) == 0 {
-		ctx.Build(pctx, blueprint.BuildParams{
-			Rule:     touch,
-			Outputs:  []string{g.archiveFile},
-			Optional: true,
-		})
-		return
+		g.testResultFile = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
+			g.properties.PkgPath, srcs, genSrcs,
+			testSrcs, g.config.useValidations)
 	}
 
 	buildGoPackage(ctx, g.pkgRoot, g.properties.PkgPath, g.archiveFile,
@@ -365,16 +389,24 @@
 			Srcs     []string
 			TestSrcs []string
 		}
+
+		Tool_dir bool `blueprint:"mutated"`
 	}
 
 	installPath string
+
+	// The bootstrap Config
+	config *Config
 }
 
 var _ GoBinaryTool = (*goBinary)(nil)
 
-func newGoBinaryModuleFactory() func() (blueprint.Module, []interface{}) {
+func newGoBinaryModuleFactory(config *Config, tooldir bool) func() (blueprint.Module, []interface{}) {
 	return func() (blueprint.Module, []interface{}) {
-		module := &goBinary{}
+		module := &goBinary{
+			config: config,
+		}
+		module.properties.Tool_dir = tooldir
 		return module, []interface{}{&module.properties, &module.SimpleName.Properties}
 	}
 }
@@ -402,20 +434,25 @@
 
 	var (
 		name            = ctx.ModuleName()
-		objDir          = moduleObjDir(ctx)
+		objDir          = moduleObjDir(ctx, g.config)
 		archiveFile     = filepath.Join(objDir, name+".a")
-		testArchiveFile = filepath.Join(testRoot(ctx), name+".a")
+		testArchiveFile = filepath.Join(testRoot(ctx, g.config), name+".a")
 		aoutFile        = filepath.Join(objDir, "a.out")
 		hasPlugins      = false
 		pluginSrc       = ""
 		genSrcs         = []string{}
 	)
 
-	g.installPath = filepath.Join(ctx.Config().(BootstrapConfig).HostToolDir(), name)
+	if g.properties.Tool_dir {
+		g.installPath = filepath.Join(toolDir(ctx.Config()), name)
+	} else {
+		g.installPath = filepath.Join(stageDir(g.config), "bin", name)
+	}
+
 	ctx.VisitDepsDepthFirstIf(isGoPluginFor(name),
 		func(module blueprint.Module) { hasPlugins = true })
 	if hasPlugins {
-		pluginSrc = filepath.Join(moduleGenSrcDir(ctx), "plugin.go")
+		pluginSrc = filepath.Join(moduleGenSrcDir(ctx, g.config), "plugin.go")
 		genSrcs = append(genSrcs, pluginSrc)
 	}
 
@@ -434,9 +471,9 @@
 		testSrcs = append(g.properties.TestSrcs, g.properties.Linux.TestSrcs...)
 	}
 
-	if ctx.Config().(BootstrapConfig).RunGoTests() {
-		testDeps = buildGoTest(ctx, testRoot(ctx), testArchiveFile,
-			name, srcs, genSrcs, testSrcs)
+	if g.config.runGoTests {
+		testDeps = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
+			name, srcs, genSrcs, testSrcs, g.config.useValidations)
 	}
 
 	buildGoPackage(ctx, objDir, "main", archiveFile, srcs, genSrcs)
@@ -466,11 +503,19 @@
 		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},
-		Validations: testDeps,
+		OrderOnly:   orderOnlyDeps,
+		Validations: validationDeps,
 		Optional:    !g.properties.Default,
 	})
 }
@@ -536,7 +581,7 @@
 }
 
 func buildGoTest(ctx blueprint.ModuleContext, testRoot, testPkgArchive,
-	pkgPath string, srcs, genSrcs, testSrcs []string) []string {
+	pkgPath string, srcs, genSrcs, testSrcs []string, useValidations bool) []string {
 
 	if len(testSrcs) == 0 {
 		return nil
@@ -598,11 +643,19 @@
 		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},
-		Validations: testDeps,
+		OrderOnly:   orderOnlyDeps,
+		Validations: validationDeps,
 		Args: map[string]string{
 			"pkg":       pkgPath,
 			"pkgSrcDir": filepath.Dir(testFiles[0]),
@@ -614,11 +667,15 @@
 }
 
 type singleton struct {
+	// The bootstrap Config
+	config *Config
 }
 
-func newSingletonFactory() func() blueprint.Singleton {
+func newSingletonFactory(config *Config) func() blueprint.Singleton {
 	return func() blueprint.Singleton {
-		return &singleton{}
+		return &singleton{
+			config: config,
+		}
 	}
 }
 
@@ -629,23 +686,16 @@
 	var primaryBuilders []*goBinary
 	// blueprintTools contains blueprint go binaries that will be built in StageMain
 	var blueprintTools []string
-	// blueprintGoPackages contains all blueprint go packages that can be built in StageMain
-	var blueprintGoPackages []string
-	ctx.VisitAllModulesIf(IsBootstrapModule,
+	ctx.VisitAllModulesIf(isBootstrapBinaryModule,
 		func(module blueprint.Module) {
 			if ctx.PrimaryModule(module) == module {
-				if binaryModule, ok := module.(*goBinary); ok {
-					blueprintTools = append(blueprintTools, binaryModule.InstallPath())
-					if binaryModule.properties.PrimaryBuilder {
-						primaryBuilders = append(primaryBuilders, binaryModule)
-					}
-				}
+				binaryModule := module.(*goBinary)
 
-				if packageModule, ok := module.(*goPackage); ok {
-					blueprintGoPackages = append(blueprintGoPackages,
-						packageModule.GoPackageTarget())
-					blueprintGoPackages = append(blueprintGoPackages,
-						packageModule.GoTestTargets()...)
+				if binaryModule.properties.Tool_dir {
+					blueprintTools = append(blueprintTools, binaryModule.InstallPath())
+				}
+				if binaryModule.properties.PrimaryBuilder {
+					primaryBuilders = append(primaryBuilders, binaryModule)
 				}
 			}
 		})
@@ -654,8 +704,11 @@
 	var primaryBuilderName string
 
 	if len(primaryBuilders) == 0 {
-		ctx.Errorf("no primary builder module present")
-		return
+		// 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 {
 		ctx.Errorf("multiple primary builder modules present:")
 		for _, primaryBuilder := range primaryBuilders {
@@ -667,95 +720,111 @@
 		primaryBuilderName = ctx.ModuleName(primaryBuilders[0])
 	}
 
-	primaryBuilderFile := filepath.Join("$ToolDir", primaryBuilderName)
-	ctx.SetOutDir(pctx, "${outDir}")
+	primaryBuilderFile := filepath.Join("$BinDir", primaryBuilderName)
+	ctx.SetNinjaBuildDir(pctx, "${ninjaBuildDir}")
 
-	for _, subninja := range ctx.Config().(BootstrapConfig).Subninjas() {
-		ctx.AddSubninja(subninja)
+	if s.config.stage == StagePrimary {
+		ctx.AddSubninja(s.config.globFile)
+
+		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, " "),
+				},
+			})
+		}
 	}
 
-	for _, i := range ctx.Config().(BootstrapConfig).PrimaryBuilderInvocations() {
-		flags := make([]string, 0)
-		flags = append(flags, primaryBuilderCmdlinePrefix...)
-		flags = append(flags, i.Args...)
-
-		pool := ""
-		if i.Console {
-			pool = "console"
+	if s.config.stage == StageMain {
+		if primaryBuilderName == "minibp" {
+			// This is a standalone Blueprint build, so we copy the minibp
+			// binary to the "bin" directory to make it easier to find.
+			finalMinibp := filepath.Join("$buildDir", "bin", primaryBuilderName)
+			ctx.Build(pctx, blueprint.BuildParams{
+				Rule:    cp,
+				Inputs:  []string{primaryBuilderFile},
+				Outputs: []string{finalMinibp},
+			})
 		}
 
-		envAssignments := ""
-		for k, v := range i.Env {
-			// NB: This is rife with quoting issues but we don't care because we trust
-			// soong_ui to not abuse this facility too much
-			envAssignments += k + "=" + v + " "
-		}
+		// Generate build system docs for the primary builder.  Generating docs reads the source
+		// files used to build the primary builder, but that dependency will be picked up through
+		// the dependency on the primary builder itself.  There are no dependencies on the
+		// Blueprints files, as any relevant changes to the Blueprints files would have caused
+		// a rebuild of the primary builder.
+		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),
+				CommandDeps: []string{primaryBuilderFile},
+				Description: fmt.Sprintf("%s docs $out", primaryBuilderName),
+			})
 
-		// Build the main build.ninja
 		ctx.Build(pctx, blueprint.BuildParams{
-			Rule:    generateBuildNinja,
-			Outputs: i.Outputs,
-			Inputs:  i.Inputs,
-			Args: map[string]string{
-				"builder": primaryBuilderFile,
-				"env":     envAssignments,
-				"extra":   strings.Join(flags, " "),
-				"pool":    pool,
-			},
-			// soong_ui explicitly requests what it wants to be build. This is
-			// because the same Ninja file contains instructions to run
-			// soong_build, run bp2build and to generate the JSON module graph.
-			Optional:    true,
-			Description: i.Description,
+			Rule:    bigbpDocs,
+			Outputs: []string{docsFile},
+		})
+
+		// Add a phony target for building the documentation
+		ctx.Build(pctx, blueprint.BuildParams{
+			Rule:    blueprint.Phony,
+			Outputs: []string{"blueprint_docs"},
+			Inputs:  []string{docsFile},
+		})
+
+		// Add a phony target for building various tools that are part of blueprint
+		ctx.Build(pctx, blueprint.BuildParams{
+			Rule:    blueprint.Phony,
+			Outputs: []string{"blueprint_tools"},
+			Inputs:  blueprintTools,
 		})
 	}
+}
 
-	// Add a phony target for building various tools that are part of blueprint
-	ctx.Build(pctx, blueprint.BuildParams{
-		Rule:    blueprint.Phony,
-		Outputs: []string{"blueprint_tools"},
-		Inputs:  blueprintTools,
-	})
-
-	// Add a phony target for running go tests
-	ctx.Build(pctx, blueprint.BuildParams{
-		Rule:     blueprint.Phony,
-		Outputs:  []string{"blueprint_go_packages"},
-		Inputs:   blueprintGoPackages,
-		Optional: true,
-	})
+func stageDir(config *Config) string {
+	if config.stage == StageMain {
+		return mainDir
+	} else {
+		return bootstrapDir
+	}
 }
 
 // packageRoot returns the module-specific package root directory path.  This
 // directory is where the final package .a files are output and where dependant
 // modules search for this package via -I arguments.
-func packageRoot(ctx blueprint.ModuleContext) string {
-	toolDir := ctx.Config().(BootstrapConfig).HostToolDir()
-	return filepath.Join(toolDir, "go", ctx.ModuleName(), "pkg")
+func packageRoot(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "pkg")
 }
 
 // testRoot returns the module-specific package root directory path used for
 // building tests. The .a files generated here will include everything from
 // packageRoot, plus the test-only code.
-func testRoot(ctx blueprint.ModuleContext) string {
-	toolDir := ctx.Config().(BootstrapConfig).HostToolDir()
-	return filepath.Join(toolDir, "go", ctx.ModuleName(), "test")
+func testRoot(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "test")
 }
 
 // moduleSrcDir returns the path of the directory that all source file paths are
 // specified relative to.
 func moduleSrcDir(ctx blueprint.ModuleContext) string {
-	return ctx.ModuleDir()
+	return filepath.Join("$srcDir", ctx.ModuleDir())
 }
 
 // moduleObjDir returns the module-specific object directory path.
-func moduleObjDir(ctx blueprint.ModuleContext) string {
-	toolDir := ctx.Config().(BootstrapConfig).HostToolDir()
-	return filepath.Join(toolDir, "go", ctx.ModuleName(), "obj")
+func moduleObjDir(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "obj")
 }
 
 // moduleGenSrcDir returns the module-specific generated sources path.
-func moduleGenSrcDir(ctx blueprint.ModuleContext) string {
-	toolDir := ctx.Config().(BootstrapConfig).HostToolDir()
-	return filepath.Join(toolDir, "go", ctx.ModuleName(), "gen")
+func moduleGenSrcDir(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "gen")
 }
diff --git a/bootstrap/bpdoc/bpdoc.go b/bootstrap/bpdoc/bpdoc.go
index 49ed8bc..8ed02c2 100644
--- a/bootstrap/bpdoc/bpdoc.go
+++ b/bootstrap/bpdoc/bpdoc.go
@@ -81,6 +81,7 @@
 		removeEmptyPropertyStructs(mtInfo)
 		collapseDuplicatePropertyStructs(mtInfo)
 		collapseNestedPropertyStructs(mtInfo)
+		combineDuplicateProperties(mtInfo)
 
 		// Add the ModuleInfo to the corresponding Package map/slice entries.
 		pkg := pkgMap[mtInfo.PkgPath]
@@ -120,12 +121,16 @@
 		v := reflect.ValueOf(s).Elem()
 		t := v.Type()
 
+		// Ignore property structs with unexported or unnamed types
+		if t.PkgPath() == "" {
+			continue
+		}
 		ps, err := r.PropertyStruct(t.PkgPath(), t.Name(), v)
-
 		if err != nil {
 			return nil, err
 		}
 		ps.ExcludeByTag("blueprint", "mutated")
+
 		for _, nestedProperty := range nestedPropertyStructs(v) {
 			nestedName := nestedProperty.nestPoint
 			nestedValue := nestedProperty.value
@@ -335,3 +340,29 @@
 	}
 	*p = n
 }
+
+func combineDuplicateProperties(mt *ModuleType) {
+	for _, ps := range mt.PropertyStructs {
+		combineDuplicateSubProperties(&ps.Properties)
+	}
+}
+
+func combineDuplicateSubProperties(p *[]Property) {
+	var n []Property
+propertyLoop:
+	for _, child := range *p {
+		if len(child.Properties) > 0 {
+			combineDuplicateSubProperties(&child.Properties)
+			for i := range n {
+				s := &n[i]
+				if s.SameSubProperties(child) {
+					s.OtherNames = append(s.OtherNames, child.Name)
+					s.OtherTexts = append(s.OtherTexts, child.Text)
+					continue propertyLoop
+				}
+			}
+		}
+		n = append(n, child)
+	}
+	*p = n
+}
diff --git a/bootstrap/bpdoc/properties.go b/bootstrap/bpdoc/properties.go
index 31b93b1..2ca8e65 100644
--- a/bootstrap/bpdoc/properties.go
+++ b/bootstrap/bpdoc/properties.go
@@ -143,26 +143,7 @@
 }
 
 func (ps *PropertyStruct) Nest(nested *PropertyStruct) {
-	ps.Properties = nestUnique(ps.Properties, nested.Properties)
-}
-
-// Adds a target element to src if it does not exist in src
-func nestUnique(src []Property, target []Property) []Property {
-	var ret []Property
-	ret = append(ret, src...)
-	for _, elem := range target {
-		isUnique := true
-		for _, retElement := range ret {
-			if elem.Equal(retElement) {
-				isUnique = false
-				break
-			}
-		}
-		if isUnique {
-			ret = append(ret, elem)
-		}
-	}
-	return ret
+	ps.Properties = append(ps.Properties, nested.Properties...)
 }
 
 func getByName(name string, prefix string, props *[]Property) *Property {
@@ -177,7 +158,7 @@
 }
 
 func (p *Property) Nest(nested *PropertyStruct) {
-	p.Properties = nestUnique(p.Properties, nested.Properties)
+	p.Properties = append(p.Properties, nested.Properties...)
 }
 
 func (p *Property) SetAnonymous() {
diff --git a/bootstrap/bpdoc/properties_test.go b/bootstrap/bpdoc/properties_test.go
index b0b3ae4..085bcdf 100644
--- a/bootstrap/bpdoc/properties_test.go
+++ b/bootstrap/bpdoc/properties_test.go
@@ -16,7 +16,6 @@
 
 import (
 	"reflect"
-	"strings"
 	"testing"
 )
 
@@ -52,131 +51,6 @@
 	}
 }
 
-func TestPropertiesOfReflectionStructs(t *testing.T) {
-	testCases := []struct {
-		fields             map[string]interface{}
-		expectedProperties map[string]Property
-		description        string
-	}{
-		{
-			fields: map[string]interface{}{
-				"A": "A is a string",
-				"B": 0, //B is an int
-			},
-			expectedProperties: map[string]Property{
-				"a": *createProperty("a", "string", ""),
-				"b": *createProperty("b", "int", ""),
-			},
-			description: "struct is composed of primitive types",
-		},
-		{
-			fields: map[string]interface{}{
-				"A": "A is a string",
-				"B": 0, //B is an int
-				"C": props{},
-			},
-			expectedProperties: map[string]Property{
-				"a": *createProperty("a", "string", ""),
-				"b": *createProperty("b", "int", ""),
-				"c": *createProperty("c", "props", "props docs."),
-			},
-			description: "struct is composed of primitive types and other structs",
-		},
-	}
-
-	r := NewReader(pkgFiles)
-	for _, testCase := range testCases {
-		structType := reflectionStructType(testCase.fields)
-		ps, err := r.PropertyStruct(structType.PkgPath(), structType.String(), reflect.New(structType).Elem())
-		if err != nil {
-			t.Fatal(err)
-		}
-		for _, actualProperty := range ps.Properties {
-			propName := actualProperty.Name
-			assertProperties(t, testCase.expectedProperties[propName], actualProperty)
-		}
-	}
-}
-
-func TestNestUnique(t *testing.T) {
-	testCases := []struct {
-		src         []Property
-		target      []Property
-		expected    []Property
-		description string
-	}{
-		{
-			src:         []Property{},
-			target:      []Property{},
-			expected:    []Property{},
-			description: "Nest Unique fails for empty slice",
-		},
-		{
-			src:         []Property{*createProperty("a", "string", ""), *createProperty("b", "string", "")},
-			target:      []Property{},
-			expected:    []Property{*createProperty("a", "string", ""), *createProperty("b", "string", "")},
-			description: "Nest Unique fails when all elements are unique",
-		},
-		{
-			src:         []Property{*createProperty("a", "string", ""), *createProperty("b", "string", "")},
-			target:      []Property{*createProperty("c", "string", "")},
-			expected:    []Property{*createProperty("a", "string", ""), *createProperty("b", "string", ""), *createProperty("c", "string", "")},
-			description: "Nest Unique fails when all elements are unique",
-		},
-		{
-			src:         []Property{*createProperty("a", "string", ""), *createProperty("b", "string", "")},
-			target:      []Property{*createProperty("a", "string", "")},
-			expected:    []Property{*createProperty("a", "string", ""), *createProperty("b", "string", "")},
-			description: "Nest Unique fails when nested elements are duplicate",
-		},
-	}
-
-	errMsgTemplate := "%s. Expected: %q, Actual: %q"
-	for _, testCase := range testCases {
-		actual := nestUnique(testCase.src, testCase.target)
-		if len(actual) != len(testCase.expected) {
-			t.Errorf(errMsgTemplate, testCase.description, testCase.expected, actual)
-		}
-		for i := 0; i < len(actual); i++ {
-			if !actual[i].Equal(testCase.expected[i]) {
-				t.Errorf(errMsgTemplate, testCase.description, testCase.expected[i], actual[i])
-			}
-		}
-	}
-}
-
-// Creates a struct using reflection and return its type
-func reflectionStructType(fields map[string]interface{}) reflect.Type {
-	var structFields []reflect.StructField
-	for fieldname, obj := range fields {
-		structField := reflect.StructField{
-			Name: fieldname,
-			Type: reflect.TypeOf(obj),
-		}
-		structFields = append(structFields, structField)
-	}
-	return reflect.StructOf(structFields)
-}
-
-// Creates a Property object with a subset of its props populated
-func createProperty(propName string, propType string, propDocs string) *Property {
-	return &Property{Name: propName, Type: propType, Text: formatText(propDocs)}
-}
-
-// Asserts that two Property objects are "similar"
-// Name, Type and Text properties are checked for similarity
-func assertProperties(t *testing.T, expected Property, actual Property) {
-	assertStrings(t, expected.Name, actual.Name)
-	assertStrings(t, expected.Type, actual.Type)
-	assertStrings(t, strings.TrimSpace(string(expected.Text)), strings.TrimSpace(string(actual.Text)))
-}
-
-func assertStrings(t *testing.T, expected string, actual string) {
-	if expected != actual {
-		t.Errorf("expected: %s, actual: %s", expected, actual)
-	}
-}
-
 func actualProperties(t *testing.T, props []Property) []string {
 	t.Helper()
 
diff --git a/bootstrap/bpdoc/reader.go b/bootstrap/bpdoc/reader.go
index 7aa655b..a39ee3c 100644
--- a/bootstrap/bpdoc/reader.go
+++ b/bootstrap/bpdoc/reader.go
@@ -83,7 +83,7 @@
 
 // Return the PropertyStruct associated with a property struct type.  The type should be in the
 // format <package path>.<type name>
-func (r *Reader) propertyStruct(pkgPath, name string, defaults reflect.Value) (*PropertyStruct, error) {
+func (r *Reader) PropertyStruct(pkgPath, name string, defaults reflect.Value) (*PropertyStruct, error) {
 	ps := r.getPropertyStruct(pkgPath, name)
 
 	if ps == nil {
@@ -113,43 +113,6 @@
 	return ps, nil
 }
 
-// Return the PropertyStruct associated with a struct type using recursion
-// This method is useful since golang structs created using reflection have an empty PkgPath()
-func (r *Reader) PropertyStruct(pkgPath, name string, defaults reflect.Value) (*PropertyStruct, error) {
-	var props []Property
-
-	// Base case: primitive type
-	if defaults.Kind() != reflect.Struct {
-		props = append(props, Property{Name: name,
-			Type: defaults.Type().String()})
-		return &PropertyStruct{Properties: props}, nil
-	}
-
-	// Base case: use r.propertyStruct if struct has a non empty pkgpath
-	if pkgPath != "" {
-		return r.propertyStruct(pkgPath, name, defaults)
-	}
-
-	numFields := defaults.NumField()
-	for i := 0; i < numFields; i++ {
-		field := defaults.Type().Field(i)
-		// Recurse
-		ps, err := r.PropertyStruct(field.Type.PkgPath(), field.Type.Name(), reflect.New(field.Type).Elem())
-
-		if err != nil {
-			return nil, err
-		}
-		prop := Property{
-			Name:       strings.ToLower(field.Name),
-			Text:       formatText(ps.Text),
-			Type:       field.Type.Name(),
-			Properties: ps.Properties,
-		}
-		props = append(props, prop)
-	}
-	return &PropertyStruct{Properties: props}, nil
-}
-
 func (r *Reader) getModuleTypeDoc(pkgPath, factoryFuncName string) (string, error) {
 	goPkg, err := r.goPkg(pkgPath)
 	if err != nil {
diff --git a/bootstrap/bpglob/bpglob.go b/bootstrap/bpglob/bpglob.go
index 1e6d25b..81c0dd0 100644
--- a/bootstrap/bpglob/bpglob.go
+++ b/bootstrap/bpglob/bpglob.go
@@ -19,10 +19,13 @@
 package main
 
 import (
+	"bytes"
+	"errors"
 	"flag"
 	"fmt"
 	"io/ioutil"
 	"os"
+	"strconv"
 	"time"
 
 	"github.com/google/blueprint/deptools"
@@ -30,14 +33,63 @@
 )
 
 var (
-	out = flag.String("o", "", "file to write list of files that match glob")
+	// flagSet is a flag.FlagSet with flag.ContinueOnError so that we can handle the versionMismatchError
+	// error from versionArg.
+	flagSet = flag.NewFlagSet("bpglob", flag.ContinueOnError)
 
-	globs []globArg
+	out = flagSet.String("o", "", "file to write list of files that match glob")
+
+	versionMatch versionArg
+	globs        []globArg
 )
 
 func init() {
-	flag.Var((*patternsArgs)(&globs), "p", "pattern to include in results")
-	flag.Var((*excludeArgs)(&globs), "e", "pattern to exclude from results from the most recent pattern")
+	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")
+}
+
+// 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.
+
+// versionArg checks the argument against pathtools.BPGlobArgumentVersion, returning a
+// versionMismatchError error if it does not match.
+type versionArg bool
+
+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
+
+	return nil
 }
 
 // A glob arg holds a single -p argument with zero or more following -e arguments.
@@ -75,24 +127,48 @@
 }
 
 func usage() {
-	fmt.Fprintln(os.Stderr, "usage: bpglob -o out -p glob [-e excludes ...] [-p glob ...]")
-	flag.PrintDefaults()
+	fmt.Fprintln(os.Stderr, "usage: bpglob -o out -v version -p glob [-e excludes ...] [-p glob ...]")
+	flagSet.PrintDefaults()
 	os.Exit(2)
 }
 
 func main() {
-	flag.Parse()
+	// 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()
+	}
 
 	if *out == "" {
 		fmt.Fprintln(os.Stderr, "error: -o is required")
 		usage()
 	}
 
-	if flag.NArg() > 0 {
+	if flagSet.NArg() > 0 {
 		usage()
 	}
 
-	err := globsWithDepFile(*out, *out+".d", globs)
+	err = globsWithDepFile(*out, *out+".d", globs)
 	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
diff --git a/bootstrap/build.ninja b/bootstrap/build.ninja
new file mode 100644
index 0000000..5787c72
--- /dev/null
+++ b/bootstrap/build.ninja
@@ -0,0 +1,23 @@
+# Included by .minibootstrap/build.ninja, which is written by bootstrap.bash
+#
+# Expected input variables:
+#   topFile           - The path to the top-level Blueprints(etc) file
+#   extraArgs         - Any extra arguments to pass to minibp (-t)
+#   bootstrapBuildDir - The path to the build directory
+
+ninja_required_version = 1.7.0
+
+myGlobs = ${bootstrapBuildDir}/.minibootstrap/build-globs.ninja
+subninja ${myGlobs}
+
+rule build.ninja
+    command = ${builder} ${extraArgs} -b ${bootstrapBuildDir} -n ${builddir} -d ${out}.d -globFile ${myGlobs} -o ${out} ${in}
+    deps = gcc
+    depfile = ${out}.d
+    description = ${builder} ${out}
+
+bootstrapNinja = ${bootstrapBuildDir}/.bootstrap/build.ninja
+
+build ${bootstrapNinja}: build.ninja ${topFile} | ${builder}
+    builder = ${bootstrapBuildDir}/.minibootstrap/minibp
+default ${bootstrapNinja}
diff --git a/bootstrap/cleanup.go b/bootstrap/cleanup.go
new file mode 100644
index 0000000..9dbea2a
--- /dev/null
+++ b/bootstrap/cleanup.go
@@ -0,0 +1,177 @@
+// Copyright 2014 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 bootstrap
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+
+	"github.com/google/blueprint"
+)
+
+const logFileName = ".ninja_log"
+
+// 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 {
+
+	if len(under) == 0 {
+		return nil
+	}
+
+	ninjaBuildDir, err := ctx.NinjaBuildDir()
+	if err != nil {
+		return err
+	}
+
+	targetRules, err := ctx.AllTargets()
+	if err != nil {
+		return fmt.Errorf("error determining target list: %s", err)
+	}
+
+	replacer := strings.NewReplacer(
+		"@@SrcDir@@", srcDir,
+		"@@BuildDir@@", buildDir)
+	ninjaBuildDir = replacer.Replace(ninjaBuildDir)
+	targets := make(map[string]bool)
+	for target := range targetRules {
+		replacedTarget := replacer.Replace(target)
+		targets[filepath.Clean(replacedTarget)] = true
+	}
+	for _, target := range exempt {
+		replacedTarget := replacer.Replace(target)
+		targets[filepath.Clean(replacedTarget)] = true
+	}
+
+	filePaths, err := parseNinjaLog(ninjaBuildDir, under)
+	if err != nil {
+		return err
+	}
+
+	for _, filePath := range filePaths {
+		isTarget := targets[filePath]
+		if !isTarget {
+			err = removeFileAndEmptyDirs(absolutePath(filePath))
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func parseNinjaLog(ninjaBuildDir string, under []string) ([]string, error) {
+	logFilePath := filepath.Join(ninjaBuildDir, logFileName)
+	logFile, err := os.Open(logFilePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	defer logFile.Close()
+
+	scanner := bufio.NewScanner(logFile)
+
+	// Check that the first line indicates that this is a Ninja log version 5
+	const expectedFirstLine = "# ninja log v5"
+	if !scanner.Scan() || scanner.Text() != expectedFirstLine {
+		return nil, errors.New("unrecognized ninja log format")
+	}
+
+	var filePaths []string
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		const fieldSeperator = "\t"
+		fields := strings.Split(line, fieldSeperator)
+
+		const precedingFields = 3
+		const followingFields = 1
+
+		if len(fields) < precedingFields+followingFields+1 {
+			return nil, fmt.Errorf("log entry has too few fields: %q", line)
+		}
+
+		start := precedingFields
+		end := len(fields) - followingFields
+		filePath := strings.Join(fields[start:end], fieldSeperator)
+
+		for _, dir := range under {
+			if strings.HasPrefix(filePath, dir) {
+				filePaths = append(filePaths, filePath)
+				break
+			}
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return filePaths, nil
+}
+
+func removeFileAndEmptyDirs(path string) error {
+	err := os.Remove(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		pathErr := err.(*os.PathError)
+		switch pathErr.Err {
+		case syscall.ENOTEMPTY, syscall.EEXIST, syscall.ENOTDIR:
+			return nil
+		}
+		return err
+	}
+	fmt.Printf("removed old ninja-created file %s because it has no rule to generate it\n", path)
+
+	path, err = filepath.Abs(path)
+	if err != nil {
+		return err
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	for dir := filepath.Dir(path); dir != cwd; dir = filepath.Dir(dir) {
+		err = os.Remove(dir)
+		if err != nil {
+			pathErr := err.(*os.PathError)
+			switch pathErr.Err {
+			case syscall.ENOTEMPTY, syscall.EEXIST:
+				// We've come to a nonempty directory, so we're done.
+				return nil
+			default:
+				return err
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/bootstrap/command.go b/bootstrap/command.go
index 8c045b4..4a938db 100644
--- a/bootstrap/command.go
+++ b/bootstrap/command.go
@@ -16,6 +16,7 @@
 
 import (
 	"bufio"
+	"flag"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -27,32 +28,126 @@
 	"runtime/trace"
 
 	"github.com/google/blueprint"
+	"github.com/google/blueprint/deptools"
 )
 
 type Args struct {
-	ModuleListFile string
-	OutFile        string
+	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
 
-	EmptyNinjaFile bool
+	PrimaryBuilderInvocations []PrimaryBuilderInvocation
+}
 
-	NoGC       bool
-	Cpuprofile string
-	Memprofile string
-	TraceFile  string
+var (
+	CmdlineArgs Args
+	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")
+}
+
+func Main(ctx *blueprint.Context, config interface{}, generatingPrimaryBuilder bool) {
+	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, stopBefore StopBefore, ctx *blueprint.Context, config interface{}) []string {
+func RunBlueprint(args Args, ctx *blueprint.Context, config interface{}) []string {
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
 	if args.NoGC {
 		debug.SetGCPercent(-1)
 	}
 
+	absSrcDir = ctx.SrcDir()
+
 	if args.Cpuprofile != "" {
-		f, err := os.Create(joinPath(ctx.SrcDir(), args.Cpuprofile))
+		f, err := os.Create(absolutePath(args.Cpuprofile))
 		if err != nil {
 			fatalf("error opening cpuprofile: %s", err)
 		}
@@ -62,7 +157,7 @@
 	}
 
 	if args.TraceFile != "" {
-		f, err := os.Create(joinPath(ctx.SrcDir(), args.TraceFile))
+		f, err := os.Create(absolutePath(args.TraceFile))
 		if err != nil {
 			fatalf("error opening trace: %s", err)
 		}
@@ -71,7 +166,7 @@
 		defer trace.Stop()
 	}
 
-	srcDir := "."
+	srcDir := filepath.Dir(args.TopFile)
 
 	ninjaDeps := make([]string, 0)
 
@@ -81,24 +176,60 @@
 	} else {
 		fatalf("-l <moduleListFile> is required and must be nonempty")
 	}
-	ctx.BeginEvent("list_modules")
 	filesToParse, err := ctx.ListModulePaths(srcDir)
-	ctx.EndEvent("list_modules")
 	if err != nil {
 		fatalf("could not enumerate files: %v\n", err.Error())
 	}
 
-	ctx.RegisterBottomUpMutator("bootstrap_plugin_deps", pluginDeps)
-	ctx.RegisterModuleType("bootstrap_go_package", newGoPackageModuleFactory())
-	ctx.RegisterModuleType("blueprint_go_binary", newGoBinaryModuleFactory())
-	ctx.RegisterSingletonType("bootstrap", newSingletonFactory())
+	buildDir := config.(BootstrapConfig).BuildDir()
 
-	ctx.BeginEvent("parse_bp")
-	blueprintFiles, errs := ctx.ParseFileList(".", filesToParse, config)
+	stage := StageMain
+	if args.GeneratingPrimaryBuilder {
+		stage = StagePrimary
+	}
+
+	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,
+		}}
+	}
+
+	bootstrapConfig := &Config{
+		stage: stage,
+
+		topLevelBlueprintsFile:    args.TopFile,
+		globFile:                  primaryBuilderNinjaGlobFile,
+		runGoTests:                args.RunGoTests,
+		useValidations:            args.UseValidations,
+		primaryBuilderInvocations: invocations,
+	}
+
+	ctx.RegisterBottomUpMutator("bootstrap_plugin_deps", pluginDeps)
+	ctx.RegisterModuleType("bootstrap_go_package", newGoPackageModuleFactory(bootstrapConfig))
+	ctx.RegisterModuleType("bootstrap_go_binary", newGoBinaryModuleFactory(bootstrapConfig, false))
+	ctx.RegisterModuleType("blueprint_go_binary", newGoBinaryModuleFactory(bootstrapConfig, true))
+	ctx.RegisterSingletonType("bootstrap", newSingletonFactory(bootstrapConfig))
+
+	ctx.RegisterSingletonType("glob", globSingletonFactory(bootstrapConfig, ctx))
+
+	blueprintFiles, errs := ctx.ParseFileList(filepath.Dir(args.TopFile), filesToParse, config)
 	if len(errs) > 0 {
 		fatalErrors(errs)
 	}
-	ctx.EndEvent("parse_bp")
 
 	// Add extra ninja file dependencies
 	ninjaDeps = append(ninjaDeps, blueprintFiles...)
@@ -109,8 +240,18 @@
 	}
 	ninjaDeps = append(ninjaDeps, extraDeps...)
 
-	if stopBefore == StopBeforePrepareBuildActions {
-		return ninjaDeps
+	if args.DocFile != "" {
+		err := writeDocs(ctx, config, absolutePath(args.DocFile))
+		if err != nil {
+			fatalErrors([]error{err})
+		}
+		return nil
+	}
+
+	if c, ok := config.(ConfigStopBefore); ok {
+		if c.StopBefore() == StopBeforePrepareBuildActions {
+			return ninjaDeps
+		}
 	}
 
 	extraDeps, errs = ctx.PrepareBuildActions(config)
@@ -119,8 +260,10 @@
 	}
 	ninjaDeps = append(ninjaDeps, extraDeps...)
 
-	if stopBefore == StopBeforeWriteNinja {
-		return ninjaDeps
+	if c, ok := config.(ConfigStopBefore); ok {
+		if c.StopBefore() == StopBeforeWriteNinja {
+			return ninjaDeps
+		}
 	}
 
 	const outFilePermissions = 0666
@@ -128,16 +271,14 @@
 	var f *os.File
 	var buf *bufio.Writer
 
-	ctx.BeginEvent("write_files")
-	defer ctx.EndEvent("write_files")
 	if args.EmptyNinjaFile {
-		if err := ioutil.WriteFile(joinPath(ctx.SrcDir(), args.OutFile), []byte(nil), outFilePermissions); err != nil {
+		if err := ioutil.WriteFile(absolutePath(args.OutFile), []byte(nil), outFilePermissions); err != nil {
 			fatalf("error writing empty Ninja file: %s", err)
 		}
 	}
 
-	if !args.EmptyNinjaFile {
-		f, err = os.OpenFile(joinPath(ctx.SrcDir(), args.OutFile), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, outFilePermissions)
+	if stage != StageMain || !args.EmptyNinjaFile {
+		f, err = os.OpenFile(absolutePath(args.OutFile), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, outFilePermissions)
 		if err != nil {
 			fatalf("error opening Ninja file: %s", err)
 		}
@@ -147,6 +288,18 @@
 		out = ioutil.Discard.(io.StringWriter)
 	}
 
+	if args.GlobFile != "" {
+		buffer, errs := generateGlobNinjaFile(bootstrapConfig, config, ctx.Globs)
+		if len(errs) > 0 {
+			fatalErrors(errs)
+		}
+
+		err = ioutil.WriteFile(absolutePath(args.GlobFile), buffer, outFilePermissions)
+		if err != nil {
+			fatalf("error writing %s: %s", args.GlobFile, err)
+		}
+	}
+
 	err = ctx.WriteBuildFile(out)
 	if err != nil {
 		fatalf("error writing Ninja file contents: %s", err)
@@ -166,8 +319,16 @@
 		}
 	}
 
+	if c, ok := config.(ConfigRemoveAbandonedFilesUnder); ok {
+		under, except := c.RemoveAbandonedFilesUnder(buildDir)
+		err := removeAbandonedFilesUnder(ctx, srcDir, buildDir, under, except)
+		if err != nil {
+			fatalf("error removing abandoned files: %s", err)
+		}
+	}
+
 	if args.Memprofile != "" {
-		f, err := os.Create(joinPath(ctx.SrcDir(), args.Memprofile))
+		f, err := os.Create(absolutePath(args.Memprofile))
 		if err != nil {
 			fatalf("error opening memprofile: %s", err)
 		}
@@ -201,9 +362,9 @@
 	os.Exit(1)
 }
 
-func joinPath(base, path string) string {
+func absolutePath(path string) string {
 	if filepath.IsAbs(path) {
 		return path
 	}
-	return filepath.Join(base, path)
+	return filepath.Join(absSrcDir, path)
 }
diff --git a/bootstrap/config.go b/bootstrap/config.go
index 9972b5d..a29ba76 100644
--- a/bootstrap/config.go
+++ b/bootstrap/config.go
@@ -39,13 +39,13 @@
 	// These variables are the only configuration needed by the bootstrap
 	// modules.
 	srcDirVariable = bootstrapVariable("srcDir", func(c BootstrapConfig) string {
-		return "."
+		return c.SrcDir()
 	})
-	soongOutDirVariable = bootstrapVariable("soongOutDir", func(c BootstrapConfig) string {
-		return c.SoongOutDir()
+	buildDirVariable = bootstrapVariable("buildDir", func(c BootstrapConfig) string {
+		return c.BuildDir()
 	})
-	outDirVariable = bootstrapVariable("outDir", func(c BootstrapConfig) string {
-		return c.OutDir()
+	ninjaBuildDirVariable = bootstrapVariable("ninjaBuildDir", func(c BootstrapConfig) string {
+		return c.NinjaBuildDir()
 	})
 	goRootVariable = bootstrapVariable("goRoot", func(c BootstrapConfig) string {
 		goroot := runtime.GOROOT()
@@ -76,39 +76,67 @@
 )
 
 type BootstrapConfig interface {
-	// The directory where tools run during the build are located.
-	HostToolDir() string
+	// The top-level directory of the source tree
+	SrcDir() string
 
 	// The directory where files emitted during bootstrapping are located.
-	// Usually OutDir() + "/soong".
-	SoongOutDir() string
+	// Usually NinjaBuildDir() + "/soong".
+	BuildDir() string
 
 	// The output directory for the build.
-	OutDir() string
+	NinjaBuildDir() string
 
 	// Whether to compile Go code in such a way that it can be debugged
 	DebugCompilation() bool
+}
 
-	// Whether to run tests for Go code
-	RunGoTests() bool
+type ConfigRemoveAbandonedFilesUnder interface {
+	// RemoveAbandonedFilesUnder should return two slices:
+	// - 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)
+}
 
-	Subninjas() []string
-	PrimaryBuilderInvocations() []PrimaryBuilderInvocation
+type ConfigBlueprintToolLocation interface {
+	// BlueprintToolLocation can return a path name to install blueprint tools
+	// designed for end users (bpfmt, bpmodify, and anything else using
+	// blueprint_go_binary).
+	BlueprintToolLocation() string
 }
 
 type StopBefore int
 
 const (
-	DoEverything StopBefore = iota
-	StopBeforePrepareBuildActions
-	StopBeforeWriteNinja
+	StopBeforePrepareBuildActions StopBefore = 1
+	StopBeforeWriteNinja          StopBefore = 2
+)
+
+type ConfigStopBefore interface {
+	StopBefore() StopBefore
+}
+
+type Stage int
+
+const (
+	StagePrimary Stage = iota
+	StageMain
 )
 
 type PrimaryBuilderInvocation struct {
-	Inputs      []string
-	Outputs     []string
-	Args        []string
-	Console     bool
-	Description string
-	Env         map[string]string
+	Inputs  []string
+	Outputs []string
+	Args    []string
+}
+
+type Config struct {
+	stage Stage
+
+	topLevelBlueprintsFile string
+	globFile               string
+
+	runGoTests     bool
+	useValidations bool
+
+	primaryBuilderInvocations []PrimaryBuilderInvocation
 }
diff --git a/bootstrap/doc.go b/bootstrap/doc.go
new file mode 100644
index 0000000..69a1784
--- /dev/null
+++ b/bootstrap/doc.go
@@ -0,0 +1,150 @@
+// Copyright 2014 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.
+
+// The Blueprint bootstrapping mechanism is intended to enable building a
+// source tree with minimal prebuilts.  The only prerequisites for performing
+// such a build are:
+//
+//   1. A Ninja binary
+//   2. A script interpreter (e.g. Bash or Python)
+//   3. A Go toolchain
+//
+// The Primary Builder
+//
+// As part of the bootstrapping process, a binary called the "primary builder"
+// is created.  This primary builder is the binary that includes both the core
+// Blueprint library and the build logic specific to the source tree.  It is
+// used to generate the Ninja file that describes how to build the entire source
+// tree.
+//
+// The primary builder must be a pure Go (i.e. no cgo) module built with the
+// module type 'bootstrap_go_binary'.  It should have the 'primaryBuilder'
+// module property set to true in its Blueprints file.  If more than one module
+// sets primaryBuilder to true the build will fail.
+//
+// The primary builder main function should look something like:
+//
+//   package main
+//
+//   import (
+//       "flag"
+//       "github.com/google/blueprint"
+//       "github.com/google/blueprint/bootstrap"
+//       "path/filepath"
+//
+//       "my/custom/build/logic"
+//   )
+//
+//   func main() {
+//       // The primary builder should use the global flag set because the
+//       // bootstrap package registers its own flags there.
+//       flag.Parse()
+//
+//       // The top-level Blueprints file is passed as the first argument.
+//       srcDir := filepath.Dir(flag.Arg(0))
+//
+//       // Create the build context.
+//       ctx := blueprint.NewContext()
+//
+//       // Register custom module types
+//       ctx.RegisterModuleType("foo", logic.FooModule)
+//       ctx.RegisterModuleType("bar", logic.BarModule)
+//
+//       // Register custom singletons
+//       ctx.RegisterSingleton("baz", logic.NewBazSingleton())
+//
+//       // Create and initialize the custom Config object.
+//       config := logic.NewConfig(srcDir)
+//
+//       // This call never returns
+//       bootstrap.Main(ctx, config)
+//   }
+//
+// Required Source Files
+//
+// There are three files that must be included in the source tree to facilitate
+// the build bootstrapping:
+//
+//   1. The top-level Blueprints file
+//   2. The bootstrap script
+//   3. The build wrapper script
+//
+// The top-level Blueprints file describes how the entire source tree should be
+// built.  It must have a 'subdirs' assignment that includes both the core
+// Blueprint library and the custom build logic for the source tree.  It should
+// also include (either directly or through a subdirs entry) describe all the
+// modules to be built in the source tree.
+//
+// The bootstrap script is a small script to setup the build directory, writing
+// a couple configuration files (including the path the source directory,
+// information about the Go build environment, etc), then copying the build
+// wrapper into the build directory.
+//
+// The Bootstrapping Process
+//
+// There are three stages to the bootstrapping process, each with a
+// corresponding Ninja file. The stages are referred to as the "bootstrap",
+// "primary", and "main" stages. Each stage builds the next stage's Ninja file.
+//
+// The bootstrapping process begins with the user running the bootstrap script
+// to initialize a new build directory.  The script is run from the build
+// directory, and creates a ".minibootstrap/build.ninja" file that sets a few
+// variables then includes blueprint's "bootstrap/build.ninja". It also writes
+// out a ".blueprint.bootstrap" file that contains a few variables for later use:
+//
+//   BLUEPRINT_BOOTSTRAP_VERSION - Used to detect when a user needs to run
+//                                 bootstrap.bash again
+//
+//   SRCDIR         - The path to the source directory
+//   BLUEPRINTDIR   - The path to the blueprints directory (includes $SRCDIR)
+//   GOROOT         - The path to the root directory of the Go toolchain
+//   NINJA_BUILDDIR - The path to store .ninja_log, .ninja_deps
+//
+// Once the script completes the build directory is initialized and ready to run
+// a build. A wrapper script (blueprint.bash by default) has been installed in
+// order to run a build. It iterates through the three stages of the build:
+//
+//      - Runs microfactory.bash to build minibp
+//      - Runs the .minibootstrap/build.ninja to build .bootstrap/build.ninja
+//      - Runs .bootstrap/build.ninja to build and run the primary builder
+//      - Runs build.ninja to build your code
+//
+// Microfactory takes care of building an up to date version of `minibp` and
+// `bpglob` under the .minibootstrap/ directory.
+//
+// During <builddir>/.minibootstrap/build.ninja, the following actions are
+// taken, if necessary:
+//
+//      - Run minibp to generate .bootstrap/build.ninja (Primary stage)
+//      - Includes .minibootstrap/build-globs.ninja, which defines rules to
+//        run bpglob during incremental builds. These outputs are listed in
+//        the dependency file output by minibp.
+//
+// During the <builddir>/.bootstrap/build.ninja, the following actions are
+// taken, if necessary:
+//
+//      - Build the primary builder, anything marked `default: true`, and
+//        any dependencies.
+//      - Run the primary builder to generate build.ninja
+//      - Run the primary builder to extract documentation
+//      - Includes .bootstrap/build-globs.ninja, which defines rules to run
+//        bpglob during incremental builds. These outputs are listed in the
+//        dependency file output by the primary builder.
+//
+// Then the main stage is at <builddir>/build.ninja, and will contain all the
+// rules generated by the primary builder. In addition, the bootstrap code
+// adds a phony rule "blueprint_tools" that depends on all blueprint_go_binary
+// rules (bpfmt, bpmodify, etc).
+//
+package bootstrap
diff --git a/bootstrap/glob.go b/bootstrap/glob.go
index 70495dc..39c662b 100644
--- a/bootstrap/glob.go
+++ b/bootstrap/glob.go
@@ -19,7 +19,6 @@
 	"fmt"
 	"hash/fnv"
 	"io"
-	"io/ioutil"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -44,16 +43,15 @@
 // in a build failure with a "missing and no known rule to make it" error.
 
 var (
-	_ = pctx.VariableFunc("globCmd", func(config interface{}) (string, error) {
-		return filepath.Join(config.(BootstrapConfig).SoongOutDir(), "bpglob"), nil
-	})
+	globCmd = filepath.Join(miniBootstrapDir, "bpglob")
 
 	// globRule rule traverses directories to produce a list of files that match $glob
 	// and writes it to $out if it has changed, and writes the directories to $out.d
 	GlobRule = pctx.StaticRule("GlobRule",
 		blueprint.RuleParams{
-			Command:     "$globCmd -o $out $args",
-			CommandDeps: []string{"$globCmd"},
+			Command: fmt.Sprintf(`%s -o $out -v %d $args`,
+				globCmd, pathtools.BPGlobArgumentVersion),
+			CommandDeps: []string{globCmd},
 			Description: "glob",
 
 			Restat:  true,
@@ -146,87 +144,77 @@
 	return string(ret)
 }
 
-// GlobSingleton collects any glob patterns that were seen by Context and writes out rules to
+// globSingleton collects any glob patterns that were seen by Context and writes out rules to
 // re-evaluate them whenever the contents of the searched directories change, and retrigger the
 // primary builder if the results change.
-type GlobSingleton struct {
-	// A function that returns the glob results of individual glob buckets
-	GlobLister func() pathtools.MultipleGlobResults
-
-	// Ninja file that contains instructions for validating the glob list files
-	GlobFile string
-
-	// Directory containing the glob list files
-	GlobDir string
-
-	// The source directory
-	SrcDir string
+type globSingleton struct {
+	config     *Config
+	globLister func() pathtools.MultipleGlobResults
+	writeRule  bool
 }
 
-func globBucketName(globDir string, globBucket int) string {
-	return filepath.Join(globDir, strconv.Itoa(globBucket))
+func globSingletonFactory(config *Config, ctx *blueprint.Context) func() blueprint.Singleton {
+	return func() blueprint.Singleton {
+		return &globSingleton{
+			config:     config,
+			globLister: ctx.Globs,
+		}
+	}
 }
 
-// Returns the directory where glob list files live
-func GlobDirectory(buildDir, globListDir string) string {
-	return filepath.Join(buildDir, "globs", globListDir)
-}
-
-func (s *GlobSingleton) GenerateBuildActions(ctx blueprint.SingletonContext) {
+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() {
+	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 := globBucketName(s.GlobDir, i)
+		fileListFile := filepath.Join(globsDir, strconv.Itoa(i))
 
-		// 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.
-		absoluteFileListFile := joinPath(s.SrcDir, fileListFile)
-		err := pathtools.WriteFileIfChanged(absoluteFileListFile, globs.FileList(), 0666)
-		if err != nil {
-			panic(fmt.Errorf("error writing %s: %s", fileListFile, err))
+		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)
+			if err != nil {
+				panic(fmt.Errorf("error writing %s: %s", fileListFile, err))
+			}
+
+			// Write out the ninja rule to run bpglob.
+			multipleGlobFilesRule(ctx, fileListFile, i, globs)
+		} else {
+			// Called from the main Context, make build.ninja depend on the fileListFile.
+			ctx.AddNinjaFileDeps(fileListFile)
 		}
-
-		// Write out the ninja rule to run bpglob.
-		multipleGlobFilesRule(ctx, fileListFile, i, globs)
 	}
 }
 
-// Writes a .ninja file that contains instructions for regenerating the glob
-// files that contain the results of every glob that was run. The list of files
-// is available as the result of GlobFileListFiles().
-func WriteBuildGlobsNinjaFile(glob *GlobSingleton, config interface{}) {
-	buffer, errs := generateGlobNinjaFile(glob, config)
-	if len(errs) > 0 {
-		fatalErrors(errs)
-	}
-
-	const outFilePermissions = 0666
-	err := ioutil.WriteFile(joinPath(glob.SrcDir, glob.GlobFile), buffer, outFilePermissions)
-	if err != nil {
-		fatalf("error writing %s: %s", glob.GlobFile, err)
-	}
-}
-func generateGlobNinjaFile(glob *GlobSingleton, config interface{}) ([]byte, []error) {
+func generateGlobNinjaFile(bootstrapConfig *Config, config interface{},
+	globLister func() pathtools.MultipleGlobResults) ([]byte, []error) {
 
 	ctx := blueprint.NewContext()
 	ctx.RegisterSingletonType("glob", func() blueprint.Singleton {
-		return glob
+		return &globSingleton{
+			config:     bootstrapConfig,
+			globLister: globLister,
+			writeRule:  true,
+		}
 	})
 
 	extraDeps, errs := ctx.ResolveDependencies(config)
@@ -254,15 +242,23 @@
 	return buf.Bytes(), nil
 }
 
-// GlobFileListFiles returns the list of files that contain the result of globs
-// in the build. It is suitable for inclusion in build.ninja.d (so that
-// build.ninja is regenerated if the globs change). The instructions to
-// regenerate these files are written by WriteBuildGlobsNinjaFile().
-func GlobFileListFiles(globDir string) []string {
+// 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++ {
-		fileListFile := globBucketName(globDir, i)
-		fileListFiles = append(fileListFiles, fileListFile)
+		fileListFiles = append(fileListFiles, filepath.Join(globsDir, strconv.Itoa(i)))
 	}
 	return fileListFiles
 }
diff --git a/bootstrap/minibp/main.go b/bootstrap/minibp/main.go
new file mode 100644
index 0000000..165f058
--- /dev/null
+++ b/bootstrap/minibp/main.go
@@ -0,0 +1,56 @@
+// Copyright 2014 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 (
+	"flag"
+	"path/filepath"
+
+	"github.com/google/blueprint"
+	"github.com/google/blueprint/bootstrap"
+)
+
+var runAsPrimaryBuilder bool
+
+func init() {
+	flag.BoolVar(&runAsPrimaryBuilder, "p", false, "run as a primary builder")
+}
+
+type Config struct {
+}
+
+func (c Config) SrcDir() string {
+	return bootstrap.CmdlineArgs.BuildDir
+}
+
+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")}
+	}
+	return
+}
+
+func main() {
+	flag.Parse()
+
+	ctx := blueprint.NewContext()
+	if !runAsPrimaryBuilder {
+		ctx.SetIgnoreUnknownModuleTypes(true)
+	}
+
+	config := Config{}
+	bootstrap.Main(ctx, config, !runAsPrimaryBuilder)
+}
diff --git a/bootstrap/writedocs.go b/bootstrap/writedocs.go
index f7314f7..99df32f 100644
--- a/bootstrap/writedocs.go
+++ b/bootstrap/writedocs.go
@@ -1,7 +1,10 @@
 package bootstrap
 
 import (
+	"bytes"
 	"fmt"
+	"html/template"
+	"io/ioutil"
 	"path/filepath"
 	"reflect"
 
@@ -12,23 +15,33 @@
 
 // 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, factories map[string]reflect.Value) ([]*bpdoc.Package, error) {
+func ModuleTypeDocs(ctx *blueprint.Context, config interface{}, 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.
 	var primaryBuilders []*goBinary
+	var minibp *goBinary
 	ctx.VisitAllModulesIf(isBootstrapBinaryModule,
 		func(module blueprint.Module) {
 			binaryModule := module.(*goBinary)
 			if binaryModule.properties.PrimaryBuilder {
 				primaryBuilders = append(primaryBuilders, binaryModule)
 			}
+			if ctx.ModuleName(binaryModule) == "minibp" {
+				minibp = binaryModule
+			}
 		})
 
+	if minibp == nil {
+		panic("missing minibp")
+	}
+
 	var primaryBuilder *goBinary
 	switch len(primaryBuilders) {
 	case 0:
-		return nil, fmt.Errorf("no primary builder module present")
+		// If there's no primary builder module then that means we'll use minibp
+		// as the primary builder.
+		primaryBuilder = minibp
 
 	case 1:
 		primaryBuilder = primaryBuilders[0]
@@ -42,7 +55,7 @@
 		switch m := module.(type) {
 		case (*goPackage):
 			pkgFiles[m.properties.PkgPath] = pathtools.PrefixPaths(m.properties.Srcs,
-				filepath.Join(ctx.SrcDir(), ctx.ModuleDir(m)))
+				filepath.Join(config.(BootstrapConfig).SrcDir(), ctx.ModuleDir(m)))
 		default:
 			panic(fmt.Errorf("unknown dependency type %T", module))
 		}
@@ -61,3 +74,111 @@
 
 	return bpdoc.AllPackages(pkgFiles, mergedFactories, ctx.ModuleTypePropertyStructs())
 }
+
+func writeDocs(ctx *blueprint.Context, config interface{}, filename string) error {
+	moduleTypeList, err := ModuleTypeDocs(ctx, config, nil)
+	if err != nil {
+		return err
+	}
+
+	buf := &bytes.Buffer{}
+
+	unique := 0
+
+	tmpl, err := template.New("file").Funcs(map[string]interface{}{
+		"unique": func() int {
+			unique++
+			return unique
+		}}).Parse(fileTemplate)
+	if err != nil {
+		return err
+	}
+
+	err = tmpl.Execute(buf, moduleTypeList)
+	if err != nil {
+		return err
+	}
+
+	err = ioutil.WriteFile(filename, buf.Bytes(), 0666)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+const (
+	fileTemplate = `
+<html>
+<head>
+<title>Build Docs</title>
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
+<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/js/bootstrap.min.js"></script>
+</head>
+<body>
+<h1>Build Docs</h1>
+<div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">
+  {{range .}}
+    <p>{{.Text}}</p>
+    {{range .ModuleTypes}}
+      {{ $collapseIndex := unique }}
+      <div class="panel panel-default">
+        <div class="panel-heading" role="tab" id="heading{{$collapseIndex}}">
+          <h2 class="panel-title">
+            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapse{{$collapseIndex}}" aria-expanded="false" aria-controls="collapse{{$collapseIndex}}">
+               {{.Name}}
+            </a>
+          </h2>
+        </div>
+      </div>
+      <div id="collapse{{$collapseIndex}}" class="panel-collapse collapse" role="tabpanel" aria-labelledby="heading{{$collapseIndex}}">
+        <div class="panel-body">
+          <p>{{.Text}}</p>
+          {{range .PropertyStructs}}
+            <p>{{.Text}}</p>
+            {{template "properties" .Properties}}
+          {{end}}
+        </div>
+      </div>
+    {{end}}
+  {{end}}
+</div>
+</body>
+</html>
+
+{{define "properties"}}
+  <div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">
+    {{range .}}
+      {{$collapseIndex := unique}}
+      {{if .Properties}}
+        <div class="panel panel-default">
+          <div class="panel-heading" role="tab" id="heading{{$collapseIndex}}">
+            <h4 class="panel-title">
+              <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapse{{$collapseIndex}}" aria-expanded="false" aria-controls="collapse{{$collapseIndex}}">
+                 {{.Name}}{{range .OtherNames}}, {{.}}{{end}}
+              </a>
+            </h4>
+          </div>
+        </div>
+        <div id="collapse{{$collapseIndex}}" class="panel-collapse collapse" role="tabpanel" aria-labelledby="heading{{$collapseIndex}}">
+          <div class="panel-body">
+            <p>{{.Text}}</p>
+            {{range .OtherTexts}}<p>{{.}}</p>{{end}}
+            {{template "properties" .Properties}}
+          </div>
+        </div>
+      {{else}}
+        <div>
+          <h4>{{.Name}}{{range .OtherNames}}, {{.}}{{end}}</h4>
+          <p>{{.Text}}</p>
+          {{range .OtherTexts}}<p>{{.}}</p>{{end}}
+          <p><i>Type: {{.Type}}</i></p>
+          {{if .Default}}<p><i>Default: {{.Default}}</i></p>{{end}}
+        </div>
+      {{end}}
+    {{end}}
+  </div>
+{{end}}
+`
+)
diff --git a/bpmodify/bpmodify.go b/bpmodify/bpmodify.go
index 431eb83..29d28f0 100644
--- a/bpmodify/bpmodify.go
+++ b/bpmodify/bpmodify.go
@@ -30,9 +30,8 @@
 	targetedProperty = new(qualifiedProperty)
 	addIdents        = new(identSet)
 	removeIdents     = new(identSet)
-	removeProperty   = flag.Bool("remove-property", false, "remove the property")
-	setString        *string
-	addLiteral       *string
+
+	setString *string
 )
 
 func init() {
@@ -40,7 +39,6 @@
 	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(stringPtrFlag{&addLiteral}, "add-literal", "a literal 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
@@ -147,12 +145,12 @@
 
 func processModule(module *parser.Module, moduleName string,
 	file *parser.File) (modified bool, errs []error) {
-	prop, parent, err := getRecursiveProperty(module, targetedProperty.name(), targetedProperty.prefixes())
+	prop, err := getRecursiveProperty(module, targetedProperty.name(), targetedProperty.prefixes())
 	if err != nil {
 		return false, []error{err}
 	}
 	if prop == nil {
-		if len(addIdents.idents) > 0 || addLiteral != 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 {
@@ -168,28 +166,25 @@
 			// Here should be unreachable, but still handle it for completeness.
 			return false, []error{err}
 		}
-	} else if *removeProperty {
-		// remove-property is used solely, so return here.
-		return parent.RemoveProperty(prop.Name), nil
 	}
 	m, errs := processParameter(prop.Value, targetedProperty.String(), moduleName, file)
 	modified = modified || m
 	return modified, errs
 }
 
-func getRecursiveProperty(module *parser.Module, name string, prefixes []string) (prop *parser.Property, parent *parser.Map, err error) {
-	prop, parent, _, err = getOrCreateRecursiveProperty(module, name, prefixes, nil)
-	return prop, parent, err
+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) {
-	prop, _, modified, err = getOrCreateRecursiveProperty(module, name, prefixes, empty)
-	return prop, modified, err
+
+	return getOrCreateRecursiveProperty(module, name, prefixes, empty)
 }
 
 func getOrCreateRecursiveProperty(module *parser.Module, name string, prefixes []string,
-	empty parser.Expression) (prop *parser.Property, parent *parser.Map, modified bool, err error) {
+	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 {
@@ -198,7 +193,7 @@
 			} 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, nil, false, fmt.Errorf("Expected property %q to be a map, found %s",
+				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 {
@@ -209,18 +204,18 @@
 			// 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, nil, false, nil
+			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, m, false, nil
+		return prop, false, nil
 	} else if empty != nil {
 		prop = &parser.Property{Name: name, Value: empty}
 		m.Properties = append(m.Properties, prop)
-		return prop, m, true, nil
+		return prop, true, nil
 	} else {
-		return nil, nil, false, nil
+		return nil, false, nil
 	}
 }
 
@@ -258,21 +253,6 @@
 		if (wasSorted || *sortLists) && modified {
 			parser.SortList(file, list)
 		}
-	} else if addLiteral != nil {
-		if *sortLists {
-			return false, []error{fmt.Errorf("sorting not supported when adding a literal")}
-		}
-		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())}
-		}
-		value, errs := parser.ParseExpression(strings.NewReader(*addLiteral))
-		if errs != nil {
-			return false, errs
-		}
-		list.Values = append(list.Values, value)
-		modified = true
 	} else if setString != nil {
 		str, ok := value.(*parser.String)
 		if !ok {
@@ -344,13 +324,8 @@
 		return
 	}
 
-	if len(addIdents.idents) == 0 && len(removeIdents.idents) == 0 && setString == nil && addLiteral == nil && !*removeProperty {
-		report(fmt.Errorf("-a, -add-literal, -r, -remove-property or -str parameter is required"))
-		return
-	}
-
-	if *removeProperty && (len(addIdents.idents) > 0 || len(removeIdents.idents) > 0 || setString != nil || addLiteral != nil) {
-		report(fmt.Errorf("-remove-property cannot be used with other parameter(s)"))
+	if len(addIdents.idents) == 0 && len(removeIdents.idents) == 0 && setString == nil {
+		report(fmt.Errorf("-a, -r or -str parameter is required"))
 		return
 	}
 
diff --git a/bpmodify/bpmodify_test.go b/bpmodify/bpmodify_test.go
index 4340edb..a92d439 100644
--- a/bpmodify/bpmodify_test.go
+++ b/bpmodify/bpmodify_test.go
@@ -23,15 +23,13 @@
 )
 
 var testCases = []struct {
-	name           string
-	input          string
-	output         string
-	property       string
-	addSet         string
-	removeSet      string
-	addLiteral     *string
-	setString      *string
-	removeProperty bool
+	name      string
+	input     string
+	output    string
+	property  string
+	addSet    string
+	removeSet string
+	setString *string
 }{
 	{
 		name: "add",
@@ -254,25 +252,6 @@
 		addSet:   "bar-v10-bar",
 	},
 	{
-		name:  "add a struct with literal",
-		input: `cc_foo {name: "foo"}`,
-		output: `cc_foo {
-    name: "foo",
-    structs: [
-        {
-            version: "1",
-            imports: [
-                "bar1",
-                "bar2",
-            ],
-        },
-    ],
-}
-`,
-		property:   "structs",
-		addLiteral: proptools.StringPtr(`{version: "1", imports: ["bar1", "bar2"]}`),
-	},
-	{
 		name: "set string",
 		input: `
 			cc_foo {
@@ -305,56 +284,6 @@
 		property:  "foo",
 		setString: proptools.StringPtr("bar"),
 	},
-	{
-		name: "remove existing property",
-		input: `
-			cc_foo {
-				name: "foo",
-				foo: "baz",
-			}
-		`,
-		output: `
-			cc_foo {
-				name: "foo",
-			}
-		`,
-		property:       "foo",
-		removeProperty: true,
-	}, {
-		name: "remove nested property",
-		input: `
-		cc_foo {
-			name: "foo",
-			foo: {
-				bar: "baz",
-			},
-		}
-	`,
-		output: `
-		cc_foo {
-			name: "foo",
-			foo: {},
-		}
-	`,
-		property:       "foo.bar",
-		removeProperty: true,
-	}, {
-		name: "remove non-existing property",
-		input: `
-			cc_foo {
-				name: "foo",
-				foo: "baz",
-			}
-		`,
-		output: `
-			cc_foo {
-				name: "foo",
-				foo: "baz",
-			}
-		`,
-		property:       "bar",
-		removeProperty: true,
-	},
 }
 
 func simplifyModuleDefinition(def string) string {
@@ -371,9 +300,7 @@
 			targetedProperty.Set(testCase.property)
 			addIdents.Set(testCase.addSet)
 			removeIdents.Set(testCase.removeSet)
-			removeProperty = &testCase.removeProperty
 			setString = testCase.setString
-			addLiteral = testCase.addLiteral
 
 			inAst, errs := parser.ParseAndEval("", strings.NewReader(testCase.input), parser.NewScope(nil))
 			if len(errs) > 0 {
diff --git a/context.go b/context.go
index 6496948..e891c23 100644
--- a/context.go
+++ b/context.go
@@ -34,7 +34,6 @@
 	"text/scanner"
 	"text/template"
 
-	"github.com/google/blueprint/metrics"
 	"github.com/google/blueprint/parser"
 	"github.com/google/blueprint/pathtools"
 	"github.com/google/blueprint/proptools"
@@ -72,9 +71,7 @@
 type Context struct {
 	context.Context
 
-	// Used for metrics-related event logging.
-	EventHandler *metrics.EventHandler
-
+	// set at instantiation
 	moduleFactories     map[string]ModuleFactory
 	nameInterface       NameInterface
 	moduleGroups        []*moduleGroup
@@ -83,6 +80,7 @@
 	preSingletonInfo    []*singletonInfo
 	singletonInfo       []*singletonInfo
 	mutatorInfo         []*mutatorInfo
+	earlyMutatorInfo    []*mutatorInfo
 	variantMutatorNames []string
 
 	depsModified uint32 // positive if a mutator modified the dependencies
@@ -104,7 +102,7 @@
 	globalRules     map[Rule]*ruleDef
 
 	// set during PrepareBuildActions
-	outDir             ninjaString // The builddir special Ninja variable
+	ninjaBuildDir      ninjaString // The builddir special Ninja variable
 	requiredNinjaMajor int         // For the ninja_required_version variable
 	requiredNinjaMinor int         // For the ninja_required_version variable
 	requiredNinjaMicro int         // For the ninja_required_version variable
@@ -382,17 +380,15 @@
 }
 
 func newContext() *Context {
-	eventHandler := metrics.EventHandler{}
 	return &Context{
 		Context:            context.Background(),
-		EventHandler:       &eventHandler,
 		moduleFactories:    make(map[string]ModuleFactory),
 		nameInterface:      NewSimpleNameInterface(),
 		moduleInfo:         make(map[Module]*moduleInfo),
 		globs:              make(map[globKey]pathtools.GlobResult),
 		fs:                 pathtools.OsFs,
 		finishedMutators:   make(map[*mutatorInfo]bool),
-		outDir:             nil,
+		ninjaBuildDir:      nil,
 		requiredNinjaMajor: 1,
 		requiredNinjaMinor: 7,
 		requiredNinjaMicro: 0,
@@ -490,7 +486,7 @@
 type SingletonFactory func() Singleton
 
 // RegisterSingletonType registers a singleton type that will be invoked to
-// generate build actions.  Each registered singleton type is instantiated
+// generate build actions.  Each registered singleton type is instantiated and
 // and invoked exactly once as part of the generate phase.  Each registered
 // singleton is invoked in registration order.
 //
@@ -629,6 +625,38 @@
 	return mutator
 }
 
+// RegisterEarlyMutator registers a mutator that will be invoked to split
+// Modules into multiple variant Modules before any dependencies have been
+// created.  Each registered mutator is invoked in registration order once
+// per Module (including each variant from previous early mutators).  Module
+// order is unpredictable.
+//
+// In order for dependencies to be satisifed in a later pass, all dependencies
+// of a module either must have an identical variant or must have no variations.
+//
+// The mutator type names given here must be unique to all bottom up or early
+// mutators in the Context.
+//
+// Deprecated, use a BottomUpMutator instead.  The only difference between
+// EarlyMutator and BottomUpMutator is that EarlyMutator runs before the
+// deprecated DynamicDependencies.
+func (c *Context) RegisterEarlyMutator(name string, mutator EarlyMutator) {
+	for _, m := range c.variantMutatorNames {
+		if m == name {
+			panic(fmt.Errorf("mutator name %s is already registered", name))
+		}
+	}
+
+	c.earlyMutatorInfo = append(c.earlyMutatorInfo, &mutatorInfo{
+		bottomUpMutator: func(mctx BottomUpMutatorContext) {
+			mutator(mctx)
+		},
+		name: name,
+	})
+
+	c.variantMutatorNames = append(c.variantMutatorNames, name)
+}
+
 // SetIgnoreUnknownModuleTypes sets the behavior of the context in the case
 // where it encounters an unknown module type while parsing Blueprints files. By
 // default, the context will report unknown module types as an error.  If this
@@ -658,7 +686,6 @@
 	if err != nil {
 		return nil, err
 	}
-	defer reader.Close()
 	bytes, err := ioutil.ReadAll(reader)
 	if err != nil {
 		return nil, err
@@ -981,7 +1008,7 @@
 		// no module list file specified; find every file named Blueprints
 		pathsToParse := []string{}
 		for candidate := range files {
-			if filepath.Base(candidate) == "Android.bp" {
+			if filepath.Base(candidate) == "Blueprints" {
 				pathsToParse = append(pathsToParse, candidate)
 			}
 		}
@@ -1102,10 +1129,15 @@
 		}
 	}
 
+	subBlueprintsName, _, err := getStringFromScope(scope, "subname")
 	if err != nil {
 		errs = append(errs, err)
 	}
 
+	if subBlueprintsName == "" {
+		subBlueprintsName = "Blueprints"
+	}
+
 	var blueprints []string
 
 	newBlueprints, newErrs := c.findBuildBlueprints(filepath.Dir(filename), build, buildPos)
@@ -1416,11 +1448,14 @@
 func newModule(factory ModuleFactory) *moduleInfo {
 	logicModule, properties := factory()
 
-	return &moduleInfo{
+	module := &moduleInfo{
 		logicModule: logicModule,
 		factory:     factory,
-		properties:  properties,
 	}
+
+	module.properties = properties
+
+	return module
 }
 
 func processModuleDef(moduleDef *parser.Module,
@@ -1510,8 +1545,6 @@
 // the modules depended upon are defined and that no circular dependencies
 // exist.
 func (c *Context) ResolveDependencies(config interface{}) (deps []string, errs []error) {
-	c.BeginEvent("resolve_deps")
-	defer c.EndEvent("resolve_deps")
 	return c.resolveDependencies(c.Context, config)
 }
 
@@ -1785,9 +1818,9 @@
 	return toInfo
 }
 
-// findBlueprintDescendants returns a map linking parent Blueprint files to child Blueprints files
-// For example, if paths = []string{"a/b/c/Android.bp", "a/Android.bp"},
-// then descendants = {"":[]string{"a/Android.bp"}, "a/Android.bp":[]string{"a/b/c/Android.bp"}}
+// findBlueprintDescendants returns a map linking parent Blueprints files to child Blueprints files
+// For example, if paths = []string{"a/b/c/Android.bp", "a/Blueprints"},
+// then descendants = {"":[]string{"a/Blueprints"}, "a/Blueprints":[]string{"a/b/c/Android.bp"}}
 func findBlueprintDescendants(paths []string) (descendants map[string][]string, err error) {
 	// make mapping from dir path to file path
 	filesByDir := make(map[string]string, len(paths))
@@ -2143,7 +2176,7 @@
 // additional fields based on the dependencies.  It builds a sorted list of modules
 // such that dependencies of a module always appear first, and populates reverse
 // dependency links and counts of total dependencies.  It also reports errors when
-// it encounters dependency cycles.  This should be called after resolveDependencies,
+// 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
@@ -2235,7 +2268,7 @@
 	return
 }
 
-type jsonVariationMap []Variation
+type jsonVariationMap map[string]string
 
 type jsonModuleName struct {
 	Name                 string
@@ -2248,26 +2281,15 @@
 	Tag string
 }
 
-type JsonModule struct {
+type jsonModule struct {
 	jsonModuleName
 	Deps      []jsonDep
 	Type      string
 	Blueprint string
-	Module    map[string]interface{}
 }
 
 func toJsonVariationMap(vm variationMap) jsonVariationMap {
-	m := make(jsonVariationMap, 0, len(vm))
-	for k, v := range vm {
-		m = append(m, Variation{k, v})
-	}
-	sort.Slice(m, func(i, j int) bool {
-		if m[i].Mutator != m[j].Mutator {
-			return m[i].Mutator < m[j].Mutator
-		}
-		return m[i].Variation < m[j].Variation
-	})
-	return m
+	return jsonVariationMap(vm)
 }
 
 func jsonModuleNameFromModuleInfo(m *moduleInfo) *jsonModuleName {
@@ -2278,94 +2300,30 @@
 	}
 }
 
-type JSONDataSupplier interface {
-	AddJSONData(d *map[string]interface{})
-}
-
-func jsonModuleFromModuleInfo(m *moduleInfo) *JsonModule {
-	result := &JsonModule{
+func jsonModuleFromModuleInfo(m *moduleInfo) *jsonModule {
+	return &jsonModule{
 		jsonModuleName: *jsonModuleNameFromModuleInfo(m),
 		Deps:           make([]jsonDep, 0),
 		Type:           m.typeName,
 		Blueprint:      m.relBlueprintsFile,
-		Module:         make(map[string]interface{}),
 	}
-	if j, ok := m.logicModule.(JSONDataSupplier); ok {
-		j.AddJSONData(&result.Module)
-	}
-	for _, p := range m.providers {
-		if j, ok := p.(JSONDataSupplier); ok {
-			j.AddJSONData(&result.Module)
-		}
-	}
-	return result
 }
 
-func jsonModuleWithActionsFromModuleInfo(m *moduleInfo) *JsonModule {
-	result := &JsonModule{
-		jsonModuleName: jsonModuleName{
-			Name: m.Name(),
-		},
-		Deps:      make([]jsonDep, 0),
-		Type:      m.typeName,
-		Blueprint: m.relBlueprintsFile,
-		Module:    make(map[string]interface{}),
-	}
-	var actions []map[string]interface{}
-	for _, bDef := range m.actionDefs.buildDefs {
-		actions = append(actions, map[string]interface{}{
-			"Inputs": append(
-				getNinjaStringsWithNilPkgNames(bDef.Inputs),
-				getNinjaStringsWithNilPkgNames(bDef.Implicits)...),
-			"Outputs": append(
-				getNinjaStringsWithNilPkgNames(bDef.Outputs),
-				getNinjaStringsWithNilPkgNames(bDef.ImplicitOutputs)...),
-		})
-	}
-	result.Module["Actions"] = actions
-	return result
-}
-
-// Gets a list of strings from the given list of ninjaStrings by invoking ninjaString.Value with
-// nil pkgNames on each of the input ninjaStrings.
-func getNinjaStringsWithNilPkgNames(nStrs []ninjaString) []string {
-	var strs []string
-	for _, nstr := range nStrs {
-		strs = append(strs, nstr.Value(nil))
-	}
-	return strs
-}
-
-// PrintJSONGraph prints info of modules in a JSON file.
-func (c *Context) PrintJSONGraphAndActions(wGraph io.Writer, wActions io.Writer) {
-	modulesToGraph := make([]*JsonModule, 0)
-	modulesToActions := make([]*JsonModule, 0)
+func (c *Context) PrintJSONGraph(w io.Writer) {
+	modules := make([]*jsonModule, 0)
 	for _, m := range c.modulesSorted {
 		jm := jsonModuleFromModuleInfo(m)
-		jmWithActions := jsonModuleWithActionsFromModuleInfo(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),
 			})
-			jmWithActions.Deps = append(jmWithActions.Deps, jsonDep{
-				jsonModuleName: jsonModuleName{
-					Name: d.module.Name(),
-				},
-			})
-
 		}
-		modulesToGraph = append(modulesToGraph, jm)
-		modulesToActions = append(modulesToActions, jmWithActions)
-	}
-	writeJson(wGraph, modulesToGraph)
-	writeJson(wActions, modulesToActions)
-}
 
-func writeJson(w io.Writer, modules []*JsonModule) {
-	e := json.NewEncoder(w)
-	e.SetIndent("", "\t")
-	e.Encode(modules)
+		modules = append(modules, jm)
+	}
+
+	json.NewEncoder(w).Encode(modules)
 }
 
 // PrepareBuildActions generates an internal representation of all the build
@@ -2388,8 +2346,6 @@
 // methods.
 
 func (c *Context) PrepareBuildActions(config interface{}) (deps []string, errs []error) {
-	c.BeginEvent("prepare_build_actions")
-	defer c.EndEvent("prepare_build_actions")
 	pprof.Do(c.Context, pprof.Labels("blueprint", "PrepareBuildActions"), func(ctx context.Context) {
 		c.buildActionsReady = false
 
@@ -2417,8 +2373,8 @@
 		deps = append(deps, depsModules...)
 		deps = append(deps, depsSingletons...)
 
-		if c.outDir != nil {
-			err := c.liveGlobals.addNinjaStringDeps(c.outDir)
+		if c.ninjaBuildDir != nil {
+			err := c.liveGlobals.addNinjaStringDeps(c.ninjaBuildDir)
 			if err != nil {
 				errs = []error{err}
 				return
@@ -2450,8 +2406,13 @@
 }
 
 func (c *Context) runMutators(ctx context.Context, config interface{}) (deps []string, errs []error) {
+	var mutators []*mutatorInfo
+
 	pprof.Do(ctx, pprof.Labels("blueprint", "runMutators"), func(ctx context.Context) {
-		for _, mutator := range c.mutatorInfo {
+		mutators = append(mutators, c.earlyMutatorInfo...)
+		mutators = append(mutators, c.mutatorInfo...)
+
+		for _, mutator := range mutators {
 			pprof.Do(ctx, pprof.Labels("mutator", mutator.name), func(context.Context) {
 				var newDeps []string
 				if mutator.topDownMutator != nil {
@@ -2839,9 +2800,8 @@
 		func(module *moduleInfo, pause chan<- pauseSpec) bool {
 			uniqueName := c.nameInterface.UniqueName(newNamespaceContext(module), module.group.name)
 			sanitizedName := toNinjaName(uniqueName)
-			sanitizedVariant := toNinjaName(module.variant.name)
 
-			prefix := moduleNamespacePrefix(sanitizedName + "_" + sanitizedVariant)
+			prefix := moduleNamespacePrefix(sanitizedName + "_" + module.variant.name)
 
 			// 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
@@ -3226,9 +3186,9 @@
 	}
 }
 
-func (c *Context) setOutDir(value ninjaString) {
-	if c.outDir == nil {
-		c.outDir = value
+func (c *Context) setNinjaBuildDir(value ninjaString) {
+	if c.ninjaBuildDir == nil {
+		c.ninjaBuildDir = value
 	}
 }
 
@@ -3420,9 +3380,9 @@
 	return targets, nil
 }
 
-func (c *Context) OutDir() (string, error) {
-	if c.outDir != nil {
-		return c.outDir.Eval(c.globalVariables)
+func (c *Context) NinjaBuildDir() (string, error) {
+	if c.ninjaBuildDir != nil {
+		return c.ninjaBuildDir.Eval(c.globalVariables)
 	} else {
 		return "", nil
 	}
@@ -3772,8 +3732,8 @@
 }
 
 func (c *Context) writeBuildDir(nw *ninjaWriter) error {
-	if c.outDir != nil {
-		err := nw.Assign("builddir", c.outDir.Value(c.pkgNames))
+	if c.ninjaBuildDir != nil {
+		err := nw.Assign("builddir", c.ninjaBuildDir.Value(c.pkgNames))
 		if err != nil {
 			return err
 		}
@@ -4087,14 +4047,6 @@
 	return nil
 }
 
-func (c *Context) BeginEvent(name string) {
-	c.EventHandler.Begin(name)
-}
-
-func (c *Context) EndEvent(name string) {
-	c.EventHandler.End(name)
-}
-
 func (c *Context) writeLocalBuildActions(nw *ninjaWriter,
 	defs *localBuildActions) error {
 
diff --git a/context_test.go b/context_test.go
index 6308ba9..d91b89d 100644
--- a/context_test.go
+++ b/context_test.go
@@ -181,7 +181,7 @@
 func TestWalkDeps(t *testing.T) {
 	ctx := NewContext()
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			foo_module {
 			    name: "A",
 			    deps: ["B", "C"],
@@ -220,7 +220,7 @@
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
 	ctx.RegisterBottomUpMutator("deps", depsMutator)
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -257,7 +257,7 @@
 func TestWalkDepsDuplicates(t *testing.T) {
 	ctx := NewContext()
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			foo_module {
 			    name: "A",
 			    deps: ["B", "C"],
@@ -301,7 +301,7 @@
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
 	ctx.RegisterBottomUpMutator("deps", depsMutator)
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -337,7 +337,7 @@
 func TestWalkDepsDuplicates_IgnoreFirstPath(t *testing.T) {
 	ctx := NewContext()
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			foo_module {
 			    name: "A",
 			    deps: ["B"],
@@ -368,7 +368,7 @@
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
 	ctx.RegisterBottomUpMutator("deps", depsMutator)
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -401,7 +401,7 @@
 func TestCreateModule(t *testing.T) {
 	ctx := newContext()
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			foo_module {
 			    name: "A",
 			    deps: ["B", "C"],
@@ -414,7 +414,7 @@
 
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -492,17 +492,17 @@
 	// setup mock context
 	ctx := newContext()
 	mockFiles := map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			sample_module {
 			    name: "a",
 			}
 		`),
-		"dir1/Android.bp": []byte(`
+		"dir1/Blueprints": []byte(`
 			sample_module {
 			    name: "b",
 			}
 		`),
-		"dir1/dir2/Android.bp": []byte(`
+		"dir1/dir2/Blueprints": []byte(`
 			sample_module {
 			    name: "c",
 			}
@@ -513,7 +513,7 @@
 	// prepare to monitor the visit order
 	visitOrder := []string{}
 	visitLock := sync.Mutex{}
-	correctVisitOrder := []string{"Android.bp", "dir1/Android.bp", "dir1/dir2/Android.bp"}
+	correctVisitOrder := []string{"Blueprints", "dir1/Blueprints", "dir1/dir2/Blueprints"}
 
 	// sleep longer when processing the earlier files
 	chooseSleepDuration := func(fileName string) (duration time.Duration) {
@@ -533,7 +533,7 @@
 		defer visitLock.Unlock()
 		visitOrder = append(visitOrder, file.Name)
 	}
-	keys := []string{"Android.bp", "dir1/Android.bp", "dir1/dir2/Android.bp"}
+	keys := []string{"Blueprints", "dir1/Blueprints", "dir1/dir2/Blueprints"}
 
 	// visit the blueprints files
 	ctx.WalkBlueprintsFiles(".", keys, visitor)
@@ -549,16 +549,16 @@
 	// setup mock context
 	ctx := newContext()
 	mockFiles := map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			sample_module {
 			    name: "a" "b",
 			}
 		`),
-		"dir1/Android.bp": []byte(`
+		"dir1/Blueprints": []byte(`
 			sample_module {
 			    name: "b",
 		`),
-		"dir1/dir2/Android.bp": []byte(`
+		"dir1/dir2/Blueprints": []byte(`
 			sample_module {
 			    name: "c",
 			}
@@ -566,14 +566,14 @@
 	}
 	ctx.MockFileSystem(mockFiles)
 
-	keys := []string{"Android.bp", "dir1/Android.bp", "dir1/dir2/Android.bp"}
+	keys := []string{"Blueprints", "dir1/Blueprints", "dir1/dir2/Blueprints"}
 
 	// visit the blueprints files
 	_, errs := ctx.WalkBlueprintsFiles(".", keys, func(file *parser.File) {})
 
 	expectedErrs := []error{
-		errors.New(`Android.bp:3:18: expected "}", found String`),
-		errors.New(`dir1/Android.bp:4:3: expected "}", found EOF`),
+		errors.New(`Blueprints:3:18: expected "}", found String`),
+		errors.New(`dir1/Blueprints:4:3: expected "}", found EOF`),
 	}
 	if fmt.Sprintf("%s", expectedErrs) != fmt.Sprintf("%s", errs) {
 		t.Errorf("Incorrect errors; expected:\n%s\ngot:\n%s", expectedErrs, errs)
@@ -584,7 +584,7 @@
 func TestParseFailsForModuleWithoutName(t *testing.T) {
 	ctx := NewContext()
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			foo_module {
 			    name: "A",
 			}
@@ -597,10 +597,10 @@
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
 
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 
 	expectedErrs := []error{
-		errors.New(`Android.bp:6:4: property 'name' is missing from a module`),
+		errors.New(`Blueprints:6:4: property 'name' is missing from a module`),
 	}
 	if fmt.Sprintf("%s", expectedErrs) != fmt.Sprintf("%s", errs) {
 		t.Errorf("Incorrect errors; expected:\n%s\ngot:\n%s", expectedErrs, errs)
diff --git a/glob_test.go b/glob_test.go
index 15fd395..3fff5a8 100644
--- a/glob_test.go
+++ b/glob_test.go
@@ -19,7 +19,7 @@
 func TestGlobCache(t *testing.T) {
 	ctx := NewContext()
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": nil,
+		"Blueprints": nil,
 		"a/a":        nil,
 		"a/b":        nil,
 	})
diff --git a/gotestmain/gotestmain.go b/gotestmain/gotestmain.go
index ea381ca..8af1818 100644
--- a/gotestmain/gotestmain.go
+++ b/gotestmain/gotestmain.go
@@ -38,11 +38,11 @@
 )
 
 type data struct {
-	Package               string
-	Tests                 []string
-	Examples              []*doc.Example
-	HasMain               bool
-	MainStartTakesFuzzers bool
+	Package                 string
+	Tests                   []string
+	Examples                []*doc.Example
+	HasMain                 bool
+	MainStartTakesInterface bool
 }
 
 func findTests(srcs []string) (tests []string, examples []*doc.Example, hasMain bool) {
@@ -68,9 +68,10 @@
 	return
 }
 
-// Returns true for go1.18+, where testing.MainStart takes an extra slice of fuzzers.
-func mainStartTakesFuzzers() bool {
-	return reflect.TypeOf(testing.MainStart).NumIn() > 4
+// Returns true for go1.8+, where testing.MainStart takes an interface instead of a function
+// as its first argument.
+func mainStartTakesInterface() bool {
+	return reflect.TypeOf(testing.MainStart).In(0).Kind() == reflect.Interface
 }
 
 func main() {
@@ -87,11 +88,11 @@
 	tests, examples, hasMain := findTests(flag.Args())
 
 	d := data{
-		Package:               *pkg,
-		Tests:                 tests,
-		Examples:              examples,
-		HasMain:               hasMain,
-		MainStartTakesFuzzers: mainStartTakesFuzzers(),
+		Package:                 *pkg,
+		Tests:                   tests,
+		Examples:                examples,
+		HasMain:                 hasMain,
+		MainStartTakesInterface: mainStartTakesInterface(),
 	}
 
 	err := testMainTmpl.Execute(buf, d)
@@ -113,10 +114,8 @@
 {{if not .HasMain}}
 	"os"
 {{end}}
-	"reflect"
 	"regexp"
 	"testing"
-	"time"
 
 	pkg "{{.Package}}"
 )
@@ -182,48 +181,11 @@
 	panic("shouldn't get here")
 }
 
-func (matchString) SetPanicOnExit0(bool) {
-	panic("shouldn't get here")
-}
-
-func (matchString) CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error {
-	panic("shouldn't get here")
-}
-
-func (matchString) RunFuzzWorker(func(corpusEntry) error) error {
-	panic("shouldn't get here")
-}
-
-func (matchString) ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) {
-	panic("shouldn't get here")
-}
-
-func (matchString) CheckCorpus([]interface{}, []reflect.Type) error {
-	panic("shouldn't get here")
-}
-
-func (matchString) ResetCoverage() {
-	panic("shouldn't get here")
-}
-
-func (matchString) SnapshotCoverage() {
-	panic("shouldn't get here")
-}
-
-type corpusEntry = struct {
-	Parent     string
-	Path       string
-	Data       []byte
-	Values     []interface{}
-	Generation int
-	IsSeed     bool
-}
-
 func main() {
-{{if .MainStartTakesFuzzers }}
-	m := testing.MainStart(matchString{}, t, nil, nil, e)
-{{else}}
+{{if .MainStartTakesInterface}}
 	m := testing.MainStart(matchString{}, t, nil, e)
+{{else}}
+	m := testing.MainStart(MatchString, t, nil, e)
 {{end}}
 {{if .HasMain}}
 	pkg.TestMain(m)
diff --git a/metrics/Android.bp b/metrics/Android.bp
deleted file mode 100644
index 3668668..0000000
--- a/metrics/Android.bp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Copyright (C) 2022 The Android Open Source Project
-//
-// 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 {
-    default_applicable_licenses: ["build_blueprint_license"],
-}
-
-bootstrap_go_package {
-    name: "blueprint-metrics",
-    pkgPath: "github.com/google/blueprint/metrics",
-    srcs: [
-        "event_handler.go",
-    ],
-}
diff --git a/metrics/event_handler.go b/metrics/event_handler.go
deleted file mode 100644
index c19d039..0000000
--- a/metrics/event_handler.go
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2022 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 metrics
-
-import (
-	"fmt"
-	"strings"
-	"time"
-)
-
-// EventHandler tracks nested events and their start/stop times in a single
-// thread.
-type EventHandler struct {
-	completedEvents []Event
-
-	// These fields handle event scoping. When starting a new event, a new entry
-	// is pushed onto these fields. When ending an event, these fields are popped.
-	scopeIds        []string
-	scopeStartTimes []time.Time
-}
-
-// _now wraps the time.Now() function. _now is declared for unit testing purpose.
-var _now = func() time.Time {
-	return time.Now()
-}
-
-// Event holds the performance metrics data of a single build event.
-type Event struct {
-	// A unique human-readable identifier / "name" for the build event. Event
-	// names use period-delimited scoping. For example, if an event alpha starts,
-	// then an event bravo starts, then an event charlie starts and ends, the
-	// unique identifier for charlie will be 'alpha.bravo.charlie'.
-	Id string
-
-	Start time.Time
-	end   time.Time
-}
-
-// RuntimeNanoseconds returns the number of nanoseconds between the start
-// and end times of the event.
-func (e Event) RuntimeNanoseconds() uint64 {
-	return uint64(e.end.Sub(e.Start).Nanoseconds())
-}
-
-// Begin logs the start of an event. This must be followed by a corresponding
-// call to End (though other events may begin and end before this event ends).
-// Events within the same scope must have unique names.
-func (h *EventHandler) Begin(name string) {
-	h.scopeIds = append(h.scopeIds, name)
-	h.scopeStartTimes = append(h.scopeStartTimes, _now())
-}
-
-// End logs the end of an event. All events nested within this event must have
-// themselves been marked completed.
-func (h *EventHandler) End(name string) {
-	if len(h.scopeIds) == 0 || name != h.scopeIds[len(h.scopeIds)-1] {
-		panic(fmt.Errorf("Unexpected scope end '%s'. Current scope: (%s)",
-			name, h.scopeIds))
-	}
-	event := Event{
-		// The event Id is formed from the period-delimited scope names of all
-		// active events (e.g. `alpha.beta.charlie`). See Event.Id documentation
-		// for more detail.
-		Id:    strings.Join(h.scopeIds, "."),
-		Start: h.scopeStartTimes[len(h.scopeStartTimes)-1],
-		end:   _now(),
-	}
-	h.completedEvents = append(h.completedEvents, event)
-	h.scopeIds = h.scopeIds[:len(h.scopeIds)-1]
-	h.scopeStartTimes = h.scopeStartTimes[:len(h.scopeStartTimes)-1]
-}
-
-// CompletedEvents returns all events which have been completed, after
-// validation.
-// It is an error to call this method if there are still ongoing events, or
-// if two events were completed with the same scope and name.
-func (h *EventHandler) CompletedEvents() []Event {
-	if len(h.scopeIds) > 0 {
-		panic(fmt.Errorf(
-			"Retrieving events before all events have been closed. Current scope: (%s)",
-			h.scopeIds))
-	}
-	// Validate no two events have the same full id.
-	ids := map[string]bool{}
-	for _, event := range h.completedEvents {
-		if _, containsId := ids[event.Id]; containsId {
-			panic(fmt.Errorf("Duplicate event registered: %s", event.Id))
-		}
-		ids[event.Id] = true
-	}
-	return h.completedEvents
-}
diff --git a/module_ctx.go b/module_ctx.go
index 53ee405..a074e37 100644
--- a/module_ctx.go
+++ b/module_ctx.go
@@ -39,7 +39,7 @@
 // modified as necessary by the Mutator.
 //
 // The Module implementation can access the build configuration as well as any
-// modules on which it depends (as defined by the "deps" property
+// modules on which on which it depends (as defined by the "deps" property
 // specified in the Blueprints file, dynamically added by implementing the
 // (deprecated) DynamicDependerModule interface, or dynamically added by a
 // BottomUpMutator) using the ModuleContext passed to GenerateBuildActions.
@@ -132,14 +132,14 @@
 	// the module was created, but may have been modified by calls to BaseMutatorContext.Rename.
 	ModuleName() string
 
-	// ModuleDir returns the path to the directory that contains the definition of the module.
+	// ModuleDir returns the path to the directory that contains the defintion of the module.
 	ModuleDir() string
 
 	// ModuleType returns the name of the module type that was used to create the module, as specified in
-	// Context.RegisterModuleType().
+	// RegisterModuleType.
 	ModuleType() string
 
-	// BlueprintsFile returns the name of the blueprint file that contains the definition of this
+	// BlueprintFile returns the name of the blueprint file that contains the definition of this
 	// module.
 	BlueprintsFile() string
 
@@ -227,7 +227,7 @@
 	// invalidated by future mutators.
 	VisitDepsDepthFirst(visit func(Module))
 
-	// VisitDepsDepthFirstIf calls pred for each transitive dependency, and if pred returns true calls visit, traversing
+	// VisitDepsDepthFirst calls pred for each transitive dependency, and if pred returns true calls visit, traversing
 	// the dependency tree in depth first order.  visit will only be called once for any given module, even if there are
 	// multiple paths through the dependency tree to the module or multiple direct dependencies with different tags.
 	// OtherModuleDependencyTag will return the tag for the first path found to the module.  The return value of pred
@@ -294,14 +294,6 @@
 	// passed to Context.SetNameInterface, or SimpleNameInterface if it was not called.
 	OtherModuleExists(name string) bool
 
-	// ModuleFromName returns (module, true) if a module exists by the given name and same context namespace,
-	// or (nil, false) if it does not exist. It panics if there is either more than one
-	// module of the given name, or if the given name refers to an alias instead of a module.
-	// There are no guarantees about which variant of the module will be returned.
-	// Prefer retrieving the module using GetDirectDep or a visit function, when possible, as
-	// this will guarantee the appropriate module-variant dependency is returned.
-	ModuleFromName(name string) (Module, 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
@@ -540,23 +532,6 @@
 	return nil
 }
 
-func (m *baseModuleContext) ModuleFromName(name string) (Module, bool) {
-	moduleGroup, exists := m.context.nameInterface.ModuleFromName(name, m.module.namespace())
-	if exists {
-		if len(moduleGroup.modules) != 1 {
-			panic(fmt.Errorf("Expected exactly one module named %q, but got %d", name, len(moduleGroup.modules)))
-		}
-		moduleInfo := moduleGroup.modules[0].module()
-		if moduleInfo != nil {
-			return moduleInfo.logicModule, true
-		} else {
-			panic(fmt.Errorf(`Expected actual module named %q, but group did not contain a module.
-    There may instead be an alias by that name.`, name))
-		}
-	}
-	return nil, exists
-}
-
 func (m *baseModuleContext) OtherModuleExists(name string) bool {
 	_, exists := m.context.nameInterface.ModuleFromName(name, m.module.namespace())
 	return exists
@@ -831,6 +806,32 @@
 	MutatorName() string
 }
 
+type EarlyMutatorContext interface {
+	BaseMutatorContext
+
+	// CreateVariations splits  a module into mulitple variants, one for each name in the variationNames
+	// parameter.  It returns a list of new modules in the same order as the variationNames
+	// list.
+	//
+	// If any of the dependencies of the module being operated on were already split
+	// by calling CreateVariations with the same name, the dependency will automatically
+	// be updated to point the matching variant.
+	//
+	// If a module is split, and then a module depending on the first module is not split
+	// when the Mutator is later called on it, the dependency of the depending module will
+	// automatically be updated to point to the first variant.
+	CreateVariations(...string) []Module
+
+	// CreateLocationVariations splits a module into mulitple variants, one for each name in the variantNames
+	// parameter.  It returns a list of new modules in the same order as the variantNames
+	// list.
+	//
+	// Local variations do not affect automatic dependency resolution - dependencies added
+	// to the split module via deps or DynamicDependerModule must exactly match a variant
+	// that contains all the non-local variations.
+	CreateLocalVariations(...string) []Module
+}
+
 type TopDownMutatorContext interface {
 	BaseMutatorContext
 
@@ -859,7 +860,7 @@
 	// module's dependency list.
 	AddReverseDependency(module Module, tag DependencyTag, name string)
 
-	// CreateVariations splits  a module into multiple variants, one for each name in the variationNames
+	// CreateVariations splits  a module into mulitple variants, one for each name in the variationNames
 	// parameter.  It returns a list of new modules in the same order as the variationNames
 	// list.
 	//
@@ -870,16 +871,16 @@
 	// If a module is split, and then a module depending on the first module is not split
 	// when the Mutator is later called on it, the dependency of the depending module will
 	// automatically be updated to point to the first variant.
-	CreateVariations(variationNames ...string) []Module
+	CreateVariations(...string) []Module
 
-	// CreateLocalVariations splits a module into multiple variants, one for each name in the variationNames
+	// CreateLocationVariations splits a module into mulitple variants, one for each name in the variantNames
 	// parameter.  It returns a list of new modules in the same order as the variantNames
 	// list.
 	//
 	// Local variations do not affect automatic dependency resolution - dependencies added
 	// to the split module via deps or DynamicDependerModule must exactly match a variant
 	// that contains all the non-local variations.
-	CreateLocalVariations(variationNames ...string) []Module
+	CreateLocalVariations(...string) []Module
 
 	// SetDependencyVariation sets all dangling dependencies on the current module to point to the variation
 	// with given name. This function ignores the default variation set by SetDefaultDependencyVariation.
@@ -916,7 +917,7 @@
 	AddFarVariationDependencies([]Variation, DependencyTag, ...string) []Module
 
 	// AddInterVariantDependency adds a dependency between two variants of the same module.  Variants are always
-	// ordered in the same order as they were listed in CreateVariations, and AddInterVariantDependency does not change
+	// ordered in the same orderas they were listed in CreateVariations, and AddInterVariantDependency does not change
 	// that ordering, but it associates a DependencyTag with the dependency and makes it visible to VisitDirectDeps,
 	// WalkDeps, etc.
 	AddInterVariantDependency(tag DependencyTag, from, to Module)
@@ -926,7 +927,7 @@
 	// after the mutator pass is finished.
 	ReplaceDependencies(string)
 
-	// ReplaceDependenciesIf replaces all dependencies on the identical variant of the module with the
+	// 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.
 	//
@@ -969,6 +970,7 @@
 // if a second Mutator chooses to split the module a second time.
 type TopDownMutator func(mctx TopDownMutatorContext)
 type BottomUpMutator func(mctx BottomUpMutatorContext)
+type EarlyMutator func(mctx EarlyMutatorContext)
 
 // DependencyTag is an interface to an arbitrary object that embeds BaseDependencyTag.  It can be
 // used to transfer information on a dependency between the mutator that called AddDependency
@@ -1008,8 +1010,13 @@
 	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 {
-	var ret []Module
+	ret := []Module{}
 	modules, errs := mctx.context.createVariations(mctx.module, mctx.name, mctx.defaultVariation, variationNames, local)
 	if len(errs) > 0 {
 		mctx.errs = append(mctx.errs, errs...)
@@ -1261,21 +1268,20 @@
 
 	// CreateModule creates a new module by calling the factory method for the specified moduleType, and applies
 	// the specified property structs to it as if the properties were set in a blueprint file.
-	CreateModule(ModuleFactory, string, ...interface{}) Module
+	CreateModule(ModuleFactory, ...interface{}) Module
 
 	// RegisterScopedModuleType creates a new module type that is scoped to the current Blueprints
 	// file.
 	RegisterScopedModuleType(name string, factory ModuleFactory)
 }
 
-func (l *loadHookContext) CreateModule(factory ModuleFactory, typeName string, props ...interface{}) Module {
+func (l *loadHookContext) CreateModule(factory ModuleFactory, props ...interface{}) Module {
 	module := newModule(factory)
 
 	module.relBlueprintsFile = l.module.relBlueprintsFile
 	module.pos = l.module.pos
 	module.propertyPos = l.module.propertyPos
 	module.createdBy = l.module
-	module.typeName = typeName
 
 	for _, p := range props {
 		err := proptools.AppendMatchingProperties(module.properties, p, nil)
@@ -1299,7 +1305,7 @@
 	}
 
 	if *l.scopedModuleFactories == nil {
-		*l.scopedModuleFactories = make(map[string]ModuleFactory)
+		(*l.scopedModuleFactories) = make(map[string]ModuleFactory)
 	}
 
 	(*l.scopedModuleFactories)[name] = factory
@@ -1337,16 +1343,16 @@
 
 	if v, exists := pendingHooks.Load(module.logicModule); exists {
 		hooks := v.(*[]LoadHook)
+		mctx := &loadHookContext{
+			baseModuleContext: baseModuleContext{
+				context: ctx,
+				config:  config,
+				module:  module,
+			},
+			scopedModuleFactories: scopedModuleFactories,
+		}
 
 		for _, hook := range *hooks {
-			mctx := &loadHookContext{
-				baseModuleContext: baseModuleContext{
-					context: ctx,
-					config:  config,
-					module:  module,
-				},
-				scopedModuleFactories: scopedModuleFactories,
-			}
 			hook(mctx)
 			newModules = append(newModules, mctx.newModules...)
 			deps = append(deps, mctx.ninjaFileDeps...)
diff --git a/module_ctx_test.go b/module_ctx_test.go
index af23be7..d57982e 100644
--- a/module_ctx_test.go
+++ b/module_ctx_test.go
@@ -91,12 +91,12 @@
 		`
 
 		mockFS := map[string][]byte{
-			"Android.bp": []byte(bp),
+			"Blueprints": []byte(bp),
 		}
 
 		ctx.MockFileSystem(mockFS)
 
-		_, errs := ctx.ParseFileList(".", []string{"Android.bp"}, nil)
+		_, errs := ctx.ParseFileList(".", []string{"Blueprints"}, nil)
 		if len(errs) > 0 {
 			t.Errorf("unexpected parse errors:")
 			for _, err := range errs {
@@ -218,12 +218,12 @@
 		`
 
 		mockFS := map[string][]byte{
-			"Android.bp": []byte(bp),
+			"Blueprints": []byte(bp),
 		}
 
 		ctx.MockFileSystem(mockFS)
 
-		_, errs := ctx.ParseFileList(".", []string{"Android.bp"}, nil)
+		_, errs := ctx.ParseFileList(".", []string{"Blueprints"}, nil)
 		if len(errs) > 0 {
 			t.Errorf("unexpected parse errors:")
 			for _, err := range errs {
@@ -339,12 +339,12 @@
 		`
 
 		mockFS := map[string][]byte{
-			"Android.bp": []byte(bp),
+			"Blueprints": []byte(bp),
 		}
 
 		ctx.MockFileSystem(mockFS)
 
-		_, errs := ctx.ParseFileList(".", []string{"Android.bp"}, nil)
+		_, errs := ctx.ParseFileList(".", []string{"Blueprints"}, nil)
 		if len(errs) > 0 {
 			t.Errorf("unexpected parse errors:")
 			for _, err := range errs {
@@ -531,103 +531,3 @@
 		)
 	})
 }
-
-type addNinjaDepsTestModule struct {
-	SimpleName
-}
-
-func addNinjaDepsTestModuleFactory() (Module, []interface{}) {
-	module := &addNinjaDepsTestModule{}
-	AddLoadHook(module, func(ctx LoadHookContext) {
-		ctx.AddNinjaFileDeps("LoadHookContext")
-	})
-	return module, []interface{}{&module.SimpleName.Properties}
-}
-
-func (m *addNinjaDepsTestModule) GenerateBuildActions(ctx ModuleContext) {
-	ctx.AddNinjaFileDeps("GenerateBuildActions")
-}
-
-func addNinjaDepsTestBottomUpMutator(ctx BottomUpMutatorContext) {
-	ctx.AddNinjaFileDeps("BottomUpMutator")
-}
-
-func addNinjaDepsTestTopDownMutator(ctx TopDownMutatorContext) {
-	ctx.AddNinjaFileDeps("TopDownMutator")
-}
-
-type addNinjaDepsTestPreSingleton struct{}
-
-func addNinjaDepsTestPreSingletonFactory() Singleton {
-	return &addNinjaDepsTestPreSingleton{}
-}
-
-func (s *addNinjaDepsTestPreSingleton) GenerateBuildActions(ctx SingletonContext) {
-	ctx.AddNinjaFileDeps("PreSingleton")
-}
-
-type addNinjaDepsTestSingleton struct{}
-
-func addNinjaDepsTestSingletonFactory() Singleton {
-	return &addNinjaDepsTestSingleton{}
-}
-
-func (s *addNinjaDepsTestSingleton) GenerateBuildActions(ctx SingletonContext) {
-	ctx.AddNinjaFileDeps("Singleton")
-}
-
-func TestAddNinjaFileDeps(t *testing.T) {
-	ctx := NewContext()
-	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
-			test {
-			    name: "test",
-			}
-		`),
-	})
-
-	ctx.RegisterModuleType("test", addNinjaDepsTestModuleFactory)
-	ctx.RegisterBottomUpMutator("testBottomUpMutator", addNinjaDepsTestBottomUpMutator)
-	ctx.RegisterTopDownMutator("testTopDownMutator", addNinjaDepsTestTopDownMutator)
-	ctx.RegisterPreSingletonType("testPreSingleton", addNinjaDepsTestPreSingletonFactory)
-	ctx.RegisterSingletonType("testSingleton", addNinjaDepsTestSingletonFactory)
-	parseDeps, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
-	if len(errs) > 0 {
-		t.Errorf("unexpected parse errors:")
-		for _, err := range errs {
-			t.Errorf("  %s", err)
-		}
-		t.FailNow()
-	}
-
-	resolveDeps, errs := ctx.ResolveDependencies(nil)
-	if len(errs) > 0 {
-		t.Errorf("unexpected dep errors:")
-		for _, err := range errs {
-			t.Errorf("  %s", err)
-		}
-		t.FailNow()
-	}
-
-	prepareDeps, errs := ctx.PrepareBuildActions(nil)
-	if len(errs) > 0 {
-		t.Errorf("unexpected prepare errors:")
-		for _, err := range errs {
-			t.Errorf("  %s", err)
-		}
-		t.FailNow()
-	}
-
-	if g, w := parseDeps, []string{"Android.bp", "LoadHookContext"}; !reflect.DeepEqual(g, w) {
-		t.Errorf("ParseBlueprintsFiles: wanted deps %q, got %q", w, g)
-	}
-
-	if g, w := resolveDeps, []string{"PreSingleton", "BottomUpMutator", "TopDownMutator"}; !reflect.DeepEqual(g, w) {
-		t.Errorf("ResolveDependencies: wanted deps %q, got %q", w, g)
-	}
-
-	if g, w := prepareDeps, []string{"GenerateBuildActions", "Singleton"}; !reflect.DeepEqual(g, w) {
-		t.Errorf("PrepareBuildActions: wanted deps %q, got %q", w, g)
-	}
-
-}
diff --git a/package_ctx.go b/package_ctx.go
index 1eafdb9..af78772 100644
--- a/package_ctx.go
+++ b/package_ctx.go
@@ -81,7 +81,7 @@
 	ninjaFileDeps []string
 }
 
-var _ PackageContext = (*packageContext)(nil)
+var _ PackageContext = &packageContext{}
 
 func (p *packageContext) getScope() *basicScope {
 	return p.scope
diff --git a/parser/ast.go b/parser/ast.go
index cb311ee..fb7e516 100644
--- a/parser/ast.go
+++ b/parser/ast.go
@@ -35,7 +35,7 @@
 }
 
 // An Assignment is a variable assignment at the top level of a Blueprints file, scoped to the
-// file and subdirs.
+// file and and subdirs.
 type Assignment struct {
 	Name       string
 	NamePos    scanner.Position
@@ -107,29 +107,6 @@
 func (p *Property) Pos() scanner.Position { return p.NamePos }
 func (p *Property) End() scanner.Position { return p.Value.End() }
 
-// A MapItem is a key: value pair within a Map, corresponding to map type, rather than a struct.
-type MapItem struct {
-	ColonPos scanner.Position
-	Key      *String
-	Value    Expression
-}
-
-func (m *MapItem) Copy() *MapItem {
-	ret := MapItem{
-		ColonPos: m.ColonPos,
-		Key:      m.Key.Copy().(*String),
-		Value:    m.Value.Copy(),
-	}
-	return &ret
-}
-
-func (m *MapItem) String() string {
-	return fmt.Sprintf("%s@%s: %s", m.Key, m.ColonPos, m.Value)
-}
-
-func (m *MapItem) Pos() scanner.Position { return m.Key.Pos() }
-func (m *MapItem) End() scanner.Position { return m.Value.End() }
-
 // An Expression is a Value in a Property or Assignment.  It can be a literal (String or Bool), a
 // Map, a List, an Operator that combines two expressions of the same type, or a Variable that
 // references and Assignment.
@@ -267,7 +244,6 @@
 	LBracePos  scanner.Position
 	RBracePos  scanner.Position
 	Properties []*Property
-	MapItems   []*MapItem
 }
 
 func (x *Map) Pos() scanner.Position { return x.LBracePos }
@@ -279,36 +255,20 @@
 	for i := range x.Properties {
 		ret.Properties[i] = x.Properties[i].Copy()
 	}
-	ret.MapItems = make([]*MapItem, len(x.MapItems))
-	for i := range x.MapItems {
-		ret.MapItems[i] = x.MapItems[i].Copy()
-	}
 	return &ret
 }
 
 func (x *Map) Eval() Expression {
-	if len(x.Properties) > 0 && len(x.MapItems) > 0 {
-		panic("Cannot support both Properties and MapItems")
-	}
 	return x
 }
 
 func (x *Map) String() string {
-	var s string
-	if len(x.MapItems) > 0 {
-		mapStrings := make([]string, len(x.MapItems))
-		for i, mapItem := range x.MapItems {
-			mapStrings[i] = mapItem.String()
-		}
-		s = strings.Join(mapStrings, ", ")
-	} else {
-		propertyStrings := make([]string, len(x.Properties))
-		for i, property := range x.Properties {
-			propertyStrings[i] = property.String()
-		}
-		s = strings.Join(propertyStrings, ", ")
+	propertyStrings := make([]string, len(x.Properties))
+	for i, property := range x.Properties {
+		propertyStrings[i] = property.String()
 	}
-	return fmt.Sprintf("@%s-%s{%s}", x.LBracePos, x.RBracePos, s)
+	return fmt.Sprintf("@%s-%s{%s}", x.LBracePos, x.RBracePos,
+		strings.Join(propertyStrings, ", "))
 }
 
 func (x *Map) Type() Type { return MapType }
@@ -329,7 +289,7 @@
 	return nil, false, -1
 }
 
-// RemoveProperty removes the property with the given name, if it exists.
+// GetProperty removes the property with the given name, if it exists.
 func (x *Map) RemoveProperty(propertyName string) (removed bool) {
 	_, found, index := x.getPropertyImpl(propertyName)
 	if found {
diff --git a/parser/parser.go b/parser/parser.go
index bb8817e..9b6aa18 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -98,14 +98,6 @@
 	return parse(p)
 }
 
-func ParseExpression(r io.Reader) (value Expression, errs []error) {
-	p := newParser(r, NewScope(nil))
-	value = p.parseExpression()
-	p.accept(scanner.EOF)
-	errs = p.errors
-	return
-}
-
 type parser struct {
 	scanner  scanner.Scanner
 	tok      rune
@@ -301,37 +293,6 @@
 	return
 }
 
-func (p *parser) parseMapItemList() []*MapItem {
-	var items []*MapItem
-	// this is a map, not a struct, we only know we're at the end if we hit a '}'
-	for p.tok != '}' {
-		items = append(items, p.parseMapItem())
-
-		if p.tok != ',' {
-			// There was no comma, so the list is done.
-			break
-		}
-		p.accept(',')
-	}
-	return items
-}
-
-func (p *parser) parseMapItem() *MapItem {
-	keyExpression := p.parseExpression()
-	if keyExpression.Type() != StringType {
-		p.errorf("only strings are supported as map keys: %s (%s)", keyExpression.Type(), keyExpression.String())
-	}
-	key := keyExpression.(*String)
-	p.accept(':')
-	pos := p.scanner.Position
-	value := p.parseExpression()
-	return &MapItem{
-		ColonPos: pos,
-		Key:      key,
-		Value:    value,
-	}
-}
-
 func (p *parser) parseProperty(isModule, compat bool) (property *Property) {
 	property = new(Property)
 
@@ -490,7 +451,7 @@
 		return p.parseVariable()
 	case '-', scanner.Int: // Integer might have '-' sign ahead ('+' is only treated as operator now)
 		return p.parseIntValue()
-	case scanner.String, scanner.RawString:
+	case scanner.String:
 		return p.parseStringValue()
 	case '[':
 		return p.parseListValue()
@@ -548,7 +509,7 @@
 		LiteralPos: p.scanner.Position,
 		Value:      str,
 	}
-	p.accept(p.tok)
+	p.accept(scanner.String)
 	return value
 }
 
@@ -614,15 +575,7 @@
 		return nil
 	}
 
-	var properties []*Property
-	var mapItems []*MapItem
-	// if the next item is an identifier, this is a property
-	if p.tok == scanner.Ident {
-		properties = p.parsePropertyList(false, false)
-	} else {
-		// otherwise, we assume that this is a map
-		mapItems = p.parseMapItemList()
-	}
+	properties := p.parsePropertyList(false, false)
 
 	rBracePos := p.scanner.Position
 	p.accept('}')
@@ -631,7 +584,6 @@
 		LBracePos:  lBracePos,
 		RBracePos:  rBracePos,
 		Properties: properties,
-		MapItems:   mapItems,
 	}
 }
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index b32581e..c9d284b 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -144,8 +144,7 @@
 	{`
 		foo {
 			stuff: ["asdf", "jkl;", "qwert",
-				"uiop", ` + "`bnm,\n`" +
-		`]
+				"uiop", "bnm,"]
 		}
 		`,
 		[]Definition{
@@ -154,7 +153,7 @@
 				TypePos: mkpos(3, 2, 3),
 				Map: Map{
 					LBracePos: mkpos(7, 2, 7),
-					RBracePos: mkpos(68, 6, 3),
+					RBracePos: mkpos(67, 5, 3),
 					Properties: []*Property{
 						{
 							Name:     "stuff",
@@ -162,7 +161,7 @@
 							ColonPos: mkpos(17, 3, 9),
 							Value: &List{
 								LBracePos: mkpos(19, 3, 11),
-								RBracePos: mkpos(64, 5, 2),
+								RBracePos: mkpos(63, 4, 19),
 								Values: []Expression{
 									&String{
 										LiteralPos: mkpos(20, 3, 12),
@@ -182,122 +181,7 @@
 									},
 									&String{
 										LiteralPos: mkpos(57, 4, 13),
-										Value:      "bnm,\n",
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		nil,
-	},
-
-	{`
-		foo {
-			stuff: {
-				"key1": 1,
-				"key2": 2,
-			},
-		}
-		`,
-		[]Definition{
-			&Module{
-				Type:    "foo",
-				TypePos: mkpos(3, 2, 3),
-				Map: Map{
-					LBracePos: mkpos(7, 2, 7),
-					RBracePos: mkpos(59, 7, 3),
-					Properties: []*Property{
-						{
-							Name:     "stuff",
-							NamePos:  mkpos(12, 3, 4),
-							ColonPos: mkpos(17, 3, 9),
-							Value: &Map{
-								LBracePos: mkpos(19, 3, 11),
-								RBracePos: mkpos(54, 6, 4),
-								MapItems: []*MapItem{
-									&MapItem{
-										ColonPos: mkpos(33, 4, 13),
-										Key: &String{
-											LiteralPos: mkpos(25, 4, 5),
-											Value:      "key1",
-										},
-										Value: &Int64{
-											LiteralPos: mkpos(33, 4, 13),
-											Value:      1,
-											Token:      "1",
-										},
-									},
-									&MapItem{
-										ColonPos: mkpos(48, 5, 13),
-										Key: &String{
-											LiteralPos: mkpos(40, 5, 5),
-											Value:      "key2",
-										},
-										Value: &Int64{
-											LiteralPos: mkpos(48, 5, 13),
-											Value:      2,
-											Token:      "2",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		nil,
-	},
-
-	{`
-		foo {
-			stuff: {
-				"key1": {
-					a: "abc",
-				},
-			},
-		}
-		`,
-		[]Definition{
-			&Module{
-				Type:    "foo",
-				TypePos: mkpos(3, 2, 3),
-				Map: Map{
-					LBracePos: mkpos(7, 2, 7),
-					RBracePos: mkpos(65, 8, 3),
-					Properties: []*Property{
-						{
-							Name:     "stuff",
-							NamePos:  mkpos(12, 3, 4),
-							ColonPos: mkpos(17, 3, 9),
-							Value: &Map{
-								LBracePos: mkpos(19, 3, 11),
-								RBracePos: mkpos(60, 7, 4),
-								MapItems: []*MapItem{
-									&MapItem{
-										ColonPos: mkpos(33, 4, 13),
-										Key: &String{
-											LiteralPos: mkpos(25, 4, 5),
-											Value:      "key1",
-										},
-										Value: &Map{
-											LBracePos: mkpos(33, 4, 13),
-											RBracePos: mkpos(54, 6, 5),
-											Properties: []*Property{
-												&Property{
-													Name:     "a",
-													NamePos:  mkpos(40, 5, 6),
-													ColonPos: mkpos(41, 5, 7),
-													Value: &String{
-														LiteralPos: mkpos(43, 5, 9),
-														Value:      "abc",
-													},
-												},
-											},
-										},
+										Value:      "bnm,",
 									},
 								},
 							},
@@ -1331,28 +1215,6 @@
 
 // TODO: Test error strings
 
-func TestMapParserError(t *testing.T) {
-	input :=
-		`
-		foo {
-			stuff: {
-				1: "value1",
-				2: "value2",
-			},
-		}
-		`
-	expectedErr := `<input>:4:6: only strings are supported as map keys: int64 ('\x01'@<input>:4:5)`
-	_, errs := ParseAndEval("", bytes.NewBufferString(input), NewScope(nil))
-	if len(errs) == 0 {
-		t.Fatalf("Expected errors, got none.")
-	}
-	for _, err := range errs {
-		if expectedErr != err.Error() {
-			t.Errorf("Unexpected err:  %s", err)
-		}
-	}
-}
-
 func TestParserEndPos(t *testing.T) {
 	in := `
 		module {
diff --git a/parser/printer.go b/parser/printer.go
index f377505..ac7ffe1 100644
--- a/parser/printer.go
+++ b/parser/printer.go
@@ -139,7 +139,7 @@
 func (p *printer) printList(list []Expression, pos, endPos scanner.Position) {
 	p.requestSpace()
 	p.printToken("[", pos)
-	if len(list) > 1 || pos.Line != endPos.Line || listHasMap(list) {
+	if len(list) > 1 || pos.Line != endPos.Line {
 		p.requestNewline()
 		p.indent(p.curIndent() + 4)
 		for _, value := range list {
@@ -392,12 +392,3 @@
 		return b
 	}
 }
-
-func listHasMap(list []Expression) bool {
-	for _, value := range list {
-		if _, ok := value.(*Map); ok {
-			return true
-		}
-	}
-	return false
-}
diff --git a/parser/printer_test.go b/parser/printer_test.go
index c889b2a..077a782 100644
--- a/parser/printer_test.go
+++ b/parser/printer_test.go
@@ -428,27 +428,6 @@
 }
 `,
 	},
-	{
-		input: `
-// test
-stuff {
-    namespace: "google",
-    list_of_structs: [{ key1: "a", key2: "b" }],
-}
-`,
-		output: `
-// test
-stuff {
-    namespace: "google",
-    list_of_structs: [
-        {
-            key1: "a",
-            key2: "b",
-        },
-    ],
-}
-`,
-	},
 }
 
 func TestPrinter(t *testing.T) {
diff --git a/pathtools/fs.go b/pathtools/fs.go
index b959289..806f466 100644
--- a/pathtools/fs.go
+++ b/pathtools/fs.go
@@ -89,7 +89,7 @@
 }
 
 type FileSystem interface {
-	// Open opens a file for reading. Follows symlinks.
+	// Open opens a file for reading.  Follows symlinks.
 	Open(name string) (ReaderAtSeekerCloser, error)
 
 	// Exists returns whether the file exists and whether it is a directory.  Follows symlinks.
@@ -124,29 +124,11 @@
 
 // osFs implements FileSystem using the local disk.
 type osFs struct {
-	srcDir        string
-	openFilesChan chan bool
+	srcDir string
 }
 
 func NewOsFs(path string) FileSystem {
-	// Darwin has a default limit of 256 open files, rate limit open files to 200
-	limit := 200
-	return &osFs{
-		srcDir:        path,
-		openFilesChan: make(chan bool, limit),
-	}
-}
-
-func (fs *osFs) acquire() {
-	if fs.openFilesChan != nil {
-		fs.openFilesChan <- true
-	}
-}
-
-func (fs *osFs) release() {
-	if fs.openFilesChan != nil {
-		<-fs.openFilesChan
-	}
+	return &osFs{srcDir: path}
 }
 
 func (fs *osFs) toAbs(path string) string {
@@ -181,31 +163,11 @@
 	return paths
 }
 
-// OsFile wraps an os.File to also release open file descriptors semaphore on close
-type OsFile struct {
-	*os.File
-	fs *osFs
-}
-
-// Close closes file and releases the open file descriptor semaphore
-func (f *OsFile) Close() error {
-	err := f.File.Close()
-	f.fs.release()
-	return err
-}
-
 func (fs *osFs) Open(name string) (ReaderAtSeekerCloser, error) {
-	fs.acquire()
-	f, err := os.Open(fs.toAbs(name))
-	if err != nil {
-		return nil, err
-	}
-	return &OsFile{f, fs}, nil
+	return os.Open(fs.toAbs(name))
 }
 
 func (fs *osFs) Exists(name string) (bool, bool, error) {
-	fs.acquire()
-	defer fs.release()
 	stat, err := os.Stat(fs.toAbs(name))
 	if err == nil {
 		return true, stat.IsDir(), nil
@@ -217,8 +179,6 @@
 }
 
 func (fs *osFs) IsDir(name string) (bool, error) {
-	fs.acquire()
-	defer fs.release()
 	info, err := os.Stat(fs.toAbs(name))
 	if err != nil {
 		return false, err
@@ -227,8 +187,6 @@
 }
 
 func (fs *osFs) IsSymlink(name string) (bool, error) {
-	fs.acquire()
-	defer fs.release()
 	if info, err := os.Lstat(fs.toAbs(name)); err != nil {
 		return false, err
 	} else {
@@ -241,22 +199,16 @@
 }
 
 func (fs *osFs) glob(pattern string) ([]string, error) {
-	fs.acquire()
-	defer fs.release()
 	paths, err := filepath.Glob(fs.toAbs(pattern))
 	fs.removeSrcDirPrefixes(paths)
 	return paths, err
 }
 
 func (fs *osFs) Lstat(path string) (stats os.FileInfo, err error) {
-	fs.acquire()
-	defer fs.release()
 	return os.Lstat(fs.toAbs(path))
 }
 
 func (fs *osFs) Stat(path string) (stats os.FileInfo, err error) {
-	fs.acquire()
-	defer fs.release()
 	return os.Stat(fs.toAbs(path))
 }
 
@@ -266,8 +218,6 @@
 }
 
 func (fs *osFs) ReadDirNames(name string) ([]string, error) {
-	fs.acquire()
-	defer fs.release()
 	dir, err := os.Open(fs.toAbs(name))
 	if err != nil {
 		return nil, err
@@ -284,8 +234,6 @@
 }
 
 func (fs *osFs) Readlink(name string) (string, error) {
-	fs.acquire()
-	defer fs.release()
 	return os.Readlink(fs.toAbs(name))
 }
 
@@ -297,7 +245,7 @@
 }
 
 func (m *mockFs) followSymlinks(name string) string {
-	dir, file := quickSplit(name)
+	dir, file := saneSplit(name)
 	if dir != "." && dir != "/" {
 		dir = m.followSymlinks(dir)
 	}
@@ -382,7 +330,7 @@
 }
 
 func (m *mockFs) IsSymlink(name string) (bool, error) {
-	dir, file := quickSplit(name)
+	dir, file := saneSplit(name)
 	dir = m.followSymlinks(dir)
 	name = filepath.Join(dir, file)
 
@@ -415,14 +363,14 @@
 }
 
 func (m *mockFs) glob(pattern string) ([]string, error) {
-	dir, file := quickSplit(pattern)
+	dir, file := saneSplit(pattern)
 
 	dir = unescapeGlob(dir)
 	toDir := m.followSymlinks(dir)
 
 	var matches []string
 	for _, f := range m.all {
-		fDir, fFile := quickSplit(f)
+		fDir, fFile := saneSplit(f)
 		if toDir == fDir {
 			match, err := filepath.Match(file, fFile)
 			if err != nil {
@@ -454,7 +402,7 @@
 func (ms *mockStat) Sys() interface{}   { return nil }
 
 func (m *mockFs) Lstat(name string) (os.FileInfo, error) {
-	dir, file := quickSplit(name)
+	dir, file := saneSplit(name)
 	dir = m.followSymlinks(dir)
 	name = filepath.Join(dir, file)
 
@@ -516,7 +464,7 @@
 
 	var ret []string
 	for _, f := range m.all {
-		dir, file := quickSplit(f)
+		dir, file := saneSplit(f)
 		if dir == name && len(file) > 0 && file[0] != '.' {
 			ret = append(ret, file)
 		}
@@ -529,7 +477,7 @@
 }
 
 func (m *mockFs) Readlink(name string) (string, error) {
-	dir, file := quickSplit(name)
+	dir, file := saneSplit(name)
 	dir = m.followSymlinks(dir)
 
 	origName := name
diff --git a/pathtools/glob.go b/pathtools/glob.go
index 5b2d685..14cdacf 100644
--- a/pathtools/glob.go
+++ b/pathtools/glob.go
@@ -24,6 +24,12 @@
 	"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
+
 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")
@@ -124,10 +130,6 @@
 			info, err = fs.Lstat(match)
 		} else {
 			info, err = fs.Stat(match)
-			if err != nil && os.IsNotExist(err) {
-				// ErrNotExist from Stat may be due to a dangling symlink, retry with lstat.
-				info, err = fs.Lstat(match)
-			}
 		}
 		if err != nil {
 			return GlobResult{}, err
@@ -176,7 +178,7 @@
 		return matches, dirs, err
 	}
 
-	dir, file := quickSplit(pattern)
+	dir, file := saneSplit(pattern)
 
 	if file == "**" {
 		if hasRecursive {
@@ -230,7 +232,7 @@
 // Faster version of dir, file := filepath.Dir(path), filepath.File(path) with no allocations
 // Similar to filepath.Split, but returns "." if dir is empty and trims trailing slash if dir is
 // not "/".  Returns ".", "" if path is "."
-func quickSplit(path string) (dir, file string) {
+func saneSplit(path string) (dir, file string) {
 	if path == "." {
 		return ".", ""
 	}
diff --git a/pathtools/glob_test.go b/pathtools/glob_test.go
index 37af483..d847bad 100644
--- a/pathtools/glob_test.go
+++ b/pathtools/glob_test.go
@@ -721,57 +721,6 @@
 	}
 }
 
-var globFollowDanglingSymlinkTestCases = []globTestCase{
-	{
-		pattern: `**/*`,
-		matches: []string{"a/", "b/", "c/", "d/", "dangling", "e", "f", "a/a/", "a/a/a", "a/a/f", "b/a/", "b/a/a", "b/a/f", "c/a", "c/f", "d/a", "d/f"},
-		deps:    []string{".", "a", "a/a", "b", "b/a", "c", "d"},
-	},
-	{
-		pattern: `dangling`,
-		matches: []string{"dangling"},
-		deps:    []string{"dangling"},
-	},
-}
-
-func TestMockGlobFollowDanglingSymlinks(t *testing.T) {
-	files := []string{
-		"a/a/a",
-		"a/a/f -> ../../f",
-		"b -> a",
-		"c -> a/a",
-		"d -> c",
-		"e -> a/a/a",
-		"f",
-		"dangling -> missing",
-	}
-
-	mockFiles := make(map[string][]byte)
-
-	for _, f := range files {
-		mockFiles[f] = nil
-	}
-
-	mock := MockFs(mockFiles)
-
-	for _, testCase := range globFollowDanglingSymlinkTestCases {
-		t.Run(testCase.pattern, func(t *testing.T) {
-			testGlob(t, mock, testCase, FollowSymlinks)
-		})
-	}
-}
-
-func TestGlobFollowDanglingSymlinks(t *testing.T) {
-	os.Chdir("testdata/dangling")
-	defer os.Chdir("../..")
-
-	for _, testCase := range globFollowDanglingSymlinkTestCases {
-		t.Run(testCase.pattern, func(t *testing.T) {
-			testGlob(t, OsFs, testCase, FollowSymlinks)
-		})
-	}
-}
-
 func testGlob(t *testing.T, fs FileSystem, testCase globTestCase, follow ShouldFollowSymlinks) {
 	t.Helper()
 	result, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
diff --git a/proptools/clone.go b/proptools/clone.go
index f464fa6..9e985f1 100644
--- a/proptools/clone.go
+++ b/proptools/clone.go
@@ -78,18 +78,6 @@
 			} else {
 				dstFieldValue.Set(srcFieldValue)
 			}
-		case reflect.Map:
-			if !srcFieldValue.IsNil() {
-				newMap := reflect.MakeMap(field.Type)
-
-				iter := srcFieldValue.MapRange()
-				for iter.Next() {
-					newMap.SetMapIndex(iter.Key(), iter.Value())
-				}
-				dstFieldValue.Set(newMap)
-			} else {
-				dstFieldValue.Set(srcFieldValue)
-			}
 		case reflect.Interface:
 			if srcFieldValue.IsNil() {
 				dstFieldValue.Set(srcFieldValue)
@@ -170,7 +158,7 @@
 		fieldValue := structValue.Field(i)
 
 		switch fieldValue.Kind() {
-		case reflect.Bool, reflect.String, reflect.Slice, reflect.Int, reflect.Uint, reflect.Map:
+		case reflect.Bool, reflect.String, reflect.Slice, reflect.Int, reflect.Uint:
 			fieldValue.Set(reflect.Zero(fieldValue.Type()))
 		case reflect.Interface:
 			if fieldValue.IsNil() {
@@ -232,7 +220,7 @@
 		dstFieldInterfaceValue := reflect.Value{}
 
 		switch srcFieldValue.Kind() {
-		case reflect.Bool, reflect.String, reflect.Slice, reflect.Map, reflect.Int, reflect.Uint:
+		case reflect.Bool, reflect.String, reflect.Slice, reflect.Int, reflect.Uint:
 			// Nothing
 		case reflect.Struct:
 			cloneEmptyProperties(dstFieldValue, srcFieldValue)
diff --git a/proptools/clone_test.go b/proptools/clone_test.go
index 137882a..3c03451 100644
--- a/proptools/clone_test.go
+++ b/proptools/clone_test.go
@@ -84,29 +84,6 @@
 		},
 	},
 	{
-		// Clone map
-		in: &struct{ S map[string]string }{
-			S: map[string]string{"key": "string1"},
-		},
-		out: &struct{ S map[string]string }{
-			S: map[string]string{"key": "string1"},
-		},
-	},
-	{
-		// Clone empty map
-		in: &struct{ S map[string]string }{
-			S: map[string]string{},
-		},
-		out: &struct{ S map[string]string }{
-			S: map[string]string{},
-		},
-	},
-	{
-		// Clone nil map
-		in:  &struct{ S map[string]string }{},
-		out: &struct{ S map[string]string }{},
-	},
-	{
 		// Clone pointer to bool
 		in: &struct{ B1, B2 *bool }{
 			B1: BoolPtr(true),
@@ -308,12 +285,6 @@
 			t.Errorf("  expected: %#v", testCase.out)
 			t.Errorf("       got: %#v", got)
 		}
-		if testCase.out == got {
-			t.Errorf("test case %s", testString)
-			t.Errorf("items should be cloned, not the original")
-			t.Errorf("  expected: %s", testCase.out)
-			t.Errorf("       got: %s", got)
-		}
 	}
 }
 
diff --git a/proptools/escape.go b/proptools/escape.go
index 4ef10f0..b8790b5 100644
--- a/proptools/escape.go
+++ b/proptools/escape.go
@@ -53,15 +53,7 @@
 		slice[i] = ShellEscape(s)
 	}
 	return slice
-}
 
-func ShellEscapeListIncludingSpaces(slice []string) []string {
-	slice = append([]string(nil), slice...)
-
-	for i, s := range slice {
-		slice[i] = ShellEscapeIncludingSpaces(s)
-	}
-	return slice
 }
 
 func shellUnsafeChar(r rune) bool {
@@ -114,10 +106,6 @@
 	return ShellEscapeList(NinjaEscapeList(slice))
 }
 
-func NinjaAndShellEscapeListIncludingSpaces(slice []string) []string {
-	return ShellEscapeListIncludingSpaces(NinjaEscapeList(slice))
-}
-
 func NinjaAndShellEscape(s string) string {
 	return ShellEscape(NinjaEscape(s))
 }
diff --git a/proptools/extend.go b/proptools/extend.go
index 4e2f498..d3c2b79 100644
--- a/proptools/extend.go
+++ b/proptools/extend.go
@@ -20,8 +20,7 @@
 )
 
 // AppendProperties appends the values of properties in the property struct src to the property
-// struct dst. dst and src must be the same type, and both must be pointers to structs. Properties
-// tagged `blueprint:"mutated"` are skipped.
+// struct dst. dst and src must be the same type, and both must be pointers to structs.
 //
 // The filter function can prevent individual properties from being appended by returning false, or
 // abort AppendProperties with an error by returning an error.  Passing nil for filter will append
@@ -39,8 +38,7 @@
 }
 
 // PrependProperties prepends the values of properties in the property struct src to the property
-// struct dst. dst and src must be the same type, and both must be pointers to structs. Properties
-// tagged `blueprint:"mutated"` are skipped.
+// struct dst. dst and src must be the same type, and both must be pointers to structs.
 //
 // The filter function can prevent individual properties from being prepended by returning false, or
 // abort PrependProperties with an error by returning an error.  Passing nil for filter will prepend
@@ -60,7 +58,7 @@
 // AppendMatchingProperties appends the values of properties in the property struct src to the
 // property structs in dst.  dst and src do not have to be the same type, but every property in src
 // must be found in at least one property in dst.  dst must be a slice of pointers to structs, and
-// src must be a pointer to a struct.  Properties tagged `blueprint:"mutated"` are skipped.
+// src must be a pointer to a struct.
 //
 // The filter function can prevent individual properties from being appended by returning false, or
 // abort AppendProperties with an error by returning an error.  Passing nil for filter will append
@@ -81,7 +79,7 @@
 // PrependMatchingProperties prepends the values of properties in the property struct src to the
 // property structs in dst.  dst and src do not have to be the same type, but every property in src
 // must be found in at least one property in dst.  dst must be a slice of pointers to structs, and
-// src must be a pointer to a struct.  Properties tagged `blueprint:"mutated"` are skipped.
+// src must be a pointer to a struct.
 //
 // The filter function can prevent individual properties from being prepended by returning false, or
 // abort PrependProperties with an error by returning an error.  Passing nil for filter will prepend
@@ -101,7 +99,6 @@
 
 // ExtendProperties appends or prepends the values of properties in the property struct src to the
 // property struct dst. dst and src must be the same type, and both must be pointers to structs.
-// Properties tagged `blueprint:"mutated"` are skipped.
 //
 // The filter function can prevent individual properties from being appended or prepended by
 // returning false, or abort ExtendProperties with an error by returning an error.  Passing nil for
@@ -126,8 +123,7 @@
 // ExtendMatchingProperties appends or prepends the values of properties in the property struct src
 // to the property structs in dst.  dst and src do not have to be the same type, but every property
 // in src must be found in at least one property in dst.  dst must be a slice of pointers to
-// structs, and src must be a pointer to a struct.  Properties tagged `blueprint:"mutated"` are
-// skipped.
+// structs, and src must be a pointer to a struct.
 //
 // The filter function can prevent individual properties from being appended or prepended by
 // returning false, or abort ExtendMatchingProperties with an error by returning an error.  Passing
@@ -251,11 +247,13 @@
 	prefix string, filter ExtendPropertyFilterFunc, sameTypes bool,
 	orderFunc ExtendPropertyOrderFunc) error {
 
-	dstValuesCopied := false
-
 	srcType := srcValue.Type()
 	for i, srcField := range typeFields(srcType) {
-		if ShouldSkipProperty(srcField) {
+		if srcField.PkgPath != "" {
+			// The field is not exported so just skip it.
+			continue
+		}
+		if HasTag(srcField, "blueprint", "mutated") {
 			continue
 		}
 
@@ -286,9 +284,7 @@
 
 		found := false
 		var recurse []reflect.Value
-		// Use an iteration loop so elements can be added to the end of dstValues inside the loop.
-		for j := 0; j < len(dstValues); j++ {
-			dstValue := dstValues[j]
+		for _, dstValue := range dstValues {
 			dstType := dstValue.Type()
 			var dstField reflect.StructField
 
@@ -301,27 +297,6 @@
 					if field.Name == srcField.Name {
 						dstField = field
 						ok = true
-					} else if IsEmbedded(field) {
-						embeddedDstValue := dstValue.FieldByIndex(field.Index)
-						if isStructPtr(embeddedDstValue.Type()) {
-							if embeddedDstValue.IsNil() {
-								newEmbeddedDstValue := reflect.New(embeddedDstValue.Type().Elem())
-								embeddedDstValue.Set(newEmbeddedDstValue)
-							}
-							embeddedDstValue = embeddedDstValue.Elem()
-						}
-						if !isStruct(embeddedDstValue.Type()) {
-							return extendPropertyErrorf(propertyName, "%s is not a struct (%s)",
-								prefix+field.Name, embeddedDstValue.Type())
-						}
-						// The destination struct contains an embedded struct, add it to the list
-						// of destinations to consider.  Make a copy of dstValues if necessary
-						// to avoid modifying the backing array of an input parameter.
-						if !dstValuesCopied {
-							dstValues = append([]reflect.Value(nil), dstValues...)
-							dstValuesCopied = true
-						}
-						dstValues = append(dstValues, embeddedDstValue)
 					}
 				}
 				if !ok {
@@ -367,7 +342,7 @@
 				// Recursively extend the struct's fields.
 				recurse = append(recurse, dstFieldValue)
 				continue
-			case reflect.Bool, reflect.String, reflect.Slice, reflect.Map:
+			case reflect.Bool, reflect.String, reflect.Slice:
 				if srcFieldValue.Type() != dstFieldValue.Type() {
 					return extendPropertyErrorf(propertyName, "mismatched types %s and %s",
 						dstFieldValue.Type(), srcFieldValue.Type())
@@ -468,34 +443,6 @@
 			newSlice = reflect.AppendSlice(newSlice, srcFieldValue)
 		}
 		dstFieldValue.Set(newSlice)
-	case reflect.Map:
-		if srcFieldValue.IsNil() {
-			break
-		}
-		var mapValue reflect.Value
-		// for append/prepend, maintain keys from original value
-		// for replace, replace entire map
-		if order == Replace || dstFieldValue.IsNil() {
-			mapValue = srcFieldValue
-		} else {
-			mapValue = dstFieldValue
-
-			iter := srcFieldValue.MapRange()
-			for iter.Next() {
-				dstValue := dstFieldValue.MapIndex(iter.Key())
-				if prepend {
-					// if the key exists in the map, keep the original value.
-					if !dstValue.IsValid() {
-						// otherwise, add the new value
-						mapValue.SetMapIndex(iter.Key(), iter.Value())
-					}
-				} else {
-					// For append, replace the original value.
-					mapValue.SetMapIndex(iter.Key(), iter.Value())
-				}
-			}
-		}
-		dstFieldValue.Set(mapValue)
 	case reflect.Ptr:
 		if srcFieldValue.IsNil() {
 			break
@@ -537,18 +484,6 @@
 	}
 }
 
-// ShouldSkipProperty indicates whether a property should be skipped in processing.
-func ShouldSkipProperty(structField reflect.StructField) bool {
-	return structField.PkgPath != "" || // The field is not exported so just skip it.
-		HasTag(structField, "blueprint", "mutated") // The field is not settable in a blueprint file
-}
-
-// IsEmbedded indicates whether a property is embedded. This is useful for determining nesting name
-// as the name of the embedded field is _not_ used in blueprint files.
-func IsEmbedded(structField reflect.StructField) bool {
-	return structField.Name == "BlueprintEmbed" || structField.Anonymous
-}
-
 type getStructEmptyError struct{}
 
 func (getStructEmptyError) Error() string { return "interface containing nil pointer" }
diff --git a/proptools/extend_test.go b/proptools/extend_test.go
index d2dac72..0470379 100644
--- a/proptools/extend_test.go
+++ b/proptools/extend_test.go
@@ -23,9 +23,8 @@
 )
 
 type appendPropertyTestCase struct {
-	name   string
-	dst    interface{}
-	src    interface{}
+	in1    interface{}
+	in2    interface{}
 	out    interface{}
 	order  Order // default is Append
 	filter ExtendPropertyFilterFunc
@@ -37,14 +36,14 @@
 		// Valid inputs
 
 		{
-			name: "Append bool",
-			dst: &struct{ B1, B2, B3, B4 bool }{
+			// Append bool
+			in1: &struct{ B1, B2, B3, B4 bool }{
 				B1: true,
 				B2: false,
 				B3: true,
 				B4: false,
 			},
-			src: &struct{ B1, B2, B3, B4 bool }{
+			in2: &struct{ B1, B2, B3, B4 bool }{
 				B1: true,
 				B2: true,
 				B3: false,
@@ -58,14 +57,14 @@
 			},
 		},
 		{
-			name: "Prepend bool",
-			dst: &struct{ B1, B2, B3, B4 bool }{
+			// Prepend bool
+			in1: &struct{ B1, B2, B3, B4 bool }{
 				B1: true,
 				B2: false,
 				B3: true,
 				B4: false,
 			},
-			src: &struct{ B1, B2, B3, B4 bool }{
+			in2: &struct{ B1, B2, B3, B4 bool }{
 				B1: true,
 				B2: true,
 				B3: false,
@@ -80,11 +79,11 @@
 			order: Prepend,
 		},
 		{
-			name: "Append strings",
-			dst: &struct{ S string }{
+			// Append strings
+			in1: &struct{ S string }{
 				S: "string1",
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: &struct{ S string }{
@@ -92,11 +91,11 @@
 			},
 		},
 		{
-			name: "Prepend strings",
-			dst: &struct{ S string }{
+			// Prepend strings
+			in1: &struct{ S string }{
 				S: "string1",
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: &struct{ S string }{
@@ -105,8 +104,8 @@
 			order: Prepend,
 		},
 		{
-			name: "Append pointer to bool",
-			dst: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			// Append pointer to bool
+			in1: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
 				B1: BoolPtr(true),
 				B2: BoolPtr(false),
 				B3: nil,
@@ -117,7 +116,7 @@
 				B8: BoolPtr(false),
 				B9: nil,
 			},
-			src: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			in2: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
 				B1: nil,
 				B2: nil,
 				B3: nil,
@@ -141,8 +140,8 @@
 			},
 		},
 		{
-			name: "Prepend pointer to bool",
-			dst: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			// Prepend pointer to bool
+			in1: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
 				B1: BoolPtr(true),
 				B2: BoolPtr(false),
 				B3: nil,
@@ -153,7 +152,7 @@
 				B8: BoolPtr(false),
 				B9: nil,
 			},
-			src: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			in2: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
 				B1: nil,
 				B2: nil,
 				B3: nil,
@@ -178,8 +177,8 @@
 			order: Prepend,
 		},
 		{
-			name: "Append pointer to integer",
-			dst: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
+			// Append pointer to integer
+			in1: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
 				I1: Int64Ptr(55),
 				I2: Int64Ptr(-3),
 				I3: nil,
@@ -190,7 +189,7 @@
 				I8: Int64Ptr(0),
 				I9: nil,
 			},
-			src: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
+			in2: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
 				I1: nil,
 				I2: nil,
 				I3: nil,
@@ -214,12 +213,12 @@
 			},
 		},
 		{
-			name: "Prepend pointer to integer",
-			dst: &struct{ I1, I2, I3 *int64 }{
+			// Prepend pointer to integer
+			in1: &struct{ I1, I2, I3 *int64 }{
 				I1: Int64Ptr(55),
 				I3: nil,
 			},
-			src: &struct{ I1, I2, I3 *int64 }{
+			in2: &struct{ I1, I2, I3 *int64 }{
 				I2: Int64Ptr(33),
 			},
 			out: &struct{ I1, I2, I3 *int64 }{
@@ -230,12 +229,12 @@
 			order: Prepend,
 		},
 		{
-			name: "Append pointer to strings",
-			dst: &struct{ S1, S2, S3, S4 *string }{
+			// Append pointer to strings
+			in1: &struct{ S1, S2, S3, S4 *string }{
 				S1: StringPtr("string1"),
 				S2: StringPtr("string2"),
 			},
-			src: &struct{ S1, S2, S3, S4 *string }{
+			in2: &struct{ S1, S2, S3, S4 *string }{
 				S1: StringPtr("string3"),
 				S3: StringPtr("string4"),
 			},
@@ -247,12 +246,12 @@
 			},
 		},
 		{
-			name: "Prepend pointer to strings",
-			dst: &struct{ S1, S2, S3, S4 *string }{
+			// Prepend pointer to strings
+			in1: &struct{ S1, S2, S3, S4 *string }{
 				S1: StringPtr("string1"),
 				S2: StringPtr("string2"),
 			},
-			src: &struct{ S1, S2, S3, S4 *string }{
+			in2: &struct{ S1, S2, S3, S4 *string }{
 				S1: StringPtr("string3"),
 				S3: StringPtr("string4"),
 			},
@@ -265,11 +264,11 @@
 			order: Prepend,
 		},
 		{
-			name: "Append slice",
-			dst: &struct{ S []string }{
+			// Append slice
+			in1: &struct{ S []string }{
 				S: []string{"string1"},
 			},
-			src: &struct{ S []string }{
+			in2: &struct{ S []string }{
 				S: []string{"string2"},
 			},
 			out: &struct{ S []string }{
@@ -277,11 +276,11 @@
 			},
 		},
 		{
-			name: "Prepend slice",
-			dst: &struct{ S []string }{
+			// Prepend slice
+			in1: &struct{ S []string }{
 				S: []string{"string1"},
 			},
-			src: &struct{ S []string }{
+			in2: &struct{ S []string }{
 				S: []string{"string2"},
 			},
 			out: &struct{ S []string }{
@@ -290,11 +289,11 @@
 			order: Prepend,
 		},
 		{
-			name: "Replace slice",
-			dst: &struct{ S []string }{
+			// Replace slice
+			in1: &struct{ S []string }{
 				S: []string{"string1"},
 			},
-			src: &struct{ S []string }{
+			in2: &struct{ S []string }{
 				S: []string{"string2"},
 			},
 			out: &struct{ S []string }{
@@ -303,12 +302,12 @@
 			order: Replace,
 		},
 		{
-			name: "Append empty slice",
-			dst: &struct{ S1, S2 []string }{
+			// Append empty slice
+			in1: &struct{ S1, S2 []string }{
 				S1: []string{"string1"},
 				S2: []string{},
 			},
-			src: &struct{ S1, S2 []string }{
+			in2: &struct{ S1, S2 []string }{
 				S1: []string{},
 				S2: []string{"string2"},
 			},
@@ -318,12 +317,12 @@
 			},
 		},
 		{
-			name: "Prepend empty slice",
-			dst: &struct{ S1, S2 []string }{
+			// Prepend empty slice
+			in1: &struct{ S1, S2 []string }{
 				S1: []string{"string1"},
 				S2: []string{},
 			},
-			src: &struct{ S1, S2 []string }{
+			in2: &struct{ S1, S2 []string }{
 				S1: []string{},
 				S2: []string{"string2"},
 			},
@@ -334,12 +333,12 @@
 			order: Prepend,
 		},
 		{
-			name: "Replace empty slice",
-			dst: &struct{ S1, S2 []string }{
+			// Replace empty slice
+			in1: &struct{ S1, S2 []string }{
 				S1: []string{"string1"},
 				S2: []string{},
 			},
-			src: &struct{ S1, S2 []string }{
+			in2: &struct{ S1, S2 []string }{
 				S1: []string{},
 				S2: []string{"string2"},
 			},
@@ -350,11 +349,11 @@
 			order: Replace,
 		},
 		{
-			name: "Append nil slice",
-			dst: &struct{ S1, S2, S3 []string }{
+			// Append nil slice
+			in1: &struct{ S1, S2, S3 []string }{
 				S1: []string{"string1"},
 			},
-			src: &struct{ S1, S2, S3 []string }{
+			in2: &struct{ S1, S2, S3 []string }{
 				S2: []string{"string2"},
 			},
 			out: &struct{ S1, S2, S3 []string }{
@@ -364,11 +363,11 @@
 			},
 		},
 		{
-			name: "Prepend nil slice",
-			dst: &struct{ S1, S2, S3 []string }{
+			// Prepend nil slice
+			in1: &struct{ S1, S2, S3 []string }{
 				S1: []string{"string1"},
 			},
-			src: &struct{ S1, S2, S3 []string }{
+			in2: &struct{ S1, S2, S3 []string }{
 				S2: []string{"string2"},
 			},
 			out: &struct{ S1, S2, S3 []string }{
@@ -379,11 +378,11 @@
 			order: Prepend,
 		},
 		{
-			name: "Replace nil slice",
-			dst: &struct{ S1, S2, S3 []string }{
+			// Replace nil slice
+			in1: &struct{ S1, S2, S3 []string }{
 				S1: []string{"string1"},
 			},
-			src: &struct{ S1, S2, S3 []string }{
+			in2: &struct{ S1, S2, S3 []string }{
 				S2: []string{"string2"},
 			},
 			out: &struct{ S1, S2, S3 []string }{
@@ -394,13 +393,13 @@
 			order: Replace,
 		},
 		{
-			name: "Replace embedded slice",
-			dst: &struct{ S *struct{ S1 []string } }{
+			// Replace embedded slice
+			in1: &struct{ S *struct{ S1 []string } }{
 				S: &struct{ S1 []string }{
 					S1: []string{"string1"},
 				},
 			},
-			src: &struct{ S *struct{ S1 []string } }{
+			in2: &struct{ S *struct{ S1 []string } }{
 				S: &struct{ S1 []string }{
 					S1: []string{"string2"},
 				},
@@ -413,13 +412,13 @@
 			order: Replace,
 		},
 		{
-			name: "Append slice of structs",
-			dst: &struct{ S []struct{ F string } }{
+			// Append slice of structs
+			in1: &struct{ S []struct{ F string } }{
 				S: []struct{ F string }{
 					{F: "foo"}, {F: "bar"},
 				},
 			},
-			src: &struct{ S []struct{ F string } }{
+			in2: &struct{ S []struct{ F string } }{
 				S: []struct{ F string }{
 					{F: "baz"},
 				},
@@ -432,13 +431,13 @@
 			order: Append,
 		},
 		{
-			name: "Prepend slice of structs",
-			dst: &struct{ S []struct{ F string } }{
+			// Prepend slice of structs
+			in1: &struct{ S []struct{ F string } }{
 				S: []struct{ F string }{
 					{F: "foo"}, {F: "bar"},
 				},
 			},
-			src: &struct{ S []struct{ F string } }{
+			in2: &struct{ S []struct{ F string } }{
 				S: []struct{ F string }{
 					{F: "baz"},
 				},
@@ -451,181 +450,13 @@
 			order: Prepend,
 		},
 		{
-			name: "Append map",
-			dst: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "",
-					"key1": "dst_value1",
-					"key2": "dst_value2",
-				},
-			},
-			src: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "src_value0",
-					"key1": "src_value1",
-					"key3": "src_value3",
-				},
-			},
-			out: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "src_value0",
-					"key1": "src_value1",
-					"key2": "dst_value2",
-					"key3": "src_value3",
-				},
-			},
-			order: Append,
-		},
-		{
-			name: "Prepend map",
-			dst: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "",
-					"key1": "dst_value1",
-					"key2": "dst_value2",
-				},
-			},
-			src: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "src_value0",
-					"key1": "src_value1",
-					"key3": "src_value3",
-				},
-			},
-			out: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "",
-					"key1": "dst_value1",
-					"key2": "dst_value2",
-					"key3": "src_value3",
-				},
-			},
-			order: Prepend,
-		},
-		{
-			name: "Replace map",
-			dst: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "",
-					"key1": "dst_value1",
-					"key2": "dst_value2",
-				},
-			},
-			src: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "src_value0",
-					"key1": "src_value1",
-					"key3": "src_value3",
-				},
-			},
-			out: &struct{ S map[string]string }{
-				S: map[string]string{
-					"key0": "src_value0",
-					"key1": "src_value1",
-					"key3": "src_value3",
-				},
-			},
-			order: Replace,
-		},
-		{
-			name: "Append empty map",
-			dst: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{},
-			},
-			src: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			out: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			order: Append,
-		},
-		{
-			name: "Prepend empty map",
-			dst: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{},
-			},
-			src: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			out: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			order: Prepend,
-		},
-		{
-			name: "Replace empty map",
-			dst: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{},
-			},
-			src: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			out: &struct{ S1, S2 map[string]string }{
-				S1: map[string]string{},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			order: Replace,
-		},
-		{
-			name: "Append nil map",
-			dst: &struct{ S1, S2, S3 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-			},
-			src: &struct{ S1, S2, S3 map[string]string }{
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			out: &struct{ S1, S2, S3 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			order: Append,
-		},
-		{
-			name: "Prepend nil map",
-			dst: &struct{ S1, S2, S3 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-			},
-			src: &struct{ S1, S2, S3 map[string]string }{
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			out: &struct{ S1, S2, S3 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			order: Prepend,
-		},
-		{
-			name: "Replace nil map",
-			dst: &struct{ S1, S2, S3 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-			},
-			src: &struct{ S1, S2, S3 map[string]string }{
-				S2: map[string]string{"key0": "src_value0"},
-			},
-			out: &struct{ S1, S2, S3 map[string]string }{
-				S1: map[string]string{"key0": "dst_value0"},
-				S2: map[string]string{"key0": "src_value0"},
-				S3: nil,
-			},
-			order: Replace,
-		},
-		{
-			name: "Replace slice of structs",
-			dst: &struct{ S []struct{ F string } }{
+			// Replace slice of structs
+			in1: &struct{ S []struct{ F string } }{
 				S: []struct{ F string }{
 					{F: "foo"}, {F: "bar"},
 				},
 			},
-			src: &struct{ S []struct{ F string } }{
+			in2: &struct{ S []struct{ F string } }{
 				S: []struct{ F string }{
 					{F: "baz"},
 				},
@@ -638,13 +469,13 @@
 			order: Replace,
 		},
 		{
-			name: "Append pointer",
-			dst: &struct{ S *struct{ S string } }{
+			// Append pointer
+			in1: &struct{ S *struct{ S string } }{
 				S: &struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S *struct{ S string } }{
+			in2: &struct{ S *struct{ S string } }{
 				S: &struct{ S string }{
 					S: "string2",
 				},
@@ -656,13 +487,13 @@
 			},
 		},
 		{
-			name: "Prepend pointer",
-			dst: &struct{ S *struct{ S string } }{
+			// Prepend pointer
+			in1: &struct{ S *struct{ S string } }{
 				S: &struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S *struct{ S string } }{
+			in2: &struct{ S *struct{ S string } }{
 				S: &struct{ S string }{
 					S: "string2",
 				},
@@ -675,13 +506,13 @@
 			order: Prepend,
 		},
 		{
-			name: "Append interface",
-			dst: &struct{ S interface{} }{
+			// Append interface
+			in1: &struct{ S interface{} }{
 				S: &struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: &struct{ S string }{
 					S: "string2",
 				},
@@ -693,13 +524,13 @@
 			},
 		},
 		{
-			name: "Prepend interface",
-			dst: &struct{ S interface{} }{
+			// Prepend interface
+			in1: &struct{ S interface{} }{
 				S: &struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: &struct{ S string }{
 					S: "string2",
 				},
@@ -712,11 +543,11 @@
 			order: Prepend,
 		},
 		{
-			name: "Unexported field",
-			dst: &struct{ s string }{
+			// Unexported field
+			in1: &struct{ s string }{
 				s: "string1",
 			},
-			src: &struct{ s string }{
+			in2: &struct{ s string }{
 				s: "string2",
 			},
 			out: &struct{ s string }{
@@ -724,11 +555,11 @@
 			},
 		},
 		{
-			name: "Unexported field",
-			dst: &struct{ i *int64 }{
+			// Unexported field
+			in1: &struct{ i *int64 }{
 				i: Int64Ptr(33),
 			},
-			src: &struct{ i *int64 }{
+			in2: &struct{ i *int64 }{
 				i: Int64Ptr(5),
 			},
 			out: &struct{ i *int64 }{
@@ -736,17 +567,17 @@
 			},
 		},
 		{
-			name: "Empty struct",
-			dst:  &struct{}{},
-			src:  &struct{}{},
-			out:  &struct{}{},
+			// Empty struct
+			in1: &struct{}{},
+			in2: &struct{}{},
+			out: &struct{}{},
 		},
 		{
-			name: "Interface nil",
-			dst: &struct{ S interface{} }{
+			// Interface nil
+			in1: &struct{ S interface{} }{
 				S: nil,
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: nil,
 			},
 			out: &struct{ S interface{} }{
@@ -754,11 +585,11 @@
 			},
 		},
 		{
-			name: "Pointer nil",
-			dst: &struct{ S *struct{} }{
+			// Pointer nil
+			in1: &struct{ S *struct{} }{
 				S: nil,
 			},
-			src: &struct{ S *struct{} }{
+			in2: &struct{ S *struct{} }{
 				S: nil,
 			},
 			out: &struct{ S *struct{} }{
@@ -766,8 +597,8 @@
 			},
 		},
 		{
-			name: "Anonymous struct",
-			dst: &struct {
+			// Anonymous struct
+			in1: &struct {
 				EmbeddedStruct
 				Nested struct{ EmbeddedStruct }
 			}{
@@ -782,7 +613,7 @@
 					},
 				},
 			},
-			src: &struct {
+			in2: &struct {
 				EmbeddedStruct
 				Nested struct{ EmbeddedStruct }
 			}{
@@ -814,56 +645,8 @@
 			},
 		},
 		{
-			name: "BlueprintEmbed struct",
-			dst: &struct {
-				BlueprintEmbed EmbeddedStruct
-				Nested         struct{ BlueprintEmbed EmbeddedStruct }
-			}{
-				BlueprintEmbed: EmbeddedStruct{
-					S: "string1",
-					I: Int64Ptr(55),
-				},
-				Nested: struct{ BlueprintEmbed EmbeddedStruct }{
-					BlueprintEmbed: EmbeddedStruct{
-						S: "string2",
-						I: Int64Ptr(-4),
-					},
-				},
-			},
-			src: &struct {
-				BlueprintEmbed EmbeddedStruct
-				Nested         struct{ BlueprintEmbed EmbeddedStruct }
-			}{
-				BlueprintEmbed: EmbeddedStruct{
-					S: "string3",
-					I: Int64Ptr(66),
-				},
-				Nested: struct{ BlueprintEmbed EmbeddedStruct }{
-					BlueprintEmbed: EmbeddedStruct{
-						S: "string4",
-						I: Int64Ptr(-8),
-					},
-				},
-			},
-			out: &struct {
-				BlueprintEmbed EmbeddedStruct
-				Nested         struct{ BlueprintEmbed EmbeddedStruct }
-			}{
-				BlueprintEmbed: EmbeddedStruct{
-					S: "string1string3",
-					I: Int64Ptr(66),
-				},
-				Nested: struct{ BlueprintEmbed EmbeddedStruct }{
-					BlueprintEmbed: EmbeddedStruct{
-						S: "string2string4",
-						I: Int64Ptr(-8),
-					},
-				},
-			},
-		},
-		{
-			name: "Anonymous interface",
-			dst: &struct {
+			// Anonymous interface
+			in1: &struct {
 				EmbeddedInterface
 				Nested struct{ EmbeddedInterface }
 			}{
@@ -884,7 +667,7 @@
 					},
 				},
 			},
-			src: &struct {
+			in2: &struct {
 				EmbeddedInterface
 				Nested struct{ EmbeddedInterface }
 			}{
@@ -928,13 +711,13 @@
 			},
 		},
 		{
-			name: "Nil pointer to a struct",
-			dst: &struct {
+			// Nil pointer to a struct
+			in1: &struct {
 				Nested *struct {
 					S string
 				}
 			}{},
-			src: &struct {
+			in2: &struct {
 				Nested *struct {
 					S string
 				}
@@ -958,13 +741,13 @@
 			},
 		},
 		{
-			name: "Nil pointer to a struct in an interface",
-			dst: &struct {
+			// Nil pointer to a struct in an interface
+			in1: &struct {
 				Nested interface{}
 			}{
 				Nested: (*struct{ S string })(nil),
 			},
-			src: &struct {
+			in2: &struct {
 				Nested interface{}
 			}{
 				Nested: &struct {
@@ -984,13 +767,13 @@
 			},
 		},
 		{
-			name: "Interface src nil",
-			dst: &struct{ S interface{} }{
+			// Interface src nil
+			in1: &struct{ S interface{} }{
 				S: &struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: nil,
 			},
 			out: &struct{ S interface{} }{
@@ -1003,39 +786,39 @@
 		// Errors
 
 		{
-			name: "Non-pointer dst",
-			dst:  struct{}{},
-			src:  &struct{}{},
-			err:  errors.New("expected pointer to struct, got struct {}"),
-			out:  struct{}{},
+			// Non-pointer in1
+			in1: struct{}{},
+			in2: &struct{}{},
+			err: errors.New("expected pointer to struct, got struct {}"),
+			out: struct{}{},
 		},
 		{
-			name: "Non-pointer src",
-			dst:  &struct{}{},
-			src:  struct{}{},
-			err:  errors.New("expected pointer to struct, got struct {}"),
-			out:  &struct{}{},
+			// Non-pointer in2
+			in1: &struct{}{},
+			in2: struct{}{},
+			err: errors.New("expected pointer to struct, got struct {}"),
+			out: &struct{}{},
 		},
 		{
-			name: "Non-struct dst",
-			dst:  &[]string{"bad"},
-			src:  &struct{}{},
-			err:  errors.New("expected pointer to struct, got *[]string"),
-			out:  &[]string{"bad"},
+			// Non-struct in1
+			in1: &[]string{"bad"},
+			in2: &struct{}{},
+			err: errors.New("expected pointer to struct, got *[]string"),
+			out: &[]string{"bad"},
 		},
 		{
-			name: "Non-struct src",
-			dst:  &struct{}{},
-			src:  &[]string{"bad"},
-			err:  errors.New("expected pointer to struct, got *[]string"),
-			out:  &struct{}{},
+			// Non-struct in2
+			in1: &struct{}{},
+			in2: &[]string{"bad"},
+			err: errors.New("expected pointer to struct, got *[]string"),
+			out: &struct{}{},
 		},
 		{
-			name: "Mismatched types",
-			dst: &struct{ A string }{
+			// Mismatched types
+			in1: &struct{ A string }{
 				A: "string1",
 			},
-			src: &struct{ B string }{
+			in2: &struct{ B string }{
 				B: "string2",
 			},
 			out: &struct{ A string }{
@@ -1044,11 +827,11 @@
 			err: errors.New("expected matching types for dst and src, got *struct { A string } and *struct { B string }"),
 		},
 		{
-			name: "Unsupported kind",
-			dst: &struct{ I int }{
+			// Unsupported kind
+			in1: &struct{ I int }{
 				I: 1,
 			},
-			src: &struct{ I int }{
+			in2: &struct{ I int }{
 				I: 2,
 			},
 			out: &struct{ I int }{
@@ -1057,11 +840,11 @@
 			err: extendPropertyErrorf("i", "unsupported kind int"),
 		},
 		{
-			name: "Unsupported kind",
-			dst: &struct{ I int64 }{
+			// Unsupported kind
+			in1: &struct{ I int64 }{
 				I: 1,
 			},
-			src: &struct{ I int64 }{
+			in2: &struct{ I int64 }{
 				I: 2,
 			},
 			out: &struct{ I int64 }{
@@ -1070,11 +853,11 @@
 			err: extendPropertyErrorf("i", "unsupported kind int64"),
 		},
 		{
-			name: "Interface nilitude mismatch",
-			dst: &struct{ S interface{} }{
+			// Interface nilitude mismatch
+			in1: &struct{ S interface{} }{
 				S: nil,
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: &struct{ S string }{
 					S: "string1",
 				},
@@ -1085,13 +868,13 @@
 			err: extendPropertyErrorf("s", "nilitude mismatch"),
 		},
 		{
-			name: "Interface type mismatch",
-			dst: &struct{ S interface{} }{
+			// Interface type mismatch
+			in1: &struct{ S interface{} }{
 				S: &struct{ A string }{
 					A: "string1",
 				},
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: &struct{ B string }{
 					B: "string2",
 				},
@@ -1104,13 +887,13 @@
 			err: extendPropertyErrorf("s", "mismatched types struct { A string } and struct { B string }"),
 		},
 		{
-			name: "Interface not a pointer",
-			dst: &struct{ S interface{} }{
+			// Interface not a pointer
+			in1: &struct{ S interface{} }{
 				S: struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: struct{ S string }{
 					S: "string2",
 				},
@@ -1123,11 +906,11 @@
 			err: extendPropertyErrorf("s", "interface not a pointer"),
 		},
 		{
-			name: "Pointer not a struct",
-			dst: &struct{ S *[]string }{
+			// Pointer not a struct
+			in1: &struct{ S *[]string }{
 				S: &[]string{"string1"},
 			},
-			src: &struct{ S *[]string }{
+			in2: &struct{ S *[]string }{
 				S: &[]string{"string2"},
 			},
 			out: &struct{ S *[]string }{
@@ -1136,13 +919,13 @@
 			err: extendPropertyErrorf("s", "pointer is a slice"),
 		},
 		{
-			name: "Error in nested struct",
-			dst: &struct{ S interface{} }{
+			// Error in nested struct
+			in1: &struct{ S interface{} }{
 				S: &struct{ I int }{
 					I: 1,
 				},
 			},
-			src: &struct{ S interface{} }{
+			in2: &struct{ S interface{} }{
 				S: &struct{ I int }{
 					I: 2,
 				},
@@ -1158,11 +941,11 @@
 		// Filters
 
 		{
-			name: "Filter true",
-			dst: &struct{ S string }{
+			// Filter true
+			in1: &struct{ S string }{
 				S: "string1",
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: &struct{ S string }{
@@ -1175,11 +958,11 @@
 			},
 		},
 		{
-			name: "Filter false",
-			dst: &struct{ S string }{
+			// Filter false
+			in1: &struct{ S string }{
 				S: "string1",
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: &struct{ S string }{
@@ -1192,11 +975,11 @@
 			},
 		},
 		{
-			name: "Filter check args",
-			dst: &struct{ S string }{
+			// Filter check args
+			in1: &struct{ S string }{
 				S: "string1",
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: &struct{ S string }{
@@ -1211,13 +994,13 @@
 			},
 		},
 		{
-			name: "Filter mutated",
-			dst: &struct {
+			// Filter mutated
+			in1: &struct {
 				S string `blueprint:"mutated"`
 			}{
 				S: "string1",
 			},
-			src: &struct {
+			in2: &struct {
 				S string `blueprint:"mutated"`
 			}{
 				S: "string2",
@@ -1229,13 +1012,13 @@
 			},
 		},
 		{
-			name: "Filter mutated",
-			dst: &struct {
+			// Filter mutated
+			in1: &struct {
 				S *int64 `blueprint:"mutated"`
 			}{
 				S: Int64Ptr(4),
 			},
-			src: &struct {
+			in2: &struct {
 				S *int64 `blueprint:"mutated"`
 			}{
 				S: Int64Ptr(5),
@@ -1247,11 +1030,11 @@
 			},
 		},
 		{
-			name: "Filter error",
-			dst: &struct{ S string }{
+			// Filter error
+			in1: &struct{ S string }{
 				S: "string1",
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: &struct{ S string }{
@@ -1269,71 +1052,68 @@
 
 func TestAppendProperties(t *testing.T) {
 	for _, testCase := range appendPropertiesTestCases() {
-		t.Run(testCase.name, func(t *testing.T) {
+		testString := fmt.Sprintf("%v, %v -> %v", testCase.in1, testCase.in2, testCase.out)
 
-			got := testCase.dst
-			var err error
-			var testType string
+		got := testCase.in1
+		var err error
+		var testType string
 
-			switch testCase.order {
-			case Append:
-				testType = "append"
-				err = AppendProperties(got, testCase.src, testCase.filter)
-			case Prepend:
-				testType = "prepend"
-				err = PrependProperties(got, testCase.src, testCase.filter)
-			case Replace:
-				testType = "replace"
-				err = ExtendProperties(got, testCase.src, testCase.filter, OrderReplace)
-			}
+		switch testCase.order {
+		case Append:
+			testType = "append"
+			err = AppendProperties(got, testCase.in2, testCase.filter)
+		case Prepend:
+			testType = "prepend"
+			err = PrependProperties(got, testCase.in2, testCase.filter)
+		case Replace:
+			testType = "replace"
+			err = ExtendProperties(got, testCase.in2, testCase.filter, OrderReplace)
+		}
 
-			check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
-		})
+		check(t, testType, testString, got, err, testCase.out, testCase.err)
 	}
 }
 
 func TestExtendProperties(t *testing.T) {
 	for _, testCase := range appendPropertiesTestCases() {
-		t.Run(testCase.name, func(t *testing.T) {
+		testString := fmt.Sprintf("%v, %v -> %v", testCase.in1, testCase.in2, testCase.out)
 
-			got := testCase.dst
-			var err error
-			var testType string
+		got := testCase.in1
+		var err error
+		var testType string
 
-			order := func(property string,
-				dstField, srcField reflect.StructField,
-				dstValue, srcValue interface{}) (Order, error) {
-				switch testCase.order {
-				case Append:
-					return Append, nil
-				case Prepend:
-					return Prepend, nil
-				case Replace:
-					return Replace, nil
-				}
-				return Append, errors.New("unknown order")
-			}
-
+		order := func(property string,
+			dstField, srcField reflect.StructField,
+			dstValue, srcValue interface{}) (Order, error) {
 			switch testCase.order {
 			case Append:
-				testType = "prepend"
+				return Append, nil
 			case Prepend:
-				testType = "append"
+				return Prepend, nil
 			case Replace:
-				testType = "replace"
+				return Replace, nil
 			}
+			return Append, errors.New("unknown order")
+		}
 
-			err = ExtendProperties(got, testCase.src, testCase.filter, order)
+		switch testCase.order {
+		case Append:
+			testType = "prepend"
+		case Prepend:
+			testType = "append"
+		case Replace:
+			testType = "replace"
+		}
 
-			check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
-		})
+		err = ExtendProperties(got, testCase.in2, testCase.filter, order)
+
+		check(t, testType, testString, got, err, testCase.out, testCase.err)
 	}
 }
 
 type appendMatchingPropertiesTestCase struct {
-	name   string
-	dst    []interface{}
-	src    interface{}
+	in1    []interface{}
+	in2    interface{}
 	out    []interface{}
 	order  Order // default is Append
 	filter ExtendPropertyFilterFunc
@@ -1343,11 +1123,11 @@
 func appendMatchingPropertiesTestCases() []appendMatchingPropertiesTestCase {
 	return []appendMatchingPropertiesTestCase{
 		{
-			name: "Append strings",
-			dst: []interface{}{&struct{ S string }{
+			// Append strings
+			in1: []interface{}{&struct{ S string }{
 				S: "string1",
 			}},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: []interface{}{&struct{ S string }{
@@ -1355,11 +1135,11 @@
 			}},
 		},
 		{
-			name: "Prepend strings",
-			dst: []interface{}{&struct{ S string }{
+			// Prepend strings
+			in1: []interface{}{&struct{ S string }{
 				S: "string1",
 			}},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: []interface{}{&struct{ S string }{
@@ -1368,8 +1148,8 @@
 			order: Prepend,
 		},
 		{
-			name: "Append all",
-			dst: []interface{}{
+			// Append all
+			in1: []interface{}{
 				&struct{ S, A string }{
 					S: "string1",
 				},
@@ -1377,7 +1157,7 @@
 					S: "string2",
 				},
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string3",
 			},
 			out: []interface{}{
@@ -1390,14 +1170,14 @@
 			},
 		},
 		{
-			name: "Append some",
-			dst: []interface{}{
+			// Append some
+			in1: []interface{}{
 				&struct{ S, A string }{
 					S: "string1",
 				},
 				&struct{ B string }{},
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: []interface{}{
@@ -1408,11 +1188,11 @@
 			},
 		},
 		{
-			name: "Append mismatched structs",
-			dst: []interface{}{&struct{ S, A string }{
+			// Append mismatched structs
+			in1: []interface{}{&struct{ S, A string }{
 				S: "string1",
 			}},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string2",
 			},
 			out: []interface{}{&struct{ S, A string }{
@@ -1420,13 +1200,13 @@
 			}},
 		},
 		{
-			name: "Append mismatched pointer structs",
-			dst: []interface{}{&struct{ S *struct{ S, A string } }{
+			// Append mismatched pointer structs
+			in1: []interface{}{&struct{ S *struct{ S, A string } }{
 				S: &struct{ S, A string }{
 					S: "string1",
 				},
 			}},
-			src: &struct{ S *struct{ S string } }{
+			in2: &struct{ S *struct{ S string } }{
 				S: &struct{ S string }{
 					S: "string2",
 				},
@@ -1438,8 +1218,8 @@
 			}},
 		},
 		{
-			name: "Append through mismatched types",
-			dst: []interface{}{
+			// Append through mismatched types
+			in1: []interface{}{
 				&struct{ B string }{},
 				&struct{ S interface{} }{
 					S: &struct{ S, A string }{
@@ -1447,7 +1227,7 @@
 					},
 				},
 			},
-			src: &struct{ S struct{ S string } }{
+			in2: &struct{ S struct{ S string } }{
 				S: struct{ S string }{
 					S: "string2",
 				},
@@ -1462,14 +1242,14 @@
 			},
 		},
 		{
-			name: "Append through mismatched types and nil",
-			dst: []interface{}{
+			// Append through mismatched types and nil
+			in1: []interface{}{
 				&struct{ B string }{},
 				&struct{ S interface{} }{
 					S: (*struct{ S, A string })(nil),
 				},
 			},
-			src: &struct{ S struct{ S string } }{
+			in2: &struct{ S struct{ S string } }{
 				S: struct{ S string }{
 					S: "string2",
 				},
@@ -1484,8 +1264,8 @@
 			},
 		},
 		{
-			name: "Append through multiple matches",
-			dst: []interface{}{
+			// Append through multiple matches
+			in1: []interface{}{
 				&struct {
 					S struct{ S, A string }
 				}{
@@ -1501,7 +1281,7 @@
 					},
 				},
 			},
-			src: &struct{ S struct{ B string } }{
+			in2: &struct{ S struct{ B string } }{
 				S: struct{ B string }{
 					B: "string3",
 				},
@@ -1524,168 +1304,44 @@
 				},
 			},
 		},
-		{
-			name: "Append through embedded struct",
-			dst: []interface{}{
-				&struct{ B string }{},
-				&struct{ EmbeddedStruct }{
-					EmbeddedStruct: EmbeddedStruct{
-						S: "string1",
-					},
-				},
-			},
-			src: &struct{ S string }{
-				S: "string2",
-			},
-			out: []interface{}{
-				&struct{ B string }{},
-				&struct{ EmbeddedStruct }{
-					EmbeddedStruct: EmbeddedStruct{
-						S: "string1string2",
-					},
-				},
-			},
-		},
-		{
-			name: "Append through BlueprintEmbed struct",
-			dst: []interface{}{
-				&struct{ B string }{},
-				&struct{ BlueprintEmbed EmbeddedStruct }{
-					BlueprintEmbed: EmbeddedStruct{
-						S: "string1",
-					},
-				},
-			},
-			src: &struct{ S string }{
-				S: "string2",
-			},
-			out: []interface{}{
-				&struct{ B string }{},
-				&struct{ BlueprintEmbed EmbeddedStruct }{
-					BlueprintEmbed: EmbeddedStruct{
-						S: "string1string2",
-					},
-				},
-			},
-		},
-		{
-			name: "Append through embedded pointer to struct",
-			dst: []interface{}{
-				&struct{ B string }{},
-				&struct{ *EmbeddedStruct }{
-					EmbeddedStruct: &EmbeddedStruct{
-						S: "string1",
-					},
-				},
-			},
-			src: &struct{ S string }{
-				S: "string2",
-			},
-			out: []interface{}{
-				&struct{ B string }{},
-				&struct{ *EmbeddedStruct }{
-					EmbeddedStruct: &EmbeddedStruct{
-						S: "string1string2",
-					},
-				},
-			},
-		},
-		{
-			name: "Append through BlueprintEmbed pointer to struct",
-			dst: []interface{}{
-				&struct{ B string }{},
-				&struct{ BlueprintEmbed *EmbeddedStruct }{
-					BlueprintEmbed: &EmbeddedStruct{
-						S: "string1",
-					},
-				},
-			},
-			src: &struct{ S string }{
-				S: "string2",
-			},
-			out: []interface{}{
-				&struct{ B string }{},
-				&struct{ BlueprintEmbed *EmbeddedStruct }{
-					BlueprintEmbed: &EmbeddedStruct{
-						S: "string1string2",
-					},
-				},
-			},
-		},
-		{
-			name: "Append through embedded nil pointer to struct",
-			dst: []interface{}{
-				&struct{ B string }{},
-				&struct{ *EmbeddedStruct }{},
-			},
-			src: &struct{ S string }{
-				S: "string2",
-			},
-			out: []interface{}{
-				&struct{ B string }{},
-				&struct{ *EmbeddedStruct }{
-					EmbeddedStruct: &EmbeddedStruct{
-						S: "string2",
-					},
-				},
-			},
-		},
-		{
-			name: "Append through BlueprintEmbed nil pointer to struct",
-			dst: []interface{}{
-				&struct{ B string }{},
-				&struct{ BlueprintEmbed *EmbeddedStruct }{},
-			},
-			src: &struct{ S string }{
-				S: "string2",
-			},
-			out: []interface{}{
-				&struct{ B string }{},
-				&struct{ BlueprintEmbed *EmbeddedStruct }{
-					BlueprintEmbed: &EmbeddedStruct{
-						S: "string2",
-					},
-				},
-			},
-		},
 
 		// Errors
 
 		{
-			name: "Non-pointer dst",
-			dst:  []interface{}{struct{}{}},
-			src:  &struct{}{},
-			err:  errors.New("expected pointer to struct, got struct {}"),
-			out:  []interface{}{struct{}{}},
+			// Non-pointer in1
+			in1: []interface{}{struct{}{}},
+			in2: &struct{}{},
+			err: errors.New("expected pointer to struct, got struct {}"),
+			out: []interface{}{struct{}{}},
 		},
 		{
-			name: "Non-pointer src",
-			dst:  []interface{}{&struct{}{}},
-			src:  struct{}{},
-			err:  errors.New("expected pointer to struct, got struct {}"),
-			out:  []interface{}{&struct{}{}},
+			// Non-pointer in2
+			in1: []interface{}{&struct{}{}},
+			in2: struct{}{},
+			err: errors.New("expected pointer to struct, got struct {}"),
+			out: []interface{}{&struct{}{}},
 		},
 		{
-			name: "Non-struct dst",
-			dst:  []interface{}{&[]string{"bad"}},
-			src:  &struct{}{},
-			err:  errors.New("expected pointer to struct, got *[]string"),
-			out:  []interface{}{&[]string{"bad"}},
+			// Non-struct in1
+			in1: []interface{}{&[]string{"bad"}},
+			in2: &struct{}{},
+			err: errors.New("expected pointer to struct, got *[]string"),
+			out: []interface{}{&[]string{"bad"}},
 		},
 		{
-			name: "Non-struct src",
-			dst:  []interface{}{&struct{}{}},
-			src:  &[]string{"bad"},
-			err:  errors.New("expected pointer to struct, got *[]string"),
-			out:  []interface{}{&struct{}{}},
+			// Non-struct in2
+			in1: []interface{}{&struct{}{}},
+			in2: &[]string{"bad"},
+			err: errors.New("expected pointer to struct, got *[]string"),
+			out: []interface{}{&struct{}{}},
 		},
 		{
-			name: "Append none",
-			dst: []interface{}{
+			// Append none
+			in1: []interface{}{
 				&struct{ A string }{},
 				&struct{ B string }{},
 			},
-			src: &struct{ S string }{
+			in2: &struct{ S string }{
 				S: "string1",
 			},
 			out: []interface{}{
@@ -1695,13 +1351,13 @@
 			err: extendPropertyErrorf("s", "failed to find property to extend"),
 		},
 		{
-			name: "Append mismatched kinds",
-			dst: []interface{}{
+			// Append mismatched kinds
+			in1: []interface{}{
 				&struct{ S string }{
 					S: "string1",
 				},
 			},
-			src: &struct{ S []string }{
+			in2: &struct{ S []string }{
 				S: []string{"string2"},
 			},
 			out: []interface{}{
@@ -1712,13 +1368,13 @@
 			err: extendPropertyErrorf("s", "mismatched types string and []string"),
 		},
 		{
-			name: "Append mismatched types",
-			dst: []interface{}{
+			// Append mismatched types
+			in1: []interface{}{
 				&struct{ S []int }{
 					S: []int{1},
 				},
 			},
-			src: &struct{ S []string }{
+			in2: &struct{ S []string }{
 				S: []string{"string2"},
 			},
 			out: []interface{}{
@@ -1733,64 +1389,62 @@
 
 func TestAppendMatchingProperties(t *testing.T) {
 	for _, testCase := range appendMatchingPropertiesTestCases() {
-		t.Run(testCase.name, func(t *testing.T) {
+		testString := fmt.Sprintf("%s, %s -> %s", p(testCase.in1), p(testCase.in2), p(testCase.out))
 
-			got := testCase.dst
-			var err error
-			var testType string
+		got := testCase.in1
+		var err error
+		var testType string
 
-			switch testCase.order {
-			case Append:
-				testType = "append"
-				err = AppendMatchingProperties(got, testCase.src, testCase.filter)
-			case Prepend:
-				testType = "prepend"
-				err = PrependMatchingProperties(got, testCase.src, testCase.filter)
-			case Replace:
-				testType = "replace"
-				err = ExtendMatchingProperties(got, testCase.src, testCase.filter, OrderReplace)
-			}
+		switch testCase.order {
+		case Append:
+			testType = "append"
+			err = AppendMatchingProperties(got, testCase.in2, testCase.filter)
+		case Prepend:
+			testType = "prepend"
+			err = PrependMatchingProperties(got, testCase.in2, testCase.filter)
+		case Replace:
+			testType = "replace"
+			err = ExtendMatchingProperties(got, testCase.in2, testCase.filter, OrderReplace)
+		}
 
-			check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
-		})
+		check(t, testType, testString, got, err, testCase.out, testCase.err)
 	}
 }
 
 func TestExtendMatchingProperties(t *testing.T) {
 	for _, testCase := range appendMatchingPropertiesTestCases() {
-		t.Run(testCase.name, func(t *testing.T) {
+		testString := fmt.Sprintf("%s, %s -> %s", p(testCase.in1), p(testCase.in2), p(testCase.out))
 
-			got := testCase.dst
-			var err error
-			var testType string
+		got := testCase.in1
+		var err error
+		var testType string
 
-			order := func(property string,
-				dstField, srcField reflect.StructField,
-				dstValue, srcValue interface{}) (Order, error) {
-				switch testCase.order {
-				case Append:
-					return Append, nil
-				case Prepend:
-					return Prepend, nil
-				case Replace:
-					return Replace, nil
-				}
-				return Append, errors.New("unknown order")
-			}
-
+		order := func(property string,
+			dstField, srcField reflect.StructField,
+			dstValue, srcValue interface{}) (Order, error) {
 			switch testCase.order {
 			case Append:
-				testType = "prepend matching"
+				return Append, nil
 			case Prepend:
-				testType = "append matching"
+				return Prepend, nil
 			case Replace:
-				testType = "replace matching"
+				return Replace, nil
 			}
+			return Append, errors.New("unknown order")
+		}
 
-			err = ExtendMatchingProperties(got, testCase.src, testCase.filter, order)
+		switch testCase.order {
+		case Append:
+			testType = "prepend matching"
+		case Prepend:
+			testType = "append matching"
+		case Replace:
+			testType = "replace matching"
+		}
 
-			check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
-		})
+		err = ExtendMatchingProperties(got, testCase.in2, testCase.filter, order)
+
+		check(t, testType, testString, got, err, testCase.out, testCase.err)
 	}
 }
 
diff --git a/proptools/proptools.go b/proptools/proptools.go
index 6946d7e..1da3ba4 100644
--- a/proptools/proptools.go
+++ b/proptools/proptools.go
@@ -129,7 +129,3 @@
 func isSliceOfStruct(t reflect.Type) bool {
 	return isSlice(t) && isStruct(t.Elem())
 }
-
-func isMapOfStruct(t reflect.Type) bool {
-	return t.Kind() == reflect.Map && isStruct(t.Elem())
-}
diff --git a/proptools/tag.go b/proptools/tag.go
index 801fa3b..b078894 100644
--- a/proptools/tag.go
+++ b/proptools/tag.go
@@ -57,7 +57,7 @@
 		field := t.Field(i)
 		ft := field.Type
 		if isStruct(ft) || isStructPtr(ft) || isSliceOfStruct(ft) {
-			if ft.Kind() == reflect.Ptr || ft.Kind() == reflect.Slice || ft.Kind() == reflect.Map {
+			if ft.Kind() == reflect.Ptr || ft.Kind() == reflect.Slice {
 				ft = ft.Elem()
 			}
 			subIndexes := propertyIndexesWithTag(ft, key, value)
diff --git a/proptools/unpack.go b/proptools/unpack.go
index 28a68b5..f6d9e95 100644
--- a/proptools/unpack.go
+++ b/proptools/unpack.go
@@ -27,12 +27,6 @@
 
 const maxUnpackErrors = 10
 
-var (
-	// Hard-coded list of allowlisted property names of type map. This is to limit use of maps to
-	// where absolutely necessary.
-	validMapProperties = []string{}
-)
-
 type UnpackError struct {
 	Err error
 	Pos scanner.Position
@@ -51,9 +45,8 @@
 // unpackContext keeps compound names and their values in a map. It is initialized from
 // parsed properties.
 type unpackContext struct {
-	propertyMap        map[string]*packedProperty
-	validMapProperties map[string]bool
-	errs               []error
+	propertyMap map[string]*packedProperty
+	errs        []error
 }
 
 // UnpackProperties populates the list of runtime values ("property structs") from the parsed properties.
@@ -74,19 +67,11 @@
 // The same property can initialize fields in multiple runtime values. It is an error if any property
 // value was not used to initialize at least one field.
 func UnpackProperties(properties []*parser.Property, objects ...interface{}) (map[string]*parser.Property, []error) {
-	return unpackProperties(properties, validMapProperties, objects...)
-}
-
-func unpackProperties(properties []*parser.Property, validMapProps []string, objects ...interface{}) (map[string]*parser.Property, []error) {
 	var unpackContext unpackContext
 	unpackContext.propertyMap = make(map[string]*packedProperty)
 	if !unpackContext.buildPropertyMap("", properties) {
 		return nil, unpackContext.errs
 	}
-	unpackContext.validMapProperties = make(map[string]bool, len(validMapProps))
-	for _, p := range validMapProps {
-		unpackContext.validMapProperties[p] = true
-	}
 
 	for _, obj := range objects {
 		valueObject := reflect.ValueOf(obj)
@@ -153,33 +138,7 @@
 		ctx.propertyMap[name] = &packedProperty{property, false}
 		switch propValue := property.Value.Eval().(type) {
 		case *parser.Map:
-			// If this is a map and the values are not primitive types, we need to unroll it for further
-			// mapping. Keys are limited to string types.
 			ctx.buildPropertyMap(name, propValue.Properties)
-			if len(propValue.MapItems) == 0 {
-				continue
-			}
-			items := propValue.MapItems
-			keysType := items[0].Key.Type()
-			valsAreBasic := primitiveType(items[0].Value.Type())
-			if keysType != parser.StringType {
-				ctx.addError(&UnpackError{Err: fmt.Errorf("complex key types are unsupported: %s", keysType)})
-				return false
-			} else if valsAreBasic {
-				continue
-			}
-			itemProperties := make([]*parser.Property, len(items), len(items))
-			for i, item := range items {
-				itemProperties[i] = &parser.Property{
-					Name:     fmt.Sprintf("%s{value:%d}", property.Name, i),
-					NamePos:  property.NamePos,
-					ColonPos: property.ColonPos,
-					Value:    item.Value,
-				}
-			}
-			if !ctx.buildPropertyMap(prefix, itemProperties) {
-				return false
-			}
 		case *parser.List:
 			// If it is a list, unroll it unless its elements are of primitive type
 			// (no further mapping will be needed in that case, so we avoid cluttering
@@ -187,7 +146,7 @@
 			if len(propValue.Values) == 0 {
 				continue
 			}
-			if primitiveType(propValue.Values[0].Type()) {
+			if t := propValue.Values[0].Type(); t == parser.StringType || t == parser.Int64Type || t == parser.BoolType {
 				continue
 			}
 
@@ -209,11 +168,6 @@
 	return len(ctx.errs) == nOldErrors
 }
 
-// primitiveType returns whether typ is a primitive type
-func primitiveType(typ parser.Type) bool {
-	return typ == parser.StringType || typ == parser.Int64Type || typ == parser.BoolType
-}
-
 func fieldPath(prefix, fieldName string) string {
 	if prefix == "" {
 		return fieldName
@@ -265,15 +219,6 @@
 		switch kind := fieldValue.Kind(); kind {
 		case reflect.Bool, reflect.String, reflect.Struct, reflect.Slice:
 			// Do nothing
-		case reflect.Map:
-			// Restrict names of map properties that _can_ be set in bp files
-			if _, ok := ctx.validMapProperties[propertyName]; !ok {
-				if !HasTag(field, "blueprint", "mutated") {
-					ctx.addError(&UnpackError{
-						Err: fmt.Errorf("Uses of maps for properties must be allowlisted. %q is an unsupported use case", propertyName),
-					})
-				}
-			}
 		case reflect.Interface:
 			if fieldValue.IsNil() {
 				panic(fmt.Errorf("field %s contains a nil interface", propertyName))
@@ -354,13 +299,6 @@
 			if len(ctx.errs) >= maxUnpackErrors {
 				return
 			}
-		} else if fieldValue.Type().Kind() == reflect.Map {
-			if unpackedValue, ok := ctx.unpackToMap(propertyName, property, fieldValue.Type()); ok {
-				ExtendBasicType(fieldValue, unpackedValue, Append)
-			}
-			if len(ctx.errs) >= maxUnpackErrors {
-				return
-			}
 
 		} else {
 			unpackedValue, err := propertyToValue(fieldValue.Type(), property)
@@ -372,61 +310,6 @@
 	}
 }
 
-// unpackToMap unpacks given parser.property into a go map of type mapType
-func (ctx *unpackContext) unpackToMap(mapName string, property *parser.Property, mapType reflect.Type) (reflect.Value, bool) {
-	propValueAsMap, ok := property.Value.Eval().(*parser.Map)
-	// Verify this property is a map
-	if !ok {
-		ctx.addError(&UnpackError{
-			fmt.Errorf("can't assign %q value to map property %q", property.Value.Type(), property.Name),
-			property.Value.Pos(),
-		})
-		return reflect.MakeMap(mapType), false
-	}
-	// And is not a struct
-	if len(propValueAsMap.Properties) > 0 {
-		ctx.addError(&UnpackError{
-			fmt.Errorf("can't assign property to a map (%s) property %q", property.Value.Type(), property.Name),
-			property.Value.Pos(),
-		})
-		return reflect.MakeMap(mapType), false
-	}
-
-	items := propValueAsMap.MapItems
-	m := reflect.MakeMap(mapType)
-	if len(items) == 0 {
-		return m, true
-	}
-	keyConstructor := ctx.itemConstructor(items[0].Key.Type())
-	keyType := mapType.Key()
-	valueConstructor := ctx.itemConstructor(items[0].Value.Type())
-	valueType := mapType.Elem()
-
-	itemProperty := &parser.Property{NamePos: property.NamePos, ColonPos: property.ColonPos}
-	for i, item := range items {
-		itemProperty.Name = fmt.Sprintf("%s{key:%d}", mapName, i)
-		itemProperty.Value = item.Key
-		if packedProperty, ok := ctx.propertyMap[itemProperty.Name]; ok {
-			packedProperty.used = true
-		}
-		keyValue, ok := itemValue(keyConstructor, itemProperty, keyType)
-		if !ok {
-			continue
-		}
-		itemProperty.Name = fmt.Sprintf("%s{value:%d}", mapName, i)
-		itemProperty.Value = item.Value
-		if packedProperty, ok := ctx.propertyMap[itemProperty.Name]; ok {
-			packedProperty.used = true
-		}
-		value, ok := itemValue(valueConstructor, itemProperty, valueType)
-		if ok {
-			m.SetMapIndex(keyValue, value)
-		}
-	}
-
-	return m, true
-}
-
 // unpackSlice creates a value of a given slice type from the property which should be a list
 func (ctx *unpackContext) unpackToSlice(
 	sliceName string, property *parser.Property, sliceType reflect.Type) (reflect.Value, bool) {
@@ -445,50 +328,11 @@
 		return value, true
 	}
 
-	itemConstructor := ctx.itemConstructor(exprs[0].Type())
-	itemType := sliceType.Elem()
-
-	itemProperty := &parser.Property{NamePos: property.NamePos, ColonPos: property.ColonPos}
-	for i, expr := range exprs {
-		itemProperty.Name = sliceName + "[" + strconv.Itoa(i) + "]"
-		itemProperty.Value = expr
-		if packedProperty, ok := ctx.propertyMap[itemProperty.Name]; ok {
-			packedProperty.used = true
-		}
-		if itemValue, ok := itemValue(itemConstructor, itemProperty, itemType); ok {
-			value = reflect.Append(value, itemValue)
-		}
-	}
-	return value, true
-}
-
-// constructItem is a function to construct a reflect.Value from given parser.Property of reflect.Type
-type constructItem func(*parser.Property, reflect.Type) (reflect.Value, bool)
-
-// itemValue creates a new item of type t with value determined by f
-func itemValue(f constructItem, property *parser.Property, t reflect.Type) (reflect.Value, bool) {
-	isPtr := t.Kind() == reflect.Ptr
-	if isPtr {
-		t = t.Elem()
-	}
-	val, ok := f(property, t)
-	if !ok {
-		return val, ok
-	}
-	if isPtr {
-		ptrValue := reflect.New(val.Type())
-		ptrValue.Elem().Set(val)
-		return ptrValue, true
-	}
-	return val, true
-}
-
-// itemConstructor returns a function  to construct an item of typ
-func (ctx *unpackContext) itemConstructor(typ parser.Type) constructItem {
 	// The function to construct an item value depends on the type of list elements.
-	switch typ {
+	var getItemFunc func(*parser.Property, reflect.Type) (reflect.Value, bool)
+	switch exprs[0].Type() {
 	case parser.BoolType, parser.StringType, parser.Int64Type:
-		return func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
+		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			value, err := propertyToValue(t, property)
 			if err != nil {
 				ctx.addError(err)
@@ -497,26 +341,46 @@
 			return value, true
 		}
 	case parser.ListType:
-		return func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
+		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			return ctx.unpackToSlice(property.Name, property, t)
 		}
 	case parser.MapType:
-		return func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
-			if t.Kind() == reflect.Map {
-				return ctx.unpackToMap(property.Name, property, t)
-			} else {
-				itemValue := reflect.New(t).Elem()
-				ctx.unpackToStruct(property.Name, itemValue)
-				return itemValue, true
-			}
+		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
+			itemValue := reflect.New(t).Elem()
+			ctx.unpackToStruct(property.Name, itemValue)
+			return itemValue, true
 		}
 	case parser.NotEvaluatedType:
-		return func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
+		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			return reflect.New(t), false
 		}
 	default:
-		panic(fmt.Errorf("bizarre property expression type: %v", typ))
+		panic(fmt.Errorf("bizarre property expression type: %v", exprs[0].Type()))
 	}
+
+	itemProperty := &parser.Property{NamePos: property.NamePos, ColonPos: property.ColonPos}
+	elemType := sliceType.Elem()
+	isPtr := elemType.Kind() == reflect.Ptr
+
+	for i, expr := range exprs {
+		itemProperty.Name = sliceName + "[" + strconv.Itoa(i) + "]"
+		itemProperty.Value = expr
+		if packedProperty, ok := ctx.propertyMap[itemProperty.Name]; ok {
+			packedProperty.used = true
+		}
+		if isPtr {
+			if itemValue, ok := getItemFunc(itemProperty, elemType.Elem()); ok {
+				ptrValue := reflect.New(itemValue.Type())
+				ptrValue.Elem().Set(itemValue)
+				value = reflect.Append(value, ptrValue)
+			}
+		} else {
+			if itemValue, ok := getItemFunc(itemProperty, elemType); ok {
+				value = reflect.Append(value, itemValue)
+			}
+		}
+	}
+	return value, true
 }
 
 // propertyToValue creates a value of a given value type from the property.
diff --git a/proptools/unpack_test.go b/proptools/unpack_test.go
index 5c6e3d0..7e2751d 100644
--- a/proptools/unpack_test.go
+++ b/proptools/unpack_test.go
@@ -129,82 +129,6 @@
 	},
 
 	{
-		name: "map",
-		input: `
-			m {
-				stuff: { "asdf": "jkl;", "qwert": "uiop"},
-				empty: {},
-				nested: {
-					other_stuff: {},
-				},
-			}
-		`,
-		output: []interface{}{
-			&struct {
-				Stuff     map[string]string
-				Empty     map[string]string
-				Nil       map[string]string
-				NonString map[string]struct{ S string } `blueprint:"mutated"`
-				Nested    struct {
-					Other_stuff map[string]string
-				}
-			}{
-				Stuff:     map[string]string{"asdf": "jkl;", "qwert": "uiop"},
-				Empty:     map[string]string{},
-				Nil:       nil,
-				NonString: nil,
-				Nested: struct{ Other_stuff map[string]string }{
-					Other_stuff: map[string]string{},
-				},
-			},
-		},
-	},
-
-	{
-		name: "map with slice",
-		input: `
-			m {
-				stuff: { "asdf": ["jkl;"], "qwert": []},
-				empty: {},
-			}
-		`,
-		output: []interface{}{
-			&struct {
-				Stuff     map[string][]string
-				Empty     map[string][]string
-				Nil       map[string][]string
-				NonString map[string]struct{ S string } `blueprint:"mutated"`
-			}{
-				Stuff:     map[string][]string{"asdf": []string{"jkl;"}, "qwert": []string{}},
-				Empty:     map[string][]string{},
-				Nil:       nil,
-				NonString: nil,
-			},
-		},
-	},
-
-	{
-		name: "map with struct",
-		input: `
-			m {
-				stuff: { "asdf": {s:"a"}},
-				empty: {},
-			}
-		`,
-		output: []interface{}{
-			&struct {
-				Stuff map[string]struct{ S string }
-				Empty map[string]struct{ S string }
-				Nil   map[string]struct{ S string }
-			}{
-				Stuff: map[string]struct{ S string }{"asdf": struct{ S string }{"a"}},
-				Empty: map[string]struct{ S string }{},
-				Nil:   nil,
-			},
-		},
-	},
-
-	{
 		name: "double nested",
 		input: `
 			m {
@@ -831,7 +755,7 @@
 					}
 				}
 
-				_, errs = unpackProperties(module.Properties, []string{"stuff", "empty", "nil", "nested.other_stuff"}, output...)
+				_, 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:")
@@ -1038,37 +962,6 @@
 				`<input>:3:16: can't assign string value to list property "map_list"`,
 			},
 		},
-		{
-			name: "invalid use of maps",
-			input: `
-				m {
-					map: {"foo": "bar"},
-				}
-			`,
-			output: []interface{}{
-				&struct {
-					Map map[string]string
-				}{},
-			},
-			errors: []string{
-				`<input>: Uses of maps for properties must be allowlisted. "map" is an unsupported use case`,
-			},
-		},
-		{
-			name: "invalid use of maps, not used in bp file",
-			input: `
-				m {
-				}
-			`,
-			output: []interface{}{
-				&struct {
-					Map map[string]string
-				}{},
-			},
-			errors: []string{
-				`<input>: Uses of maps for properties must be allowlisted. "map" is an unsupported use case`,
-			},
-		},
 	}
 
 	for _, testCase := range testCases {
diff --git a/provider_test.go b/provider_test.go
index 942dd31..8f8def4 100644
--- a/provider_test.go
+++ b/provider_test.go
@@ -110,7 +110,7 @@
 	ctx.RegisterBottomUpMutator("provider_after_mutator", providerTestAfterMutator)
 
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			provider_module {
 				name: "A",
 				deps: ["B"],
@@ -132,7 +132,7 @@
 		`),
 	})
 
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) == 0 {
 		_, errs = ctx.ResolveDependencies(nil)
 	}
@@ -322,10 +322,10 @@
 			childBP)
 
 		ctx.MockFileSystem(map[string][]byte{
-			"Android.bp": []byte(bp),
+			"Blueprints": []byte(bp),
 		})
 
-		_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+		_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 
 		if len(errs) == 0 {
 			_, errs = ctx.ResolveDependencies(nil)
diff --git a/singleton_ctx.go b/singleton_ctx.go
index 455f6fc..a4e7153 100644
--- a/singleton_ctx.go
+++ b/singleton_ctx.go
@@ -82,10 +82,10 @@
 	// RequireNinjaVersion sets the generated ninja manifest to require at least the specified version of ninja.
 	RequireNinjaVersion(major, minor, micro int)
 
-	// SetOutDir sets the value of the top-level "builddir" Ninja variable
+	// SetNinjaBuildDir sets the value of the top-level "builddir" Ninja variable
 	// that controls where Ninja stores its build log files.  This value can be
 	// set at most one time for a single build, later calls are ignored.
-	SetOutDir(pctx PackageContext, value string)
+	SetNinjaBuildDir(pctx PackageContext, value string)
 
 	// AddSubninja adds a ninja file to include with subninja. This should likely
 	// only ever be used inside bootstrap to handle glob rules.
@@ -289,7 +289,7 @@
 	s.context.requireNinjaVersion(major, minor, micro)
 }
 
-func (s *singletonContext) SetOutDir(pctx PackageContext, value string) {
+func (s *singletonContext) SetNinjaBuildDir(pctx PackageContext, value string) {
 	s.scope.ReparentTo(pctx)
 
 	ninjaValue, err := parseNinjaString(s.scope, value)
@@ -297,7 +297,7 @@
 		panic(err)
 	}
 
-	s.context.setOutDir(ninjaValue)
+	s.context.setNinjaBuildDir(ninjaValue)
 }
 
 func (s *singletonContext) AddSubninja(file string) {
diff --git a/visit_test.go b/visit_test.go
index 798e289..1c74b93 100644
--- a/visit_test.go
+++ b/visit_test.go
@@ -93,7 +93,7 @@
 	ctx.RegisterTopDownMutator("visit", visitMutator)
 
 	ctx.MockFileSystem(map[string][]byte{
-		"Android.bp": []byte(`
+		"Blueprints": []byte(`
 			visit_module {
 				name: "A",
 				visit: ["B"],
@@ -125,7 +125,7 @@
 		`),
 	})
 
-	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {