Revert "Move AllowMissingDependencies check from PathsForSource to PathForSource" (c48c1436) · Commits · e / os / android_build_soong

android/paths.go

+75 −61

Original line number	Diff line number	Diff line
		@@ -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())
		reportPathErrorf(ctx, "source path %s is in output", abs)
		return ret
		}

		return ret, nil
		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)
		}

		// 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...)
		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 {
		p, err := validatePath(pathComponents...)
		if err != nil {
		return false, fmt.Errorf("glob: %s", err.Error())
		}

		return len(files) > 0, nil
		reportPathError(ctx, err)
		return OptionalPath{}
		}
		path := SourcePath{basePath{p, ctx.Config(), ""}}

		// 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...)
		abs, err := filepath.Abs(path.String())
		if err != nil {
		reportPathError(ctx, err)
		return OptionalPath{}
		}

		if modCtx, ok := ctx.(ModuleContext); ok && ctx.Config().AllowMissingDependencies() {
		exists, err := existsWithDependencies(ctx, path)
		buildroot, err := filepath.Abs(ctx.Config().buildDir)
		if err != nil {
		reportPathError(ctx, err)
		return OptionalPath{}
		}
		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)
		if strings.HasPrefix(abs, buildroot) {
		reportPathErrorf(ctx, "source path %s is in output", abs)
		return OptionalPath{}
		}
		return path

		if pathtools.IsGlob(path.String()) {
		reportPathErrorf(ctx, "path may not contain a glob: %s", path.String())
		return OptionalPath{}
		}

		// 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...)
		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 {
		reportPathError(ctx, err)
		reportPathErrorf(ctx, "glob: %s", err.Error())
		return OptionalPath{}
		}

		exists, err := existsWithDependencies(ctx, path)
		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 {
		reportPathError(ctx, err)
		reportPathErrorf(ctx, "glob: %s", err.Error())
		return OptionalPath{}
		}
		if !exists {

		ctx.AddNinjaFileDeps(dirs...)

		if len(files) == 0 {
		return OptionalPath{}
		}

		ctx.AddNinjaFileDeps(path.String())
		}
		return OptionalPathForPath(path)
		}