Build completions lazily and cut evaluation overhead

[jdesrosiers]

Completion value sets were built for every instance location during every evaluation, so diagnostics, hover and colors paid for completions on every edit. Evaluation now only records what each schema contributes, and completions are built and combined when they're requested.

• Lazy value sets. Each location's value set is a memoized thunk that's built the first time something asks for it. Completions, hover, default snippets and deprecated diagnostics share the result.
• Combine when requested. Completions were merged into every schema on the way up, so an object's property completions were copied once for each $ref and allOf between the schema that declared them and the root. Each schema evaluation now records its own contributions and how its subschemas combine (intersect, union, exclusive union, negate). The completions at a location are combined on request, visiting only the schemas whose instance location contains it. An intermediate commit that combined them in place is superseded by this.
• Lazy declared properties. The properties keyword records its subschemas instead of adding completions for every declared property each time it's evaluated. A property's completions are created only when it's requested.
• Cached value sets. The value set built from a schema doesn't depend on the instance, so it's cached by schema location for as long as the compiled schema is in use. A set that depends on the dynamic scope is cached for that scope. One that depends on where a cycle was entered isn't cached. This matters for schemas that reference the same definitions from many places: in the oxlint schema, 868 rules reference the same definition.
• Cheaper value set building. Keywords that don't constrain values, such as description, are skipped instead of being intersected as unconstrained sets. Building starts from the first constraining keyword instead of an unconstrained set, and the same goes for allOf. The value set iterator now yields members in type order, which completions had relied on the extra intersection for.

Measured against the oxlint configuration schema (765 KB, 871 rules):

	Before	After
Validation	~87 ms	~0.4 ms (hyperjump alone: ~0.2 ms)
Validation + value completions for one rule	~87 ms	~0.3 ms
Validation + property completions for rules	~87 ms	~3 ms (~5 ms on the first request after compiling)

Behavior change

Cached value sets share annotation objects, and annotations are deduplicated by identity. So a subschema reached more than once at a location that evaluation doesn't reach now contributes its annotations once instead of once per reference. For example, in { "properties": { "foo": { "allOf": [{ "$ref": "#/$defs/a" }, { "$ref": "#/$defs/a" }] } } }, an absent foo now has a's description once instead of twice. Locations that evaluation reaches are unaffected.

Testing

Apart from that, behavior isn't intended to change, so there are no new tests. The existing tests pass. For each step, I compared annotations and completions before and after, and they were identical. The comparisons covered the oxlint schema's objects and their properties, including the order of property names, array items and incomplete locations. For the caching step, they also covered a schema document validated against the 2020-12 meta-schema, which exercises $dynamicRef and recursion. Each comparison was run both on the first query and with the cache warm.

🤖 Generated with Claude Code