98c19cd · jibb · git.iko.soy

git.iko.soy/jibb

Infer known string interpolations

98c19cdiko10 hours ago

docs/compiler.md+2

@@ -58,6 +58,8 @@ The core is split into chapters, `+| %name`, in this order:

59The inference fragment supports fixed auras, unrestricted `@`, one-way widening into it and toward aura-family ancestors, generic variables and gates, faced and unfaced cells, cell sample binders, known record field reads, a two-binder cell pattern, a complete two-arm loobean branch, a complete two-arm unit-shaped branch, closed local mold aliases and acyclic forward value references. For a supported single syntactic top-level recursive gate, the checker infers the sample first and uses that exact sample, including its field faces, in a monomorphic self placeholder. The completed body must unify with the placeholder before the gate is generalized; incompatible recursive arguments can report the call and argument sites. Uses of generalized top-level definitions instantiate their schemes independently. For a complete loobean branch with one direct self-call arm, the checker can infer the other arm independently and use its closed, fully resolved type to seed the recursive result; it then checks the whole body. Open or pending base types do not seed the result, and other branch shapes still depend on the existing partial inference. A supported single local recursive gate also uses a monomorphic self reference while its body is checked, then generalizes variables free of its enclosing environment; captured variables remain shared. Acyclic local value definitions can refer forward. The checker collects written capitals per `++` before inference, excluding nested definitions: a capital used in an enclosing definition is shared with its locals, even when written later, while a capital introduced only in a local definition is generalized there. Sibling locals can introduce independent capitals with the same spelling; generic mold parameters keep their own scope. Mutual recursive groups, polymorphic recursion and value cycles remain unsupported. Acyclic simple local mold aliases can also refer forward, and are scoped to the body, not its gate's sample. Nonrecursive generic aliases of supported molds can be applied at exact arity, including locally and through library interfaces; their parameters are lexical. Closed, provably disjoint nonrecursive unions and tagged single-case molds support contextual term values, `~` and `|=%tag` constructors. A null-headed cell can match a union case but does not supply a `|=%$` constructor; unresolved tags and nulls remain pending, with distinct partial-inference diagnostics. Nonrecursive top-level generic union molds with provably disjoint cases also support contextual tags and constructors at exact arity; their arguments are retained through generalization and supported library interfaces. Nonrecursive generic aliases can reorder, repeat or omit parameters while preserving a supported union’s origin, including through local scopes and library interfaces. A generic union declared directly inside a body remains unsupported, as do mutually recursive local groups and recursive molds. A value with type variable `A` can fit a field whose type is that same `A`, including in generic union payloads and nested or repeated record fields. A differing-variable face constraint remains unsupported. When inference forces two distinct explicitly written capitals equal, it reports both source sites; forcing a capital to a concrete type remains unsupported in this fragment. It can infer and generalize atom constraints arising from explicit capitals or bare sample binders, preserve those constraints through aliases, instantiate them independently, and print multiple constraints. Unresolved decimal variables default to `@ud` for inferred types without gates; defaulting inside gate types and other constraint cases remain incomplete. It does not yet check a module, complete imports, general patterns, general deferred constraints, recursive molds, dependency cycles or most errors with both conflicting excerpts. Definite cast and call mismatches, incompatible branches and overlapping union cases report both sites and excerpts. Concrete branch results can join at an explicitly present parent aura or `@`. Some known tuple and record positions acquire matching faces; other variable-dependent face merges, general branch tag context and ambiguous call-result propagation remain unsupported; function compatibility involving nested `@` and variable-dependent joins remain unsupported except for equal types. The reporting path repeats inference of a recursive gate rather than instantiating its generalized interface inside its own body. This adds work, and the current dependency pass can take quadratic time on long forward chains; the milestone's speed target remains unverified. A separate conservative pass reports unions whose cases are provably disjoint or overlapping and leaves other cases unresolved; it does not claim the mold is checked. Unsupported forms are reported as such, and the partial output says the module has not been checked.

61+String interpolation infers its pieces in order and preserves substitutions and pending constraints. A piece with a known atom aura, unrestricted `@`, or a tape `(list @tD)` is accepted; an isolated decimal literal takes its normal `@ud` default. A known cell reports that it needs a printer, and an explicitly generic atom asks for an aura at its use site. Loobeans, term singletons, non-tape collections, open types and a type fixed only later remain unsupported in this fragment.

62+

61For supported closed unions, the type printer keeps the union’s origin separate from its displayed name. It prints an in-scope name such as `msg` or `msg.lib`, including in records and gates; an accessible imported nongeneric alias may name a transitive union. A nongeneric body-local union that escapes its scope, or an origin without an accessible name, prints its cases separated by spaces, parenthesized when nested. That case-list form is print-only. A supported generic union prints its name and all arguments, including unused arguments; when its name is unavailable, the partial printer reports that limitation instead of dropping its arguments. Two faces for the same imported origin remain compatible; compatibility between distinct union origins, including in gate types, remains unsupported. Some comparisons of generic union arguments also remain unsupported rather than deciding equality or mismatch. The Hoon bridge also translates some imported unnamed unions into this representation; unsupported cases remain errors.

63For supported closed unions, the type printer keeps the union’s origin separate from its displayed name. It prints an in-scope name such as `msg` or `msg.lib`, including in records and gates; an accessible imported nongeneric alias may name a transitive union. A nongeneric body-local union that escapes its scope, or an origin without an accessible name, prints its cases separated by spaces, parenthesized when nested. That case-list form is print-only. A supported generic union prints its name and all arguments, including unused arguments; when its name is unavailable, the partial printer reports that limitation instead of dropping its arguments. Two faces for the same imported origin remain compatible; compatibility between distinct union origins, including in gate types, remains unsupported. Some comparisons of generic union arguments also remain unsupported rather than deciding equality or mismatch. The Hoon bridge also translates some imported unnamed unions into this representation; unsupported cases remain errors.

63Multi-argument calls form one right-nested sample: `f a b c` supplies `[a [b c]]`, with the last argument able to be a cell itself. The fragment fits the complete sample, preserving known faces and shared variables. Known sample positions can provide list or union context to arguments; unknown sample shapes use ordinary inference and some contextual forms remain unsupported. For a definite mismatch, the diagnostic points to a specific argument when it can establish which one failed; otherwise it reports the combined sample.

65Multi-argument calls form one right-nested sample: `f a b c` supplies `[a [b c]]`, with the last argument able to be a cell itself. The fragment fits the complete sample, preserving known faces and shared variables. Known sample positions can provide list or union context to arguments; unknown sample shapes use ordinary inference and some contextual forms remain unsupported. For a definite mismatch, the diagnostic points to a specific argument when it can establish which one failed; otherwise it reports the combined sample.

docs/status.md+7−6

@@ -19,7 +19,7 @@ On 2026-10-30, @iko decided that Jibb drops `$?`, so a `+$` takes a union's case

20## Milestone 2: in progress

22−The repository spec records the subsequent type-system and prelude decisions; those changes also need synchronization to the Claude document. An initial inference fragment and a standalone Hoon type reader are being tested. The fragment explicitly reports that it does not check a module; partial bridges pass selected Hoon atoms, term singletons, nested faced or unfaced cells, supported disjoint unions and opaque standard collections from `/sur` molds and marks into inference. Collections retain their names and supported arguments for printing and unification; nested supported union arguments are retained too. The bridge trusts unchanged results from the source-aware reader; a materialized type graph alone cannot reveal cases Hoon already collapsed. The source-validated standard prelude `list` mold shares this representation with imported lists; other Jibb-written collection molds and most prelude collection operations remain unsupported; malformed names and arities fail closed. Selected self-recursive `/sur` molds cross as opaque module-and-name identities; aliases, foreign references, recursive marks, unfolding and construction remain unsupported. The reader handles mark samples, recursive molds whose origins can be verified through Ford imports, nested collections, direct ordered maps, certain ordered-map fields, direct `$^` unions whose cases can be proved disjoint, and one verified explicit union argument in a list, set, map or unit. Ambiguous recursive origins fail closed; recognizable explicit unions are checked from source before Hoon can collapse their cases, as @iko confirmed for imported `$%`, `$?` and `$^`, while other nested unions, nested ordered maps, general union disjointness and complete import integration remain unfinished. Opt-in structured reader APIs preserve successful graphs and distinguish definite unsupported-aura and core evidence from failures the reader cannot prove; unverified union disjointness and name-only vase recognition remain unsupported. They revalidate and re-walk failed types. An opt-in partial checker entry point consumes unchanged reader results and reports definite aura or core errors at imported mold use sites when their inputs are unique. Ordered replay covers nested cell samples, record and function casts, and non-generic same-module aliases; unsupported prefixes, cycles and shadowing stop it. Union molds, generic applications, transitive modules and unsupported reader outcomes remain generic. Replay repeats inference and may add work. The partial checker resolves a subset of ordinary library imports in dependency order using supplied Jibb sources and a source-derived partial prelude interface, caches completed interfaces per run, and detects missing sources and cycles. It does not yet check API or kind semantics, and the prelude inventory is incomplete. The inference fragment supports unrestricted `@`, selected one-way widenings including aura-family ancestors, generalized atom constraints arising from explicit capitals or bare sample binders, acyclic local value definitions with captures, selected single self-recursive top-level and local gates, simple and nonrecursive generic mold aliases, selected faced record casts and field reads, and contextual tags, `~` and constructors for closed disjoint unions, including direct nonrecursive generic unions and propagation through complete loobean and unit-shaped branches in casts and known union-sample calls, including nested branches. Multi-argument calls form a right-nested sample, retain known faces and shared type variables, and can use known sample positions to contextualize list and union arguments. A definite mismatch points to the failing argument when the fragment can establish it, otherwise to the combined sample; unsupported contextual forms still fail closed. For a supported recursive gate, the checker infers the sample first and uses its exact type, including field faces, for one monomorphic self reference. It generalizes after the body is checked; subsequent uses instantiate it independently. Incompatible recursive arguments can report the gate and argument sites. For a complete loobean branch with one direct self-call arm, a separately inferred closed base type can seed the recursive result before the whole body is checked. Open or pending base types do not seed it; other branch shapes remain subject to the fragment’s existing limits. A supported single local recursive gate also uses a monomorphic self reference and generalizes variables free of the enclosing environment after checking its body; captured variables remain shared. The checker collects written capitals per `++` before inference, excluding nested definitions: a capital used in an enclosing definition is shared with its locals even when written later, while a capital introduced only in a local definition is generalized there. Sibling locals can introduce independent capitals with the same spelling; generic mold parameters keep their own scope. Mutual groups, polymorphic recursion and value cycles remain unsupported. Reporting repeats inference for a recursive gate, so its performance cost remains unmeasured. Contextual null-headed cells fit their cases, but do not supply a `|=%$` constructor; unresolved nulls remain pending and are reported separately from tags. A known union of `~` and a null-headed cell supports a complete `~` / `[~ value]` branch in either order, including shadow checks; unknown subjects, missing or duplicate arms, and unresolved branch results remain unsupported. This fragment infers the prelude’s `fall` and `need` signatures. With the validated prelude list and a known cast or gate sample, empty, nonempty and nested list literals infer their element types, including contextual union tags; a mismatched element names both sites. In that context `~` and zero-valued terms fit an empty list, and two-item unfaced cells form cons lists, including nested cons and imported-list contexts; invalid heads or tails name both sites. Faced or longer cells and a missing or altered prelude list fail closed. A known list result also supplies context through complete loobean, unit-shaped and list-shaped branches, including recursive and nested branches. For a known standard list with a supported element type, a complete `~` / `[item rest]` branch infers the element and tail types in either arm order and checks binders for shadowing. Uncontextualized list construction, unknown subjects, unsupported element types and other or incomplete list patterns remain unsupported. A value with type variable `A` can fit a field whose type is that same `A`, including in generic union payloads and nested or repeated record fields. Other variable-dependent face merges remain unsupported. Forced equality of distinct written capitals now reports both source sites, following @iko’s decision; forcing one to a concrete type remains unsupported. Imported record spines with repeated faces fail closed where used, but only with a generic unsupported diagnostic. Hoon may erase unfaced nested-cell boundaries, so the check can conservatively reject valid names in distinct erased scopes. Supported closed unions print using an in-scope name or imported alias; an unnamed nongeneric union prints its cases, parenthesized when nested. The latter is print-only. Generic union types retain all arguments in their printed name; if that name is unavailable, the partial printer reports the limitation. Different import faces for the same origin remain compatible; compatibility across distinct union origins and some generic-argument comparisons remain unsupported. Nonrecursive generic aliases can reorder, repeat or omit parameters while retaining a union’s origin, including through local scopes and library interfaces. A generic union declared directly inside a body remains unsupported, as do differing-variable face constraints in a union payload. A transitive generic union whose name is unavailable is reported as unsupported instead of hiding its arguments. Unfixed decimal literals default to `@ud` in gate-free inferred types; mutually recursive local groups and recursive molds, general branch tag context, other constraint cases and defaulting inside gate types still need work. Collection recognition checks the originating core and fails closed on shadows or unsupported Ford subject shapes; a wrapper regression also rejects forged subjects, samples and tails. Its golden fixtures include three real Tlon files. A Clay test passes a Ford-built nested union through the reader into partial inference. The partial prelude includes `murn`, `join`, `snip`, `rear` and the newly agreed shared-type `clap`, parsed but still awaiting checker and backend validation, and [prelude-inventory.md](prelude-inventory.md) is a source audit, not the complete inventory or signatures. The milestone remains unfinished.

