diff --git a/.travis.yml b/.travis.yml
index 6abd686..c39ad38 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,6 @@
 language: go
 
 go:
-    - 1.9
     - "1.10"
     - "1.11"
     - "1.12"
diff --git a/Blueprints b/Blueprints
index 35e4190..d58169e 100644
--- a/Blueprints
+++ b/Blueprints
@@ -125,6 +125,8 @@
         "bootstrap/bpdoc/reader.go",
     ],
     testSrcs: [
+        "bootstrap/bpdoc/bpdoc_test.go",
+        "bootstrap/bpdoc/properties_test.go",
         "bootstrap/bpdoc/reader_test.go",
     ],
 }
diff --git a/bootstrap/bootstrap.go b/bootstrap/bootstrap.go
index 3464c0b..c5d4899 100644
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -130,6 +130,7 @@
 			Deps:        blueprint.DepsGCC,
 			Depfile:     "$out.d",
 			Restat:      true,
+			Pool:        blueprint.Console,
 		},
 		"builder", "extra", "generator", "globFile")
 
diff --git a/bootstrap/bpdoc/bpdoc.go b/bootstrap/bpdoc/bpdoc.go
index 8ce41cf..4acfc5d 100644
--- a/bootstrap/bpdoc/bpdoc.go
+++ b/bootstrap/bpdoc/bpdoc.go
@@ -173,6 +173,9 @@
 				// The field is not exported so just skip it.
 				continue
 			}
+			if proptools.HasTag(field, "blueprint", "mutated") {
+				continue
+			}
 
 			fieldValue := structValue.Field(i)
 
diff --git a/bootstrap/bpdoc/bpdoc_test.go b/bootstrap/bpdoc/bpdoc_test.go
new file mode 100644
index 0000000..687d97b
--- /dev/null
+++ b/bootstrap/bpdoc/bpdoc_test.go
@@ -0,0 +1,46 @@
+package bpdoc
+
+import (
+	"reflect"
+	"testing"
+)
+
+type parentProps struct {
+	A string
+
+	Child *childProps
+
+	Mutated *mutatedProps `blueprint:"mutated"`
+}
+
+type childProps struct {
+	B int
+
+	Child *grandchildProps
+}
+
+type grandchildProps struct {
+	C bool
+}
+
+type mutatedProps struct {
+	D int
+}
+
+func TestNestedPropertyStructs(t *testing.T) {
+	parent := parentProps{Child: &childProps{Child: &grandchildProps{}}, Mutated: &mutatedProps{}}
+
+	allStructs := nestedPropertyStructs(reflect.ValueOf(parent))
+
+	// mutated shouldn't be found because it's a mutated property.
+	expected := []string{"child", "child.child"}
+	if len(allStructs) != len(expected) {
+		t.Errorf("expected %d structs, got %d, all entries: %q",
+			len(expected), len(allStructs), allStructs)
+	}
+	for _, e := range expected {
+		if _, ok := allStructs[e]; !ok {
+			t.Errorf("missing entry %q, all entries: %q", e, allStructs)
+		}
+	}
+}
diff --git a/bootstrap/bpdoc/properties.go b/bootstrap/bpdoc/properties.go
index 23b1ffd..9256d8e 100644
--- a/bootstrap/bpdoc/properties.go
+++ b/bootstrap/bpdoc/properties.go
@@ -250,17 +250,23 @@
 	// len(props) times to this slice will overwrite the original slice contents
 	filtered := (*props)[:0]
 	for _, x := range *props {
-		tag := x.Tag.Get(key)
-		for _, entry := range strings.Split(tag, ",") {
-			if (entry == value) == !exclude {
-				filtered = append(filtered, x)
-			}
+		if hasTag(x.Tag, key, value) == !exclude {
+			filtered = append(filtered, x)
 		}
 	}
 
 	*props = filtered
 }
 
+func hasTag(tag reflect.StructTag, key, value string) bool {
+	for _, entry := range strings.Split(tag.Get(key), ",") {
+		if entry == value {
+			return true
+		}
+	}
+	return false
+}
+
 func formatText(text string) template.HTML {
 	var html template.HTML
 	lines := strings.Split(text, "\n")
diff --git a/bootstrap/bpdoc/properties_test.go b/bootstrap/bpdoc/properties_test.go
new file mode 100644
index 0000000..4045cb1
--- /dev/null
+++ b/bootstrap/bpdoc/properties_test.go
@@ -0,0 +1,58 @@
+// Copyright 2019 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 bpdoc
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestExcludeByTag(t *testing.T) {
+	r := NewReader(pkgFiles)
+	ps, err := r.PropertyStruct(pkgPath, "tagTestProps", reflect.ValueOf(tagTestProps{}))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ps.ExcludeByTag("tag1", "a")
+
+	expected := []string{"c"}
+	actual := []string{}
+	for _, p := range ps.Properties {
+		actual = append(actual, p.Name)
+	}
+	if !reflect.DeepEqual(expected, actual) {
+		t.Errorf("unexpected ExcludeByTag result, expected: %q, actual: %q", expected, actual)
+	}
+}
+
+func TestIncludeByTag(t *testing.T) {
+	r := NewReader(pkgFiles)
+	ps, err := r.PropertyStruct(pkgPath, "tagTestProps", reflect.ValueOf(tagTestProps{A: "B"}))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ps.IncludeByTag("tag1", "c")
+
+	expected := []string{"b", "c"}
+	actual := []string{}
+	for _, p := range ps.Properties {
+		actual = append(actual, p.Name)
+	}
+	if !reflect.DeepEqual(expected, actual) {
+		t.Errorf("unexpected IncludeByTag result, expected: %q, actual: %q", expected, actual)
+	}
+}
diff --git a/bootstrap/bpdoc/reader_test.go b/bootstrap/bpdoc/reader_test.go
index b8ff109..0d608b3 100644
--- a/bootstrap/bpdoc/reader_test.go
+++ b/bootstrap/bpdoc/reader_test.go
@@ -34,6 +34,13 @@
 	A string
 }
 
+// for properties_test.go
+type tagTestProps struct {
+	A string `tag1:"a,b" tag2:"c"`
+	B string `tag1:"a,c"`
+	C string `tag1:"b,c"`
+}
+
 var pkgPath string
 var pkgFiles map[string][]string
 
diff --git a/bootstrap/bpglob/bpglob.go b/bootstrap/bpglob/bpglob.go
index 1097760..fe47b6f 100644
--- a/bootstrap/bpglob/bpglob.go
+++ b/bootstrap/bpglob/bpglob.go
@@ -21,7 +21,9 @@
 import (
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"os"
+	"time"
 
 	"github.com/google/blueprint/pathtools"
 )
