diff --git a/Blueprints b/Blueprints
index 93357fa..6731365 100644
--- a/Blueprints
+++ b/Blueprints
@@ -67,6 +67,7 @@
         "pathtools/glob.go",
     ],
     testSrcs: [
+        "pathtools/fs_test.go",
         "pathtools/glob_test.go",
     ],
 }
diff --git a/blueprint_impl.bash b/blueprint_impl.bash
index 514ba31..6f5abba 100644
--- a/blueprint_impl.bash
+++ b/blueprint_impl.bash
@@ -28,6 +28,8 @@
 
 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"
 
diff --git a/bootstrap.bash b/bootstrap.bash
index 24f16c2..08b85b5 100755
--- a/bootstrap.bash
+++ b/bootstrap.bash
@@ -93,6 +93,11 @@
 # If RUN_TESTS is set, behave like -t was passed in as an option.
 [ ! -z "$RUN_TESTS" ] && EXTRA_ARGS="${EXTRA_ARGS} -t"
 
+# 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"
@@ -107,6 +112,10 @@
 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
diff --git a/bootstrap/bootstrap.go b/bootstrap/bootstrap.go
index e9a8f01..3464c0b 100644
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -17,6 +17,8 @@
 import (
 	"fmt"
 	"go/build"
+	"io/ioutil"
+	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -55,18 +57,22 @@
 
 	compile = pctx.StaticRule("compile",
 		blueprint.RuleParams{
-			Command: "GOROOT='$goRoot' $compileCmd $parallelCompile -o $out " +
-				"-p $pkgPath -complete $incFlags -pack $in",
+			Command: "GOROOT='$goRoot' $compileCmd $parallelCompile -o $out.tmp " +
+				"-p $pkgPath -complete $incFlags -pack $in && " +
+				"if cmp --quiet $out.tmp $out; then rm $out.tmp; else mv -f $out.tmp $out; fi",
 			CommandDeps: []string{"$compileCmd"},
 			Description: "compile $out",
+			Restat:      true,
 		},
 		"pkgPath", "incFlags")
 
 	link = pctx.StaticRule("link",
 		blueprint.RuleParams{
-			Command:     "GOROOT='$goRoot' $linkCmd -o $out $libDirFlags $in",
+			Command: "GOROOT='$goRoot' $linkCmd -o $out.tmp $libDirFlags $in && " +
+				"if cmp --quiet $out.tmp $out; then rm $out.tmp; else mv -f $out.tmp $out; fi",
 			CommandDeps: []string{"$linkCmd"},
 			Description: "link $out",
+			Restat:      true,
 		},
 		"libDirFlags")
 
@@ -118,14 +124,14 @@
 
 	generateBuildNinja = pctx.StaticRule("build.ninja",
 		blueprint.RuleParams{
-			Command:     "$builder $extra -b $buildDir -n $ninjaBuildDir -d $out.d -o $out $in",
+			Command:     "$builder $extra -b $buildDir -n $ninjaBuildDir -d $out.d -globFile $globFile -o $out $in",
 			CommandDeps: []string{"$builder"},
 			Description: "$builder $out",
 			Deps:        blueprint.DepsGCC,
 			Depfile:     "$out.d",
 			Restat:      true,
 		},
-		"builder", "extra", "generator")
+		"builder", "extra", "generator", "globFile")
 
 	// Work around a Ninja issue.  See https://github.com/martine/ninja/pull/634
 	phony = pctx.StaticRule("phony",
@@ -356,7 +362,7 @@
 			TestSrcs []string
 		}
 
-		Tool_dir bool `blueprint:mutated`
+		Tool_dir bool `blueprint:"mutated"`
 	}
 
 	installPath string
@@ -433,10 +439,12 @@
 
 	buildGoPackage(ctx, objDir, name, archiveFile, srcs, genSrcs)
 
