Disentangling the elaboration rules from llbuild2fx

Sources/PterodactylBuild/Elaborator/ElabEnv.swift

···
 
 	func lookupDef(name: QName) async -> GlobalDef? {
 		if let def = await sink.lookupEmitted(name) { return def }
-		if let defId = signature.toplevelEnv.decls[name] {
-			return try? await defId.read(signature.buildContext)
-		}
-
-		return nil
+		return await signature.lookup(name)
 	}
 
 	func resolveLocal(name: String) async -> (Value.Type_, Term)? {
···
 
 		let resolver = NameResolver(namespace: self.namespace)
 		guard
-			let (resolvedName, defId) = resolver.resolve(name: .user(name), in: signature.toplevelEnv.decls),
-			let def = try? await defId.read(signature.buildContext)
+			let resolvedName = resolver.resolve(name: .user(name), in: signature.knownDecls),
+			let def = await signature.lookup(resolvedName)
 		else { return nil }
 
 		let type = await evaluator().evaluate(type: def.type)

Sources/PterodactylBuild/Elaborator/ElabSignature.swift

···
 //
 // SPDX-License-Identifier: MPL-2.0
 
+import OrderedCollections
 import PterodactylCore
-import TSCUtility
 
 struct ElabSignature: Sendable {
-	let buildContext: TSCUtility.Context
-	let toplevelEnv: ToplevelEnv
-
-	func lookup(_ name: QName) async -> GlobalDef? {
-		guard let defID = toplevelEnv.decls[name] else { return nil }
-		return try? await defID.read(buildContext)
-	}
+	let lookup: @Sendable (QName) async -> GlobalDef?
+	let knownDecls: OrderedSet<QName>
 }

Sources/PterodactylBuild/Elaborator/ElabSink.swift

···
 import OrderedCollections
 import PterodactylFeedback
 import PterodactylCore
-import TSCUtility
 
 struct Emission: Sendable {
 	var provenance: Range<Int>?

Sources/PterodactylBuild/Elaborator/NameResolver.swift

···
 struct NameResolver {
 	let namespace: [Name]
 
-	/// Resolve an unqualified name against a dictionary of known declarations.
+	/// Resolve an unqualified name against a set of known declarations.
 	/// Tries the current namespace first, then each enclosing namespace, and finally the top level.
-	func resolve<V>(name: Name, in decls: OrderedDictionary<QName, V>) -> (QName, V)? {
+	func resolve(name: Name, in decls: OrderedSet<QName>) -> QName? {
 		for i in stride(from: namespace.count, through: 0, by: -1) {
 			let candidate = QName(names: Array(namespace.prefix(i)) + [name])
-			if let value = decls[candidate] {
-				return (candidate, value)
+			if decls.contains(candidate) {
+				return candidate
 			}
 		}
 		return nil

Sources/PterodactylBuild/Keys/DriverKeys.swift

···
 	public static let versionDependencies: [any FXVersioning.Type] = [ElaborateDecl.self]
 
 	func elabEnv(_ context: Context) -> ElabEnv {
-		ElabEnv(
-			signature: ElabSignature(buildContext: context, toplevelEnv: toplevelEnv),
+		let toplevelEnv = toplevelEnv
+		return ElabEnv(
+			signature: ElabSignature(
+				lookup: { name in
+					guard let defID = toplevelEnv.decls[name] else { return nil }
+					return try? await defID.read(context)
+				},
+				knownDecls: OrderedSet(toplevelEnv.decls.keys)
+			),
 			sink: ElabSink(),
 			namespace: namespace.names
 		)