22+The repository spec records the subsequent type-system and prelude decisions; those changes also need synchronization to the Claude document. An initial inference fragment and a standalone Hoon type reader are being tested. The fragment explicitly reports that it does not check a module; partial bridges pass selected Hoon atoms, term singletons, nested faced or unfaced cells, supported disjoint unions and opaque standard collections from `/sur` molds and marks into inference. Collections retain their names and supported arguments for printing and unification; nested supported union arguments are retained too. The bridge trusts unchanged results from the source-aware reader; a materialized type graph alone cannot reveal cases Hoon already collapsed. The source-validated standard prelude `list` mold shares this representation with imported lists; other Jibb-written collection molds and most prelude collection operations remain unsupported; malformed names and arities fail closed. Selected self-recursive `/sur` molds cross as opaque module-and-name identities; aliases, foreign references, recursive marks, unfolding and construction remain unsupported. The reader handles mark samples, recursive molds whose origins can be verified through Ford imports, nested collections, direct ordered maps, certain ordered-map fields, direct `$^` unions whose cases can be proved disjoint, and one verified explicit union argument in a list, set, map or unit. Ambiguous recursive origins fail closed; recognizable explicit unions are checked from source before Hoon can collapse their cases, as @iko confirmed for imported `$%`, `$?` and `$^`, while other nested unions, nested ordered maps, general union disjointness and complete import integration remain unfinished. Opt-in structured reader APIs preserve successful graphs and distinguish definite unsupported-aura and core evidence from failures the reader cannot prove; unverified union disjointness and name-only vase recognition remain unsupported. They revalidate and re-walk failed types. An opt-in partial checker entry point consumes unchanged reader results and reports definite aura or core errors at imported mold use sites when their inputs are unique. Ordered replay covers nested cell samples, record and function casts, and non-generic same-module aliases; unsupported prefixes, cycles and shadowing stop it. Union molds, generic applications, transitive modules and unsupported reader outcomes remain generic. Replay repeats inference and may add work. The partial checker resolves a subset of ordinary library imports in dependency order using supplied Jibb sources and a source-derived partial prelude interface, caches completed interfaces per run, and detects missing sources and cycles. It does not yet check API or kind semantics, and the prelude inventory is incomplete. The inference fragment supports unrestricted `@`, selected one-way widenings including aura-family ancestors, generalized atom constraints arising from explicit capitals or bare sample binders, acyclic local value definitions with captures, selected single self-recursive top-level and local gates, simple and nonrecursive generic mold aliases, selected faced record casts and field reads, and contextual tags, `~` and constructors for closed disjoint unions, including direct nonrecursive generic unions and propagation through complete loobean and unit-shaped branches in casts and known union-sample calls, including nested branches. Multi-argument calls form a right-nested sample, retain known faces and shared type variables, and can use known sample positions to contextualize list and union arguments. A definite mismatch points to the failing argument when the fragment can establish it, otherwise to the combined sample; unsupported contextual forms still fail closed. For a supported recursive gate, the checker infers the sample first and uses its exact type, including field faces, for one monomorphic self reference. It generalizes after the body is checked; subsequent uses instantiate it independently. Incompatible recursive arguments can report the gate and argument sites. For a complete loobean branch with one direct self-call arm, a separately inferred closed base type can seed the recursive result before the whole body is checked. Open or pending base types do not seed it; other branch shapes remain subject to the fragment’s existing limits. A supported single local recursive gate also uses a monomorphic self reference and generalizes variables free of the enclosing environment after checking its body; captured variables remain shared. The checker collects written capitals per `++` before inference, excluding nested definitions: a capital used in an enclosing definition is shared with its locals even when written later, while a capital introduced only in a local definition is generalized there. Sibling locals can introduce independent capitals with the same spelling; generic mold parameters keep their own scope. Mutual groups, polymorphic recursion and value cycles remain unsupported. Reporting repeats inference for a recursive gate, so its performance cost remains unmeasured. String interpolation accepts known atom auras, unrestricted `@`, tapes and isolated decimal literals; a known cell asks for a printer, and an explicitly generic atom asks for an aura. Loobeans, term singletons, non-tape collections, open types and a type fixed only later remain unsupported. Contextual null-headed cells fit their cases, but do not supply a `|=%$` constructor; unresolved nulls remain pending and are reported separately from tags. A known union of `~` and a null-headed cell supports a complete `~` / `[~ value]` branch in either order, including shadow checks; unknown subjects, missing or duplicate arms, and unresolved branch results remain unsupported. This fragment infers the prelude’s `fall` and `need` signatures. With the validated prelude list and a known cast or gate sample, empty, nonempty and nested list literals infer their element types, including contextual union tags; a mismatched element names both sites. In that context `~` and zero-valued terms fit an empty list, and two-item unfaced cells form cons lists, including nested cons and imported-list contexts; invalid heads or tails name both sites. Faced or longer cells and a missing or altered prelude list fail closed. A known list result also supplies context through complete loobean, unit-shaped and list-shaped branches, including recursive and nested branches. For a known standard list with a supported element type, a complete `~` / `[item rest]` branch infers the element and tail types in either arm order and checks binders for shadowing. Uncontextualized list construction, unknown subjects, unsupported element types and other or incomplete list patterns remain unsupported. A value with type variable `A` can fit a field whose type is that same `A`, including in generic union payloads and nested or repeated record fields. Other variable-dependent face merges remain unsupported. Forced equality of distinct written capitals now reports both source sites, following @iko’s decision; forcing one to a concrete type remains unsupported. Imported record spines with repeated faces fail closed where used, but only with a generic unsupported diagnostic. Hoon may erase unfaced nested-cell boundaries, so the check can conservatively reject valid names in distinct erased scopes. Supported closed unions print using an in-scope name or imported alias; an unnamed nongeneric union prints its cases, parenthesized when nested. The latter is print-only. Generic union types retain all arguments in their printed name; if that name is unavailable, the partial printer reports the limitation. Different import faces for the same origin remain compatible; compatibility across distinct union origins and some generic-argument comparisons remain unsupported. Nonrecursive generic aliases can reorder, repeat or omit parameters while retaining a union’s origin, including through local scopes and library interfaces. A generic union declared directly inside a body remains unsupported, as do differing-variable face constraints in a union payload. A transitive generic union whose name is unavailable is reported as unsupported instead of hiding its arguments. Unfixed decimal literals default to `@ud` in gate-free inferred types; mutually recursive local groups and recursive molds, general branch tag context, other constraint cases and defaulting inside gate types still need work. Collection recognition checks the originating core and fails closed on shadows or unsupported Ford subject shapes; a wrapper regression also rejects forged subjects, samples and tails. Its golden fixtures include three real Tlon files. A Clay test passes a Ford-built nested union through the reader into partial inference. The partial prelude includes `murn`, `join`, `snip`, `rear` and the newly agreed shared-type `clap`, parsed but still awaiting checker and backend validation, and [prelude-inventory.md](prelude-inventory.md) is a source audit, not the complete inventory or signatures. The milestone remains unfinished.

