scripts/cog/ide_query/analyzer.go - fuchsia - Git at Google

 // Copyright 2026 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package main

 import (
 	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"sort"
 	"strings"
 )

 const unknownTarget = "Unknown to Build"

 // CompileCommand represents an entry in compile_commands.json.
 type CompileCommand struct {
 	Directory string   `json:"directory"`
 	File      string   `json:"file"`
 	Command   string   `json:"command,omitempty"`
 	Arguments []string `json:"arguments,omitempty"`
 }

 // GetArgs returns the command line arguments for the compilation.
 func (c *CompileCommand) GetArgs() []string {
 	if len(c.Arguments) > 0 {
 		return c.Arguments
 	}
 	return splitCommand(c.Command)
 }

 // splitCommand splits a shell command string into arguments, handling simple quoting.
 func splitCommand(cmd string) []string {
 	var args []string
 	var arg strings.Builder
 	inQuote := false
 	var quoteChar rune

 	runes := []rune(cmd)
 	for i := 0; i < len(runes); i++ {
 		r := runes[i]

 		// Handle backslash escapes. Note that this simple implementation
 		// treats backslash as an escape character both inside and outside quotes.
 		if r == '\\' && i+1 < len(runes) {
 			arg.WriteRune(runes[i+1])
 			i++
 			continue
 		}

 		if inQuote {
 			if r == quoteChar {
 				inQuote = false
 			} else {
 				arg.WriteRune(r)
 			}
 		} else {
 			if r == '"' || r == '\'' {
 				inQuote = true
 				quoteChar = r
 			} else if r == ' ' {
 				if arg.Len() > 0 {
 					args = append(args, arg.String())
 					arg.Reset()
 				}
 			} else {
 				arg.WriteRune(r)
 			}
 		}
 	}
 	if arg.Len() > 0 {
 		args = append(args, arg.String())
 	}
 	return args
 }

 // ExtractOutput finds the primary output file (-o) in the compilation command.
 func ExtractOutput(cmd CompileCommand) (string, error) {
 	args := cmd.GetArgs()
 	for i := 0; i < len(args)-1; i++ {
 		if args[i] == "-o" {
 			out := args[i+1]
 			if !filepath.IsAbs(out) {
 				out = filepath.Join(cmd.Directory, out)
 			}
 			return out, nil
 		}
 	}
 	return "", fmt.Errorf("no output file found in command")
 }

 // PopulateTargets identifies the GN build targets for the files in the context.
 func (ctx *WorkspaceContext) PopulateTargets() error {
 	if ctx.BuildDir == "" {
 		return nil
 	}

 	compDbPath := filepath.Join(ctx.BuildDir, "compile_commands.json")
 	if _, err := os.Stat(compDbPath); os.IsNotExist(err) {
 		return nil // No compilation database, can't find targets.
 	}

 	data, err := os.ReadFile(compDbPath)
 	if err != nil {
 		return fmt.Errorf("failed to read compile_commands.json: %w", err)
 	}

 	var commands []CompileCommand
 	if err := json.Unmarshal(data, &commands); err != nil {
 		return fmt.Errorf("failed to unmarshal compile_commands.json: %w", err)
 	}

 	// Maps for exact match and heuristic fallback.
 	fileToCmd := make(map[string][]CompileCommand)
 	dirToCmd := make(map[string]CompileCommand)
 	dirAndBaseToCmd := make(map[string][]CompileCommand)

 	for _, cmd := range commands {
 		absFile := cmd.File
 		if !filepath.IsAbs(absFile) {
 			absFile = filepath.Join(cmd.Directory, absFile)
 		}

 		relFile := ctx.toRel(absFile)
 		fileToCmd[relFile] = append(fileToCmd[relFile], cmd)

 		relDir := filepath.Dir(relFile)
 		// For the general directory fallback, we just need one example command
 		// to "borrow" flags or output structure from.
 		if _, ok := dirToCmd[relDir]; !ok {
 			dirToCmd[relDir] = cmd
 		}

 		base := strings.TrimSuffix(filepath.Base(relFile), filepath.Ext(relFile))
 		key := relDir + ":" + base
 		dirAndBaseToCmd[key] = append(dirAndBaseToCmd[key], cmd)
 	}

 	// ninjaToLabel caches the resolution of Ninja paths to GN labels.
 	ninjaToLabel := make(map[string]string)

 	for i, f := range ctx.Files {
 		if f.Status != StatusFound || f.IsDirectory {
 			continue
 		}

 		// Only attempt to find targets for C-family files.
 		ext := filepath.Ext(f.AbsPath)
 		switch ext {
 		case ".cc", ".cpp", ".cxx", ".c", ".h", ".hh", ".hpp":
 			// proceed
 		default:
 			continue
 		}

 		relFile := ctx.toRel(f.AbsPath)
 		var candidateCmds []CompileCommand
 		relDir := filepath.Dir(relFile)

 		if cmds, ok := fileToCmd[relFile]; ok {
 			candidateCmds = cmds
 		} else {
 			// Heuristic 1: look for a file with the same base name in the same directory.
 			base := strings.TrimSuffix(filepath.Base(relFile), filepath.Ext(relFile))
 			if cmds, ok := dirAndBaseToCmd[relDir+":"+base]; ok {
 				candidateCmds = cmds
 			}
 		}

 		if len(candidateCmds) == 0 {
 			// Heuristic 2: walk up the tree and find a file with similar base name.
 			base := strings.TrimSuffix(filepath.Base(relFile), filepath.Ext(relFile))
 			curr := filepath.Dir(relDir)
 			for {
 				if cmds, found := dirAndBaseToCmd[curr+":"+base]; found {
 					candidateCmds = cmds
 					break
 				}
 				parent := filepath.Dir(curr)
 				if parent == curr {
 					break
 				}
 				curr = parent
 			}
 		}

 		if len(candidateCmds) == 0 {
 			// Heuristic 3: try neighbor in the same directory.
 			if cmd, ok := dirToCmd[relDir]; ok {
 				candidateCmds = []CompileCommand{cmd}
 			}
 		}

 		if len(candidateCmds) == 0 {
 			f.BuildTargets = []string{unknownTarget}
 			ctx.Files[i] = f
 			continue
 		}

 		// Resolve all candidate commands to unique labels.
 		var labels []string
 		for _, cmd := range candidateCmds {
 			output, err := ExtractOutput(cmd)
 			if err != nil {
 				continue
 			}

 			// build/api/client expects paths relative to the build directory.
 			relOutput, err := filepath.Rel(ctx.BuildDir, output)
 			if err != nil {
 				relOutput = output
 			}

 			label, ok := ninjaToLabel[relOutput]
 			if !ok {
 				label, err = resolveNinjaPath(ctx, relOutput)
 				if err != nil || label == "" {
 					label = unknownTarget
 				}
 				ninjaToLabel[relOutput] = label
 			}
 			if label != unknownTarget {
 				labels = append(labels, label)
 			}
 		}

 		if len(labels) == 0 {
 			f.BuildTargets = []string{unknownTarget}
 		} else {
 			// Deduplicate and sort labels, then pick the first one alphabetically.
 			sort.Strings(labels)
 			unique := labels[:0]
 			for _, l := range labels {
 				if len(unique) == 0 || l != unique[len(unique)-1] {
 					unique = append(unique, l)
 				}
 			}
 			f.BuildTargets = []string{unique[0]}
 		}
 		ctx.Files[i] = f
 	}

 	if err := ctx.VerifyBuild(); err != nil {
 		return fmt.Errorf("failed during build verification: %w", err)
 	}

 	return nil
 }

 // VerifyBuild handles the synchronization of the shadow build directory and executes the build.
 func (ctx *WorkspaceContext) VerifyBuild() error {
 	if ctx.BuildDir == "" {
 		ctx.setAnalysisErrorOnFoundFiles("Build directory not specified and .fx-build-dir is missing.")
 		return nil
 	}

 	ideAnalysisDir := filepath.Join(ctx.FuchsiaDir, "out", ".ide-analysis")
 	argsGnPath := filepath.Join(ctx.BuildDir, "args.gn")
 	destArgsGnPath := filepath.Join(ideAnalysisDir, "args.gn")

 	// 1. Check for args.gn in primary build directory.
 	if _, err := os.Stat(argsGnPath); os.IsNotExist(err) {
 		ctx.setAnalysisErrorOnFoundFiles("args.gn missing in primary build directory: %s", ctx.BuildDir)
 		return nil
 	}

 	// 2. Sync args.gn and run fx gen if needed.
 	changed, err := syncFile(argsGnPath, destArgsGnPath)
 	if err != nil {
 		ctx.setAnalysisErrorOnFoundFiles("failed to sync args.gn: %v", err)
 		return nil
 	}

 	if changed {
 		if err := ctx.runFx(ideAnalysisDir, "gen"); err != nil {
 			ctx.setAnalysisErrorOnFoundFiles("fx gen failed: %v", err)
 			return nil
 		}
 	}

 	// 3. Collect targets and execute build.
 	targets := make([]string, 0)
 	targetToFiles := make(map[string][]int)
 	for i, f := range ctx.Files {
 		if f.Status == StatusNotFound {
 			ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusNotFound}
 			continue
 		}
 		if len(f.BuildTargets) == 0 || f.BuildTargets[0] == unknownTarget {
 			ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusUnknown}
 			continue
 		}
 		for _, t := range f.BuildTargets {
 			if _, ok := targetToFiles[t]; !ok {
 				targets = append(targets, t)
 			}
 			targetToFiles[t] = append(targetToFiles[t], i)
 		}
 	}

 	if len(targets) == 0 {
 		return nil
 	}

 	// 4. Execute build and populate results.
 	// Try to build all targets at once first for performance.
 	// If that fails, fall back to building them one by one to identify specific failures.

 	batchArgs := append([]string{"build"}, targets...)
 	batchErr := ctx.runFx(ideAnalysisDir, batchArgs...)

 	if batchErr == nil {
 		// All targets built successfully.
 		for _, target := range targets {
 			for _, i := range targetToFiles[target] {
 				if ctx.Files[i].AnalysisResult == nil || ctx.Files[i].AnalysisResult.Status != AnalysisStatusBuildFailed {
 					ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusOk}
 				}
 			}
 		}
 	} else {
 		// Fallback to serial builds to identify specific failures.
 		for _, target := range targets {
 			buildErr := ctx.runFx(ideAnalysisDir, "build", target)
 			for _, i := range targetToFiles[target] {
 				if buildErr != nil {
 					ctx.Files[i].AnalysisResult = &AnalysisResult{
 						Status:  AnalysisStatusBuildFailed,
 						Message: "File failed to build.",
 					}
 				} else {
 					// Only set to OK if it hasn't been set as failed by another target.
 					if ctx.Files[i].AnalysisResult == nil || ctx.Files[i].AnalysisResult.Status != AnalysisStatusBuildFailed {
 						ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusOk}
 					}
 				}
 			}
 		}
 	}

 	return nil
 }

 // setAnalysisErrorOnFoundFiles sets the AnalysisError field on all files with StatusFound.
 func (ctx *WorkspaceContext) setAnalysisErrorOnFoundFiles(format string, a ...interface{}) {
 	errMsg := fmt.Sprintf(format, a...)
 	for i := range ctx.Files {
 		if ctx.Files[i].Status == StatusFound {
 			ctx.Files[i].AnalysisError = errMsg
 		}
 	}
 }

 func (ctx *WorkspaceContext) runFx(dir string, args ...string) error {
 	return runFx(ctx, dir, args...)
 }

 var runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
 	fxPath := filepath.Join(ctx.FuchsiaDir, ".jiri_root", "bin", "fx")
 	fullArgs := append([]string{"--dir", dir}, args...)
 	cmd := exec.Command(fxPath, fullArgs...)
 	cmd.Dir = ctx.FuchsiaDir
 	if out, err := cmd.CombinedOutput(); err != nil {
 		return fmt.Errorf("fx %v failed: %w\nOutput: %s", args, err, string(out))
 	}
 	return nil
 }

 func syncFile(src, dst string) (bool, error) {
 	srcContent, err := os.ReadFile(src)
 	if err != nil {
 		return false, err
 	}

 	dstContent, err := os.ReadFile(dst)
 	if err == nil && bytes.Equal(srcContent, dstContent) {
 		return false, nil
 	}

 	if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
 		return false, err
 	}

 	if err := os.WriteFile(dst, srcContent, 0644); err != nil {
 		return false, err
 	}

 	return true, nil
 }

 // toRel normalizes a path to be relative to the Fuchsia root,
 // handling cases where absolute paths might use different Cog/CartFS mount points.
 func (ctx *WorkspaceContext) toRel(path string) string {
 	// Try standard relative path first.
 	rel, err := filepath.Rel(ctx.FuchsiaDir, path)
 	if err == nil && !strings.HasPrefix(rel, "..") {
 		return rel
 	}

 	// Heuristic: If we can't get a direct relative path (likely due to mount point mismatch),
 	// find the part of the path that follows the fuchsia root basename.
 	rootBase := filepath.Base(ctx.FuchsiaDir)
 	search := "/" + rootBase + "/"
 	if idx := strings.LastIndex(path, search); idx != -1 {
 		return path[idx+len(search):]
 	}

 	return path
 }

 // resolveNinjaPath resolves a Ninja path to a GN label.
 // This is a variable so it can be overridden in tests.
 var resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
 	clientPath := filepath.Join(ctx.FuchsiaDir, "build", "api", "client")
 	// Use --allow-unknown so we get the path back instead of an error if it's not found.
 	args := []string{"ninja_path_to_gn_label", "--allow-unknown", ninjaPath}

 	cmd := exec.Command(clientPath, args...)
 	cmd.Dir = ctx.FuchsiaDir
 	out, err := cmd.Output()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			return "", fmt.Errorf("build/api/client failed with stderr: %s", string(exitErr.Stderr))
 		}
 		return "", err
 	}

 	label := strings.TrimSpace(string(out))
 	if label == ninjaPath {
 		return "", nil // Tool returned the input path, which means it's unknown.
 	}
 	return label, nil
 }
	// Copyright 2026 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package main

	import (
	"bytes"
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strings"
	)

	const unknownTarget = "Unknown to Build"

	// CompileCommand represents an entry in compile_commands.json.
	type CompileCommand struct {
	Directory string `json:"directory"`
	File string `json:"file"`
	Command string `json:"command,omitempty"`
	Arguments []string `json:"arguments,omitempty"`
	}

	// GetArgs returns the command line arguments for the compilation.
	func (c *CompileCommand) GetArgs() []string {
	if len(c.Arguments) > 0 {
	return c.Arguments
	}
	return splitCommand(c.Command)
	}

	// splitCommand splits a shell command string into arguments, handling simple quoting.
	func splitCommand(cmd string) []string {
	var args []string
	var arg strings.Builder
	inQuote := false
	var quoteChar rune

	runes := []rune(cmd)
	for i := 0; i < len(runes); i++ {
	r := runes[i]

	// Handle backslash escapes. Note that this simple implementation
	// treats backslash as an escape character both inside and outside quotes.
	if r == '\\' && i+1 < len(runes) {
	arg.WriteRune(runes[i+1])
	i++
	continue
	}

	if inQuote {
	if r == quoteChar {
	inQuote = false
	} else {
	arg.WriteRune(r)
	}
	} else {
	if r == '"' \|\| r == '\'' {
	inQuote = true
	quoteChar = r
	} else if r == ' ' {
	if arg.Len() > 0 {
	args = append(args, arg.String())
	arg.Reset()
	}
	} else {
	arg.WriteRune(r)
	}
	}
	}
	if arg.Len() > 0 {
	args = append(args, arg.String())
	}
	return args
	}

	// ExtractOutput finds the primary output file (-o) in the compilation command.
	func ExtractOutput(cmd CompileCommand) (string, error) {
	args := cmd.GetArgs()
	for i := 0; i < len(args)-1; i++ {
	if args[i] == "-o" {
	out := args[i+1]
	if !filepath.IsAbs(out) {
	out = filepath.Join(cmd.Directory, out)
	}
	return out, nil
	}
	}
	return "", fmt.Errorf("no output file found in command")
	}

	// PopulateTargets identifies the GN build targets for the files in the context.
	func (ctx *WorkspaceContext) PopulateTargets() error {
	if ctx.BuildDir == "" {
	return nil
	}

	compDbPath := filepath.Join(ctx.BuildDir, "compile_commands.json")
	if _, err := os.Stat(compDbPath); os.IsNotExist(err) {
	return nil // No compilation database, can't find targets.
	}

	data, err := os.ReadFile(compDbPath)
	if err != nil {
	return fmt.Errorf("failed to read compile_commands.json: %w", err)
	}

	var commands []CompileCommand
	if err := json.Unmarshal(data, &commands); err != nil {
	return fmt.Errorf("failed to unmarshal compile_commands.json: %w", err)
	}

	// Maps for exact match and heuristic fallback.
	fileToCmd := make(map[string][]CompileCommand)
	dirToCmd := make(map[string]CompileCommand)
	dirAndBaseToCmd := make(map[string][]CompileCommand)

	for _, cmd := range commands {
	absFile := cmd.File
	if !filepath.IsAbs(absFile) {
	absFile = filepath.Join(cmd.Directory, absFile)
	}

	relFile := ctx.toRel(absFile)
	fileToCmd[relFile] = append(fileToCmd[relFile], cmd)

	relDir := filepath.Dir(relFile)
	// For the general directory fallback, we just need one example command
	// to "borrow" flags or output structure from.
	if _, ok := dirToCmd[relDir]; !ok {
	dirToCmd[relDir] = cmd
	}

	base := strings.TrimSuffix(filepath.Base(relFile), filepath.Ext(relFile))
	key := relDir + ":" + base
	dirAndBaseToCmd[key] = append(dirAndBaseToCmd[key], cmd)
	}

	// ninjaToLabel caches the resolution of Ninja paths to GN labels.
	ninjaToLabel := make(map[string]string)

	for i, f := range ctx.Files {
	if f.Status != StatusFound \|\| f.IsDirectory {
	continue
	}

	// Only attempt to find targets for C-family files.
	ext := filepath.Ext(f.AbsPath)
	switch ext {
	case ".cc", ".cpp", ".cxx", ".c", ".h", ".hh", ".hpp":
	// proceed
	default:
	continue
	}

	relFile := ctx.toRel(f.AbsPath)
	var candidateCmds []CompileCommand
	relDir := filepath.Dir(relFile)

	if cmds, ok := fileToCmd[relFile]; ok {
	candidateCmds = cmds
	} else {
	// Heuristic 1: look for a file with the same base name in the same directory.
	base := strings.TrimSuffix(filepath.Base(relFile), filepath.Ext(relFile))
	if cmds, ok := dirAndBaseToCmd[relDir+":"+base]; ok {
	candidateCmds = cmds
	}
	}

	if len(candidateCmds) == 0 {
	// Heuristic 2: walk up the tree and find a file with similar base name.
	base := strings.TrimSuffix(filepath.Base(relFile), filepath.Ext(relFile))
	curr := filepath.Dir(relDir)
	for {
	if cmds, found := dirAndBaseToCmd[curr+":"+base]; found {
	candidateCmds = cmds
	break
	}
	parent := filepath.Dir(curr)
	if parent == curr {
	break
	}
	curr = parent
	}
	}

	if len(candidateCmds) == 0 {
	// Heuristic 3: try neighbor in the same directory.
	if cmd, ok := dirToCmd[relDir]; ok {
	candidateCmds = []CompileCommand{cmd}
	}
	}

	if len(candidateCmds) == 0 {
	f.BuildTargets = []string{unknownTarget}
	ctx.Files[i] = f
	continue
	}

	// Resolve all candidate commands to unique labels.
	var labels []string
	for _, cmd := range candidateCmds {
	output, err := ExtractOutput(cmd)
	if err != nil {
	continue
	}

	// build/api/client expects paths relative to the build directory.
	relOutput, err := filepath.Rel(ctx.BuildDir, output)
	if err != nil {
	relOutput = output
	}

	label, ok := ninjaToLabel[relOutput]
	if !ok {
	label, err = resolveNinjaPath(ctx, relOutput)
	if err != nil \|\| label == "" {
	label = unknownTarget
	}
	ninjaToLabel[relOutput] = label
	}
	if label != unknownTarget {
	labels = append(labels, label)
	}
	}

	if len(labels) == 0 {
	f.BuildTargets = []string{unknownTarget}
	} else {
	// Deduplicate and sort labels, then pick the first one alphabetically.
	sort.Strings(labels)
	unique := labels[:0]
	for _, l := range labels {
	if len(unique) == 0 \|\| l != unique[len(unique)-1] {
	unique = append(unique, l)
	}
	}
	f.BuildTargets = []string{unique[0]}
	}
	ctx.Files[i] = f
	}

	if err := ctx.VerifyBuild(); err != nil {
	return fmt.Errorf("failed during build verification: %w", err)
	}

	return nil
	}

	// VerifyBuild handles the synchronization of the shadow build directory and executes the build.
	func (ctx *WorkspaceContext) VerifyBuild() error {
	if ctx.BuildDir == "" {
	ctx.setAnalysisErrorOnFoundFiles("Build directory not specified and .fx-build-dir is missing.")
	return nil
	}

	ideAnalysisDir := filepath.Join(ctx.FuchsiaDir, "out", ".ide-analysis")
	argsGnPath := filepath.Join(ctx.BuildDir, "args.gn")
	destArgsGnPath := filepath.Join(ideAnalysisDir, "args.gn")

	// 1. Check for args.gn in primary build directory.
	if _, err := os.Stat(argsGnPath); os.IsNotExist(err) {
	ctx.setAnalysisErrorOnFoundFiles("args.gn missing in primary build directory: %s", ctx.BuildDir)
	return nil
	}

	// 2. Sync args.gn and run fx gen if needed.
	changed, err := syncFile(argsGnPath, destArgsGnPath)
	if err != nil {
	ctx.setAnalysisErrorOnFoundFiles("failed to sync args.gn: %v", err)
	return nil
	}

	if changed {
	if err := ctx.runFx(ideAnalysisDir, "gen"); err != nil {
	ctx.setAnalysisErrorOnFoundFiles("fx gen failed: %v", err)
	return nil
	}
	}

	// 3. Collect targets and execute build.
	targets := make([]string, 0)
	targetToFiles := make(map[string][]int)
	for i, f := range ctx.Files {
	if f.Status == StatusNotFound {
	ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusNotFound}
	continue
	}
	if len(f.BuildTargets) == 0 \|\| f.BuildTargets[0] == unknownTarget {
	ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusUnknown}
	continue
	}
	for _, t := range f.BuildTargets {
	if _, ok := targetToFiles[t]; !ok {
	targets = append(targets, t)
	}
	targetToFiles[t] = append(targetToFiles[t], i)
	}
	}

	if len(targets) == 0 {
	return nil
	}

	// 4. Execute build and populate results.
	// Try to build all targets at once first for performance.
	// If that fails, fall back to building them one by one to identify specific failures.

	batchArgs := append([]string{"build"}, targets...)
	batchErr := ctx.runFx(ideAnalysisDir, batchArgs...)

	if batchErr == nil {
	// All targets built successfully.
	for _, target := range targets {
	for _, i := range targetToFiles[target] {
	if ctx.Files[i].AnalysisResult == nil \|\| ctx.Files[i].AnalysisResult.Status != AnalysisStatusBuildFailed {
	ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusOk}
	}
	}
	}
	} else {
	// Fallback to serial builds to identify specific failures.
	for _, target := range targets {
	buildErr := ctx.runFx(ideAnalysisDir, "build", target)
	for _, i := range targetToFiles[target] {
	if buildErr != nil {
	ctx.Files[i].AnalysisResult = &AnalysisResult{
	Status: AnalysisStatusBuildFailed,
	Message: "File failed to build.",
	}
	} else {
	// Only set to OK if it hasn't been set as failed by another target.
	if ctx.Files[i].AnalysisResult == nil \|\| ctx.Files[i].AnalysisResult.Status != AnalysisStatusBuildFailed {
	ctx.Files[i].AnalysisResult = &AnalysisResult{Status: AnalysisStatusOk}
	}
	}
	}
	}
	}

	return nil
	}

	// setAnalysisErrorOnFoundFiles sets the AnalysisError field on all files with StatusFound.
	func (ctx *WorkspaceContext) setAnalysisErrorOnFoundFiles(format string, a ...interface{}) {
	errMsg := fmt.Sprintf(format, a...)
	for i := range ctx.Files {
	if ctx.Files[i].Status == StatusFound {
	ctx.Files[i].AnalysisError = errMsg
	}
	}
	}

	func (ctx *WorkspaceContext) runFx(dir string, args ...string) error {
	return runFx(ctx, dir, args...)
	}

	var runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
	fxPath := filepath.Join(ctx.FuchsiaDir, ".jiri_root", "bin", "fx")
	fullArgs := append([]string{"--dir", dir}, args...)
	cmd := exec.Command(fxPath, fullArgs...)
	cmd.Dir = ctx.FuchsiaDir
	if out, err := cmd.CombinedOutput(); err != nil {
	return fmt.Errorf("fx %v failed: %w\nOutput: %s", args, err, string(out))
	}
	return nil
	}

	func syncFile(src, dst string) (bool, error) {
	srcContent, err := os.ReadFile(src)
	if err != nil {
	return false, err
	}

	dstContent, err := os.ReadFile(dst)
	if err == nil && bytes.Equal(srcContent, dstContent) {
	return false, nil
	}

	if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
	return false, err
	}

	if err := os.WriteFile(dst, srcContent, 0644); err != nil {
	return false, err
	}

	return true, nil
	}

	// toRel normalizes a path to be relative to the Fuchsia root,
	// handling cases where absolute paths might use different Cog/CartFS mount points.
	func (ctx *WorkspaceContext) toRel(path string) string {
	// Try standard relative path first.
	rel, err := filepath.Rel(ctx.FuchsiaDir, path)
	if err == nil && !strings.HasPrefix(rel, "..") {
	return rel
	}

	// Heuristic: If we can't get a direct relative path (likely due to mount point mismatch),
	// find the part of the path that follows the fuchsia root basename.
	rootBase := filepath.Base(ctx.FuchsiaDir)
	search := "/" + rootBase + "/"
	if idx := strings.LastIndex(path, search); idx != -1 {
	return path[idx+len(search):]
	}

	return path
	}

	// resolveNinjaPath resolves a Ninja path to a GN label.
	// This is a variable so it can be overridden in tests.
	var resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
	clientPath := filepath.Join(ctx.FuchsiaDir, "build", "api", "client")
	// Use --allow-unknown so we get the path back instead of an error if it's not found.
	args := []string{"ninja_path_to_gn_label", "--allow-unknown", ninjaPath}

	cmd := exec.Command(clientPath, args...)
	cmd.Dir = ctx.FuchsiaDir
	out, err := cmd.Output()
	if err != nil {
	if exitErr, ok := err.(*exec.ExitError); ok {
	return "", fmt.Errorf("build/api/client failed with stderr: %s", string(exitErr.Stderr))
	}
	return "", err
	}

	label := strings.TrimSpace(string(out))
	if label == ninjaPath {
	return "", nil // Tool returned the input path, which means it's unknown.
	}
	return label, nil
	}