Wire final import declarations through loading

internal/engine/imports.go

@@ -51,6 +51,7 @@ type importTraversal struct {
 	limits       importLimits
 	rule         *VersionRule
 	versionState *sourceVersionState
+	defaults     importDefaults
 
 	scope        acquisitionScope
 	itemScope    bool
@@ -161,11 +162,16 @@ func loadImportedWithAccessTrackedAndProcessingPolicyDeferred(access *filesystem
 	accounting.sources++
 	accounting.bytes += main.bytes
 	accounting.nodes += countInputNodes(main.document)
+	defaults := importDefaults{}
+	if versionState != nil {
+		defaults = snapshotImportDefaults(versionState.importDefaults)
+	}
 	state := importTraversal{
 		access: access, accounting: accounting, limits: limits, rule: rule, versionState: versionState,
-		scope:   acquisitionScope{owner: mainNodeKey, destination: destination.clone()},
-		sources: []SourceInfo{mainInfo},
-		active:  make(map[resourceIdentity]int), visited: visited,
+		defaults: defaults,
+		scope:    acquisitionScope{owner: mainNodeKey, destination: destination.clone()},
+		sources:  []SourceInfo{mainInfo},
+		active:   make(map[resourceIdentity]int), visited: visited,
 		importGraph: newImportInclusionGraph(),
 	}
 	if mainIsItem {
@@ -194,7 +200,7 @@ func loadImportedWithAccessTrackedAndProcessingPolicyDeferred(access *filesystem
 	state.visited[mainResource] = mainRoute
 	state.stack = append(state.stack, mainRoute)
 	var body *document.Node
-	var declarations []importDeclaration
+	var declarations []importDeclarationSpec
 	var diagnostics []Diagnostic
 	if processing != nil {
 		body = processing.payload
@@ -383,62 +389,62 @@ func (s *importTraversal) checkInitialLimits() *Diagnostic {
 	return nil
 }
 
-func (s *importTraversal) walkDeclarations(basePath string, declarations []importDeclaration, depth int, parentDestination Path) []Diagnostic {
-	for _, declaration := range declarations {
-		childDestination := appendDestination(parentDestination, declaration.destination)
-		if declaration.glob != "" {
-			matches, diagnostics := s.expandImportGlob(basePath, declaration)
-			if len(diagnostics) != 0 {
+func (s *importTraversal) walkDeclarations(basePath string, declarations []importDeclarationSpec, depth int, parentDestination Path) []Diagnostic {
+	policies := make([]resolvedImportPolicy, len(declarations))
+	for index, spec := range declarations {
+		policy, diagnostics := resolveImportPolicy(spec, s.defaults)
+		if len(diagnostics) != 0 {
+			return diagnostics
+		}
+		if policy.placement == placementModeSequenceItem && len(appendDestination(parentDestination, policy.destination).segments) == 0 {
+			site := spec.fieldSites["placement"]
+			return []Diagnostic{{Code: CodeImportInvalid, Severity: SeverityError, Path: site.path.clone(), Message: "sequence-item placement requires a nonempty destination", Primary: cloneLocation(&site.location)}}
+		}
+		if depth+1 > s.limits.depth {
+			location := spec.location
+			return []Diagnostic{importDiagnostic(CodeImportLimitExceeded, "configuration exceeds the active import-depth limit", &location)}
+		}
+		policies[index] = policy
+	}
+	for index, spec := range declarations {
+		policy := policies[index]
+		var selection importSelection
+		var diagnostics []Diagnostic
+		switch spec.selector {
+		case importSelectorPath:
+			selection, diagnostics = selectNamedImportCandidates(s.access, basePath, spec, policy)
+		case importSelectorDirectory:
+			selection, diagnostics = selectDirectoryImportCandidates(s.access, basePath, spec, policy, s.limits, s.accounting)
+		case importSelectorGlob:
+			selection, diagnostics = selectGlobImportCandidates(s.access, basePath, spec, policy, s.limits, s.accounting)
+		default:
+			location := spec.location
+			return []Diagnostic{importDiagnostic(CodeImportInvalid, "import selector is invalid", &location)}
+		}
+		if len(diagnostics) != 0 {
+			return diagnostics
+		}
+		childDestination := appendDestination(parentDestination, policy.destination)
+		for _, candidate := range selection.candidates {
+			if diagnostics := s.visitPath(candidate, spec, policy, childDestination, policy.destination, depth+1); len(diagnostics) != 0 {
 				return diagnostics
 			}
-			if len(matches) == 0 {
-				if declaration.optional {
-					continue
-				}
-				location := declaration.location
-				return []Diagnostic{importDiagnostic(CodeImportMissing, "required import glob matched no files", &location)}
-			}
-			for _, match := range matches {
-				matched := declaration
-				matched.path = match
-				matched.glob = ""
-				if diagnostics := s.visitPath(basePath, matched, childDestination, declaration.destination, depth+1); len(diagnostics) != 0 {
-					return diagnostics
-				}
-			}
-			continue
-		}
-		if diagnostics := s.visitPath(basePath, declaration, childDestination, declaration.destination, depth+1); len(diagnostics) != 0 {
-			return diagnostics
 		}
 	}
 	return nil
 }
 
-func (s *importTraversal) visitPath(basePath string, declaration importDeclaration, destination, relativeDestination Path, depth int) []Diagnostic {
-	location := declaration.location
-	if declaration.placement == placementModeSequenceItem && len(destination.segments) == 0 {
-		return []Diagnostic{{
-			Code: CodeImportInvalid, Severity: SeverityError,
-			Path:    declaration.placementPath.clone(),
-			Message: "sequence-item placement requires a nonempty destination",
-			Primary: cloneLocation(declaration.placementLocation),
-		}}
+func (s *importTraversal) visitPath(candidate selectedImportCandidate, spec importDeclarationSpec, policy resolvedImportPolicy, destination, relativeDestination Path, depth int) []Diagnostic {
+	location := candidate.site.location
+	if location.SourceID == "" && location.Line == 0 && location.Column == 0 {
+		location = spec.location
 	}
-	if depth > s.limits.depth {
-		return []Diagnostic{importDiagnostic(CodeImportLimitExceeded, "configuration exceeds the active import-depth limit", &location)}
-	}
-	if !validImportPath(declaration.path) {
-		return []Diagnostic{importDiagnostic(CodeImportInvalid, "import path must be a nonempty slash-relative path without a network scheme", &location)}
-	}
-
-	candidate := s.access.join(basePath, declaration.path)
-	if !s.access.contains(candidate) {
+	if !s.access.contains(candidate.accessPath) {
 		return []Diagnostic{importDiagnostic(CodeImportOutsideRoot, "import target is outside the configuration root", &location)}
 	}
-	canonical, err := s.access.canonical(candidate)
+	canonical, err := s.access.canonical(candidate.accessPath)
 	if err != nil {
-		if declaration.optional && errors.Is(err, fs.ErrNotExist) {
+		if !policy.required && errors.Is(err, fs.ErrNotExist) {
 			return nil
 		}
 		code := CodeImportInvalid
@@ -479,13 +485,16 @@ func (s *importTraversal) visitPath(basePath string, declaration importDeclarati
 	}
 	sourceID := "source-" + strconv.Itoa(s.accounting.sources+1)
 	kind := SourceKindFile
-	label := declaration.path
+	label := candidate.label
+	if label == "" {
+		label = candidate.path
+	}
 	if s.access.native != nil {
 		kind = SourceKindFilesystem
 		label = s.access.label + "/" + canonical
 	}
 	info := SourceInfo{ID: sourceID, Label: label, Path: canonical, Destination: s.sourceDestination(destination), Layer: LayerBase, Kind: kind, ImportedFrom: &location}
-	if declaration.placement == placementModeSequenceItem {
+	if policy.placement == placementModeSequenceItem {
 		info.placementMode = placementModeSequenceItem
 	}
 	// A source's own item placement still has an exact sequence-container
@@ -496,7 +505,7 @@ func (s *importTraversal) visitPath(basePath string, declaration importDeclarati
 		info.namespace = s.access.token
 	}
 	s.sources = append(s.sources, info)
-	data, skipped, diagnostic := s.readImport(canonical, sourceID, declaration.optional)
+	data, skipped, diagnostic := s.readImport(canonical, sourceID, policy.required)
 	if diagnostic != nil {
 		return []Diagnostic{*diagnostic}
 	}
@@ -519,7 +528,7 @@ func (s *importTraversal) visitPath(basePath string, declaration importDeclarati
 	s.accounting.nodes += nodeCount
 
 	var body *document.Node
-	var declarations []importDeclaration
+	var declarations []importDeclarationSpec
 	var diagnostics []Diagnostic
 	var processing *sourceVersionProcessingResult
 	if s.versionState != nil && s.versionState.mode != sourceVersionModeDefault {
@@ -527,7 +536,7 @@ func (s *importTraversal) visitPath(basePath string, declaration importDeclarati
 		if s.itemScope {
 			versionDestination = appendDestination(s.itemPrefix.Index(0), destination)
 		}
-		processed, failures := s.versionState.process(root, sourceVersionContribution, versionDestination, sourceID, declaration.placement)
+		processed, failures := s.versionState.process(root, sourceVersionContribution, versionDestination, sourceID, policy.placement)
 		if len(failures) != 0 {
 			return failures
 		}
@@ -541,7 +550,7 @@ func (s *importTraversal) visitPath(basePath string, declaration importDeclarati
 	}
 	placementDestination := destination
 	mode := placementModeMapping
-	if declaration.placement == placementModeSequenceItem {
+	if policy.placement == placementModeSequenceItem {
 		mode = placementModeSequenceItem
 	}
 	role := importRoleMapping
@@ -555,7 +564,7 @@ func (s *importTraversal) visitPath(basePath string, declaration importDeclarati
 		s.active[identity] = len(s.stack)
 		s.visited[identity] = route
 		s.stack = append(s.stack, route)
-		diagnostics := s.visitItemSource(canonical, nodeKey, declaration, destination, relativeDestination, depth, info, body, declarations, processing)
+		diagnostics := s.visitItemSource(canonical, nodeKey, destination, relativeDestination, depth, info, body, declarations, processing)
 		delete(s.active, identity)
 		s.stack = s.stack[:len(s.stack)-1]
 		return diagnostics
@@ -604,7 +613,7 @@ func (s *importTraversal) sourceDestination(destination Path) Path {
 	return s.itemFallback.clone()
 }
 
-func (s *importTraversal) visitItemSource(canonical string, identity importNodeKey, declaration importDeclaration, destination, relativeDestination Path, depth int, info SourceInfo, body *document.Node, declarations []importDeclaration, processing *sourceVersionProcessingResult) []Diagnostic {
+func (s *importTraversal) visitItemSource(canonical string, identity importNodeKey, destination, relativeDestination Path, depth int, info SourceInfo, body *document.Node, declarations []importDeclarationSpec, processing *sourceVersionProcessingResult) []Diagnostic {
 	parentScope := s.scope
 	parentItemScope, parentPrefix, parentFallback := s.itemScope, s.itemPrefix, s.itemFallback
 	s.scope = acquisitionScope{owner: identity}
@@ -911,7 +920,7 @@ func projectSourceVersionEvidence(processing *sourceVersionProcessingResult, des
 	}
 }
 
-func (s *importTraversal) readImport(name, sourceID string, optional bool) ([]byte, bool, *Diagnostic) {
+func (s *importTraversal) readImport(name, sourceID string, required bool) ([]byte, bool, *Diagnostic) {
 	remaining := s.limits.bytes - s.accounting.bytes
 	limit := min(int64(maxSourceBytes), remaining)
 	if limit < 0 {
@@ -919,7 +928,7 @@ func (s *importTraversal) readImport(name, sourceID string, optional bool) ([]by
 	}
 	data, failure := readRegularFile(name, s.access.stat, s.access.open, limit)
 	if failure != nil {
-		if optional && failure.missingTarget {
+		if !required && failure.missingTarget {
 			return nil, true, nil
 		}
 		value := sourceReadDiagnostic(failure, sourceID, CodeImportLimitExceeded, "configuration exceeds a source or aggregate byte limit")