24The shared prelude interface reserves every name present in the supplied vendored source and makes only supported inferred entries available, including `list`, `unit`, `same`, `fall`, `need`, `lure`, `weld` and `snoc`. The validated standard `list` mold is injected when the prelude’s own gates are inferred; `weld` has an ordinary explicit result cast. An absent or altered `list` is not injected, and an altered declaration cannot leak through direct or transitive mold aliases. List-dependent prelude mold aliases remain unsupported because their templates are prepared before injection. Unsupported entries such as most list helpers remain reserved but unavailable; backend validation of the helpers remains outstanding. All callers use the same prelude origin, so a library can export a type containing unqualified `(unit A)` to another module. Preparation rejects empty, malformed, conflicting or import-bearing source; the prepared value is trusted and must come unchanged from `+prepare-prelude`. The module-scope fixture compares the prepared and source-taking paths against the real prelude and a two-module golden under eval and on the ship. The source and checker remain incomplete, so this does not establish complete shadowing coverage or a checked module.

@@ -39,8 +39,8 @@ What the plan asks for, and where it is:

40Besides the plan's list:

42−- 514 golden cases: 298 that parse and 216 that fail, each failure at a stated line and column. One failing case has an unclear expectation (corpus question 3). The newer type-output cases exercise only the partial inference fragment. Each case's `about.txt` quotes the doc's words it tests.

42+- 515 golden cases: 299 that parse and 216 that fail, each failure at a stated line and column. One failing case has an unclear expectation (corpus question 3). The newer type-output cases exercise only the partial inference fragment. Each case's `about.txt` quotes the doc's words it tests.

43−- The 514-case corpus passed under `urbit eval` in 62.6 s. The fake ship passed all 520 tests, including the importer, importer/checker and mark/checker bridges, module scope and unification checks, with 30.5 s for sync and 36.0 s for tests. The importer golden compares 149 projections; `tools/clay-fixtures` builds the example Hoon fixtures through Clay, checks a recursive Ford import's origin, and passes Clay-built types through the Clay-built importer and partial checker.

43+- The 515-case corpus passed under `urbit eval` in 58.3 s. The fake ship passed all 521 tests, including the importer, importer/checker and mark/checker bridges, module scope and unification checks, with 32.6 s for sync and 37.9 s for tests. The importer golden compares 149 projections; `tools/clay-fixtures` builds the example Hoon fixtures through Clay, checks a recursive Ford import's origin, and passes Clay-built types through the Clay-built importer and partial checker.

44- `tools/testdata/selftest` (22 checks) and `tools/testdata/ship-selftest` test the tools themselves.

45- Two independent audits before 7c739b7, one of which compared the library with a reference parser written in Python from the doc over about 19,000 generated programs. Before ab797a9, a second Python parser, written from the decisions, agreed with the library on 8,000 generated programs and 900 hand-written probes.

46- Speed: starting `urbit eval` and building the library takes about 8 s. After that, a 2,000-line module of 400 definitions parses in about a second. Loops over definitions, arms, lines and items grow no stack; nesting costs a few stack frames a level, and 100,000 nested brackets still parse (library section 3).

@@ -91,14 +91,15 @@ Besides the plan's list:

91| 1470d18 | 2026-10-30 | Infer selected prelude list helpers |

92| 10cbf9c | 2026-10-30 | Infer selected local recursive gates and distinguish reader diagnostics |

93| 45afb13 | 2026-10-30 | Infer local capital scopes and report direct reader diagnostics |

94−| This change | 2026-10-30 | Report nested reader diagnostics |

94+| 054e651 | 2026-10-30 | Report nested reader diagnostics |

95+| This change | 2026-10-30 | Infer known-aura string interpolation |

96## Checking it

97## Checking it

98On a machine set up as [development.md](development.md) says:

99On a machine set up as [development.md](development.md) says:

100

100```

101```

101−tools/golden # 514 cases under urbit eval

102+tools/golden # 515 cases under urbit eval

102tools/importer-test # the Hoon importer fixture projection

103tools/importer-test # the Hoon importer fixture projection

103tools/type-import-test # the importer/checker bridge fixture

104tools/type-import-test # the importer/checker bridge fixture

104tools/type-mark-test # the mark/checker bridge fixture

105tools/type-mark-test # the mark/checker bridge fixture

@@ -108,7 +109,7 @@ tools/testdata/selftest # the tools themselves

108tools/doc-blocks docs/spec # the doc's examples are golden cases

109tools/doc-blocks docs/spec # the doc's examples are golden cases

109tools/ship start

110tools/ship start

110tools/ship gen-tests --check # tests/lib/jibb.hoon is up to date

111tools/ship gen-tests --check # tests/lib/jibb.hoon is up to date

111−tools/ship test # the same 514 cases as -test arms on the ship

112+tools/ship test # the same 515 cases as -test arms on the ship

112tools/testdata/ship-selftest

113tools/testdata/ship-selftest

113tools/ship check-commit # |commit stores .jibb files

114tools/ship check-commit # |commit stores .jibb files

114tools/clay-fixtures # example /sur files and marks build through Clay

115tools/clay-fixtures # example /sur files and marks build through Clay

jibb-dev/lib/jibb.hoon+26−5

@@ -5226,7 +5226,7 @@

5226 problems

5227::

5228:: The expression inference below is deliberately a fragment: bindings,

5229−:: simple gates, calls, fixed-aura literals, and plain strings. The

5229+:: simple gates, calls, fixed-aura literals, and some interpolated strings. The

5230:: result for unsupported syntax is a diagnostic, never a checked module.

5231::

5232+$ ischeme [typ=itype vars=(list @ud)]

@@ -6671,6 +6671,30 @@

6671 ?~ joined [%| ["unit branch results need unsupported inference" ~]]

6672 [%& typ.p.left state.p.right(sub u.joined)]

6673::

6674+:: Infer pieces in order, retaining their substitutions and pending tags.

6675+:: A bare decimal literal has no outside type constraint, so it takes its

6676+:: normal @ud default here. Other open numeric and aura variables wait for

6677+:: deferred constraints, which this fragment does not implement yet.

6678+++ infer-string-pieces

6679+ |= [ps=(list piece) env=ienv state=istate]

6680+ ^- iresult

6681+ ?~ ps [%& [%atom %t] state]

6682+ ?: ?=(%text -.i.ps) $(ps t.ps)

6683+ =/ item=iresult (infer-fragment p.i.ps env state)

6684+ ?: ?=(%| -.item) item

6685+ =/ t=itype (itype-normalize typ.p.item sub.state.p.item)

6686+ ?: |(?=(%atom -.t) ?=(%any-atom -.t))

6687+ $(ps t.ps, state state.p.item)

6688+ ?: &(?=(%nvar -.t) ?=(%lit -.p.i.ps) =(%number form.lit.p.i.ps))

6689+ $(ps t.ps, state state.p.item)

6690+ ?: &(?=(%collection -.t) =(%list name.t) =(~[[%atom 'tD']] args.t))

6691+ $(ps t.ps, state state.p.item)

6692+ ?: &(?=(%avar -.t) (atom-var-from-cap id.t caps.state.p.item sub.state.p.item))

6693+ [%| ["a generic atom in interpolation needs an aura" ~[[(span-of p.i.ps) "atom with a generic aura"]]]]

6694+ ?: ?=(%cell -.t)

6695+ [%| ["a cell in interpolation needs a printer" ~[[(span-of p.i.ps) "cell without a printer"]]]]

6696+ [%| ["interpolation type needs unsupported inference" ~]]

6697+::

6674++ infer-fragment

6698++ infer-fragment

6675 |= [e=expr env=ienv state=istate]

6699 |= [e=expr env=ienv state=istate]

6676 ^- iresult

6700 ^- iresult

@@ -6688,10 +6712,7 @@

6688 %term [%& [%tag next.state lit.e |] state(next +(next.state), tags [[next.state lit.e] tags.state])]

6712 %term [%& [%tag next.state lit.e |] state(next +(next.state), tags [[next.state lit.e] tags.state])]

6689 %null [%& [%tag next.state lit.e |] state(next +(next.state), tags [[next.state lit.e] tags.state])]

6713 %null [%& [%tag next.state lit.e |] state(next +(next.state), tags [[next.state lit.e] tags.state])]

6690 ==

6714 ==

6691− %str

6715+ %str (infer-string-pieces pieces.e env state)

6692− =/ interpolated=? (lien pieces.e |=(p=piece ?=(%expr -.p)))

6693− ?: interpolated [%| ["interpolation is not supported by partial inference" ~]]

6694− [%& [%atom %t] state]

6695 %wing

6716 %wing

6696 ?~ names.e [%| ["empty wing" ~]]

6717 ?~ names.e [%| ["empty wing" ~]]

6697 ?^ t.names.e

6718 ?^ t.names.e

tests/golden/types-string-interpolation/about.txtnew file+4

@@ -0,0 +1,4 @@

1+source: Grammar, Expressions: "In `{…}`, an atom prints by its aura"; "`@t`, `@ta`, `@tas` and tapes splice as text; any other cell is an error asking for a printer"; "an atom whose aura its `++` is generic over ... is an error asking for an aura".

2+tests: Known auras, unrestricted atoms, tapes and isolated decimal literals infer as cords. A known tuple needs a printer and a generic atom needs an aura, each at the interpolated expression. Unresolved variables, tags, gates and non-tape lists stay unsupported; unrelated pending constraints and errors inside a piece are retained. An earlier cast can fix an aura, but a later cast needs deferred inference.

3+expect: parses

4+expect-types: a partial inference report

tests/golden/types-string-interpolation/modules.txtnew file+1

@@ -0,0 +1 @@

1+# no module fixtures

tests/golden/types-string-interpolation/source.jibbnew file+28

@@ -0,0 +1,28 @@

1+++ render |= [day=@da n=@ud ship=@p words=@t] "Updated {day}: {n} by {ship}, {words}"

2+++ bare |= x=@ "{x}"

3+++ repeat |= n=@ud "{n} then {n}"

4+++ nested |= x=@t "{(same x)}"

5+++ record |= x=[@t @ud] "{x}"

6+++ gate |= x=$-(@t @t) "{x}"

7+++ generic |= x=A "{x}"

8+++ unknown |= x "{x}"

9+++ pending |= x=@t "{%orphan}"

10+++ other-pending |= x=@t

11+ ~& %orphan

12+ "{x}"

13+++ tape |= x=(list @tD) "{x}"

14+++ non-tape |= x=(list @t) "{x}"

15+++ number "number {1}"

16+++ number-cast "number {^- @ud 1}"

17+++ generic-atom |= n=A

18+ ~& ^- @ n

19+ "{n}"

20+++ fixed-first |= n

21+ ~& ^- @ud n

22+ "{n}"

23+++ fixed-later |= n

24+ ~& "{n}"

25+ ^- @ud n

26+++ explicit-force |= x=A "{^- @ud x}"

