diff --git a/Blueprints b/Blueprints
index c3c8975..ecc0792 100644
--- a/Blueprints
+++ b/Blueprints
@@ -19,15 +19,14 @@
         "package_ctx.go",
         "scope.go",
         "singleton_ctx.go",
-        "unpack.go",
     ],
     testSrcs: [
         "context_test.go",
         "glob_test.go",
+        "module_ctx_test.go",
         "ninja_strings_test.go",
         "ninja_writer_test.go",
         "splice_modules_test.go",
-        "unpack_test.go",
         "visit_test.go",
     ],
 }
@@ -75,6 +74,9 @@
 bootstrap_go_package {
     name: "blueprint-proptools",
     pkgPath: "github.com/google/blueprint/proptools",
+    deps: [
+        "blueprint-parser",
+    ],
     srcs: [
         "proptools/clone.go",
         "proptools/escape.go",
@@ -83,6 +85,7 @@
         "proptools/proptools.go",
         "proptools/tag.go",
         "proptools/typeequal.go",
+        "proptools/unpack.go",
     ],
     testSrcs: [
         "proptools/clone_test.go",
@@ -91,6 +94,7 @@
         "proptools/filter_test.go",
         "proptools/tag_test.go",
         "proptools/typeequal_test.go",
+        "proptools/unpack_test.go",
     ],
 }
 
diff --git a/bootstrap/bootstrap.go b/bootstrap/bootstrap.go
index 1799e68..bb85e7d 100644
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -27,6 +27,7 @@
 	"github.com/google/blueprint/pathtools"
 )
 
+const mainSubDir = ".primary"
 const bootstrapSubDir = ".bootstrap"
 const miniBootstrapSubDir = ".minibootstrap"
 
@@ -143,15 +144,16 @@
 		"depfile")
 
 	_ = pctx.VariableFunc("BinDir", func(config interface{}) (string, error) {
-		return binDir(), nil
+		return bootstrapBinDir(), nil
 	})
 
 	_ = pctx.VariableFunc("ToolDir", func(config interface{}) (string, error) {
 		return toolDir(config), nil
 	})
 
-	docsDir = filepath.Join(bootstrapDir, "docs")
+	docsDir = filepath.Join(mainDir, "docs")
 
+	mainDir          = filepath.Join("$buildDir", mainSubDir)
 	bootstrapDir     = filepath.Join("$buildDir", bootstrapSubDir)
 	miniBootstrapDir = filepath.Join("$buildDir", miniBootstrapSubDir)
 
@@ -165,7 +167,7 @@
 	isGoBinary()
 }
 
-func binDir() string {
+func bootstrapBinDir() string {
 	return filepath.Join(BuildDir, bootstrapSubDir, "bin")
 }
 
@@ -307,14 +309,14 @@
 		return
 	}
 
-	g.pkgRoot = packageRoot(ctx)
+	g.pkgRoot = packageRoot(ctx, g.config)
 	g.archiveFile = filepath.Join(g.pkgRoot,
 		filepath.FromSlash(g.properties.PkgPath)+".a")
 
 	ctx.VisitDepsDepthFirstIf(isGoPluginFor(name),
 		func(module blueprint.Module) { hasPlugins = true })
 	if hasPlugins {
-		pluginSrc = filepath.Join(moduleGenSrcDir(ctx), "plugin.go")
+		pluginSrc = filepath.Join(moduleGenSrcDir(ctx, g.config), "plugin.go")
 		genSrcs = append(genSrcs, pluginSrc)
 	}
 
@@ -332,9 +334,9 @@
 	}
 
 	if g.config.runGoTests {
-		testArchiveFile := filepath.Join(testRoot(ctx),
+		testArchiveFile := filepath.Join(testRoot(ctx, g.config),
 			filepath.FromSlash(g.properties.PkgPath)+".a")
-		g.testResultFile = buildGoTest(ctx, testRoot(ctx), testArchiveFile,
+		g.testResultFile = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
 			g.properties.PkgPath, srcs, genSrcs,
 			testSrcs)
 	}
@@ -395,9 +397,9 @@
 func (g *goBinary) GenerateBuildActions(ctx blueprint.ModuleContext) {
 	var (
 		name            = ctx.ModuleName()
-		objDir          = moduleObjDir(ctx)
+		objDir          = moduleObjDir(ctx, g.config)
 		archiveFile     = filepath.Join(objDir, name+".a")
-		testArchiveFile = filepath.Join(testRoot(ctx), name+".a")
+		testArchiveFile = filepath.Join(testRoot(ctx, g.config), name+".a")
 		aoutFile        = filepath.Join(objDir, "a.out")
 		hasPlugins      = false
 		pluginSrc       = ""
@@ -406,14 +408,16 @@
 
 	if g.properties.Tool_dir {
 		g.installPath = filepath.Join(toolDir(ctx.Config()), name)
+	} else if g.config.stage == StageMain {
+		g.installPath = filepath.Join(mainDir, "bin", name)
 	} else {
-		g.installPath = filepath.Join(binDir(), name)
+		g.installPath = filepath.Join(bootstrapDir, "bin", name)
 	}
 
 	ctx.VisitDepsDepthFirstIf(isGoPluginFor(name),
 		func(module blueprint.Module) { hasPlugins = true })
 	if hasPlugins {
-		pluginSrc = filepath.Join(moduleGenSrcDir(ctx), "plugin.go")
+		pluginSrc = filepath.Join(moduleGenSrcDir(ctx, g.config), "plugin.go")
 		genSrcs = append(genSrcs, pluginSrc)
 	}
 
@@ -433,7 +437,7 @@
 	}
 
 	if g.config.runGoTests {
-		deps = buildGoTest(ctx, testRoot(ctx), testArchiveFile,
+		deps = buildGoTest(ctx, testRoot(ctx, g.config), testArchiveFile,
 			name, srcs, genSrcs, testSrcs)
 	}
 
@@ -687,7 +691,7 @@
 
 	if s.config.stage == StagePrimary {
 		mainNinjaFile := filepath.Join("$buildDir", "build.ninja")
-		primaryBuilderNinjaGlobFile := filepath.Join(BuildDir, bootstrapSubDir, "build-globs.ninja")
+		primaryBuilderNinjaGlobFile := absolutePath(filepath.Join(BuildDir, bootstrapSubDir, "build-globs.ninja"))
 
 		if _, err := os.Stat(primaryBuilderNinjaGlobFile); os.IsNotExist(err) {
 			err = ioutil.WriteFile(primaryBuilderNinjaGlobFile, nil, 0666)
@@ -758,18 +762,26 @@
 	}
 }
 
+func stageDir(config *Config) string {
+	if config.stage == StageMain {
+		return mainDir
+	} else {
+		return bootstrapDir
+	}
+}
+
 // packageRoot returns the module-specific package root directory path.  This
 // directory is where the final package .a files are output and where dependant
 // modules search for this package via -I arguments.
-func packageRoot(ctx blueprint.ModuleContext) string {
-	return filepath.Join(bootstrapDir, ctx.ModuleName(), "pkg")
+func packageRoot(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "pkg")
 }
 
 // testRoot returns the module-specific package root directory path used for
 // building tests. The .a files generated here will include everything from
 // packageRoot, plus the test-only code.
-func testRoot(ctx blueprint.ModuleContext) string {
-	return filepath.Join(bootstrapDir, ctx.ModuleName(), "test")
+func testRoot(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "test")
 }
 
 // moduleSrcDir returns the path of the directory that all source file paths are
@@ -779,11 +791,11 @@
 }
 
 // moduleObjDir returns the module-specific object directory path.
-func moduleObjDir(ctx blueprint.ModuleContext) string {
-	return filepath.Join(bootstrapDir, ctx.ModuleName(), "obj")
+func moduleObjDir(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "obj")
 }
 
 // moduleGenSrcDir returns the module-specific generated sources path.
-func moduleGenSrcDir(ctx blueprint.ModuleContext) string {
-	return filepath.Join(bootstrapDir, ctx.ModuleName(), "gen")
+func moduleGenSrcDir(ctx blueprint.ModuleContext, config *Config) string {
+	return filepath.Join(stageDir(config), ctx.ModuleName(), "gen")
 }
diff --git a/bootstrap/bpdoc/bpdoc.go b/bootstrap/bpdoc/bpdoc.go
index 4acfc5d..4abf2e7 100644
--- a/bootstrap/bpdoc/bpdoc.go
+++ b/bootstrap/bpdoc/bpdoc.go
@@ -6,7 +6,6 @@
 	"reflect"
 	"sort"
 
-	"github.com/google/blueprint"
 	"github.com/google/blueprint/proptools"
 )
 
@@ -146,14 +145,6 @@
 				return nil, fmt.Errorf("nesting point %q not found", nestedName)
 			}
 
-			key, value, err := blueprint.HasFilter(nestPoint.Tag)
-			if err != nil {
-				return nil, err
-			}
-			if key != "" {
-				nested.IncludeByTag(key, value)
-			}
-
 			nestPoint.Nest(nested)
 		}
 		mt.PropertyStructs = append(mt.PropertyStructs, ps)
diff --git a/bootstrap/cleanup.go b/bootstrap/cleanup.go
index 4a8ce25..6444081 100644
--- a/bootstrap/cleanup.go
+++ b/bootstrap/cleanup.go
@@ -70,7 +70,7 @@
 	for _, filePath := range filePaths {
 		isTarget := targets[filePath]
 		if !isTarget {
-			err = removeFileAndEmptyDirs(filePath)
+			err = removeFileAndEmptyDirs(absolutePath(filePath))
 			if err != nil {
 				return err
 			}
diff --git a/bootstrap/command.go b/bootstrap/command.go
index bf6bbe9..1e3b2fe 100644
--- a/bootstrap/command.go
+++ b/bootstrap/command.go
@@ -47,6 +47,8 @@
 	BuildDir      string
 	NinjaBuildDir string
 	SrcDir        string
+
+	absSrcDir string
 )
 
 func init() {
@@ -76,8 +78,10 @@
 		debug.SetGCPercent(-1)
 	}
 
+	absSrcDir = ctx.SrcDir()
+
 	if cpuprofile != "" {
-		f, err := os.Create(cpuprofile)
+		f, err := os.Create(absolutePath(cpuprofile))
 		if err != nil {
 			fatalf("error opening cpuprofile: %s", err)
 		}
@@ -87,7 +91,7 @@
 	}
 
 	if traceFile != "" {
-		f, err := os.Create(traceFile)
+		f, err := os.Create(absolutePath(traceFile))
 		if err != nil {
 			fatalf("error opening trace: %s", err)
 		}
@@ -140,7 +144,7 @@
 
 	ctx.RegisterSingletonType("glob", globSingletonFactory(ctx))
 
-	deps, errs := ctx.ParseFileList(filepath.Dir(bootstrapConfig.topLevelBlueprintsFile), filesToParse)
+	deps, errs := ctx.ParseFileList(filepath.Dir(bootstrapConfig.topLevelBlueprintsFile), filesToParse, config)
 	if len(errs) > 0 {
 		fatalErrors(errs)
 	}
@@ -155,7 +159,7 @@
 	deps = append(deps, extraDeps...)
 
 	if docFile != "" {
-		err := writeDocs(ctx, docFile)
+		err := writeDocs(ctx, absolutePath(docFile))
 		if err != nil {
 			fatalErrors([]error{err})
 		}
@@ -180,7 +184,7 @@
 	var buf *bufio.Writer
 
 	if stage != StageMain || !emptyNinjaFile {
-		f, err = os.OpenFile(outFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, outFilePermissions)
+		f, err = os.OpenFile(absolutePath(outFile), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, outFilePermissions)
 		if err != nil {
 			fatalf("error opening Ninja file: %s", err)
 		}
@@ -190,6 +194,25 @@
 		out = ioutil.Discard
 	}
 
+	if globFile != "" {
+		buffer, errs := generateGlobNinjaFile(ctx.Globs)
+		if len(errs) > 0 {
+			fatalErrors(errs)
+		}
+
+		err = ioutil.WriteFile(absolutePath(globFile), buffer, outFilePermissions)
+		if err != nil {
+			fatalf("error writing %s: %s", globFile, err)
+		}
+	}
+
+	if depFile != "" {
+		err := deptools.WriteDepFile(absolutePath(depFile), outFile, deps)
+		if err != nil {
+			fatalf("error writing depfile: %s", err)
+		}
+	}
+
 	err = ctx.WriteBuildFile(out)
 	if err != nil {
 		fatalf("error writing Ninja file contents: %s", err)
@@ -209,25 +232,6 @@
 		}
 	}
 
-	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 {
-			fatalf("error writing depfile: %s", err)
-		}
-	}
-
 	if c, ok := config.(ConfigRemoveAbandonedFilesUnder); ok {
 		under, except := c.RemoveAbandonedFilesUnder()
 		err := removeAbandonedFilesUnder(ctx, bootstrapConfig, SrcDir, under, except)
@@ -237,7 +241,7 @@
 	}
 
 	if memprofile != "" {
-		f, err := os.Create(memprofile)
+		f, err := os.Create(absolutePath(memprofile))
 		if err != nil {
 			fatalf("error opening memprofile: %s", err)
 		}
@@ -268,3 +272,10 @@
 	}
 	os.Exit(1)
 }
