Revert "Move AllowMissingDependencies check from PathsForSource to PathForSource"
This reverts commit 94a321045a743e3f0ecc0185129d2c2a3684e144.
Reason for revert: Broke builds with ALLOW_MISSING_DEPENDENCIES=true
Change-Id: I9604887f796a79809ef8d6c741597796219dcaf3
diff --git a/android/paths.go b/android/paths.go
index 3bb5d1b..3d4d3f3 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -195,6 +195,20 @@
// PathsForSource returns Paths rooted from SrcDir
func PathsForSource(ctx PathContext, paths []string) Paths {
+ if ctx.Config().AllowMissingDependencies() {
+ if modCtx, ok := ctx.(ModuleContext); ok {
+ ret := make(Paths, 0, len(paths))
+ for _, path := range paths {
+ p := ExistentPathForSource(ctx, path)
+ if p.Valid() {
+ ret = append(ret, p.Path())
+ } else {
+ modCtx.AddMissingDependencies([]string{path})
+ }
+ }
+ return ret
+ }
+ }
ret := make(Paths, len(paths))
for i, path := range paths {
ret[i] = PathForSource(ctx, path)
@@ -493,99 +507,99 @@
return ret
}
-// pathForSource creates a SourcePath from pathComponents, but does not check that it exists.
-func pathForSource(ctx PathContext, pathComponents ...string) (SourcePath, error) {
- p, err := validatePath(pathComponents...)
- ret := SourcePath{basePath{p, ctx.Config(), ""}}
- if err != nil {
- return ret, err
- }
-
- abs, err := filepath.Abs(ret.String())
- if err != nil {
- return ret, err
- }
- buildroot, err := filepath.Abs(ctx.Config().buildDir)
- if err != nil {
- return ret, err
- }
- if strings.HasPrefix(abs, buildroot) {
- return ret, fmt.Errorf("source path %s is in output", abs)
- }
-
- if pathtools.IsGlob(ret.String()) {
- return ret, fmt.Errorf("path may not contain a glob: %s", ret.String())
- }
-
- return ret, nil
-}
-
-// existsWithDependencies returns true if the path exists, and adds appropriate dependencies to rerun if the
-// path does not exist.
-func existsWithDependencies(ctx PathContext, path SourcePath) (exists bool, err error) {
- var files []string
-
- if gctx, ok := ctx.(PathGlobContext); ok {
- // Use glob to produce proper dependencies, even though we only want
- // a single file.
- files, err = gctx.GlobWithDeps(path.String(), nil)
- } else {
- var deps []string
- // We cannot add build statements in this context, so we fall back to
- // AddNinjaFileDeps
- files, deps, err = pathtools.Glob(path.String(), nil)
- ctx.AddNinjaFileDeps(deps...)
- }
-
- if err != nil {
- return false, fmt.Errorf("glob: %s", err.Error())
- }
-
- return len(files) > 0, nil
-}
-
// PathForSource joins the provided path components and validates that the result
// neither escapes the source dir nor is in the out dir.
// On error, it will return a usable, but invalid SourcePath, and report a ModuleError.
func PathForSource(ctx PathContext, pathComponents ...string) SourcePath {
- path, err := pathForSource(ctx, pathComponents...)
+ p, err := validatePath(pathComponents...)
+ ret := SourcePath{basePath{p, ctx.Config(), ""}}
if err != nil {
reportPathError(ctx, err)
+ return ret
}
- if modCtx, ok := ctx.(ModuleContext); ok && ctx.Config().AllowMissingDependencies() {
- exists, err := existsWithDependencies(ctx, path)
- if err != nil {
- reportPathError(ctx, err)
- }
- if !exists {
- modCtx.AddMissingDependencies([]string{path.String()})
- }
- } else if exists, _, err := ctx.Fs().Exists(path.String()); err != nil {
- reportPathErrorf(ctx, "%s: %s", path, err.Error())
- } else if !exists {
- reportPathErrorf(ctx, "source path %s does not exist", path)
+ abs, err := filepath.Abs(ret.String())
+ if err != nil {
+ reportPathError(ctx, err)
+ return ret
}
- return path
+ buildroot, err := filepath.Abs(ctx.Config().buildDir)
+ if err != nil {
+ reportPathError(ctx, err)
+ return ret
+ }
+ if strings.HasPrefix(abs, buildroot) {
+ reportPathErrorf(ctx, "source path %s is in output", abs)
+ return ret
+ }
+
+ if exists, _, err := ctx.Fs().Exists(ret.String()); err != nil {
+ reportPathErrorf(ctx, "%s: %s", ret, err.Error())
+ } else if !exists {
+ reportPathErrorf(ctx, "source path %s does not exist", ret)
+ }
+ return ret
}
// ExistentPathForSource returns an OptionalPath with the SourcePath if the
// path exists, or an empty OptionalPath if it doesn't exist. Dependencies are added
// so that the ninja file will be regenerated if the state of the path changes.
func ExistentPathForSource(ctx PathContext, pathComponents ...string) OptionalPath {
- path, err := pathForSource(ctx, pathComponents...)
+ p, err := validatePath(pathComponents...)
if err != nil {
reportPathError(ctx, err)
return OptionalPath{}
}
+ path := SourcePath{basePath{p, ctx.Config(), ""}}
+
+ abs, err := filepath.Abs(path.String())
+ if err != nil {
+ reportPathError(ctx, err)
+ return OptionalPath{}
+ }
+ buildroot, err := filepath.Abs(ctx.Config().buildDir)
+ if err != nil {
+ reportPathError(ctx, err)
+ return OptionalPath{}
+ }
+ if strings.HasPrefix(abs, buildroot) {
+ reportPathErrorf(ctx, "source path %s is in output", abs)
+ return OptionalPath{}
+ }
- exists, err := existsWithDependencies(ctx, path)
- if err != nil {
- reportPathError(ctx, err)
+ if pathtools.IsGlob(path.String()) {
+ reportPathErrorf(ctx, "path may not contain a glob: %s", path.String())
return OptionalPath{}
}
- if !exists {
- return OptionalPath{}
+
+ if gctx, ok := ctx.(PathGlobContext); ok {
+ // Use glob to produce proper dependencies, even though we only want
+ // a single file.
+ files, err := gctx.GlobWithDeps(path.String(), nil)
+ if err != nil {
+ reportPathErrorf(ctx, "glob: %s", err.Error())
+ return OptionalPath{}
+ }
+
+ if len(files) == 0 {
+ return OptionalPath{}
+ }
+ } else {
+ // We cannot add build statements in this context, so we fall back to
+ // AddNinjaFileDeps
+ files, dirs, err := pathtools.Glob(path.String(), nil)
+ if err != nil {
+ reportPathErrorf(ctx, "glob: %s", err.Error())
+ return OptionalPath{}
+ }
+
+ ctx.AddNinjaFileDeps(dirs...)
+
+ if len(files) == 0 {
+ return OptionalPath{}
+ }
+
+ ctx.AddNinjaFileDeps(path.String())
}
return OptionalPathForPath(path)
}