feat: compile-check answers a method-body edit in a large assembly in seconds instead of a full recompile

.github/workflows/unity-compile-check-and-test-runner.yml

@@ -62,7 +62,7 @@ jobs:
           echo "$CHANGED"
 
           # Plugin import settings decide which precompiled assemblies a script assembly references.
-          if echo "$CHANGED" | grep -qE '^(Packages/src/Editor/.*\.cs|Packages/src/Runtime/.*\.cs|Assets/.*\.cs|tests/.*\.cs|tests/.*\.csproj|Packages/.*\.asmdef|Assets/.*\.asmdef|Packages/src/.*\.dll\.meta|Packages/manifest\.json|Packages/packages-lock\.json|ci/unity-projects/.*|\.github/workflows/unity-compile-check-and-test-runner\.yml)$'; then
+          if echo "$CHANGED" | grep -qE '^(Packages/src/Editor/.*\.cs|cli/dispatcher/internal/compilecheck/fastcheck/worker/.*\.cs|Packages/src/Runtime/.*\.cs|Assets/.*\.cs|tests/.*\.cs|tests/.*\.csproj|Packages/.*\.asmdef|Assets/.*\.asmdef|Packages/src/.*\.dll\.meta|Packages/manifest\.json|Packages/packages-lock\.json|ci/unity-projects/.*|\.github/workflows/unity-compile-check-and-test-runner\.yml)$'; then
             echo "csharp=true" >> "$GITHUB_OUTPUT"
           else
             echo "csharp=false" >> "$GITHUB_OUTPUT"
@@ -85,6 +85,7 @@ jobs:
           dotnet test tests/SharedRoslynCompilerWorker.UnitTests/SharedRoslynCompilerWorker.UnitTests.csproj --configuration Release
           dotnet test tests/OutputFileRetention.UnitTests/OutputFileRetention.UnitTests.csproj --configuration Release
           dotnet test tests/RunTestsExecutionTimeout.UnitTests/RunTestsExecutionTimeout.UnitTests.csproj --configuration Release
+          dotnet test tests/CompileCheckWorker.UnitTests/CompileCheckWorker.UnitTests.csproj --configuration Release
 
       - name: Cache Library folder
         if: env.HAS_UNITY_LICENSE == 'true'

Packages/src/Editor/CliOnlyTools~/CompileCheck/Skill/SKILL.md

@@ -53,11 +53,23 @@ An assembly whose inputs are all exactly as the previous `compile-check` read th
 again: the run reports the diagnostics recorded then, errors included. `--all` compiles
 everything from scratch, which is the way out if a reused result ever looks wrong.
 
+In a large assembly whose last compile-check compile succeeded, an edit that keeps every
+declaration is checked on the changed files only, in a few seconds. Adding or removing a using
+directive counts as a declaration change. Such a check skips a few assembly-wide rules, so run once
+with `--full` before finishing. When the project treats warnings as errors, a rule listed in
+`UncheckedCodes`, such as CS0414, can fail that `--full` run only. The first body edit after a Unity
+build, after a full compile that had errors (a `--full` run or a run that fell back to one), after
+a run that picked it up only because an assembly it references changed, whether it compiled or
+skipped the assembly, or after `--all` in an assembly that references one whose rebuilt API
+differed from the last Unity build and that the next run no longer rebuilds is compiled in full and
+records what the next check compares against; `FastPathFallbacks` says why.
+
 ## Parameters
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
 | `--all` | flag | Compile every assembly instead of only the changed ones and their dependents |
+| `--full` | flag | Compile changed assemblies in full instead of checking only their changed files |
 | `--editor-version <version>` | string | Use this Unity Editor version's compiler instead of ProjectVersion.txt |
 | `--jobs <N>` | number | Compile up to N assemblies at once (default: half the CPUs, at least 1; `1` compiles sequentially) |
 | `--max-depth <N>` | number | Search depth when locating the project (default: 3, -1 for unlimited) |
@@ -73,12 +85,18 @@ A JSON payload:
 - `CompiledAssemblies`: the assemblies this run compiled, in dependency order
 - `ReusedAssemblies`: the assemblies reported from the previous run's recorded result, without compiling
 - `BlockedAssemblies`: the assemblies not compiled because an assembly they reference has errors, as Unity's own build would stop there; fix those errors and run again