27+++ clash |= [x=@t y=@p] "{x} {^- @t y}"

28+++ invalid-expression "{missing}"

tests/golden/types-string-interpolation/tokens.txtnew file+259

@@ -0,0 +1,259 @@

1+1:1 glyph ++

2+1:4 name render

3+1:11 glyph |=

4+1:14 glyph [

5+1:15 tight name day

6+1:18 tight glyph =

7+1:19 tight aura @da

8+1:23 name n

9+1:24 tight glyph =

10+1:25 tight aura @ud

11+1:29 name ship

12+1:33 tight glyph =

13+1:34 tight aura @p

14+1:37 name words

15+1:42 tight glyph =

16+1:43 tight aura @t

17+1:45 tight glyph ]

18+1:47 str-head "Updated "

19+1:57 tight name day

20+1:60 tight str-mid ": "

21+1:64 tight name n

22+1:65 tight str-mid " by "

23+1:71 tight name ship

24+1:75 tight str-mid ", "

25+1:79 tight name words

26+1:84 tight str-tail ""

27+2:1 NEWLINE

28+2:1 glyph ++

29+2:4 name bare

30+2:9 glyph |=

31+2:12 name x

32+2:13 tight glyph =

33+2:14 tight aura @

34+2:16 str-head ""

35+2:18 tight name x

36+2:19 tight str-tail ""

37+3:1 NEWLINE

38+3:1 glyph ++

39+3:4 name repeat

40+3:11 glyph |=

41+3:14 name n

42+3:15 tight glyph =

43+3:16 tight aura @ud

44+3:20 str-head ""

45+3:22 tight name n

46+3:23 tight str-mid " then "

47+3:31 tight name n

48+3:32 tight str-tail ""

49+4:1 NEWLINE

50+4:1 glyph ++

51+4:4 name nested

52+4:11 glyph |=

53+4:14 name x

54+4:15 tight glyph =

55+4:16 tight aura @t

56+4:19 str-head ""

57+4:21 tight glyph (

58+4:22 tight name same

59+4:27 name x

60+4:28 tight glyph )

61+4:29 tight str-tail ""

62+5:1 NEWLINE

63+5:1 glyph ++

64+5:4 name record

65+5:11 glyph |=

66+5:14 name x

67+5:15 tight glyph =

68+5:16 tight glyph [

69+5:17 tight aura @t

70+5:20 aura @ud

71+5:23 tight glyph ]

72+5:25 str-head ""

73+5:27 tight name x

74+5:28 tight str-tail ""

75+6:1 NEWLINE

76+6:1 glyph ++

77+6:4 name gate

78+6:9 glyph |=

79+6:12 name x

80+6:13 tight glyph =

81+6:14 tight glyph $-(

82+6:17 tight aura @t

83+6:20 aura @t

84+6:22 tight glyph )

85+6:24 str-head ""

86+6:26 tight name x

87+6:27 tight str-tail ""

88+7:1 NEWLINE

89+7:1 glyph ++

90+7:4 name generic

91+7:12 glyph |=

92+7:15 name x

93+7:16 tight glyph =

94+7:17 tight tvar A

95+7:19 str-head ""

96+7:21 tight name x

97+7:22 tight str-tail ""

98+8:1 NEWLINE

99+8:1 glyph ++

100+8:4 name unknown

101+8:12 glyph |=

102+8:15 name x

103+8:17 str-head ""

104+8:19 tight name x

105+8:20 tight str-tail ""

106+9:1 NEWLINE

107+9:1 glyph ++

108+9:4 name pending

109+9:12 glyph |=

110+9:15 name x

111+9:16 tight glyph =

112+9:17 tight aura @t

113+9:20 str-head ""

114+9:22 tight lit %orphan

115+9:29 tight str-tail ""

116+10:1 NEWLINE

117+10:1 glyph ++

118+10:4 name other-pending

119+10:18 glyph |=

120+10:21 name x

121+10:22 tight glyph =

122+10:23 tight aura @t

123+11:3 INDENT

124+11:3 glyph ~&

125+11:6 lit %orphan

126+12:5 INDENT

127+12:5 str-head ""

128+12:7 tight name x

129+12:8 tight str-tail ""

130+13:1 DEDENT

131+13:1 DEDENT

132+13:1 NEWLINE

133+13:1 glyph ++

134+13:4 name tape

135+13:9 glyph |=

136+13:12 name x

137+13:13 tight glyph =

138+13:14 tight glyph (

139+13:15 tight name list

140+13:20 aura @tD

141+13:23 tight glyph )

142+13:25 str-head ""

143+13:27 tight name x

144+13:28 tight str-tail ""

145+14:1 NEWLINE

146+14:1 glyph ++

147+14:4 name non-tape

148+14:13 glyph |=

149+14:16 name x

150+14:17 tight glyph =

151+14:18 tight glyph (

152+14:19 tight name list

153+14:24 aura @t

154+14:26 tight glyph )

155+14:28 str-head ""

156+14:30 tight name x

157+14:31 tight str-tail ""

158+15:1 NEWLINE

159+15:1 glyph ++

160+15:4 name number

161+15:11 str-head "number "

162+15:20 tight lit 1

163+15:21 tight str-tail ""

164+16:1 NEWLINE

165+16:1 glyph ++

166+16:4 name number-cast

167+16:16 str-head "number "

168+16:25 tight glyph ^-

169+16:28 aura @ud

170+16:32 lit 1

171+16:33 tight str-tail ""

172+17:1 NEWLINE

173+17:1 glyph ++

174+17:4 name generic-atom

175+17:17 glyph |=

176+17:20 name n

177+17:21 tight glyph =

178+17:22 tight tvar A

179+18:3 INDENT

180+18:3 glyph ~&

181+18:6 glyph ^-

182+18:9 aura @

183+18:11 name n

184+19:5 INDENT

185+19:5 str-head ""

186+19:7 tight name n

187+19:8 tight str-tail ""

188+20:1 DEDENT

189+20:1 DEDENT

190+20:1 NEWLINE

191+20:1 glyph ++

192+20:4 name fixed-first

193+20:16 glyph |=

194+20:19 name n

195+21:3 INDENT

196+21:3 glyph ~&

197+21:6 glyph ^-

198+21:9 aura @ud

199+21:13 name n

200+22:5 INDENT

201+22:5 str-head ""

202+22:7 tight name n

203+22:8 tight str-tail ""

204+23:1 DEDENT

205+23:1 DEDENT

206+23:1 NEWLINE

207+23:1 glyph ++

208+23:4 name fixed-later

209+23:16 glyph |=

210+23:19 name n

211+24:3 INDENT

212+24:3 glyph ~&

213+24:6 str-head ""

214+24:8 tight name n

215+24:9 tight str-tail ""

216+25:5 INDENT

217+25:5 glyph ^-

218+25:8 aura @ud

219+25:12 name n

220+26:1 DEDENT

221+26:1 DEDENT

222+26:1 NEWLINE

223+26:1 glyph ++

224+26:4 name explicit-force

225+26:19 glyph |=

226+26:22 name x

227+26:23 tight glyph =

228+26:24 tight tvar A

229+26:26 str-head ""

230+26:28 tight glyph ^-

231+26:31 aura @ud

232+26:35 name x

233+26:36 tight str-tail ""

234+27:1 NEWLINE

235+27:1 glyph ++

236+27:4 name clash

237+27:10 glyph |=

238+27:13 glyph [

239+27:14 tight name x

240+27:15 tight glyph =

241+27:16 tight aura @t

242+27:19 name y

243+27:20 tight glyph =

244+27:21 tight aura @p

245+27:23 tight glyph ]

246+27:25 str-head ""

247+27:27 tight name x

248+27:28 tight str-mid " "

249+27:31 tight glyph ^-

250+27:34 aura @t

251+27:37 name y

252+27:38 tight str-tail ""

253+28:1 NEWLINE

254+28:1 glyph ++

255+28:4 name invalid-expression

256+28:23 str-head ""

257+28:25 tight name missing

258+28:32 tight str-tail ""

259+28:34 NEWLINE

tests/golden/types-string-interpolation/tree.txtnew file+109

@@ -0,0 +1,109 @@

1+(module

2+ (value 1:1 render

3+ (gate 1:11

4+ (cell 1:14

5+ (face 1:15 day (aura 1:19 @da))

6+ (face 1:23 n (aura 1:25 @ud))

7+ (face 1:29 ship (aura 1:34 @p))

8+ (face 1:37 words (aura 1:43 @t)))

9+ (str 1:47 "Updated " (wing 1:57 day) ": " (wing 1:64 n) " by " (wing 1:71 ship) ", " (wing 1:79 words))))

10+ (value 2:1 bare

11+ (gate 2:9

12+ (face 2:12 x (aura 2:14 @))

13+ (str 2:16 (wing 2:18 x))))

14+ (value 3:1 repeat

15+ (gate 3:11

16+ (face 3:14 n (aura 3:16 @ud))

17+ (str 3:20 (wing 3:22 n) " then " (wing 3:31 n))))

18+ (value 4:1 nested

19+ (gate 4:11

20+ (face 4:14 x (aura 4:16 @t))

21+ (str 4:19

22+ (group 4:21

23+ (call 4:22 (wing 4:22 same) (wing 4:27 x))))))

24+ (value 5:1 record

25+ (gate 5:11

26+ (face 5:14 x

27+ (cell 5:16 (aura 5:17 @t) (aura 5:20 @ud)))

28+ (str 5:25 (wing 5:27 x))))

29+ (value 6:1 gate

30+ (gate 6:9

31+ (face 6:12 x

32+ (fn 6:14 (aura 6:17 @t) (aura 6:20 @t)))

33+ (str 6:24 (wing 6:26 x))))

34+ (value 7:1 generic

35+ (gate 7:12

36+ (face 7:15 x (tvar 7:17 A))

37+ (str 7:19 (wing 7:21 x))))

38+ (value 8:1 unknown

39+ (gate 8:12

40+ (bind 8:15 x)

41+ (str 8:17 (wing 8:19 x))))

42+ (value 9:1 pending

43+ (gate 9:12

44+ (face 9:15 x (aura 9:17 @t))

45+ (str 9:20 (lit 9:22 %orphan))))

46+ (value 10:1 other-pending

47+ (gate 10:18

48+ (face 10:21 x (aura 10:23 @t))

49+ (body 11:3

50+ (trace 11:3

51+ (lit 11:6 %orphan)

52+ (body 12:5

53+ (str 12:5 (wing 12:7 x)))))))

54+ (value 13:1 tape

55+ (gate 13:9

56+ (face 13:12 x

57+ (apply 13:14 list (aura 13:20 @tD)))

58+ (str 13:25 (wing 13:27 x))))

59+ (value 14:1 non-tape

60+ (gate 14:13

61+ (face 14:16 x

62+ (apply 14:18 list (aura 14:24 @t)))

63+ (str 14:28 (wing 14:30 x))))

64+ (value 15:1 number

65+ (str 15:11 "number " (lit 15:20 1)))

66+ (value 16:1 number-cast

67+ (str 16:16

68+ "number "

69+ (cast 16:25 (aura 16:28 @ud) (lit 16:32 1))))

70+ (value 17:1 generic-atom

71+ (gate 17:17

72+ (face 17:20 n (tvar 17:22 A))

73+ (body 18:3

74+ (trace 18:3

75+ (cast 18:6 (aura 18:9 @) (wing 18:11 n))

76+ (body 19:5

77+ (str 19:5 (wing 19:7 n)))))))

78+ (value 20:1 fixed-first

79+ (gate 20:16

80+ (bind 20:19 n)

81+ (body 21:3

82+ (trace 21:3

83+ (cast 21:6 (aura 21:9 @ud) (wing 21:13 n))

84+ (body 22:5

85+ (str 22:5 (wing 22:7 n)))))))

86+ (value 23:1 fixed-later

87+ (gate 23:16

88+ (bind 23:19 n)

89+ (body 24:3

90+ (trace 24:3

91+ (str 24:6 (wing 24:8 n))

92+ (body 25:5

93+ (cast 25:5 (aura 25:8 @ud) (wing 25:12 n)))))))

94+ (value 26:1 explicit-force

95+ (gate 26:19

96+ (face 26:22 x (tvar 26:24 A))

97+ (str 26:26

98+ (cast 26:28 (aura 26:31 @ud) (wing 26:35 x)))))

99+ (value 27:1 clash

100+ (gate 27:10

101+ (cell 27:13

102+ (face 27:14 x (aura 27:16 @t))

103+ (face 27:19 y (aura 27:21 @p)))

104+ (str 27:25

105+ (wing 27:27 x)

106+ " "

107+ (cast 27:31 (aura 27:34 @t) (wing 27:37 y)))))

108+ (value 28:1 invalid-expression

109+ (str 28:23 (wing 28:25 missing))))

