Wire final import declarations through loading

internal/engine/import_selection.go

@@ -19,6 +19,7 @@ const (
 type selectedImportCandidate struct {
 	path       string
 	accessPath string
+	label      string
 	site       importFieldSite
 }
 
@@ -47,7 +48,7 @@ func selectNamedImportCandidates(access *filesystemAccess, basePath string, spec
 		} else {
 			site = spec.fieldSites["path"]
 		}
-		normalized = append(normalized, selectedImportCandidate{path: candidatePath, accessPath: accessPath, site: site})
+		normalized = append(normalized, selectedImportCandidate{path: candidatePath, accessPath: accessPath, label: relativeImportLabel(access, basePath, accessPath), site: site})
 	}
 	sort.Slice(normalized, func(left, right int) bool {
 		return normalized[left].path < normalized[right].path
@@ -111,6 +112,7 @@ func selectDirectoryImportCandidates(access *filesystemAccess, basePath string,
 		if targetErr != nil {
 			return importSelection{}, []Diagnostic{*importDirectoryTargetDiagnostic(root.site, targetErr)}
 		}
+		root.accessPath = rootTarget.identity
 		entries, missing, diagnostic := importDirectoryEntries(access, root.accessPath, root.site, limits, accounting)
 		if diagnostic != nil {
 			return importSelection{}, []Diagnostic{*diagnostic}
@@ -131,8 +133,10 @@ func selectDirectoryImportCandidates(access *filesystemAccess, basePath string,
 			entry := frame.entries[frame.next]
 			frame.next++
 			accessPath := access.join(frame.directory.accessPath, entry.Name())
+			lexicalPath := access.join(frame.directory.path, entry.Name())
 			candidate := selectedImportCandidate{
-				path: normalizedImportCandidatePath(access, accessPath), accessPath: accessPath, site: frame.directory.site,
+				path: normalizedImportCandidatePath(access, lexicalPath), accessPath: accessPath,
+				label: relativeImportLabel(access, basePath, lexicalPath), site: frame.directory.site,
 			}
 			if !policy.hidden && strings.HasPrefix(entry.Name(), ".") {
 				continue
@@ -166,11 +170,24 @@ func selectDirectoryImportCandidates(access *filesystemAccess, basePath string,
 					return importSelection{}, []Diagnostic{*childDiagnostic}
 				}
 				if !vanished {
+					candidate.accessPath = target.identity
 					activeDirectories[target.identity] = struct{}{}
 					stack = append(stack, importDirectoryFrame{directory: candidate, depth: frame.depth + 1, entries: childEntries, identity: target.identity})
 				}
 				continue
 			}
+			if target.identity != "" {
+				candidate.accessPath = target.identity
+			} else {
+				canonical, canonicalErr := access.canonical(accessPath)
+				if canonicalErr != nil {
+					if errors.Is(canonicalErr, fs.ErrNotExist) {
+						continue
+					}
+					return importSelection{}, []Diagnostic{globFilesystemDiagnostic(canonicalErr, "directory search file could not be canonicalized", frame.directory.site.location)}
+				}
+				candidate.accessPath = canonical
+			}
 			if !matchesImportFilename(entry.Name(), policy.pattern) {
 				continue
 			}
@@ -222,8 +239,19 @@ func importDirectoryTargetDiagnostic(site importFieldSite, err error) *Diagnosti
 }
 
 func importDirectoryEntries(access *filesystemAccess, directory string, site importFieldSite, limits importLimits, accounting *importAccounting) ([]fs.DirEntry, bool, *Diagnostic) {
+	target, targetErr := access.importEntryTarget(directory, nil, true)
+	if targetErr != nil {
+		if errors.Is(targetErr, fs.ErrNotExist) {
+			return nil, true, nil
+		}
+		return nil, false, importDirectoryTargetDiagnostic(site, targetErr)
+	}
+	readPath := target.identity
+	if readPath == "" {
+		readPath = directory
+	}
 	entries := make([]fs.DirEntry, 0)
-	err := visitBoundedImportDirectory(access, directory, limits.entries, accounting, func(entry fs.DirEntry) error {
+	err := visitBoundedImportDirectory(access, readPath, limits.entries, accounting, func(entry fs.DirEntry) error {
 		entries = append(entries, entry)
 		return nil
 	})
@@ -255,6 +283,27 @@ func normalizedImportCandidatePath(access *filesystemAccess, accessPath string)
 	return filepath.ToSlash(filepath.Clean(accessPath))
 }
 
+func relativeImportLabel(access *filesystemAccess, basePath, candidatePath string) string {
+	if access.native != nil {
+		if candidatePath == basePath {
+			return "."
+		}
+		prefix := strings.TrimSuffix(basePath, "/") + "/"
+		if basePath == "." {
+			return candidatePath
+		}
+		if strings.HasPrefix(candidatePath, prefix) {
+			return strings.TrimPrefix(candidatePath, prefix)
+		}
+		return candidatePath
+	}
+	label, err := filepath.Rel(basePath, candidatePath)
+	if err == nil {
+		return filepath.ToSlash(label)
+	}
+	return filepath.ToSlash(candidatePath)
+}
+
 func matchesImportFilename(name string, patterns []string) bool {
 	if patterns == nil {
 		return true