From c48c14369cdccd49a50550e3cf2254538c0dba27 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 23 Feb 2018 07:09:01 +0000 Subject: [PATCH] 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 --- android/paths.go | 156 ++++++++++++++++++++++++++--------------------- 1 file changed, 85 insertions(+), 71 deletions(-) diff --git a/android/paths.go b/android/paths.go index 3bb5d1b78..3d4d3f30e 100644 --- a/android/paths.go +++ b/android/paths.go @@ -195,6 +195,20 @@ type Paths []Path // 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 @@ func safePathForSource(ctx PathContext, path string) SourcePath { 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) }