tests/golden/types-string-interpolation/types.txtnew file+33

@@ -0,0 +1,33 @@

1+partial inference; module not checked

2+++ render: $-([day=@da [n=@ud [ship=@p words=@t]]] @t)

3+++ bare: $-(@ @t)

4+++ repeat: $-(@ud @t)

5+++ nested: $-(@t @t)

6+++ record: a cell in interpolation needs a printer

7+/tests/golden/types-string-interpolation/source.jibb:5:27: cell without a printer

8+++ record |= x=[@t @ud] "{x}"

9+ ^

10+++ gate: interpolation type needs unsupported inference

11+++ generic: interpolation type needs unsupported inference

12+++ unknown: interpolation type needs unsupported inference

13+++ pending: interpolation type needs unsupported inference

14+++ other-pending: tag needs context in partial inference

15+++ tape: $-((list @tD) @t)

16+++ non-tape: interpolation type needs unsupported inference

17+++ number: @t

18+++ number-cast: @t

19+++ generic-atom: a generic atom in interpolation needs an aura

20+/tests/golden/types-string-interpolation/source.jibb:19:7: atom with a generic aura

21+ "{n}"

22+ ^

23+++ fixed-first: $-(@ud @t)

24+++ fixed-later: interpolation type needs unsupported inference

25+++ explicit-force: explicit capital constraints are not supported by partial inference

26+++ clash: cast mold and expression type do not unify

27+/tests/golden/types-string-interpolation/source.jibb:27:34: cast mold has type @t

28+++ clash |= [x=@t y=@p] "{x} {^- @t y}"

29+ ^

30+/tests/golden/types-string-interpolation/source.jibb:27:37: expression has type @p

31+++ clash |= [x=@t y=@p] "{x} {^- @t y}"

32+ ^

33+++ invalid-expression: name is not available to partial inference

tests/lib/jibb.hoon+139−133

@@ -1712,115 +1712,119 @@