@@ -71,7 +73,15 @@
 
 	_, err := pathtools.GlobWithDepFile(flag.Arg(0), *out, *out+".d", excludes)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "error: %s\n", err.Error())
-		os.Exit(1)
+		// Globs here were already run in the primary builder without error.  The only errors here should be if the glob
+		// pattern was made invalid by a change in the pathtools glob implementation, in which case the primary builder
+		// needs to be rerun anyways.  Update the output file with something that will always cause the primary builder
+		// to rerun.
+		s := fmt.Sprintf("%s: error: %s\n", time.Now().Format(time.StampNano), err.Error())
+		err := ioutil.WriteFile(*out, []byte(s), 0666)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error: %s\n", err.Error())
+			os.Exit(1)
+		}
 	}
 }
diff --git a/bpfmt/bpfmt.go b/bpfmt/bpfmt.go
index 17fe513..c287ea2 100644
--- a/bpfmt/bpfmt.go
+++ b/bpfmt/bpfmt.go
@@ -125,6 +125,7 @@
 }
 
 func main() {
+	flag.Usage = usage
 	flag.Parse()
 
 	if !*writeToStout && !*overwriteSourceFile && !*doDiff && !*list {
@@ -135,8 +136,7 @@
 		// file to parse is stdin
 		if *overwriteSourceFile {
 			fmt.Fprintln(os.Stderr, "error: cannot use -w with standard input")
-			exitCode = 2
-			return
+			os.Exit(2)
 		}
 		if err := processReader("<standard input>", os.Stdin, os.Stdout); err != nil {
 			report(err)
@@ -157,6 +157,8 @@
 			}
 		}
 	}
+
+	os.Exit(exitCode)
 }
 
 func diff(b1, b2 []byte) (data []byte, err error) {
diff --git a/context.go b/context.go
index 324d1ec..6a61861 100644
--- a/context.go
+++ b/context.go
@@ -173,6 +173,7 @@
 	relBlueprintsFile string
 	pos               scanner.Position
 	propertyPos       map[string]scanner.Position
+	createdBy         *moduleInfo
 
 	variantName       string
 	variant           variationMap
@@ -183,12 +184,13 @@
 	properties  []interface{}
 
 	// set during ResolveDependencies
-	directDeps  []depInfo
-	missingDeps []string
+	missingDeps   []string
+	newDirectDeps []depInfo
 
 	// set during updateDependencies
 	reverseDeps []*moduleInfo
 	forwardDeps []*moduleInfo
+	directDeps  []depInfo
 
 	// used by parallelVisitAllBottomUp
 	waitingCount int
@@ -214,6 +216,10 @@
 	if module.variantName != "" {
 		s += fmt.Sprintf(" variant %q", module.variantName)
 	}
+	if module.createdBy != nil {
+		s += fmt.Sprintf(" (created by %s)", module.createdBy)
+	}
+
 	return s
 }
 
@@ -1427,7 +1433,7 @@
 	}
 
 	if m := c.findMatchingVariant(module, possibleDeps); m != nil {
-		module.directDeps = append(module.directDeps, depInfo{m, tag})
+		module.newDirectDeps = append(module.newDirectDeps, depInfo{m, tag})
 		atomic.AddUint32(&c.depsModified, 1)
 		return nil
 	}
@@ -1530,7 +1536,7 @@
 					Pos: module.pos,
 				}}
 			}
-			module.directDeps = append(module.directDeps, depInfo{m, tag})
+			module.newDirectDeps = append(module.newDirectDeps, depInfo{m, tag})
 			atomic.AddUint32(&c.depsModified, 1)
 			return nil
 		}
@@ -1575,7 +1581,7 @@
 			origModule.Name()))
 	}
 
-	fromInfo.directDeps = append(fromInfo.directDeps, depInfo{toInfo, tag})
+	fromInfo.newDirectDeps = append(fromInfo.newDirectDeps, depInfo{toInfo, tag})
 	atomic.AddUint32(&c.depsModified, 1)
 }
 
@@ -2149,9 +2155,18 @@
 					module.directDeps[j].module = dep.module.splitModules[0]
 				}
 			}
+
+			if module.createdBy != nil && module.createdBy.logicModule == nil {
+				module.createdBy = module.createdBy.splitModules[0]
+			}
+
+			// Add in any new direct dependencies that were added by the mutator
+			module.directDeps = append(module.directDeps, module.newDirectDeps...)
+			module.newDirectDeps = nil
 		}
 	}
 
