use cquery for resolving files and dependencies

This takes antoher stub at #594 by introducing cquery back in. In
difference to the previous attempt this splits up the resolving of
buildfiles. CQuery does not support buildfiles but without cquery
bazel-watcher could watch files which are not reflected in the build
for e.g. dependencies behind a select statement. In order to avoid
depending on such cases first a cquery is issued which resolves
dependencies of selected targets. These dependencies are then injected
into the buildfiles query in order to get dependent build files.

Revival of #672.

Co-authored-by: Tobias Kohlbau <tobias@kohlbau.de>

Author: tobiaskohlbau

internal/bazel/testing/mock.go

@@ -16,7 +16,10 @@ package testing
 
 import (
 	"bytes"
+	"flag"
 	"fmt"
+	"io"
+	"os"
 	"os/exec"
 	"regexp"
 	"testing"
@@ -32,6 +35,7 @@ type MockBazel struct {
 	cqueryResponse map[string]*analysis.CqueryResult
 	args           []string
 	startupArgs    []string
+	info           map[string]string
 
 	buildError error
 	waitError  error
@@ -51,6 +55,9 @@ func (b *MockBazel) SetStartupArgs(args []string) {
 	b.startupArgs = args
 }
 
+func (b *MockBazel) SetInfo(info map[string]string) {
+	b.info = info
+}
 func (b *MockBazel) WriteToStderr(v bool) {
 	b.actions = append(b.actions, []string{"WriteToStderr", fmt.Sprint(v)})
 }
@@ -59,7 +66,7 @@ func (b *MockBazel) WriteToStdout(v bool) {
 }
 func (b *MockBazel) Info() (map[string]string, *bytes.Buffer, error) {
 	b.actions = append(b.actions, []string{"Info"})
-	return map[string]string{}, nil, nil
+	return b.info, nil, nil
 }
 func (b *MockBazel) DumpRepoMapping(canonicalRepoName string) (map[string]string, *bytes.Buffer, error) {
 	b.actions = append(b.actions, []string{"DumpRepoMapping", canonicalRepoName})
@@ -73,9 +80,12 @@ func (b *MockBazel) AddQueryResponse(query string, res *blaze_query.QueryResult)
 }
 func (b *MockBazel) Query(args ...string) (*blaze_query.QueryResult, error) {
 	b.actions = append(b.actions, append([]string{"Query"}, args...))
-	query := args[0]
+	queryArgs, err := parseQueryArgs(args)
+	if err != nil {
+		panic(fmt.Sprintf("failed to parse query args: %v", err))
+	}
+	query := queryArgs[0]
 	res, ok := b.queryResponse[query]
-
 	if !ok {
 		var candidates []string
 		for candidate := range b.queryResponse {
@@ -161,9 +171,19 @@ func (b *MockBazel) AssertActions(t *testing.T, expected [][]string) {
 	}
 }
 
-func max(a, b int) int {
-	if a > b {
-		return a
+func parseQueryArgs(args []string) ([]string, error) {
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.SetOutput(io.Discard)
+	queryFile := fs.String("query_file", "", "")
+	if err := fs.Parse(args); err != nil {
+		return args, nil
+	}
+	if *queryFile == "" {
+		return args, nil
+	}
+	contents, err := os.ReadFile(*queryFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read query file: %w", err)
 	}
-	return b
+	return []string{string(contents)}, nil
 }

internal/ibazel/ibazel.go

@@ -61,7 +61,8 @@ const (
 )
 
 const sourceQuery = "kind('source file', deps(set(%s)))"
-const buildQuery = "buildfiles(deps(set(%s)))"
+const targetQuery = "deps(set(%s))"
+const buildQuery = "buildfiles(set(%s))"
 
 type IBazel struct {
 	debounceDuration time.Duration
@@ -311,8 +312,21 @@ func (i *IBazel) iteration(command string, commandToRun runnableCommand, targets
 	case QUERY:
 		// Query for which files to watch.
 		log.Logf("Querying for files to watch...")
-		i.watchFiles(fmt.Sprintf(buildQuery, joinedTargets), i.buildFileWatcher)
-		i.watchFiles(fmt.Sprintf(sourceQuery, joinedTargets), i.sourceFileWatcher)
+
+		toWatchBuildFiles, err := i.queryForBuildFiles(joinedTargets)
+		if err != nil {
+			log.Errorf("Error querying for build files: %v", err)
+		} else {
+			i.watchFiles(toWatchBuildFiles, i.buildFileWatcher)
+		}
+
+		toWatchSourceFiles, err := i.queryForSourceFiles(joinedTargets)
+		if err != nil {
+			log.Errorf("Error querying for source files: %v", err)
+		} else {
+			i.watchFiles(toWatchSourceFiles, i.sourceFileWatcher)
+		}
+
 		i.state = RUN
 	case DEBOUNCE_RUN:
 		select {
@@ -492,63 +506,96 @@ func (i *IBazel) dumpRootRepoMapping() (map[string]string, *bytes.Buffer, error)
 	return res, stderr, nil
 }
 
-func (i *IBazel) queryForSourceFiles(query string) ([]string, error) {
+func (i *IBazel) queryForSourceFiles(targets string) ([]string, error) {
 	b := i.newBazel()
 
-	localRepositories, err := i.realLocalRepositoryPaths()
+	res, err := b.CQuery(i.cQueryArgs(fmt.Sprintf(sourceQuery, targets))...)
 	if err != nil {
+		log.Errorf("Bazel cquery failed: %v", err)
 		return nil, err
 	}
 
-	res, err := b.Query(i.queryArgs(query)...)
+	labels := make([]string, 0, len(res.Results))
+	for _, target := range res.Results {
+		switch *target.Target.Type {
+		case blaze_query.Target_SOURCE_FILE:
+			label := target.Target.SourceFile.GetName()
+			labels = append(labels, label)
+		default:
+			log.Errorf("%v\n", target)
+		}
+	}
+
+	return i.labelsToWatch(labels)
+}
+
+func (i *IBazel) queryForBuildFiles(targets string) ([]string, error) {
+	b := i.newBazel()
+
+	targetRes, err := b.CQuery(i.cQueryArgs(fmt.Sprintf(targetQuery, targets))...)
 	if err != nil {
-		log.Errorf("Bazel query failed: %v", err)
+		log.Errorf("Bazel target query failed: %v", err)
 		return nil, err
 	}
 
-	workspacePath, err := i.workspaceFinder.FindWorkspace()
+	localRepositories, err := i.realLocalRepositoryPaths()
 	if err != nil {
-		log.Errorf("Error finding workspace: %v", err)
 		return nil, err
 	}
-
-	toWatch := make([]string, 0, len(res.GetTarget()))
-	for _, target := range res.GetTarget() {
-		switch *target.Type {
-		case blaze_query.Target_SOURCE_FILE:
-			label := target.GetSourceFile().GetName()
+	quotedBuildTargets := make([]string, 0, len(targetRes.Results))
+	for _, configuredTarget := range targetRes.Results {
+		target := configuredTarget.GetTarget()
+		if *target.Type == blaze_query.Target_RULE {
+			label := target.GetRule().GetName()
 			if strings.HasPrefix(label, "@") {
-				repo, target := parseTarget(label)
-				if realPath, ok := localRepositories[repo]; ok {
-					label = strings.Replace(target, ":", string(filepath.Separator), 1)
-					toWatch = append(toWatch, filepath.Join(realPath, label))
-					break
+				repo, _ := parseTarget(label)
+				if _, ok := localRepositories[repo]; !ok {
+					continue
 				}
-				continue
 			}
 			if strings.HasPrefix(label, "//external") {
 				continue
 			}
+			// Build targets may contain characters that shells don't like.
+			// Quote them to guarantee the correct behavior.
+			quotedBuildTargets = append(quotedBuildTargets, fmt.Sprintf("%q", label))
+		}
+	}
+
+	f, err := os.CreateTemp("", "query")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create query file: %w", err)
+	}
+	defer func() {
+		f.Close()
+		os.Remove(f.Name())
+	}()
+	_, err = f.WriteString(fmt.Sprintf(buildQuery, strings.Join(quotedBuildTargets, " ")))
+	if err != nil {
+		return nil, fmt.Errorf("failed to write query file: %w", err)
+	}
+
+	res, err := b.Query(i.queryArgs(fmt.Sprintf("--query_file=%s", f.Name()))...)
+	if err != nil {
+		log.Errorf("Bazel query failed: %v", err)
+		return nil, err
+	}
 
-			label = strings.Replace(strings.TrimPrefix(label, "//"), ":", string(filepath.Separator), 1)
-			toWatch = append(toWatch, filepath.Join(workspacePath, label))
-			break
+	labels := make([]string, 0, len(res.GetTarget()))
+	for _, target := range res.GetTarget() {
+		switch *target.Type {
+		case blaze_query.Target_SOURCE_FILE:
+			label := target.GetSourceFile().GetName()
+			labels = append(labels, label)
 		default:
 			log.Errorf("%v\n", target)
 		}
 	}
 
-	return toWatch, nil
+	return i.labelsToWatch(labels)
 }
 
-func (i *IBazel) watchFiles(query string, watcher common.Watcher) {
-	toWatch, err := i.queryForSourceFiles(query)
-	if err != nil {
-		// If the query fails, just keep watching the same files as before
-		log.Errorf("Error querying for source files: %v", err)
-		return
-	}
-
+func (i *IBazel) watchFiles(toWatch []string, watcher common.Watcher) {
 	filesWatched := map[string]struct{}{}
 	uniqueDirectories := map[string]struct{}{}
 
@@ -569,18 +616,52 @@ func (i *IBazel) watchFiles(query string, watcher common.Watcher) {
 	}
 
 	watchList := keys(uniqueDirectories)
-	err = watcher.UpdateAll(watchList)
+	err := watcher.UpdateAll(watchList)
 	if err != nil {
 		log.Errorf("Error(s) updating watch list:\n %v", err)
 	}
 
 	if len(filesWatched) == 0 {
-		log.Errorf("Didn't find any files to watch from query %s", query)
+		log.Errorf("Didn't find any files to watch for")
 	}
 
 	i.filesWatched[watcher] = filesWatched
 }
 
+func (i *IBazel) labelsToWatch(labels []string) ([]string, error) {
+	localRepositories, err := i.realLocalRepositoryPaths()
+	if err != nil {
+		return nil, err
+	}
+
+	workspacePath, err := i.workspaceFinder.FindWorkspace()
+	if err != nil {
+		log.Errorf("Error finding workspace: %v", err)
+		return nil, err
+	}
+
+	toWatch := make([]string, 0, len(labels))
+	for _, label := range labels {
+		if strings.HasPrefix(label, "@") {
+			repo, target := parseTarget(label)
+			if realPath, ok := localRepositories[repo]; ok {
+				label = strings.Replace(target, ":", string(filepath.Separator), 1)
+				toWatch = append(toWatch, filepath.Join(realPath, label))
+				break
+			}
+			continue
+		}
+		if strings.HasPrefix(label, "//external") {
+			continue
+		}
+
+		label = strings.Replace(strings.TrimPrefix(label, "//"), ":", string(filepath.Separator), 1)
+		toWatch = append(toWatch, filepath.Join(workspacePath, label))
+	}
+
+	return toWatch, nil
+}
+
 func (i *IBazel) queryArgs(args ...string) []string {
 	queryArgs := append([]string(nil), args...)