+
+func absolutePath(path string) string {
+	if filepath.IsAbs(path) {
+		return path
+	}
+	return filepath.Join(absSrcDir, path)
+}
diff --git a/bootstrap/config.go b/bootstrap/config.go
index 0772b0a..9499aeb 100644
--- a/bootstrap/config.go
+++ b/bootstrap/config.go
@@ -30,7 +30,7 @@
 }
 
 var (
-	// These variables are the only configuration needed by the boostrap
+	// These variables are the only configuration needed by the bootstrap
 	// modules.
 	srcDir = bootstrapVariable("srcDir", func() string {
 		return SrcDir
diff --git a/bootstrap/glob.go b/bootstrap/glob.go
index 9841611..52dbf2f 100644
--- a/bootstrap/glob.go
+++ b/bootstrap/glob.go
@@ -131,8 +131,14 @@
 			depFile := fileListFile + ".d"
 
 			fileList := strings.Join(g.Files, "\n") + "\n"
-			pathtools.WriteFileIfChanged(fileListFile, []byte(fileList), 0666)
-			deptools.WriteDepFile(depFile, fileListFile, g.Deps)
+			err := pathtools.WriteFileIfChanged(absolutePath(fileListFile), []byte(fileList), 0666)
+			if err != nil {
+				panic(fmt.Errorf("error writing %s: %s", fileListFile, err))
+			}
+			err = deptools.WriteDepFile(absolutePath(depFile), fileListFile, g.Deps)
+			if err != nil {
+				panic(fmt.Errorf("error writing %s: %s", depFile, err))
+			}
 
 			GlobFile(ctx, g.Pattern, g.Excludes, fileListFile, depFile)
 		} else {
diff --git a/context.go b/context.go
index cedf3d8..1ad1588 100644
--- a/context.go
+++ b/context.go
@@ -96,15 +96,15 @@
 	// set during PrepareBuildActions
 	pkgNames        map[*packageContext]string
 	liveGlobals     *liveTracker
-	globalVariables map[Variable]*ninjaString
+	globalVariables map[Variable]ninjaString
 	globalPools     map[Pool]*poolDef
 	globalRules     map[Rule]*ruleDef
 
 	// set during PrepareBuildActions
-	ninjaBuildDir      *ninjaString // The builddir special Ninja variable
-	requiredNinjaMajor int          // For the ninja_required_version variable
-	requiredNinjaMinor int          // For the ninja_required_version variable
-	requiredNinjaMicro int          // For the ninja_required_version variable
+	ninjaBuildDir      ninjaString // The builddir special Ninja variable
+	requiredNinjaMajor int         // For the ninja_required_version variable
+	requiredNinjaMinor int         // For the ninja_required_version variable
+	requiredNinjaMicro int         // For the ninja_required_version variable
 
 	subninjas []string
 
@@ -114,6 +114,7 @@
 	globs    map[string]GlobPath
 	globLock sync.Mutex
 
+	srcDir         string
 	fs             pathtools.FileSystem
 	moduleListFile string
 }
@@ -157,11 +158,19 @@
 	buildDefs []*buildDef
 }
 
+type moduleAlias struct {
+	variantName       string
+	variant           variationMap
+	dependencyVariant variationMap
+	target            *moduleInfo
+}
+
 type moduleGroup struct {
 	name      string
 	ninjaName string
 
 	modules []*moduleInfo
+	aliases []*moduleAlias
 
 	namespace Namespace
 }
@@ -197,6 +206,7 @@
 
 	// set during each runMutator
 	splitModules []*moduleInfo
+	aliasTarget  *moduleInfo
 
 	// set during PrepareBuildActions
 	actionDefs localBuildActions
@@ -242,6 +252,9 @@
 type variationMap map[string]string
 
 func (vm variationMap) clone() variationMap {
+	if vm == nil {
+		return nil
+	}
 	newVm := make(variationMap)
 	for k, v := range vm {
 		newVm[k] = v
@@ -436,6 +449,15 @@
 	c.nameInterface = i
 }
 
+func (c *Context) SetSrcDir(path string) {
+	c.srcDir = path
+	c.fs = pathtools.NewOsFs(path)
+}
+
+func (c *Context) SrcDir() string {
+	return c.srcDir
+}
+
 func singletonPkgPath(singleton Singleton) string {
 	typ := reflect.TypeOf(singleton)
 	for typ.Kind() == reflect.Ptr {
@@ -619,17 +641,19 @@
 // which the future output will depend is returned.  This list will include both
 // Blueprints file paths as well as directory paths for cases where wildcard
 // subdirs are found.
-func (c *Context) ParseBlueprintsFiles(rootFile string) (deps []string, errs []error) {
+func (c *Context) ParseBlueprintsFiles(rootFile string,
+	config interface{}) (deps []string, errs []error) {
+
 	baseDir := filepath.Dir(rootFile)
 	pathsToParse, err := c.ListModulePaths(baseDir)
 	if err != nil {
 		return nil, []error{err}
 	}
-	return c.ParseFileList(baseDir, pathsToParse)
+	return c.ParseFileList(baseDir, pathsToParse, config)
 }
 
-func (c *Context) ParseFileList(rootDir string, filePaths []string) (deps []string,
-	errs []error) {
+func (c *Context) ParseFileList(rootDir string, filePaths []string,
+	config interface{}) (deps []string, errs []error) {
 
 	if len(filePaths) < 1 {
 		return nil, []error{fmt.Errorf("no paths provided to parse")}
@@ -637,7 +661,12 @@
 
 	c.dependenciesReady = false
 
-	moduleCh := make(chan *moduleInfo)
+	type newModuleInfo struct {
+		*moduleInfo
+		added chan<- struct{}
+	}
+
+	moduleCh := make(chan newModuleInfo)
 	errsCh := make(chan []error)
 	doneCh := make(chan struct{})
 	var numErrs uint32
@@ -649,24 +678,47 @@
 			return
 		}
 
+		addedCh := make(chan struct{})
+
+		var scopedModuleFactories map[string]ModuleFactory
+
+		var addModule func(module *moduleInfo) []error
+		addModule = func(module *moduleInfo) (errs []error) {
+			moduleCh <- newModuleInfo{module, addedCh}
+			<-addedCh
+			var newModules []*moduleInfo
+			newModules, errs = runAndRemoveLoadHooks(c, config, module, &scopedModuleFactories)
+			if len(errs) > 0 {
+				return errs
+			}
+			for _, n := range newModules {
+				errs = addModule(n)
+				if len(errs) > 0 {
+					return errs
+				}
+			}
+			return nil
+		}
+
 		for _, def := range file.Defs {
-			var module *moduleInfo
-			var errs []error
 			switch def := def.(type) {
 			case *parser.Module:
-				module, errs = c.processModuleDef(def, file.Name)
+				module, errs := c.processModuleDef(def, file.Name, scopedModuleFactories)
+				if len(errs) == 0 && module != nil {
+					errs = addModule(module)
+				}
+
+				if len(errs) > 0 {
+					atomic.AddUint32(&numErrs, uint32(len(errs)))
+					errsCh <- errs
+				}
+
 			case *parser.Assignment:
 				// Already handled via Scope object
 			default:
 				panic("unknown definition type")
 			}
 
-			if len(errs) > 0 {
-				atomic.AddUint32(&numErrs, uint32(len(errs)))
-				errsCh <- errs
-			} else if module != nil {
-				moduleCh <- module
-			}
 		}
 	}
 
@@ -686,7 +738,10 @@
 		case newErrs := <-errsCh:
 			errs = append(errs, newErrs...)
 		case module := <-moduleCh:
-			newErrs := c.addModule(module)
+			newErrs := c.addModule(module.moduleInfo)
+			if module.added != nil {
+				module.added <- struct{}{}
+			}
 			if len(newErrs) > 0 {
 				errs = append(errs, newErrs...)
 			}
@@ -877,6 +932,10 @@
 	c.fs = pathtools.MockFs(files)
 }
 
+func (c *Context) SetFs(fs pathtools.FileSystem) {
+	c.fs = fs
+}
+
 // openAndParse opens and parses a single Blueprints file, and returns the results
 func (c *Context) openAndParse(filename string, scope *parser.Scope, rootDir string,
 	parent *fileParseContext) (file *parser.File,
@@ -1143,8 +1202,8 @@
 	}
 
 	for i := range newProperties {
-		dst := reflect.ValueOf(newProperties[i]).Elem()
-		src := reflect.ValueOf(origModule.properties[i]).Elem()
+		dst := reflect.ValueOf(newProperties[i])
+		src := reflect.ValueOf(origModule.properties[i])
 
 		proptools.CopyProperties(dst, src)
 	}
@@ -1178,6 +1237,9 @@
 		}
 
 		newVariant := origModule.variant.clone()
+		if newVariant == nil {
+			newVariant = make(variationMap)
+		}
 		newVariant[mutatorName] = variationName
 
 		m := *origModule
@@ -1261,6 +1323,19 @@
 	return strings.Join(names, ", ")
 }
 
+func (c *Context) prettyPrintGroupVariants(group *moduleGroup) string {
+	var variants []string
+	for _, mod := range group.modules {
+		variants = append(variants, c.prettyPrintVariant(mod.variant))
+	}
+	for _, mod := range group.aliases {
+		variants = append(variants, c.prettyPrintVariant(mod.variant)+
+			"(alias to "+c.prettyPrintVariant(mod.target.variant)+")")
+	}
+	sort.Strings(variants)
+	return strings.Join(variants, "\n  ")
+}
+
 func (c *Context) newModule(factory ModuleFactory) *moduleInfo {
 	logicModule, properties := factory()
 
@@ -1275,9 +1350,12 @@
 }
 
 func (c *Context) processModuleDef(moduleDef *parser.Module,
-	relBlueprintsFile string) (*moduleInfo, []error) {
+	relBlueprintsFile string, scopedModuleFactories map[string]ModuleFactory) (*moduleInfo, []error) {
 
 	factory, ok := c.moduleFactories[moduleDef.Type]
+	if !ok && scopedModuleFactories != nil {
+		factory, ok = scopedModuleFactories[moduleDef.Type]
+	}
 	if !ok {
 		if c.ignoreUnknownModuleTypes {
 			return nil, nil
@@ -1296,8 +1374,17 @@
 
 	module.relBlueprintsFile = relBlueprintsFile
 
-	propertyMap, errs := unpackProperties(moduleDef.Properties, module.properties...)
+	propertyMap, errs := proptools.UnpackProperties(moduleDef.Properties, module.properties...)
 	if len(errs) > 0 {
+		for i, err := range errs {
+			if unpackErr, ok := err.(*proptools.UnpackError); ok {
+				err = &BlueprintError{
+					Err: unpackErr.Err,
+					Pos: unpackErr.Pos,
+				}
+				errs[i] = err
+			}
+		}
 		return nil, errs
 	}
 
@@ -1410,9 +1497,9 @@
 
 // findMatchingVariant searches the moduleGroup for a module with the same variant as module,
 // and returns the matching module, or nil if one is not found.
-func (c *Context) findMatchingVariant(module *moduleInfo, possible []*moduleInfo, reverse bool) *moduleInfo {
-	if len(possible) == 1 {
-		return possible[0]
+func (c *Context) findMatchingVariant(module *moduleInfo, possible *moduleGroup, reverse bool) *moduleInfo {
+	if len(possible.modules) == 1 {
+		return possible.modules[0]
 	} else {
 		var variantToMatch variationMap
 		if !reverse {
@@ -1423,11 +1510,16 @@
 			// For reverse dependency, use all the variants
 			variantToMatch = module.variant
 		}
-		for _, m := range possible {
+		for _, m := range possible.modules {
 			if m.variant.equal(variantToMatch) {
 				return m
 			}
 		}
+		for _, m := range possible.aliases {
+			if m.variant.equal(variantToMatch) {
+				return m.target
+			}
+		}
 	}
 
 	return nil
@@ -1445,7 +1537,7 @@
 		}}
 	}
 
-	possibleDeps := c.modulesFromName(depName, module.namespace())
+	possibleDeps := c.moduleGroupFromName(depName, module.namespace())
 	if possibleDeps == nil {
 		return c.discoveredMissingDependencies(module, depName)
 	}
@@ -1456,17 +1548,11 @@
 		return nil
 	}
 
-	variants := make([]string, len(possibleDeps))
-	for i, mod := range possibleDeps {
-		variants[i] = c.prettyPrintVariant(mod.variant)
-	}
-	sort.Strings(variants)
-
 	return []error{&BlueprintError{
 		Err: fmt.Errorf("dependency %q of %q missing variant:\n  %s\navailable variants:\n  %s",
 			depName, module.Name(),
 			c.prettyPrintVariant(module.dependencyVariant),
-			strings.Join(variants, "\n  ")),
+			c.prettyPrintGroupVariants(possibleDeps)),
 		Pos: module.pos,
 	}}
 }
@@ -1479,7 +1565,7 @@
 		}}
 	}
 
-	possibleDeps := c.modulesFromName(destName, module.namespace())
+	possibleDeps := c.moduleGroupFromName(destName, module.namespace())
 	if possibleDeps == nil {
 		return nil, []error{&BlueprintError{
 			Err: fmt.Errorf("%q has a reverse dependency on undefined module %q",
@@ -1492,17 +1578,11 @@
 		return m, nil
 	}
 
-	variants := make([]string, len(possibleDeps))
-	for i, mod := range possibleDeps {
-		variants[i] = c.prettyPrintVariant(mod.variant)
-	}
-	sort.Strings(variants)
-
 	return nil, []error{&BlueprintError{
 		Err: fmt.Errorf("reverse dependency %q of %q missing variant:\n  %s\navailable variants:\n  %s",
 			destName, module.Name(),
 			c.prettyPrintVariant(module.dependencyVariant),
-			strings.Join(variants, "\n  ")),
+			c.prettyPrintGroupVariants(possibleDeps)),
 		Pos: module.pos,
 	}}
 }
@@ -1513,7 +1593,7 @@
 		panic("BaseDependencyTag is not allowed to be used directly!")
 	}
 
-	possibleDeps := c.modulesFromName(depName, module.namespace())
+	possibleDeps := c.moduleGroupFromName(depName, module.namespace())
 	if possibleDeps == nil {
 		return c.discoveredMissingDependencies(module, depName)
 	}
@@ -1524,55 +1604,67 @@
 	var newVariant variationMap
 	if !far {
 		newVariant = module.dependencyVariant.clone()
-	} else {
-		newVariant = make(variationMap)
 	}
 	for _, v := range variations {
+		if newVariant == nil {
+			newVariant = make(variationMap)
+		}
 		newVariant[v.Mutator] = v.Variation
 	}
 
-	for _, m := range possibleDeps {
-		var found bool
+	check := func(variant variationMap) bool {
 		if far {
-			found = m.variant.subset(newVariant)
+			return variant.subset(newVariant)
 		} else {
-			found = m.variant.equal(newVariant)
-		}
-		if found {
-			if module == m {
-				return []error{&BlueprintError{
-					Err: fmt.Errorf("%q depends on itself", depName),
-					Pos: module.pos,
-				}}
-			}
-			// AddVariationDependency allows adding a dependency on itself, but only if
-			// that module is earlier in the module list than this one, since we always
-			// run GenerateBuildActions in order for the variants of a module
-			if m.group == module.group && beforeInModuleList(module, m, module.group.modules) {
-				return []error{&BlueprintError{
-					Err: fmt.Errorf("%q depends on later version of itself", depName),
-					Pos: module.pos,
-				}}
-			}
-			module.newDirectDeps = append(module.newDirectDeps, depInfo{m, tag})
-			atomic.AddUint32(&c.depsModified, 1)
-			return nil
+			return variant.equal(newVariant)
 		}
 	}
 
-	variants := make([]string, len(possibleDeps))
-	for i, mod := range possibleDeps {
-		variants[i] = c.prettyPrintVariant(mod.variant)
+	var foundDep *moduleInfo
+	for _, m := range possibleDeps.modules {
+		if check(m.variant) {
+			foundDep = m
+			break
+		}
 	}
-	sort.Strings(variants)
 
-	return []error{&BlueprintError{
-		Err: fmt.Errorf("dependency %q of %q missing variant:\n  %s\navailable variants:\n  %s",
-			depName, module.Name(),
-			c.prettyPrintVariant(newVariant),
-			strings.Join(variants, "\n  ")),
-		Pos: module.pos,
-	}}
+	if foundDep == nil {
+		for _, m := range possibleDeps.aliases {
+			if check(m.variant) {
+				foundDep = m.target
+				break
+			}
+		}
+	}
+
+	if foundDep == nil {
+		return []error{&BlueprintError{
+			Err: fmt.Errorf("dependency %q of %q missing variant:\n  %s\navailable variants:\n  %s",
+				depName, module.Name(),
+				c.prettyPrintVariant(newVariant),
+				c.prettyPrintGroupVariants(possibleDeps)),
+			Pos: module.pos,
+		}}
+	}
+
+	if module == foundDep {
+		return []error{&BlueprintError{
+			Err: fmt.Errorf("%q depends on itself", depName),
+			Pos: module.pos,
+		}}
+	}
+	// AddVariationDependency allows adding a dependency on itself, but only if
+	// that module is earlier in the module list than this one, since we always
+	// run GenerateBuildActions in order for the variants of a module
+	if foundDep.group == module.group && beforeInModuleList(module, foundDep, module.group.modules) {
+		return []error{&BlueprintError{
+			Err: fmt.Errorf("%q depends on later version of itself", depName),
+			Pos: module.pos,
+		}}
+	}
+	module.newDirectDeps = append(module.newDirectDeps, depInfo{foundDep, tag})
+	atomic.AddUint32(&c.depsModified, 1)
+	return nil
 }
 
 func (c *Context) addInterVariantDependency(origModule *moduleInfo, tag DependencyTag,
@@ -2166,6 +2258,16 @@
 				group.modules, i = spliceModules(group.modules, i, module.splitModules)
 			}
 
+			// Create any new aliases.
+			if module.aliasTarget != nil {
+				group.aliases = append(group.aliases, &moduleAlias{
+					variantName:       module.variantName,
+					variant:           module.variant,
+					dependencyVariant: module.dependencyVariant,
+					target:            module.aliasTarget,
+				})
+			}
+
 			// Fix up any remaining dependencies on modules that were split into variants
 			// by replacing them with the first variant
 			for j, dep := range module.directDeps {
@@ -2182,6 +2284,21 @@
 			module.directDeps = append(module.directDeps, module.newDirectDeps...)
 			module.newDirectDeps = nil
 		}
+
+		// Forward or delete any dangling aliases.
+		for i := 0; i < len(group.aliases); i++ {
+			alias := group.aliases[i]
+
+			if alias.target.logicModule == nil {
+				if alias.target.aliasTarget != nil {
+					alias.target = alias.target.aliasTarget
+				} else {
+					// The alias was left dangling, remove it.
+					group.aliases = append(group.aliases[:i], group.aliases[i+1:]...)
+					i--
+				}
+			}
+		}
 	}
 
 	// Add in any new reverse dependencies that were added by the mutator
@@ -2510,18 +2627,24 @@
 }
 
 func (c *Context) moduleMatchingVariant(module *moduleInfo, name string) *moduleInfo {
-	targets := c.modulesFromName(name, module.namespace())
+	group := c.moduleGroupFromName(name, module.namespace())
 
-	if targets == nil {
+	if group == nil {
 		return nil
 	}
 
-	for _, m := range targets {
+	for _, m := range group.modules {
 		if module.variantName == m.variantName {
 			return m
 		}
 	}
 
+	for _, m := range group.aliases {
+		if module.variantName == m.variantName {
+			return m.target
+		}
+	}
+
 	return nil
 }
 
@@ -2573,10 +2696,10 @@
 	}
 }
 
-func (c *Context) modulesFromName(name string, namespace Namespace) []*moduleInfo {
+func (c *Context) moduleGroupFromName(name string, namespace Namespace) *moduleGroup {
 	group, exists := c.nameInterface.ModuleFromName(name, namespace)
 	if exists {
-		return group.modules
+		return group.moduleGroup
 	}
 	return nil
 }
@@ -2665,7 +2788,7 @@
 	}
 }
 