+	var linkDeps []string
 	var libDirFlags []string
 	ctx.VisitDepsDepthFirstIf(isGoPackageProducer,
 		func(module blueprint.Module) {
 			dep := module.(goPackageProducer)
+			linkDeps = append(linkDeps, dep.GoPackageTarget())
 			libDir := dep.GoPkgRoot()
 			libDirFlags = append(libDirFlags, "-L "+libDir)
 			deps = append(deps, dep.GoTestTargets()...)
@@ -448,11 +456,12 @@
 	}
 
 	ctx.Build(pctx, blueprint.BuildParams{
-		Rule:     link,
-		Outputs:  []string{aoutFile},
-		Inputs:   []string{archiveFile},
-		Args:     linkArgs,
-		Optional: true,
+		Rule:      link,
+		Outputs:   []string{aoutFile},
+		Inputs:    []string{archiveFile},
+		Implicits: linkDeps,
+		Args:      linkArgs,
+		Optional:  true,
 	})
 
 	ctx.Build(pctx, blueprint.BuildParams{
@@ -552,11 +561,13 @@
 		Optional: true,
 	})
 
+	linkDeps := []string{testPkgArchive}
 	libDirFlags := []string{"-L " + testRoot}
 	testDeps := []string{}
 	ctx.VisitDepsDepthFirstIf(isGoPackageProducer,
 		func(module blueprint.Module) {
 			dep := module.(goPackageProducer)
+			linkDeps = append(linkDeps, dep.GoPackageTarget())
 			libDir := dep.GoPkgRoot()
 			libDirFlags = append(libDirFlags, "-L "+libDir)
 			testDeps = append(testDeps, dep.GoTestTargets()...)
@@ -575,9 +586,10 @@
 	})
 
 	ctx.Build(pctx, blueprint.BuildParams{
-		Rule:    link,
-		Outputs: []string{testFile},
-		Inputs:  []string{testArchive},
+		Rule:      link,
+		Outputs:   []string{testFile},
+		Inputs:    []string{testArchive},
+		Implicits: linkDeps,
 		Args: map[string]string{
 			"libDirFlags": strings.Join(libDirFlags, " "),
 		},
@@ -638,6 +650,9 @@
 	if s.config.moduleListFile != "" {
 		extraSharedFlagArray = append(extraSharedFlagArray, "-l", s.config.moduleListFile)
 	}
+	if s.config.emptyNinjaFile {
+		extraSharedFlagArray = append(extraSharedFlagArray, "--empty-ninja-file")
+	}
 	extraSharedFlagString := strings.Join(extraSharedFlagArray, " ")
 
 	var primaryBuilderName, primaryBuilderExtraFlags string
@@ -668,32 +683,33 @@
 	topLevelBlueprints := filepath.Join("$srcDir",
 		filepath.Base(s.config.topLevelBlueprintsFile))
 
-	mainNinjaFile := filepath.Join("$buildDir", "build.ninja")
-	primaryBuilderNinjaFile := filepath.Join(bootstrapDir, "build.ninja")
-
 	ctx.SetNinjaBuildDir(pctx, "${ninjaBuildDir}")
 
-	// Build the main build.ninja
-	ctx.Build(pctx, blueprint.BuildParams{
-		Rule:    generateBuildNinja,
-		Outputs: []string{mainNinjaFile},
-		Inputs:  []string{topLevelBlueprints},
-		Args: map[string]string{
-			"builder": primaryBuilderFile,
-			"extra":   primaryBuilderExtraFlags,
-		},
-	})
+	if s.config.stage == StagePrimary {
+		mainNinjaFile := filepath.Join("$buildDir", "build.ninja")
+		primaryBuilderNinjaGlobFile := filepath.Join(BuildDir, bootstrapSubDir, "build-globs.ninja")
 
-	// Add a way to rebuild the primary build.ninja so that globs works
-	ctx.Build(pctx, blueprint.BuildParams{
-		Rule:    generateBuildNinja,
-		Outputs: []string{primaryBuilderNinjaFile},
-		Inputs:  []string{topLevelBlueprints},
-		Args: map[string]string{
-			"builder": minibpFile,
-			"extra":   extraSharedFlagString,
-		},
-	})
+		if _, err := os.Stat(primaryBuilderNinjaGlobFile); os.IsNotExist(err) {
+			err = ioutil.WriteFile(primaryBuilderNinjaGlobFile, nil, 0666)
+			if err != nil {
+				ctx.Errorf("Failed to create empty ninja file: %s", err)
+			}
+		}
+
+		ctx.AddSubninja(primaryBuilderNinjaGlobFile)
+
+		// Build the main build.ninja
+		ctx.Build(pctx, blueprint.BuildParams{
+			Rule:    generateBuildNinja,
+			Outputs: []string{mainNinjaFile},
+			Inputs:  []string{topLevelBlueprints},
+			Args: map[string]string{
+				"builder":  primaryBuilderFile,
+				"extra":    primaryBuilderExtraFlags,
+				"globFile": primaryBuilderNinjaGlobFile,
+			},
+		})
+	}
 
 	if s.config.stage == StageMain {
 		if primaryBuilderName == "minibp" {
diff --git a/bootstrap/build.ninja b/bootstrap/build.ninja
index b338843..5787c72 100644
--- a/bootstrap/build.ninja
+++ b/bootstrap/build.ninja
@@ -7,8 +7,11 @@
 
 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 -o ${out} ${in}
+    command = ${builder} ${extraArgs} -b ${bootstrapBuildDir} -n ${builddir} -d ${out}.d -globFile ${myGlobs} -o ${out} ${in}
     deps = gcc
     depfile = ${out}.d
     description = ${builder} ${out}
diff --git a/bootstrap/cleanup.go b/bootstrap/cleanup.go
index a4a18c7..4a8ce25 100644
--- a/bootstrap/cleanup.go
+++ b/bootstrap/cleanup.go
@@ -30,9 +30,9 @@
 
 // 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.
+// build targets, or in `exempt`
 func removeAbandonedFilesUnder(ctx *blueprint.Context, config *Config,
-	srcDir string, under []string) error {
+	srcDir string, under, exempt []string) error {
 
 	if len(under) == 0 {
 		return nil
@@ -57,6 +57,10 @@
 		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 {
diff --git a/bootstrap/command.go b/bootstrap/command.go
index 04eb535..da0191b 100644
--- a/bootstrap/command.go
+++ b/bootstrap/command.go
@@ -32,6 +32,7 @@
 
 var (
 	outFile        string
+	globFile       string
 	depFile        string
 	docFile        string
 	cpuprofile     string
@@ -40,6 +41,7 @@
 	runGoTests     bool
 	noGC           bool
 	moduleListFile string
+	emptyNinjaFile bool
 
 	BuildDir      string
 	NinjaBuildDir string
@@ -48,6 +50,7 @@
 
 func init() {
 	flag.StringVar(&outFile, "o", "build.ninja", "the Ninja file to output")
+	flag.StringVar(&globFile, "globFile", "build-globs.ninja", "the Ninja file of globs to output")
 	flag.StringVar(&BuildDir, "b", ".", "the build output directory")
 	flag.StringVar(&NinjaBuildDir, "n", "", "the ninja builddir directory")
 	flag.StringVar(&depFile, "d", "", "the dependency file to output")
@@ -58,6 +61,7 @@
 	flag.BoolVar(&noGC, "nogc", false, "turn off GC for debugging")
 	flag.BoolVar(&runGoTests, "t", false, "build and run go tests during bootstrap")
 	flag.StringVar(&moduleListFile, "l", "", "file that lists filepaths to parse")
+	flag.BoolVar(&emptyNinjaFile, "empty-ninja-file", false, "write out a 0-byte ninja file")
 }
 
 func Main(ctx *blueprint.Context, config interface{}, extraNinjaFileDeps ...string) {
@@ -120,7 +124,9 @@
 
 	bootstrapConfig := &Config{
 		stage: stage,
+
 		topLevelBlueprintsFile: flag.Arg(0),
+		emptyNinjaFile:         emptyNinjaFile,
 		runGoTests:             runGoTests,
 		moduleListFile:         moduleListFile,
 	}
@@ -173,12 +179,28 @@
 		fatalf("error generating Ninja file contents: %s", err)
 	}
 
+	if stage == StageMain && emptyNinjaFile {
+		buf.Reset()
+	}
+
 	const outFilePermissions = 0666
 	err = ioutil.WriteFile(outFile, buf.Bytes(), outFilePermissions)
 	if err != nil {
 		fatalf("error writing %s: %s", outFile, err)
 	}
 
+	if globFile != "" {
+		buffer, errs := generateGlobNinjaFile(ctx.Globs)
+		if len(errs) > 0 {
+			fatalErrors(errs)
+		}
+
+		err = ioutil.WriteFile(globFile, buffer, outFilePermissions)
+		if err != nil {
+			fatalf("error writing %s: %s", outFile, err)
+		}
+	}
+
 	if depFile != "" {
 		err := deptools.WriteDepFile(depFile, outFile, deps)
 		if err != nil {
@@ -187,8 +209,8 @@
 	}
 
 	if c, ok := config.(ConfigRemoveAbandonedFilesUnder); ok {
-		under := c.RemoveAbandonedFilesUnder()
-		err := removeAbandonedFilesUnder(ctx, bootstrapConfig, SrcDir, under)
+		under, except := c.RemoveAbandonedFilesUnder()
+		err := removeAbandonedFilesUnder(ctx, bootstrapConfig, SrcDir, under, except)
 		if err != nil {
 			fatalf("error removing abandoned files: %s", err)
 		}
diff --git a/bootstrap/config.go b/bootstrap/config.go
index 5785ea7..0772b0a 100644
--- a/bootstrap/config.go
+++ b/bootstrap/config.go
@@ -69,10 +69,11 @@
 }
 
 type ConfigRemoveAbandonedFilesUnder interface {
-	// RemoveAbandonedFilesUnder should return a slice of path prefixes that
-	// will be cleaned of files that are no longer active targets, but are
-	// listed in the .ninja_log.
-	RemoveAbandonedFilesUnder() []string
+	// 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() (under, except []string)
 }
 
 type ConfigBlueprintToolLocation interface {
@@ -104,6 +105,7 @@
 
 	topLevelBlueprintsFile string
 
+	emptyNinjaFile bool
 	runGoTests     bool
 	moduleListFile string
 }
diff --git a/bootstrap/doc.go b/bootstrap/doc.go
index 3c7108e..69a1784 100644
--- a/bootstrap/doc.go
+++ b/bootstrap/doc.go
@@ -120,23 +120,27 @@
 //      - 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` under
-// the .minibootstrap/ directory.
+// 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:
 //
-//      - Rebuild .bootstrap/build.ninja, usually due to globs changing --
-//        other dependencies will trigger it to be built during minibootstrap
 //      - 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
diff --git a/bootstrap/glob.go b/bootstrap/glob.go
index 160ef58..9841611 100644
--- a/bootstrap/glob.go
+++ b/bootstrap/glob.go
@@ -15,6 +15,7 @@
 package bootstrap
 
 import (
+	"bytes"
 	"fmt"
 	"path/filepath"
 	"strings"
@@ -40,7 +41,7 @@
 // in a build failure with a "missing and no known rule to make it" error.
 
 var (
-	globCmd = filepath.Join("$BinDir", "bpglob")
+	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
@@ -111,6 +112,7 @@
 // primary builder if the results change.
 type globSingleton struct {
 	globLister func() []blueprint.GlobPath
+	writeRule  bool
 }
 
 func globSingletonFactory(ctx *blueprint.Context) func() blueprint.Singleton {
@@ -124,15 +126,52 @@
 func (s *globSingleton) GenerateBuildActions(ctx blueprint.SingletonContext) {
 	for _, g := range s.globLister() {
 		fileListFile := filepath.Join(BuildDir, ".glob", g.Name)
-		depFile := fileListFile + ".d"
 
-		fileList := strings.Join(g.Files, "\n") + "\n"
-		pathtools.WriteFileIfChanged(fileListFile, []byte(fileList), 0666)
-		deptools.WriteDepFile(depFile, fileListFile, g.Deps)
+		if s.writeRule {
+			depFile := fileListFile + ".d"
 
-		GlobFile(ctx, g.Pattern, g.Excludes, fileListFile, depFile)
+			fileList := strings.Join(g.Files, "\n") + "\n"
+			pathtools.WriteFileIfChanged(fileListFile, []byte(fileList), 0666)
+			deptools.WriteDepFile(depFile, fileListFile, g.Deps)
 
-		// Make build.ninja depend on the fileListFile
-		ctx.AddNinjaFileDeps(fileListFile)
+			GlobFile(ctx, g.Pattern, g.Excludes, fileListFile, depFile)
+		} else {
+			// Make build.ninja depend on the fileListFile
+			ctx.AddNinjaFileDeps(fileListFile)
+		}
 	}
 }
+
+func generateGlobNinjaFile(globLister func() []blueprint.GlobPath) ([]byte, []error) {
+	ctx := blueprint.NewContext()
+	ctx.RegisterSingletonType("glob", func() blueprint.Singleton {
+		return &globSingleton{
+			globLister: globLister,
+			writeRule:  true,
+		}
+	})
+
+	extraDeps, errs := ctx.ResolveDependencies(nil)
+	if len(extraDeps) > 0 {
+		return nil, []error{fmt.Errorf("shouldn't have extra deps")}
+	}
+	if len(errs) > 0 {
+		return nil, errs
+	}
+
+	extraDeps, errs = ctx.PrepareBuildActions(nil)
+	if len(extraDeps) > 0 {
+		return nil, []error{fmt.Errorf("shouldn't have extra deps")}
+	}
+	if len(errs) > 0 {
+		return nil, errs
+	}
+
+	buf := bytes.NewBuffer(nil)
+	err := ctx.WriteBuildFile(buf)
+	if err != nil {
+		return nil, []error{err}
+	}
+
+	return buf.Bytes(), nil
+}
diff --git a/bootstrap/minibp/main.go b/bootstrap/minibp/main.go
index 72ed9f6..1714739 100644
--- a/bootstrap/minibp/main.go
+++ b/bootstrap/minibp/main.go
@@ -37,8 +37,12 @@
 	return c.generatingPrimaryBuilder
 }
 
-func (c Config) RemoveAbandonedFilesUnder() []string {
-	return []string{filepath.Join(bootstrap.BuildDir, ".bootstrap")}
+func (c Config) RemoveAbandonedFilesUnder() (under, exempt []string) {
+	if c.generatingPrimaryBuilder {
+		under = []string{filepath.Join(bootstrap.BuildDir, ".bootstrap")}
+		exempt = []string{filepath.Join(bootstrap.BuildDir, ".bootstrap", "build.ninja")}
+	}
+	return
 }
 
 func main() {
diff --git a/context.go b/context.go
index f96306b..93212f0 100644
--- a/context.go
+++ b/context.go
@@ -102,6 +102,8 @@
 	requiredNinjaMinor int          // For the ninja_required_version variable
 	requiredNinjaMicro int          // For the ninja_required_version variable
 
+	subninjas []string
+
 	// set lazily by sortedModuleGroups
 	cachedSortedModuleGroups []*moduleGroup
 
@@ -717,7 +719,6 @@
 	descendantsMap, err := findBlueprintDescendants(filePaths)
 	if err != nil {
 		panic(err.Error())
-		return nil, []error{err}
 	}
 	blueprintsSet := make(map[string]bool)
 
@@ -1291,6 +1292,14 @@
 
 func (c *Context) addModule(module *moduleInfo) []error {
 	name := module.logicModule.Name()
+	if name == "" {
+		return []error{
+			&BlueprintError{
+				Err: fmt.Errorf("property 'name' is missing from a module"),
+				Pos: module.pos,
+			},
+		}
+	}
 	c.moduleInfo[module.logicModule] = module
 
 	group := &moduleGroup{
@@ -1401,12 +1410,6 @@
 	}
 
 	if m := c.findMatchingVariant(module, possibleDeps); m != nil {
-		for _, dep := range module.directDeps {
-			if m == dep.module {
-				// TODO(ccross): what if adding a dependency with a different tag?
-				return nil
-			}
-		}
 		module.directDeps = append(module.directDeps, depInfo{m, tag})
 		atomic.AddUint32(&c.depsModified, 1)
 		return nil
@@ -2386,7 +2389,7 @@
 	return nil
 }
 
-func (c *Context) walkDeps(topModule *moduleInfo,
+func (c *Context) walkDeps(topModule *moduleInfo, allowDuplicates bool,
 	visitDown func(depInfo, *moduleInfo) bool, visitUp func(depInfo, *moduleInfo)) {
 
 	visited := make(map[*moduleInfo]bool)
@@ -2402,16 +2405,16 @@
 	var walk func(module *moduleInfo)
 	walk = func(module *moduleInfo) {
 		for _, dep := range module.directDeps {
-			if !visited[dep.module] {
-				visited[dep.module] = true
+			if allowDuplicates || !visited[dep.module] {
 				visiting = dep.module
 				recurse := true
 				if visitDown != nil {
 					recurse = visitDown(dep, module)
 				}
-				if recurse {
+				if recurse && !visited[dep.module] {
 					walk(dep.module)
 				}
+				visited[dep.module] = true
 				if visitUp != nil {
 					visitUp(dep, module)
 				}
@@ -2884,7 +2887,7 @@
 		}
 	}()
 
-	c.walkDeps(topModule, nil, func(dep depInfo, parent *moduleInfo) {
+	c.walkDeps(topModule, false, nil, func(dep depInfo, parent *moduleInfo) {
 		visiting = dep.module
 		visit(dep.module.logicModule)
 	})
@@ -2902,7 +2905,7 @@
 		}
 	}()
 
-	c.walkDeps(topModule, nil, func(dep depInfo, parent *moduleInfo) {
+	c.walkDeps(topModule, false, nil, func(dep depInfo, parent *moduleInfo) {
 		if pred(dep.module.logicModule) {
 			visiting = dep.module
 			visit(dep.module.logicModule)
@@ -2945,6 +2948,11 @@
 		return err
 	}
 
+	err = c.writeSubninjas(nw)
+	if err != nil {
+		return err
+	}
+
 	// TODO: Group the globals by package.
 
 	err = c.writeGlobalVariables(nw)
@@ -3054,6 +3062,13 @@
 	return nw.BlankLine()
 }
 
+func (c *Context) writeSubninjas(nw *ninjaWriter) error {
+	for _, subninja := range c.subninjas {
+		nw.Subninja(subninja)
+	}
+	return nw.BlankLine()
+}
+
 func (c *Context) writeBuildDir(nw *ninjaWriter) error {
 	if c.ninjaBuildDir != nil {
 		err := nw.Assign("builddir", c.ninjaBuildDir.Value(c.pkgNames))
diff --git a/context_test.go b/context_test.go
index 635f73e..0d783dc 100644
--- a/context_test.go
+++ b/context_test.go
@@ -122,9 +122,9 @@
 	}
 }
 
-// |---B===D       - represents a non-walkable edge
+// |===B---D       - represents a non-walkable edge
 // A               = represents a walkable edge
-// |===C---E===G
+// |===C===E---G
 //     |       |   A should not be visited because it's the root node.
 //     |===F===|   B, D and E should not be walked.
 func TestWalkDeps(t *testing.T) {
@@ -189,24 +189,114 @@
 	var outputDown string
 	var outputUp string
 	topModule := ctx.modulesFromName("A", nil)[0]
-	ctx.walkDeps(topModule,
+	ctx.walkDeps(topModule, false,
 		func(dep depInfo, parent *moduleInfo) bool {
+			outputDown += ctx.ModuleName(dep.module.logicModule)
 			if dep.module.logicModule.(Walker).Walk() {
-				outputDown += ctx.ModuleName(dep.module.logicModule)
 				return true
 			}
 			return false
 		},
 		func(dep depInfo, parent *moduleInfo) {
-			if dep.module.logicModule.(Walker).Walk() {
-				outputUp += ctx.ModuleName(dep.module.logicModule)
-			}
+			outputUp += ctx.ModuleName(dep.module.logicModule)
 		})
-	if outputDown != "CFG" {
-		t.Fatalf("unexpected walkDeps behaviour: %s\ndown should be: CFG", outputDown)
+	if outputDown != "BCEFG" {
+		t.Errorf("unexpected walkDeps behaviour: %s\ndown should be: BCEFG", outputDown)
 	}
-	if outputUp != "GFC" {
-		t.Fatalf("unexpected walkDeps behaviour: %s\nup should be: GFC", outputUp)
+	if outputUp != "BEGFC" {
+		t.Errorf("unexpected walkDeps behaviour: %s\nup should be: BEGFC", outputUp)
+	}
+}
+
+// |===B---D           - represents a non-walkable edge
+// A                   = represents a walkable edge
+// |===C===E===\       A should not be visited because it's the root node.
+//     |       |       B, D should not be walked.
+//     |===F===G===H   G should be visited multiple times
+//         \===/       H should only be visited once
+func TestWalkDepsDuplicates(t *testing.T) {
+	ctx := NewContext()
+	ctx.MockFileSystem(map[string][]byte{
+		"Blueprints": []byte(`
+			foo_module {
+			    name: "A",
+			    deps: ["B", "C"],
+			}
+
+			bar_module {
+			    name: "B",
+			    deps: ["D"],
+			}
+
+			foo_module {
+			    name: "C",
+			    deps: ["E", "F"],
+			}
+
+			foo_module {
+			    name: "D",
+			}
+
+			foo_module {
+			    name: "E",
+			    deps: ["G"],
+			}
+
+			foo_module {
+			    name: "F",
+			    deps: ["G", "G"],
+			}
+
+			foo_module {
+			    name: "G",
+				deps: ["H"],
+			}
+
+			foo_module {
+			    name: "H",
+			}
+		`),
+	})
+
+	ctx.RegisterModuleType("foo_module", newFooModule)
+	ctx.RegisterModuleType("bar_module", newBarModule)
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+	if len(errs) > 0 {
+		t.Errorf("unexpected parse errors:")
+		for _, err := range errs {
+			t.Errorf("  %s", err)
+		}
+		t.FailNow()
+	}
+
+	_, errs = ctx.ResolveDependencies(nil)
+	if len(errs) > 0 {
+		t.Errorf("unexpected dep errors:")
+		for _, err := range errs {
+			t.Errorf("  %s", err)
+		}
+		t.FailNow()
+	}
+
+	var outputDown string
+	var outputUp string
+	topModule := ctx.modulesFromName("A", nil)[0]
+	ctx.walkDeps(topModule, true,
+		func(dep depInfo, parent *moduleInfo) bool {
+			outputDown += ctx.ModuleName(dep.module.logicModule)
+			if dep.module.logicModule.(Walker).Walk() {
+				return true
+			}
+			return false
+		},
+		func(dep depInfo, parent *moduleInfo) {
+			outputUp += ctx.ModuleName(dep.module.logicModule)
+		})
+	if outputDown != "BCEGHFGG" {
+		t.Errorf("unexpected walkDeps behaviour: %s\ndown should be: BCEGHFGG", outputDown)
+	}
+	if outputUp != "BHGEGGFC" {
+		t.Errorf("unexpected walkDeps behaviour: %s\nup should be: BHGEGGFC", outputUp)
 	}
 }
 
@@ -392,3 +482,29 @@
 	}
 
 }
+
+func TestParseFailsForModuleWithoutName(t *testing.T) {
+	ctx := NewContext()
+	ctx.MockFileSystem(map[string][]byte{
+		"Blueprints": []byte(`
+			foo_module {
+			    name: "A",
+			}
+			
+			bar_module {
+			    deps: ["A"],
+			}
+		`),
+	})
+	ctx.RegisterModuleType("foo_module", newFooModule)
+	ctx.RegisterModuleType("bar_module", newBarModule)
+
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+
+	expectedErrs := []error{
+		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.go b/glob.go
index 4553f69..4f7e978 100644
--- a/glob.go
+++ b/glob.go
@@ -19,6 +19,8 @@
 	"fmt"
 	"sort"
 	"strings"
+
+	"github.com/google/blueprint/pathtools"
 )
 
 type GlobPath struct {
@@ -59,7 +61,7 @@
 	}
 
 	// Get a globbed file list
-	files, deps, err := c.fs.Glob(pattern, excludes)
+	files, deps, err := c.fs.Glob(pattern, excludes, pathtools.FollowSymlinks)
 	if err != nil {
 		return nil, err
 	}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..933cd12
--- /dev/null
+++ b/go.mod
@@ -0,0 +1 @@
+module github.com/google/blueprint
diff --git a/microfactory/microfactory.go b/microfactory/microfactory.go
index 845238b..a70d3c5 100644
--- a/microfactory/microfactory.go
+++ b/microfactory/microfactory.go
@@ -400,7 +400,7 @@
 		"-o", p.output,
 		"-p", p.Name,
 		"-complete", "-pack", "-nolocalimports")
-	if !isGo18 {
+	if !isGo18 && !config.Race {
 		cmd.Args = append(cmd.Args, "-c", fmt.Sprintf("%d", runtime.NumCPU()))
 	}
 	if config.Race {
diff --git a/module_ctx.go b/module_ctx.go
index fe6c12b..62646f1 100644
--- a/module_ctx.go
+++ b/module_ctx.go
@@ -164,7 +164,7 @@
 	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)
+	WalkDeps(visit func(child, parent Module) bool)
 
 	ModuleSubDir() string
 
@@ -304,6 +304,9 @@
 	})
 }
 
+// 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 {
@@ -319,8 +322,9 @@
 	return nil
 }
 
-// GetDirectDep returns the Module and DependencyTag for the direct dependency with the specified
-// name, or nil if none exists.
+// 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) GetDirectDep(name string) (Module, DependencyTag) {
 	for _, dep := range m.module.directDeps {
 		if dep.module.Name() == name {
@@ -347,6 +351,8 @@
 	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 {
@@ -366,6 +372,9 @@
 	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 {
@@ -387,6 +396,10 @@
 	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 {
@@ -395,7 +408,7 @@
 		}
 	}()
 
-	m.context.walkDeps(m.module, nil, func(dep depInfo, parent *moduleInfo) {
+	m.context.walkDeps(m.module, false, nil, func(dep depInfo, parent *moduleInfo) {
 		m.visitingParent = parent
 		m.visitingDep = dep
 		visit(dep.module.logicModule)
@@ -405,6 +418,11 @@
 	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)) {
 
@@ -415,7 +433,7 @@
 		}
 	}()
 
-	m.context.walkDeps(m.module, nil, func(dep depInfo, parent *moduleInfo) {
+	m.context.walkDeps(m.module, false, nil, func(dep depInfo, parent *moduleInfo) {
 		if pred(dep.module.logicModule) {
 			m.visitingParent = parent
 			m.visitingDep = dep
@@ -427,8 +445,12 @@
 	m.visitingDep = depInfo{}
 }
 
-func (m *baseModuleContext) WalkDeps(visit func(Module, Module) bool) {
-	m.context.walkDeps(m.module, func(dep depInfo, parent *moduleInfo) bool {
+// 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
 		m.visitingDep = dep
 		return visit(dep.module.logicModule, parent.logicModule)
diff --git a/name_interface.go b/name_interface.go
index 6743f0c..1849e9d 100644
--- a/name_interface.go
+++ b/name_interface.go
@@ -126,20 +126,22 @@
 func (s *SimpleNameInterface) Rename(oldName string, newName string, namespace Namespace) (errs []error) {
 	existingGroup, exists := s.modules[newName]
 	if exists {
-		errs = append(errs,
+		return []error{
 			// seven characters at the start of the second line to align with the string "error: "
 			fmt.Errorf("renaming module %q to %q conflicts with existing module\n"+
 				"       %s <-- existing module defined here",
 				oldName, newName, existingGroup.modules[0].pos),
-		)
-		return errs
+		}
 	}
 
-	group := s.modules[oldName]
+	group, exists := s.modules[oldName]
+	if !exists {
+		return []error{fmt.Errorf("module %q to renamed to %q doesn't exist", oldName, newName)}
+	}
 	s.modules[newName] = group
 	delete(s.modules, group.name)
 	group.name = newName
-	return []error{}
+	return nil
 }
 
 func (s *SimpleNameInterface) AllModules() []ModuleGroup {
diff --git a/ninja_writer.go b/ninja_writer.go
index a61667d..5902986 100644
--- a/ninja_writer.go
+++ b/ninja_writer.go
@@ -193,6 +193,12 @@
 	return wrapper.Flush()
 }
 
+func (n *ninjaWriter) Subninja(file string) error {
+	n.justDidBlankLine = false
+	_, err := fmt.Fprintf(n.writer, "subninja %s\n", file)
+	return err
+}
+
 func (n *ninjaWriter) BlankLine() (err error) {
 	// We don't output multiple blank lines in a row.
 	if !n.justDidBlankLine {
diff --git a/ninja_writer_test.go b/ninja_writer_test.go
index 44e4ff8..cc880e5 100644
--- a/ninja_writer_test.go
+++ b/ninja_writer_test.go
@@ -74,6 +74,12 @@
 	},
 	{
 		input: func(w *ninjaWriter) {
+			ck(w.Subninja("build.ninja"))
+		},
+		output: "subninja build.ninja\n",
+	},
+	{
+		input: func(w *ninjaWriter) {
 			ck(w.BlankLine())
 		},
 		output: "\n",
diff --git a/parser/parser.go b/parser/parser.go
index e832e1a..cb86246 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -302,8 +302,10 @@
 	pos := p.scanner.Position
 
 	if isModule {
-		if compat && p.tok == ':' {
-			p.accept(':')
+		if compat {
+			if !p.accept(':') {
+				return
+			}
 		} else {
 			if !p.accept('=') {
 				return
diff --git a/parser/printer.go b/parser/printer.go
index d3aad4a..ac7ffe1 100644
--- a/parser/printer.go
+++ b/parser/printer.go
@@ -173,15 +173,34 @@
 }
 
 func (p *printer) printOperator(operator *Operator) {
+	p.printOperatorInternal(operator, true)
+}
+
+func (p *printer) printOperatorInternal(operator *Operator, allowIndent bool) {
 	p.printExpression(operator.Args[0])
 	p.requestSpace()
 	p.printToken(string(operator.Operator), operator.OperatorPos)
+
+	indented := false
 	if operator.Args[0].End().Line == operator.Args[1].Pos().Line {
 		p.requestSpace()
 	} else {
+		if allowIndent {
+			indented = true
+			p.indent(p.curIndent() + 4)
+		}
 		p.requestNewline()
 	}
-	p.printExpression(operator.Args[1])
+
+	if op, isOp := operator.Args[1].(*Operator); isOp {
+		p.printOperatorInternal(op, false)
+	} else {
+		p.printExpression(operator.Args[1])
+	}
+
+	if indented {
+		p.unindent(p.pos)
+	}
 }
 
 func (p *printer) printProperty(property *Property) {
diff --git a/parser/printer_test.go b/parser/printer_test.go
index a223fab..6f76b26 100644
--- a/parser/printer_test.go
+++ b/parser/printer_test.go
@@ -33,7 +33,7 @@
 	},
 	{
 		input: `
-foo{name= "abc",num= 4,}
+foo(name= "abc",num= 4,)
 `,
 		output: `
 foo {
@@ -166,6 +166,22 @@
 	},
 	{
 		input: `
+foo {
+    bar: "b" +
+        "a" +
+	"z",
+}
+`,
+		output: `
+foo {
+    bar: "b" +
+        "a" +
+        "z",
+}
+`,
+	},
+	{
+		input: `
 foo = "stuff"
 bar = foo
 baz = foo + bar
@@ -194,6 +210,18 @@
 	},
 	{
 		input: `
+foo = "bar " +
+    "" +
+    "baz"
+`,
+		output: `
+foo = "bar " +
+    "" +
+    "baz"
+`,
+	},
+	{
+		input: `
 //test
 test /* test */ {
     srcs: [
diff --git a/pathtools/fs.go b/pathtools/fs.go
index 6edf3dd..4217487 100644
--- a/pathtools/fs.go
+++ b/pathtools/fs.go
@@ -16,7 +16,6 @@
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -24,20 +23,35 @@
 	"path/filepath"
 	"sort"
 	"strings"
+	"syscall"
+	"time"
 )
 
 // Based on Andrew Gerrand's "10 things you (probably) dont' know about Go"
 
+type ShouldFollowSymlinks bool
+
+const (
+	FollowSymlinks     = ShouldFollowSymlinks(true)
+	DontFollowSymlinks = ShouldFollowSymlinks(false)
+)
+
 var OsFs FileSystem = osFs{}
 
 func MockFs(files map[string][]byte) FileSystem {
 	fs := &mockFs{
-		files: make(map[string][]byte, len(files)),
-		dirs:  make(map[string]bool),
-		all:   []string(nil),
+		files:    make(map[string][]byte, len(files)),
+		dirs:     make(map[string]bool),
+		symlinks: make(map[string]string),
+		all:      []string(nil),
 	}
 
 	for f, b := range files {
+		if tokens := strings.SplitN(f, "->", 2); len(tokens) == 2 {
+			fs.symlinks[strings.TrimSpace(tokens[0])] = strings.TrimSpace(tokens[1])
+			continue
+		}
+
 		fs.files[filepath.Clean(f)] = b
 		dir := filepath.Dir(f)
 		for dir != "." && dir != "/" {
@@ -55,25 +69,60 @@
 		fs.all = append(fs.all, d)
 	}
 
+	for s := range fs.symlinks {
+		fs.all = append(fs.all, s)
+	}
+
 	sort.Strings(fs.all)
 
 	return fs
 }
 
+type ReaderAtSeekerCloser interface {
+	io.Reader
+	io.ReaderAt
+	io.Seeker
+	io.Closer
+}
+
 type FileSystem interface {
-	Open(name string) (io.ReadCloser, error)
+	// 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.
 	Exists(name string) (bool, bool, error)
-	Glob(pattern string, excludes []string) (matches, dirs []string, err error)
+
+	Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, dirs []string, err error)
 	glob(pattern string) (matches []string, err error)
+
+	// IsDir returns true if the path points to a directory, false it it points to a file.  Follows symlinks.
+	// Returns os.ErrNotExist if the path does not exist or is a symlink to a path that does not exist.
 	IsDir(name string) (bool, error)
+
+	// IsSymlink returns true if the path points to a symlink, even if that symlink points to a path that does
+	// not exist.  Returns os.ErrNotExist if the path does not exist.
+	IsSymlink(name string) (bool, error)
+
+	// Lstat returns info on a file without following symlinks.
 	Lstat(name string) (os.FileInfo, error)
-	ListDirsRecursive(name string) (dirs []string, err error)
+
+	// Lstat returns info on a file.
+	Stat(name string) (os.FileInfo, error)
+
+	// ListDirsRecursive returns a list of all the directories in a path, following symlinks if requested.
+	ListDirsRecursive(name string, follow ShouldFollowSymlinks) (dirs []string, err error)
+
+	// ReadDirNames returns a list of everything in a directory.
+	ReadDirNames(name string) ([]string, error)
+
+	// Readlink returns the destination of the named symbolic link.
+	Readlink(name string) (string, error)
 }
 
 // osFs implements FileSystem using the local disk.
 type osFs struct{}
 
-func (osFs) Open(name string) (io.ReadCloser, error) { return os.Open(name) }
+func (osFs) Open(name string) (ReaderAtSeekerCloser, error) { return os.Open(name) }
 func (osFs) Exists(name string) (bool, bool, error) {
 	stat, err := os.Stat(name)
 	if err == nil {
@@ -88,13 +137,21 @@
 func (osFs) IsDir(name string) (bool, error) {
 	info, err := os.Stat(name)
 	if err != nil {
-		return false, fmt.Errorf("unexpected error after glob: %s", err)
+		return false, err
 	}
 	return info.IsDir(), nil
 }
 
-func (fs osFs) Glob(pattern string, excludes []string) (matches, dirs []string, err error) {
-	return startGlob(fs, pattern, excludes)
+func (osFs) IsSymlink(name string) (bool, error) {
+	if info, err := os.Lstat(name); err != nil {
+		return false, err
+	} else {
+		return info.Mode()&os.ModeSymlink != 0, nil
+	}
+}
+
+func (fs osFs) Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, dirs []string, err error) {
+	return startGlob(fs, pattern, excludes, follow)
 }
 
 func (osFs) glob(pattern string) ([]string, error) {
@@ -105,34 +162,70 @@
 	return os.Lstat(path)
 }
 
+func (osFs) Stat(path string) (stats os.FileInfo, err error) {
+	return os.Stat(path)
+}
+
 // Returns a list of all directories under dir
-func (osFs) ListDirsRecursive(name string) (dirs []string, err error) {
-	err = filepath.Walk(name, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
+func (osFs) ListDirsRecursive(name string, follow ShouldFollowSymlinks) (dirs []string, err error) {
+	return listDirsRecursive(OsFs, name, follow)
+}
 
-		if info.Mode().IsDir() {
-			name := info.Name()
-			if name[0] == '.' && name != "." {
-				return filepath.SkipDir
-			}
+func (osFs) ReadDirNames(name string) ([]string, error) {
+	dir, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer dir.Close()
 
-			dirs = append(dirs, path)
-		}
-		return nil
-	})
+	contents, err := dir.Readdirnames(-1)
+	if err != nil {
+		return nil, err
+	}
 
-	return dirs, err
+	sort.Strings(contents)
+	return contents, nil
+}
+
+func (osFs) Readlink(name string) (string, error) {
+	return os.Readlink(name)
 }
 
 type mockFs struct {
-	files map[string][]byte
-	dirs  map[string]bool
-	all   []string
+	files    map[string][]byte
+	dirs     map[string]bool
+	symlinks map[string]string
+	all      []string
 }
 
-func (m *mockFs) Open(name string) (io.ReadCloser, error) {
+func (m *mockFs) followSymlinks(name string) string {
+	dir, file := saneSplit(name)
+	if dir != "." && dir != "/" {
+		dir = m.followSymlinks(dir)
+	}
+	name = filepath.Join(dir, file)
+
+	for i := 0; i < 255; i++ {
+		i++
+		if i > 255 {
+			panic("symlink loop")
+		}
+		to, exists := m.symlinks[name]
+		if !exists {
+			break
+		}
+		if filepath.IsAbs(to) {
+			name = to
+		} else {
+			name = filepath.Join(dir, to)
+		}
+	}
+	return name
+}
+
+func (m *mockFs) Open(name string) (ReaderAtSeekerCloser, error) {
+	name = filepath.Clean(name)
+	name = m.followSymlinks(name)
 	if f, ok := m.files[name]; ok {
 		return struct {
 			io.Closer
@@ -152,6 +245,7 @@
 
 func (m *mockFs) Exists(name string) (bool, bool, error) {
 	name = filepath.Clean(name)
+	name = m.followSymlinks(name)
 	if _, ok := m.files[name]; ok {
 		return ok, false, nil
 	}
@@ -162,51 +256,264 @@
 }
 
 func (m *mockFs) IsDir(name string) (bool, error) {
-	return m.dirs[filepath.Clean(name)], nil
+	dir := filepath.Dir(name)
+	if dir != "." && dir != "/" {
+		isDir, err := m.IsDir(dir)
+
+		if serr, ok := err.(*os.SyscallError); ok && serr.Err == syscall.ENOTDIR {
+			isDir = false
+		} else if err != nil {
+			return false, err
+		}
+
+		if !isDir {
+			return false, os.NewSyscallError("stat "+name, syscall.ENOTDIR)
+		}
+	}
+
+	name = filepath.Clean(name)
+	name = m.followSymlinks(name)
+
+	if _, ok := m.dirs[name]; ok {
+		return true, nil
+	}
+	if _, ok := m.files[name]; ok {
+		return false, nil
+	}
+	return false, os.ErrNotExist
 }
 
-func (m *mockFs) Glob(pattern string, excludes []string) (matches, dirs []string, err error) {
-	return startGlob(m, pattern, excludes)
+func (m *mockFs) IsSymlink(name string) (bool, error) {
+	dir, file := saneSplit(name)
+	dir = m.followSymlinks(dir)
+	name = filepath.Join(dir, file)
+
+	if _, isSymlink := m.symlinks[name]; isSymlink {
+		return true, nil
+	}
+	if _, isDir := m.dirs[name]; isDir {
+		return false, nil
+	}
+	if _, isFile := m.files[name]; isFile {
+		return false, nil
+	}
+	return false, os.ErrNotExist
+}
+
+func (m *mockFs) Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, dirs []string, err error) {
+	return startGlob(m, pattern, excludes, follow)
+}
+
+func unescapeGlob(s string) string {
+	i := 0
+	for i < len(s) {
+		if s[i] == '\\' {
+			s = s[:i] + s[i+1:]
+		} else {
+			i++
+		}
+	}
+	return s
 }
 
 func (m *mockFs) glob(pattern string) ([]string, error) {
+	dir, file := saneSplit(pattern)
+
+	dir = unescapeGlob(dir)
+	toDir := m.followSymlinks(dir)
+
 	var matches []string
 	for _, f := range m.all {
-		match, err := filepath.Match(pattern, f)
-		if err != nil {
-			return nil, err
-		}
-		if f == "." && f != pattern {
-			// filepath.Glob won't return "." unless the pattern was "."
-			match = false
-		}
-		if match {
-			matches = append(matches, f)
+		fDir, fFile := saneSplit(f)
+		if toDir == fDir {
+			match, err := filepath.Match(file, fFile)
+			if err != nil {
+				return nil, err
+			}
+			if f == "." && f != pattern {
+				// filepath.Glob won't return "." unless the pattern was "."
+				match = false
+			}
+			if match {
+				matches = append(matches, filepath.Join(dir, fFile))
+			}
 		}
 	}
 	return matches, nil
 }
 
-func (m *mockFs) Lstat(path string) (stats os.FileInfo, err error) {
-	return nil, errors.New("Lstat is not yet implemented in MockFs")
+type mockStat struct {
+	name string
+	size int64
+	mode os.FileMode
 }
 
-func (m *mockFs) ListDirsRecursive(name string) (dirs []string, err error) {
-	name = filepath.Clean(name)
-	dirs = append(dirs, name)
-	if name == "." {
-		name = ""
-	} else if name != "/" {
-		name = name + "/"
+func (ms *mockStat) Name() string       { return ms.name }
+func (ms *mockStat) IsDir() bool        { return ms.Mode().IsDir() }
+func (ms *mockStat) Size() int64        { return ms.size }
+func (ms *mockStat) Mode() os.FileMode  { return ms.mode }
+func (ms *mockStat) ModTime() time.Time { return time.Time{} }
+func (ms *mockStat) Sys() interface{}   { return nil }
+
+func (m *mockFs) Lstat(name string) (os.FileInfo, error) {
+	dir, file := saneSplit(name)
+	dir = m.followSymlinks(dir)
+	name = filepath.Join(dir, file)
+
+	ms := mockStat{
+		name: file,
 	}
+
+	if symlink, isSymlink := m.symlinks[name]; isSymlink {
+		ms.mode = os.ModeSymlink
+		ms.size = int64(len(symlink))
+	} else if _, isDir := m.dirs[name]; isDir {
+		ms.mode = os.ModeDir
+	} else if _, isFile := m.files[name]; isFile {
+		ms.mode = 0
+		ms.size = int64(len(m.files[name]))
+	} else {
+		return nil, os.ErrNotExist
+	}
+
+	return &ms, nil
+}
+
+func (m *mockFs) Stat(name string) (os.FileInfo, error) {
+	name = filepath.Clean(name)
+	origName := name
+	name = m.followSymlinks(name)
+
+	ms := mockStat{
+		name: filepath.Base(origName),
+		size: int64(len(m.files[name])),
+	}
+
+	if _, isDir := m.dirs[name]; isDir {
+		ms.mode = os.ModeDir
+	} else if _, isFile := m.files[name]; isFile {
+		ms.mode = 0
+		ms.size = int64(len(m.files[name]))
+	} else {
+		return nil, os.ErrNotExist
+	}
+
+	return &ms, nil
+}
+
+func (m *mockFs) ReadDirNames(name string) ([]string, error) {
+	name = filepath.Clean(name)
+	name = m.followSymlinks(name)
+
+	exists, isDir, err := m.Exists(name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, os.ErrNotExist
+	}
+	if !isDir {
+		return nil, os.NewSyscallError("readdir", syscall.ENOTDIR)
+	}
+
+	var ret []string
 	for _, f := range m.all {
-		if _, isDir := m.dirs[f]; isDir && filepath.Base(f)[0] != '.' {
-			if strings.HasPrefix(f, name) &&
-				strings.HasPrefix(f, "/") == strings.HasPrefix(name, "/") {
-				dirs = append(dirs, f)
+		dir, file := saneSplit(f)
+		if dir == name && len(file) > 0 && file[0] != '.' {
+			ret = append(ret, file)
+		}
+	}
+	return ret, nil
+}
+
+func (m *mockFs) ListDirsRecursive(name string, follow ShouldFollowSymlinks) ([]string, error) {
+	return listDirsRecursive(m, name, follow)
+}
+
+func (m *mockFs) Readlink(name string) (string, error) {
+	dir, file := saneSplit(name)
+	dir = m.followSymlinks(dir)
+
+	origName := name
+	name = filepath.Join(dir, file)
+
+	if dest, isSymlink := m.symlinks[name]; isSymlink {
+		return dest, nil
+	}
+
+	if exists, _, err := m.Exists(name); err != nil {
+		return "", err
+	} else if !exists {
+		return "", os.ErrNotExist
+	} else {
+		return "", os.NewSyscallError("readlink: "+origName, syscall.EINVAL)
+	}
+}
+
+func listDirsRecursive(fs FileSystem, name string, follow ShouldFollowSymlinks) ([]string, error) {
+	name = filepath.Clean(name)
+
+	isDir, err := fs.IsDir(name)
+	if err != nil {
+		return nil, err
+	}
+
+	if !isDir {
+		return nil, nil
+	}
+
+	dirs := []string{name}
+
+	subDirs, err := listDirsRecursiveRelative(fs, name, follow, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, d := range subDirs {
+		dirs = append(dirs, filepath.Join(name, d))
+	}
+
+	return dirs, nil
+}
+
+func listDirsRecursiveRelative(fs FileSystem, name string, follow ShouldFollowSymlinks, depth int) ([]string, error) {
+	depth++
+	if depth > 255 {
+		return nil, fmt.Errorf("too many symlinks")
+	}
+	contents, err := fs.ReadDirNames(name)
+	if err != nil {
+		return nil, err
+	}
+
+	var dirs []string
+	for _, f := range contents {
+		if f[0] == '.' {
+			continue
+		}
+		f = filepath.Join(name, f)
+		if isSymlink, _ := fs.IsSymlink(f); isSymlink && follow == DontFollowSymlinks {
+			continue
+		}
+		if isDir, _ := fs.IsDir(f); isDir {
+			dirs = append(dirs, f)
+			subDirs, err := listDirsRecursiveRelative(fs, f, follow, depth)
+			if err != nil {
+				return nil, err
+			}
+			for _, s := range subDirs {
+				dirs = append(dirs, filepath.Join(f, s))
 			}
 		}
 	}
 
+	for i, d := range dirs {
+		rel, err := filepath.Rel(name, d)
+		if err != nil {
+			return nil, err
+		}
+		dirs[i] = rel
+	}
+
 	return dirs, nil
 }
diff --git a/pathtools/fs_test.go b/pathtools/fs_test.go
new file mode 100644
index 0000000..1b5c458
--- /dev/null
+++ b/pathtools/fs_test.go
@@ -0,0 +1,589 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pathtools
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"syscall"
+	"testing"
+)
+
+func symlinkMockFs() *mockFs {
+	files := []string{
+		"a/a/a",
+		"a/a/f -> ../../f",
+		"b -> a",
+		"c -> a/a",
+		"d -> c",
+		"e -> a/a/a",
+		"dangling -> missing",
+		"f",
+	}
+
+	mockFiles := make(map[string][]byte)
+
+	for _, f := range files {
+		mockFiles[f] = nil
+		mockFiles[filepath.Join(pwd, "testdata", f)] = nil
+	}
+
+	return MockFs(mockFiles).(*mockFs)
+}
+
+func TestMockFs_followSymlinks(t *testing.T) {
+
+	testCases := []struct {
+		from, to string
+	}{
+		{".", "."},
+		{"/", "/"},
+
+		{"a", "a"},
+		{"a/a", "a/a"},
+		{"a/a/a", "a/a/a"},
+		{"a/a/f", "f"},
+
+		{"b", "a"},
+		{"b/a", "a/a"},
+		{"b/a/a", "a/a/a"},
+		{"b/a/f", "f"},
+
+		{"c/a", "a/a/a"},
+		{"c/f", "f"},
+
+		{"d/a", "a/a/a"},
+		{"d/f", "f"},
+
+		{"e", "a/a/a"},
+
+		{"f", "f"},
+
+		{"dangling", "missing"},
+
+		{"a/missing", "a/missing"},
+		{"b/missing", "a/missing"},
+		{"c/missing", "a/a/missing"},
+		{"d/missing", "a/a/missing"},
+		{"e/missing", "a/a/a/missing"},
+		{"dangling/missing", "missing/missing"},
+
+		{"a/missing/missing", "a/missing/missing"},
+		{"b/missing/missing", "a/missing/missing"},
+		{"c/missing/missing", "a/a/missing/missing"},
+		{"d/missing/missing", "a/a/missing/missing"},
+		{"e/missing/missing", "a/a/a/missing/missing"},
+		{"dangling/missing/missing", "missing/missing/missing"},
+	}
+
+	mock := symlinkMockFs()
+
+	for _, test := range testCases {
+		t.Run(test.from, func(t *testing.T) {
+			got := mock.followSymlinks(test.from)
+			if got != test.to {
+				t.Errorf("want: %v, got %v", test.to, got)
+			}
+		})
+	}
+}
+
+func TestFs_IsDir(t *testing.T) {
+	testCases := []struct {
+		name  string
+		isDir bool
+		err   error
+	}{
+		{"a", true, nil},
+		{"a/a", true, nil},
+		{"a/a/a", false, nil},
+		{"a/a/f", false, nil},
+
+		{"b", true, nil},
+		{"b/a", true, nil},
+		{"b/a/a", false, nil},
+		{"b/a/f", false, nil},
+
+		{"c", true, nil},
+		{"c/a", false, nil},
+		{"c/f", false, nil},
+
+		{"d", true, nil},
+		{"d/a", false, nil},
+		{"d/f", false, nil},
+
+		{"e", false, nil},
+
+		{"f", false, nil},
+
+		{"dangling", false, os.ErrNotExist},
+
+		{"a/missing", false, os.ErrNotExist},
+		{"b/missing", false, os.ErrNotExist},
+		{"c/missing", false, os.ErrNotExist},
+		{"d/missing", false, os.ErrNotExist},
+		{"e/missing", false, syscall.ENOTDIR},
+		{"dangling/missing", false, os.ErrNotExist},
+
+		{"a/missing/missing", false, os.ErrNotExist},
+		{"b/missing/missing", false, os.ErrNotExist},
+		{"c/missing/missing", false, os.ErrNotExist},
+		{"d/missing/missing", false, os.ErrNotExist},
+		{"e/missing/missing", false, syscall.ENOTDIR},
+		{"dangling/missing/missing", false, os.ErrNotExist},
+
+		{"c/f/missing", false, syscall.ENOTDIR},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+			for _, test := range testCases {
+				t.Run(test.name, func(t *testing.T) {
+					got, err := fs.IsDir(test.name)
+					checkErr(t, test.err, err)
+					if got != test.isDir {
+						t.Errorf("want: %v, got %v", test.isDir, got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestFs_ListDirsRecursiveFollowSymlinks(t *testing.T) {
+	testCases := []struct {
+		name string
+		dirs []string
+		err  error
+	}{
+		{".", []string{".", "a", "a/a", "b", "b/a", "c", "d"}, nil},
+
+		{"a", []string{"a", "a/a"}, nil},
+		{"a/a", []string{"a/a"}, nil},
+		{"a/a/a", nil, nil},
+
+		{"b", []string{"b", "b/a"}, nil},
+		{"b/a", []string{"b/a"}, nil},
+		{"b/a/a", nil, nil},
+
+		{"c", []string{"c"}, nil},
+		{"c/a", nil, nil},
+
+		{"d", []string{"d"}, nil},
+		{"d/a", nil, nil},
+
+		{"e", nil, nil},
+
+		{"dangling", nil, os.ErrNotExist},
+
+		{"missing", nil, os.ErrNotExist},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+
+			for _, test := range testCases {
+				t.Run(test.name, func(t *testing.T) {
+					got, err := fs.ListDirsRecursive(test.name, FollowSymlinks)
+					checkErr(t, test.err, err)
+					if !reflect.DeepEqual(got, test.dirs) {
+						t.Errorf("want: %v, got %v", test.dirs, got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestFs_ListDirsRecursiveDontFollowSymlinks(t *testing.T) {
+	testCases := []struct {
+		name string
+		dirs []string
+		err  error
+	}{
+		{".", []string{".", "a", "a/a"}, nil},
+
+		{"a", []string{"a", "a/a"}, nil},
+		{"a/a", []string{"a/a"}, nil},
+		{"a/a/a", nil, nil},
+
+		{"b", []string{"b", "b/a"}, nil},
+		{"b/a", []string{"b/a"}, nil},
+		{"b/a/a", nil, nil},
+
+		{"c", []string{"c"}, nil},
+		{"c/a", nil, nil},
+
+		{"d", []string{"d"}, nil},
+		{"d/a", nil, nil},
+
+		{"e", nil, nil},
+
+		{"dangling", nil, os.ErrNotExist},
+
+		{"missing", nil, os.ErrNotExist},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+
+			for _, test := range testCases {
+				t.Run(test.name, func(t *testing.T) {
+					got, err := fs.ListDirsRecursive(test.name, DontFollowSymlinks)
+					checkErr(t, test.err, err)
+					if !reflect.DeepEqual(got, test.dirs) {
+						t.Errorf("want: %v, got %v", test.dirs, got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestFs_Readlink(t *testing.T) {
+	testCases := []struct {
+		from, to string
+		err      error
+	}{
+		{".", "", syscall.EINVAL},
+		{"/", "", syscall.EINVAL},
+
+		{"a", "", syscall.EINVAL},
+		{"a/a", "", syscall.EINVAL},
+		{"a/a/a", "", syscall.EINVAL},
+		{"a/a/f", "../../f", nil},
+
+		{"b", "a", nil},
+		{"b/a", "", syscall.EINVAL},
+		{"b/a/a", "", syscall.EINVAL},
+		{"b/a/f", "../../f", nil},
+
+		{"c", "a/a", nil},
+		{"c/a", "", syscall.EINVAL},
+		{"c/f", "../../f", nil},
+
+		{"d/a", "", syscall.EINVAL},
+		{"d/f", "../../f", nil},
+
+		{"e", "a/a/a", nil},
+
+		{"f", "", syscall.EINVAL},
+
+		{"dangling", "missing", nil},
+
+		{"a/missing", "", os.ErrNotExist},
+		{"b/missing", "", os.ErrNotExist},
+		{"c/missing", "", os.ErrNotExist},
+		{"d/missing", "", os.ErrNotExist},
+		{"e/missing", "", os.ErrNotExist},
+		{"dangling/missing", "", os.ErrNotExist},
+
+		{"a/missing/missing", "", os.ErrNotExist},
+		{"b/missing/missing", "", os.ErrNotExist},
+		{"c/missing/missing", "", os.ErrNotExist},
+		{"d/missing/missing", "", os.ErrNotExist},
+		{"e/missing/missing", "", os.ErrNotExist},
+		{"dangling/missing/missing", "", os.ErrNotExist},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+
+			for _, test := range testCases {
+				t.Run(test.from, func(t *testing.T) {
+					got, err := fs.Readlink(test.from)
+					checkErr(t, test.err, err)
+					if got != test.to {
+						t.Errorf("fs.Readlink(%q) want: %q, got %q", test.from, test.to, got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestFs_Lstat(t *testing.T) {
+	testCases := []struct {
+		name string
+		mode os.FileMode
+		size int64
+		err  error
+	}{
+		{".", os.ModeDir, 0, nil},
+		{"/", os.ModeDir, 0, nil},
+
+		{"a", os.ModeDir, 0, nil},
+		{"a/a", os.ModeDir, 0, nil},
+		{"a/a/a", 0, 0, nil},
+		{"a/a/f", os.ModeSymlink, 7, nil},
+
+		{"b", os.ModeSymlink, 1, nil},
+		{"b/a", os.ModeDir, 0, nil},
+		{"b/a/a", 0, 0, nil},
+		{"b/a/f", os.ModeSymlink, 7, nil},
+
+		{"c", os.ModeSymlink, 3, nil},
+		{"c/a", 0, 0, nil},
+		{"c/f", os.ModeSymlink, 7, nil},
+
+		{"d/a", 0, 0, nil},
+		{"d/f", os.ModeSymlink, 7, nil},
+
+		{"e", os.ModeSymlink, 5, nil},
+
+		{"f", 0, 0, nil},
+
+		{"dangling", os.ModeSymlink, 7, nil},
+
+		{"a/missing", 0, 0, os.ErrNotExist},
+		{"b/missing", 0, 0, os.ErrNotExist},
+		{"c/missing", 0, 0, os.ErrNotExist},
+		{"d/missing", 0, 0, os.ErrNotExist},
+		{"e/missing", 0, 0, os.ErrNotExist},
+		{"dangling/missing", 0, 0, os.ErrNotExist},
+
+		{"a/missing/missing", 0, 0, os.ErrNotExist},
+		{"b/missing/missing", 0, 0, os.ErrNotExist},
+		{"c/missing/missing", 0, 0, os.ErrNotExist},
+		{"d/missing/missing", 0, 0, os.ErrNotExist},
+		{"e/missing/missing", 0, 0, os.ErrNotExist},
+		{"dangling/missing/missing", 0, 0, os.ErrNotExist},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+
+			for _, test := range testCases {
+				t.Run(test.name, func(t *testing.T) {
+					got, err := fs.Lstat(test.name)
+					checkErr(t, test.err, err)
+					if err != nil {
+						return
+					}
+					if got.Mode()&os.ModeType != test.mode {
+						t.Errorf("fs.Lstat(%q).Mode()&os.ModeType want: %x, got %x",
+							test.name, test.mode, got.Mode()&os.ModeType)
+					}
+					if test.mode == 0 && got.Size() != test.size {
+						t.Errorf("fs.Lstat(%q).Size() want: %d, got %d", test.name, test.size, got.Size())
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestFs_Stat(t *testing.T) {
+	testCases := []struct {
+		name string
+		mode os.FileMode
+		size int64
+		err  error
+	}{
+		{".", os.ModeDir, 0, nil},
+		{"/", os.ModeDir, 0, nil},
+
+		{"a", os.ModeDir, 0, nil},
+		{"a/a", os.ModeDir, 0, nil},
+		{"a/a/a", 0, 0, nil},
+		{"a/a/f", 0, 0, nil},
+
+		{"b", os.ModeDir, 0, nil},
+		{"b/a", os.ModeDir, 0, nil},
+		{"b/a/a", 0, 0, nil},
+		{"b/a/f", 0, 0, nil},
+
+		{"c", os.ModeDir, 0, nil},
+		{"c/a", 0, 0, nil},
+		{"c/f", 0, 0, nil},
+
+		{"d/a", 0, 0, nil},
+		{"d/f", 0, 0, nil},
+
+		{"e", 0, 0, nil},
+
+		{"f", 0, 0, nil},
+
+		{"dangling", 0, 0, os.ErrNotExist},
+
+		{"a/missing", 0, 0, os.ErrNotExist},
+		{"b/missing", 0, 0, os.ErrNotExist},
+		{"c/missing", 0, 0, os.ErrNotExist},
+		{"d/missing", 0, 0, os.ErrNotExist},
+		{"e/missing", 0, 0, os.ErrNotExist},
+		{"dangling/missing", 0, 0, os.ErrNotExist},
+
+		{"a/missing/missing", 0, 0, os.ErrNotExist},
+		{"b/missing/missing", 0, 0, os.ErrNotExist},
+		{"c/missing/missing", 0, 0, os.ErrNotExist},
+		{"d/missing/missing", 0, 0, os.ErrNotExist},
+		{"e/missing/missing", 0, 0, os.ErrNotExist},
+		{"dangling/missing/missing", 0, 0, os.ErrNotExist},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+
+			for _, test := range testCases {
+				t.Run(test.name, func(t *testing.T) {
+					got, err := fs.Stat(test.name)
+					checkErr(t, test.err, err)
+					if err != nil {
+						return
+					}
+					if got.Mode()&os.ModeType != test.mode {
+						t.Errorf("fs.Stat(%q).Mode()&os.ModeType want: %x, got %x",
+							test.name, test.mode, got.Mode()&os.ModeType)
+					}
+					if test.mode == 0 && got.Size() != test.size {
+						t.Errorf("fs.Stat(%q).Size() want: %d, got %d", test.name, test.size, got.Size())
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestMockFs_glob(t *testing.T) {
+	testCases := []struct {
+		pattern string
+		files   []string
+	}{
+		{"*", []string{"a", "b", "c", "d", "dangling", "e", "f"}},
+		{"./*", []string{"a", "b", "c", "d", "dangling", "e", "f"}},
+		{"a", []string{"a"}},
+		{"a/a", []string{"a/a"}},
+		{"a/*", []string{"a/a"}},
+		{"a/a/a", []string{"a/a/a"}},
+		{"a/a/f", []string{"a/a/f"}},
+		{"a/a/*", []string{"a/a/a", "a/a/f"}},
+
+		{"b", []string{"b"}},
+		{"b/a", []string{"b/a"}},
+		{"b/*", []string{"b/a"}},
+		{"b/a/a", []string{"b/a/a"}},
+		{"b/a/f", []string{"b/a/f"}},
+		{"b/a/*", []string{"b/a/a", "b/a/f"}},
+
+		{"c", []string{"c"}},
+		{"c/a", []string{"c/a"}},
+		{"c/f", []string{"c/f"}},
+		{"c/*", []string{"c/a", "c/f"}},
+
+		{"d", []string{"d"}},
+		{"d/a", []string{"d/a"}},
+		{"d/f", []string{"d/f"}},
+		{"d/*", []string{"d/a", "d/f"}},
+
+		{"e", []string{"e"}},
+
+		{"dangling", []string{"dangling"}},
+
+		{"missing", nil},
+	}
+
+	mock := symlinkMockFs()
+	fsList := []FileSystem{mock, OsFs}
+	names := []string{"mock", "os"}
+
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for i, fs := range fsList {
+		t.Run(names[i], func(t *testing.T) {
+			for _, test := range testCases {
+				t.Run(test.pattern, func(t *testing.T) {
+					got, err := fs.glob(test.pattern)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !reflect.DeepEqual(got, test.files) {
+						t.Errorf("want: %v, got %v", test.files, got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func syscallError(err error) error {
+	if serr, ok := err.(*os.SyscallError); ok {
+		return serr.Err.(syscall.Errno)
+	} else if serr, ok := err.(syscall.Errno); ok {
+		return serr
+	} else {
+		return nil
+	}
+}
+
+func checkErr(t *testing.T, want, got error) {
+	t.Helper()
+	if (got != nil) != (want != nil) {
+		t.Fatalf("want: %v, got %v", want, got)
+	}
+
+	if os.IsNotExist(got) == os.IsNotExist(want) {
+		return
+	}
+
+	if syscallError(got) == syscallError(want) {
+		return
+	}
+
+	t.Fatalf("want: %v, got %v", want, got)
+}
diff --git a/pathtools/glob.go b/pathtools/glob.go
index f7b32d7..67394d2 100644
--- a/pathtools/glob.go
+++ b/pathtools/glob.go
@@ -39,15 +39,17 @@
 // In general ModuleContext.GlobWithDeps or SingletonContext.GlobWithDeps
 // should be used instead, as they will automatically set up dependencies
 // to rerun the primary builder when the list of matching files changes.
-func Glob(pattern string, excludes []string) (matches, deps []string, err error) {
-	return startGlob(OsFs, pattern, excludes)
+func Glob(pattern string, excludes []string, follow ShouldFollowSymlinks) (matches, deps []string, err error) {
+	return startGlob(OsFs, pattern, excludes, follow)
 }
 
-func startGlob(fs FileSystem, pattern string, excludes []string) (matches, deps []string, err error) {
+func startGlob(fs FileSystem, pattern string, excludes []string,
+	follow ShouldFollowSymlinks) (matches, deps []string, err error) {
+
 	if filepath.Base(pattern) == "**" {
 		return nil, nil, GlobLastRecursiveErr
 	} else {
-		matches, deps, err = glob(fs, pattern, false)
+		matches, deps, err = glob(fs, pattern, false, follow)
 	}
 
 	if err != nil {
@@ -73,10 +75,24 @@
 	}
 
 	for i, match := range matches {
-		if isDir, err := fs.IsDir(match); err != nil {
-			return nil, nil, fmt.Errorf("IsDir(%s): %s", match, err.Error())
-		} else if isDir {
-			matches[i] = match + "/"
+		isSymlink, err := fs.IsSymlink(match)
+		if err != nil {
+			return nil, nil, err
+		}
+		if !(isSymlink && follow == DontFollowSymlinks) {
+			isDir, err := fs.IsDir(match)
+			if os.IsNotExist(err) {
+				if isSymlink {
+					return nil, nil, fmt.Errorf("%s: dangling symlink", match)
+				}
+			}
+			if err != nil {
+				return nil, nil, fmt.Errorf("%s: %s", match, err.Error())
+			}
+
+			if isDir {
+				matches[i] = match + "/"
+			}
 		}
 	}
 
@@ -85,7 +101,9 @@
 
 // glob is a recursive helper function to handle globbing each level of the pattern individually,
 // allowing searched directories to be tracked.  Also handles the recursive glob pattern, **.
-func glob(fs FileSystem, pattern string, hasRecursive bool) (matches, dirs []string, err error) {
+func glob(fs FileSystem, pattern string, hasRecursive bool,
+	follow ShouldFollowSymlinks) (matches, dirs []string, err error) {
+
 	if !isWild(pattern) {
 		// If there are no wilds in the pattern, check whether the file exists or not.
 		// Uses filepath.Glob instead of manually statting to get consistent results.
@@ -120,24 +138,32 @@
 		hasRecursive = true
 	}
 
-	dirMatches, dirs, err := glob(fs, dir, hasRecursive)
+	dirMatches, dirs, err := glob(fs, dir, hasRecursive, follow)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	for _, m := range dirMatches {
-		if isDir, err := fs.IsDir(m); err != nil {
+		isDir, err := fs.IsDir(m)
+		if os.IsNotExist(err) {
+			if isSymlink, _ := fs.IsSymlink(m); isSymlink {
+				return nil, nil, fmt.Errorf("dangling symlink: %s", m)
+			}
+		}
+		if err != nil {
 			return nil, nil, fmt.Errorf("unexpected error after glob: %s", err)
-		} else if isDir {
+		}
+
+		if isDir {
 			if file == "**" {
-				recurseDirs, err := fs.ListDirsRecursive(m)
+				recurseDirs, err := fs.ListDirsRecursive(m, follow)
 				if err != nil {
 					return nil, nil, err
 				}
 				matches = append(matches, recurseDirs...)
 			} else {
 				dirs = append(dirs, m)
-				newMatches, err := fs.glob(filepath.Join(m, file))
+				newMatches, err := fs.glob(filepath.Join(MatchEscape(m), file))
 				if err != nil {
 					return nil, nil, err
 				}
@@ -222,6 +248,18 @@
 		return false, GlobLastRecursiveErr
 	}
 
+	patternDir := pattern[len(pattern)-1] == '/'
+	nameDir := name[len(name)-1] == '/'
+
+	if patternDir != nameDir {
+		return false, nil
+	}
+
+	if nameDir {
+		name = name[:len(name)-1]
+		pattern = pattern[:len(pattern)-1]
+	}
+
 	for {
 		var patternFile, nameFile string
 		pattern, patternFile = saneSplit(pattern)
@@ -305,7 +343,7 @@
 
 	for _, pattern := range patterns {
 		if isWild(pattern) {
-			matches, deps, err = Glob(filepath.Join(prefix, pattern), nil)
+			matches, deps, err = Glob(filepath.Join(prefix, pattern), nil, FollowSymlinks)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -349,7 +387,7 @@
 // should be used instead, as they will automatically set up dependencies
 // to rerun the primary builder when the list of matching files changes.
 func GlobWithDepFile(glob, fileListFile, depFile string, excludes []string) (files []string, err error) {
-	files, deps, err := Glob(glob, excludes)
+	files, deps, err := Glob(glob, excludes, FollowSymlinks)
 	if err != nil {
 		return nil, err
 	}
@@ -414,3 +452,15 @@
 
 	return nil
 }
+
+var matchEscaper = strings.NewReplacer(
+	`*`, `\*`,
+	`?`, `\?`,
+	`[`, `\[`,
+	`]`, `\]`,
+)
+
+// MatchEscape returns its inputs with characters that would be interpreted by
+func MatchEscape(s string) string {
+	return matchEscaper.Replace(s)
+}
diff --git a/pathtools/glob_test.go b/pathtools/glob_test.go
index 1d17e10..0265df6 100644
--- a/pathtools/glob_test.go
+++ b/pathtools/glob_test.go
@@ -18,7 +18,6 @@
 	"os"
 	"path/filepath"
 	"reflect"
-	"strconv"
 	"testing"
 )
 
@@ -59,7 +58,26 @@
 		matches: []string{"a/a/a"},
 		deps:    []string{".", "a", "b", "c", "a/a"},
 	},
-
+	{
+		pattern: "c/*/?",
+		matches: []string{"c/h/h"},
+		deps:    []string{"c", "c/f", "c/g", "c/h"},
+	},
+	{
+		pattern: "c/*/[gh]*",
+		matches: []string{"c/g/g.ext", "c/h/h"},
+		deps:    []string{"c", "c/f", "c/g", "c/h"},
+	},
+	{
+		pattern: "c/*/[fgh]*",
+		matches: []string{"c/f/f.ext", "c/g/g.ext", "c/h/h"},
+		deps:    []string{"c", "c/f", "c/g", "c/h"},
+	},
+	{
+		pattern: "c/*/[f-h]*",
+		matches: []string{"c/f/f.ext", "c/g/g.ext", "c/h/h"},
+		deps:    []string{"c", "c/f", "c/g", "c/h"},
+	},
 	// ./ directory tests
 	{
 		pattern: "./*",
@@ -96,16 +114,16 @@
 
 	// absolute tests
 	{
-		pattern: filepath.Join(pwd, "testdata/c/*/*.ext"),
+		pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
 		matches: []string{
-			filepath.Join(pwd, "testdata/c/f/f.ext"),
-			filepath.Join(pwd, "testdata/c/g/g.ext"),
+			filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
+			filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
 		},
 		deps: []string{
-			filepath.Join(pwd, "testdata/c"),
-			filepath.Join(pwd, "testdata/c/f"),
-			filepath.Join(pwd, "testdata/c/g"),
-			filepath.Join(pwd, "testdata/c/h"),
+			filepath.Join(pwd, "testdata/glob/c"),
+			filepath.Join(pwd, "testdata/glob/c/f"),
+			filepath.Join(pwd, "testdata/glob/c/g"),
+			filepath.Join(pwd, "testdata/glob/c/h"),
 		},
 	},
 
@@ -152,23 +170,23 @@
 
 	// absolute recursive tests
 	{
-		pattern: filepath.Join(pwd, "testdata/**/*.ext"),
+		pattern: filepath.Join(pwd, "testdata/glob/**/*.ext"),
 		matches: []string{
-			filepath.Join(pwd, "testdata/d.ext"),
-			filepath.Join(pwd, "testdata/e.ext"),
-			filepath.Join(pwd, "testdata/c/f/f.ext"),
-			filepath.Join(pwd, "testdata/c/g/g.ext"),
+			filepath.Join(pwd, "testdata/glob/d.ext"),
+			filepath.Join(pwd, "testdata/glob/e.ext"),
+			filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
+			filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
 		},
 		deps: []string{
-			filepath.Join(pwd, "testdata"),
-			filepath.Join(pwd, "testdata/a"),
-			filepath.Join(pwd, "testdata/a/a"),
-			filepath.Join(pwd, "testdata/a/b"),
-			filepath.Join(pwd, "testdata/b"),
-			filepath.Join(pwd, "testdata/c"),
-			filepath.Join(pwd, "testdata/c/f"),
-			filepath.Join(pwd, "testdata/c/g"),
-			filepath.Join(pwd, "testdata/c/h"),
+			filepath.Join(pwd, "testdata/glob"),
+			filepath.Join(pwd, "testdata/glob/a"),
+			filepath.Join(pwd, "testdata/glob/a/a"),
+			filepath.Join(pwd, "testdata/glob/a/b"),
+			filepath.Join(pwd, "testdata/glob/b"),
+			filepath.Join(pwd, "testdata/glob/c"),
+			filepath.Join(pwd, "testdata/glob/c/f"),
+			filepath.Join(pwd, "testdata/glob/c/g"),
+			filepath.Join(pwd, "testdata/glob/c/h"),
 		},
 	},
 
@@ -232,29 +250,29 @@
 
 	// absolute exclude tests
 	{
-		pattern:  filepath.Join(pwd, "testdata/c/*/*.ext"),
-		excludes: []string{filepath.Join(pwd, "testdata/c/*/f.ext")},
+		pattern:  filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
+		excludes: []string{filepath.Join(pwd, "testdata/glob/c/*/f.ext")},
 		matches: []string{
-			filepath.Join(pwd, "testdata/c/g/g.ext"),
+			filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
 		},
 		deps: []string{
-			filepath.Join(pwd, "testdata/c"),
-			filepath.Join(pwd, "testdata/c/f"),
-			filepath.Join(pwd, "testdata/c/g"),
-			filepath.Join(pwd, "testdata/c/h"),
+			filepath.Join(pwd, "testdata/glob/c"),
+			filepath.Join(pwd, "testdata/glob/c/f"),
+			filepath.Join(pwd, "testdata/glob/c/g"),
+			filepath.Join(pwd, "testdata/glob/c/h"),
 		},
 	},
 	{
-		pattern:  filepath.Join(pwd, "testdata/c/*/*.ext"),
-		excludes: []string{filepath.Join(pwd, "testdata/c/f/*.ext")},
+		pattern:  filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
+		excludes: []string{filepath.Join(pwd, "testdata/glob/c/f/*.ext")},
 		matches: []string{
-			filepath.Join(pwd, "testdata/c/g/g.ext"),
+			filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
 		},
 		deps: []string{
-			filepath.Join(pwd, "testdata/c"),
-			filepath.Join(pwd, "testdata/c/f"),
-			filepath.Join(pwd, "testdata/c/g"),
-			filepath.Join(pwd, "testdata/c/h"),
+			filepath.Join(pwd, "testdata/glob/c"),
+			filepath.Join(pwd, "testdata/glob/c/f"),
+			filepath.Join(pwd, "testdata/glob/c/g"),
+			filepath.Join(pwd, "testdata/glob/c/h"),
 		},
 	},
 
@@ -304,16 +322,16 @@
 
 	// absoulte recursive exclude tests
 	{
-		pattern:  filepath.Join(pwd, "testdata/c/*/*.ext"),
-		excludes: []string{filepath.Join(pwd, "testdata/**/f.ext")},
+		pattern:  filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
+		excludes: []string{filepath.Join(pwd, "testdata/glob/**/f.ext")},
 		matches: []string{
-			filepath.Join(pwd, "testdata/c/g/g.ext"),
+			filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
 		},
 		deps: []string{
-			filepath.Join(pwd, "testdata/c"),
-			filepath.Join(pwd, "testdata/c/f"),
-			filepath.Join(pwd, "testdata/c/g"),
-			filepath.Join(pwd, "testdata/c/h"),
+			filepath.Join(pwd, "testdata/glob/c"),
+			filepath.Join(pwd, "testdata/glob/c/f"),
+			filepath.Join(pwd, "testdata/glob/c/g"),
+			filepath.Join(pwd, "testdata/glob/c/h"),
 		},
 	},
 
@@ -464,36 +482,245 @@
 
 	for _, f := range files {
 		mockFiles[f] = nil
-		mockFiles[filepath.Join(pwd, "testdata", f)] = nil
+		mockFiles[filepath.Join(pwd, "testdata/glob", f)] = nil
 	}
 
 	mock := MockFs(mockFiles)
 
-	for i, testCase := range globTestCases {
-		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			testGlob(t, mock, testCase)
+	for _, testCase := range globTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, mock, testCase, FollowSymlinks)
 		})
 	}
 }
 
 func TestGlob(t *testing.T) {
-	os.Chdir("testdata")
-	defer os.Chdir("..")
-	for i, testCase := range globTestCases {
-		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			testGlob(t, OsFs, testCase)
+	os.Chdir("testdata/glob")
+	defer os.Chdir("../..")
+	for _, testCase := range globTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, OsFs, testCase, FollowSymlinks)
 		})
 	}
 }
 
-func testGlob(t *testing.T, fs FileSystem, testCase globTestCase) {
-	matches, deps, err := fs.Glob(testCase.pattern, testCase.excludes)
+var globEscapeTestCases = []globTestCase{
+	{
+		pattern: `**/*`,
+		matches: []string{`*`, `**/`, `?`, `a/`, `b`, `**/*`, `**/a`, `**/b/`, `**/b/b`, `a/a`},
+		deps:    []string{`.`, `**`, `**/b`, `a`},
+	},
+	{
+		pattern: `**/\*`,
+		matches: []string{`*`, `**/*`},
+		deps:    []string{`.`, `**`, `**/b`, `a`},
+	},
+	{
+		pattern: `\*\*/*`,
+		matches: []string{`**/*`, `**/a`, `**/b/`},
+		deps:    []string{`.`, `**`},
+	},
+	{
+		pattern: `\*\*/**/*`,
+		matches: []string{`**/*`, `**/a`, `**/b/`, `**/b/b`},
+		deps:    []string{`.`, `**`, `**/b`},
+	},
+}
+
+func TestMockGlobEscapes(t *testing.T) {
+	files := []string{
+		`*`,
+		`**/*`,
+		`**/a`,
+		`**/b/b`,
+		`?`,
+		`a/a`,
+		`b`,
+	}
+
+	mockFiles := make(map[string][]byte)
+
+	for _, f := range files {
+		mockFiles[f] = nil
+	}
+
+	mock := MockFs(mockFiles)
+
+	for _, testCase := range globEscapeTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, mock, testCase, FollowSymlinks)
+		})
+	}
+
+}
+
+func TestGlobEscapes(t *testing.T) {
+	os.Chdir("testdata/escapes")
+	defer os.Chdir("../..")
+	for _, testCase := range globEscapeTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, OsFs, testCase, FollowSymlinks)
+		})
+	}
+
+}
+
+var globSymlinkTestCases = []globTestCase{
+	{
+		pattern: `**/*`,
+		matches: []string{"a/", "b/", "c/", "d/", "e", "a/a/", "a/a/a", "b/a/", "b/a/a", "c/a", "d/a"},
+		deps:    []string{".", "a", "a/a", "b", "b/a", "c", "d"},
+	},
+	{
+		pattern: `b/**/*`,
+		matches: []string{"b/a/", "b/a/a"},
+		deps:    []string{"b", "b/a"},
+	},
+}
+
+func TestMockGlobSymlinks(t *testing.T) {
+	files := []string{
+		"a/a/a",
+		"b -> a",
+		"c -> a/a",
+		"d -> c",
+		"e -> a/a/a",
+	}
+
+	mockFiles := make(map[string][]byte)
+
+	for _, f := range files {
+		mockFiles[f] = nil
+	}
+
+	mock := MockFs(mockFiles)
+
+	for _, testCase := range globSymlinkTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, mock, testCase, FollowSymlinks)
+		})
+	}
+}
+
+func TestGlobSymlinks(t *testing.T) {
+	os.Chdir("testdata/symlinks")
+	defer os.Chdir("../..")
+
+	for _, testCase := range globSymlinkTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, OsFs, testCase, FollowSymlinks)
+		})
+	}
+}
+
+var globDontFollowSymlinkTestCases = []globTestCase{
+	{
+		pattern: `**/*`,
+		matches: []string{"a/", "b", "c", "d", "e", "a/a/", "a/a/a"},
+		deps:    []string{".", "a", "a/a"},
+	},
+	{
+		pattern: `b/**/*`,
+		matches: []string{"b/a/", "b/a/a"},
+		deps:    []string{"b", "b/a"},
+	},
+}
+
+func TestMockGlobDontFollowSymlinks(t *testing.T) {
+	files := []string{
+		"a/a/a",
+		"b -> a",
+		"c -> a/a",
+		"d -> c",
+		"e -> a/a/a",
+	}
+
+	mockFiles := make(map[string][]byte)
+
+	for _, f := range files {
+		mockFiles[f] = nil
+	}
+
+	mock := MockFs(mockFiles)
+
+	for _, testCase := range globDontFollowSymlinkTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, mock, testCase, DontFollowSymlinks)
+		})
+	}
+}
+
+func TestGlobDontFollowSymlinks(t *testing.T) {
+	os.Chdir("testdata/symlinks")
+	defer os.Chdir("../..")
+
+	for _, testCase := range globDontFollowSymlinkTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, OsFs, testCase, DontFollowSymlinks)
+		})
+	}
+}
+
+var globDontFollowDanglingSymlinkTestCases = []globTestCase{
+	{
+		pattern: `**/*`,
+		matches: []string{"a/", "b", "c", "d", "dangling", "e", "f", "a/a/", "a/a/a", "a/a/f"},
+		deps:    []string{".", "a", "a/a"},
+	},
+	{
+		pattern: `dangling`,
+		matches: []string{"dangling"},
+		deps:    []string{"dangling"},
+	},
+}
+
+func TestMockGlobDontFollowDanglingSymlinks(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 globDontFollowDanglingSymlinkTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, mock, testCase, DontFollowSymlinks)
+		})
+	}
+}
+
+func TestGlobDontFollowDanglingSymlinks(t *testing.T) {
+	os.Chdir("testdata/dangling")
+	defer os.Chdir("../..")
+
+	for _, testCase := range globDontFollowDanglingSymlinkTestCases {
+		t.Run(testCase.pattern, func(t *testing.T) {
+			testGlob(t, OsFs, testCase, DontFollowSymlinks)
+		})
+	}
+}
+
+func testGlob(t *testing.T, fs FileSystem, testCase globTestCase, follow ShouldFollowSymlinks) {
+	t.Helper()
+	matches, deps, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
 	if err != testCase.err {
-		t.Errorf(" pattern: %q", testCase.pattern)
-		if testCase.excludes != nil {
-			t.Errorf("excludes: %q", testCase.excludes)
+		if err == nil {
+			t.Fatalf("missing error: %s", testCase.err)
+		} else {
+			t.Fatalf("error: %s", err)
 		}
-		t.Errorf("   error: %s", err)
 		return
 	}
 
@@ -516,3 +743,100 @@
 		t.Errorf("expected: %#v", testCase.deps)
 	}
 }
+
+func TestMatch(t *testing.T) {
+	testCases := []struct {
+		pattern, name string
+		match         bool
+	}{
+		{"a/*", "b/", false},
+		{"a/*", "b/a", false},
+		{"a/*", "b/b/", false},
+		{"a/*", "b/b/c", false},
+		{"a/**/*", "b/", false},
+		{"a/**/*", "b/a", false},
+		{"a/**/*", "b/b/", false},
+		{"a/**/*", "b/b/c", 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/**/*/", "a/", false},
+		{"a/**/*/", "a/a", false},
+		{"a/**/*/", "a/b/", true},
+		{"a/**/*/", "a/b/c", false},
+
+		{`a/\*\*/\*`, `a/**/*`, true},
+		{`a/\*\*/\*`, `a/a/*`, false},
+		{`a/\*\*/\*`, `a/**/a`, false},
+		{`a/\*\*/\*`, `a/a/a`, false},
+
+		{`a/**/\*`, `a/**/*`, true},
+		{`a/**/\*`, `a/a/*`, true},
+		{`a/**/\*`, `a/**/a`, false},
+		{`a/**/\*`, `a/a/a`, false},
+
+		{`a/\*\*/*`, `a/**/*`, true},
+		{`a/\*\*/*`, `a/a/*`, false},
+		{`a/\*\*/*`, `a/**/a`, true},
+		{`a/\*\*/*`, `a/a/a`, false},
+
+		{`*/**/a`, `a/a/a`, true},
+		{`*/**/a`, `*/a/a`, true},
+		{`*/**/a`, `a/**/a`, true},
+		{`*/**/a`, `*/**/a`, true},
+
+		{`\*/\*\*/a`, `a/a/a`, false},
+		{`\*/\*\*/a`, `*/a/a`, false},
+		{`\*/\*\*/a`, `a/**/a`, false},
+		{`\*/\*\*/a`, `*/**/a`, true},
+
+		{`a/?`, `a/?`, true},
+		{`a/?`, `a/a`, true},
+		{`a/\?`, `a/?`, true},
+		{`a/\?`, `a/a`, false},
+
+		{`a/?`, `a/?`, true},
+		{`a/?`, `a/a`, true},
+		{`a/\?`, `a/?`, true},
+		{`a/\?`, `a/a`, false},
+
+		{`a/[a-c]`, `a/b`, true},
+		{`a/[abc]`, `a/b`, true},
+
+		{`a/\[abc]`, `a/b`, false},
+		{`a/\[abc]`, `a/[abc]`, true},
+
+		{`a/\[abc\]`, `a/b`, false},
+		{`a/\[abc\]`, `a/[abc]`, true},
+
+		{`a/?`, `a/?`, true},
+		{`a/?`, `a/a`, true},
+		{`a/\?`, `a/?`, true},
+		{`a/\?`, `a/a`, false},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.pattern+","+test.name, func(t *testing.T) {
+			match, err := Match(test.pattern, test.name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if match != test.match {
+				t.Errorf("want: %v, got %v", test.match, match)
+			}
+		})
+	}
+}
diff --git a/pathtools/testdata/a/a/a b/pathtools/testdata/dangling/a/a/a
similarity index 100%
copy from pathtools/testdata/a/a/a
copy to pathtools/testdata/dangling/a/a/a
diff --git a/pathtools/testdata/dangling/a/a/f b/pathtools/testdata/dangling/a/a/f
new file mode 120000
index 0000000..8a1f8dd
--- /dev/null
+++ b/pathtools/testdata/dangling/a/a/f
@@ -0,0 +1 @@
+../../f
\ No newline at end of file
diff --git a/pathtools/testdata/dangling/b b/pathtools/testdata/dangling/b
new file mode 120000
index 0000000..2e65efe
--- /dev/null
+++ b/pathtools/testdata/dangling/b
@@ -0,0 +1 @@
+a
\ No newline at end of file
diff --git a/pathtools/testdata/dangling/c b/pathtools/testdata/dangling/c
new file mode 120000
index 0000000..de35cbe
--- /dev/null
+++ b/pathtools/testdata/dangling/c
@@ -0,0 +1 @@
+a/a
\ No newline at end of file
diff --git a/pathtools/testdata/dangling/d b/pathtools/testdata/dangling/d
new file mode 120000
index 0000000..3410062
--- /dev/null
+++ b/pathtools/testdata/dangling/d
@@ -0,0 +1 @@
+c
\ No newline at end of file
diff --git a/pathtools/testdata/dangling/dangling b/pathtools/testdata/dangling/dangling
new file mode 120000
index 0000000..6eab79a
--- /dev/null
+++ b/pathtools/testdata/dangling/dangling
@@ -0,0 +1 @@
+missing
\ No newline at end of file
diff --git a/pathtools/testdata/dangling/e b/pathtools/testdata/dangling/e
new file mode 120000
index 0000000..6bf79dd
--- /dev/null
+++ b/pathtools/testdata/dangling/e
@@ -0,0 +1 @@
+a/a/a
\ No newline at end of file
diff --git a/pathtools/testdata/c/g/g.ext b/pathtools/testdata/dangling/f
similarity index 100%
copy from pathtools/testdata/c/g/g.ext
copy to pathtools/testdata/dangling/f
diff --git a/pathtools/testdata/.test/.ing b/pathtools/testdata/escapes/*
similarity index 100%
copy from pathtools/testdata/.test/.ing
copy to pathtools/testdata/escapes/*
diff --git a/pathtools/testdata/.test/.ing b/pathtools/testdata/escapes/**/*
similarity index 100%
copy from pathtools/testdata/.test/.ing
copy to pathtools/testdata/escapes/**/*
diff --git a/pathtools/testdata/.test/a b/pathtools/testdata/escapes/**/a
similarity index 100%
copy from pathtools/testdata/.test/a
copy to pathtools/testdata/escapes/**/a
diff --git a/pathtools/testdata/a/b/b b/pathtools/testdata/escapes/**/b/b
similarity index 100%
copy from pathtools/testdata/a/b/b
copy to pathtools/testdata/escapes/**/b/b
diff --git a/pathtools/testdata/.test/.ing b/pathtools/testdata/escapes/?
similarity index 100%
copy from pathtools/testdata/.test/.ing
copy to pathtools/testdata/escapes/?
diff --git a/pathtools/testdata/a/a/a b/pathtools/testdata/escapes/a/a
similarity index 100%
copy from pathtools/testdata/a/a/a
copy to pathtools/testdata/escapes/a/a
diff --git a/pathtools/testdata/a/b/b b/pathtools/testdata/escapes/b
similarity index 100%
copy from pathtools/testdata/a/b/b
copy to pathtools/testdata/escapes/b
diff --git a/pathtools/testdata/.test/.ing b/pathtools/testdata/glob/.test/.ing
similarity index 100%
rename from pathtools/testdata/.test/.ing
rename to pathtools/testdata/glob/.test/.ing
diff --git a/pathtools/testdata/.test/a b/pathtools/testdata/glob/.test/a
similarity index 100%
rename from pathtools/testdata/.test/a
rename to pathtools/testdata/glob/.test/a
diff --git a/pathtools/testdata/.testing b/pathtools/testdata/glob/.testing
similarity index 100%
rename from pathtools/testdata/.testing
rename to pathtools/testdata/glob/.testing
diff --git a/pathtools/testdata/a/a/a b/pathtools/testdata/glob/a/a/a
similarity index 100%
rename from pathtools/testdata/a/a/a
rename to pathtools/testdata/glob/a/a/a
diff --git a/pathtools/testdata/a/b/b b/pathtools/testdata/glob/a/b/b
similarity index 100%
rename from pathtools/testdata/a/b/b
rename to pathtools/testdata/glob/a/b/b
diff --git a/pathtools/testdata/b/a b/pathtools/testdata/glob/b/a
similarity index 100%
rename from pathtools/testdata/b/a
rename to pathtools/testdata/glob/b/a
diff --git a/pathtools/testdata/c/c b/pathtools/testdata/glob/c/c
similarity index 100%
rename from pathtools/testdata/c/c
rename to pathtools/testdata/glob/c/c
diff --git a/pathtools/testdata/c/f/f.ext b/pathtools/testdata/glob/c/f/f.ext
similarity index 100%
rename from pathtools/testdata/c/f/f.ext
rename to pathtools/testdata/glob/c/f/f.ext
diff --git a/pathtools/testdata/c/g/g.ext b/pathtools/testdata/glob/c/g/g.ext
similarity index 100%
rename from pathtools/testdata/c/g/g.ext
rename to pathtools/testdata/glob/c/g/g.ext
diff --git a/pathtools/testdata/c/h/h b/pathtools/testdata/glob/c/h/h
similarity index 100%
rename from pathtools/testdata/c/h/h
rename to pathtools/testdata/glob/c/h/h
diff --git a/pathtools/testdata/d.ext b/pathtools/testdata/glob/d.ext
similarity index 100%
rename from pathtools/testdata/d.ext
rename to pathtools/testdata/glob/d.ext
diff --git a/pathtools/testdata/e.ext b/pathtools/testdata/glob/e.ext
similarity index 100%
rename from pathtools/testdata/e.ext
rename to pathtools/testdata/glob/e.ext
diff --git a/pathtools/testdata/a/a/a b/pathtools/testdata/symlinks/a/a/a
similarity index 100%
copy from pathtools/testdata/a/a/a
copy to pathtools/testdata/symlinks/a/a/a
diff --git a/pathtools/testdata/symlinks/b b/pathtools/testdata/symlinks/b
new file mode 120000
index 0000000..2e65efe
--- /dev/null
+++ b/pathtools/testdata/symlinks/b
@@ -0,0 +1 @@
+a
\ No newline at end of file
diff --git a/pathtools/testdata/symlinks/c b/pathtools/testdata/symlinks/c
new file mode 120000
index 0000000..de35cbe
--- /dev/null
+++ b/pathtools/testdata/symlinks/c
@@ -0,0 +1 @@
+a/a
\ No newline at end of file
diff --git a/pathtools/testdata/symlinks/d b/pathtools/testdata/symlinks/d
new file mode 120000
index 0000000..3410062
--- /dev/null
+++ b/pathtools/testdata/symlinks/d
@@ -0,0 +1 @@
+c
\ No newline at end of file
diff --git a/pathtools/testdata/symlinks/e b/pathtools/testdata/symlinks/e
new file mode 120000
index 0000000..6bf79dd
--- /dev/null
+++ b/pathtools/testdata/symlinks/e
@@ -0,0 +1 @@
+a/a/a
\ No newline at end of file
diff --git a/proptools/clone.go b/proptools/clone.go
index 9948b9a..dbd72b4 100644
--- a/proptools/clone.go
+++ b/proptools/clone.go
@@ -52,9 +52,6 @@
 			CopyProperties(dstFieldValue, srcFieldValue)
 		case reflect.Slice:
 			if !srcFieldValue.IsNil() {
-				if field.Type.Elem().Kind() != reflect.String {
-					panic(fmt.Errorf("can't copy field %q: slice elements are not strings", field.Name))
-				}
 				if srcFieldValue != dstFieldValue {
 					newSlice := reflect.MakeSlice(field.Type, srcFieldValue.Len(),
 						srcFieldValue.Len())
diff --git a/proptools/clone_test.go b/proptools/clone_test.go
index b6f1bf6..660f1c0 100644
--- a/proptools/clone_test.go
+++ b/proptools/clone_test.go
@@ -71,6 +71,19 @@
 		out: &struct{ S []string }{},
 	},
 	{
+		// Clone slice of structs
+		in: &struct{ S []struct{ T string } }{
+			S: []struct{ T string }{
+				{"string1"}, {"string2"},
+			},
+		},
+		out: &struct{ S []struct{ T string } }{
+			S: []struct{ T string }{
+				{"string1"}, {"string2"},
+			},
+		},
+	},
+	{
 		// Clone pointer to bool
 		in: &struct{ B1, B2 *bool }{
 			B1: BoolPtr(true),
@@ -317,6 +330,17 @@
 		out: &struct{ S []string }{},
 	},
 	{
+		// Clone slice of structs
+		in: &struct{ S []struct{ T string } }{
+			S: []struct{ T string }{
+				{"string1"}, {"string2"},
+			},
+		},
+		out: &struct{ S []struct{ T string } }{
+			S: []struct{ T string }(nil),
+		},
+	},
+	{
 		// Clone pointer to bool
 		in: &struct{ B1, B2 *bool }{
 			B1: BoolPtr(true),
diff --git a/singleton_ctx.go b/singleton_ctx.go
index bbfce00..1b044fa 100644
--- a/singleton_ctx.go
+++ b/singleton_ctx.go
@@ -47,6 +47,10 @@
 	// set at most one time for a single build, later calls are ignored.
 	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.
+	AddSubninja(file string)
+
 	// Eval takes a string with embedded ninja variables, and returns a string
 	// with all of the variables recursively expanded. Any variables references
 	// are expanded in the scope of the PackageContext.
@@ -203,8 +207,23 @@
 	s.context.setNinjaBuildDir(ninjaValue)
 }
 
+func (s *singletonContext) AddSubninja(file string) {
+	s.context.subninjas = append(s.context.subninjas, file)
+}
+
 func (s *singletonContext) VisitAllModules(visit func(Module)) {
-	s.context.VisitAllModules(visit)
+	var visitingModule Module
+	defer func() {
+		if r := recover(); r != nil {
+			panic(newPanicErrorf(r, "VisitAllModules(%s) for module %s",
+				funcName(visit), visitingModule))
+		}
+	}()
+
+	s.context.VisitAllModules(func(m Module) {
+		visitingModule = m
+		visit(m)
+	})
 }
 
 func (s *singletonContext) VisitAllModulesIf(pred func(Module) bool,
diff --git a/unpack.go b/unpack.go
index cd165da..3156599 100644
--- a/unpack.go
+++ b/unpack.go
@@ -163,7 +163,9 @@
 		case reflect.Slice:
 			elemType := field.Type.Elem()
 			if elemType.Kind() != reflect.String {
-				panic(fmt.Errorf("field %s is a non-string slice", propertyName))
+				if !proptools.HasTag(field, "blueprint", "mutated") {
+					panic(fmt.Errorf("field %s is a non-string slice", propertyName))
+				}
 			}
 		case reflect.Interface:
 			if fieldValue.IsNil() {
diff --git a/unpack_test.go b/unpack_test.go
index b65fa3f..d6b88ab 100644
--- a/unpack_test.go
+++ b/unpack_test.go
@@ -111,13 +111,15 @@
 		`,
 		output: []interface{}{
 			struct {
-				Stuff []string
-				Empty []string
-				Nil   []string
+				Stuff     []string
+				Empty     []string
+				Nil       []string
+				NonString []struct{ S string } `blueprint:"mutated"`
 			}{
-				Stuff: []string{"asdf", "jkl;", "qwert", "uiop", "bnm,"},
-				Empty: []string{},
-				Nil:   nil,
+				Stuff:     []string{"asdf", "jkl;", "qwert", "uiop", "bnm,"},
+				Empty:     []string{},
+				Nil:       nil,
+				NonString: nil,
 			},
 		},
 	},
diff --git a/visit_test.go b/visit_test.go
index 3aa0f1b..873e72c 100644
--- a/visit_test.go
+++ b/visit_test.go
@@ -83,6 +83,9 @@
 //   D
 //   |
 //   E
+//  / \
+//  \ /
+//   F
 func setupVisitTest(t *testing.T) *Context {
 	ctx := NewContext()
 	ctx.RegisterModuleType("visit_module", newVisitModule)
@@ -113,6 +116,11 @@
 	
 			visit_module {
 				name: "E",
+				visit: ["F", "F"],
+			}
+
+			visit_module {
+				name: "F",
 			}
 		`),
 	})
@@ -142,10 +150,16 @@
 	ctx := setupVisitTest(t)
 
 	topModule := ctx.modulesFromName("A", nil)[0].logicModule.(*visitModule)
-	assertString(t, topModule.properties.VisitDepsDepthFirst, "EDCB")
-	assertString(t, topModule.properties.VisitDepsDepthFirstIf, "EDC")
+	assertString(t, topModule.properties.VisitDepsDepthFirst, "FEDCB")
+	assertString(t, topModule.properties.VisitDepsDepthFirstIf, "FEDC")
 	assertString(t, topModule.properties.VisitDirectDeps, "B")
 	assertString(t, topModule.properties.VisitDirectDepsIf, "")
+
+	eModule := ctx.modulesFromName("E", nil)[0].logicModule.(*visitModule)
+	assertString(t, eModule.properties.VisitDepsDepthFirst, "F")
+	assertString(t, eModule.properties.VisitDepsDepthFirstIf, "F")
+	assertString(t, eModule.properties.VisitDirectDeps, "FF")
+	assertString(t, eModule.properties.VisitDirectDepsIf, "FF")
 }
 
 func assertString(t *testing.T, got, expected string) {