-- `SkippedAssemblies`: how many assemblies were left out: nothing they compile from changed, or every assembly they reference kept the same public surface
+- `FastCheckedAssemblies`: the assemblies checked on their changed files only
+- `FastChecks`: per fast-checked assembly, `ChangedFiles`, `UncheckedCodes` (rules only `--full` runs), `GeneratorsNotRerun`, and `Reused` (the previous run's check of the same edit, reported again)
+- `FastPathFallbacks`: `Assembly` and `Reason` for each assembly that was compiled in full instead
+- `FastPathBaselineNotes`: `Assembly` and `Reason` for each successful full compile that left no baseline for the next changed-files check
+- `SkippedAssemblies`: how many assemblies were left out: nothing they compile from changed, or every assembly they reference kept the same public surface or changed only names they never write
 - `ResponseFileSet`: the Bee build the run replayed
 - `ProjectRoot`: resolved project root
 - `Message`: one-line summary
 
-The process exits 1 when `ErrorCount` is greater than zero.
+The process exits 1 when `ErrorCount` is greater than zero. A failure of the command itself, such
+as `COMPILE_CHECK_UNITY_BUILD_REQUIRED`, also exits 1 but prints no payload: the error, with its
+`ErrorCode`, goes to stderr.
 
 Only one compile-check runs per project at a time. A second one waits for the first, up to five
 minutes, then fails with `COMPILE_CHECK_PROJECT_BUSY`: wait for the other run to finish and run

cli/dispatcher/internal/compilecheck/asmdef_contract_test.go

@@ -47,7 +47,7 @@ func newContractProject(
 	if err != nil {
 		t.Fatalf("failed to load the assembly graph: %v", err)
 	}
-	assemblyDefinitions, err := IndexAssemblyDefinitions(projectRoot)
+	assemblyDefinitions, err := IndexAssemblyDefinitions(walkProjectTree(projectRoot))
 	if err != nil {
 		t.Fatalf("failed to index the assembly definitions: %v", err)
 	}

cli/dispatcher/internal/compilecheck/assembly_reference.go

@@ -2,7 +2,6 @@ package compilecheck
 
 import (
 	"fmt"
-	"io/fs"
 	"path/filepath"
 	"sort"
 )
@@ -18,17 +17,19 @@ type AssemblyReference struct {
 }
 
 // IndexAssemblyReferences lists every .asmref in the project, ordered by path.
-func IndexAssemblyReferences(projectRoot string) ([]AssemblyReference, error) {
+func IndexAssemblyReferences(tree projectTree) ([]AssemblyReference, error) {
 	references := []AssemblyReference{}
-	for _, root := range projectIndexRoots(projectRoot) {
-		if !directoryExists(root) {
-			continue
+	for _, root := range tree.roots {
+		for _, path := range root.referenceFiles {
+			reference, readErr := readAssemblyReference(path)
+			if readErr != nil {
+				return nil, fmt.Errorf(assemblyReferenceIndexError, root.path, readErr)
+			}
+			references = append(references, reference)
 		}
-		found, err := indexAssemblyReferencesUnder(root)
-		if err != nil {
-			return nil, fmt.Errorf(assemblyReferenceIndexError, root, err)
+		if root.walkErr != nil {
+			return nil, fmt.Errorf(assemblyReferenceIndexError, root.path, root.walkErr)
 		}
-		references = append(references, found...)
 	}
 	sort.Slice(references, func(first int, second int) bool {
 		return references[first].Path < references[second].Path
@@ -37,38 +38,6 @@ func IndexAssemblyReferences(projectRoot string) ([]AssemblyReference, error) {
 	return references, nil
 }
 
-// indexAssemblyReferencesUnder collects every .asmref found below one project root.
-func indexAssemblyReferencesUnder(root string) ([]AssemblyReference, error) {
-	references := []AssemblyReference{}
-	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if entry.IsDir() {
-			if path != root && isUnityIgnoredName(entry.Name()) {
-				return filepath.SkipDir
-			}
-
-			return nil
-		}
-		if isUnityIgnoredName(entry.Name()) || filepath.Ext(path) != assemblyReferenceExtension {
-			return nil
-		}
-		reference, readErr := readAssemblyReference(path)
-		if readErr != nil {
-			return readErr
-		}
-		references = append(references, reference)
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return references, nil
-}
-
 // readAssemblyReference reads the assembly one .asmref names.
 func readAssemblyReference(path string) (AssemblyReference, error) {
 	var content struct {

cli/dispatcher/internal/compilecheck/assembly_reference_test.go

@@ -51,15 +51,16 @@ func detectReferenceChange(
 	t *testing.T, projectRoot string, graph assemblyGraph, context AssemblyContext,
 ) error {
 	t.Helper()
-	references, err := IndexAssemblyReferences(projectRoot)
+	tree := walkProjectTree(projectRoot)
+	references, err := IndexAssemblyReferences(tree)
 	if err != nil {
 		t.Fatalf("failed to index the assembly references: %v", err)
 	}
-	definitions, definitionErr := IndexAssemblyDefinitions(projectRoot)
+	definitions, definitionErr := IndexAssemblyDefinitions(tree)
 	if definitionErr != nil {
 		t.Fatalf("failed to index the assembly definitions: %v", definitionErr)
 	}
-	owners := newAssemblyOwnerIndex(definitions, references, context)
+	owners := newAssemblyOwnerIndex(definitions, references, context, tree)
 
 	return DetectAssemblyReferenceChange(projectRoot, graph, context, references, owners)
 }

cli/dispatcher/internal/compilecheck/baseline_record.go

@@ -0,0 +1,87 @@
+package compilecheck
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/hatayama/unity-cli-loop/dispatcher/internal/compilecheck/fastcheck"
+	"github.com/hatayama/unity-cli-loop/dispatcher/internal/compilecheck/resultstore"
+)
+
+// RecordBaseline records what the next changed-files check of a unit compares against, after a
+// successful full compile. nonSourceKey is the unit's non-source key computed before the compile.
+// Why every content hash must match the one the input key read, and the non-source key the one
+// computed before the compile: the manifest describes the inputs csc compiled, and an input changed
+// during the compile would otherwise enter the baseline as if that compile had seen it, and its
+// effect would never be checked by the next run.
+func (runner *fastPathRunner) RecordBaseline(
+	ctx context.Context, c Compiler, plan BuildPlan, unit CompileUnit, keyResult inputKeyResult,
+	nonSourceKey nonSourceIdentity,
+) error {
+	if nonSourceKey.Key == "" {
+		return errors.New("inputs other than source contents could not be read before the compile")
+	}
+	currentNonSourceKey, err := computeNonSourceKey(c.ProjectRoot, c.Paths, plan, unit)
+	if err != nil {
+		return err
+	}
+	if currentNonSourceKey.Key != nonSourceKey.Key {
+		return errors.New("inputs other than source contents changed during the compile: " +
+			strings.Join(changedInputKinds(currentNonSourceKey, nonSourceKey), ", "))
+	}
+
+	worker, err := runner.Worker.Ensure(ctx)
+	if err != nil {
+		return err
+	}
+
+	request := fastcheck.FingerprintRequest{
+		ProjectRoot:      c.ProjectRoot,
+		ResponseFilePath: filepath.Join(c.ProjectRoot, plan.OutputDir, unit.Assembly.AssemblyName+responseFileExtension),
+		Sources:          make([]string, 0, len(unit.Sources)),
+	}
+	for _, source := range unit.Sources {
+		request.Sources = append(request.Sources, projectPath(c.ProjectRoot, source))
+	}
+
+	fingerprints, err := runner.Worker.Fingerprint(ctx, worker, request)
+	if err != nil {
+		return err
+	}
+
+	files, err := baselineFiles(c.ProjectRoot, unit, keyResult, fingerprints)
+	if err != nil {
+		return err
+	}
+
+	return c.records(plan).RecordBaseline(unit.Assembly.AssemblyName, resultstore.BaselineInputs{
+		InputKey:     keyResult.Key,
+		NonSourceKey: resultstore.KeyDigest(nonSourceKey),
+		WorkerKey:    worker.Key,
+		Files:        files,
+	})
+}
+
+// baselineFiles pairs each source's content hash, as the input key read it, with its fingerprint.
+func baselineFiles(
+	projectRoot string, unit CompileUnit, keyResult inputKeyResult, fingerprints fastcheck.FingerprintResponse,
+) (map[string]resultstore.BaselineFile, error) {
+	files := make(map[string]resultstore.BaselineFile, len(unit.Sources))
+	for _, source := range unit.Sources {
+		absolute := projectPath(projectRoot, source)
+		fingerprint, hasFingerprint := fingerprints.Fingerprints[absolute]
+		contentHash, hasHash := fingerprints.ContentHashes[absolute]
+		if !hasFingerprint || !hasHash {
+			return nil, fmt.Errorf("worker returned no fingerprint for %s", source)
+		}
+		if contentHash != keyResult.SourceHashes[source] {
+			return nil, fmt.Errorf("source changed during the compile: %s", source)
+		}
+		files[source] = resultstore.BaselineFile{ContentHash: contentHash, Fingerprint: fingerprint}
+	}
+
+	return files, nil
+}