From c48c14369cdccd49a50550e3cf2254538c0dba27 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 23 Feb 2018 07:09:01 +0000 Subject: 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 | 136 ++++++++++++++++++++++++++++++------------------------- 1 file changed, 75 insertions(+), 61 deletions(-) diff --git a/android/paths.go b/android/paths.go index 3bb5d1b7..3d4d3f30 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,100 +507,100 @@ 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) { +// 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 { p, err := validatePath(pathComponents...) ret := SourcePath{basePath{p, ctx.Config(), ""}} if err != nil { - return ret, err + reportPathError(ctx, err) + return ret } abs, err := filepath.Abs(ret.String()) if err != nil { - return ret, err + reportPathError(ctx, err) + return ret } buildroot, err := filepath.Abs(ctx.Config().buildDir) if err != nil { - return ret, err + reportPathError(ctx, err) + return ret } 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...) - if err != nil { - reportPathError(ctx, err) + reportPathErrorf(ctx, "source path %s is in output", abs) + 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()) + 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", path) + reportPathErrorf(ctx, "source path %s does not exist", ret) } - return path + 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(), ""}} - exists, err := existsWithDependencies(ctx, path) + abs, err := filepath.Abs(path.String()) if err != nil { reportPathError(ctx, err) return OptionalPath{} } - if !exists { + 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{} + } + + if pathtools.IsGlob(path.String()) { + reportPathErrorf(ctx, "path may not contain a glob: %s", path.String()) 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) } -- cgit v1.2.3