lsp/cache: notice on-disk creation of files satisfying failed imports

When deciding whether a changed file that is not open in the editor
can influence any loaded package, DidModifyFiles considers the
workspace's active files and directories, and embed attributes which
match the file. But like embed attributes, import specs declare an
interest in paths which may not exist yet: a loaded package can hold
an import of a package which is yet to be created.

Consequently, when the files of such an imported package were
created on disk (not in the editor) in a directory containing no
other active files, the creation was ignored entirely, and the
import stayed unresolved until the importing package happened to be
reloaded for some other reason.

Also inspect a changed file when its directory is where the package
of some loaded package's unresolved import would live, within the
enclosing module or under the old module system's
cue.mod/{gen|pkg|usr} hierarchies. The existing machinery then does
the rest: the new file's package is loaded, and reloadPackages
notices that the failed importers must be reloaded.

Change-Id: I8f36fb8f0d725945dff78a6d85596a91539bc608
Signed-off-by: Matthew Sackman <matthew@cue.works>
Reviewed-on: https://cue.gerrithub.io/c/cue-lang/cue/+/1242883
TryBot-Result: CUEcueckoo <cueckoo@cuelang.org>
Reviewed-by: Roger Peppe <rogpeppe@gmail.com>
Unity-Result: CUE porcuepine <cue.porcuepine@gmail.com>

Author: cuematthew

cmd/cue/cmd/integration/workspace/imports_late_test.go

@@ -64,9 +64,9 @@ ax: sub.y
 
 // TestImportCreatedLaterOnDisk is like TestImportCreatedLater,
 // except the imported package is created on disk (not in the
-// editor), in a directory which contains no other active files. This
-// shows bad behaviour: the file's creation is ignored entirely, so
-// the new package is never loaded and the import stays unresolved.
+// editor), in a directory which contains no other active files. The
+// file's creation must still be noticed, because a loaded package
+// has an unresolved import which it helps satisfy.
 func TestImportCreatedLaterOnDisk(t *testing.T) {
 	const files = `
 -- cue.mod/module.cue --
@@ -90,21 +90,27 @@ ax: sub.y
 		)
 
 		// Now create the imported package on disk, without opening
-		// any of its files in the editor. The creation is ignored:
-		// the new package is never loaded, and the importing package
-		// is not reloaded.
+		// any of its files in the editor.
 		env.WriteWorkspaceFile("sub/sub.cue", "package sub\n\ny: 4\n")
 		env.Await(
 			env.DoneWithChangeWatchedFiles(),
-			NoLogMatching(protocol.Debug, `Package dirs=\[%v/sub\]`, rootURI),
-			LogExactf(protocol.Debug, 1, false, "Package dirs=[%v] importPath=mod.example/x@v0:a Reloaded", rootURI),
+			LogExactf(protocol.Debug, 1, false, "Package dirs=[%v/sub] importPath=mod.example/x/sub@v0 Reloaded", rootURI),
+			// The importing package must be reloaded so that its
+			// import now resolves.
+			LogExactf(protocol.Debug, 2, false, "Package dirs=[%v] importPath=mod.example/x@v0:a Reloaded", rootURI),
 		)
 
-		// Definitions on "y" within "ax: sub.y" find nothing.
 		gotDefs := env.Definition(protocol.Location{
 			URI:   rootURI + "/a.cue",
 			Range: protocol.Range{Start: protocol.Position{Line: 4, Character: 8}},
 		})
-		qt.Assert(t, qt.HasLen(gotDefs, 0))
+		wantDefs := []protocol.Location{{
+			URI: rootURI + "/sub/sub.cue",
+			Range: protocol.Range{
+				Start: protocol.Position{Line: 2, Character: 0},
+				End:   protocol.Position{Line: 2, Character: 1},
+			},
+		}}
+		qt.Assert(t, qt.DeepEquals(gotDefs, wantDefs))
 	})
 }

internal/lsp/cache/workspace.go

@@ -366,6 +366,13 @@ func (w *Workspace) DidModifyFiles(ctx context.Context, modifications []file.Mod
 				// matches this file, but does not currently embed it -
 				// this file must be new in some way.
 				needsInspecting = true
+			} else if w.matchesUnresolvedImport(uri) {
+				// A loaded cue package has an import which does not
+				// currently resolve, and this file's directory is
+				// where that import's package would live. Inspecting
+				// this file will load its package, and reloadPackages
+				// will then reload the failed importers.
+				needsInspecting = true
 			}
 
 			if !needsInspecting {
@@ -1118,6 +1125,54 @@ func (w *Workspace) matchesUnknownEmbedding(file protocol.DocumentURI) bool {
 	return false
 }
 
+// matchesUnresolvedImport reports whether any loaded cue package has
+// an unresolved import which the given file could help satisfy: that
+// is, whether the file's directory is a package directory implied by
+// some unresolved import path.
+func (w *Workspace) matchesUnresolvedImport(file protocol.DocumentURI) bool {
+	dir := file.Dir()
+
+	// Gather the unresolved import paths of all loaded packages: any
+	// loaded package, in any module, could hold an import which this
+	// file helps satisfy.
+	unresolved := make(map[ast.ImportPath]struct{})
+	for _, m := range w.modules {
+		for _, pkg := range m.packages {
+			maps.Copy(unresolved, pkg.unresolvedImports)
+		}
+	}
+	if len(unresolved) == 0 {
+		return false
+	}
+
+	// For each module enclosing the file, test whether the file's
+	// directory is where some unresolved import's package would
+	// live, either within the module itself, or under the old module
+	// system's cue.mod/{gen|pkg|usr} hierarchies.
+	for _, m := range w.modules {
+		if m.modFile == nil || !m.rootURI.Encloses(file) {
+			continue
+		}
+		modPath, _, _ := ast.SplitPackageVersion(m.modFile.QualifiedModule())
+		for ip := range unresolved {
+			if ip.Path == modPath && m.rootURI == dir {
+				return true
+			}
+			if relPath, ok := strings.CutPrefix(ip.Path, modPath+"/"); ok {
+				if joinURI(m.rootURI, relPath) == dir {
+					return true
+				}
+			}
+			for _, prefix := range []string{"cue.mod/gen/", "cue.mod/pkg/", "cue.mod/usr/"} {
+				if joinURI(m.rootURI, prefix+ip.Path) == dir {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
 // markUnresolvedImportersDirty marks as dirty every loaded package
 // which has an unresolved import that a package with the given
 // import path would satisfy. It reports whether any package was