-func (c *Context) setNinjaBuildDir(value *ninjaString) {
+func (c *Context) setNinjaBuildDir(value ninjaString) {
 	if c.ninjaBuildDir == nil {
 		c.ninjaBuildDir = value
 	}
@@ -2731,7 +2854,7 @@
 }
 
 func (c *Context) checkForVariableReferenceCycles(
-	variables map[Variable]*ninjaString, pkgNames map[*packageContext]string) {
+	variables map[Variable]ninjaString, pkgNames map[*packageContext]string) {
 
 	visited := make(map[Variable]bool)  // variables that were already checked
 	checking := make(map[Variable]bool) // variables actively being checked
@@ -2744,7 +2867,7 @@
 		defer delete(checking, v)
 
 		value := variables[v]
-		for _, dep := range value.variables {
+		for _, dep := range value.Variables() {
 			if checking[dep] {
 				// This is a cycle.
 				return []Variable{dep, v}
@@ -3229,7 +3352,7 @@
 
 		// First visit variables on which this variable depends.
 		value := c.globalVariables[v]
-		for _, dep := range value.variables {
+		for _, dep := range value.Variables() {
 			if !visited[dep] {
 				err := walk(dep)
 				if err != nil {
diff --git a/context_test.go b/context_test.go
index 0d783dc..d4e9bf7 100644
--- a/context_test.go
+++ b/context_test.go
@@ -168,7 +168,7 @@
 
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
-	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -188,7 +188,7 @@
 
 	var outputDown string
 	var outputUp string
-	topModule := ctx.modulesFromName("A", nil)[0]
+	topModule := ctx.moduleGroupFromName("A", nil).modules[0]
 	ctx.walkDeps(topModule, false,
 		func(dep depInfo, parent *moduleInfo) bool {
 			outputDown += ctx.ModuleName(dep.module.logicModule)
@@ -260,7 +260,7 @@
 
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
-	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -280,7 +280,7 @@
 
 	var outputDown string
 	var outputUp string
-	topModule := ctx.modulesFromName("A", nil)[0]
+	topModule := ctx.moduleGroupFromName("A", nil).modules[0]
 	ctx.walkDeps(topModule, true,
 		func(dep depInfo, parent *moduleInfo) bool {
 			outputDown += ctx.ModuleName(dep.module.logicModule)
@@ -316,7 +316,7 @@
 
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
-	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -334,10 +334,10 @@
 		t.FailNow()
 	}
 
-	a := ctx.modulesFromName("A", nil)[0].logicModule.(*fooModule)
-	b := ctx.modulesFromName("B", nil)[0].logicModule.(*barModule)
-	c := ctx.modulesFromName("C", nil)[0].logicModule.(*barModule)
-	d := ctx.modulesFromName("D", nil)[0].logicModule.(*fooModule)
+	a := ctx.moduleGroupFromName("A", nil).modules[0].logicModule.(*fooModule)
+	b := ctx.moduleGroupFromName("B", nil).modules[0].logicModule.(*barModule)
+	c := ctx.moduleGroupFromName("C", nil).modules[0].logicModule.(*barModule)
+	d := ctx.moduleGroupFromName("D", nil).modules[0].logicModule.(*fooModule)
 
 	checkDeps := func(m Module, expected string) {
 		var deps []string
@@ -499,7 +499,7 @@
 	ctx.RegisterModuleType("foo_module", newFooModule)
 	ctx.RegisterModuleType("bar_module", newBarModule)
 
-	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 
 	expectedErrs := []error{
 		errors.New(`Blueprints:6:4: property 'name' is missing from a module`),
diff --git a/live_tracker.go b/live_tracker.go
index 5e13a87..40e1930 100644
--- a/live_tracker.go
+++ b/live_tracker.go
@@ -24,7 +24,7 @@
 	sync.Mutex
 	config interface{} // Used to evaluate variable, rule, and pool values.
 
-	variables map[Variable]*ninjaString
+	variables map[Variable]ninjaString
 	pools     map[Pool]*poolDef
 	rules     map[Rule]*ruleDef
 }
@@ -32,7 +32,7 @@
 func newLiveTracker(config interface{}) *liveTracker {
 	return &liveTracker{
 		config:    config,
-		variables: make(map[Variable]*ninjaString),
+		variables: make(map[Variable]ninjaString),
 		pools:     make(map[Pool]*poolDef),
 		rules:     make(map[Rule]*ruleDef),
 	}
@@ -170,7 +170,7 @@
 	return nil
 }
 
-func (l *liveTracker) addNinjaStringListDeps(list []*ninjaString) error {
+func (l *liveTracker) addNinjaStringListDeps(list []ninjaString) error {
 	for _, str := range list {
 		err := l.addNinjaStringDeps(str)
 		if err != nil {
@@ -180,8 +180,8 @@
 	return nil
 }
 
-func (l *liveTracker) addNinjaStringDeps(str *ninjaString) error {
-	for _, v := range str.variables {
+func (l *liveTracker) addNinjaStringDeps(str ninjaString) error {
+	for _, v := range str.Variables() {
 		err := l.addVariable(v)
 		if err != nil {
 			return err
diff --git a/module_ctx.go b/module_ctx.go
index be5d974..012142e 100644
--- a/module_ctx.go
+++ b/module_ctx.go
@@ -17,6 +17,7 @@
 import (
 	"fmt"
 	"path/filepath"
+	"sync"
 	"text/scanner"
 
 	"github.com/google/blueprint/pathtools"
@@ -120,7 +121,7 @@
 	DynamicDependencies(DynamicDependerModuleContext) []string
 }
 
-type BaseModuleContext interface {
+type EarlyModuleContext interface {
 	// Module returns the current module as a Module.  It should rarely be necessary, as the module already has a
 	// reference to itself.
 	Module() Module
@@ -136,6 +137,10 @@
 	// RegisterModuleType.
 	ModuleType() string
 
+	// BlueprintFile returns the name of the blueprint file that contains the definition of this
+	// module.
+	BlueprintsFile() string
+
 	// Config returns the config object that was passed to Context.PrepareBuildActions.
 	Config() interface{}
 
@@ -179,6 +184,13 @@
 	// default SimpleNameInterface if Context.SetNameInterface was not called.
 	Namespace() Namespace
 
+	// ModuleFactories returns a map of all of the global ModuleFactories by name.
+	ModuleFactories() map[string]ModuleFactory
+}
+
+type BaseModuleContext interface {
+	EarlyModuleContext
+
 	// GetDirectDepWithTag returns the Module the direct dependency with the specified name, or nil if
 	// none exists.  It panics if the dependency does not have the specified tag.
 	GetDirectDepWithTag(name string, tag DependencyTag) Module
@@ -343,6 +355,10 @@
 	return filepath.Dir(d.module.relBlueprintsFile)
 }
 
+func (d *baseModuleContext) BlueprintsFile() string {
+	return d.module.relBlueprintsFile
+}
+
 func (d *baseModuleContext) Config() interface{} {
 	return d.config
 }
@@ -597,6 +613,14 @@
 	m.ninjaFileDeps = append(m.ninjaFileDeps, deps...)
 }
 
+func (m *baseModuleContext) ModuleFactories() map[string]ModuleFactory {
+	ret := make(map[string]ModuleFactory)
+	for k, v := range m.context.moduleFactories {
+		ret[k] = v
+	}
+	return ret
+}
+
 func (m *moduleContext) ModuleSubDir() string {
 	return m.module.variantName
 }
@@ -785,6 +809,13 @@
 	// specified name with the current variant of this module.  Replacements don't take effect until
 	// after the mutator pass is finished.
 	ReplaceDependencies(string)
+
+	// AliasVariation takes a variationName that was passed to CreateVariations for this module, and creates an
+	// alias from the current variant to the new variant.  The alias will be valid until the next time a mutator
+	// calls CreateVariations or CreateLocalVariations on this module without also calling AliasVariation.  The
+	// alias can be used to add dependencies on the newly created variant using the variant map from before
+	// CreateVariations was run.
+	AliasVariation(variationName string)
 }
 
 // A Mutator function is called for each Module, and can use
@@ -838,6 +869,9 @@
 	for i, module := range modules {
 		ret = append(ret, module.logicModule)
 		if !local {
+			if module.dependencyVariant == nil {
+				module.dependencyVariant = make(variationMap)
+			}
 			module.dependencyVariant[mctx.name] = variationNames[i]
 		}
 	}
@@ -854,6 +888,25 @@
 	return ret
 }
 
+func (mctx *mutatorContext) AliasVariation(variationName string) {
+	if mctx.module.aliasTarget != nil {
+		panic(fmt.Errorf("AliasVariation already called"))
+	}
+
+	for _, variant := range mctx.newVariations {
+		if variant.variant[mctx.name] == variationName {
+			mctx.module.aliasTarget = variant
+			return
+		}
+	}
+
+	var foundVariations []string
+	for _, variant := range mctx.newVariations {
+		foundVariations = append(foundVariations, variant.variant[mctx.name])
+	}
+	panic(fmt.Errorf("no %q variation in module variations %q", variationName, foundVariations))
+}
+
 func (mctx *mutatorContext) SetDependencyVariation(variationName string) {
 	mctx.context.convertDepsToVariation(mctx.module, mctx.name, variationName, nil)
 }
@@ -966,3 +1019,107 @@
 func (s *SimpleName) Name() string {
 	return s.Properties.Name
 }
+
+// Load Hooks
+
+type LoadHookContext interface {
+	EarlyModuleContext
+
+	// CreateModule creates a new module by calling the factory method for the specified moduleType, and applies
+	// the specified property structs to it as if the properties were set in a blueprint file.
+	CreateModule(ModuleFactory, ...interface{}) Module
+
+	// RegisterScopedModuleType creates a new module type that is scoped to the current Blueprints
+	// file.
+	RegisterScopedModuleType(name string, factory ModuleFactory)
+}
+
+func (l *loadHookContext) CreateModule(factory ModuleFactory, props ...interface{}) Module {
+	module := l.context.newModule(factory)
+
+	module.relBlueprintsFile = l.module.relBlueprintsFile
+	module.pos = l.module.pos
+	module.propertyPos = l.module.propertyPos
+	module.createdBy = l.module
+
+	for _, p := range props {
+		err := proptools.AppendMatchingProperties(module.properties, p, nil)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	l.newModules = append(l.newModules, module)
+
+	return module.logicModule
+}
+
+func (l *loadHookContext) RegisterScopedModuleType(name string, factory ModuleFactory) {
+	if _, exists := l.context.moduleFactories[name]; exists {
+		panic(fmt.Errorf("A global module type named %q already exists", name))
+	}
+
+	if _, exists := (*l.scopedModuleFactories)[name]; exists {
+		panic(fmt.Errorf("A module type named %q already exists in this scope", name))
+	}
+
+	if *l.scopedModuleFactories == nil {
+		(*l.scopedModuleFactories) = make(map[string]ModuleFactory)
+	}
+
+	(*l.scopedModuleFactories)[name] = factory
+}
+
+type loadHookContext struct {
+	baseModuleContext
+	newModules            []*moduleInfo
+	scopedModuleFactories *map[string]ModuleFactory
+}
+
+type LoadHook func(ctx LoadHookContext)
+
+// Load hooks need to be added by module factories, which don't have any parameter to get to the
+// Context, and only produce a Module interface with no base implementation, so the load hooks
+// must be stored in a global map.  The key is a pointer allocated by the module factory, so there
+// is no chance of collisions even if tests are running in parallel with multiple contexts.  The
+// contents should be short-lived, they are added during a module factory and removed immediately
+// after the module factory returns.
+var pendingHooks sync.Map
+
+func AddLoadHook(module Module, hook LoadHook) {
+	// Only one goroutine can be processing a given module, so no additional locking is required
+	// for the slice stored in the sync.Map.
+	v, exists := pendingHooks.Load(module)
+	if !exists {
+		v, _ = pendingHooks.LoadOrStore(module, new([]LoadHook))
+	}
+	hooks := v.(*[]LoadHook)
+	*hooks = append(*hooks, hook)
+}
+
+func runAndRemoveLoadHooks(ctx *Context, config interface{}, module *moduleInfo,
+	scopedModuleFactories *map[string]ModuleFactory) (newModules []*moduleInfo, errs []error) {
+
+	if v, exists := pendingHooks.Load(module.logicModule); exists {
+		hooks := v.(*[]LoadHook)
+		mctx := &loadHookContext{
+			baseModuleContext: baseModuleContext{
+				context: ctx,
+				config:  config,
+				module:  module,
+			},
+			scopedModuleFactories: scopedModuleFactories,
+		}
+
+		for _, hook := range *hooks {
+			hook(mctx)
+			newModules = append(newModules, mctx.newModules...)
+			errs = append(errs, mctx.errs...)
+		}
+		pendingHooks.Delete(module.logicModule)
+
+		return newModules, errs
+	}
+
+	return nil, nil
+}
diff --git a/module_ctx_test.go b/module_ctx_test.go
new file mode 100644
index 0000000..e72be8c
--- /dev/null
+++ b/module_ctx_test.go
@@ -0,0 +1,197 @@
+// Copyright 2019 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blueprint
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type moduleCtxTestModule struct {
+	SimpleName
+}
+
+func newModuleCtxTestModule() (Module, []interface{}) {
+	m := &moduleCtxTestModule{}
+	return m, []interface{}{&m.SimpleName.Properties}
+}
+
+func (f *moduleCtxTestModule) GenerateBuildActions(ModuleContext) {
+}
+
+func noCreateAliasMutator(name string) func(ctx BottomUpMutatorContext) {
+	return func(ctx BottomUpMutatorContext) {
+		if ctx.ModuleName() == name {
+			ctx.CreateVariations("a", "b")
+		}
+	}
+}
+
+func createAliasMutator(name string) func(ctx BottomUpMutatorContext) {
+	return func(ctx BottomUpMutatorContext) {
+		if ctx.ModuleName() == name {
+			ctx.CreateVariations("a", "b")
+			ctx.AliasVariation("b")
+		}
+	}
+}
+
+func addVariantDepsMutator(variants []Variation, tag DependencyTag, from, to string) func(ctx BottomUpMutatorContext) {
+	return func(ctx BottomUpMutatorContext) {
+		if ctx.ModuleName() == from {
+			ctx.AddVariationDependencies(variants, tag, to)
+		}
+	}
+}
+
+func TestAliases(t *testing.T) {
+	runWithFailures := func(ctx *Context, expectedErr string) {
+		t.Helper()
+		bp := `
+			test {
+				name: "foo",
+			}
+
+			test {
+				name: "bar",
+			}
+		`
+
+		mockFS := map[string][]byte{
+			"Blueprints": []byte(bp),
+		}
+
+		ctx.MockFileSystem(mockFS)
+
+		_, errs := ctx.ParseFileList(".", []string{"Blueprints"}, nil)
+		if len(errs) > 0 {
+			t.Errorf("unexpected parse errors:")
+			for _, err := range errs {
+				t.Errorf("  %s", err)
+			}
+		}
+
+		_, errs = ctx.ResolveDependencies(nil)
+		if len(errs) > 0 {
+			if expectedErr == "" {
+				t.Errorf("unexpected dep errors:")
+				for _, err := range errs {
+					t.Errorf("  %s", err)
+				}
+			} else {
+				for _, err := range errs {
+					if strings.Contains(err.Error(), expectedErr) {
+						continue
+					} else {
+						t.Errorf("unexpected dep error: %s", err)
+					}
+				}
+			}
+		} else if expectedErr != "" {
+			t.Errorf("missing dep error: %s", expectedErr)
+		}
+	}
+
+	run := func(ctx *Context) {
+		t.Helper()
+		runWithFailures(ctx, "")
+	}
+
+	t.Run("simple", func(t *testing.T) {
+		// Creates a module "bar" with variants "a" and "b" and alias "" -> "b".
+		// Tests a dependency from "foo" to "bar" variant "b" through alias "".
+		ctx := NewContext()
+		ctx.RegisterModuleType("test", newModuleCtxTestModule)
+		ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("2", addVariantDepsMutator(nil, nil, "foo", "bar"))
+
+		run(ctx)
+
+		foo := ctx.moduleGroupFromName("foo", nil).modules[0]
+		barB := ctx.moduleGroupFromName("bar", nil).modules[1]
+
+		if g, w := barB.variantName, "b"; g != w {
+			t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g)
+		}
+
+		if g, w := foo.forwardDeps, []*moduleInfo{barB}; !reflect.DeepEqual(g, w) {
+			t.Fatalf("expected foo deps to be %q, got %q", w, g)
+		}
+	})
+
+	t.Run("chained", func(t *testing.T) {
+		// Creates a module "bar" with variants "a_a", "a_b", "b_a" and "b_b" and aliases "" -> "b_b",
+		// "a" -> "a_b", and "b" -> "b_b".
+		// Tests a dependency from "foo" to "bar" variant "b_b" through alias "".
+		ctx := NewContext()
+		ctx.RegisterModuleType("test", newModuleCtxTestModule)
+		ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("2", createAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("3", addVariantDepsMutator(nil, nil, "foo", "bar"))
+
+		run(ctx)
+
+		foo := ctx.moduleGroupFromName("foo", nil).modules[0]
+		barBB := ctx.moduleGroupFromName("bar", nil).modules[3]
+
+		if g, w := barBB.variantName, "b_b"; g != w {
+			t.Fatalf("expected bar.modules[3] variant to be %q, got %q", w, g)
+		}
+
+		if g, w := foo.forwardDeps, []*moduleInfo{barBB}; !reflect.DeepEqual(g, w) {
+			t.Fatalf("expected foo deps to be %q, got %q", w, g)
+		}
+	})
+
+	t.Run("chained2", func(t *testing.T) {
+		// Creates a module "bar" with variants "a_a", "a_b", "b_a" and "b_b" and aliases "" -> "b_b",
+		// "a" -> "a_b", and "b" -> "b_b".
+		// Tests a dependency from "foo" to "bar" variant "a_b" through alias "a".
+		ctx := NewContext()
+		ctx.RegisterModuleType("test", newModuleCtxTestModule)
+		ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("2", createAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("3", addVariantDepsMutator([]Variation{{"1", "a"}}, nil, "foo", "bar"))
+
+		run(ctx)
+
+		foo := ctx.moduleGroupFromName("foo", nil).modules[0]
+		barAB := ctx.moduleGroupFromName("bar", nil).modules[1]
+
+		if g, w := barAB.variantName, "a_b"; g != w {
+			t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g)
+		}
+
+		if g, w := foo.forwardDeps, []*moduleInfo{barAB}; !reflect.DeepEqual(g, w) {
+			t.Fatalf("expected foo deps to be %q, got %q", w, g)
+		}
+	})
+
+	t.Run("removed dangling alias", func(t *testing.T) {
+		// Creates a module "bar" with variants "a" and "b" and aliases "" -> "b", then splits the variants into
+		// "a_a", "a_b", "b_a" and "b_b" without creating new aliases.
+		// Tests a dependency from "foo" to removed "bar" alias "" fails.
+		ctx := NewContext()
+		ctx.RegisterModuleType("test", newModuleCtxTestModule)
+		ctx.RegisterBottomUpMutator("1", createAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("2", noCreateAliasMutator("bar"))
+		ctx.RegisterBottomUpMutator("3", addVariantDepsMutator(nil, nil, "foo", "bar"))
+
+		runWithFailures(ctx, `dependency "bar" of "foo" missing variant:`+"\n  \n"+
+			"available variants:"+
+			"\n  1:a, 2:a\n  1:a, 2:b\n  1:b, 2:a\n  1:b, 2:b")
+	})
+}
diff --git a/ninja_defs.go b/ninja_defs.go
index 61846fe..c5d0e4b 100644
--- a/ninja_defs.go
+++ b/ninja_defs.go
@@ -128,11 +128,11 @@
 // A ruleDef describes a rule definition.  It does not include the name of the
 // rule.
 type ruleDef struct {
-	CommandDeps      []*ninjaString
-	CommandOrderOnly []*ninjaString
+	CommandDeps      []ninjaString
+	CommandOrderOnly []ninjaString
 	Comment          string
 	Pool             Pool
-	Variables        map[string]*ninjaString
+	Variables        map[string]ninjaString
 }
 
 func parseRuleParams(scope scope, params *RuleParams) (*ruleDef,
@@ -141,7 +141,7 @@
 	r := &ruleDef{
 		Comment:   params.Comment,
 		Pool:      params.Pool,
-		Variables: make(map[string]*ninjaString),
+		Variables: make(map[string]ninjaString),
 	}
 
 	if params.Command == "" {
@@ -252,13 +252,13 @@
 	Comment         string
 	Rule            Rule
 	RuleDef         *ruleDef
-	Outputs         []*ninjaString
-	ImplicitOutputs []*ninjaString
-	Inputs          []*ninjaString
-	Implicits       []*ninjaString
-	OrderOnly       []*ninjaString
-	Args            map[Variable]*ninjaString
-	Variables       map[string]*ninjaString
+	Outputs         []ninjaString
+	ImplicitOutputs []ninjaString
+	Inputs          []ninjaString
+	Implicits       []ninjaString
+	OrderOnly       []ninjaString
+	Args            map[Variable]ninjaString
+	Variables       map[string]ninjaString
 	Optional        bool
 }
 
@@ -273,9 +273,9 @@
 		Rule:    rule,
 	}
 
-	setVariable := func(name string, value *ninjaString) {
+	setVariable := func(name string, value ninjaString) {
 		if b.Variables == nil {
-			b.Variables = make(map[string]*ninjaString)
+			b.Variables = make(map[string]ninjaString)
 		}
 		b.Variables[name] = value
 	}
@@ -339,7 +339,7 @@
 	argNameScope := rule.scope()
 
 	if len(params.Args) > 0 {
-		b.Args = make(map[Variable]*ninjaString)
+		b.Args = make(map[Variable]ninjaString)
 		for name, value := range params.Args {
 			if !rule.isArg(name) {
 				return nil, fmt.Errorf("unknown argument %q", name)
@@ -419,7 +419,7 @@
 	return nw.BlankLine()
 }
 
-func valueList(list []*ninjaString, pkgNames map[*packageContext]string,
+func valueList(list []ninjaString, pkgNames map[*packageContext]string,
 	escaper *strings.Replacer) []string {
 
 	result := make([]string, len(list))
@@ -429,7 +429,7 @@
 	return result
 }
 
-func writeVariables(nw *ninjaWriter, variables map[string]*ninjaString,
+func writeVariables(nw *ninjaWriter, variables map[string]ninjaString,
 	pkgNames map[*packageContext]string) error {
 	var keys []string
 	for k := range variables {
diff --git a/ninja_strings.go b/ninja_strings.go
index 5b8767d..190cae9 100644
--- a/ninja_strings.go
+++ b/ninja_strings.go
@@ -34,21 +34,28 @@
 		":", "$:")
 )
 
-type ninjaString struct {
+type ninjaString interface {
+	Value(pkgNames map[*packageContext]string) string
+	ValueWithEscaper(pkgNames map[*packageContext]string, escaper *strings.Replacer) string
+	Eval(variables map[Variable]ninjaString) (string, error)
+	Variables() []Variable
+}
+
+type varNinjaString struct {
 	strings   []string
 	variables []Variable
 }
 
+type literalNinjaString string
+
 type scope interface {
 	LookupVariable(name string) (Variable, error)
 	IsRuleVisible(rule Rule) bool
 	IsPoolVisible(pool Pool) bool
 }
 
-func simpleNinjaString(str string) *ninjaString {
-	return &ninjaString{
-		strings: []string{str},
-	}
+func simpleNinjaString(str string) ninjaString {
+	return literalNinjaString(str)
 }
 
 type parseState struct {
@@ -57,7 +64,7 @@
 	pendingStr  string
 	stringStart int
 	varStart    int
-	result      *ninjaString
+	result      *varNinjaString
 }
 
 func (ps *parseState) pushVariable(v Variable) {
@@ -84,10 +91,16 @@
 // parseNinjaString parses an unescaped ninja string (i.e. all $<something>
 // occurrences are expected to be variables or $$) and returns a list of the
 // variable names that the string references.
-func parseNinjaString(scope scope, str string) (*ninjaString, error) {
+func parseNinjaString(scope scope, str string) (ninjaString, error) {
 	// naively pre-allocate slices by counting $ signs
 	n := strings.Count(str, "$")
-	result := &ninjaString{
+	if n == 0 {
+		if strings.HasPrefix(str, " ") {
+			str = "$" + str
+		}
+		return literalNinjaString(str), nil
+	}
+	result := &varNinjaString{
 		strings:   make([]string, 0, n+1),
 		variables: make([]Variable, 0, n),
 	}
@@ -253,13 +266,13 @@
 	}
 }
 
-func parseNinjaStrings(scope scope, strs []string) ([]*ninjaString,
+func parseNinjaStrings(scope scope, strs []string) ([]ninjaString,
 	error) {
 
 	if len(strs) == 0 {
 		return nil, nil
 	}
-	result := make([]*ninjaString, len(strs))
+	result := make([]ninjaString, len(strs))
 	for i, str := range strs {
 		ninjaStr, err := parseNinjaString(scope, str)
 		if err != nil {
@@ -270,11 +283,11 @@
 	return result, nil
 }
 
-func (n *ninjaString) Value(pkgNames map[*packageContext]string) string {
+func (n varNinjaString) Value(pkgNames map[*packageContext]string) string {
 	return n.ValueWithEscaper(pkgNames, defaultEscaper)
 }
 
-func (n *ninjaString) ValueWithEscaper(pkgNames map[*packageContext]string,
+func (n varNinjaString) ValueWithEscaper(pkgNames map[*packageContext]string,
 	escaper *strings.Replacer) string {
 
 	if len(n.strings) == 1 {
@@ -293,7 +306,7 @@
 	return str.String()
 }
 
-func (n *ninjaString) Eval(variables map[Variable]*ninjaString) (string, error) {
+func (n varNinjaString) Eval(variables map[Variable]ninjaString) (string, error) {
 	str := n.strings[0]
 	for i, v := range n.variables {
 		variable, ok := variables[v]
@@ -309,6 +322,27 @@
 	return str, nil
 }
 
+func (n varNinjaString) Variables() []Variable {
+	return n.variables
+}
+
+func (l literalNinjaString) Value(pkgNames map[*packageContext]string) string {
+	return l.ValueWithEscaper(pkgNames, defaultEscaper)
+}
+
+func (l literalNinjaString) ValueWithEscaper(pkgNames map[*packageContext]string,
+	escaper *strings.Replacer) string {
+	return escaper.Replace(string(l))
+}
+
+func (l literalNinjaString) Eval(variables map[Variable]ninjaString) (string, error) {
+	return string(l), nil
+}
+
+func (l literalNinjaString) Variables() []Variable {
+	return nil
+}
+
 func validateNinjaName(name string) error {
 	for i, r := range name {
 		valid := (r >= 'a' && r <= 'z') ||
diff --git a/ninja_strings_test.go b/ninja_strings_test.go
index 0e0de64..c1e05f7 100644
--- a/ninja_strings_test.go
+++ b/ninja_strings_test.go
@@ -22,10 +22,11 @@
 )
 
 var ninjaParseTestCases = []struct {
-	input string
-	vars  []string
-	strs  []string
-	err   string
+	input   string
+	vars    []string
+	strs    []string
+	literal bool
+	err     string
 }{
 	{
 		input: "abc def $ghi jkl",
@@ -56,6 +57,7 @@
 		input: "foo $$ bar",
 		vars:  nil,
 		strs:  []string{"foo $$ bar"},
+		// this is technically a literal, but not recognized as such due to the $$
 	},
 	{
 		input: "$foo${bar}",
@@ -68,16 +70,22 @@
 		strs:  []string{"", "$$"},
 	},
 	{
-		input: "foo bar",
-		vars:  nil,
-		strs:  []string{"foo bar"},
+		input:   "foo bar",
+		vars:    nil,
+		strs:    []string{"foo bar"},
+		literal: true,
 	},
 	{
-		input: " foo ",
-		vars:  nil,
-		strs:  []string{"$ foo "},
+		input:   " foo ",
+		vars:    nil,
+		strs:    []string{"$ foo "},
+		literal: true,
 	},
 	{
+		input: " $foo ",
+		vars:  []string{"foo"},
+		strs:  []string{"$ ", " "},
+	}, {
 		input: "foo $ bar",
 		err:   "invalid character after '$' at byte offset 5",
 	},
@@ -114,19 +122,25 @@
 			expectedVars = append(expectedVars, v)
 		}
 
+		var expected ninjaString
+		if len(testCase.strs) > 0 {
+			if testCase.literal {
+				expected = literalNinjaString(testCase.strs[0])
+			} else {
+				expected = &varNinjaString{
+					strings:   testCase.strs,
+					variables: expectedVars,
+				}
+			}
+		}
+
 		output, err := parseNinjaString(scope, testCase.input)
 		if err == nil {
-			if !reflect.DeepEqual(output.variables, expectedVars) {
-				t.Errorf("incorrect variable list:")
+			if !reflect.DeepEqual(output, expected) {
+				t.Errorf("incorrect ninja string:")
 				t.Errorf("     input: %q", testCase.input)
-				t.Errorf("  expected: %#v", expectedVars)
-				t.Errorf("       got: %#v", output.variables)
-			}
-			if !reflect.DeepEqual(output.strings, testCase.strs) {
-				t.Errorf("incorrect string list:")
-				t.Errorf("     input: %q", testCase.input)
-				t.Errorf("  expected: %#v", testCase.strs)
-				t.Errorf("       got: %#v", output.strings)
+				t.Errorf("  expected: %#v", expected)
+				t.Errorf("       got: %#v", output)
 			}
 		}
 		var errStr string
@@ -156,7 +170,7 @@
 	}
 
 	expect := []Variable{ImpVar}
-	if !reflect.DeepEqual(output.variables, expect) {
+	if !reflect.DeepEqual(output.(*varNinjaString).variables, expect) {
 		t.Errorf("incorrect output:")
 		t.Errorf("     input: %q", input)
 		t.Errorf("  expected: %#v", expect)
diff --git a/package_ctx.go b/package_ctx.go
index c55152a..088239e 100644
--- a/package_ctx.go
+++ b/package_ctx.go
@@ -292,7 +292,7 @@
 	return packageNamespacePrefix(pkgNames[v.pctx]) + v.name_
 }
 
-func (v *staticVariable) value(interface{}) (*ninjaString, error) {
+func (v *staticVariable) value(interface{}) (ninjaString, error) {
 	ninjaStr, err := parseNinjaString(v.pctx.scope, v.value_)
 	if err != nil {
 		err = fmt.Errorf("error parsing variable %s value: %s", v, err)
@@ -392,7 +392,7 @@
 	return packageNamespacePrefix(pkgNames[v.pctx]) + v.name_
 }
 
-func (v *variableFunc) value(config interface{}) (*ninjaString, error) {
+func (v *variableFunc) value(config interface{}) (ninjaString, error) {
 	value, err := v.value_(config)
 	if err != nil {
 		return nil, err
@@ -452,7 +452,7 @@
 	return v.name_
 }
 
-func (v *argVariable) value(config interface{}) (*ninjaString, error) {
+func (v *argVariable) value(config interface{}) (ninjaString, error) {
 	return nil, errVariableIsArg
 }
 
diff --git a/parser/ast.go b/parser/ast.go
index b5053bb..57c4948 100644
--- a/parser/ast.go
+++ b/parser/ast.go
@@ -164,6 +164,7 @@
 	Int64Type
 	ListType
 	MapType
+	NotEvaluatedType
 )
 
 func (t Type) String() string {
@@ -178,6 +179,8 @@
 		return "list"
 	case MapType:
 		return "map"
+	case NotEvaluatedType:
+		return "notevaluated"
 	default:
 		panic(fmt.Errorf("Unknown type %d", t))
 	}
@@ -476,6 +479,29 @@
 	return string(buf)
 }
 
+type NotEvaluated struct {
+	Position scanner.Position
+}
+
+func (n NotEvaluated) Copy() Expression {
+	return NotEvaluated{Position: n.Position}
+}
+
+func (n NotEvaluated) String() string {
+	return "Not Evaluated"
+}
+
+func (n NotEvaluated) Type() Type {
+	return NotEvaluatedType
+}
+
+func (n NotEvaluated) Eval() Expression {
+	return NotEvaluated{Position: n.Position}
+}
+
+func (n NotEvaluated) Pos() scanner.Position { return n.Position }
+func (n NotEvaluated) End() scanner.Position { return n.Position }
+
 func endPos(pos scanner.Position, n int) scanner.Position {
 	pos.Offset += n
 	pos.Column += n
diff --git a/parser/parser.go b/parser/parser.go
index cb86246..6ae5df3 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -484,6 +484,8 @@
 				}
 				value = assignment.Value
 			}
+		} else {
+			value = &NotEvaluated{}
 		}
 		value = &Variable{
 			Name:    text,
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 6377dc1..70151ad 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -1122,3 +1122,24 @@
 		}
 	}
 }
+
+func TestParserNotEvaluated(t *testing.T) {
+	// When parsing without evaluation, create variables correctly
+	scope := NewScope(nil)
+	input := "FOO=abc\n"
+	_, errs := Parse("", bytes.NewBufferString(input), scope)
+	if errs != nil {
+		t.Errorf("unexpected errors:")
+		for _, err := range errs {
+			t.Errorf("  %s", err)
+		}
+		t.FailNow()
+	}
+	assignment, found := scope.Get("FOO")
+	if !found {
+		t.Fatalf("Expected to find FOO after parsing %s", input)
+	}
+	if s := assignment.String(); strings.Contains(s, "PANIC") {
+		t.Errorf("Attempt to print FOO returned %s", s)
+	}
+}
diff --git a/pathtools/fs.go b/pathtools/fs.go
index 8329392..21754d0 100644
--- a/pathtools/fs.go
+++ b/pathtools/fs.go
@@ -36,7 +36,7 @@
 	DontFollowSymlinks = ShouldFollowSymlinks(false)
 )
 
-var OsFs FileSystem = osFs{}
+var OsFs FileSystem = &osFs{}
 
 func MockFs(files map[string][]byte) FileSystem {
 	fs := &mockFs{
@@ -123,11 +123,52 @@
 }
 
 // osFs implements FileSystem using the local disk.
-type osFs struct{}
+type osFs struct {
+	srcDir string
+}
 
-func (osFs) Open(name string) (ReaderAtSeekerCloser, error) { return os.Open(name) }
-func (osFs) Exists(name string) (bool, bool, error) {
-	stat, err := os.Stat(name)
+func NewOsFs(path string) FileSystem {
+	return &osFs{srcDir: path}
+}
+
+func (fs *osFs) toAbs(path string) string {
+	if filepath.IsAbs(path) {
+		return path
+	}
+	return filepath.Join(fs.srcDir, path)
+}
+
+func (fs *osFs) removeSrcDirPrefix(path string) string {
+	if fs.srcDir == "" {
+		return path
+	}
+	rel, err := filepath.Rel(fs.srcDir, path)
+	if err != nil {
+		panic(fmt.Errorf("unexpected failure in removeSrcDirPrefix filepath.Rel(%s, %s): %s",
+			fs.srcDir, path, err))
+	}
+	if strings.HasPrefix(rel, "../") {
+		panic(fmt.Errorf("unexpected relative path outside directory in removeSrcDirPrefix filepath.Rel(%s, %s): %s",
+			fs.srcDir, path, rel))
+	}
+	return rel
+}
+
+func (fs *osFs) removeSrcDirPrefixes(paths []string) []string {
+	if fs.srcDir != "" {
+		for i, path := range paths {
+			paths[i] = fs.removeSrcDirPrefix(path)
+		}
+	}
+	return paths
+}
+
+func (fs *osFs) Open(name string) (ReaderAtSeekerCloser, error) {
+	return os.Open(fs.toAbs(name))
+}
+
+func (fs *osFs) Exists(name string) (bool, bool, error) {
+	stat, err := os.Stat(fs.toAbs(name))
 	if err == nil {
 		return true, stat.IsDir(), nil
 	} else if os.IsNotExist(err) {
@@ -137,45 +178,47 @@
 	}
 }
 
-func (osFs) IsDir(name string) (bool, error) {
-	info, err := os.Stat(name)
+func (fs *osFs) IsDir(name string) (bool, error) {
+	info, err := os.Stat(fs.toAbs(name))
 	if err != nil {
 		return false, err
 	}
 	return info.IsDir(), nil
 }
 
-func (osFs) IsSymlink(name string) (bool, error) {
-	if info, err := os.Lstat(name); err != nil {
+func (fs *osFs) IsSymlink(name string) (bool, error) {
+	if info, err := os.Lstat(fs.toAbs(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) {
+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) {
-	return filepath.Glob(pattern)
+func (fs *osFs) glob(pattern string) ([]string, error) {
+	paths, err := filepath.Glob(fs.toAbs(pattern))
+	fs.removeSrcDirPrefixes(paths)
+	return paths, err
 }
 
-func (osFs) Lstat(path string) (stats os.FileInfo, err error) {
-	return os.Lstat(path)
+func (fs *osFs) Lstat(path string) (stats os.FileInfo, err error) {
+	return os.Lstat(fs.toAbs(path))
 }
 
-func (osFs) Stat(path string) (stats os.FileInfo, err error) {
-	return os.Stat(path)
+func (fs *osFs) Stat(path string) (stats os.FileInfo, err error) {
+	return os.Stat(fs.toAbs(path))
 }
 
 // Returns a list of all directories under dir
-func (osFs) ListDirsRecursive(name string, follow ShouldFollowSymlinks) (dirs []string, err error) {
-	return listDirsRecursive(OsFs, name, follow)
+func (fs *osFs) ListDirsRecursive(name string, follow ShouldFollowSymlinks) (dirs []string, err error) {
+	return listDirsRecursive(fs, name, follow)
 }
 
-func (osFs) ReadDirNames(name string) ([]string, error) {
-	dir, err := os.Open(name)
+func (fs *osFs) ReadDirNames(name string) ([]string, error) {
+	dir, err := os.Open(fs.toAbs(name))
 	if err != nil {
 		return nil, err
 	}
@@ -190,8 +233,8 @@
 	return contents, nil
 }
 
-func (osFs) Readlink(name string) (string, error) {
-	return os.Readlink(name)
+func (fs *osFs) Readlink(name string) (string, error) {
+	return os.Readlink(fs.toAbs(name))
 }
 
 type mockFs struct {
diff --git a/pathtools/fs_test.go b/pathtools/fs_test.go
index 1b5c458..3b4d4d0 100644
--- a/pathtools/fs_test.go
+++ b/pathtools/fs_test.go
@@ -22,6 +22,8 @@
 	"testing"
 )
 
+const testdataDir = "testdata/dangling"
+
 func symlinkMockFs() *mockFs {
 	files := []string{
 		"a/a/a",
@@ -101,6 +103,42 @@
 	}
 }
 
+func runTestFs(t *testing.T, f func(t *testing.T, fs FileSystem, dir string)) {
+	mock := symlinkMockFs()
+	wd, _ := os.Getwd()
+	absTestDataDir := filepath.Join(wd, testdataDir)
+
+	run := func(t *testing.T, fs FileSystem) {
+		t.Run("relpath", func(t *testing.T) {
+			f(t, fs, "")
+		})
+		t.Run("abspath", func(t *testing.T) {
+			f(t, fs, absTestDataDir)
+		})
+	}
+
+	t.Run("mock", func(t *testing.T) {
+		f(t, mock, "")
+	})
+
+	t.Run("os", func(t *testing.T) {
+		os.Chdir(absTestDataDir)
+		defer os.Chdir(wd)
+		run(t, OsFs)
+	})
+
+	t.Run("os relative srcDir", func(t *testing.T) {
+		run(t, NewOsFs(testdataDir))
+	})
+
+	t.Run("os absolute srcDir", func(t *testing.T) {
+		os.Chdir("/")
+		defer os.Chdir(wd)
+		run(t, NewOsFs(filepath.Join(wd, testdataDir)))
+	})
+
+}
+
 func TestFs_IsDir(t *testing.T) {
 	testCases := []struct {
 		name  string
@@ -148,26 +186,17 @@
 		{"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)
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		for _, test := range testCases {
+			t.Run(test.name, func(t *testing.T) {
+				got, err := fs.IsDir(filepath.Join(dir, 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) {
@@ -199,27 +228,21 @@
 		{"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)
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		for _, test := range testCases {
+			t.Run(test.name, func(t *testing.T) {
+				got, err := fs.ListDirsRecursive(filepath.Join(dir, test.name), FollowSymlinks)
+				checkErr(t, test.err, err)
+				want := append([]string(nil), test.dirs...)
+				for i := range want {
+					want[i] = filepath.Join(dir, want[i])
+				}
+				if !reflect.DeepEqual(got, want) {
+					t.Errorf("want: %v, got %v", want, got)
+				}
+			})
+		}
+	})
 }
 
 func TestFs_ListDirsRecursiveDontFollowSymlinks(t *testing.T) {
@@ -251,27 +274,21 @@
 		{"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)
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		for _, test := range testCases {
+			t.Run(test.name, func(t *testing.T) {
+				got, err := fs.ListDirsRecursive(filepath.Join(dir, test.name), DontFollowSymlinks)
+				checkErr(t, test.err, err)
+				want := append([]string(nil), test.dirs...)
+				for i := range want {
+					want[i] = filepath.Join(dir, want[i])
+				}
+				if !reflect.DeepEqual(got, want) {
+					t.Errorf("want: %v, got %v", want, got)
+				}
+			})
+		}
+	})
 }
 
 func TestFs_Readlink(t *testing.T) {
@@ -320,27 +337,17 @@
 		{"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)
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		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) {
@@ -391,34 +398,24 @@
 		{"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())
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		for _, test := range testCases {
+			t.Run(test.name, func(t *testing.T) {
+				got, err := fs.Lstat(filepath.Join(dir, 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) {
@@ -469,34 +466,24 @@
 		{"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())
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		for _, test := range testCases {
+			t.Run(test.name, func(t *testing.T) {
+				got, err := fs.Stat(filepath.Join(dir, 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) {
@@ -537,28 +524,19 @@
 		{"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)
-					}
-				})
-			}
-		})
-	}
+	runTestFs(t, func(t *testing.T, fs FileSystem, dir string) {
+		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 {
diff --git a/proptools/clone.go b/proptools/clone.go
index fe4e115..9e985f1 100644
--- a/proptools/clone.go
+++ b/proptools/clone.go
@@ -20,13 +20,32 @@
 	"sync"
 )
 
+// CloneProperties takes a reflect.Value of a pointer to a struct and returns a reflect.Value
+// of a pointer to a new struct that copies of the values for its fields.  It recursively clones
+// struct pointers and interfaces that contain struct pointers.
 func CloneProperties(structValue reflect.Value) reflect.Value {
-	result := reflect.New(structValue.Type())
-	CopyProperties(result.Elem(), structValue)
+	if !isStructPtr(structValue.Type()) {
+		panic(fmt.Errorf("CloneProperties expected *struct, got %s", structValue.Type()))
+	}
+	result := reflect.New(structValue.Type().Elem())
+	copyProperties(result.Elem(), structValue.Elem())
 	return result
 }
 
+// CopyProperties takes destination and source reflect.Values of a pointer to structs and returns
+// copies each field from the source into the destination.  It recursively copies struct pointers
+// and interfaces that contain struct pointers.
 func CopyProperties(dstValue, srcValue reflect.Value) {
+	if !isStructPtr(dstValue.Type()) {
+		panic(fmt.Errorf("CopyProperties expected dstValue *struct, got %s", dstValue.Type()))
+	}
+	if !isStructPtr(srcValue.Type()) {
+		panic(fmt.Errorf("CopyProperties expected srcValue *struct, got %s", srcValue.Type()))
+	}
+	copyProperties(dstValue.Elem(), srcValue.Elem())
+}
+
+func copyProperties(dstValue, srcValue reflect.Value) {
 	typ := dstValue.Type()
 	if srcValue.Type() != typ {
 		panic(fmt.Errorf("can't copy mismatching types (%s <- %s)",
@@ -47,7 +66,7 @@
 		case reflect.Bool, reflect.String, reflect.Int, reflect.Uint:
 			dstFieldValue.Set(srcFieldValue)
 		case reflect.Struct:
-			CopyProperties(dstFieldValue, srcFieldValue)
+			copyProperties(dstFieldValue, srcFieldValue)
 		case reflect.Slice:
 			if !srcFieldValue.IsNil() {
 				if srcFieldValue != dstFieldValue {
@@ -67,13 +86,9 @@
 
 			srcFieldValue = srcFieldValue.Elem()
 
-			if srcFieldValue.Kind() != reflect.Ptr {
-				panic(fmt.Errorf("can't clone field %q: interface refers to a non-pointer",
-					field.Name))
-			}
-			if srcFieldValue.Type().Elem().Kind() != reflect.Struct {
-				panic(fmt.Errorf("can't clone field %q: interface points to a non-struct",
-					field.Name))
+			if !isStructPtr(srcFieldValue.Type()) {
+				panic(fmt.Errorf("can't clone field %q: expected interface to contain *struct, found %s",
+					field.Name, srcFieldValue.Type()))
 			}
 
 			if dstFieldValue.IsNil() || dstFieldValue.Elem().Type() != srcFieldValue.Type() {
@@ -93,13 +108,11 @@
 				break
 			}
 
-			srcFieldValue := srcFieldValue.Elem()
-
-			switch srcFieldValue.Kind() {
+			switch srcFieldValue.Elem().Kind() {
 			case reflect.Struct:
 				if !dstFieldValue.IsNil() {
 					// Re-use the existing allocation.
-					CopyProperties(dstFieldValue.Elem(), srcFieldValue)
+					copyProperties(dstFieldValue.Elem(), srcFieldValue.Elem())
 					break
 				} else {
 					newValue := CloneProperties(srcFieldValue)
@@ -110,21 +123,30 @@
 					}
 				}
 			case reflect.Bool, reflect.Int64, reflect.String:
-				newValue := reflect.New(srcFieldValue.Type())
-				newValue.Elem().Set(srcFieldValue)
+				newValue := reflect.New(srcFieldValue.Elem().Type())
+				newValue.Elem().Set(srcFieldValue.Elem())
 				origDstFieldValue.Set(newValue)
 			default:
-				panic(fmt.Errorf("can't clone field %q: points to a %s",
-					field.Name, srcFieldValue.Kind()))
+				panic(fmt.Errorf("can't clone pointer field %q type %s",
+					field.Name, srcFieldValue.Type()))
 			}
 		default:
-			panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
-				field.Name, srcFieldValue.Kind()))
+			panic(fmt.Errorf("unexpected type for property struct field %q: %s",
+				field.Name, srcFieldValue.Type()))
 		}
 	}
 }
 
+// ZeroProperties takes a reflect.Value of a pointer to a struct and replaces all of its fields
+// with zero values, recursing into struct, pointer to struct and interface fields.
 func ZeroProperties(structValue reflect.Value) {
+	if !isStructPtr(structValue.Type()) {
+		panic(fmt.Errorf("ZeroProperties expected *struct, got %s", structValue.Type()))
+	}
+	zeroProperties(structValue.Elem())
+}
+
+func zeroProperties(structValue reflect.Value) {
 	typ := structValue.Type()
 
 	for i, field := range typeFields(typ) {
@@ -146,13 +168,9 @@
 			// We leave the pointer intact and zero out the struct that's
 			// pointed to.
 			fieldValue = fieldValue.Elem()
-			if fieldValue.Kind() != reflect.Ptr {
-				panic(fmt.Errorf("can't zero field %q: interface refers to a non-pointer",
-					field.Name))
-			}
-			if fieldValue.Type().Elem().Kind() != reflect.Struct {
-				panic(fmt.Errorf("can't zero field %q: interface points to a non-struct",
-					field.Name))
+			if !isStructPtr(fieldValue.Type()) {
+				panic(fmt.Errorf("can't zero field %q: expected interface to contain *struct, found %s",
+					field.Name, fieldValue.Type()))
 			}
 			fallthrough
 		case reflect.Ptr:
@@ -161,7 +179,7 @@
 				if fieldValue.IsNil() {
 					break
 				}
-				ZeroProperties(fieldValue.Elem())
+				zeroProperties(fieldValue.Elem())
 			case reflect.Bool, reflect.Int64, reflect.String:
 				fieldValue.Set(reflect.Zero(fieldValue.Type()))
 			default:
@@ -169,7 +187,7 @@
 					field.Name, fieldValue.Elem().Kind()))
 			}
 		case reflect.Struct:
-			ZeroProperties(fieldValue)
+			zeroProperties(fieldValue)
 		default:
 			panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
 				field.Name, fieldValue.Kind()))
@@ -177,9 +195,15 @@
 	}
 }
 
+// CloneEmptyProperties takes a reflect.Value of a pointer to a struct and returns a reflect.Value
+// of a pointer to a new struct that has the zero values for its fields.  It recursively clones
+// struct pointers and interfaces that contain struct pointers.
 func CloneEmptyProperties(structValue reflect.Value) reflect.Value {
-	result := reflect.New(structValue.Type())
-	cloneEmptyProperties(result.Elem(), structValue)
+	if !isStructPtr(structValue.Type()) {
+		panic(fmt.Errorf("CloneEmptyProperties expected *struct, got %s", structValue.Type()))
+	}
+	result := reflect.New(structValue.Type().Elem())
+	cloneEmptyProperties(result.Elem(), structValue.Elem())
 	return result
 }
 
@@ -206,13 +230,9 @@
 			}
 
 			srcFieldValue = srcFieldValue.Elem()
-			if srcFieldValue.Kind() != reflect.Ptr {
-				panic(fmt.Errorf("can't clone empty field %q: interface refers to a non-pointer",
-					field.Name))
-			}
-			if srcFieldValue.Type().Elem().Kind() != reflect.Struct {
-				panic(fmt.Errorf("can't clone empty field %q: interface points to a non-struct",
-					field.Name))
+			if !isStructPtr(srcFieldValue.Type()) {
+				panic(fmt.Errorf("can't clone empty field %q: expected interface to contain *struct, found %s",
+					field.Name, srcFieldValue.Type()))
 			}
 
 			newValue := reflect.New(srcFieldValue.Type()).Elem()
@@ -226,7 +246,7 @@
 				if srcFieldValue.IsNil() {
 					break
 				}
-				newValue := CloneEmptyProperties(srcFieldValue.Elem())
+				newValue := CloneEmptyProperties(srcFieldValue)
 				if dstFieldInterfaceValue.IsValid() {
 					dstFieldInterfaceValue.Set(newValue)
 				} else {
diff --git a/proptools/clone_test.go b/proptools/clone_test.go
index 660f1c0..3c03451 100644
--- a/proptools/clone_test.go
+++ b/proptools/clone_test.go
@@ -277,7 +277,7 @@
 	for _, testCase := range clonePropertiesTestCases {
 		testString := fmt.Sprintf("%s", testCase.in)
 
-		got := CloneProperties(reflect.ValueOf(testCase.in).Elem()).Interface()
+		got := CloneProperties(reflect.ValueOf(testCase.in)).Interface()
 
 		if !reflect.DeepEqual(testCase.out, got) {
 			t.Errorf("test case %s", testString)
@@ -499,7 +499,7 @@
 	for _, testCase := range cloneEmptyPropertiesTestCases {
 		testString := fmt.Sprintf("%#v", testCase.in)
 
-		got := CloneEmptyProperties(reflect.ValueOf(testCase.in).Elem()).Interface()
+		got := CloneEmptyProperties(reflect.ValueOf(testCase.in)).Interface()
 
 		if !reflect.DeepEqual(testCase.out, got) {
 			t.Errorf("test case %s", testString)
@@ -514,8 +514,8 @@
 	for _, testCase := range cloneEmptyPropertiesTestCases {
 		testString := fmt.Sprintf("%#v", testCase.in)
 
-		got := CloneProperties(reflect.ValueOf(testCase.in).Elem()).Interface()
-		ZeroProperties(reflect.ValueOf(got).Elem())
+		got := CloneProperties(reflect.ValueOf(testCase.in)).Interface()
+		ZeroProperties(reflect.ValueOf(got))
 
 		if !reflect.DeepEqual(testCase.out, got) {
 			t.Errorf("test case %s", testString)
diff --git a/proptools/extend.go b/proptools/extend.go
index b1a35d0..d3c2b79 100644
--- a/proptools/extend.go
+++ b/proptools/extend.go
@@ -150,6 +150,7 @@
 const (
 	Append Order = iota
 	Prepend
+	Replace
 )
 
 type ExtendPropertyFilterFunc func(property string,
@@ -172,6 +173,12 @@
 	return Prepend, nil
 }
 
+func OrderReplace(property string,
+	dstField, srcField reflect.StructField,
+	dstValue, srcValue interface{}) (Order, error) {
+	return Replace, nil
+}
+
 type ExtendPropertyError struct {
 	Err      error
 	Property string
@@ -267,7 +274,7 @@
 		}
 
 		// Step into source pointers to structs
-		if srcFieldValue.Kind() == reflect.Ptr && srcFieldValue.Type().Elem().Kind() == reflect.Struct {
+		if isStructPtr(srcFieldValue.Type()) {
 			if srcFieldValue.IsNil() {
 				continue
 			}
@@ -316,7 +323,7 @@
 			}
 
 			// Step into destination pointers to structs
-			if dstFieldValue.Kind() == reflect.Ptr && dstFieldValue.Type().Elem().Kind() == reflect.Struct {
+			if isStructPtr(dstFieldValue.Type()) {
 				if dstFieldValue.IsNil() {
 					dstFieldValue = reflect.New(dstFieldValue.Type().Elem())
 					origDstFieldValue.Set(dstFieldValue)
@@ -428,9 +435,12 @@
 		if prepend {
 			newSlice = reflect.AppendSlice(newSlice, srcFieldValue)
 			newSlice = reflect.AppendSlice(newSlice, dstFieldValue)
-		} else {
+		} else if order == Append {
 			newSlice = reflect.AppendSlice(newSlice, dstFieldValue)
 			newSlice = reflect.AppendSlice(newSlice, srcFieldValue)
+		} else {
+			// replace
+			newSlice = reflect.AppendSlice(newSlice, srcFieldValue)
 		}
 		dstFieldValue.Set(newSlice)
 	case reflect.Ptr:
@@ -491,11 +501,8 @@
 
 func getStruct(in interface{}) (reflect.Value, error) {
 	value := reflect.ValueOf(in)
-	if value.Kind() != reflect.Ptr {
-		return reflect.Value{}, fmt.Errorf("expected pointer to struct, got %T", in)
-	}
-	if value.Type().Elem().Kind() != reflect.Struct {
-		return reflect.Value{}, fmt.Errorf("expected pointer to struct, got %T", in)
+	if !isStructPtr(value.Type()) {
+		return reflect.Value{}, fmt.Errorf("expected pointer to struct, got %s", value.Type())
 	}
 	if value.IsNil() {
 		return reflect.Value{}, getStructEmptyError{}
diff --git a/proptools/extend_test.go b/proptools/extend_test.go
index 66adabb..d591ce6 100644
--- a/proptools/extend_test.go
+++ b/proptools/extend_test.go
@@ -23,12 +23,12 @@
 )
 
 type appendPropertyTestCase struct {
-	in1     interface{}
-	in2     interface{}
-	out     interface{}
-	prepend bool
-	filter  ExtendPropertyFilterFunc
-	err     error
+	in1    interface{}
+	in2    interface{}
+	out    interface{}
+	order  Order // default is Append
+	filter ExtendPropertyFilterFunc
+	err    error
 }
 
 func appendPropertiesTestCases() []appendPropertyTestCase {
@@ -76,7 +76,7 @@
 				B3: true,
 				B4: false,
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append strings
@@ -101,7 +101,7 @@
 			out: &struct{ S string }{
 				S: "string2string1",
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append pointer to bool
@@ -174,7 +174,7 @@
 				B8: BoolPtr(false),
 				B9: BoolPtr(false),
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append pointer to integer
@@ -226,7 +226,7 @@
 				I2: Int64Ptr(33),
 				I3: nil,
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append pointer to strings
@@ -261,7 +261,7 @@
 				S3: StringPtr("string4"),
 				S4: nil,
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append slice
@@ -286,7 +286,20 @@
 			out: &struct{ S []string }{
 				S: []string{"string2", "string1"},
 			},
-			prepend: true,
+			order: Prepend,
+		},
+		{
+			// Replace slice
+			in1: &struct{ S []string }{
+				S: []string{"string1"},
+			},
+			in2: &struct{ S []string }{
+				S: []string{"string2"},
+			},
+			out: &struct{ S []string }{
+				S: []string{"string2"},
+			},
+			order: Replace,
 		},
 		{
 			// Append empty slice
@@ -317,7 +330,23 @@
 				S1: []string{"string1"},
 				S2: []string{"string2"},
 			},
-			prepend: true,
+			order: Prepend,
+		},
+		{
+			// Replace empty slice
+			in1: &struct{ S1, S2 []string }{
+				S1: []string{"string1"},
+				S2: []string{},
+			},
+			in2: &struct{ S1, S2 []string }{
+				S1: []string{},
+				S2: []string{"string2"},
+			},
+			out: &struct{ S1, S2 []string }{
+				S1: []string{},
+				S2: []string{"string2"},
+			},
+			order: Replace,
 		},
 		{
 			// Append nil slice
@@ -346,7 +375,41 @@
 				S2: []string{"string2"},
 				S3: nil,
 			},
-			prepend: true,
+			order: Prepend,
+		},
+		{
+			// Replace nil slice
+			in1: &struct{ S1, S2, S3 []string }{
+				S1: []string{"string1"},
+			},
+			in2: &struct{ S1, S2, S3 []string }{
+				S2: []string{"string2"},
+			},
+			out: &struct{ S1, S2, S3 []string }{
+				S1: []string{"string1"},
+				S2: []string{"string2"},
+				S3: nil,
+			},
+			order: Replace,
+		},
+		{
+			// Replace embedded slice
+			in1: &struct{ S *struct{ S1 []string } }{
+				S: &struct{ S1 []string }{
+					S1: []string{"string1"},
+				},
+			},
+			in2: &struct{ S *struct{ S1 []string } }{
+				S: &struct{ S1 []string }{
+					S1: []string{"string2"},
+				},
+			},
+			out: &struct{ S *struct{ S1 []string } }{
+				S: &struct{ S1 []string }{
+					S1: []string{"string2"},
+				},
+			},
+			order: Replace,
 		},
 		{
 			// Append pointer
@@ -383,7 +446,7 @@
 					S: "string2string1",
 				},
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append interface
@@ -420,7 +483,7 @@
 					S: "string2string1",
 				},
 			},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Unexported field
@@ -938,12 +1001,16 @@
 		var err error
 		var testType string
 
-		if testCase.prepend {
-			testType = "prepend"
-			err = PrependProperties(got, testCase.in2, testCase.filter)
-		} else {
+		switch testCase.order {
+		case Append:
 			testType = "append"
 			err = AppendProperties(got, testCase.in2, testCase.filter)
+		case Prepend:
+			testType = "prepend"
+			err = PrependProperties(got, testCase.in2, testCase.filter)
+		case Replace:
+			testType = "replace"
+			err = ExtendProperties(got, testCase.in2, testCase.filter, OrderReplace)
 		}
 
 		check(t, testType, testString, got, err, testCase.out, testCase.err)
@@ -961,17 +1028,24 @@
 		order := func(property string,
 			dstField, srcField reflect.StructField,
 			dstValue, srcValue interface{}) (Order, error) {
-			if testCase.prepend {
-				return Prepend, nil
-			} else {
+			switch testCase.order {
+			case Append:
 				return Append, nil
+			case Prepend:
+				return Prepend, nil
+			case Replace:
+				return Replace, nil
 			}
+			return Append, errors.New("unknown order")
 		}
 
-		if testCase.prepend {
+		switch testCase.order {
+		case Append:
 			testType = "prepend"
-		} else {
+		case Prepend:
 			testType = "append"
+		case Replace:
+			testType = "replace"
 		}
 
 		err = ExtendProperties(got, testCase.in2, testCase.filter, order)
@@ -981,12 +1055,12 @@
 }
 
 type appendMatchingPropertiesTestCase struct {
-	in1     []interface{}
-	in2     interface{}
-	out     []interface{}
-	prepend bool
-	filter  ExtendPropertyFilterFunc
-	err     error
+	in1    []interface{}
+	in2    interface{}
+	out    []interface{}
+	order  Order // default is Append
+	filter ExtendPropertyFilterFunc
+	err    error
 }
 
 func appendMatchingPropertiesTestCases() []appendMatchingPropertiesTestCase {
@@ -1014,7 +1088,7 @@
 			out: []interface{}{&struct{ S string }{
 				S: "string2string1",
 			}},
-			prepend: true,
+			order: Prepend,
 		},
 		{
 			// Append all
@@ -1264,12 +1338,16 @@
 		var err error
 		var testType string
 
-		if testCase.prepend {
-			testType = "prepend matching"
-			err = PrependMatchingProperties(got, testCase.in2, testCase.filter)
-		} else {
-			testType = "append matching"
+		switch testCase.order {
+		case Append:
+			testType = "append"
 			err = AppendMatchingProperties(got, testCase.in2, testCase.filter)
+		case Prepend:
+			testType = "prepend"
+			err = PrependMatchingProperties(got, testCase.in2, testCase.filter)
+		case Replace:
+			testType = "replace"
+			err = ExtendMatchingProperties(got, testCase.in2, testCase.filter, OrderReplace)
 		}
 
 		check(t, testType, testString, got, err, testCase.out, testCase.err)
@@ -1287,17 +1365,24 @@
 		order := func(property string,
 			dstField, srcField reflect.StructField,
 			dstValue, srcValue interface{}) (Order, error) {
-			if testCase.prepend {
-				return Prepend, nil
-			} else {
+			switch testCase.order {
+			case Append:
 				return Append, nil
+			case Prepend:
+				return Prepend, nil
+			case Replace:
+				return Replace, nil
 			}
+			return Append, errors.New("unknown order")
 		}
 
-		if testCase.prepend {
+		switch testCase.order {
+		case Append:
 			testType = "prepend matching"
-		} else {
+		case Prepend:
 			testType = "append matching"
+		case Replace:
+			testType = "replace matching"
 		}
 
 		err = ExtendMatchingProperties(got, testCase.in2, testCase.filter, order)
diff --git a/proptools/filter.go b/proptools/filter.go
index 7a61b02..e6b3336 100644
--- a/proptools/filter.go
+++ b/proptools/filter.go
@@ -15,12 +15,59 @@
 package proptools
 
 import (
+	"fmt"
 	"reflect"
+	"strconv"
 )
 
 type FilterFieldPredicate func(field reflect.StructField, string string) (bool, reflect.StructField)
 
-func filterPropertyStructFields(fields []reflect.StructField, prefix string, predicate FilterFieldPredicate) (filteredFields []reflect.StructField, filtered bool) {
+type cantFitPanic struct {
+	field reflect.StructField
+	size  int
+}
+
+func (x cantFitPanic) Error() string {
+	return fmt.Sprintf("Can't fit field %s %s %s size %d into %d",
+		x.field.Name, x.field.Type.String(), strconv.Quote(string(x.field.Tag)),
+		fieldToTypeNameSize(x.field, true)+2, x.size)
+}
+
+// All runtime created structs will have a name that starts with "struct {" and ends with "}"
+const emptyStructTypeNameSize = len("struct {}")
+
+func filterPropertyStructFields(fields []reflect.StructField, prefix string, maxTypeNameSize int,
+	predicate FilterFieldPredicate) (filteredFieldsShards [][]reflect.StructField, filtered bool) {
+
+	structNameSize := emptyStructTypeNameSize
+
+	var filteredFields []reflect.StructField
+
+	appendAndShardIfNameFull := func(field reflect.StructField) {
+		fieldTypeNameSize := fieldToTypeNameSize(field, true)
+		// Every field will have a space before it and either a semicolon or space after it.
+		fieldTypeNameSize += 2
+
+		if maxTypeNameSize > 0 && structNameSize+fieldTypeNameSize > maxTypeNameSize {
+			if len(filteredFields) == 0 {
+				if isStruct(field.Type) || isStructPtr(field.Type) {
+					// An error fitting the nested struct should have been caught when recursing
+					// into the nested struct.
+					panic(fmt.Errorf("Shouldn't happen: can't fit nested struct %q (%d) into %d",
+						field.Type.String(), len(field.Type.String()), maxTypeNameSize-structNameSize))
+				}
+				panic(cantFitPanic{field, maxTypeNameSize - structNameSize})
+
+			}
+			filteredFieldsShards = append(filteredFieldsShards, filteredFields)
+			filteredFields = nil
+			structNameSize = emptyStructTypeNameSize
+		}
+
+		filteredFields = append(filteredFields, field)
+		structNameSize += fieldTypeNameSize
+	}
+
 	for _, field := range fields {
 		var keep bool
 		if keep, field = predicate(field, prefix); !keep {
@@ -33,32 +80,61 @@
 			subPrefix = prefix + "." + subPrefix
 		}
 
-		// Recurse into structs
-		switch field.Type.Kind() {
-		case reflect.Struct:
-			var subFiltered bool
-			field.Type, subFiltered = filterPropertyStruct(field.Type, subPrefix, predicate)
-			filtered = filtered || subFiltered
-			if field.Type == nil {
-				continue
-			}
-		case reflect.Ptr:
-			if field.Type.Elem().Kind() == reflect.Struct {
-				nestedType, subFiltered := filterPropertyStruct(field.Type.Elem(), subPrefix, predicate)
-				filtered = filtered || subFiltered
-				if nestedType == nil {
-					continue
-				}
-				field.Type = reflect.PtrTo(nestedType)
-			}
-		case reflect.Interface:
-			panic("Interfaces are not supported in filtered property structs")
+		ptrToStruct := false
+		if isStructPtr(field.Type) {
+			ptrToStruct = true
 		}
 
-		filteredFields = append(filteredFields, field)
+		// Recurse into structs
+		if ptrToStruct || isStruct(field.Type) {
+			subMaxTypeNameSize := maxTypeNameSize
+			if maxTypeNameSize > 0 {
+				// In the worst case where only this nested struct will fit in the outer struct, the
+				// outer struct will contribute struct{}, the name and tag of the field that contains
+				// the nested struct, and one space before and after the field.
+				subMaxTypeNameSize -= emptyStructTypeNameSize + fieldToTypeNameSize(field, false) + 2
+			}
+			typ := field.Type
+			if ptrToStruct {
+				subMaxTypeNameSize -= len("*")
+				typ = typ.Elem()
+			}
+			nestedTypes, subFiltered := filterPropertyStruct(typ, subPrefix, subMaxTypeNameSize, predicate)
+			filtered = filtered || subFiltered
+			if nestedTypes == nil {
+				continue
+			}
+
+			for _, nestedType := range nestedTypes {
+				if ptrToStruct {
+					nestedType = reflect.PtrTo(nestedType)
+				}
+				field.Type = nestedType
+				appendAndShardIfNameFull(field)
+			}
+		} else {
+			appendAndShardIfNameFull(field)
+		}
 	}
 
-	return filteredFields, filtered
+	if len(filteredFields) > 0 {
+		filteredFieldsShards = append(filteredFieldsShards, filteredFields)
+	}
+
+	return filteredFieldsShards, filtered
+}
+
+func fieldToTypeNameSize(field reflect.StructField, withType bool) int {
+	nameSize := len(field.Name)
+	nameSize += len(" ")
+	if withType {
+		nameSize += len(field.Type.String())
+	}
+	if field.Tag != "" {
+		nameSize += len(" ")
+		nameSize += len(strconv.Quote(string(field.Tag)))
+	}
+	return nameSize
 }
 
 // FilterPropertyStruct takes a reflect.Type that is either a struct or a pointer to a struct, and returns a
@@ -66,10 +142,20 @@
 // that is true if the new struct type has fewer fields than the original type.  If there are no fields in the
 // original type for which predicate returns true it returns nil and true.
 func FilterPropertyStruct(prop reflect.Type, predicate FilterFieldPredicate) (filteredProp reflect.Type, filtered bool) {
-	return filterPropertyStruct(prop, "", predicate)
+	filteredFieldsShards, filtered := filterPropertyStruct(prop, "", -1, predicate)
+	switch len(filteredFieldsShards) {
+	case 0:
+		return nil, filtered
+	case 1:
+		return filteredFieldsShards[0], filtered
+	default:
+		panic("filterPropertyStruct should only return 1 struct if maxNameSize < 0")
+	}
 }
 
-func filterPropertyStruct(prop reflect.Type, prefix string, predicate FilterFieldPredicate) (filteredProp reflect.Type, filtered bool) {
+func filterPropertyStruct(prop reflect.Type, prefix string, maxNameSize int,
+	predicate FilterFieldPredicate) (filteredProp []reflect.Type, filtered bool) {
+
 	var fields []reflect.StructField
 
 	ptr := prop.Kind() == reflect.Ptr
@@ -81,22 +167,26 @@
 		fields = append(fields, prop.Field(i))
 	}
 
-	filteredFields, filtered := filterPropertyStructFields(fields, prefix, predicate)
+	filteredFieldsShards, filtered := filterPropertyStructFields(fields, prefix, maxNameSize, predicate)
 
-	if len(filteredFields) == 0 {
+	if len(filteredFieldsShards) == 0 {
 		return nil, true
 	}
 
 	if !filtered {
 		if ptr {
-			return reflect.PtrTo(prop), false
+			return []reflect.Type{reflect.PtrTo(prop)}, false
 		}
-		return prop, false
+		return []reflect.Type{prop}, false
 	}
 
-	ret := reflect.StructOf(filteredFields)
-	if ptr {
-		ret = reflect.PtrTo(ret)
+	var ret []reflect.Type
+	for _, filteredFields := range filteredFieldsShards {
+		p := reflect.StructOf(filteredFields)
+		if ptr {
+			p = reflect.PtrTo(p)
+		}
+		ret = append(ret, p)
 	}
 
 	return ret, true
@@ -109,51 +199,6 @@
 // level fields in it to attempt to avoid hitting the 65535 byte type name length limit in reflect.StructOf
 // (reflect.nameFrom: name too long), although the limit can still be reached with a single struct field with many
 // fields in it.
-func FilterPropertyStructSharded(prop reflect.Type, predicate FilterFieldPredicate) (filteredProp []reflect.Type, filtered bool) {
-	var fields []reflect.StructField
-
-	ptr := prop.Kind() == reflect.Ptr
-	if ptr {
-		prop = prop.Elem()
-	}
-
-	for i := 0; i < prop.NumField(); i++ {
-		fields = append(fields, prop.Field(i))
-	}
-
-	fields, filtered = filterPropertyStructFields(fields, "", predicate)
-	if !filtered {
-		if ptr {
-			return []reflect.Type{reflect.PtrTo(prop)}, false
-		}
-		return []reflect.Type{prop}, false
-	}
-
-	if len(fields) == 0 {
-		return nil, true
-	}
-
-	shards := shardFields(fields, 10)
-
-	for _, shard := range shards {
-		s := reflect.StructOf(shard)
-		if ptr {
-			s = reflect.PtrTo(s)
-		}
-		filteredProp = append(filteredProp, s)
-	}
-
-	return filteredProp, true
-}
-
-func shardFields(fields []reflect.StructField, shardSize int) [][]reflect.StructField {
-	ret := make([][]reflect.StructField, 0, (len(fields)+shardSize-1)/shardSize)
-	for len(fields) > shardSize {
-		ret = append(ret, fields[0:shardSize])
-		fields = fields[shardSize:]
-	}
-	if len(fields) > 0 {
-		ret = append(ret, fields)
-	}
-	return ret
+func FilterPropertyStructSharded(prop reflect.Type, maxTypeNameSize int, predicate FilterFieldPredicate) (filteredProp []reflect.Type, filtered bool) {
+	return filterPropertyStruct(prop, "", maxTypeNameSize, predicate)
 }
diff --git a/proptools/filter_test.go b/proptools/filter_test.go
index 695549a..0ea04bb 100644
--- a/proptools/filter_test.go
+++ b/proptools/filter_test.go
@@ -16,6 +16,7 @@
 
 import (
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -237,3 +238,281 @@
 		})
 	}
 }
+
+func TestFilterPropertyStructSharded(t *testing.T) {
+	tests := []struct {
+		name        string
+		maxNameSize int
+		in          interface{}
+		out         []interface{}
+		filtered    bool
+	}{
+		// Property tests
+		{
+			name:        "basic",
+			maxNameSize: 20,
+			in: &struct {
+				A *string `keep:"true"`
+				B *string `keep:"true"`
+				C *string
+			}{},
+			out: []interface{}{
+				&struct {
+					A *string
+				}{},
+				&struct {
+					B *string
+				}{},
+			},
+			filtered: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			out, filtered := filterPropertyStruct(reflect.TypeOf(test.in), "", test.maxNameSize,
+				func(field reflect.StructField, prefix string) (bool, reflect.StructField) {
+					if HasTag(field, "keep", "true") {
+						field.Tag = ""
+						return true, field
+					}
+					return false, field
+				})
+			if filtered != test.filtered {
+				t.Errorf("expected filtered %v, got %v", test.filtered, filtered)
+			}
+			var expected []reflect.Type
+			for _, t := range test.out {
+				expected = append(expected, reflect.TypeOf(t))
+			}
+			if !reflect.DeepEqual(out, expected) {
+				t.Errorf("expected type %v, got %v", expected, out)
+			}
+		})
+	}
+}
+
+func Test_fieldToTypeNameSize(t *testing.T) {
+	tests := []struct {
+		name  string
+		field reflect.StructField
+	}{
+		{
+			name: "string",
+			field: reflect.StructField{
+				Name: "Foo",
+				Type: reflect.TypeOf(""),
+			},
+		},
+		{
+			name: "string pointer",
+			field: reflect.StructField{
+				Name: "Foo",
+				Type: reflect.TypeOf(StringPtr("")),
+			},
+		},
+		{
+			name: "anonymous struct",
+			field: reflect.StructField{
+				Name: "Foo",
+				Type: reflect.TypeOf(struct{ foo string }{}),
+			},
+		}, {
+			name: "anonymous struct pointer",
+			field: reflect.StructField{
+				Name: "Foo",
+				Type: reflect.TypeOf(&struct{ foo string }{}),
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			typeName := reflect.StructOf([]reflect.StructField{test.field}).String()
+			typeName = strings.TrimPrefix(typeName, "struct { ")
+			typeName = strings.TrimSuffix(typeName, " }")
+			if g, w := fieldToTypeNameSize(test.field, true), len(typeName); g != w {
+				t.Errorf("want fieldToTypeNameSize(..., true) = %v, got %v", w, g)
+			}
+			if g, w := fieldToTypeNameSize(test.field, false), len(typeName)-len(test.field.Type.String()); g != w {
+				t.Errorf("want fieldToTypeNameSize(..., false) = %v, got %v", w, g)
+			}
+		})
+	}
+}
+
+func Test_filterPropertyStructFields(t *testing.T) {
+	type args struct {
+	}
+	tests := []struct {
+		name            string
+		maxTypeNameSize int
+		in              interface{}
+		out             []interface{}
+	}{
+		{
+			name:            "empty",
+			maxTypeNameSize: -1,
+			in:              struct{}{},
+			out:             nil,
+		},
+		{
+			name:            "one",
+			maxTypeNameSize: -1,
+			in: struct {
+				A *string
+			}{},
+			out: []interface{}{
+				struct {
+					A *string
+				}{},
+			},
+		},
+		{
+			name:            "two",
+			maxTypeNameSize: 20,
+			in: struct {
+				A *string
+				B *string
+			}{},
+			out: []interface{}{
+				struct {
+					A *string
+				}{},
+				struct {
+					B *string
+				}{},
+			},
+		},
+		{
+			name:            "nested",
+			maxTypeNameSize: 36,
+			in: struct {
+				AAAAA struct {
+					A string
+				}
+				BBBBB struct {
+					B string
+				}
+			}{},
+			out: []interface{}{
+				struct {
+					AAAAA struct {
+						A string
+					}
+				}{},
+				struct {
+					BBBBB struct {
+						B string
+					}
+				}{},
+			},
+		},
+		{
+			name:            "nested pointer",
+			maxTypeNameSize: 37,
+			in: struct {
+				AAAAA *struct {
+					A string
+				}
+				BBBBB *struct {
+					B string
+				}
+			}{},
+			out: []interface{}{
+				struct {
+					AAAAA *struct {
+						A string
+					}
+				}{},
+				struct {
+					BBBBB *struct {
+						B string
+					}
+				}{},
+			},
+		},
+		{
+			name:            "doubly nested",
+			maxTypeNameSize: 49,
+			in: struct {
+				AAAAA struct {
+					A struct {
+						A string
+					}
+				}
+				BBBBB struct {
+					B struct {
+						B string
+					}
+				}
+			}{},
+			out: []interface{}{
+				struct {
+					AAAAA struct {
+						A struct {
+							A string
+						}
+					}
+				}{},
+				struct {
+					BBBBB struct {
+						B struct {
+							B string
+						}
+					}
+				}{},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			inType := reflect.TypeOf(test.in)
+			var in []reflect.StructField
+			for i := 0; i < inType.NumField(); i++ {
+				in = append(in, inType.Field(i))
+			}
+
+			keep := func(field reflect.StructField, string string) (bool, reflect.StructField) {
+				return true, field
+			}
+
+			// Test that maxTypeNameSize is the
+			if test.maxTypeNameSize > 0 {
+				correctPanic := false
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							if _, ok := r.(cantFitPanic); ok {
+								correctPanic = true
+							} else {
+								panic(r)
+							}
+						}
+					}()
+
+					_, _ = filterPropertyStructFields(in, "", test.maxTypeNameSize-1, keep)
+				}()
+
+				if !correctPanic {
+					t.Errorf("filterPropertyStructFields() with size-1 should produce cantFitPanic")
+				}
+			}
+
+			filteredFieldsShards, _ := filterPropertyStructFields(in, "", test.maxTypeNameSize, keep)
+
+			var out []interface{}
+			for _, filteredFields := range filteredFieldsShards {
+				typ := reflect.StructOf(filteredFields)
+				if test.maxTypeNameSize > 0 && len(typ.String()) > test.maxTypeNameSize {
+					t.Errorf("out %q expected size <= %d, got %d",
+						typ.String(), test.maxTypeNameSize, len(typ.String()))
+				}
+				out = append(out, reflect.Zero(typ).Interface())
+			}
+
+			if g, w := out, test.out; !reflect.DeepEqual(g, w) {
+				t.Errorf("filterPropertyStructFields() want %v, got %v", w, g)
+			}
+		})
+	}
+}
diff --git a/proptools/proptools.go b/proptools/proptools.go
index 6881828..c44a4a8 100644
--- a/proptools/proptools.go
+++ b/proptools/proptools.go
@@ -15,19 +15,35 @@
 package proptools
 
 import (
+	"reflect"
+	"strings"
 	"unicode"
 	"unicode/utf8"
 )
 
+// PropertyNameForField converts the name of a field in property struct to the property name that
+// might appear in a Blueprints file.  Since the property struct fields must always be exported
+// to be accessed with reflection and the canonical Blueprints style is lowercased names, it
+// lower cases the first rune in the field name unless the field name contains an uppercase rune
+// after the first rune (which is always uppercase), and no lowercase runes.
 func PropertyNameForField(fieldName string) string {
 	r, size := utf8.DecodeRuneInString(fieldName)
 	propertyName := string(unicode.ToLower(r))
+	if size == len(fieldName) {
+		return propertyName
+	}
+	if strings.IndexFunc(fieldName[size:], unicode.IsLower) == -1 &&
+		strings.IndexFunc(fieldName[size:], unicode.IsUpper) != -1 {
+		return fieldName
+	}
 	if len(fieldName) > size {
 		propertyName += fieldName[size:]
 	}
 	return propertyName
 }
 
+// FieldNameForProperty converts the name of a property that might appear in a Blueprints file to
+// the name of a field in property struct by uppercasing the first rune.
 func FieldNameForProperty(propertyName string) string {
 	r, size := utf8.DecodeRuneInString(propertyName)
 	fieldName := string(unicode.ToUpper(r))
@@ -97,3 +113,11 @@
 func Int(i *int64) int {
 	return IntDefault(i, 0)
 }
+
+func isStruct(t reflect.Type) bool {
+	return t.Kind() == reflect.Struct
+}
+
+func isStructPtr(t reflect.Type) bool {
+	return t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct
+}
diff --git a/proptools/proptools_test.go b/proptools/proptools_test.go
new file mode 100644
index 0000000..207ee1b
--- /dev/null
+++ b/proptools/proptools_test.go
@@ -0,0 +1,114 @@
+// Copyright 2020 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package proptools
+
+import "testing"
+
+func TestPropertyNameForField(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{
+			name:  "short",
+			input: "S",
+			want:  "s",
+		},
+		{
+			name:  "long",
+			input: "String",
+			want:  "string",
+		},
+		{
+			name:  "uppercase",
+			input: "STRING",
+			want:  "STRING",
+		},
+		{
+			name:  "mixed",
+			input: "StRiNg",
+			want:  "stRiNg",
+		},
+		{
+			name:  "underscore",
+			input: "Under_score",
+			want:  "under_score",
+		},
+		{
+			name:  "uppercase underscore",
+			input: "UNDER_SCORE",
+			want:  "UNDER_SCORE",
+		},
+		{
+			name:  "x86",
+			input: "X86",
+			want:  "x86",
+		},
+		{
+			name:  "x86_64",
+			input: "X86_64",
+			want:  "x86_64",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := PropertyNameForField(tt.input); got != tt.want {
+				t.Errorf("PropertyNameForField(%v) = %v, want %v", tt.input, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestFieldNameForProperty(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{
+			name:  "short lowercase",
+			input: "s",
+			want:  "S",
+		},
+		{
+			name:  "short uppercase",
+			input: "S",
+			want:  "S",
+		},
+		{
+			name:  "long lowercase",
+			input: "string",
+			want:  "String",
+		},
+		{
+			name:  "long uppercase",
+			input: "STRING",
+			want:  "STRING",
+		},
+		{
+			name:  "mixed",
+			input: "StRiNg",
+			want:  "StRiNg",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := FieldNameForProperty(tt.input); got != tt.want {
+				t.Errorf("FieldNameForProperty(%v) = %v, want %v", tt.input, got, tt.want)
+			}
+		})
+	}
+}
diff --git a/proptools/tag.go b/proptools/tag.go
index af5b97e..d69853a 100644
--- a/proptools/tag.go
+++ b/proptools/tag.go
@@ -36,7 +36,7 @@
 // are tagged with the given key and value, including ones found in embedded structs or pointers to structs.
 func PropertyIndexesWithTag(ps interface{}, key, value string) [][]int {
 	t := reflect.TypeOf(ps)
-	if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
+	if !isStructPtr(t) {
 		panic(fmt.Errorf("type %s is not a pointer to a struct", t))
 	}
 	t = t.Elem()
@@ -49,7 +49,7 @@
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
 		ft := field.Type
-		if ft.Kind() == reflect.Struct || (ft.Kind() == reflect.Ptr && ft.Elem().Kind() == reflect.Struct) {
+		if isStruct(ft) || isStructPtr(ft) {
 			if ft.Kind() == reflect.Ptr {
 				ft = ft.Elem()
 			}
diff --git a/unpack.go b/proptools/unpack.go
similarity index 73%
rename from unpack.go
rename to proptools/unpack.go
index 3156599..344327f 100644
--- a/unpack.go
+++ b/proptools/unpack.go
@@ -12,24 +12,33 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package blueprint
+package proptools
 
 import (
 	"fmt"
 	"reflect"
-	"strconv"
-	"strings"
+	"text/scanner"
 
 	"github.com/google/blueprint/parser"
-	"github.com/google/blueprint/proptools"
 )
 
+const maxUnpackErrors = 10
+
+type UnpackError struct {
+	Err error
+	Pos scanner.Position
+}
+
+func (e *UnpackError) Error() string {
+	return fmt.Sprintf("%s: %s", e.Pos, e.Err)
+}
+
 type packedProperty struct {
 	property *parser.Property
 	unpacked bool
 }
 
-func unpackProperties(propertyDefs []*parser.Property,
+func UnpackProperties(propertyDefs []*parser.Property,
 	propertiesStructs ...interface{}) (map[string]*parser.Property, []error) {
 
 	propertyMap := make(map[string]*packedProperty)
@@ -40,19 +49,16 @@
 
 	for _, properties := range propertiesStructs {
 		propertiesValue := reflect.ValueOf(properties)
-		if propertiesValue.Kind() != reflect.Ptr {
-			panic("properties must be a pointer to a struct")
+		if !isStructPtr(propertiesValue.Type()) {
+			panic(fmt.Errorf("properties must be *struct, got %s",
+				propertiesValue.Type()))
 		}
-
 		propertiesValue = propertiesValue.Elem()
-		if propertiesValue.Kind() != reflect.Struct {
-			panic("properties must be a pointer to a struct")
-		}
 
-		newErrs := unpackStructValue("", propertiesValue, propertyMap, "", "")
+		newErrs := unpackStructValue("", propertiesValue, propertyMap)
 		errs = append(errs, newErrs...)
 
-		if len(errs) >= maxErrors {
+		if len(errs) >= maxUnpackErrors {
 			return nil, errs
 		}
 	}
@@ -63,7 +69,7 @@
 	for name, packedProperty := range propertyMap {
 		result[name] = packedProperty.property
 		if !packedProperty.unpacked {
-			err := &BlueprintError{
+			err := &UnpackError{
 				Err: fmt.Errorf("unrecognized property %q", name),
 				Pos: packedProperty.property.ColonPos,
 			}
@@ -88,15 +94,15 @@
 				// We've already added this property.
 				continue
 			}
-			errs = append(errs, &BlueprintError{
+			errs = append(errs, &UnpackError{
 				Err: fmt.Errorf("property %q already defined", name),
 				Pos: propertyDef.ColonPos,
 			})
-			errs = append(errs, &BlueprintError{
+			errs = append(errs, &UnpackError{
 				Err: fmt.Errorf("<-- previous definition here"),
 				Pos: first.property.ColonPos,
 			})
-			if len(errs) >= maxErrors {
+			if len(errs) >= maxUnpackErrors {
 				return errs
 			}
 			continue
@@ -119,7 +125,7 @@
 }
 
 func unpackStructValue(namePrefix string, structValue reflect.Value,
-	propertyMap map[string]*packedProperty, filterKey, filterValue string) []error {
+	propertyMap map[string]*packedProperty) []error {
 
 	structType := structValue.Type()
 
@@ -142,7 +148,7 @@
 			continue
 		}
 
-		propertyName := namePrefix + proptools.PropertyNameForField(field.Name)
+		propertyName := namePrefix + PropertyNameForField(field.Name)
 
 		if !fieldValue.CanSet() {
 			panic(fmt.Errorf("field %s is not settable", propertyName))
@@ -163,7 +169,7 @@
 		case reflect.Slice:
 			elemType := field.Type.Elem()
 			if elemType.Kind() != reflect.String {
-				if !proptools.HasTag(field, "blueprint", "mutated") {
+				if !HasTag(field, "blueprint", "mutated") {
 					panic(fmt.Errorf("field %s is a non-string slice", propertyName))
 				}
 			}
@@ -195,7 +201,7 @@
 			}
 
 		case reflect.Int, reflect.Uint:
-			if !proptools.HasTag(field, "blueprint", "mutated") {
+			if !HasTag(field, "blueprint", "mutated") {
 				panic(fmt.Errorf(`int field %s must be tagged blueprint:"mutated"`, propertyName))
 			}
 
@@ -203,8 +209,8 @@
 			panic(fmt.Errorf("unsupported kind for field %s: %s", propertyName, kind))
 		}
 
-		if field.Anonymous && fieldValue.Kind() == reflect.Struct {
-			newErrs := unpackStructValue(namePrefix, fieldValue, propertyMap, filterKey, filterValue)
+		if field.Anonymous && isStruct(fieldValue.Type()) {
+			newErrs := unpackStructValue(namePrefix, fieldValue, propertyMap)
 			errs = append(errs, newErrs...)
 			continue
 		}
@@ -216,25 +222,13 @@
 
 		packedProperty.unpacked = true
 
-		if proptools.HasTag(field, "blueprint", "mutated") {
+		if HasTag(field, "blueprint", "mutated") {
 			errs = append(errs,
-				&BlueprintError{
+				&UnpackError{
 					Err: fmt.Errorf("mutated field %s cannot be set in a Blueprint file", propertyName),
 					Pos: packedProperty.property.ColonPos,
 				})
-			if len(errs) >= maxErrors {
-				return errs
-			}
-			continue
-		}
-
-		if filterKey != "" && !proptools.HasTag(field, filterKey, filterValue) {
-			errs = append(errs,
-				&BlueprintError{
-					Err: fmt.Errorf("filtered field %s cannot be set in a Blueprint file", propertyName),
-					Pos: packedProperty.property.ColonPos,
-				})
-			if len(errs) >= maxErrors {
+			if len(errs) >= maxUnpackErrors {
 				return errs
 			}
 			continue
@@ -242,29 +236,12 @@
 
 		var newErrs []error
 
-		if fieldValue.Kind() == reflect.Struct {
-			localFilterKey, localFilterValue := filterKey, filterValue
-			if k, v, err := HasFilter(field.Tag); err != nil {
-				errs = append(errs, err)
-				if len(errs) >= maxErrors {
-					return errs
-				}
-			} else if k != "" {
-				if filterKey != "" {
-					errs = append(errs, fmt.Errorf("nested filter tag not supported on field %q",
-						field.Name))
-					if len(errs) >= maxErrors {
-						return errs
-					}
-				} else {
-					localFilterKey, localFilterValue = k, v
-				}
-			}
+		if isStruct(fieldValue.Type()) {
 			newErrs = unpackStruct(propertyName+".", fieldValue,
-				packedProperty.property, propertyMap, localFilterKey, localFilterValue)
+				packedProperty.property, propertyMap)
 
 			errs = append(errs, newErrs...)
-			if len(errs) >= maxErrors {
+			if len(errs) >= maxUnpackErrors {
 				return errs
 			}
 
@@ -276,12 +253,12 @@
 		propertyValue, err := propertyToValue(fieldValue.Type(), packedProperty.property)
 		if err != nil {
 			errs = append(errs, err)
-			if len(errs) >= maxErrors {
+			if len(errs) >= maxUnpackErrors {
 				return errs
 			}
 		}
 
-		proptools.ExtendBasicType(fieldValue, propertyValue, proptools.Append)
+		ExtendBasicType(fieldValue, propertyValue, Append)
 	}
 
 	return errs
@@ -354,8 +331,7 @@
 }
 
 func unpackStruct(namePrefix string, structValue reflect.Value,
-	property *parser.Property, propertyMap map[string]*packedProperty,
-	filterKey, filterValue string) []error {
+	property *parser.Property, propertyMap map[string]*packedProperty) []error {
 
 	m, ok := property.Value.Eval().(*parser.Map)
 	if !ok {
@@ -370,31 +346,5 @@
 		return errs
 	}
 
-	return unpackStructValue(namePrefix, structValue, propertyMap, filterKey, filterValue)
-}
-
-func HasFilter(field reflect.StructTag) (k, v string, err error) {
-	tag := field.Get("blueprint")
-	for _, entry := range strings.Split(tag, ",") {
-		if strings.HasPrefix(entry, "filter") {
-			if !strings.HasPrefix(entry, "filter(") || !strings.HasSuffix(entry, ")") {
-				return "", "", fmt.Errorf("unexpected format for filter %q: missing ()", entry)
-			}
-			entry = strings.TrimPrefix(entry, "filter(")
-			entry = strings.TrimSuffix(entry, ")")
-
-			s := strings.Split(entry, ":")
-			if len(s) != 2 {
-				return "", "", fmt.Errorf("unexpected format for filter %q: expected single ':'", entry)
-			}
-			k = s[0]
-			v, err = strconv.Unquote(s[1])
-			if err != nil {
-				return "", "", fmt.Errorf("unexpected format for filter %q: %s", entry, err.Error())
-			}
-			return k, v, nil
-		}
-	}
-
-	return "", "", nil
+	return unpackStructValue(namePrefix, structValue, propertyMap)
 }
diff --git a/unpack_test.go b/proptools/unpack_test.go
similarity index 73%
rename from unpack_test.go
rename to proptools/unpack_test.go
index d6b88ab..942dbb8 100644
--- a/unpack_test.go
+++ b/proptools/unpack_test.go
@@ -12,17 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package blueprint
+package proptools
 
 import (
 	"bytes"
-	"fmt"
 	"reflect"
 	"testing"
 	"text/scanner"
 
 	"github.com/google/blueprint/parser"
-	"github.com/google/blueprint/proptools"
 )
 
 var validUnpackTestCases = []struct {
@@ -34,18 +32,18 @@
 	{
 		input: `
 			m {
-				name: "abc",
+				s: "abc",
 				blank: "",
 			}
 		`,
 		output: []interface{}{
-			struct {
-				Name  *string
+			&struct {
+				S     *string
 				Blank *string
 				Unset *string
 			}{
-				Name:  proptools.StringPtr("abc"),
-				Blank: proptools.StringPtr(""),
+				S:     StringPtr("abc"),
+				Blank: StringPtr(""),
 				Unset: nil,
 			},
 		},
@@ -54,14 +52,14 @@
 	{
 		input: `
 			m {
-				name: "abc",
+				s: "abc",
 			}
 		`,
 		output: []interface{}{
-			struct {
-				Name string
+			&struct {
+				S string
 			}{
-				Name: "abc",
+				S: "abc",
 			},
 		},
 	},
@@ -73,7 +71,7 @@
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				IsGood bool
 			}{
 				IsGood: true,
@@ -89,13 +87,13 @@
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				IsGood *bool
 				IsBad  *bool
 				IsUgly *bool
 			}{
-				IsGood: proptools.BoolPtr(true),
-				IsBad:  proptools.BoolPtr(false),
+				IsGood: BoolPtr(true),
+				IsBad:  BoolPtr(false),
 				IsUgly: nil,
 			},
 		},
@@ -110,7 +108,7 @@
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Stuff     []string
 				Empty     []string
 				Nil       []string
@@ -128,18 +126,18 @@
 		input: `
 			m {
 				nested: {
-					name: "abc",
+					s: "abc",
 				}
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested struct {
-					Name string
+					S string
 				}
 			}{
-				Nested: struct{ Name string }{
-					Name: "abc",
+				Nested: struct{ S string }{
+					S: "abc",
 				},
 			},
 		},
@@ -149,16 +147,16 @@
 		input: `
 			m {
 				nested: {
-					name: "def",
+					s: "def",
 				}
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested interface{}
 			}{
-				Nested: &struct{ Name string }{
-					Name: "def",
+				Nested: &struct{ S string }{
+					S: "def",
 				},
 			},
 		},
@@ -175,7 +173,7 @@
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested struct {
 					Foo string
 				}
@@ -202,7 +200,7 @@
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested struct {
 					Foo string `allowNested:"true"`
 				} `blueprint:"filter(allowNested:\"true\")"`
@@ -220,64 +218,31 @@
 		},
 	},
 
-	{
-		input: `
-			m {
-				nested: {
-					foo: "abc",
-				},
-				bar: false,
-				baz: ["def", "ghi"],
-			}
-		`,
-		output: []interface{}{
-			struct {
-				Nested struct {
-					Foo string
-				} `blueprint:"filter(allowNested:\"true\")"`
-				Bar bool
-				Baz []string
-			}{
-				Nested: struct{ Foo string }{
-					Foo: "",
-				},
-				Bar: false,
-				Baz: []string{"def", "ghi"},
-			},
-		},
-		errs: []error{
-			&BlueprintError{
-				Err: fmt.Errorf("filtered field nested.foo cannot be set in a Blueprint file"),
-				Pos: mkpos(30, 4, 9),
-			},
-		},
-	},
-
 	// Anonymous struct
 	{
 		input: `
 			m {
-				name: "abc",
+				s: "abc",
 				nested: {
-					name: "def",
+					s: "def",
 				},
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				EmbeddedStruct
 				Nested struct {
 					EmbeddedStruct
 				}
 			}{
 				EmbeddedStruct: EmbeddedStruct{
-					Name: "abc",
+					S: "abc",
 				},
 				Nested: struct {
 					EmbeddedStruct
 				}{
 					EmbeddedStruct: EmbeddedStruct{
-						Name: "def",
+						S: "def",
 					},
 				},
 			},
@@ -288,27 +253,27 @@
 	{
 		input: `
 			m {
-				name: "abc",
+				s: "abc",
 				nested: {
-					name: "def",
+					s: "def",
 				},
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				EmbeddedInterface
 				Nested struct {
 					EmbeddedInterface
 				}
 			}{
-				EmbeddedInterface: &struct{ Name string }{
-					Name: "abc",
+				EmbeddedInterface: &struct{ S string }{
+					S: "abc",
 				},
 				Nested: struct {
 					EmbeddedInterface
 				}{
-					EmbeddedInterface: &struct{ Name string }{
-						Name: "def",
+					EmbeddedInterface: &struct{ S string }{
+						S: "def",
 					},
 				},
 			},
@@ -319,32 +284,32 @@
 	{
 		input: `
 			m {
-				name: "abc",
+				s: "abc",
 				nested: {
-					name: "def",
+					s: "def",
 				},
 			}
 		`,
 		output: []interface{}{
-			struct {
-				Name string
+			&struct {
+				S string
 				EmbeddedStruct
 				Nested struct {
-					Name string
+					S string
 					EmbeddedStruct
 				}
 			}{
-				Name: "abc",
+				S: "abc",
 				EmbeddedStruct: EmbeddedStruct{
-					Name: "abc",
+					S: "abc",
 				},
 				Nested: struct {
-					Name string
+					S string
 					EmbeddedStruct
 				}{
-					Name: "def",
+					S: "def",
 					EmbeddedStruct: EmbeddedStruct{
-						Name: "def",
+						S: "def",
 					},
 				},
 			},
@@ -355,32 +320,32 @@
 	{
 		input: `
 			m {
-				name: "abc",
+				s: "abc",
 				nested: {
-					name: "def",
+					s: "def",
 				},
 			}
 		`,
 		output: []interface{}{
-			struct {
-				Name string
+			&struct {
+				S string
 				EmbeddedInterface
 				Nested struct {
-					Name string
+					S string
 					EmbeddedInterface
 				}
 			}{
-				Name: "abc",
-				EmbeddedInterface: &struct{ Name string }{
-					Name: "abc",
+				S: "abc",
+				EmbeddedInterface: &struct{ S string }{
+					S: "abc",
 				},
 				Nested: struct {
-					Name string
+					S string
 					EmbeddedInterface
 				}{
-					Name: "def",
-					EmbeddedInterface: &struct{ Name string }{
-						Name: "def",
+					S: "def",
+					EmbeddedInterface: &struct{ S string }{
+						S: "def",
 					},
 				},
 			},
@@ -394,18 +359,18 @@
 			string = "def"
 			list_with_variable = [string]
 			m {
-				name: string,
+				s: string,
 				list: list,
 				list2: list_with_variable,
 			}
 		`,
 		output: []interface{}{
-			struct {
-				Name  string
+			&struct {
+				S     string
 				List  []string
 				List2 []string
 			}{
-				Name:  "def",
+				S:     "def",
 				List:  []string{"abc"},
 				List2: []string{"def"},
 			},
@@ -417,30 +382,30 @@
 		input: `
 			m {
 				nested: {
-					name: "abc",
+					s: "abc",
 				}
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested struct {
-					Name string
+					S string
 				}
 			}{
-				Nested: struct{ Name string }{
-					Name: "abc",
+				Nested: struct{ S string }{
+					S: "abc",
 				},
 			},
-			struct {
+			&struct {
 				Nested struct {
-					Name string
+					S string
 				}
 			}{
-				Nested: struct{ Name string }{
-					Name: "abc",
+				Nested: struct{ S string }{
+					S: "abc",
 				},
 			},
-			struct {
+			&struct {
 			}{},
 		},
 	},
@@ -450,25 +415,25 @@
 		input: `
 			m {
 				nested: {
-					name: "abc",
+					s: "abc",
 				}
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested *struct {
-					Name string
+					S string
 				}
 			}{
-				Nested: &struct{ Name string }{
-					Name: "abc",
+				Nested: &struct{ S string }{
+					S: "abc",
 				},
 			},
 		},
 		empty: []interface{}{
 			&struct {
 				Nested *struct {
-					Name string
+					S string
 				}
 			}{},
 		},
@@ -479,16 +444,16 @@
 		input: `
 			m {
 				nested: {
-					name: "abc",
+					s: "abc",
 				}
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				Nested interface{}
 			}{
 				Nested: &EmbeddedStruct{
-					Name: "abc",
+					S: "abc",
 				},
 			},
 		},
@@ -513,7 +478,7 @@
 			}
 		`,
 		output: []interface{}{
-			struct {
+			&struct {
 				String     string
 				String_ptr *string
 				Bool       bool
@@ -521,9 +486,9 @@
 				List       []string
 			}{
 				String:     "012abc",
-				String_ptr: proptools.StringPtr("abc"),
+				String_ptr: StringPtr("abc"),
 				Bool:       true,
-				Bool_ptr:   proptools.BoolPtr(false),
+				Bool_ptr:   BoolPtr(false),
 				List:       []string{"0", "1", "2", "a", "b", "c"},
 			},
 		},
@@ -536,18 +501,30 @@
 				List       []string
 			}{
 				String:     "012",
-				String_ptr: proptools.StringPtr("012"),
+				String_ptr: StringPtr("012"),
 				Bool:       true,
-				Bool_ptr:   proptools.BoolPtr(true),
+				Bool_ptr:   BoolPtr(true),
 				List:       []string{"0", "1", "2"},
 			},
 		},
 	},
+	// Captitalized property
+	{
+		input: `
+			m {
+				CAPITALIZED: "foo",
+			}
+		`,
+		output: []interface{}{
+			&struct {
+				CAPITALIZED string
+			}{
+				CAPITALIZED: "foo",
+			},
+		},
+	},
 }
 
-type EmbeddedStruct struct{ Name string }
-type EmbeddedInterface interface{}
-
 func TestUnpackProperties(t *testing.T) {
 	for _, testCase := range validUnpackTestCases {
 		r := bytes.NewBufferString(testCase.input)
@@ -572,10 +549,10 @@
 				output = testCase.empty
 			} else {
 				for _, p := range testCase.output {
-					output = append(output, proptools.CloneEmptyProperties(reflect.ValueOf(p)).Interface())
+					output = append(output, CloneEmptyProperties(reflect.ValueOf(p)).Interface())
 				}
 			}
-			_, errs = unpackProperties(module.Properties, output...)
+			_, errs = UnpackProperties(module.Properties, output...)
 			if len(errs) != 0 && len(testCase.errs) == 0 {
 				t.Errorf("test case: %s", testCase.input)
 				t.Errorf("unexpected unpack errors:")
@@ -596,7 +573,7 @@
 			}
 
 			for i := range output {
-				got := reflect.ValueOf(output[i]).Elem().Interface()
+				got := reflect.ValueOf(output[i]).Interface()
 				if !reflect.DeepEqual(got, testCase.output[i]) {
 					t.Errorf("test case: %s", testCase.input)
 					t.Errorf("incorrect output:")
diff --git a/scope.go b/scope.go
index 84db0cf..0a520d9 100644
--- a/scope.go
+++ b/scope.go
@@ -28,7 +28,7 @@
 	packageContext() *packageContext
 	name() string                                        // "foo"
 	fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
-	value(config interface{}) (*ninjaString, error)
+	value(config interface{}) (ninjaString, error)
 	String() string
 }
 
@@ -351,7 +351,7 @@
 type localVariable struct {
 	namePrefix string
 	name_      string
-	value_     *ninjaString
+	value_     ninjaString
 }
 
 func (l *localVariable) packageContext() *packageContext {
@@ -366,7 +366,7 @@
 	return l.namePrefix + l.name_
 }
 
-func (l *localVariable) value(interface{}) (*ninjaString, error) {
+func (l *localVariable) value(interface{}) (ninjaString, error) {
 	return l.value_, nil
 }
 
diff --git a/visit_test.go b/visit_test.go
index 873e72c..efaadba 100644
--- a/visit_test.go
+++ b/visit_test.go
@@ -125,7 +125,7 @@
 		`),
 	})
 
-	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
+	_, errs := ctx.ParseBlueprintsFiles("Blueprints", nil)
 	if len(errs) > 0 {
 		t.Errorf("unexpected parse errors:")
 		for _, err := range errs {
@@ -149,13 +149,13 @@
 func TestVisit(t *testing.T) {
 	ctx := setupVisitTest(t)
 
-	topModule := ctx.modulesFromName("A", nil)[0].logicModule.(*visitModule)
+	topModule := ctx.moduleGroupFromName("A", nil).modules[0].logicModule.(*visitModule)
 	assertString(t, topModule.properties.VisitDepsDepthFirst, "FEDCB")
 	assertString(t, topModule.properties.VisitDepsDepthFirstIf, "FEDC")
 	assertString(t, topModule.properties.VisitDirectDeps, "B")
 	assertString(t, topModule.properties.VisitDirectDepsIf, "")
 
-	eModule := ctx.modulesFromName("E", nil)[0].logicModule.(*visitModule)
+	eModule := ctx.moduleGroupFromName("E", nil).modules[0].logicModule.(*visitModule)
 	assertString(t, eModule.properties.VisitDepsDepthFirst, "F")
 	assertString(t, eModule.properties.VisitDepsDepthFirstIf, "F")
 	assertString(t, eModule.properties.VisitDirectDeps, "FF")
diff --git a/vnames.go.json b/vnames.go.json
new file mode 100644
index 0000000..ba239c1
--- /dev/null
+++ b/vnames.go.json
@@ -0,0 +1,9 @@
+[
+    {
+        "pattern": "(.*)",
+        "vname": {
+            "corpus": "android.googlesource.com/platform/superproject",
+            "path": "build/blueprint/@1@"
+        }
+    }
+]