+	// Add in any new reverse dependencies that were added by the mutator
 	for module, deps := range reverseDeps {
 		sort.Sort(depSorter(deps))
 		module.directDeps = append(module.directDeps, deps...)
diff --git a/doc.go b/doc.go
index f489bfd..4a9dfd7 100644
--- a/doc.go
+++ b/doc.go
@@ -14,7 +14,7 @@
 
 // Blueprint is a meta-build system that reads in Blueprints files that describe
 // modules that need to be built, and produces a Ninja
-// (http://martine.github.io/ninja/) manifest describing the commands that need
+// (https://ninja-build.org/) manifest describing the commands that need
 // to be run and their dependencies.  Where most build systems use built-in
 // rules or a domain-specific language to describe the logic how modules are
 // converted to build rules, Blueprint delegates this to per-project build logic
diff --git a/module_ctx.go b/module_ctx.go
index d127c0e..37079ad 100644
--- a/module_ctx.go
+++ b/module_ctx.go
@@ -121,15 +121,39 @@
 }
 
 type BaseModuleContext interface {
+	// Module returns the current module as a Module.  It should rarely be necessary, as the module already has a
+	// reference to itself.
+	Module() Module
+
+	// ModuleName returns the name of the module.  This is generally the value that was returned by Module.Name() when
+	// 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 defintion of the module.
 	ModuleDir() string
+
+	// ModuleType returns the name of the module type that was used to create the module, as specified in
+	// RegisterModuleType.
 	ModuleType() string
+
+	// Config returns the config object that was passed to Context.PrepareBuildActions.
 	Config() interface{}
 
+	// ContainsProperty returns true if the specified property name was set in the module definition.
 	ContainsProperty(name string) bool
+
+	// Errorf reports an error at the specified position of the module definition file.
 	Errorf(pos scanner.Position, fmt string, args ...interface{})
+
+	// ModuleErrorf reports an error at the line number of the module type in the module definition.
 	ModuleErrorf(fmt string, args ...interface{})
+
+	// PropertyErrorf reports an error at the line number of a property in the module definition.
 	PropertyErrorf(property, fmt string, args ...interface{})
+
+	// Failed returns true if any errors have been reported.  In most cases the module can continue with generating
+	// build rules after an error, allowing it to report additional errors in a single run, but in cases where the error
+	// has prevented the module from creating necessary data it can return early when Failed returns true.
 	Failed() bool
 
 	// GlobWithDeps returns a list of files and directories that match the
@@ -140,13 +164,103 @@
 	// does not match the pattern is added to a searched directory.
 	GlobWithDeps(pattern string, excludes []string) ([]string, error)
 
+	// Fs returns a pathtools.Filesystem that can be used to interact with files.  Using the Filesystem interface allows
+	// the module to be used in build system tests that run against a mock filesystem.
 	Fs() pathtools.FileSystem
+
+	// AddNinjaFileDeps adds dependencies on the specified files to the rule that creates the ninja manifest.  The
+	// primary builder will be rerun whenever the specified files are modified.
 	AddNinjaFileDeps(deps ...string)
 
 	moduleInfo() *moduleInfo
 	error(err error)
 
+	// Namespace returns the Namespace object provided by the NameInterface set by Context.SetNameInterface, or the
+	// default SimpleNameInterface if Context.SetNameInterface was not called.
 	Namespace() Namespace
+
+	// GetDirectDepWithTag returns the Module the direct dependency with the specified name, or nil if
+	// none exists.  It panics if the dependency does not have the specified tag.
+	GetDirectDepWithTag(name string, tag DependencyTag) Module
+
+	// GetDirectDep returns the Module and DependencyTag for the  direct dependency with the specified
+	// name, or nil if none exists.  If there are multiple dependencies on the same module it returns
+	// the first DependencyTag.
+	GetDirectDep(name string) (Module, DependencyTag)
+
+	// VisitDirectDeps calls visit for each direct dependency.  If there are multiple direct dependencies on the same
+	// module visit will be called multiple times on that module and OtherModuleDependencyTag will return a different
+	// tag for each.
+	//
+	// The Module passed to the visit function should not be retained outside of the visit function, it may be
+	// invalidated by future mutators.
+	VisitDirectDeps(visit func(Module))
+
+	// VisitDirectDepsIf calls pred for each direct dependency, and if pred returns true calls visit.  If there are
+	// multiple direct dependencies on the same module pred and visit will be called multiple times on that module and
+	// OtherModuleDependencyTag will return a different tag for each.
+	//
+	// The Module passed to the visit function should not be retained outside of the visit function, it may be
+	// invalidated by future mutators.
+	VisitDirectDepsIf(pred func(Module) bool, visit func(Module))
+
+	// VisitDepsDepthFirst calls visit for each transitive dependency, 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 Module passed to the visit function should not be retained outside of the visit function, it may be
+	// invalidated by future mutators.
+	VisitDepsDepthFirst(visit func(Module))
+
+	// 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
+	// does not affect which branches of the tree are traversed.
+	//
+	// The Module passed to the visit function should not be retained outside of the visit function, it may be
+	// invalidated by future mutators.
+	VisitDepsDepthFirstIf(pred func(Module) bool, visit func(Module))
+
+	// WalkDeps calls visit for each transitive dependency, traversing the dependency tree in top down order.  visit may
+	// be called multiple times for the same (child, parent) pair if there are multiple direct dependencies between the
+	// child and parent with different tags.  OtherModuleDependencyTag will return the tag for the currently visited
+	// (child, parent) pair.  If visit returns false WalkDeps will not continue recursing down to child.
+	//
+	// The Modules passed to the visit function should not be retained outside of the visit function, they may be
+	// invalidated by future mutators.
+	WalkDeps(visit func(Module, Module) bool)
+
+	// OtherModuleName returns the name of another Module.  See BaseModuleContext.ModuleName for more information.
+	// It is intended for use inside the visit functions of Visit* and WalkDeps.
+	OtherModuleName(m Module) string
+
+	// OtherModuleDir returns the directory of another Module.  See BaseModuleContext.ModuleDir for more information.
+	// It is intended for use inside the visit functions of Visit* and WalkDeps.
+	OtherModuleDir(m Module) string
+
+	// OtherModuleSubDir returns the unique subdirectory name of another Module.  See ModuleContext.ModuleSubDir for
+	// more information.
+	// It is intended for use inside the visit functions of Visit* and WalkDeps.
+	OtherModuleSubDir(m Module) string
+
+	// OtherModuleType returns the type of another Module.  See BaseModuleContext.ModuleType for more information.
+	// It is intended for use inside the visit functions of Visit* and WalkDeps.
+	OtherModuleType(m Module) string
+
+	// OtherModuleErrorf reports an error on another Module.  See BaseModuleContext.ModuleErrorf for more information.
+	// It is intended for use inside the visit functions of Visit* and WalkDeps.
+	OtherModuleErrorf(m Module, fmt string, args ...interface{})
+
+	// OtherModuleDependencyTag returns the dependency tag used to depend on a module, or nil if there is no dependency
+	// on the module.  When called inside a Visit* method with current module being visited, and there are multiple
+	// dependencies on the module being visited, it returns the dependency tag used for the current dependency.
+	OtherModuleDependencyTag(m Module) DependencyTag
+
+	// OtherModuleExists returns true if a module with the specified name exists, as determined by the NameInterface
+	// passed to Context.SetNameInterface, or SimpleNameInterface if it was not called.
+	OtherModuleExists(name string) bool
 }
 
 type DynamicDependerModuleContext BottomUpMutatorContext