1712/* tok-490 %txt /tests/golden/types-recursive-sample/tokens/txt

1713/* tre-490 %txt /tests/golden/types-recursive-sample/tree/txt

1714/* typ-490 %txt /tests/golden/types-recursive-sample/types/txt

1715−/* src-491 %jibb /tests/golden/types-union-alias/source/jibb

1715+/* src-491 %jibb /tests/golden/types-string-interpolation/source/jibb

1716+/* tok-491 %txt /tests/golden/types-string-interpolation/tokens/txt

1717+/* tre-491 %txt /tests/golden/types-string-interpolation/tree/txt

1718+/* typ-491 %txt /tests/golden/types-string-interpolation/types/txt

1719+/* src-492 %jibb /tests/golden/types-union-alias/source/jibb

1716−/* tok-491 %txt /tests/golden/types-union-alias/tokens/txt

1720+/* tok-492 %txt /tests/golden/types-union-alias/tokens/txt

1717−/* tre-491 %txt /tests/golden/types-union-alias/tree/txt

1721+/* tre-492 %txt /tests/golden/types-union-alias/tree/txt

1718−/* typ-491 %txt /tests/golden/types-union-alias/types/txt

1722+/* typ-492 %txt /tests/golden/types-union-alias/types/txt

1719−/* src-492 %jibb /tests/golden/types-union-branch-context/source/jibb

1723+/* src-493 %jibb /tests/golden/types-union-branch-context/source/jibb

1720−/* tok-492 %txt /tests/golden/types-union-branch-context/tokens/txt

1724+/* tok-493 %txt /tests/golden/types-union-branch-context/tokens/txt

1721−/* tre-492 %txt /tests/golden/types-union-branch-context/tree/txt

1725+/* tre-493 %txt /tests/golden/types-union-branch-context/tree/txt

1722−/* typ-492 %txt /tests/golden/types-union-branch-context/types/txt

1726+/* typ-493 %txt /tests/golden/types-union-branch-context/types/txt

1723−/* src-493 %jibb /tests/golden/types-union-branch-pending/source/jibb

1727+/* src-494 %jibb /tests/golden/types-union-branch-pending/source/jibb

1724−/* tok-493 %txt /tests/golden/types-union-branch-pending/tokens/txt

1728+/* tok-494 %txt /tests/golden/types-union-branch-pending/tokens/txt

1725−/* tre-493 %txt /tests/golden/types-union-branch-pending/tree/txt

1729+/* tre-494 %txt /tests/golden/types-union-branch-pending/tree/txt

1726−/* typ-493 %txt /tests/golden/types-union-branch-pending/types/txt

1730+/* typ-494 %txt /tests/golden/types-union-branch-pending/types/txt

1727−/* src-494 %jibb /tests/golden/types-union-constructor-shape/source/jibb

1731+/* src-495 %jibb /tests/golden/types-union-constructor-shape/source/jibb

1728−/* tok-494 %txt /tests/golden/types-union-constructor-shape/tokens/txt

1732+/* tok-495 %txt /tests/golden/types-union-constructor-shape/tokens/txt

1729−/* tre-494 %txt /tests/golden/types-union-constructor-shape/tree/txt

1733+/* tre-495 %txt /tests/golden/types-union-constructor-shape/tree/txt

1730−/* typ-494 %txt /tests/golden/types-union-constructor-shape/types/txt

1734+/* typ-495 %txt /tests/golden/types-union-constructor-shape/types/txt

1731−/* src-495 %jibb /tests/golden/types-union-context-flow/source/jibb

1735+/* src-496 %jibb /tests/golden/types-union-context-flow/source/jibb

1732−/* tok-495 %txt /tests/golden/types-union-context-flow/tokens/txt

1736+/* tok-496 %txt /tests/golden/types-union-context-flow/tokens/txt

1733−/* tre-495 %txt /tests/golden/types-union-context-flow/tree/txt

1737+/* tre-496 %txt /tests/golden/types-union-context-flow/tree/txt

1734−/* typ-495 %txt /tests/golden/types-union-context-flow/types/txt

1738+/* typ-496 %txt /tests/golden/types-union-context-flow/types/txt

1735−/* src-496 %jibb /tests/golden/types-union-import/source/jibb

1739+/* src-497 %jibb /tests/golden/types-union-import/source/jibb

1736−/* tok-496 %txt /tests/golden/types-union-import/tokens/txt

1740+/* tok-497 %txt /tests/golden/types-union-import/tokens/txt

1737−/* tre-496 %txt /tests/golden/types-union-import/tree/txt

1741+/* tre-497 %txt /tests/golden/types-union-import/tree/txt

1738−/* mod-496-1 %jibb /tests/golden/types-union-import/modules/ui/lib/jibb

1742+/* mod-497-1 %jibb /tests/golden/types-union-import/modules/ui/lib/jibb

1739−/* typ-496 %txt /tests/golden/types-union-import/types/txt

1743+/* typ-497 %txt /tests/golden/types-union-import/types/txt

1740−/* mtre-496 %txt /tests/golden/types-union-import/module-trees/txt

1744+/* mtre-497 %txt /tests/golden/types-union-import/module-trees/txt

1741−/* src-497 %jibb /tests/golden/types-union-local-pending/source/jibb

1745+/* src-498 %jibb /tests/golden/types-union-local-pending/source/jibb

1742−/* tok-497 %txt /tests/golden/types-union-local-pending/tokens/txt

1746+/* tok-498 %txt /tests/golden/types-union-local-pending/tokens/txt

1743−/* tre-497 %txt /tests/golden/types-union-local-pending/tree/txt

1747+/* tre-498 %txt /tests/golden/types-union-local-pending/tree/txt

1744−/* typ-497 %txt /tests/golden/types-union-local-pending/types/txt

1748+/* typ-498 %txt /tests/golden/types-union-local-pending/types/txt

1745−/* src-498 %jibb /tests/golden/types-union-overlap/source/jibb

1749+/* src-499 %jibb /tests/golden/types-union-overlap/source/jibb

1746−/* tok-498 %txt /tests/golden/types-union-overlap/tokens/txt

1750+/* tok-499 %txt /tests/golden/types-union-overlap/tokens/txt

1747−/* tre-498 %txt /tests/golden/types-union-overlap/tree/txt

1751+/* tre-499 %txt /tests/golden/types-union-overlap/tree/txt

1748−/* typ-498 %txt /tests/golden/types-union-overlap/types/txt

1752+/* typ-499 %txt /tests/golden/types-union-overlap/types/txt

1749−/* src-499 %jibb /tests/golden/types-union-overlap-nested/source/jibb

1753+/* src-500 %jibb /tests/golden/types-union-overlap-nested/source/jibb

1750−/* tok-499 %txt /tests/golden/types-union-overlap-nested/tokens/txt

1754+/* tok-500 %txt /tests/golden/types-union-overlap-nested/tokens/txt

1751−/* tre-499 %txt /tests/golden/types-union-overlap-nested/tree/txt

1755+/* tre-500 %txt /tests/golden/types-union-overlap-nested/tree/txt

1752−/* typ-499 %txt /tests/golden/types-union-overlap-nested/types/txt

1756+/* typ-500 %txt /tests/golden/types-union-overlap-nested/types/txt

1753−/* src-500 %jibb /tests/golden/types-union-phantom-generic/source/jibb

1757+/* src-501 %jibb /tests/golden/types-union-phantom-generic/source/jibb

1754−/* tok-500 %txt /tests/golden/types-union-phantom-generic/tokens/txt

1758+/* tok-501 %txt /tests/golden/types-union-phantom-generic/tokens/txt

1755−/* tre-500 %txt /tests/golden/types-union-phantom-generic/tree/txt

1759+/* tre-501 %txt /tests/golden/types-union-phantom-generic/tree/txt

1756−/* typ-500 %txt /tests/golden/types-union-phantom-generic/types/txt

1760+/* typ-501 %txt /tests/golden/types-union-phantom-generic/types/txt

1757−/* src-501 %jibb /tests/golden/types-union-print-cross-namespace/source/jibb

1761+/* src-502 %jibb /tests/golden/types-union-print-cross-namespace/source/jibb

1758−/* tok-501 %txt /tests/golden/types-union-print-cross-namespace/tokens/txt

1762+/* tok-502 %txt /tests/golden/types-union-print-cross-namespace/tokens/txt

1759−/* tre-501 %txt /tests/golden/types-union-print-cross-namespace/tree/txt

1763+/* tre-502 %txt /tests/golden/types-union-print-cross-namespace/tree/txt

1760−/* mod-501-1 %jibb /tests/golden/types-union-print-cross-namespace/modules/ui/lib/jibb

1764+/* mod-502-1 %jibb /tests/golden/types-union-print-cross-namespace/modules/ui/lib/jibb

1761−/* typ-501 %txt /tests/golden/types-union-print-cross-namespace/types/txt

1765+/* typ-502 %txt /tests/golden/types-union-print-cross-namespace/types/txt

1762−/* mtre-501 %txt /tests/golden/types-union-print-cross-namespace/module-trees/txt

1766+/* mtre-502 %txt /tests/golden/types-union-print-cross-namespace/module-trees/txt

1763−/* src-502 %jibb /tests/golden/types-union-print-distinct/source/jibb

1767+/* src-503 %jibb /tests/golden/types-union-print-distinct/source/jibb

1764−/* tok-502 %txt /tests/golden/types-union-print-distinct/tokens/txt

1768+/* tok-503 %txt /tests/golden/types-union-print-distinct/tokens/txt

1765−/* tre-502 %txt /tests/golden/types-union-print-distinct/tree/txt

1769+/* tre-503 %txt /tests/golden/types-union-print-distinct/tree/txt

1766−/* mod-502-1 %jibb /tests/golden/types-union-print-distinct/modules/ui/left/jibb

1770+/* mod-503-1 %jibb /tests/golden/types-union-print-distinct/modules/ui/left/jibb

1767−/* mod-502-2 %jibb /tests/golden/types-union-print-distinct/modules/ui/right/jibb

1771+/* mod-503-2 %jibb /tests/golden/types-union-print-distinct/modules/ui/right/jibb

1768−/* mod-502-3 %jibb /tests/golden/types-union-print-distinct/modules/ui/twin/jibb

1772+/* mod-503-3 %jibb /tests/golden/types-union-print-distinct/modules/ui/twin/jibb

1769−/* typ-502 %txt /tests/golden/types-union-print-distinct/types/txt

1773+/* typ-503 %txt /tests/golden/types-union-print-distinct/types/txt

1770−/* mtre-502 %txt /tests/golden/types-union-print-distinct/module-trees/txt

1774+/* mtre-503 %txt /tests/golden/types-union-print-distinct/module-trees/txt

1771−/* src-503 %jibb /tests/golden/types-union-print-escape/source/jibb

1775+/* src-504 %jibb /tests/golden/types-union-print-escape/source/jibb

1772−/* tok-503 %txt /tests/golden/types-union-print-escape/tokens/txt

1776+/* tok-504 %txt /tests/golden/types-union-print-escape/tokens/txt

1773−/* tre-503 %txt /tests/golden/types-union-print-escape/tree/txt

1777+/* tre-504 %txt /tests/golden/types-union-print-escape/tree/txt

1774−/* typ-503 %txt /tests/golden/types-union-print-escape/types/txt

1778+/* typ-504 %txt /tests/golden/types-union-print-escape/types/txt

1775−/* src-504 %jibb /tests/golden/types-union-print-local/source/jibb

1779+/* src-505 %jibb /tests/golden/types-union-print-local/source/jibb

1776−/* tok-504 %txt /tests/golden/types-union-print-local/tokens/txt

1780+/* tok-505 %txt /tests/golden/types-union-print-local/tokens/txt

1777−/* tre-504 %txt /tests/golden/types-union-print-local/tree/txt

1781+/* tre-505 %txt /tests/golden/types-union-print-local/tree/txt

1778−/* typ-504 %txt /tests/golden/types-union-print-local/types/txt

1782+/* typ-505 %txt /tests/golden/types-union-print-local/types/txt

1779−/* src-505 %jibb /tests/golden/types-union-print-nested/source/jibb

1783+/* src-506 %jibb /tests/golden/types-union-print-nested/source/jibb

1780−/* tok-505 %txt /tests/golden/types-union-print-nested/tokens/txt

1784+/* tok-506 %txt /tests/golden/types-union-print-nested/tokens/txt

1781−/* tre-505 %txt /tests/golden/types-union-print-nested/tree/txt

1785+/* tre-506 %txt /tests/golden/types-union-print-nested/tree/txt

1782−/* typ-505 %txt /tests/golden/types-union-print-nested/types/txt

1786+/* typ-506 %txt /tests/golden/types-union-print-nested/types/txt

1783−/* src-506 %jibb /tests/golden/types-union-print-same-origin/source/jibb

1787+/* src-507 %jibb /tests/golden/types-union-print-same-origin/source/jibb

1784−/* tok-506 %txt /tests/golden/types-union-print-same-origin/tokens/txt

1788+/* tok-507 %txt /tests/golden/types-union-print-same-origin/tokens/txt

1785−/* tre-506 %txt /tests/golden/types-union-print-same-origin/tree/txt

1789+/* tre-507 %txt /tests/golden/types-union-print-same-origin/tree/txt

1786−/* mod-506-1 %jibb /tests/golden/types-union-print-same-origin/modules/ui/shared/jibb

1790+/* mod-507-1 %jibb /tests/golden/types-union-print-same-origin/modules/ui/shared/jibb

1787−/* typ-506 %txt /tests/golden/types-union-print-same-origin/types/txt

1791+/* typ-507 %txt /tests/golden/types-union-print-same-origin/types/txt

1788−/* mtre-506 %txt /tests/golden/types-union-print-same-origin/module-trees/txt

1792+/* mtre-507 %txt /tests/golden/types-union-print-same-origin/module-trees/txt

1789−/* src-507 %jibb /tests/golden/types-union-print-transitive/source/jibb

1793+/* src-508 %jibb /tests/golden/types-union-print-transitive/source/jibb

1790−/* tok-507 %txt /tests/golden/types-union-print-transitive/tokens/txt

1794+/* tok-508 %txt /tests/golden/types-union-print-transitive/tokens/txt

1791−/* tre-507 %txt /tests/golden/types-union-print-transitive/tree/txt

1795+/* tre-508 %txt /tests/golden/types-union-print-transitive/tree/txt

1792−/* mod-507-1 %jibb /tests/golden/types-union-print-transitive/modules/ui/mid/jibb

1796+/* mod-508-1 %jibb /tests/golden/types-union-print-transitive/modules/ui/mid/jibb

1793−/* mod-507-2 %jibb /tests/golden/types-union-print-transitive/modules/ui/base/jibb

1797+/* mod-508-2 %jibb /tests/golden/types-union-print-transitive/modules/ui/base/jibb

1794−/* typ-507 %txt /tests/golden/types-union-print-transitive/types/txt

1798+/* typ-508 %txt /tests/golden/types-union-print-transitive/types/txt

1795−/* mtre-507 %txt /tests/golden/types-union-print-transitive/module-trees/txt

1799+/* mtre-508 %txt /tests/golden/types-union-print-transitive/module-trees/txt

1796−/* src-508 %jibb /tests/golden/types-union-singleton/source/jibb

1800+/* src-509 %jibb /tests/golden/types-union-singleton/source/jibb

1797−/* tok-508 %txt /tests/golden/types-union-singleton/tokens/txt

1801+/* tok-509 %txt /tests/golden/types-union-singleton/tokens/txt

1798−/* tre-508 %txt /tests/golden/types-union-singleton/tree/txt

1802+/* tre-509 %txt /tests/golden/types-union-singleton/tree/txt

1799−/* typ-508 %txt /tests/golden/types-union-singleton/types/txt

1803+/* typ-509 %txt /tests/golden/types-union-singleton/types/txt

1800−/* src-509 %jibb /tests/golden/types-union-tag-atoms/source/jibb

1804+/* src-510 %jibb /tests/golden/types-union-tag-atoms/source/jibb

1801−/* tok-509 %txt /tests/golden/types-union-tag-atoms/tokens/txt

1805+/* tok-510 %txt /tests/golden/types-union-tag-atoms/tokens/txt

1802−/* tre-509 %txt /tests/golden/types-union-tag-atoms/tree/txt

1806+/* tre-510 %txt /tests/golden/types-union-tag-atoms/tree/txt

1803−/* typ-509 %txt /tests/golden/types-union-tag-atoms/types/txt

1807+/* typ-510 %txt /tests/golden/types-union-tag-atoms/types/txt

1804−/* src-510 %jibb /tests/golden/types-union-tags/source/jibb

1808+/* src-511 %jibb /tests/golden/types-union-tags/source/jibb

1805−/* tok-510 %txt /tests/golden/types-union-tags/tokens/txt

1809+/* tok-511 %txt /tests/golden/types-union-tags/tokens/txt

1806−/* tre-510 %txt /tests/golden/types-union-tags/tree/txt

1810+/* tre-511 %txt /tests/golden/types-union-tags/tree/txt

1807−/* typ-510 %txt /tests/golden/types-union-tags/types/txt

1811+/* typ-511 %txt /tests/golden/types-union-tags/types/txt

1808−/* src-511 %jibb /tests/golden/types-union-unresolved/source/jibb

1812+/* src-512 %jibb /tests/golden/types-union-unresolved/source/jibb

1809−/* tok-511 %txt /tests/golden/types-union-unresolved/tokens/txt

1813+/* tok-512 %txt /tests/golden/types-union-unresolved/tokens/txt

1810−/* tre-511 %txt /tests/golden/types-union-unresolved/tree/txt

1814+/* tre-512 %txt /tests/golden/types-union-unresolved/tree/txt

1811−/* typ-511 %txt /tests/golden/types-union-unresolved/types/txt

1815+/* typ-512 %txt /tests/golden/types-union-unresolved/types/txt

1812−/* src-512 %jibb /tests/golden/types-union-unresolved-flow/source/jibb

1816+/* src-513 %jibb /tests/golden/types-union-unresolved-flow/source/jibb

1813−/* tok-512 %txt /tests/golden/types-union-unresolved-flow/tokens/txt

1817+/* tok-513 %txt /tests/golden/types-union-unresolved-flow/tokens/txt

1814−/* tre-512 %txt /tests/golden/types-union-unresolved-flow/tree/txt

1818+/* tre-513 %txt /tests/golden/types-union-unresolved-flow/tree/txt

1815−/* typ-512 %txt /tests/golden/types-union-unresolved-flow/types/txt

1819+/* typ-513 %txt /tests/golden/types-union-unresolved-flow/types/txt

1816−/* src-513 %jibb /tests/golden/types-unit-context/source/jibb

1820+/* src-514 %jibb /tests/golden/types-unit-context/source/jibb

1817−/* tok-513 %txt /tests/golden/types-unit-context/tokens/txt

1821+/* tok-514 %txt /tests/golden/types-unit-context/tokens/txt

1818−/* tre-513 %txt /tests/golden/types-unit-context/tree/txt

1822+/* tre-514 %txt /tests/golden/types-unit-context/tree/txt

1819−/* typ-513 %txt /tests/golden/types-unit-context/types/txt

1823+/* typ-514 %txt /tests/golden/types-unit-context/types/txt

1820−/* src-514 %jibb /tests/golden/types-unit-patterns/source/jibb

1824+/* src-515 %jibb /tests/golden/types-unit-patterns/source/jibb

1821−/* tok-514 %txt /tests/golden/types-unit-patterns/tokens/txt

1825+/* tok-515 %txt /tests/golden/types-unit-patterns/tokens/txt

1822−/* tre-514 %txt /tests/golden/types-unit-patterns/tree/txt

1826+/* tre-515 %txt /tests/golden/types-unit-patterns/tree/txt

1823−/* typ-514 %txt /tests/golden/types-unit-patterns/types/txt

1827+/* typ-515 %txt /tests/golden/types-unit-patterns/types/txt

1824=/ prepared-prelude (prepare-prelude:jibb prelude-source)

1828=/ prepared-prelude (prepare-prelude:jibb prelude-source)

1825|%

1829|%

1826:: one arm per case

1830:: one arm per case

@@ -2805,54 +2809,56 @@

2805 (weld (check ~.types-recursive-gate src-489 `tok-489 `tre-489) (check-types ~.types-recursive-gate ~[%tests %golden ~.types-recursive-gate %source %jibb] src-489 `typ-489))

2809 (weld (check ~.types-recursive-gate src-489 `tok-489 `tre-489) (check-types ~.types-recursive-gate ~[%tests %golden ~.types-recursive-gate %source %jibb] src-489 `typ-489))

2806++ test-types-recursive-sample

2810++ test-types-recursive-sample

2807 (weld (check ~.types-recursive-sample src-490 `tok-490 `tre-490) (check-types ~.types-recursive-sample ~[%tests %golden ~.types-recursive-sample %source %jibb] src-490 `typ-490))

2811 (weld (check ~.types-recursive-sample src-490 `tok-490 `tre-490) (check-types ~.types-recursive-sample ~[%tests %golden ~.types-recursive-sample %source %jibb] src-490 `typ-490))

2812+++ test-types-string-interpolation

2813+ (weld (check ~.types-string-interpolation src-491 `tok-491 `tre-491) (check-module-types ~.types-string-interpolation ~[%tests %golden ~.types-string-interpolation %source %jibb] src-491 `typ-491 ~ ~ ~))

2808++ test-types-union-alias

2814++ test-types-union-alias

2809− (weld (check ~.types-union-alias src-491 `tok-491 `tre-491) (check-types ~.types-union-alias ~[%tests %golden ~.types-union-alias %source %jibb] src-491 `typ-491))

2815+ (weld (check ~.types-union-alias src-492 `tok-492 `tre-492) (check-types ~.types-union-alias ~[%tests %golden ~.types-union-alias %source %jibb] src-492 `typ-492))

2810++ test-types-union-branch-context

2816++ test-types-union-branch-context

2811− (weld (check ~.types-union-branch-context src-492 `tok-492 `tre-492) (check-types ~.types-union-branch-context ~[%tests %golden ~.types-union-branch-context %source %jibb] src-492 `typ-492))

2817+ (weld (check ~.types-union-branch-context src-493 `tok-493 `tre-493) (check-types ~.types-union-branch-context ~[%tests %golden ~.types-union-branch-context %source %jibb] src-493 `typ-493))

2812++ test-types-union-branch-pending

2818++ test-types-union-branch-pending

2813− (weld (check ~.types-union-branch-pending src-493 `tok-493 `tre-493) (check-types ~.types-union-branch-pending ~[%tests %golden ~.types-union-branch-pending %source %jibb] src-493 `typ-493))

2819+ (weld (check ~.types-union-branch-pending src-494 `tok-494 `tre-494) (check-types ~.types-union-branch-pending ~[%tests %golden ~.types-union-branch-pending %source %jibb] src-494 `typ-494))

2814++ test-types-union-constructor-shape

2820++ test-types-union-constructor-shape

2815− (weld (check ~.types-union-constructor-shape src-494 `tok-494 `tre-494) (check-types ~.types-union-constructor-shape ~[%tests %golden ~.types-union-constructor-shape %source %jibb] src-494 `typ-494))

2821+ (weld (check ~.types-union-constructor-shape src-495 `tok-495 `tre-495) (check-types ~.types-union-constructor-shape ~[%tests %golden ~.types-union-constructor-shape %source %jibb] src-495 `typ-495))

2816++ test-types-union-context-flow

2822++ test-types-union-context-flow

2817− (weld (check ~.types-union-context-flow src-495 `tok-495 `tre-495) (check-types ~.types-union-context-flow ~[%tests %golden ~.types-union-context-flow %source %jibb] src-495 `typ-495))

2823+ (weld (check ~.types-union-context-flow src-496 `tok-496 `tre-496) (check-types ~.types-union-context-flow ~[%tests %golden ~.types-union-context-flow %source %jibb] src-496 `typ-496))

2818++ test-types-union-import

2824++ test-types-union-import

2819− (weld (weld (check ~.types-union-import src-496 `tok-496 `tre-496) (check-module-types ~.types-union-import ~[%tests %golden ~.types-union-import %source %jibb] src-496 `typ-496 ~ ~ ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-496-1]])) (check-module-trees ~.types-union-import `mtre-496 ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-496-1]]))

2825+ (weld (weld (check ~.types-union-import src-497 `tok-497 `tre-497) (check-module-types ~.types-union-import ~[%tests %golden ~.types-union-import %source %jibb] src-497 `typ-497 ~ ~ ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-497-1]])) (check-module-trees ~.types-union-import `mtre-497 ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-497-1]]))

2820++ test-types-union-local-pending

2826++ test-types-union-local-pending

2821− (weld (check ~.types-union-local-pending src-497 `tok-497 `tre-497) (check-types ~.types-union-local-pending ~[%tests %golden ~.types-union-local-pending %source %jibb] src-497 `typ-497))

2827+ (weld (check ~.types-union-local-pending src-498 `tok-498 `tre-498) (check-types ~.types-union-local-pending ~[%tests %golden ~.types-union-local-pending %source %jibb] src-498 `typ-498))

2822++ test-types-union-overlap

2828++ test-types-union-overlap

2823− (weld (check ~.types-union-overlap src-498 `tok-498 `tre-498) (check-types ~.types-union-overlap ~[%tests %golden ~.types-union-overlap %source %jibb] src-498 `typ-498))

2829+ (weld (check ~.types-union-overlap src-499 `tok-499 `tre-499) (check-types ~.types-union-overlap ~[%tests %golden ~.types-union-overlap %source %jibb] src-499 `typ-499))

2824++ test-types-union-overlap-nested

2830++ test-types-union-overlap-nested

2825− (weld (check ~.types-union-overlap-nested src-499 `tok-499 `tre-499) (check-types ~.types-union-overlap-nested ~[%tests %golden ~.types-union-overlap-nested %source %jibb] src-499 `typ-499))

2831+ (weld (check ~.types-union-overlap-nested src-500 `tok-500 `tre-500) (check-types ~.types-union-overlap-nested ~[%tests %golden ~.types-union-overlap-nested %source %jibb] src-500 `typ-500))

2826++ test-types-union-phantom-generic

2832++ test-types-union-phantom-generic

2827− (weld (check ~.types-union-phantom-generic src-500 `tok-500 `tre-500) (check-types ~.types-union-phantom-generic ~[%tests %golden ~.types-union-phantom-generic %source %jibb] src-500 `typ-500))

2833+ (weld (check ~.types-union-phantom-generic src-501 `tok-501 `tre-501) (check-types ~.types-union-phantom-generic ~[%tests %golden ~.types-union-phantom-generic %source %jibb] src-501 `typ-501))

2828++ test-types-union-print-cross-namespace

2834++ test-types-union-print-cross-namespace

2829− (weld (weld (check ~.types-union-print-cross-namespace src-501 `tok-501 `tre-501) (check-module-types ~.types-union-print-cross-namespace ~[%tests %golden ~.types-union-print-cross-namespace %source %jibb] src-501 `typ-501 ~ ~ ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-501-1]])) (check-module-trees ~.types-union-print-cross-namespace `mtre-501 ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-501-1]]))

2835+ (weld (weld (check ~.types-union-print-cross-namespace src-502 `tok-502 `tre-502) (check-module-types ~.types-union-print-cross-namespace ~[%tests %golden ~.types-union-print-cross-namespace %source %jibb] src-502 `typ-502 ~ ~ ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-502-1]])) (check-module-trees ~.types-union-print-cross-namespace `mtre-502 ~[['/ui/lib.jibb' ~[~.ui ~.lib ~.jibb] mod-502-1]]))

2830++ test-types-union-print-distinct

2836++ test-types-union-print-distinct

2831− (weld (weld (check ~.types-union-print-distinct src-502 `tok-502 `tre-502) (check-module-types ~.types-union-print-distinct ~[%tests %golden ~.types-union-print-distinct %source %jibb] src-502 `typ-502 ~ ~ ~[['/ui/left.jibb' ~[~.ui ~.left ~.jibb] mod-502-1] ['/ui/right.jibb' ~[~.ui ~.right ~.jibb] mod-502-2] ['/ui/twin.jibb' ~[~.ui ~.twin ~.jibb] mod-502-3]])) (check-module-trees ~.types-union-print-distinct `mtre-502 ~[['/ui/left.jibb' ~[~.ui ~.left ~.jibb] mod-502-1] ['/ui/right.jibb' ~[~.ui ~.right ~.jibb] mod-502-2] ['/ui/twin.jibb' ~[~.ui ~.twin ~.jibb] mod-502-3]]))

2837+ (weld (weld (check ~.types-union-print-distinct src-503 `tok-503 `tre-503) (check-module-types ~.types-union-print-distinct ~[%tests %golden ~.types-union-print-distinct %source %jibb] src-503 `typ-503 ~ ~ ~[['/ui/left.jibb' ~[~.ui ~.left ~.jibb] mod-503-1] ['/ui/right.jibb' ~[~.ui ~.right ~.jibb] mod-503-2] ['/ui/twin.jibb' ~[~.ui ~.twin ~.jibb] mod-503-3]])) (check-module-trees ~.types-union-print-distinct `mtre-503 ~[['/ui/left.jibb' ~[~.ui ~.left ~.jibb] mod-503-1] ['/ui/right.jibb' ~[~.ui ~.right ~.jibb] mod-503-2] ['/ui/twin.jibb' ~[~.ui ~.twin ~.jibb] mod-503-3]]))

2832++ test-types-union-print-escape

2838++ test-types-union-print-escape

2833− (weld (check ~.types-union-print-escape src-503 `tok-503 `tre-503) (check-types ~.types-union-print-escape ~[%tests %golden ~.types-union-print-escape %source %jibb] src-503 `typ-503))

2839+ (weld (check ~.types-union-print-escape src-504 `tok-504 `tre-504) (check-types ~.types-union-print-escape ~[%tests %golden ~.types-union-print-escape %source %jibb] src-504 `typ-504))

2834++ test-types-union-print-local

2840++ test-types-union-print-local

2835− (weld (check ~.types-union-print-local src-504 `tok-504 `tre-504) (check-types ~.types-union-print-local ~[%tests %golden ~.types-union-print-local %source %jibb] src-504 `typ-504))

2841+ (weld (check ~.types-union-print-local src-505 `tok-505 `tre-505) (check-types ~.types-union-print-local ~[%tests %golden ~.types-union-print-local %source %jibb] src-505 `typ-505))

2836++ test-types-union-print-nested

2842++ test-types-union-print-nested

2837− (weld (check ~.types-union-print-nested src-505 `tok-505 `tre-505) (check-types ~.types-union-print-nested ~[%tests %golden ~.types-union-print-nested %source %jibb] src-505 `typ-505))

2843+ (weld (check ~.types-union-print-nested src-506 `tok-506 `tre-506) (check-types ~.types-union-print-nested ~[%tests %golden ~.types-union-print-nested %source %jibb] src-506 `typ-506))

2838++ test-types-union-print-same-origin

2844++ test-types-union-print-same-origin

2839− (weld (weld (check ~.types-union-print-same-origin src-506 `tok-506 `tre-506) (check-module-types ~.types-union-print-same-origin ~[%tests %golden ~.types-union-print-same-origin %source %jibb] src-506 `typ-506 ~ ~ ~[['/ui/shared.jibb' ~[~.ui ~.shared ~.jibb] mod-506-1]])) (check-module-trees ~.types-union-print-same-origin `mtre-506 ~[['/ui/shared.jibb' ~[~.ui ~.shared ~.jibb] mod-506-1]]))

2845+ (weld (weld (check ~.types-union-print-same-origin src-507 `tok-507 `tre-507) (check-module-types ~.types-union-print-same-origin ~[%tests %golden ~.types-union-print-same-origin %source %jibb] src-507 `typ-507 ~ ~ ~[['/ui/shared.jibb' ~[~.ui ~.shared ~.jibb] mod-507-1]])) (check-module-trees ~.types-union-print-same-origin `mtre-507 ~[['/ui/shared.jibb' ~[~.ui ~.shared ~.jibb] mod-507-1]]))

2840++ test-types-union-print-transitive

2846++ test-types-union-print-transitive

2841− (weld (weld (check ~.types-union-print-transitive src-507 `tok-507 `tre-507) (check-module-types ~.types-union-print-transitive ~[%tests %golden ~.types-union-print-transitive %source %jibb] src-507 `typ-507 ~ ~ ~[['/ui/mid.jibb' ~[~.ui ~.mid ~.jibb] mod-507-1] ['/ui/base.jibb' ~[~.ui ~.base ~.jibb] mod-507-2]])) (check-module-trees ~.types-union-print-transitive `mtre-507 ~[['/ui/mid.jibb' ~[~.ui ~.mid ~.jibb] mod-507-1] ['/ui/base.jibb' ~[~.ui ~.base ~.jibb] mod-507-2]]))

2847+ (weld (weld (check ~.types-union-print-transitive src-508 `tok-508 `tre-508) (check-module-types ~.types-union-print-transitive ~[%tests %golden ~.types-union-print-transitive %source %jibb] src-508 `typ-508 ~ ~ ~[['/ui/mid.jibb' ~[~.ui ~.mid ~.jibb] mod-508-1] ['/ui/base.jibb' ~[~.ui ~.base ~.jibb] mod-508-2]])) (check-module-trees ~.types-union-print-transitive `mtre-508 ~[['/ui/mid.jibb' ~[~.ui ~.mid ~.jibb] mod-508-1] ['/ui/base.jibb' ~[~.ui ~.base ~.jibb] mod-508-2]]))

2842++ test-types-union-singleton

2848++ test-types-union-singleton

2843− (weld (check ~.types-union-singleton src-508 `tok-508 `tre-508) (check-types ~.types-union-singleton ~[%tests %golden ~.types-union-singleton %source %jibb] src-508 `typ-508))

2849+ (weld (check ~.types-union-singleton src-509 `tok-509 `tre-509) (check-types ~.types-union-singleton ~[%tests %golden ~.types-union-singleton %source %jibb] src-509 `typ-509))

2844++ test-types-union-tag-atoms

2850++ test-types-union-tag-atoms

2845− (weld (check ~.types-union-tag-atoms src-509 `tok-509 `tre-509) (check-types ~.types-union-tag-atoms ~[%tests %golden ~.types-union-tag-atoms %source %jibb] src-509 `typ-509))

2851+ (weld (check ~.types-union-tag-atoms src-510 `tok-510 `tre-510) (check-types ~.types-union-tag-atoms ~[%tests %golden ~.types-union-tag-atoms %source %jibb] src-510 `typ-510))

2846++ test-types-union-tags

2852++ test-types-union-tags

2847− (weld (check ~.types-union-tags src-510 `tok-510 `tre-510) (check-types ~.types-union-tags ~[%tests %golden ~.types-union-tags %source %jibb] src-510 `typ-510))

2853+ (weld (check ~.types-union-tags src-511 `tok-511 `tre-511) (check-types ~.types-union-tags ~[%tests %golden ~.types-union-tags %source %jibb] src-511 `typ-511))

2848++ test-types-union-unresolved

2854++ test-types-union-unresolved

2849− (weld (check ~.types-union-unresolved src-511 `tok-511 `tre-511) (check-types ~.types-union-unresolved ~[%tests %golden ~.types-union-unresolved %source %jibb] src-511 `typ-511))

2855+ (weld (check ~.types-union-unresolved src-512 `tok-512 `tre-512) (check-types ~.types-union-unresolved ~[%tests %golden ~.types-union-unresolved %source %jibb] src-512 `typ-512))

2850++ test-types-union-unresolved-flow

2856++ test-types-union-unresolved-flow

2851− (weld (check ~.types-union-unresolved-flow src-512 `tok-512 `tre-512) (check-types ~.types-union-unresolved-flow ~[%tests %golden ~.types-union-unresolved-flow %source %jibb] src-512 `typ-512))

2857+ (weld (check ~.types-union-unresolved-flow src-513 `tok-513 `tre-513) (check-types ~.types-union-unresolved-flow ~[%tests %golden ~.types-union-unresolved-flow %source %jibb] src-513 `typ-513))

2852++ test-types-unit-context

2858++ test-types-unit-context

2853− (weld (check ~.types-unit-context src-513 `tok-513 `tre-513) (check-types ~.types-unit-context ~[%tests %golden ~.types-unit-context %source %jibb] src-513 `typ-513))

2859+ (weld (check ~.types-unit-context src-514 `tok-514 `tre-514) (check-types ~.types-unit-context ~[%tests %golden ~.types-unit-context %source %jibb] src-514 `typ-514))

2854++ test-types-unit-patterns

2860++ test-types-unit-patterns

2855− (weld (check ~.types-unit-patterns src-514 `tok-514 `tre-514) (check-types ~.types-unit-patterns ~[%tests %golden ~.types-unit-patterns %source %jibb] src-514 `typ-514))

2861+ (weld (check ~.types-unit-patterns src-515 `tok-515 `tre-515) (check-types ~.types-unit-patterns ~[%tests %golden ~.types-unit-patterns %source %jibb] src-515 `typ-515))

2856::

2862::

2857:: +check: run golden:jibb on a case and compare both outputs

2863:: +check: run golden:jibb on a case and compare both outputs

2858::

2864::