Refactoring elaboration queries to return a delta

Sources/PterodactylBuild/Elaborator/ElabEnv.swift

···
 import PterodactylSyntax
 
 struct ElabEnv: Sendable {
-	let state: ElabState
+	let signature: Signature
+	let sink: EmissionSink
 	var namespace: [Name]
 	private var localNames: [Name?]
 	private var localValueTypes: [Value.Type_.Thunk]
 	var localValues: [Value]
 
-	public init(state: ElabState, namespace: [Name] = []) {
-		self.state = state
+	init(signature: Signature, sink: EmissionSink, namespace: [Name] = []) {
+		self.signature = signature
+		self.sink = sink
 		self.namespace = namespace
 		self.localNames = []
 		self.localValueTypes = []
···
 
 	func evaluator() async -> Evaluator {
 		return Evaluator(
-			globals: state.lookup(_:),
+			globals: { [sink, signature] name in
+				if let def = await sink.lookupEmitted(name) {
+					return def
+				}
+				return await signature.lookup(name)
+			},
 			locals: localValues
 		)
 	}
···
 		}
 
 		let resolver = NameResolver(namespace: namespace)
-		if let (resolvedName, defId) = resolver.resolve(name: name, in: state.toplevelEnv.decls),
-			let def = try? await defId.read(state.buildContext)
+		if let (resolvedName, defId) = resolver.resolve(name: name, in: signature.toplevelEnv.decls),
+			let def = try? await defId.read(signature.buildContext)
 		{
 			let type = await evaluator().evaluate(type: def.type)
 			let term = Term.global(name: resolvedName)

Sources/PterodactylBuild/Elaborator/ElabRules.swift

···
 			rhsEnv.extendNamespace(name: Name(agent: .machine, string: "type"))
 			let itype = await type.elabType(rhsEnv)
 			let emission = Emission(def: GlobalDef(type: itype, cause: .user))
-			await env.state.emit(name: NamespacedName(namespace: env.namespace, name: Name(agent: .user, string: name)), emission)
+			await env.sink.emit(name: NamespacedName(namespace: env.namespace, name: Name(agent: .user, string: name)), emission)
 		}
 	}
 
···
 		func elabTypedTerm(_ env: ElabEnv) async -> (Value.Type_, Term) {
 			if let typedTerm = await env.resolve(name: name) { return typedTerm }
 			if let provenance {
-				await env.state.emitFeedback(
+				await env.sink.emitFeedback(
 					.diagnostic(
 						Diagnostic(
 							message: "Could not resolve identifier `\(name)`",
···
 			}
 
 			if let provenance {
-				await env.state.emitFeedback(
+				await env.sink.emitFeedback(
 					.diagnostic(
 						Diagnostic(
 							message: "Cannot apply element of non-function type",
···
 			default:
 				let type = env.localAnalysis.quote(type: type)
 				if let provenance {
-					await env.state.emitFeedback(
+					await env.sink.emitFeedback(
 						.diagnostic(
 							Diagnostic(
 								message: "Attempted to put a lambda abstraction where a value of type \(type) was expected.",

Sources/PterodactylBuild/Elaborator/ElabState.swift

···
 import PterodactylSyntax
 import TSCUtility
 
+struct Signature: Sendable {
+	let buildContext: TSCUtility.Context
+	let toplevelEnv: ToplevelEnv
+
+	func lookup(_ name: NamespacedName) async -> GlobalDef? {
+		guard let defID = toplevelEnv.decls[name] else { return nil }
+		return try? await defID.read(buildContext)
+	}
+}
+
 struct Emission: Sendable {
 	var provenance: SyntaxTreeCursor.Options?
 	var def: GlobalDef
 }
 
-actor ElabState {
-	let buildContext: TSCUtility.Context
-	let toplevelEnv: ToplevelEnv
-
+actor EmissionSink {
 	private(set) var emitted: [NamespacedName: Emission] = [:]
 	private(set) var feedbacks: [Feedback] = []
 
-	init(
-		buildContext: TSCUtility.Context,
-		toplevelEnv: ToplevelEnv,
-	) {
-		self.buildContext = buildContext
-		self.toplevelEnv = toplevelEnv
-	}
-
-	func lookup(_ name: NamespacedName) async -> GlobalDef? {
-		if let emission = emitted[name] {
-			return emission.def
-		} else if let defID = toplevelEnv.decls[name] {
-			return try? await defID.read(buildContext)
-		}
-
-		return nil
+	func lookupEmitted(_ name: NamespacedName) -> GlobalDef? {
+		emitted[name]?.def
 	}
 
 	func emit(name: NamespacedName, _ emission: Emission) {

Sources/PterodactylBuild/Elaborator/Judgements.swift

···
 
 		let holeName = NamespacedName(namespace: env.namespace, name: name)
 		let emission = Emission(provenance: provenance, def: GlobalDef(type: generalisedType, cause: cause))
-		await env.state.emit(name: holeName, emission)
+		await env.sink.emit(name: holeName, emission)
 
 		if let provenance, cause == .user {
-			await env.state.emitFeedback(
+			await env.sink.emitFeedback(
 				.inlay(
 					InlayHint(
 						label: holeName.description,

Sources/PterodactylBuild/Elaborator/SyntaxTreeCursor+Elab.swift

···
 		if let identifier {
 			return await identifier.elabTypedTerm(env)
 		}
-		
+
 		if let applications {
 			return await applications.elabTypedTerm(env)
 		}
-		
+
 		if kind == .hole {
 			return await emitTypedTermHole(env, name: Name(agent: .machine, string: "hole"), cause: .user)
 		}
 
 		if kind != .error {
-			await env.state.emitFeedback(
+			await env.sink.emitFeedback(
 				.diagnostic(
 					Diagnostic(
 						message: "Expected a synthesizable term expression",
···
 		let term = await emitTermHole(env, type: type, name: Name(agent: .machine, string: "recovery"), cause: .recovery)
 
 		if kind != .error {
-			await env.state.emitFeedback(
+			await env.sink.emitFeedback(
 				.diagnostic(
 					Diagnostic(
 						message: "Expected a checkable term expression",

Sources/PterodactylBuild/Keys/DriverKeys.swift

···
 
 public struct ElaborateDecl: AsyncFXKey {
 	public struct ValueType: Codable, FXValue {
-		public var toplevelEnv: ToplevelEnv
+		public var newDecls: [NamespacedName: TypedDataID<GlobalDef>]
 		public var feedbacks: [Feedback]
 	}
 
···
 	public static let versionDependencies: [any FXVersioning.Type] = [ElaborateDecl.self]
 
 	func elabEnv(_ context: Context) -> ElabEnv {
-		ElabEnv(state: ElabState(buildContext: context, toplevelEnv: toplevelEnv), namespace: namespace)
+		ElabEnv(signature: Signature(buildContext: context, toplevelEnv: toplevelEnv), sink: EmissionSink(), namespace: namespace)
 	}
 
 	public func computeValue(_ fi: llbuild2fx.FXFunctionInterface<Self>, _ ctx: TSCUtility.Context) async throws -> ValueType {
···
 			let theoryName = subtrees.first { $0.kind == .theoryName }?.text
 			let decls = subtrees.filter { $0.kind.isDecl }
 
-			var result = ValueType(toplevelEnv: toplevelEnv, feedbacks: [])
+			var newDecls: [NamespacedName: TypedDataID<GlobalDef>] = [:]
+			var feedbacks: [Feedback] = []
+			var runningEnv = toplevelEnv
 
 			for decl in decls {
 				let namespace = if let theoryName { namespace + [Name(agent: .user, string: theoryName)] } else { namespace }
-				let declResult = try await fi.request(ElaborateDecl(namespace: namespace, toplevelEnv: result.toplevelEnv, code: decl.tree), ctx)
-				result.toplevelEnv = declResult.toplevelEnv
-				result.feedbacks += declResult.feedbacks.map {
+				let declResult = try await fi.request(ElaborateDecl(namespace: namespace, toplevelEnv: runningEnv, code: decl.tree), ctx)
+				runningEnv.decls.merge(declResult.newDecls) { _, new in new }
+				newDecls.merge(declResult.newDecls) { _, new in new }
+				feedbacks += declResult.feedbacks.map {
 					$0.offsettingUtf16Range(by: decl.utf16Offset)
 				}
 			}
 
-			return result
+			return ValueType(newDecls: newDecls, feedbacks: feedbacks)
 
 		case .claimDecl:
 			guard let claim = cursor.claim else { fatalError() }
 			let elabEnv = elabEnv(ctx)
 			await claim.elabDecl(elabEnv)
 
-			var result = ValueType(toplevelEnv: toplevelEnv, feedbacks: [])
-			try await result.toplevelEnv.update(from: elabEnv.state, in: ctx)
-			result.feedbacks += await elabEnv.state.feedbacks
-			return result
+			var newDecls: [NamespacedName: TypedDataID<GlobalDef>] = [:]
+			for (name, emission) in await elabEnv.sink.emitted {
+				newDecls[name] = try await emission.def.save(ctx)
+			}
+			return ValueType(newDecls: newDecls, feedbacks: await elabEnv.sink.feedbacks)
 
 		case .defineDecl, .refineDecl:
 			let diagnostic = Diagnostic(message: "This kind of declaration is not yet supported", severity: .warning, absoluteRange: cursor.utf16Range)
-			return ValueType(toplevelEnv: toplevelEnv, feedbacks: [.diagnostic(diagnostic)])
+			return ValueType(newDecls: [:], feedbacks: [.diagnostic(diagnostic)])
 		default: fatalError()
 		}
 	}
···
 
 				if childTree.kind.isDecl {
 					let localResult = try await fi.request(ElaborateDecl(namespace: [], toplevelEnv: result.toplevelEnv, code: childTree.tree), ctx)
-					result.toplevelEnv = localResult.toplevelEnv
+					result.toplevelEnv.decls.merge(localResult.newDecls) { _, new in new }
 					result.feedbacks += localResult.feedbacks.map { $0.offsettingUtf16Range(by: childTree.utf16Offset) }
 				}
 			}

Sources/PterodactylBuild/ToplevelEnv.swift

···
 // SPDX-License-Identifier: MPL-2.0
 
 import PterodactylKernel
-import PterodactylSyntax
 import llbuild2fx
 
 public struct ToplevelEnv: Codable, Sendable {
···
 
 	mutating func `import`(env: Self) {
 		decls.merge(env.decls) { original, new in new }
-	}
-
-	mutating func update(from state: ElabState, in context: Context) async throws {
-		for (name, emission) in await state.emitted {
-			decls[name] = try await emission.def.save(context)
-		}
 	}
 }

Sources/PterodactylKernel/Core Types/Value.swift

···
 		public let head: Head
 		public let spine: Spine
 		public let boundary: AsyncThunk<Boundary>
-		
+
 		public init(head: Head, spine: Spine, boundary: AsyncThunk<Boundary>) {
 			self.head = head
 			self.spine = spine
 			self.boundary = boundary
 		}
-		
+
 		public var globalHead: NamespacedName? {
 			switch head {
 			case .global(let name): name

Sources/PterodactylKernel/Evaluator.swift

···
 		case user
 		case recovery
 	}
-	
+
 	public let type: Term.Type_
 	public let term: Term?
 	public let cause: Cause?

Sources/PterodactylLanguageServer/Event Handlers/RequestHandler.swift

···
 			let position = info.lineMap.lspPosition(at: range.endIndex)
 			return InlayHint(position: position, label: .optionA(hint))
 		}
-		
+
 		if let state = await actor.savedFeedbacks[params.textDocument.uri] {
 			lspHints += state.allFeedbacks.compactMap { feedback in
 				switch feedback {

Sources/PterodactylSyntax/Diagnostic.swift

···
 public struct InlayHint: Codable, Sendable, Equatable, RelativelyLocated {
 	public var label: String
 	public var utf16Offset: Int
-	
+
 	public init(label: String, utf16Offset: Int) {
 		self.label = label
 		self.utf16Offset = utf16Offset

Sources/PterodactylSyntax/LineMap.swift

···
 		let columnNumber = utf16Offset - lineStart
 		return Position(line: lineNumber, character: columnNumber)
 	}
-	
+
 	public func lspRange(of range: Range<Int>) -> LanguageServerProtocol.LSPRange {
 		let start = lspPosition(at: range.lowerBound)
 		let end = lspPosition(at: range.upperBound)

Tests/PterodactylBuildTests/Test.swift

···
 
 	@Test
 	func testElab() async throws {
-		let state = ElabState(buildContext: Context(), toplevelEnv: ToplevelEnv())
-		let env = ElabEnv(state: state)
+		let signature = Signature(buildContext: Context(), toplevelEnv: ToplevelEnv())
+		let sink = EmissionSink()
+		let env = ElabEnv(signature: signature, sink: sink)
 
 		let funType =
 			await ElabRules.FunType(
···
 			}
 
 		#expect(result, "Identity function incorrectly elaborated as: \(lambda)")
-		#expect(await state.emitted.count == 0)
+		#expect(await sink.emitted.count == 0)
 	}
 }