@@ -154,32 +268,41 @@
 type ModuleContext interface {
 	BaseModuleContext
 
-	OtherModuleName(m Module) string
-	OtherModuleDir(m Module) string
-	OtherModuleSubDir(m Module) string
-	OtherModuleType(m Module) string
-	OtherModuleErrorf(m Module, fmt string, args ...interface{})
-	OtherModuleDependencyTag(m Module) DependencyTag
-
-	GetDirectDepWithTag(name string, tag DependencyTag) Module
-	GetDirectDep(name string) (Module, DependencyTag)
-
-	VisitDirectDeps(visit func(Module))
-	VisitDirectDepsIf(pred func(Module) bool, visit func(Module))
-	VisitDepsDepthFirst(visit func(Module))
-	VisitDepsDepthFirstIf(pred func(Module) bool, visit func(Module))
-	WalkDeps(visit func(child, parent Module) bool)
-
+	// ModuleSubDir returns a unique name for the current variant of a module that can be used as part of the path
+	// to ensure that each variant of a module gets its own intermediates directory to write to.
 	ModuleSubDir() string
 
+	// Variable creates a new ninja variable scoped to the module.  It can be referenced by calls to Rule and Build
+	// in the same module.
 	Variable(pctx PackageContext, name, value string)
+
+	// Rule creates a new ninja rule scoped to the module.  It can be referenced by calls to Build in the same module.
 	Rule(pctx PackageContext, name string, params RuleParams, argNames ...string) Rule
+
+	// Build creates a new ninja build statement.
 	Build(pctx PackageContext, params BuildParams)
 
+	// PrimaryModule returns the first variant of the current module.  Variants of a module are always visited in
+	// order by mutators and GenerateBuildActions, so the data created by the current mutator can be read from the
+	// Module returned by PrimaryModule without data races.  This can be used to perform singleton actions that are
+	// only done once for all variants of a module.
 	PrimaryModule() Module
+
+	// FinalModule returns the last variant of the current module.  Variants of a module are always visited in
+	// order by mutators and GenerateBuildActions, so the data created by the current mutator can be read from all
+	// variants using VisitAllModuleVariants if the current module == FinalModule().  This can be used to perform
+	// singleton actions that are only done once for all variants of a module.
 	FinalModule() Module
+
+	// VisitAllModuleVariants calls visit for each variant of the current module.  Variants of a module are always
+	// visited in order by mutators and GenerateBuildActions, so the data created by the current mutator can be read
+	// from all variants if the current module == FinalModule().  Otherwise, care must be taken to not access any
+	// data modified by the current mutator.
 	VisitAllModuleVariants(visit func(Module))
 
+	// GetMissingDependencies returns the list of dependencies that were passed to AddDependencies or related methods,
+	// but do not exist.  It can be used with Context.SetAllowMissingDependencies to allow the primary builder to
+	// handle missing dependencies on its own instead of having Blueprint treat them as an error.
 	GetMissingDependencies() []string
 }
 
@@ -199,6 +322,10 @@
 	return d.module
 }
 
+func (d *baseModuleContext) Module() Module {
+	return d.module.logicModule
+}
+
 func (d *baseModuleContext) ModuleName() string {
 	return d.module.Name()
 }
@@ -327,9 +454,6 @@
 	})
 }
 
-// OtherModuleDependencyTag returns the dependency tag used to depend on a module, or nil if there is no dependency
-// on the module.  When called inside a Visit* method with current module being visited, and there are multiple
-// dependencies on the module being visited, it returns the dependency tag used for the current dependency.
 func (m *baseModuleContext) OtherModuleDependencyTag(logicModule Module) DependencyTag {
 	// fast path for calling OtherModuleDependencyTag from inside VisitDirectDeps
 	if logicModule == m.visitingDep.module.logicModule {
@@ -345,9 +469,11 @@
 	return nil
 }
 
-// GetDirectDep returns the Module and DependencyTag for the  direct dependency with the specified
-// name, or nil if none exists.  If there are multiple dependencies on the same module it returns
-// the first DependencyTag.
+func (m *baseModuleContext) OtherModuleExists(name string) bool {
+	_, exists := m.context.nameInterface.ModuleFromName(name, m.module.namespace())
+	return exists
+}
+
 func (m *baseModuleContext) GetDirectDep(name string) (Module, DependencyTag) {
 	for _, dep := range m.module.directDeps {
 		if dep.module.Name() == name {
@@ -358,8 +484,6 @@
 	return nil, nil
 }
 
-// GetDirectDepWithTag returns the Module the direct dependency with the specified name, or nil if
-// none exists.  It panics if the dependency does not have the specified tag.
 func (m *baseModuleContext) GetDirectDepWithTag(name string, tag DependencyTag) Module {
 	var deps []depInfo
 	for _, dep := range m.module.directDeps {
@@ -378,8 +502,6 @@
 	return nil
 }
 
-// VisitDirectDeps calls visit for each direct dependency.  If there are multiple direct dependencies on the same module
-// visit will be called multiple times on that module and OtherModuleDependencyTag will return a different tag for each.
 func (m *baseModuleContext) VisitDirectDeps(visit func(Module)) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -399,9 +521,6 @@
 	m.visitingDep = depInfo{}
 }
 
-// VisitDirectDepsIf calls pred for each direct dependency, and if pred returns true calls visit.  If there are multiple
-// direct dependencies on the same module pred and visit will be called multiple times on that module and
-// OtherModuleDependencyTag will return a different tag for each.
 func (m *baseModuleContext) VisitDirectDepsIf(pred func(Module) bool, visit func(Module)) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -423,10 +542,6 @@
 	m.visitingDep = depInfo{}
 }
 
-// VisitDepsDepthFirst calls visit for each transitive dependency, 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.
 func (m *baseModuleContext) VisitDepsDepthFirst(visit func(Module)) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -445,11 +560,6 @@
 	m.visitingDep = depInfo{}
 }
 
-// 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 does
-// not affect which branches of the tree are traversed.
 func (m *baseModuleContext) VisitDepsDepthFirstIf(pred func(Module) bool,
 	visit func(Module)) {
 
@@ -472,10 +582,6 @@
 	m.visitingDep = depInfo{}
 }
 
-// WalkDeps calls visit for each transitive dependency, traversing the dependency tree in top down order.  visit may be
-// called multiple times for the same (child, parent) pair if there are multiple direct dependencies between the
-// child and parent with different tags.  OtherModuleDependencyTag will return the tag for the currently visited
-// (child, parent) pair.  If visit returns false WalkDeps will not continue recursing down to child.
 func (m *baseModuleContext) WalkDeps(visit func(child, parent Module) bool) {
 	m.context.walkDeps(m.module, true, func(dep depInfo, parent *moduleInfo) bool {
 		m.visitingParent = parent
@@ -563,54 +669,116 @@
 	newModules    []*moduleInfo // brand new modules
 }
 
-type baseMutatorContext interface {
+type BaseMutatorContext interface {
 	BaseModuleContext
 
-	OtherModuleExists(name string) bool
+	// Rename all variants of a module.  The new name is not visible to calls to ModuleName,
+	// AddDependency or OtherModuleName until after this mutator pass is complete.
 	Rename(name string)
-	Module() Module
+
+	// MutatorName returns the name that this mutator was registered with.
+	MutatorName() string
 }
 
 type EarlyMutatorContext interface {
-	baseMutatorContext
+	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
+	BaseMutatorContext
 
-	OtherModuleName(m Module) string
-	OtherModuleDir(m Module) string
-	OtherModuleSubDir(m Module) string
-	OtherModuleType(m Module) string
-	OtherModuleErrorf(m Module, fmt string, args ...interface{})
-	OtherModuleDependencyTag(m Module) DependencyTag
-
+	// 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, ...interface{})
-
-	GetDirectDepWithTag(name string, tag DependencyTag) Module
-	GetDirectDep(name string) (Module, DependencyTag)
-
-	VisitDirectDeps(visit func(Module))
-	VisitDirectDepsIf(pred func(Module) bool, visit func(Module))
-	VisitDepsDepthFirst(visit func(Module))
-	VisitDepsDepthFirstIf(pred func(Module) bool, visit func(Module))
-	WalkDeps(visit func(Module, Module) bool)
 }
 
 type BottomUpMutatorContext interface {
-	baseMutatorContext
+	BaseMutatorContext
 
+	// AddDependency adds a dependency to the given module.
+	// Does not affect the ordering of the current mutator pass, but will be ordered
+	// correctly for all future mutator passes.
 	AddDependency(module Module, tag DependencyTag, name ...string)
+
+	// AddReverseDependency adds a dependency from the destination to the given module.
+	// Does not affect the ordering of the current mutator pass, but will be ordered
+	// correctly for all future mutator passes.  All reverse dependencies for a destination module are
+	// collected until the end of the mutator pass, sorted by name, and then appended to the destination
+	// module's dependency list.
 	AddReverseDependency(module Module, tag DependencyTag, name string)
+
+	// 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
+
+	// SetDependencyVariation sets all dangling dependencies on the current module to point to the variation
+	// with given name.
 	SetDependencyVariation(string)
+
+	// AddVariationDependencies adds deps as dependencies of the current module, but uses the variations
+	// argument to select which variant of the dependency to use.  A variant of the dependency must
+	// exist that matches the all of the non-local variations of the current module, plus the variations
+	// argument.
 	AddVariationDependencies([]Variation, DependencyTag, ...string)
+
+	// AddFarVariationDependencies adds deps as dependencies of the current module, but uses the
+	// variations argument to select which variant of the dependency to use.  A variant of the
+	// dependency must exist that matches the variations argument, but may also have other variations.
+	// For any unspecified variation the first variant will be used.
+	//
+	// Unlike AddVariationDependencies, the variations of the current module are ignored - the
+	// dependency only needs to match the supplied variations.
 	AddFarVariationDependencies([]Variation, DependencyTag, ...string)
+
+	// AddInterVariantDependency adds a dependency between two variants of the same module.  Variants are always
+	// ordered in the same orderas they were listed in CreateVariations, and AddInterVariantDependency does not change
+	// that ordering, but it associates a DependencyTag with the dependency and makes it visible to VisitDirectDeps,
+	// WalkDeps, etc.
 	AddInterVariantDependency(tag DependencyTag, from, to Module)
+
+	// ReplaceDependencies replaces all dependencies on the identical variant of the module with the
+	// specified name with the current variant of this module.  Replacements don't take effect until
+	// after the mutator pass is finished.
 	ReplaceDependencies(string)
 }
 
@@ -643,28 +811,14 @@
 
 var _ DependencyTag = BaseDependencyTag{}
 
-// Split 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.
+func (mctx *mutatorContext) MutatorName() string {
+	return mctx.name
+}
+
 func (mctx *mutatorContext) CreateVariations(variationNames ...string) []Module {
 	return mctx.createVariations(variationNames, false)
 }
 
-// Split 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.
 func (mctx *mutatorContext) CreateLocalVariations(variationNames ...string) []Module {
 	return mctx.createVariations(variationNames, true)
 }
@@ -695,8 +849,6 @@
 	return ret
 }
 
-// Set all dangling dependencies on the current module to point to the variation
-// with given name.
 func (mctx *mutatorContext) SetDependencyVariation(variationName string) {
 	mctx.context.convertDepsToVariation(mctx.module, mctx.name, variationName)
 }
@@ -705,9 +857,6 @@
 	return mctx.module.logicModule
 }
 
-// Add a dependency to the given module.
-// Does not affect the ordering of the current mutator pass, but will be ordered
-// correctly for all future mutator passes.
 func (mctx *mutatorContext) AddDependency(module Module, tag DependencyTag, deps ...string) {
 	for _, dep := range deps {
 		modInfo := mctx.context.moduleInfo[module]
@@ -718,11 +867,6 @@
 	}
 }
 
-// Add a dependency from the destination to the given module.
-// Does not affect the ordering of the current mutator pass, but will be ordered
-// correctly for all future mutator passes.  All reverse dependencies for a destination module are
-// collected until the end of the mutator pass, sorted by name, and then appended to the destination
-// module's dependency list.
 func (mctx *mutatorContext) AddReverseDependency(module Module, tag DependencyTag, destName string) {
 	if _, ok := tag.(BaseDependencyTag); ok {
 		panic("BaseDependencyTag is not allowed to be used directly!")
@@ -740,10 +884,6 @@
 	})
 }
 
-// AddVariationDependencies adds deps as dependencies of the current module, but uses the variations
-// argument to select which variant of the dependency to use.  A variant of the dependency must
-// exist that matches the all of the non-local variations of the current module, plus the variations
-// argument.
 func (mctx *mutatorContext) AddVariationDependencies(variations []Variation, tag DependencyTag,
 	deps ...string) {
 
@@ -755,13 +895,6 @@
 	}
 }
 
-// AddFarVariationDependencies adds deps as dependencies of the current module, but uses the
-// variations argument to select which variant of the dependency to use.  A variant of the
-// dependency must exist that matches the variations argument, but may also have other variations.
-// For any unspecified variation the first variant will be used.
-//
-// Unlike AddVariationDependencies, the variations of the current module are ignored - the
-// depdendency only needs to match the supplied variations.
 func (mctx *mutatorContext) AddFarVariationDependencies(variations []Variation, tag DependencyTag,
 	deps ...string) {
 
@@ -777,9 +910,6 @@
 	mctx.context.addInterVariantDependency(mctx.module, tag, from, to)
 }
 
-// ReplaceDependencies replaces all dependencies on the identical variant of the module with the
-// specified name with the current variant of this module.  Replacements don't take effect until
-// after the mutator pass is finished.
 func (mctx *mutatorContext) ReplaceDependencies(name string) {
 	target := mctx.context.moduleMatchingVariant(mctx.module, name)
 
@@ -791,24 +921,17 @@
 	mctx.replace = append(mctx.replace, replace{target, mctx.module})
 }
 
-func (mctx *mutatorContext) OtherModuleExists(name string) bool {
-	_, exists := mctx.context.nameInterface.ModuleFromName(name, mctx.module.namespace())
-	return exists
-}
-
-// Rename all variants of a module.  The new name is not visible to calls to ModuleName,
-// AddDependency or OtherModuleName until after this mutator pass is complete.
 func (mctx *mutatorContext) Rename(name string) {
 	mctx.rename = append(mctx.rename, rename{mctx.module.group, name})
 }
 
-// Create a new module by calling the factory method for the specified moduleType, and apply
-// the specified property structs to it as if the properties were set in a blueprint file.
 func (mctx *mutatorContext) CreateModule(factory ModuleFactory, props ...interface{}) {
 	module := mctx.context.newModule(factory)
 
 	module.relBlueprintsFile = mctx.module.relBlueprintsFile
 	module.pos = mctx.module.pos
+	module.propertyPos = mctx.module.propertyPos
+	module.createdBy = mctx.module
 
 	for _, p := range props {
 		err := proptools.AppendMatchingProperties(module.properties, p, nil)
diff --git a/ninja_strings.go b/ninja_strings.go
index a13205f..5b8767d 100644
--- a/ninja_strings.go
+++ b/ninja_strings.go
@@ -277,12 +277,20 @@
 func (n *ninjaString) ValueWithEscaper(pkgNames map[*packageContext]string,
 	escaper *strings.Replacer) string {
 
-	str := escaper.Replace(n.strings[0])
-	for i, v := range n.variables {
-		str += "${" + v.fullName(pkgNames) + "}"
-		str += escaper.Replace(n.strings[i+1])
+	if len(n.strings) == 1 {
+		return escaper.Replace(n.strings[0])
 	}
-	return str
+
+	str := strings.Builder{}
+	str.WriteString(escaper.Replace(n.strings[0]))
+	for i, v := range n.variables {
+		str.WriteString("${")
+		str.WriteString(v.fullName(pkgNames))
+		str.WriteString("}")
+		str.WriteString(escaper.Replace(n.strings[i+1]))
+	}
+
+	return str.String()
 }
 
 func (n *ninjaString) Eval(variables map[Variable]*ninjaString) (string, error) {
diff --git a/ninja_strings_test.go b/ninja_strings_test.go
index 6227ea6..0e0de64 100644
--- a/ninja_strings_test.go
+++ b/ninja_strings_test.go
@@ -16,6 +16,8 @@
 
 import (
 	"reflect"
+	"strconv"
+	"strings"
 	"testing"
 )
 
@@ -161,3 +163,45 @@
 		t.Errorf("       got: %#v", output)
 	}
 }
+
+func BenchmarkNinjaString_Value(b *testing.B) {
+	b.Run("constant", func(b *testing.B) {
+		for _, l := range []int{1, 10, 100, 1000} {
+			ns := simpleNinjaString(strings.Repeat("a", l))
+			b.Run(strconv.Itoa(l), func(b *testing.B) {
+				for n := 0; n < b.N; n++ {
+					ns.Value(nil)
+				}
+			})
+		}
+	})
+	b.Run("variable", func(b *testing.B) {
+		for _, l := range []int{1, 10, 100, 1000} {
+			scope := newLocalScope(nil, "")
+			scope.AddLocalVariable("a", strings.Repeat("b", l/3))
+			ns, _ := parseNinjaString(scope, strings.Repeat("a", l/3)+"${a}"+strings.Repeat("a", l/3))
+			b.Run(strconv.Itoa(l), func(b *testing.B) {
+				for n := 0; n < b.N; n++ {
+					ns.Value(nil)
+				}
+			})
+		}
+	})
+	b.Run("variables", func(b *testing.B) {
+		for _, l := range []int{1, 2, 3, 4, 5, 10, 100, 1000} {
+			scope := newLocalScope(nil, "")
+			str := strings.Repeat("a", 10)
+			for i := 0; i < l; i++ {
+				scope.AddLocalVariable("a"+strconv.Itoa(i), strings.Repeat("b", 10))
+				str += "${a" + strconv.Itoa(i) + "}"
+			}
+			ns, _ := parseNinjaString(scope, str)
+			b.Run(strconv.Itoa(l), func(b *testing.B) {
+				for n := 0; n < b.N; n++ {
+					ns.Value(nil)
+				}
+			})
+		}
+	})
+
+}
diff --git a/pathtools/fs.go b/pathtools/fs.go
index 4217487..8329392 100644
--- a/pathtools/fs.go
+++ b/pathtools/fs.go
@@ -61,6 +61,9 @@
 		fs.dirs[dir] = true
 	}
 
+	fs.dirs["."] = true
+	fs.dirs["/"] = true
+
 	for f := range fs.files {
 		fs.all = append(fs.all, f)
 	}
@@ -330,8 +333,8 @@
 			if err != nil {
 				return nil, err
 			}
-			if f == "." && f != pattern {
-				// filepath.Glob won't return "." unless the pattern was "."
+			if (f == "." || f == "/") && f != pattern {
+				// filepath.Glob won't return "." or "/" unless the pattern was "." or "/"
 				match = false
 			}
 			if match {
diff --git a/pathtools/glob.go b/pathtools/glob.go
index 67394d2..727b725 100644
--- a/pathtools/glob.go
+++ b/pathtools/glob.go
@@ -25,8 +25,9 @@
 	"github.com/google/blueprint/deptools"
 )
 
-var GlobMultipleRecursiveErr = errors.New("pattern contains multiple **")
-var GlobLastRecursiveErr = errors.New("pattern ** as last path element")
+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")
 
 // Glob returns the list of files and directories that match the given pattern
 // but do not match the given exclude patterns, along with the list of
@@ -118,7 +119,7 @@
 			// as a dependency.
 			var matchDirs []string
 			for len(matchDirs) == 0 {
-				pattern, _ = saneSplit(pattern)
+				pattern = filepath.Dir(pattern)
 				matchDirs, err = fs.glob(pattern)
 				if err != nil {
 					return matches, dirs, err
@@ -136,6 +137,8 @@
 			return matches, dirs, GlobMultipleRecursiveErr
 		}
 		hasRecursive = true
+	} else if strings.Contains(file, "**") {
+		return matches, dirs, GlobInvalidRecursiveErr
 	}
 
 	dirMatches, dirs, err := glob(fs, dir, hasRecursive, follow)
@@ -242,7 +245,7 @@
 }
 
 // Match returns true if name matches pattern using the same rules as filepath.Match, but supporting
-// hierarchical patterns (a/*) and recursive globs (**).
+// recursive globs (**).
 func Match(pattern, name string) (bool, error) {
 	if filepath.Base(pattern) == "**" {
 		return false, GlobLastRecursiveErr
@@ -262,16 +265,35 @@
 
 	for {
 		var patternFile, nameFile string
-		pattern, patternFile = saneSplit(pattern)
-		name, nameFile = saneSplit(name)
+		pattern, patternFile = filepath.Dir(pattern), filepath.Base(pattern)
 
 		if patternFile == "**" {
-			return matchPrefix(pattern, filepath.Join(name, nameFile))
+			if strings.Contains(pattern, "**") {
+				return false, GlobMultipleRecursiveErr
+			}
+			// Test if the any prefix of name matches the part of the pattern before **
+			for {
+				if name == "." || name == "/" {
+					return name == pattern, nil
+				}
+				if match, err := filepath.Match(pattern, name); err != nil {
+					return false, err
+				} else if match {
+					return true, nil
+				}
+				name = filepath.Dir(name)
+			}
+		} else if strings.Contains(patternFile, "**") {
+			return false, GlobInvalidRecursiveErr
 		}
 
-		if nameFile == "" && patternFile == "" {
+		name, nameFile = filepath.Dir(name), filepath.Base(name)
+
+		if nameFile == "." && patternFile == "." {
 			return true, nil
-		} else if nameFile == "" || patternFile == "" {
+		} else if nameFile == "/" && patternFile == "/" {
+			return true, nil
+		} else if nameFile == "." || patternFile == "." || nameFile == "/" || patternFile == "/" {
 			return false, nil
 		}
 
@@ -282,56 +304,6 @@
 	}
 }
 
-// matchPrefix returns true if the beginning of name matches pattern using the same rules as
-// filepath.Match, but supporting hierarchical patterns (a/*).  Recursive globs (**) are not
-// supported, they should have been handled in Match().
-func matchPrefix(pattern, name string) (bool, error) {
-	if len(pattern) > 0 && pattern[0] == '/' {
-		if len(name) > 0 && name[0] == '/' {
-			pattern = pattern[1:]
-			name = name[1:]
-		} else {
-			return false, nil
-		}
-	}
-
-	for {
-		var patternElem, nameElem string
-		patternElem, pattern = saneSplitFirst(pattern)
-		nameElem, name = saneSplitFirst(name)
-
-		if patternElem == "." {
-			patternElem = ""
-		}
-		if nameElem == "." {
-			nameElem = ""
-		}
-
-		if patternElem == "**" {
-			return false, GlobMultipleRecursiveErr
-		}
-
-		if patternElem == "" {
-			return true, nil
-		} else if nameElem == "" {
-			return false, nil
-		}
-
-		match, err := filepath.Match(patternElem, nameElem)
-		if err != nil || !match {
-			return match, err
-		}
-	}
-}
-
-func saneSplitFirst(path string) (string, string) {
-	i := strings.IndexRune(path, filepath.Separator)
-	if i < 0 {
-		return path, ""
-	}
-	return path[:i], path[i+1:]
-}
-
 func GlobPatternList(patterns []string, prefix string) (globedList []string, depDirs []string, err error) {
 	var (
 		matches []string
diff --git a/pathtools/glob_test.go b/pathtools/glob_test.go
index 0265df6..a3a36ff 100644
--- a/pathtools/glob_test.go
+++ b/pathtools/glob_test.go
@@ -18,6 +18,7 @@
 	"os"
 	"path/filepath"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -215,6 +216,14 @@
 		pattern: "**/**",
 		err:     GlobLastRecursiveErr,
 	},
+	{
+		pattern: "a**/",
+		err:     GlobInvalidRecursiveErr,
+	},
+	{
+		pattern: "**a/",
+		err:     GlobInvalidRecursiveErr,
+	},
 
 	// exclude tests
 	{
@@ -778,6 +787,16 @@
 		{"a/**/*/", "a/b/", true},
 		{"a/**/*/", "a/b/c", false},
 
+		{"**/*", "a/", false},
+		{"**/*", "a/a", true},
+		{"**/*", "a/b/", false},
+		{"**/*", "a/b/c", true},
+
+		{"**/*/", "a/", true},
+		{"**/*/", "a/a", false},
+		{"**/*/", "a/b/", true},
+		{"**/*/", "a/b/c", false},
+
 		{`a/\*\*/\*`, `a/**/*`, true},
 		{`a/\*\*/\*`, `a/a/*`, false},
 		{`a/\*\*/\*`, `a/**/a`, false},
@@ -826,6 +845,38 @@
 		{`a/?`, `a/a`, true},
 		{`a/\?`, `a/?`, true},
 		{`a/\?`, `a/a`, false},
+
+		{"/a/*", "/a/", false},
+		{"/a/*", "/a/a", true},
+		{"/a/*", "/a/b/", false},
+		{"/a/*", "/a/b/c", false},
+
+		{"/a/*/", "/a/", false},
+		{"/a/*/", "/a/a", false},
+		{"/a/*/", "/a/b/", true},
+		{"/a/*/", "/a/b/c", false},
+
+		{"/a/**/*", "/a/", false},
+		{"/a/**/*", "/a/a", true},
+		{"/a/**/*", "/a/b/", false},
+		{"/a/**/*", "/a/b/c", true},
+
+		{"/**/*", "/a/", false},
+		{"/**/*", "/a/a", true},
+		{"/**/*", "/a/b/", false},
+		{"/**/*", "/a/b/c", true},
+
+		{"/**/*/", "/a/", true},
+		{"/**/*/", "/a/a", false},
+		{"/**/*/", "/a/b/", true},
+		{"/**/*/", "/a/b/c", false},
+
+		{`a`, `/a`, false},
+		{`/a`, `a`, false},
+		{`*`, `/a`, false},
+		{`/*`, `a`, false},
+		{`**/*`, `/a`, false},
+		{`/**/*`, `a`, false},
 	}
 
 	for _, test := range testCases {
@@ -839,4 +890,36 @@
 			}
 		})
 	}
+
+	// Run the same test cases through Glob
+	for _, test := range testCases {
+		// Glob and Match disagree on matching directories
+		if strings.HasSuffix(test.name, "/") || strings.HasSuffix(test.pattern, "/") {
+			continue
+		}
+		t.Run("glob:"+test.pattern+","+test.name, func(t *testing.T) {
+			mockFiles := map[string][]byte{
+				test.name: nil,
+			}
+
+			mock := MockFs(mockFiles)
+
+			matches, _, err := mock.Glob(test.pattern, nil, DontFollowSymlinks)
+			t.Log(test.name, test.pattern, matches)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			match := false
+			for _, x := range matches {
+				if x == test.name {
+					match = true
+				}
+			}
+
+			if match != test.match {
+				t.Errorf("want: %v, got %v", test.match, match)
+			}
+		})
+	}
 }
diff --git a/proptools/extend.go b/proptools/extend.go
index 1f323cf..f588ab2 100644
--- a/proptools/extend.go
+++ b/proptools/extend.go
@@ -34,7 +34,7 @@
 // embedded structs, pointers to structs, and interfaces containing
 // pointers to structs.  Appending the zero value of a property will always be a no-op.
 func AppendProperties(dst interface{}, src interface{}, filter ExtendPropertyFilterFunc) error {
-	return extendProperties(dst, src, filter, orderAppend)
+	return extendProperties(dst, src, filter, OrderAppend)
 }
 
 // PrependProperties prepends the values of properties in the property struct src to the property
@@ -52,7 +52,7 @@
 // embedded structs, pointers to structs, and interfaces containing
 // pointers to structs.  Prepending the zero value of a property will always be a no-op.
 func PrependProperties(dst interface{}, src interface{}, filter ExtendPropertyFilterFunc) error {
-	return extendProperties(dst, src, filter, orderPrepend)
+	return extendProperties(dst, src, filter, OrderPrepend)
 }
 
 // AppendMatchingProperties appends the values of properties in the property struct src to the
@@ -73,7 +73,7 @@
 // pointers to structs.  Appending the zero value of a property will always be a no-op.
 func AppendMatchingProperties(dst []interface{}, src interface{},
 	filter ExtendPropertyFilterFunc) error {
-	return extendMatchingProperties(dst, src, filter, orderAppend)
+	return extendMatchingProperties(dst, src, filter, OrderAppend)
 }
 
 // PrependMatchingProperties prepends the values of properties in the property struct src to the
@@ -94,7 +94,7 @@
 // pointers to structs.  Prepending the zero value of a property will always be a no-op.
 func PrependMatchingProperties(dst []interface{}, src interface{},
 	filter ExtendPropertyFilterFunc) error {
-	return extendMatchingProperties(dst, src, filter, orderPrepend)
+	return extendMatchingProperties(dst, src, filter, OrderPrepend)
 }
 
 // ExtendProperties appends or prepends the values of properties in the property struct src to the
@@ -160,13 +160,13 @@
 	dstField, srcField reflect.StructField,
 	dstValue, srcValue interface{}) (Order, error)
 
-func orderAppend(property string,
+func OrderAppend(property string,
 	dstField, srcField reflect.StructField,
 	dstValue, srcValue interface{}) (Order, error) {
 	return Append, nil
 }
 
-func orderPrepend(property string,
+func OrderPrepend(property string,
 	dstField, srcField reflect.StructField,
 	dstValue, srcValue interface{}) (Order, error) {
 	return Prepend, nil
diff --git a/singleton_ctx.go b/singleton_ctx.go
index 5ca8ee6..cc58e06 100644
--- a/singleton_ctx.go
+++ b/singleton_ctx.go
@@ -25,23 +25,51 @@
 }
 
 type SingletonContext interface {
+	// Config returns the config object that was passed to Context.PrepareBuildActions.
 	Config() interface{}
 
+	// Name returns the name of the current singleton passed to Context.RegisterSingletonType
 	Name() string
 
+	// ModuleName returns the name of the given Module.  See BaseModuleContext.ModuleName for more information.
 	ModuleName(module Module) string
+
+	// ModuleDir returns the directory of the given Module.  See BaseModuleContext.ModuleDir for more information.
 	ModuleDir(module Module) string
+
+	// ModuleSubDir returns the unique subdirectory name of the given Module.  See ModuleContext.ModuleSubDir for
+	// more information.
 	ModuleSubDir(module Module) string
+
+	// ModuleType returns the type of the given Module.  See BaseModuleContext.ModuleType for more information.
 	ModuleType(module Module) string
+
+	// BlueprintFile returns the path of the Blueprint file that defined the given module.
 	BlueprintFile(module Module) string
 
+	// ModuleErrorf reports an error at the line number of the module type in the module definition.
 	ModuleErrorf(module Module, format string, args ...interface{})
+
+	// Errorf reports an error at the specified position of the module definition file.
 	Errorf(format string, args ...interface{})
+
+	// Failed returns true if any errors have been reported.  In most cases the singleton can continue with generating
+	// build rules after an error, allowing it to report additional errors in a single run, but in cases where the error
+	// has prevented the singleton from creating necessary data it can return early when Failed returns true.
 	Failed() bool
 
+	// Variable creates a new ninja variable scoped to the singleton.  It can be referenced by calls to Rule and Build
+	// in the same singleton.
 	Variable(pctx PackageContext, name, value string)
+
+	// Rule creates a new ninja rule scoped to the singleton.  It can be referenced by calls to Build in the same
+	// singleton.
 	Rule(pctx PackageContext, name string, params RuleParams, argNames ...string) Rule
+
+	// Build creates a new ninja build statement.
 	Build(pctx PackageContext, params BuildParams)
+
+	// RequireNinjaVersion sets the generated ninja manifest to require at least the specified version of ninja.
 	RequireNinjaVersion(major, minor, micro int)
 
 	// SetNinjaBuildDir sets the value of the top-level "builddir" Ninja variable
@@ -58,17 +86,37 @@
 	// are expanded in the scope of the PackageContext.
 	Eval(pctx PackageContext, ninjaStr string) (string, error)
 
+	// VisitAllModules calls visit for each defined variant of each module in an unspecified order.
 	VisitAllModules(visit func(Module))
+
+	// VisitAllModules calls pred for each defined variant of each module in an unspecified order, and if pred returns
+	// true calls visit.
 	VisitAllModulesIf(pred func(Module) bool, visit func(Module))
+
+	// VisitDepsDepthFirst calls visit for each transitive dependency, 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.
 	VisitDepsDepthFirst(module Module, visit func(Module))
+
+	// 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.
 	VisitDepsDepthFirstIf(module Module, pred func(Module) bool,
 		visit func(Module))
 
+	// VisitAllModuleVariants calls visit for each variant of the given module.
 	VisitAllModuleVariants(module Module, visit func(Module))
 
+	// PrimaryModule returns the first variant of the given module.  This can be used to perform
+	//	// singleton actions that are only done once for all variants of a module.
 	PrimaryModule(module Module) Module
+
+	// FinalModule returns the last variant of the given module.  This can be used to perform
+	// singleton actions that are only done once for all variants of a module.
 	FinalModule(module Module) Module
 
+	// AddNinjaFileDeps adds dependencies on the specified files to the rule that creates the ninja manifest.  The
+	// primary builder will be rerun whenever the specified files are modified.
 	AddNinjaFileDeps(deps ...string)
 
 	// GlobWithDeps returns a list of files and directories that match the
@@ -79,6 +127,8 @@
 	// does not match the pattern is added to a searched directory.
 	GlobWithDeps(pattern string, excludes []string) ([]string, error)
 
+	// Fs returns a pathtools.Filesystem that can be used to interact with files.  Using the Filesystem interface allows
+	// the singleton to be used in build system tests that run against a mock filesystem.
 	Fs() pathtools.FileSystem
 }
 
@@ -223,7 +273,7 @@
 	defer func() {
 		if r := recover(); r != nil {
 			panic(newPanicErrorf(r, "VisitAllModules(%s) for module %s",
-				funcName(visit), visitingModule))
+				funcName(visit), s.context.moduleInfo[visitingModule]))
 		}
 	}()