Merge + update mono tests

FAQ.md

@@ -96,7 +96,7 @@ circulate about how to unlock those speed boosts. If Roc had this feature, it's
 piece of advice would eventually circulate: "don't use this feature because it slows down your builds."
 
 If a feature exists in a language, but the common recommendation is never to use it, that's cause for reconsidering
-whether the feature should be in the language at all. In the case of this feature, I think it's simpler if the
+whether the feature should be in the language at all. In the case of this feature, it's simpler if the
 language doesn't have it; that way nobody has to learn (or spend time spreading the word) about the
 performance-boosting advice not to use it.
 
@@ -148,7 +148,7 @@ On a historical note, `Maybe` may have been thought of as a substitute for null
 
 ## Why doesn't Roc have higher-kinded polymorphism or arbitrary-rank types?
 
-_Since this is a FAQ answer, I'm going to assume familiarity with higher-kinded types and higher-rank types instead of including a primer on them._
+_Since this is a FAQ answer, it assumes familiarity with higher-kinded types and higher-rank types instead of including a primer on them._
 
 A valuable aspect of Roc's type system is that it has decidable [principal](https://en.wikipedia.org/wiki/Principal_type)
 type inference. This means that:
@@ -162,34 +162,33 @@ would be unable to infer a type—and you'd have to write a type annotation. Thi
 situations where the editor would not be able to reliably tell you the type of part of your program, unlike today
 where it can accurately tell you the type of anything, even if you have no type annotations in your entire code base.
 
-assuming that's right, here is a proposed new FAQ entry:
+This is one factor that higher-rank and higher-kinded types have in common. There are other factors which are specific
+to each.
 
 ### Higher-rank types
 
-Roc uses a Rank-1 type system. Other languages, like Haskell, support Rank-2 or even arbitrary-rank (aka "Rank-N") types. Supporting higher-rank types in Roc has been discussed before, but it has several important downsides:
+Supporting higher-rank types in Roc has been discussed before, but it has several important downsides:
 
-- It would remove principal decidable type inference. (Only Rank-1 types are compatible with principal decidable type inference; Rank-2 types are decidable but the inferred types are not principal, and Rank 3+ types are not even fully decidable.)
 - It would increase the complexity of the language.
 - It would make some compiler error messages more confusing (e.g. they might mention `forall` because that was the most general type that could be inferred, even if that wasn't helpful or related to the actual problem).
 - It would substantially increase the complexity of the type checker, which would necessarily slow it down.
-- Most significantly, it would make the runtime slower, because Roc compiles programs by fully specializing all function calls to their type instances (this is sometimes called monomorphization). It's unclear how we could fully specialize programs containing Rank-2 types, which means compiling programs that included Rank-2 types (or higher) would require losing specialization in general—which would substantially degrade runtime performance.
+- It would make some Roc programs run significantly more slowly. Roc compiles programs by [monomorphizing](https://en.wikipedia.org/wiki/Monomorphization), and it's unclear how we could fully monomorphize programs containing Rank-2 types. This means compiling programs which include Rank-2 types (or higher) would require sacrificing monomorphization, which would substantially degrade runtime performance.
 
 As such, the plan is for Roc to stick with Rank-1 types indefinitely.
 
 ### Higher-kinded polymorphism
 
-I want to be really clear about this one: the explicit plan is that Roc will never support higher-kinded polymorphism.
+The explicit plan is that Roc will never support higher-kinded polymorphism.
 
-On the technical side, the reasons for this are ordinary: I understand the practical benefits and
+On the technical side, the reasons for this are ordinary: like any language feature, HKP has both benefits and drawbacks,
-drawbacks of HKP, and I think the drawbacks outweigh the benefits when it comes to Roc. (Those who come to a
+and in the context of Roc, the drawbacks seem to outweigh the benefits. (Those who come to a different conclusion may
-different conclusion may think HKP's drawbacks would be less of a big a deal in Roc than I do. That's reasonable;
+think HKP's drawbacks would be less of a big a deal in Roc. That's reasonable; we programmers often weigh the same
-we programmers often weigh the same trade-offs differently.) To be clear, I think this in the specific context of
+trade-offs differently.) To be clear, this analysis of HKP is in the specific context of Roc; there are plenty of
-Roc; there are plenty of other languages where HKP seems like a great fit. For example, it's hard to imagine Haskell
+other languages where HKP seems like a great fit. For example, it's hard to imagine Haskell without it. Similarly,
-without it. Similarly, I think lifetime annotations are a great fit for Rust, but don't think they'd be right
+lifetime annotations might be a natural fit for Rust, but they wouldn't be a good fit for Roc either.
-for Roc either.
 
-I also think it's important to consider the cultural implications of deciding whether or not to support HKP.
+It's also important to consider the cultural implications of deciding whether or not to support HKP.
-To illustrate what I mean, imagine this conversation:
+To illustrate these implications, imagine this conversation:
 
 **Programmer 1:** "How do you feel about higher-kinded polymorphism?"
 
@@ -199,9 +198,9 @@ To illustrate what I mean, imagine this conversation:
 
 **Programmer 2:** "OH NO."
 
-I've had several variations of this conversation: I'm talking about higher-kinded types,
+For some, this conversation does not require imagining, because it's so familiar: higher-kinded types come up in
-another programmer asks what that means, I give monads as an example, and their reaction is strongly negative.
+conversation, another programmer asks what that means, monads are given as an example, and their reaction is
-I've also had plenty of conversations with programmers who love HKP and vigorously advocate for its addition
+strongly negative. On the flip side, plenty of programmers love HKP and vigorously advocate for its addition
 to languages they use which don't have it. Feelings about HKP seem strongly divided, maybe more so
 than any other type system feature besides static and dynamic types.
 
@@ -211,67 +210,28 @@ language will inevitably follow. If the language does support HKP, one or more a
 around monads will inevitably follow, along with corresponding cultural changes. (See Scala for example.)
 Culturally, to support HKP is to take a side, and to decline to support it is also to take a side.
 
-Given this, language designers have three options:
+Given this, languages have three options:
 
 - Have HKP and have Monad in the standard library. Embrace them and build a culture and ecosystem around them.
 - Have HKP and don't have Monad in the standard library. An alternate standard library built around monads will inevitably emerge, and both the community and ecosystem will divide themselves along pro-monad and anti-monad lines.
 - Don't have HKP; build a culture and ecosystem around other things.
 
-Considering that these are the only three options, I think the best choice for Roc—not only on a technical
+Considering that these are the only three options, an early decision in Roc's design—not only on a technical
-level, but on a cultural level as well—is to make it clear that the plan is for Roc never to support HKP.
+level, but on a cultural level as well—was to make it clear that the plan is for Roc never to support HKP.
-I hope this clarity can save a lot of community members' time that would otherwise be spent on advocacy or
+The hope is that this clarity can save a lot of community members' time that would otherwise be spent on advocacy or
-arguing between the two sides of the divide. Again, I think it's completely reasonable for anyone to have a
+arguing between the two sides of the divide. Again, it's completely reasonable for anyone to have a different preference,
-different preference, but given that language designers can only choose one of these options, I'm confident
+but given that languages can only choose one of these options, it seems clear that the right choice for Roc
-I've made the right choice for Roc by designing it never to have higher-kinded polymorphism.
+is for it to never have higher-kinded polymorphism.
-
-## Why do Roc's syntax and standard library differ from Elm's?
-
-Roc is a direct descendant of [Elm](https://elm-lang.org/). However, there are some differences between the two languages.
-
-Syntactic differences are among these. This is a feature, not a bug; if Roc had identical syntax to Elm, then it's
-predictable that people would write code that was designed to work in both languages - and would then rely on
-that being true, for example by making a package which advertised "Works in both Elm and Roc!" This in turn
-would mean that later if either language were to change its syntax in a way that didn't make sense for the other,
-the result would be broken code and sadness.
-
-So why does Roc have the specific syntax changes it does? Here are some brief explanations:
-
-- `#` instead of `--` for comments - this allows [hashbang](https://senthilnayagan.medium.com/shebang-hashbang-10966b8f28a8)s to work without needing special syntax. That isn't a use case Elm supports, but it is one Roc is designed to support.
-- `{}` instead of `()` for the unit type - Elm has both, and they can both be used as a unit type. Since `{}` has other uses in the type system, but `()` doesn't, I consider it redundant and took it out.
-- `when`...`is` instead of `case`...`of` - I predict it will be easier for beginners to pick up, because usually the way I explain `case`...`of` to beginners is by saying the words "when" and "is" out loud - e.g. "when `color` is `Red`, it runs this first branch; when `color` is `Blue`, it runs this other branch..."
-- `:` instead of `=` for record field definitions (e.g. `{ foo: bar }` where Elm syntax would be `{ foo = bar }`): I like `=` being reserved for definitions, and `:` is the most popular alternative.
-- Backpassing syntax - since Roc is designed to be used for use cases like command-line apps, shell scripts, and servers, I expect chained effects to come up a lot more often than they do in Elm. I think backpassing is nice for those use cases, similarly to how `do` notation is nice for them in Haskell.
-- Tag unions instead of Elm's custom types (aka algebraic data types). This isn't just a syntactic change; tag unions are mainly in Roc because they can facilitate errors being accumulated across chained effects, which (as noted a moment ago) I expect to be a lot more common in Roc than in Elm. If you have tag unions, you don't really need a separate language feature for algebraic data types, since closed tag unions essentially work the same way - aside from not giving you a way to selectively expose variants or define phantom types. Roc's opaque types language feature covers those use cases instead.
-- No `::` operator, or `::` pattern matching for lists. Both of these are for the same reason: an Elm `List` is a linked list, so both prepending to it and removing an element from the front are very cheap operations. In contrast, a Roc `List` is a flat array, so both prepending to it and removing an element from the front are among the most expensive operations you can possibly do with it! To get good performance, this usage pattern should be encouraged in Elm and discouraged in Roc. Since having special syntax would encourage it, it would not be good for Roc to have that syntax!
-- No `<|` operator. In Elm, I almost exclusively found myself wanting to use this in conjunction with anonymous functions (e.g. `foo <| \bar -> ...`) or conditionals (e.g. `foo <| if bar then ...`). In Roc you can do both of these without the `<|`. That means the main remaining use for `<|` is to reduce parentheses, but I tend to think `|>` is better at that (or else the parens are fine), so after the other syntactic changes, I considered `<|` an unnecessary stylistic alternative to `|>` or parens.
-- The `|>` operator passes the expression before the `|>` as the _first_ argument to the function after the `|>` instead of as the last argument. See the section on currying for details on why this works this way.
-- `:` instead of `type alias` - I like to avoid reserved keywords for terms that are desirable in userspace, so that people don't have to name things `typ` because `type` is a reserved keyword, or `clazz` because `class` is reserved. (I couldn't think of satisfactory alternatives for `as`, `when`, `is`, or `if` other than different reserved keywords. I could see an argument for `then`—and maybe even `is`—being replaced with a `->` or `=>` or something, but I don't anticipate missing either of those words much in userspace. `then` is used in JavaScript promises, but I think there are several better names for that function.)
-- No underscores in variable names - I've seen Elm beginners reflexively use `snake_case` over `camelCase` and then need to un-learn the habit after the compiler accepted it. I'd rather have the compiler give feedback that this isn't the way to do it in Roc, and suggest a camelCase alternative. I've also seen underscores used for lazy naming, e.g. `foo` and then `foo_`. If lazy naming is the goal, `foo2` is just as concise as `foo_`, but `foo3` is more concise than `foo__`. So in a way, removing `_` is a forcing function for improved laziness. (Of course, more descriptive naming would be even better.) Acronyms also use camelCase despite being capitalized in English, eg. `xmlHttpRequest` for a variable and `XmlHttpRequest` for a type. Each word starts with a capital letter, so if acronyms are only capitals it's harder to see where the words start. eg. `XMLHTTPRequest` is less clear than `XmlHttpRequest`, unless you already know the acronyms.
-- Trailing commas - I've seen people walk away (in some cases physically!) from Elm as soon as they saw the leading commas in collection literals. While I think they've made a mistake by not pushing past this aesthetic preference to give the language a chance, I also would prefer not put them in a position to make such a mistake in the first place. Secondarily, while I'm personally fine with either style, between the two I prefer the look of trailing commas.
-- The `!` unary prefix operator. I didn't want to have a `Basics` module (more on that in a moment), and without `Basics`, this would either need to be called fully-qualified (`Bool.not`) or else a module import of `Bool.{ not }` would be necessary. Both seemed less nice than supporting the `!` prefix that's common to so many widely-used languages, especially when we already have a unary prefix operator of `-` for negation (e.g. `-x`).
-- `!=` for the inequality operator (instead of Elm's `/=`) - this one pairs more naturally with the `!` prefix operator and is also very common in other languages.
-
-Roc also has a different standard library from Elm. Some of the differences come down to platforms and applications (e.g. having `Task` in Roc's standard library wouldn't make sense), but others do not. Here are some brief explanations:
-
-- No `Basics` module. I wanted to have a simple rule of "all modules in the standard library are imported by default, and so are their exposed types," and that's it. Given that I wanted the comparison operators (e.g. `<`) to work only on numbers, it ended up that having `Num` and `Bool` modules meant that almost nothing would be left for a `Basics` equivalent in Roc except `identity` and `Never`. The Roc type `[]` (empty tag union) is equivalent to `Never`, so that wasn't necessary, and I generally think that `identity` is a good concept but a sign of an incomplete API whenever its use comes up in practice. For example, instead of calling `|> List.filterMap identity` I'd rather have access to a more self-descriptive function like `|> List.dropNothings`. With `Num` and `Bool`, and without `identity` and `Never`, there was nothing left in `Basics`.
-- `Str` instead of `String` - after using the `str` type in Rust, I realized I had no issue whatsoever with the more concise name, especially since it was used in so many places (similar to `Msg` and `Cmd` in Elm) - so I decided to save a couple of letters.
-- No function composition operators - I stopped using these in Elm so long ago, at one point I forgot they were in the language! See the FAQ entry on currying for details about why.
-- No `Char`. What most people think of as a "character" is a rendered glyph. However, rendered glyphs are comprised of [grapheme clusters](https://stackoverflow.com/a/27331885), which are a variable number of Unicode code points - and there's no upper bound on how many code points there can be in a single cluster. In a world of emoji, I think this makes `Char` error-prone and it's better to have `Str` be the only first-class unit. For convenience when working with unicode code points (e.g. for performance-critical tasks like parsing), the single-quote syntax is sugar for the corresponding `U32` code point - for example, writing `'鹏'` is exactly the same as writing `40527`. Like Rust, you get a compiler error if you put something in single quotes that's not a valid [Unicode scalar value](http://www.unicode.org/glossary/#unicode_scalar_value).
-- No `Maybe`. See the "Why doesn't Roc have a `Maybe`/`Option`/`Optional` type" FAQ question
 
 ## Why aren't Roc functions curried by default?
 
 Although technically any language with first-class functions makes it possible to curry
-any function (e.g. I can manually curry a Roc function `\x, y, z ->` by writing `\x -> \y -> \z ->` instead),
+any function (e.g. anyone can manually curry a Roc function `\x, y, z ->` by writing `\x -> \y -> \z ->` instead),
 typically what people mean when they say Roc isn't a curried language is that Roc functions aren't curried
-by default. For the rest of this section, I'll use "currying" as a shorthand for "functions that are curried
+by default. The rest of this section will use "currying" as a shorthand for "functions that are curried
 by default" for the sake of brevity.
 
-As I see it, currying has one major upside and several major downsides. The upside:
+Currying makes function calls more concise in some cases, but it has several significant downsides:
-
-- It makes function calls more concise in some cases.
-
-The downsides:
 
 - It lowers error message quality, because there can no longer be an error for "function called with too few arguments." (Calling a function with fewer arguments is always valid in curried functions; the error you get instead will unavoidably be some other sort of type mismatch, and it will be up to you to figure out that the real problem was that you forgot an argument.)
 - It makes the `|>` operator more error-prone in some cases.
@@ -280,10 +240,10 @@ The downsides:
 - It facilitates pointfree function composition. (More on why this is listed as a downside later.)
 
 There's also a downside that it would make runtime performance of compiled programs worse by default,
-but I assume it would be possible to optimize that away at the cost of slightly longer compile times.
+but it would most likely be possible to optimize that away at the cost of slightly longer compile times.
 
-I consider the one upside (conciseness in some places) extremely minor, and have almost never missed it in Roc.
+These downsides seem to outweigh the one upside (conciseness in some places). Here are some more details about each of
-Here are some more details about the downsides as I see them.
+the downsides.
 
 ### Currying and the `|>` operator
 
@@ -298,11 +258,17 @@ Str.concat "Hello, " "World!"
 |> Str.concat "World!"
 ```
 
-In curried languages with a `|>` operator, the first expression still returns `"Hello, World!"` but the second one returns `"World!Hello, "`. This is because Roc's `|>` operator uses the expression before the `|>` as the _first_ argument, whereas in curried languages, `|>` uses it as the _last_ argument.
+It's unsurprising to most beginners that these work the same way; it's common for a beginner who has recently learned
+how `|>` works to assume that `|> Str.concat "!"` would concatenate `!` onto the end of a string.
 
-(For example, this is how `|>` works in both [F#](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/#function-symbols-and-operators) and in [Elm](https://package.elm-lang.org/packages/elm/core/1.0.5/Basics#|%3E), both of which are curried languages. In contrast, Roc's `|>` design uses the same argument ordering as [Elixir](https://hexdocs.pm/elixir/1.14.0/Kernel.html#%7C%3E/2) and [Gleam](https://gleam.run/book/tour/functions.html#pipe-operator), neither of which is a curried language.)
+This is not how it works in curried languages, however. In curried languages with a `|>` operator, the first expression
+still returns `"Hello, World!"` but the second one returns `"World!Hello, "` instead. This can be an unpleasant surprise
+for beginners, but even experienced users commonly find that this behavior is less useful than having both of
+these expressions evaluate to the same thing.
 
-This comes up in other situations as well. For example, consider subtraction and division:
+In Roc, both expressions evaluate to the same thing because Roc's `|>` operator uses the expression before the `|>` as the _first_ argument, whereas in curried languages, `|>` uses it as the _last_ argument. For example, this is how `|>` works in both [F#](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/#function-symbols-and-operators) and in [Elm](https://package.elm-lang.org/packages/elm/core/1.0.5/Basics#|%3E), both of which are curried languages. In contrast, Roc's `|>` design uses the same argument ordering as [Elixir](https://hexdocs.pm/elixir/1.14.0/Kernel.html#%7C%3E/2) and [Gleam](https://gleam.run/book/tour/functions.html#pipe-operator), none of which are curried languages.
+
+This comes up in other situations besides string concatenation. For example, consider subtraction and division:
 
 ```elixir
 someNumber
@@ -314,11 +280,14 @@ someNumber
 |> Num.sub 1
 ```
 
-What do you expect these expressions to do?
+Again, it's reasonable to expect that `|> Num.div 2` will divide a number by 2, and that
+`|> Num.sub 1` will subtract 1 from a number. In Roc, this is how they work, but in
+curried languages they work the opposite way: `|> Num.div 2` takes the number 2 and
+divides it by a number, and `|> Num.sub 1` takes the number 1 and subtracts a number
+from it. This is once again both more surprising to beginners and less useful to
+experienced users.
 
-In Roc, the first  divides `someNumber` by 2 and the second one subtracts 1 from `someNumber`.  In languages where `|>` uses the other argument ordering, the first example instead takes 2 and divides it by `someNumber`, while the second takes 1 and subtracts `someNumber` from it. This was a pain point I ran into with curried languages, and I was pleasantly surprised that changing the argument ordering in `|>` addressed the pain point.
+The way `|>` works in Roc has a second benefit when it comes to higher-order functions. Consider these two examples:
-
-This style has a second benefit when it comes to higher-order functions. Consider these two examples:
 
 ```elixir
 answer = List.map numbers \num ->
@@ -361,29 +330,33 @@ answer =
         numbers
 ```
 
-This was also a pain point I'd encountered in curried languages. I prefer the way the former example reads, but that style doesn't work with the argument order that currying encourages for higher-order functions like `List.map`. (Prior to using curried languages, I'd used [CoffeeScript](https://coffeescript.org/) in a functional style with [`_.map`](https://underscorejs.org/#map), and was disappointed to realize that I could no longer use the enjoyable style of `answer = _.map numbers (num) -> …` as I had before. In Roc, this style works.)
+The Roc version of this is nicer in that it doesn't require parentheses around the function argument. A curried language
+could theoretically adopt Roc's style of `|>` (where it pipes in the first argument instead of the last argument), but
+to get this second benefit, the language would also need to have `List.map` take the function as its second argument
+instead of the first. However, this would work against currying's one upside; it would no longer work to write
+`(List.map negate)` if the `List.map` arguments were flipped, the way they are in Roc. So currying and `|>` are unavoidably
+in tension.
 
 As a historical note, these stylistic benefits (of `|> Num.sub 1` working as expected, and being able to write `List.map numbers \num ->`) were not among the original reasons Roc did not have currying. These benefits were discovered after the decision had already been made that Roc would not be a curried language, and they served to reinforce after the fact that the decision was the right one for Roc given the language's goals.
 
 ### Currying and learning curve
 
-Prior to designing Roc, I taught a lot of beginner [Elm](https://elm-lang.org/) workshops. Sometimes at
+Currying leads to function signatures that look surprising to beginners. For example, in Roc, the
-conferences, sometimes for [Frontend Masters](https://frontendmasters.com/courses/intro-elm/),
+[`Bool.and`](https://www.roc-lang.org/builtins/Bool#and) function has the type `Bool, Bool -> Bool`. If Roc were a
-sometimes for free at local coding bootcamps or meetup groups.
+curried language, this function would instead have the type `Bool -> Bool -> Bool`. Since no mainstream programming
-In total I've spent well over 100 hours standing in front of a class, introducing the students to their
+languages today are curried, anyone who knows a mainstream language and is learning their first curried language will
-first pure functional programming language.
+require additional explanation about why function types look this way.
 
-Here was my experience teaching currying:
+This explanation is nontrivial. It requires explaining partial application, how curried functions facilitate partial
+application, how function signatures accurately reflect that they're curried, and going through examples for all of these.
+All of it builds up to the punchline that "technically, all functions in this language have a single argument," which
+some percentage of learners find interesting, and some percentage still find confusing even after all that explanation.
 
-- The only way to avoid teaching it is to refuse to explain why multi-argument functions have multiple `->`s in them. (If you don't explain it, at least one student will ask about it - and many if not all of the others will wonder.)
+It's common for beginners to report that currying only "clicked" for them after spending significant time writing code
-- Teaching currying properly takes a solid chunk of time, because it requires explaining partial application, explaining how curried functions facilitate partial application, how function signatures accurately reflect that they're curried, and going through examples for all of these.
+in a curried language. This is not the end of the world, especially because it's easy enough to think "I still don't
-- Even after doing all this, and iterating on my approach each time to try to explain it more effectively than I had the time before, I'd estimate that under 50% of the class ended up actually understanding currying. I consistently heard that in practice it only "clicked" for most people after spending significantly more time writing code with it.
+totally get this even after that explanation, but I can remember that function arguments are separated by `->` in this
-
+language and maybe I'll understand the rest later." Clearly currying doesn't preclude a language from being easy to learn,
-This is not the end of the world, especially because it's easy enough to think "okay, I still don't totally get this
+because Elm has currying, and Elm's learning curve is famously gentle.
-even after that explanation, but I can remember that function arguments are separated by `->` in this language
-and maybe I'll understand the rest later." (Which they almost always do, if they stick with the language.)
-Clearly currying doesn't preclude a language from being easy to learn, because Elm has currying, and Elm's learning
-curve is famously gentle.
 
 That said, beginners who feel confused while learning the language are less likely to continue with it.
 And however easy Roc would be to learn if it had currying, the language is certainly easier to learn without it.
@@ -402,37 +375,26 @@ compose : (a -> b), (c -> a) -> (c -> b)
 compose = \f, g, x -> f (g x)
 ```
 
-Here's how I would instead write this:
+Here's a way to write it without pointfree function composition:
 
 ```elm
 reverseSort : List elem -> List elem
 reverseSort = \list -> List.reverse (List.sort list)
 ```
 
-I've consistently found that I can more quickly and accurately understand function definitions that use
+It's common for programmers to build a mental model of what `compose List.reverse List.sort` does by mentally
-named arguments, even though the code is longer. I suspect this is because I'm faster at reading than I am at
+translating it into `\list -> List.reverse (List.sort list)`. This extra mental translation step makes it take
-eta-expanding ( e.g. converting `List.sort` into `\l -> List.sort l` ). Whenever I read
+longer to read and to understand despite being technically more concise. In more complex examples (this
-the top version I end up needing to mentally eta-expand it into the bottom version.
+is among the tamest of pointfree function composition examples), the chances increase of making a mistake in
-In more complex examples (this is among the tamest pointfree function composition examples I've seen), I make
+the mental translation step, leading to a misundesrtanding of what the function is doing—which can cause bugs.
-a mistake in my mental eta-expansion, and misunderstand what the function is doing - which can cause bugs.
 
-I assumed I would get faster and more accurate at this over time. However, by now it's been about a decade
+Some languages place such a high value on conciseness that they would consider the conciceness upside to outweigh
-since I first learned about the technique, and I'm still slower and less accurate at reading code that uses
+these downsides, but Roc is not one of those languages. It's considered stylistically better in Roc to write the
-pointfree function composition (including if I wrote it - but even moreso if I didn't) than code written with
+second version above. Given this, since currying facilitates pointfree function composition, making Roc a curried
-with named arguments. I've asked a lot of other programmers about their experiences with pointfree function
+language would have the downside of facilitating an antipattern in the language.
-composition over the years, and the overwhelming majority of responses have been consistent with my experience.
-
-As such, my opinion about pointfree function composition has gotten less and less nuanced over time. I've now moved
-past "it's the right tool for the job, sometimes" to concluding it's best thought of as an antipattern. This is
-because I realized how much time I was spending evaluating on a case-by-case basis whether it might be the
-right fit for a given situation. The time spent on this analysis alone vastly outweighed the sum of all the
-benefits I got in the rare cases where I concluded it was a fit. So I've found the way to get the most out of
-pointfree function composition is to never even think about using it; every other strategy leads to a worse outcome.
-
-Currying facilitates the antipattern of pointfree function composition, which I view as a downside of currying.
 
 Stacking up all these downsides of currying against the one upside of making certain function calls more concise,
-I concluded that it would be a mistake to have it in Roc.
+it seems clear that Roc should not be a curried language.
 
 ## Will Roc ever have linear types, dependent types, refinement types, or uniqueness types?
 

crates/compiler/builtins/roc/Dict.roc

@@ -130,7 +130,7 @@ hashDict = \hasher, dict -> Hash.hashUnordered hasher (toList dict) List.walk
 ## ```
 ## emptyDict = Dict.empty {}
 ## ```
-empty : {} -> Dict k v where k implements Hash & Eq
+empty : {} -> Dict * *
 empty = \{} ->
     @Dict {
         metadata: List.repeat emptySlot 8,
@@ -151,12 +151,12 @@ capacity : Dict * * -> Nat
 capacity = \@Dict { dataIndices } ->
     cap = List.len dataIndices
 
-    cap - Num.shiftRightZfBy cap 3
+    Num.subWrap cap (Num.shiftRightZfBy cap 3)
 
 ## Return a dictionary with space allocated for a number of entries. This
 ## may provide a performance optimization if you know how many entries will be
 ## inserted.
-withCapacity : Nat -> Dict k v where k implements Hash & Eq
+withCapacity : Nat -> Dict * *
 withCapacity = \_ ->
     # TODO: power of 2 * 8 and actual implementation
     empty {}
@@ -401,7 +401,7 @@ insert = \@Dict { metadata, dataIndices, data, size }, key, value ->
                             metadata,
                             dataIndices,
                             data,
-                            size: size + 1,
+                            size: Num.addWrap size 1,
                         }
                     )
 
@@ -430,7 +430,7 @@ remove = \@Dict { metadata, dataIndices, data, size }, key ->
 
     when findIndexHelper metadata dataIndices data h2Key key probe 0 is
         Ok index ->
-            last = List.len data - 1
+            last = Num.subWrap (List.len data) 1
             dataIndex = listGetUnsafe dataIndices index
 
             if dataIndex == last then
@@ -438,7 +438,7 @@ remove = \@Dict { metadata, dataIndices, data, size }, key ->
                     metadata: List.set metadata index deletedSlot,
                     dataIndices,
                     data: List.dropLast data,
-                    size: size - 1,
+                    size: Num.subWrap size 1,
                 }
             else
                 swapAndUpdateDataIndex (@Dict { metadata, dataIndices, data, size }) index last
@@ -626,7 +626,7 @@ swapAndUpdateDataIndex = \@Dict { metadata, dataIndices, data, size }, removedIn
                 # Update index of swaped element.
                 dataIndices: List.set dataIndices index dataIndex,
                 data: nextData,
-                size: size - 1,
+                size: Num.subWrap size 1,
             }
 
         Err NotFound ->
@@ -701,7 +701,7 @@ maybeRehash = \@Dict { metadata, dataIndices, data, size } ->
     cap = List.len dataIndices
     maxLoadCap =
         # This is 7/8 * capacity, which is the max load factor.
-        cap - Num.shiftRightZfBy cap 3
+        Num.subWrap cap (Num.shiftRightZfBy cap 3)
 
     if size > maxLoadCap then
         rehash (@Dict { metadata, dataIndices, data, size })
@@ -737,7 +737,7 @@ rehashHelper = \dict, oldMetadata, oldDataIndices, oldData, index ->
                     # Empty or deleted data
                     dict
 
-            rehashHelper nextDict oldMetadata oldDataIndices oldData (index + 1)
+            rehashHelper nextDict oldMetadata oldDataIndices oldData (Num.addWrap index 1)
 
         Err OutOfBounds ->
             # Walked entire list, complete now.

crates/compiler/builtins/roc/Hash.roc

@@ -28,7 +28,7 @@ interface Hash
         Num.{ U8, U16, U32, U64, U128, I8, I16, I32, I64, I128, Nat, Dec },
     ]
 
-## A value that can hashed.
+## A value that can be hashed.
 Hash implements
     ## Hashes a value into a [Hasher].
     ## Note that [hash] does not produce a hash value itself; the hasher must be

crates/compiler/builtins/roc/List.roc

@@ -391,7 +391,7 @@ repeat = \value, count ->
 repeatHelp : a, Nat, List a -> List a
 repeatHelp = \value, count, accum ->
     if count > 0 then
-        repeatHelp value (count - 1) (List.appendUnsafe accum value)
+        repeatHelp value (Num.subWrap count 1) (List.appendUnsafe accum value)
     else
         accum
 
@@ -405,7 +405,7 @@ reverse = \list ->
 
 reverseHelp = \list, left, right ->
     if left < right then
-        reverseHelp (List.swap list left right) (left + 1) (right - 1)
+        reverseHelp (List.swap list left right) (Num.addWrap left 1) (Num.subWrap right 1)
     else
         list
 
@@ -418,9 +418,9 @@ reverseHelp = \list, left, right ->
 join : List (List a) -> List a
 join = \lists ->
     totalLength =
-        List.walk lists 0 (\state, list -> state + List.len list)
+        List.walk lists 0 (\state, list -> Num.addWrap state (List.len list))
 
-    List.walk lists (List.withCapacity totalLength) (\state, list -> List.concat state list)
+    List.walk lists (List.withCapacity totalLength) \state, list -> List.concat state list
 
 contains : List a, a -> Bool where a implements Eq
 contains = \list, needle ->
@@ -478,7 +478,7 @@ walkBackwardsHelp = \list, state, f, indexPlusOne ->
     if indexPlusOne == 0 then
         state
     else
-        index = indexPlusOne - 1
+        index = Num.subWrap indexPlusOne 1
         nextState = f state (getUnsafe list index)
 
         walkBackwardsHelp list nextState f index
@@ -590,9 +590,9 @@ keepIfHelp : List a, (a -> Bool), Nat, Nat, Nat -> List a
 keepIfHelp = \list, predicate, kept, index, length ->
     if index < length then
         if predicate (List.getUnsafe list index) then
-            keepIfHelp (List.swap list kept index) predicate (kept + 1) (index + 1) length
+            keepIfHelp (List.swap list kept index) predicate (Num.addWrap kept 1) (Num.addWrap index 1) length
         else
-            keepIfHelp list predicate kept (index + 1) length
+            keepIfHelp list predicate kept (Num.addWrap index 1) length
     else
         List.takeFirst list kept
 
@@ -619,7 +619,7 @@ countIf : List a, (a -> Bool) -> Nat
 countIf = \list, predicate ->
     walkState = \state, elem ->
         if predicate elem then
-            state + 1
+            Num.addWrap state 1
         else
             state
 
@@ -712,7 +712,7 @@ mapWithIndexHelp = \src, dest, func, index, length ->
         mappedElem = func elem index
         newDest = List.appendUnsafe dest mappedElem
 
-        mapWithIndexHelp src newDest func (index + 1) length
+        mapWithIndexHelp src newDest func (Num.addWrap index 1) length
     else
         dest
 
@@ -817,7 +817,7 @@ rangeLengthHelp = \accum, i, remaining, calcNext ->
     else
         when i is
             Ok val ->
-                rangeLengthHelp (List.appendUnsafe accum val) (calcNext val) (remaining - 1) calcNext
+                rangeLengthHelp (List.appendUnsafe accum val) (calcNext val) (Num.subWrap remaining 1) calcNext
 
             Err _ ->
                 # We went past the end of the numeric range and there is no next.
@@ -1036,7 +1036,7 @@ findFirstIndex = \list, matcher ->
         if matcher elem then
             Break index
         else
-            Continue (index + 1)
+            Continue (Num.addWrap index 1)
 
     when foundIndex is
         Break index -> Ok index
@@ -1048,10 +1048,12 @@ findFirstIndex = \list, matcher ->
 findLastIndex : List elem, (elem -> Bool) -> Result Nat [NotFound]
 findLastIndex = \list, matches ->
     foundIndex = List.iterateBackwards list (List.len list) \prevIndex, elem ->
+        answer = Num.subWrap prevIndex 1
+
         if matches elem then
-            Break (prevIndex - 1)
+            Break answer
         else
-            Continue (prevIndex - 1)
+            Continue answer
 
     when foundIndex is
         Break index -> Ok index
@@ -1137,7 +1139,7 @@ split = \elements, userSplitIndex ->
     length = List.len elements
     splitIndex = if length > userSplitIndex then userSplitIndex else length
     before = List.sublist elements { start: 0, len: splitIndex }
-    others = List.sublist elements { start: splitIndex, len: length - splitIndex }
+    others = List.sublist elements { start: splitIndex, len: Num.subWrap length splitIndex }
 
     { before, others }
 
@@ -1151,7 +1153,7 @@ splitFirst = \list, delimiter ->
     when List.findFirstIndex list (\elem -> elem == delimiter) is
         Ok index ->
             before = List.sublist list { start: 0, len: index }
-            after = List.sublist list { start: index + 1, len: List.len list - index - 1 }
+            after = List.sublist list { start: Num.addWrap index 1, len: Num.subWrap (List.len list) index |> Num.subWrap 1 }
 
             Ok { before, after }
 
@@ -1167,7 +1169,7 @@ splitLast = \list, delimiter ->
     when List.findLastIndex list (\elem -> elem == delimiter) is
         Ok index ->
             before = List.sublist list { start: 0, len: index }
-            after = List.sublist list { start: index + 1, len: List.len list - index - 1 }
+            after = List.sublist list { start: Num.addWrap index 1, len: Num.subWrap (List.len list) index |> Num.subWrap 1 }
 
             Ok { before, after }
 
@@ -1202,7 +1204,7 @@ walkTryHelp : List elem, state, (state, elem -> Result state err), Nat, Nat -> R
 walkTryHelp = \list, state, f, index, length ->
     if index < length then
         when f state (List.getUnsafe list index) is
-            Ok nextState -> walkTryHelp list nextState f (index + 1) length
+            Ok nextState -> walkTryHelp list nextState f (Num.addWrap index 1) length
             Err b -> Err b
     else
         Ok state
@@ -1217,7 +1219,7 @@ iterHelp : List elem, s, (s, elem -> [Continue s, Break b]), Nat, Nat -> [Contin
 iterHelp = \list, state, f, index, length ->
     if index < length then
         when f state (List.getUnsafe list index) is
-            Continue nextState -> iterHelp list nextState f (index + 1) length
+            Continue nextState -> iterHelp list nextState f (Num.addWrap index 1) length
             Break b -> Break b
     else
         Continue state
@@ -1232,7 +1234,7 @@ iterateBackwards = \list, init, func ->
 iterBackwardsHelp : List elem, s, (s, elem -> [Continue s, Break b]), Nat -> [Continue s, Break b]
 iterBackwardsHelp = \list, state, f, prevIndex ->
     if prevIndex > 0 then
-        index = prevIndex - 1
+        index = Num.subWrap prevIndex 1
 
         when f state (List.getUnsafe list index) is
             Continue nextState -> iterBackwardsHelp list nextState f index

crates/compiler/builtins/roc/Num.roc

@@ -540,7 +540,7 @@ bytesToU16 = \bytes, index ->
     # we need at least 1 more byte
     offset = 1
 
-    if index + offset < List.len bytes then
+    if Num.addSaturated index offset < List.len bytes then
         Ok (bytesToU16Lowlevel bytes index)
     else
         Err OutOfBounds
@@ -550,7 +550,7 @@ bytesToU32 = \bytes, index ->
     # we need at least 3 more bytes
     offset = 3
 
-    if index + offset < List.len bytes then
+    if Num.addSaturated index offset < List.len bytes then
         Ok (bytesToU32Lowlevel bytes index)
     else
         Err OutOfBounds
@@ -560,7 +560,7 @@ bytesToU64 = \bytes, index ->
     # we need at least 7 more bytes
     offset = 7
 
-    if index + offset < List.len bytes then
+    if Num.addSaturated index offset < List.len bytes then
         Ok (bytesToU64Lowlevel bytes index)
     else
         Err OutOfBounds
@@ -570,7 +570,7 @@ bytesToU128 = \bytes, index ->
     # we need at least 15 more bytes
     offset = 15
 
-    if index + offset < List.len bytes then
+    if Num.addSaturated index offset < List.len bytes then
         Ok (bytesToU128Lowlevel bytes index)
     else
         Err OutOfBounds

crates/compiler/builtins/roc/Set.roc

@@ -60,13 +60,13 @@ hashSet = \hasher, @Set inner -> Hash.hash hasher inner
 ##
 ## expect countValues == 0
 ## ```
-empty : {} -> Set k where k implements Hash & Eq
+empty : {} -> Set *
 empty = \{} -> @Set (Dict.empty {})
 
 ## Return a dictionary with space allocated for a number of entries. This
 ## may provide a performance optimization if you know how many entries will be
 ## inserted.
-withCapacity : Nat -> Set k where k implements Hash & Eq
+withCapacity : Nat -> Set *
 withCapacity = \cap ->
     @Set (Dict.withCapacity cap)
 

crates/compiler/builtins/roc/Str.roc

@@ -400,7 +400,7 @@ expect (Str.fromUtf8 [255]) |> Result.isErr
 ## ```
 fromUtf8Range : List U8, { start : Nat, count : Nat } -> Result Str [BadUtf8 Utf8ByteProblem Nat, OutOfBounds]
 fromUtf8Range = \bytes, config ->
-    if config.start + config.count <= List.len bytes then
+    if Num.addSaturated config.start config.count <= List.len bytes then
         result = fromUtf8RangeLowlevel bytes config.start config.count
 
         if result.cIsOk then
@@ -721,7 +721,7 @@ splitFirst = \haystack, needle ->
             remaining = Str.countUtf8Bytes haystack - Str.countUtf8Bytes needle - index
 
             before = Str.substringUnsafe haystack 0 index
-            after = Str.substringUnsafe haystack (index + Str.countUtf8Bytes needle) remaining
+            after = Str.substringUnsafe haystack (Num.addWrap index (Str.countUtf8Bytes needle)) remaining
 
             Ok { before, after }
 
@@ -757,7 +757,7 @@ firstMatchHelp = \haystack, needle, index, lastPossible ->
         if matchesAt haystack index needle then
             Some index
         else
-            firstMatchHelp haystack needle (index + 1) lastPossible
+            firstMatchHelp haystack needle (Num.addWrap index 1) lastPossible
     else
         None
 
@@ -775,7 +775,7 @@ splitLast = \haystack, needle ->
             remaining = Str.countUtf8Bytes haystack - Str.countUtf8Bytes needle - index
 
             before = Str.substringUnsafe haystack 0 index
-            after = Str.substringUnsafe haystack (index + Str.countUtf8Bytes needle) remaining
+            after = Str.substringUnsafe haystack (Num.addWrap index (Str.countUtf8Bytes needle)) remaining
 
             Ok { before, after }
 
@@ -820,7 +820,7 @@ matchesAt : Str, Nat, Str -> Bool
 matchesAt = \haystack, haystackIndex, needle ->
     haystackLength = Str.countUtf8Bytes haystack
     needleLength = Str.countUtf8Bytes needle
-    endIndex = min (haystackIndex + needleLength) haystackLength
+    endIndex = min (Num.addSaturated haystackIndex needleLength) haystackLength
 
     matchesAtHelp {
         haystack,
@@ -847,8 +847,8 @@ matchesAtHelp = \state ->
         doesRestMatch =
             matchesAtHelp
                 { state &
-                    haystackIndex: haystackIndex + 1,
+                    haystackIndex: Num.addWrap haystackIndex 1,
-                    needleIndex: needleIndex + 1,
+                    needleIndex: Num.addWrap needleIndex 1,
                 }
 
         doesThisMatch && doesRestMatch
@@ -871,7 +871,7 @@ walkUtf8WithIndexHelp = \string, state, step, index, length ->
         byte = Str.getUnsafe string index
         newState = step state byte index
 
-        walkUtf8WithIndexHelp string newState step (index + 1) length
+        walkUtf8WithIndexHelp string newState step (Num.addWrap index 1) length
     else
         state
 
@@ -892,7 +892,7 @@ walkUtf8Help = \str, state, step, index, length ->
         byte = Str.getUnsafe str index
         newState = step state byte
 
-        walkUtf8Help str newState step (index + 1) length
+        walkUtf8Help str newState step (Num.addWrap index 1) length
     else
         state
 
@@ -942,7 +942,7 @@ walkScalarsHelp = \string, state, step, index, length ->
         { scalar, bytesParsed } = getScalarUnsafe string index
         newState = step state scalar
 
-        walkScalarsHelp string newState step (index + bytesParsed) length
+        walkScalarsHelp string newState step (Num.addWrap index bytesParsed) length
     else
         state
 
@@ -970,7 +970,7 @@ walkScalarsUntilHelp = \string, state, step, index, length ->
 
         when step state scalar is
             Continue newState ->
-                walkScalarsUntilHelp string newState step (index + bytesParsed) length
+                walkScalarsUntilHelp string newState step (Num.addWrap index bytesParsed) length
 
             Break newState ->
                 newState

crates/compiler/load_internal/src/docs.rs

@@ -54,11 +54,30 @@ pub enum TypeAnnotation {
         fields: Vec<RecordField>,
         extension: Box<TypeAnnotation>,
     },
+    Tuple {
+        elems: Vec<TypeAnnotation>,
+        extension: Box<TypeAnnotation>,
+    },
     Ability {
         members: Vec<AbilityMember>,
     },
     Wildcard,
     NoTypeAnn,
+    Where {
+        ann: Box<TypeAnnotation>,
+        implements: Vec<ImplementsClause>,
+    },
+    As {
+        ann: Box<TypeAnnotation>,
+        name: String,
+        vars: Vec<String>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct ImplementsClause {
+    pub name: String,
+    pub abilities: Vec<TypeAnnotation>,
 }
 
 #[derive(Debug, Clone)]
@@ -540,7 +559,57 @@ fn type_to_docs(in_func_type_ann: bool, type_annotation: ast::TypeAnnotation) ->
             }
         }
         ast::TypeAnnotation::Wildcard => TypeAnnotation::Wildcard,
-        _ => NoTypeAnn,
+        ast::TypeAnnotation::As(loc_ann, _comments, type_header) => TypeAnnotation::As {
+            ann: Box::new(type_to_docs(in_func_type_ann, loc_ann.value)),
+            name: type_header.name.value.to_string(),
+            vars: type_header
+                .vars
+                .iter()
+                .filter_map(|loc_pattern| match loc_pattern.value {
+                    ast::Pattern::Identifier(ident) => Some(ident.to_string()),
+                    _ => None,
+                })
+                .collect(),
+        },
+        ast::TypeAnnotation::Tuple { elems, ext } => {
+            let mut doc_elems = Vec::new();
+
+            for loc_ann in elems.items {
+                doc_elems.push(type_to_docs(in_func_type_ann, loc_ann.value));
+            }
+
+            let extension = match ext {
+                None => NoTypeAnn,
+                Some(ext_type_ann) => type_to_docs(in_func_type_ann, ext_type_ann.value),
+            };
+
+            TypeAnnotation::Tuple {
+                elems: doc_elems,
+                extension: Box::new(extension),
+            }
+        }
+        ast::TypeAnnotation::Where(loc_ann, implements) => TypeAnnotation::Where {
+            ann: Box::new(type_to_docs(in_func_type_ann, loc_ann.value)),
+            implements: implements
+                .iter()
+                .map(|clause| {
+                    let abilities = clause
+                        .value
+                        .abilities
+                        .iter()
+                        .map(|ability| type_to_docs(in_func_type_ann, ability.value))
+                        .collect();
+
+                    ImplementsClause {
+                        name: clause.value.var.value.item().to_string(),
+                        abilities,
+                    }
+                })
+                .collect(),
+        },
+        ast::TypeAnnotation::Malformed(_) | ast::TypeAnnotation::Inferred => {
+            TypeAnnotation::NoTypeAnn
+        }
     }
 }
 

crates/compiler/parse/src/ast.rs

@@ -38,6 +38,13 @@ impl<'a, T> Spaced<'a, T> {
             }
         }
     }
+
+    pub fn item(&self) -> &T {
+        match self {
+            Spaced::Item(answer) => answer,
+            Spaced::SpaceBefore(next, _spaces) | Spaced::SpaceAfter(next, _spaces) => next.item(),
+        }
+    }
 }
 
 impl<'a, T: Debug> Debug for Spaced<'a, T> {

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -3,96 +3,96 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     ret Bool.24;
 
 procedure List.26 (List.159, List.160, List.161):
-    let List.536 : [C U64, C U64] = CallByName List.93 List.159 List.160 List.161;
+    let List.537 : [C U64, C U64] = CallByName List.93 List.159 List.160 List.161;
-    let List.539 : U8 = 1i64;
+    let List.540 : U8 = 1i64;
-    let List.540 : U8 = GetTagId List.536;
+    let List.541 : U8 = GetTagId List.537;
-    let List.541 : Int1 = lowlevel Eq List.539 List.540;
+    let List.542 : Int1 = lowlevel Eq List.540 List.541;
-    if List.541 then
+    if List.542 then
-        let List.162 : U64 = UnionAtIndex (Id 1) (Index 0) List.536;
+        let List.162 : U64 = UnionAtIndex (Id 1) (Index 0) List.537;
         ret List.162;
     else
-        let List.163 : U64 = UnionAtIndex (Id 0) (Index 0) List.536;
+        let List.163 : U64 = UnionAtIndex (Id 0) (Index 0) List.537;
         ret List.163;
 
 procedure List.29 (List.304, List.305):
-    let List.535 : U64 = CallByName List.6 List.304;
+    let List.536 : U64 = CallByName List.6 List.304;
-    let List.306 : U64 = CallByName Num.77 List.535 List.305;
+    let List.306 : U64 = CallByName Num.77 List.536 List.305;
-    let List.521 : List U8 = CallByName List.43 List.304 List.306;
+    let List.522 : List U8 = CallByName List.43 List.304 List.306;
-    ret List.521;
-
-procedure List.43 (List.302, List.303):
-    let List.533 : U64 = CallByName List.6 List.302;
-    let List.532 : U64 = CallByName Num.77 List.533 List.303;
-    let List.523 : {U64, U64} = Struct {List.303, List.532};
-    let List.522 : List U8 = CallByName List.49 List.302 List.523;
     ret List.522;
 
-procedure List.49 (List.376, List.377):
+procedure List.43 (List.302, List.303):
-    let List.530 : U64 = StructAtIndex 0 List.377;
+    let List.534 : U64 = CallByName List.6 List.302;
-    let List.531 : U64 = 0i64;
+    let List.533 : U64 = CallByName Num.77 List.534 List.303;
-    let List.528 : Int1 = CallByName Bool.11 List.530 List.531;
+    let List.524 : {U64, U64} = Struct {List.303, List.533};
-    if List.528 then
+    let List.523 : List U8 = CallByName List.49 List.302 List.524;
-        dec List.376;
+    ret List.523;
-        let List.529 : List U8 = Array [];
+
-        ret List.529;
+procedure List.49 (List.377, List.378):
+    let List.531 : U64 = StructAtIndex 0 List.378;
+    let List.532 : U64 = 0i64;
+    let List.529 : Int1 = CallByName Bool.11 List.531 List.532;
+    if List.529 then
+        dec List.377;
+        let List.530 : List U8 = Array [];
+        ret List.530;
     else
-        let List.525 : U64 = StructAtIndex 1 List.377;
+        let List.526 : U64 = StructAtIndex 1 List.378;
-        let List.526 : U64 = StructAtIndex 0 List.377;
+        let List.527 : U64 = StructAtIndex 0 List.378;
-        let List.524 : List U8 = CallByName List.72 List.376 List.525 List.526;
+        let List.525 : List U8 = CallByName List.72 List.377 List.526 List.527;
-        ret List.524;
+        ret List.525;
 
 procedure List.6 (#Attr.2):
-    let List.534 : U64 = lowlevel ListLen #Attr.2;
+    let List.535 : U64 = lowlevel ListLen #Attr.2;
-    ret List.534;
+    ret List.535;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.557 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.558 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.557;
+    ret List.558;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.527 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.528 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.527;
+    ret List.528;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.545 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.546 List.440 List.441 List.442 List.443 List.444:
-        let List.547 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.548 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.547 then
+        if List.548 then
-            let List.556 : U8 = CallByName List.66 List.439 List.442;
+            let List.557 : U8 = CallByName List.66 List.440 List.443;
-            let List.548 : [C U64, C U64] = CallByName Test.4 List.440 List.556;
+            let List.549 : [C U64, C U64] = CallByName Test.4 List.441 List.557;
-            let List.553 : U8 = 1i64;
+            let List.554 : U8 = 1i64;
-            let List.554 : U8 = GetTagId List.548;
+            let List.555 : U8 = GetTagId List.549;
-            let List.555 : Int1 = lowlevel Eq List.553 List.554;
+            let List.556 : Int1 = lowlevel Eq List.554 List.555;
-            if List.555 then
+            if List.556 then
-                let List.444 : U64 = UnionAtIndex (Id 1) (Index 0) List.548;
+                let List.445 : U64 = UnionAtIndex (Id 1) (Index 0) List.549;
-                let List.551 : U64 = 1i64;
+                let List.552 : U64 = 1i64;
-                let List.550 : U64 = CallByName Num.19 List.442 List.551;
+                let List.551 : U64 = CallByName Num.51 List.443 List.552;
-                jump List.545 List.439 List.444 List.441 List.550 List.443;
+                jump List.546 List.440 List.445 List.442 List.551 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : U64 = UnionAtIndex (Id 0) (Index 0) List.548;
+                let List.446 : U64 = UnionAtIndex (Id 0) (Index 0) List.549;
-                let List.552 : [C U64, C U64] = TagId(0) List.445;
+                let List.553 : [C U64, C U64] = TagId(0) List.446;
-                ret List.552;
+                ret List.553;
         else
-            dec List.439;
+            dec List.440;
-            let List.546 : [C U64, C U64] = TagId(1) List.440;
+            let List.547 : [C U64, C U64] = TagId(1) List.441;
-            ret List.546;
+            ret List.547;
     in
-    jump List.545 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.546 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.543 : U64 = 0i64;
+    let List.544 : U64 = 0i64;
-    let List.544 : U64 = CallByName List.6 List.436;
+    let List.545 : U64 = CallByName List.6 List.437;
-    let List.542 : [C U64, C U64] = CallByName List.80 List.436 List.437 List.438 List.543 List.544;
+    let List.543 : [C U64, C U64] = CallByName List.80 List.437 List.438 List.439 List.544 List.545;
-    ret List.542;
+    ret List.543;
-
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.295;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.294;
+
 procedure Num.77 (#Attr.2, #Attr.3):
     let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
     ret Num.293;

crates/compiler/test_mono/generated/call_function_in_empty_list.txt

@@ -1,7 +1,7 @@
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.521 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
+    let List.522 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
     decref #Attr.2;
-    ret List.521;
+    ret List.522;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/call_function_in_empty_list_unbound.txt

@@ -1,7 +1,7 @@
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.521 : List [] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
+    let List.522 : List [] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
     decref #Attr.2;
-    ret List.521;
+    ret List.522;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -1,48 +1,48 @@
 procedure List.145 (List.146, List.147, List.144):
-    let List.540 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.146 List.147 List.144;
+    let List.541 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.146 List.147 List.144;
-    ret List.540;
+    ret List.541;
 
 procedure List.18 (List.142, List.143, List.144):
-    let List.521 : [<r>C {}, C *self {{}, []}] = CallByName List.93 List.142 List.143 List.144;
+    let List.522 : [<r>C {}, C *self {{}, []}] = CallByName List.93 List.142 List.143 List.144;
-    ret List.521;
+    ret List.522;
 
 procedure List.6 (#Attr.2):
-    let List.538 : U64 = lowlevel ListLen #Attr.2;
+    let List.539 : U64 = lowlevel ListLen #Attr.2;
-    ret List.538;
+    ret List.539;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.537 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.538 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.537;
+    ret List.538;
 
 procedure List.80 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
-    joinpoint List.527 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.528 List.440 List.441 List.442 List.443 List.444:
-        let List.529 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.530 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.529 then
+        if List.530 then
-            let List.536 : [] = CallByName List.66 List.439 List.442;
+            let List.537 : [] = CallByName List.66 List.440 List.443;
-            let List.530 : [<r>C {}, C *self {{}, []}] = CallByName List.145 List.440 List.536 List.441;
+            let List.531 : [<r>C {}, C *self {{}, []}] = CallByName List.145 List.441 List.537 List.442;
-            let List.533 : U64 = 1i64;
+            let List.534 : U64 = 1i64;
-            let List.532 : U64 = CallByName Num.19 List.442 List.533;
+            let List.533 : U64 = CallByName Num.51 List.443 List.534;
-            jump List.527 List.439 List.530 List.441 List.532 List.443;
+            jump List.528 List.440 List.531 List.442 List.533 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.527 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    jump List.528 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.525 : U64 = 0i64;
+    let List.526 : U64 = 0i64;
-    let List.526 : U64 = CallByName List.6 List.436;
+    let List.527 : U64 = CallByName List.6 List.437;
-    let List.524 : [<r>C {}, C *self {{}, []}] = CallByName List.80 List.436 List.437 List.438 List.525 List.526;
+    let List.525 : [<r>C {}, C *self {{}, []}] = CallByName List.80 List.437 List.438 List.439 List.526 List.527;
-    ret List.524;
+    ret List.525;
-
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.292;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.293 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.293;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
+
 procedure Test.10 (Test.66, #Attr.12):
     let Test.9 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
     let #Derived_gen.20 : Int1 = lowlevel RefCountIsUnique #Attr.12;

crates/compiler/test_mono/generated/choose_correct_recursion_var_under_record.txt

@@ -3,48 +3,48 @@ procedure Bool.1 ():
     ret Bool.24;
 
 procedure List.2 (List.97, List.98):
-    let List.535 : U64 = CallByName List.6 List.97;
+    let List.536 : U64 = CallByName List.6 List.97;
-    let List.531 : Int1 = CallByName Num.22 List.98 List.535;
+    let List.532 : Int1 = CallByName Num.22 List.98 List.536;
-    if List.531 then
+    if List.532 then
-        let List.533 : Str = CallByName List.66 List.97 List.98;
+        let List.534 : Str = CallByName List.66 List.97 List.98;
-        inc List.533;
+        inc List.534;
         dec List.97;
-        let List.532 : [C {}, C Str] = TagId(1) List.533;
+        let List.533 : [C {}, C Str] = TagId(1) List.534;
-        ret List.532;
+        ret List.533;
     else
         dec List.97;
-        let List.530 : {} = Struct {};
+        let List.531 : {} = Struct {};
-        let List.529 : [C {}, C Str] = TagId(0) List.530;
+        let List.530 : [C {}, C Str] = TagId(0) List.531;
-        ret List.529;
+        ret List.530;
 
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.537 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.10 #Attr.3;
+    let List.538 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.10 #Attr.3;
     decref #Attr.2;
-    ret List.537;
+    ret List.538;
 
 procedure List.6 (#Attr.2):
-    let List.536 : U64 = lowlevel ListLen #Attr.2;
+    let List.537 : U64 = lowlevel ListLen #Attr.2;
-    ret List.536;
+    ret List.537;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.534 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.535 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.534;
+    ret List.535;
 
 procedure List.9 (List.293):
-    let List.528 : U64 = 0i64;
+    let List.529 : U64 = 0i64;
-    let List.521 : [C {}, C Str] = CallByName List.2 List.293 List.528;
+    let List.522 : [C {}, C Str] = CallByName List.2 List.293 List.529;
-    let List.525 : U8 = 1i64;
+    let List.526 : U8 = 1i64;
-    let List.526 : U8 = GetTagId List.521;
+    let List.527 : U8 = GetTagId List.522;
-    let List.527 : Int1 = lowlevel Eq List.525 List.526;
+    let List.528 : Int1 = lowlevel Eq List.526 List.527;
-    if List.527 then
+    if List.528 then
-        let List.294 : Str = UnionAtIndex (Id 1) (Index 0) List.521;
+        let List.294 : Str = UnionAtIndex (Id 1) (Index 0) List.522;
-        let List.522 : [C {}, C Str] = TagId(1) List.294;
+        let List.523 : [C {}, C Str] = TagId(1) List.294;
-        ret List.522;
-    else
-        dec List.521;
-        let List.524 : {} = Struct {};
-        let List.523 : [C {}, C Str] = TagId(0) List.524;
         ret List.523;
+    else
+        dec List.522;
+        let List.525 : {} = Struct {};
+        let List.524 : [C {}, C Str] = TagId(0) List.525;
+        ret List.524;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/closure_in_list.txt

@@ -1,6 +1,6 @@
 procedure List.6 (#Attr.2):
-    let List.521 : U64 = lowlevel ListLen #Attr.2;
+    let List.522 : U64 = lowlevel ListLen #Attr.2;
-    ret List.521;
+    ret List.522;
 
 procedure Test.1 (Test.5):
     let Test.2 : I64 = 41i64;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -3,50 +3,50 @@ procedure Bool.2 ():
     ret Bool.23;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.540 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.146 List.147 List.144;
+    let List.541 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.146 List.147 List.144;
-    ret List.540;
+    ret List.541;
 
 procedure List.18 (List.142, List.143, List.144):
-    let List.521 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.93 List.142 List.143 List.144;
+    let List.522 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.93 List.142 List.143 List.144;
-    ret List.521;
+    ret List.522;
 
 procedure List.6 (#Attr.2):
-    let List.538 : U64 = lowlevel ListLen #Attr.2;
+    let List.539 : U64 = lowlevel ListLen #Attr.2;
-    ret List.538;
+    ret List.539;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.537 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.538 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.537;
+    ret List.538;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.527 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.528 List.440 List.441 List.442 List.443 List.444:
-        let List.529 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.530 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.529 then
+        if List.530 then
-            let List.536 : Int1 = CallByName List.66 List.439 List.442;
+            let List.537 : Int1 = CallByName List.66 List.440 List.443;
-            let List.530 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.145 List.440 List.536 List.441;
+            let List.531 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.145 List.441 List.537 List.442;
-            let List.533 : U64 = 1i64;
+            let List.534 : U64 = 1i64;
-            let List.532 : U64 = CallByName Num.19 List.442 List.533;
+            let List.533 : U64 = CallByName Num.51 List.443 List.534;
-            jump List.527 List.439 List.530 List.441 List.532 List.443;
+            jump List.528 List.440 List.531 List.442 List.533 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.527 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.528 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.525 : U64 = 0i64;
+    let List.526 : U64 = 0i64;
-    let List.526 : U64 = CallByName List.6 List.436;
+    let List.527 : U64 = CallByName List.6 List.437;
-    let List.524 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.80 List.436 List.437 List.438 List.525 List.526;
+    let List.525 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.80 List.437 List.438 List.439 List.526 List.527;
-    ret List.524;
+    ret List.525;
-
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.292;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.293 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.293;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
+
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.291 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
     ret Str.291;

crates/compiler/test_mono/generated/dict.txt

@@ -25,67 +25,67 @@ procedure Dict.4 (Dict.562):
     ret Dict.100;
 
 procedure List.11 (List.121, List.122):
-    let List.522 : List I8 = CallByName List.68 List.122;
+    let List.523 : List I8 = CallByName List.68 List.122;
-    let List.521 : List I8 = CallByName List.83 List.121 List.122 List.522;
+    let List.522 : List I8 = CallByName List.83 List.121 List.122 List.523;
-    ret List.521;
+    ret List.522;
 
 procedure List.11 (List.121, List.122):
-    let List.534 : List U64 = CallByName List.68 List.122;
+    let List.535 : List U64 = CallByName List.68 List.122;
-    let List.533 : List U64 = CallByName List.83 List.121 List.122 List.534;
+    let List.534 : List U64 = CallByName List.83 List.121 List.122 List.535;
+    ret List.534;
+
+procedure List.68 (#Attr.2):
+    let List.533 : List I8 = lowlevel ListWithCapacity #Attr.2;
     ret List.533;
 
 procedure List.68 (#Attr.2):
-    let List.532 : List I8 = lowlevel ListWithCapacity #Attr.2;
+    let List.545 : List U64 = lowlevel ListWithCapacity #Attr.2;
-    ret List.532;
+    ret List.545;
-
-procedure List.68 (#Attr.2):
-    let List.544 : List U64 = lowlevel ListWithCapacity #Attr.2;
-    ret List.544;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.529 : List I8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.530 : List I8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.529;
+    ret List.530;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.541 : List U64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.542 : List U64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.541;
+    ret List.542;
 
 procedure List.83 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
-    joinpoint List.523 List.123 List.124 List.125:
+    joinpoint List.524 List.123 List.124 List.125:
-        let List.531 : U64 = 0i64;
+        let List.532 : U64 = 0i64;
-        let List.525 : Int1 = CallByName Num.24 List.124 List.531;
+        let List.526 : Int1 = CallByName Num.24 List.124 List.532;
-        if List.525 then
+        if List.526 then
-            let List.530 : U64 = 1i64;
+            let List.531 : U64 = 1i64;
-            let List.527 : U64 = CallByName Num.20 List.124 List.530;
+            let List.528 : U64 = CallByName Num.75 List.124 List.531;
-            let List.528 : List I8 = CallByName List.71 List.125 List.123;
+            let List.529 : List I8 = CallByName List.71 List.125 List.123;
-            jump List.523 List.123 List.527 List.528;
+            jump List.524 List.123 List.528 List.529;
         else
             ret List.125;
     in
-    jump List.523 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2;
+    jump List.524 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2;
 
 procedure List.83 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
-    joinpoint List.535 List.123 List.124 List.125:
+    joinpoint List.536 List.123 List.124 List.125:
-        let List.543 : U64 = 0i64;
+        let List.544 : U64 = 0i64;
-        let List.537 : Int1 = CallByName Num.24 List.124 List.543;
+        let List.538 : Int1 = CallByName Num.24 List.124 List.544;
-        if List.537 then
+        if List.538 then
-            let List.542 : U64 = 1i64;
+            let List.543 : U64 = 1i64;
-            let List.539 : U64 = CallByName Num.20 List.124 List.542;
+            let List.540 : U64 = CallByName Num.75 List.124 List.543;
-            let List.540 : List U64 = CallByName List.71 List.125 List.123;
+            let List.541 : List U64 = CallByName List.71 List.125 List.123;
-            jump List.535 List.123 List.539 List.540;
+            jump List.536 List.123 List.540 List.541;
         else
             ret List.125;
     in
-    jump List.535 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.536 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.293;
 
 procedure Num.24 (#Attr.2, #Attr.3):
     let Num.295 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.295;
 
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.293 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.293;
+
 procedure Test.0 ():
     let Test.3 : {} = Struct {};
     let Test.2 : {List {[], []}, List U64, List I8, U64} = CallByName Dict.1 Test.3;

crates/compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -3,26 +3,26 @@ procedure Bool.1 ():
     ret Bool.23;
 
 procedure List.2 (List.97, List.98):
-    let List.527 : U64 = CallByName List.6 List.97;
+    let List.528 : U64 = CallByName List.6 List.97;
-    let List.523 : Int1 = CallByName Num.22 List.98 List.527;
+    let List.524 : Int1 = CallByName Num.22 List.98 List.528;
-    if List.523 then
+    if List.524 then
-        let List.525 : {} = CallByName List.66 List.97 List.98;
+        let List.526 : {} = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.524 : [C {}, C {}] = TagId(1) List.525;
+        let List.525 : [C {}, C {}] = TagId(1) List.526;
-        ret List.524;
+        ret List.525;
     else
         dec List.97;
-        let List.522 : {} = Struct {};
+        let List.523 : {} = Struct {};
-        let List.521 : [C {}, C {}] = TagId(0) List.522;
+        let List.522 : [C {}, C {}] = TagId(0) List.523;
-        ret List.521;
+        ret List.522;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.526 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.527 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/encode.txt

@@ -1,16 +1,16 @@
 procedure List.4 (List.113, List.114):
-    let List.524 : U64 = 1i64;
+    let List.525 : U64 = 1i64;
-    let List.522 : List U8 = CallByName List.70 List.113 List.524;
+    let List.523 : List U8 = CallByName List.70 List.113 List.525;
-    let List.521 : List U8 = CallByName List.71 List.522 List.114;
+    let List.522 : List U8 = CallByName List.71 List.523 List.114;
-    ret List.521;
+    ret List.522;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.525 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.526 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.525;
+    ret List.526;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.523 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.524 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.523;
+    ret List.524;
 
 procedure Test.23 (Test.24, Test.35, Test.22):
     let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;

crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt

@@ -78,271 +78,271 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.689 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    let List.690 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.689;
+    ret List.690;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.569 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
+    let List.570 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
-    ret List.569;
+    ret List.570;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.637 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
+    let List.638 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
-    ret List.637;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.657 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.657;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.550 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.550;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.618 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.618;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.638 : List U8 = CallByName List.93 List.142 List.143 List.144;
     ret List.638;
 
+procedure List.145 (List.146, List.147, List.144):
+    let List.658 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    ret List.658;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.551 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.551;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.619 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.619;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.639 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    ret List.639;
+
 procedure List.26 (List.159, List.160, List.161):
-    let List.706 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.707 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.709 : U8 = 1i64;
+    let List.710 : U8 = 1i64;
-    let List.710 : U8 = GetTagId List.706;
+    let List.711 : U8 = GetTagId List.707;
-    let List.711 : Int1 = lowlevel Eq List.709 List.710;
+    let List.712 : Int1 = lowlevel Eq List.710 List.711;
-    if List.711 then
+    if List.712 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.706;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.707;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.706;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.707;
         ret List.163;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.671 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.672 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.671;
+    ret List.672;
 
 procedure List.38 (List.298):
-    let List.679 : U64 = 0i64;
+    let List.680 : U64 = 0i64;
-    let List.678 : List Str = CallByName List.31 List.298 List.679;
+    let List.679 : List Str = CallByName List.31 List.298 List.680;
-    ret List.678;
+    ret List.679;
 
 procedure List.4 (List.113, List.114):
-    let List.614 : U64 = 1i64;
+    let List.615 : U64 = 1i64;
-    let List.613 : List Str = CallByName List.70 List.113 List.614;
+    let List.614 : List Str = CallByName List.70 List.113 List.615;
-    let List.612 : List Str = CallByName List.71 List.613 List.114;
+    let List.613 : List Str = CallByName List.71 List.614 List.114;
-    ret List.612;
+    ret List.613;
 
 procedure List.4 (List.113, List.114):
-    let List.617 : U64 = 1i64;
+    let List.618 : U64 = 1i64;
-    let List.616 : List U8 = CallByName List.70 List.113 List.617;
+    let List.617 : List U8 = CallByName List.70 List.113 List.618;
-    let List.615 : List U8 = CallByName List.71 List.616 List.114;
+    let List.616 : List U8 = CallByName List.71 List.617 List.114;
-    ret List.615;
+    ret List.616;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.698 : U64 = StructAtIndex 0 List.377;
+    let List.699 : U64 = StructAtIndex 0 List.378;
-    let List.699 : U64 = 0i64;
+    let List.700 : U64 = 0i64;
-    let List.696 : Int1 = CallByName Bool.11 List.698 List.699;
+    let List.697 : Int1 = CallByName Bool.11 List.699 List.700;
-    if List.696 then
+    if List.697 then
-        dec List.376;
+        dec List.377;
-        let List.697 : List U8 = Array [];
+        let List.698 : List U8 = Array [];
-        ret List.697;
+        ret List.698;
     else
-        let List.693 : U64 = StructAtIndex 1 List.377;
+        let List.694 : U64 = StructAtIndex 1 List.378;
-        let List.694 : U64 = StructAtIndex 0 List.377;
+        let List.695 : U64 = StructAtIndex 0 List.378;
-        let List.692 : List U8 = CallByName List.72 List.376 List.693 List.694;
+        let List.693 : List U8 = CallByName List.72 List.377 List.694 List.695;
-        ret List.692;
+        ret List.693;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.704 List.394:
+    joinpoint List.705 List.395:
-        let List.702 : U64 = 0i64;
+        let List.703 : U64 = 0i64;
-        let List.701 : {U64, U64} = Struct {List.394, List.702};
+        let List.702 : {U64, U64} = Struct {List.395, List.703};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.701;
+        let List.396 : List U8 = CallByName List.49 List.392 List.702;
-        let List.700 : U64 = CallByName Num.20 List.393 List.394;
+        let List.701 : U64 = CallByName Num.75 List.394 List.395;
-        let List.691 : {U64, U64} = Struct {List.700, List.394};
+        let List.692 : {U64, U64} = Struct {List.701, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.691;
+        let List.397 : List U8 = CallByName List.49 List.392 List.692;
-        let List.690 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.691 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.690;
+        ret List.691;
     in
-    let List.705 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.706 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.705 then
+    if List.706 then
-        jump List.704 List.392;
+        jump List.705 List.393;
     else
-        jump List.704 List.393;
+        jump List.705 List.394;
 
 procedure List.6 (#Attr.2):
-    let List.588 : U64 = lowlevel ListLen #Attr.2;
+    let List.589 : U64 = lowlevel ListLen #Attr.2;
-    ret List.588;
+    ret List.589;
-
-procedure List.6 (#Attr.2):
-    let List.685 : U64 = lowlevel ListLen #Attr.2;
-    ret List.685;
 
 procedure List.6 (#Attr.2):
     let List.686 : U64 = lowlevel ListLen #Attr.2;
     ret List.686;
 
 procedure List.6 (#Attr.2):
-    let List.688 : U64 = lowlevel ListLen #Attr.2;
+    let List.687 : U64 = lowlevel ListLen #Attr.2;
-    ret List.688;
+    ret List.687;
+
+procedure List.6 (#Attr.2):
+    let List.689 : U64 = lowlevel ListLen #Attr.2;
+    ret List.689;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.566 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.567 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.566;
+    ret List.567;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.634 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.634;
+    ret List.635;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.654 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.655 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.654;
+    ret List.655;
 
 procedure List.68 (#Attr.2):
-    let List.681 : List Str = lowlevel ListWithCapacity #Attr.2;
+    let List.682 : List Str = lowlevel ListWithCapacity #Attr.2;
-    ret List.681;
+    ret List.682;
 
 procedure List.68 (#Attr.2):
-    let List.683 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.684 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.683;
+    ret List.684;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.594 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.595 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.594;
+    ret List.595;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.611 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.612 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.611;
+    ret List.612;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.592 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.593 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.592;
+    ret List.593;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.609 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.610 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.609;
+    ret List.610;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.695 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.696 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.695;
+    ret List.696;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.660 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.661 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.660;
+    ret List.661;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.668 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.669 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.668;
+    ret List.669;
 
 procedure List.80 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24):
-    joinpoint List.556 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.557 List.440 List.441 List.442 List.443 List.444:
-        let List.558 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.559 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.558 then
+        if List.559 then
-            let List.565 : {Str, Str} = CallByName List.66 List.439 List.442;
+            let List.566 : {Str, Str} = CallByName List.66 List.440 List.443;
-            inc List.565;
+            inc List.566;
-            let List.559 : {List U8, U64} = CallByName List.145 List.440 List.565 List.441;
+            let List.560 : {List U8, U64} = CallByName List.145 List.441 List.566 List.442;
-            let List.562 : U64 = 1i64;
+            let List.563 : U64 = 1i64;
-            let List.561 : U64 = CallByName Num.19 List.442 List.562;
+            let List.562 : U64 = CallByName Num.51 List.443 List.563;
-            jump List.556 List.439 List.559 List.441 List.561 List.443;
+            jump List.557 List.440 List.560 List.442 List.562 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.556 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
+    jump List.557 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
 
-procedure List.80 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32):
+procedure List.80 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
-    joinpoint List.715 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.645 List.440 List.441 List.442 List.443 List.444:
-        let List.717 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.647 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.717 then
+        if List.647 then
-            let List.726 : U8 = CallByName List.66 List.439 List.442;
+            let List.654 : U8 = CallByName List.66 List.440 List.443;
-            let List.718 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.726;
+            let List.648 : List U8 = CallByName List.145 List.441 List.654 List.442;
-            let List.723 : U8 = 1i64;
+            let List.651 : U64 = 1i64;
-            let List.724 : U8 = GetTagId List.718;
+            let List.650 : U64 = CallByName Num.51 List.443 List.651;
-            let List.725 : Int1 = lowlevel Eq List.723 List.724;
+            jump List.645 List.440 List.648 List.442 List.650 List.444;
-            if List.725 then
+        else
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.718;
+            dec List.440;
-                let List.721 : U64 = 1i64;
+            ret List.441;
-                let List.720 : U64 = CallByName Num.19 List.442 List.721;
+    in
-                jump List.715 List.439 List.444 List.441 List.720 List.443;
+    jump List.645 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
+
+procedure List.80 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37):
+    joinpoint List.716 List.440 List.441 List.442 List.443 List.444:
+        let List.718 : Int1 = CallByName Num.22 List.443 List.444;
+        if List.718 then
+            let List.727 : U8 = CallByName List.66 List.440 List.443;
+            let List.719 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.727;
+            let List.724 : U8 = 1i64;
+            let List.725 : U8 = GetTagId List.719;
+            let List.726 : Int1 = lowlevel Eq List.724 List.725;
+            if List.726 then
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.719;
+                let List.722 : U64 = 1i64;
+                let List.721 : U64 = CallByName Num.51 List.443 List.722;
+                jump List.716 List.440 List.445 List.442 List.721 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.718;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.719;
-                let List.722 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
+                let List.723 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
-                ret List.722;
+                ret List.723;
         else
-            dec List.439;
+            dec List.440;
-            let List.716 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            let List.717 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
-            ret List.716;
+            ret List.717;
     in
-    jump List.715 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32;
+    jump List.716 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37;
-
-procedure List.80 (#Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47):
-    joinpoint List.644 List.439 List.440 List.441 List.442 List.443:
-        let List.646 : Int1 = CallByName Num.22 List.442 List.443;
-        if List.646 then
-            let List.653 : U8 = CallByName List.66 List.439 List.442;
-            let List.647 : List U8 = CallByName List.145 List.440 List.653 List.441;
-            let List.650 : U64 = 1i64;
-            let List.649 : U64 = CallByName Num.19 List.442 List.650;
-            jump List.644 List.439 List.647 List.441 List.649 List.443;
-        else
-            dec List.439;
-            ret List.440;
-    in
-    jump List.644 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47;
 
 procedure List.80 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52):
-    joinpoint List.624 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.625 List.440 List.441 List.442 List.443 List.444:
-        let List.626 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.627 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.626 then
+        if List.627 then
-            let List.633 : {Str, Str} = CallByName List.66 List.439 List.442;
+            let List.634 : {Str, Str} = CallByName List.66 List.440 List.443;
-            inc List.633;
+            inc List.634;
-            let List.627 : {List U8, U64} = CallByName List.145 List.440 List.633 List.441;
+            let List.628 : {List U8, U64} = CallByName List.145 List.441 List.634 List.442;
-            let List.630 : U64 = 1i64;
+            let List.631 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.19 List.442 List.630;
+            let List.630 : U64 = CallByName Num.51 List.443 List.631;
-            jump List.624 List.439 List.627 List.441 List.629 List.443;
+            jump List.625 List.440 List.628 List.442 List.630 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.624 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52;
+    jump List.625 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.554 : U64 = 0i64;
+    let List.555 : U64 = 0i64;
-    let List.555 : U64 = CallByName List.6 List.436;
+    let List.556 : U64 = CallByName List.6 List.437;
-    let List.553 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.554 List.555;
+    let List.554 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.555 List.556;
-    ret List.553;
+    ret List.554;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.622 : U64 = 0i64;
+    let List.623 : U64 = 0i64;
-    let List.623 : U64 = CallByName List.6 List.436;
+    let List.624 : U64 = CallByName List.6 List.437;
-    let List.621 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.622 List.623;
+    let List.622 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.623 List.624;
-    ret List.621;
+    ret List.622;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.642 : U64 = 0i64;
+    let List.643 : U64 = 0i64;
-    let List.643 : U64 = CallByName List.6 List.436;
+    let List.644 : U64 = CallByName List.6 List.437;
-    let List.641 : List U8 = CallByName List.80 List.436 List.437 List.438 List.642 List.643;
+    let List.642 : List U8 = CallByName List.80 List.437 List.438 List.439 List.643 List.644;
-    ret List.641;
+    ret List.642;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.713 : U64 = 0i64;
+    let List.714 : U64 = 0i64;
-    let List.714 : U64 = CallByName List.6 List.436;
+    let List.715 : U64 = CallByName List.6 List.437;
-    let List.712 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.713 List.714;
+    let List.713 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.714 List.715;
-    ret List.712;
+    ret List.713;
 
 procedure Num.127 (#Attr.2):
     let Num.307 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.307;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.316 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.311 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.316;
+    ret Num.311;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.320 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.308 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.320;
+    ret Num.308;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.313 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -356,6 +356,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.321 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.321;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.316 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.316;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.320 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.320;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.312 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.312;
@@ -1446,7 +1454,7 @@ procedure TotallyNotJson.97 (TotallyNotJson.837):
     dec TotallyNotJson.1562;
     ret TotallyNotJson.1560;
 
-procedure TotallyNotJson.98 (#Derived_gen.36):
+procedure TotallyNotJson.98 (#Derived_gen.41):
     joinpoint TotallyNotJson.1568 TotallyNotJson.1169:
         let TotallyNotJson.842 : List Str = StructAtIndex 0 TotallyNotJson.1169;
         let TotallyNotJson.841 : List Str = StructAtIndex 1 TotallyNotJson.1169;
@@ -1482,7 +1490,7 @@ procedure TotallyNotJson.98 (#Derived_gen.36):
             let TotallyNotJson.1569 : {List Str, List Str} = Struct {TotallyNotJson.842, TotallyNotJson.841};
             ret TotallyNotJson.1569;
     in
-    jump TotallyNotJson.1568 #Derived_gen.36;
+    jump TotallyNotJson.1568 #Derived_gen.41;
 
 procedure Test.0 ():
     let Test.12 : Str = "bar";

crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt

@@ -51,233 +51,233 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.621 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    let List.622 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.621;
+    ret List.622;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.569 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
+    let List.570 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
-    ret List.569;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.589 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.589;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.550 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.550;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.570 : List U8 = CallByName List.93 List.142 List.143 List.144;
     ret List.570;
 
+procedure List.145 (List.146, List.147, List.144):
+    let List.590 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    ret List.590;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.551 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.551;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.571 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    ret List.571;
+
 procedure List.26 (List.159, List.160, List.161):
-    let List.638 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.639 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.641 : U8 = 1i64;
+    let List.642 : U8 = 1i64;
-    let List.642 : U8 = GetTagId List.638;
+    let List.643 : U8 = GetTagId List.639;
-    let List.643 : Int1 = lowlevel Eq List.641 List.642;
+    let List.644 : Int1 = lowlevel Eq List.642 List.643;
-    if List.643 then
+    if List.644 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.638;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.639;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.638;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.639;
         ret List.163;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.603 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.604 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.603;
+    ret List.604;
 
 procedure List.38 (List.298):
-    let List.611 : U64 = 0i64;
+    let List.612 : U64 = 0i64;
-    let List.610 : List Str = CallByName List.31 List.298 List.611;
+    let List.611 : List Str = CallByName List.31 List.298 List.612;
-    ret List.610;
+    ret List.611;
 
 procedure List.4 (List.113, List.114):
-    let List.546 : U64 = 1i64;
+    let List.547 : U64 = 1i64;
-    let List.545 : List Str = CallByName List.70 List.113 List.546;
+    let List.546 : List Str = CallByName List.70 List.113 List.547;
-    let List.544 : List Str = CallByName List.71 List.545 List.114;
+    let List.545 : List Str = CallByName List.71 List.546 List.114;
-    ret List.544;
+    ret List.545;
 
 procedure List.4 (List.113, List.114):
-    let List.549 : U64 = 1i64;
+    let List.550 : U64 = 1i64;
-    let List.548 : List U8 = CallByName List.70 List.113 List.549;
+    let List.549 : List U8 = CallByName List.70 List.113 List.550;
-    let List.547 : List U8 = CallByName List.71 List.548 List.114;
+    let List.548 : List U8 = CallByName List.71 List.549 List.114;
-    ret List.547;
+    ret List.548;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.630 : U64 = StructAtIndex 0 List.377;
+    let List.631 : U64 = StructAtIndex 0 List.378;
-    let List.631 : U64 = 0i64;
+    let List.632 : U64 = 0i64;
-    let List.628 : Int1 = CallByName Bool.11 List.630 List.631;
+    let List.629 : Int1 = CallByName Bool.11 List.631 List.632;
-    if List.628 then
+    if List.629 then
-        dec List.376;
+        dec List.377;
-        let List.629 : List U8 = Array [];
+        let List.630 : List U8 = Array [];
-        ret List.629;
+        ret List.630;
     else
-        let List.625 : U64 = StructAtIndex 1 List.377;
+        let List.626 : U64 = StructAtIndex 1 List.378;
-        let List.626 : U64 = StructAtIndex 0 List.377;
+        let List.627 : U64 = StructAtIndex 0 List.378;
-        let List.624 : List U8 = CallByName List.72 List.376 List.625 List.626;
+        let List.625 : List U8 = CallByName List.72 List.377 List.626 List.627;
-        ret List.624;
+        ret List.625;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.636 List.394:
+    joinpoint List.637 List.395:
-        let List.634 : U64 = 0i64;
+        let List.635 : U64 = 0i64;
-        let List.633 : {U64, U64} = Struct {List.394, List.634};
+        let List.634 : {U64, U64} = Struct {List.395, List.635};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.633;
+        let List.396 : List U8 = CallByName List.49 List.392 List.634;
-        let List.632 : U64 = CallByName Num.20 List.393 List.394;
+        let List.633 : U64 = CallByName Num.75 List.394 List.395;
-        let List.623 : {U64, U64} = Struct {List.632, List.394};
+        let List.624 : {U64, U64} = Struct {List.633, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.623;
+        let List.397 : List U8 = CallByName List.49 List.392 List.624;
-        let List.622 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.623 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.622;
+        ret List.623;
     in
-    let List.637 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.638 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.637 then
+    if List.638 then
-        jump List.636 List.392;
+        jump List.637 List.393;
     else
-        jump List.636 List.393;
+        jump List.637 List.394;
-
-procedure List.6 (#Attr.2):
-    let List.617 : U64 = lowlevel ListLen #Attr.2;
-    ret List.617;
 
 procedure List.6 (#Attr.2):
     let List.618 : U64 = lowlevel ListLen #Attr.2;
     ret List.618;
 
 procedure List.6 (#Attr.2):
-    let List.620 : U64 = lowlevel ListLen #Attr.2;
+    let List.619 : U64 = lowlevel ListLen #Attr.2;
-    ret List.620;
+    ret List.619;
+
+procedure List.6 (#Attr.2):
+    let List.621 : U64 = lowlevel ListLen #Attr.2;
+    ret List.621;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.566 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.567 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.566;
+    ret List.567;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.586 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.587 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.586;
+    ret List.587;
 
 procedure List.68 (#Attr.2):
-    let List.613 : List Str = lowlevel ListWithCapacity #Attr.2;
+    let List.614 : List Str = lowlevel ListWithCapacity #Attr.2;
-    ret List.613;
+    ret List.614;
 
 procedure List.68 (#Attr.2):
-    let List.615 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.616 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.615;
+    ret List.616;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.526 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.527 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.543 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.544 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.543;
+    ret List.544;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.524 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.525 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.524;
+    ret List.525;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.541 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.542 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.541;
+    ret List.542;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.627 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.628 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.627;
+    ret List.628;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.592 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.593 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.592;
+    ret List.593;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.600 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.601 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.600;
+    ret List.601;
 
 procedure List.80 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
-    joinpoint List.647 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.648 List.440 List.441 List.442 List.443 List.444:
-        let List.649 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.650 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.649 then
+        if List.650 then
-            let List.658 : U8 = CallByName List.66 List.439 List.442;
+            let List.659 : U8 = CallByName List.66 List.440 List.443;
-            let List.650 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.658;
+            let List.651 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.659;
-            let List.655 : U8 = 1i64;
+            let List.656 : U8 = 1i64;
-            let List.656 : U8 = GetTagId List.650;
+            let List.657 : U8 = GetTagId List.651;
-            let List.657 : Int1 = lowlevel Eq List.655 List.656;
+            let List.658 : Int1 = lowlevel Eq List.656 List.657;
-            if List.657 then
+            if List.658 then
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.650;
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.651;
-                let List.653 : U64 = 1i64;
+                let List.654 : U64 = 1i64;
-                let List.652 : U64 = CallByName Num.19 List.442 List.653;
+                let List.653 : U64 = CallByName Num.51 List.443 List.654;
-                jump List.647 List.439 List.444 List.441 List.652 List.443;
+                jump List.648 List.440 List.445 List.442 List.653 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.650;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.651;
-                let List.654 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
+                let List.655 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
-                ret List.654;
+                ret List.655;
         else
-            dec List.439;
+            dec List.440;
-            let List.648 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            let List.649 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
-            ret List.648;
+            ret List.649;
     in
-    jump List.647 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
+    jump List.648 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
 
 procedure List.80 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
-    joinpoint List.576 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.577 List.440 List.441 List.442 List.443 List.444:
-        let List.578 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.579 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.578 then
+        if List.579 then
-            let List.585 : U8 = CallByName List.66 List.439 List.442;
+            let List.586 : U8 = CallByName List.66 List.440 List.443;
-            let List.579 : List U8 = CallByName List.145 List.440 List.585 List.441;
+            let List.580 : List U8 = CallByName List.145 List.441 List.586 List.442;
-            let List.582 : U64 = 1i64;
+            let List.583 : U64 = 1i64;
-            let List.581 : U64 = CallByName Num.19 List.442 List.582;
+            let List.582 : U64 = CallByName Num.51 List.443 List.583;
-            jump List.576 List.439 List.579 List.441 List.581 List.443;
+            jump List.577 List.440 List.580 List.442 List.582 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.576 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
+    jump List.577 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
 
 procedure List.80 (#Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
-    joinpoint List.556 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.557 List.440 List.441 List.442 List.443 List.444:
-        let List.558 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.559 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.558 then
+        if List.559 then
-            let List.565 : {Str, Str} = CallByName List.66 List.439 List.442;
+            let List.566 : {Str, Str} = CallByName List.66 List.440 List.443;
-            inc List.565;
+            inc List.566;
-            let List.559 : {List U8, U64} = CallByName List.145 List.440 List.565 List.441;
+            let List.560 : {List U8, U64} = CallByName List.145 List.441 List.566 List.442;
-            let List.562 : U64 = 1i64;
+            let List.563 : U64 = 1i64;
-            let List.561 : U64 = CallByName Num.19 List.442 List.562;
+            let List.562 : U64 = CallByName Num.51 List.443 List.563;
-            jump List.556 List.439 List.559 List.441 List.561 List.443;
+            jump List.557 List.440 List.560 List.442 List.562 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.556 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
+    jump List.557 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.554 : U64 = 0i64;
+    let List.555 : U64 = 0i64;
-    let List.555 : U64 = CallByName List.6 List.436;
+    let List.556 : U64 = CallByName List.6 List.437;
-    let List.553 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.554 List.555;
+    let List.554 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.555 List.556;
-    ret List.553;
+    ret List.554;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.574 : U64 = 0i64;
+    let List.575 : U64 = 0i64;
-    let List.575 : U64 = CallByName List.6 List.436;
+    let List.576 : U64 = CallByName List.6 List.437;
-    let List.573 : List U8 = CallByName List.80 List.436 List.437 List.438 List.574 List.575;
+    let List.574 : List U8 = CallByName List.80 List.437 List.438 List.439 List.575 List.576;
-    ret List.573;
+    ret List.574;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.645 : U64 = 0i64;
+    let List.646 : U64 = 0i64;
-    let List.646 : U64 = CallByName List.6 List.436;
+    let List.647 : U64 = CallByName List.6 List.437;
-    let List.644 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.645 List.646;
+    let List.645 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.646 List.647;
-    ret List.644;
+    ret List.645;
 
 procedure Num.127 (#Attr.2):
     let Num.297 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.297;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.306 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.301 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.306;
+    ret Num.301;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.310 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.298 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.310;
+    ret Num.298;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.303 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -291,6 +291,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.311 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.311;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.306 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.306;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.310 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.310;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.302 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.302;

crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt

@@ -58,233 +58,233 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.621 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    let List.622 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.621;
+    ret List.622;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.569 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
+    let List.570 : {List U8, U64} = CallByName TotallyNotJson.237 List.146 List.147 List.144;
-    ret List.569;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.589 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.589;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.550 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.550;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.570 : List U8 = CallByName List.93 List.142 List.143 List.144;
     ret List.570;
 
+procedure List.145 (List.146, List.147, List.144):
+    let List.590 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    ret List.590;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.551 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.551;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.571 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    ret List.571;
+
 procedure List.26 (List.159, List.160, List.161):
-    let List.638 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.639 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.641 : U8 = 1i64;
+    let List.642 : U8 = 1i64;
-    let List.642 : U8 = GetTagId List.638;
+    let List.643 : U8 = GetTagId List.639;
-    let List.643 : Int1 = lowlevel Eq List.641 List.642;
+    let List.644 : Int1 = lowlevel Eq List.642 List.643;
-    if List.643 then
+    if List.644 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.638;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.639;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.638;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.639;
         ret List.163;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.603 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.604 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.603;
+    ret List.604;
 
 procedure List.38 (List.298):
-    let List.611 : U64 = 0i64;
+    let List.612 : U64 = 0i64;
-    let List.610 : List Str = CallByName List.31 List.298 List.611;
+    let List.611 : List Str = CallByName List.31 List.298 List.612;
-    ret List.610;
+    ret List.611;
 
 procedure List.4 (List.113, List.114):
-    let List.546 : U64 = 1i64;
+    let List.547 : U64 = 1i64;
-    let List.545 : List Str = CallByName List.70 List.113 List.546;
+    let List.546 : List Str = CallByName List.70 List.113 List.547;
-    let List.544 : List Str = CallByName List.71 List.545 List.114;
+    let List.545 : List Str = CallByName List.71 List.546 List.114;
-    ret List.544;
+    ret List.545;
 
 procedure List.4 (List.113, List.114):
-    let List.549 : U64 = 1i64;
+    let List.550 : U64 = 1i64;
-    let List.548 : List U8 = CallByName List.70 List.113 List.549;
+    let List.549 : List U8 = CallByName List.70 List.113 List.550;
-    let List.547 : List U8 = CallByName List.71 List.548 List.114;
+    let List.548 : List U8 = CallByName List.71 List.549 List.114;
-    ret List.547;
+    ret List.548;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.630 : U64 = StructAtIndex 0 List.377;
+    let List.631 : U64 = StructAtIndex 0 List.378;
-    let List.631 : U64 = 0i64;
+    let List.632 : U64 = 0i64;
-    let List.628 : Int1 = CallByName Bool.11 List.630 List.631;
+    let List.629 : Int1 = CallByName Bool.11 List.631 List.632;
-    if List.628 then
+    if List.629 then
-        dec List.376;
+        dec List.377;
-        let List.629 : List U8 = Array [];
+        let List.630 : List U8 = Array [];
-        ret List.629;
+        ret List.630;
     else
-        let List.625 : U64 = StructAtIndex 1 List.377;
+        let List.626 : U64 = StructAtIndex 1 List.378;
-        let List.626 : U64 = StructAtIndex 0 List.377;
+        let List.627 : U64 = StructAtIndex 0 List.378;
-        let List.624 : List U8 = CallByName List.72 List.376 List.625 List.626;
+        let List.625 : List U8 = CallByName List.72 List.377 List.626 List.627;
-        ret List.624;
+        ret List.625;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.636 List.394:
+    joinpoint List.637 List.395:
-        let List.634 : U64 = 0i64;
+        let List.635 : U64 = 0i64;
-        let List.633 : {U64, U64} = Struct {List.394, List.634};
+        let List.634 : {U64, U64} = Struct {List.395, List.635};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.633;
+        let List.396 : List U8 = CallByName List.49 List.392 List.634;
-        let List.632 : U64 = CallByName Num.20 List.393 List.394;
+        let List.633 : U64 = CallByName Num.75 List.394 List.395;
-        let List.623 : {U64, U64} = Struct {List.632, List.394};
+        let List.624 : {U64, U64} = Struct {List.633, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.623;
+        let List.397 : List U8 = CallByName List.49 List.392 List.624;
-        let List.622 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.623 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.622;
+        ret List.623;
     in
-    let List.637 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.638 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.637 then
+    if List.638 then
-        jump List.636 List.392;
+        jump List.637 List.393;
     else
-        jump List.636 List.393;
+        jump List.637 List.394;
-
-procedure List.6 (#Attr.2):
-    let List.617 : U64 = lowlevel ListLen #Attr.2;
-    ret List.617;
 
 procedure List.6 (#Attr.2):
     let List.618 : U64 = lowlevel ListLen #Attr.2;
     ret List.618;
 
 procedure List.6 (#Attr.2):
-    let List.620 : U64 = lowlevel ListLen #Attr.2;
+    let List.619 : U64 = lowlevel ListLen #Attr.2;
-    ret List.620;
+    ret List.619;
+
+procedure List.6 (#Attr.2):
+    let List.621 : U64 = lowlevel ListLen #Attr.2;
+    ret List.621;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.566 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.567 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.566;
+    ret List.567;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.586 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.587 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.586;
+    ret List.587;
 
 procedure List.68 (#Attr.2):
-    let List.613 : List Str = lowlevel ListWithCapacity #Attr.2;
+    let List.614 : List Str = lowlevel ListWithCapacity #Attr.2;
-    ret List.613;
+    ret List.614;
 
 procedure List.68 (#Attr.2):
-    let List.615 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.616 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.615;
+    ret List.616;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.526 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.527 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.543 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.544 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.543;
+    ret List.544;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.524 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.525 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.524;
+    ret List.525;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.541 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.542 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.541;
+    ret List.542;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.627 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.628 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.627;
+    ret List.628;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.592 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.593 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.592;
+    ret List.593;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.600 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.601 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.600;
+    ret List.601;
 
 procedure List.80 (#Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
-    joinpoint List.647 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.648 List.440 List.441 List.442 List.443 List.444:
-        let List.649 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.650 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.649 then
+        if List.650 then
-            let List.658 : U8 = CallByName List.66 List.439 List.442;
+            let List.659 : U8 = CallByName List.66 List.440 List.443;
-            let List.650 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.658;
+            let List.651 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.659;
-            let List.655 : U8 = 1i64;
+            let List.656 : U8 = 1i64;
-            let List.656 : U8 = GetTagId List.650;
+            let List.657 : U8 = GetTagId List.651;
-            let List.657 : Int1 = lowlevel Eq List.655 List.656;
+            let List.658 : Int1 = lowlevel Eq List.656 List.657;
-            if List.657 then
+            if List.658 then
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.650;
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.651;
-                let List.653 : U64 = 1i64;
+                let List.654 : U64 = 1i64;
-                let List.652 : U64 = CallByName Num.19 List.442 List.653;
+                let List.653 : U64 = CallByName Num.51 List.443 List.654;
-                jump List.647 List.439 List.444 List.441 List.652 List.443;
+                jump List.648 List.440 List.445 List.442 List.653 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.650;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.651;
-                let List.654 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
+                let List.655 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
-                ret List.654;
+                ret List.655;
         else
-            dec List.439;
+            dec List.440;
-            let List.648 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            let List.649 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
-            ret List.648;
+            ret List.649;
     in
-    jump List.647 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
+    jump List.648 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
 
 procedure List.80 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24):
-    joinpoint List.576 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.577 List.440 List.441 List.442 List.443 List.444:
-        let List.578 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.579 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.578 then
+        if List.579 then
-            let List.585 : U8 = CallByName List.66 List.439 List.442;
+            let List.586 : U8 = CallByName List.66 List.440 List.443;
-            let List.579 : List U8 = CallByName List.145 List.440 List.585 List.441;
+            let List.580 : List U8 = CallByName List.145 List.441 List.586 List.442;
-            let List.582 : U64 = 1i64;
+            let List.583 : U64 = 1i64;
-            let List.581 : U64 = CallByName Num.19 List.442 List.582;
+            let List.582 : U64 = CallByName Num.51 List.443 List.583;
-            jump List.576 List.439 List.579 List.441 List.581 List.443;
+            jump List.577 List.440 List.580 List.442 List.582 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.576 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
+    jump List.577 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
 
 procedure List.80 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
-    joinpoint List.556 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.557 List.440 List.441 List.442 List.443 List.444:
-        let List.558 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.559 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.558 then
+        if List.559 then
-            let List.565 : {Str, Str} = CallByName List.66 List.439 List.442;
+            let List.566 : {Str, Str} = CallByName List.66 List.440 List.443;
-            inc List.565;
+            inc List.566;
-            let List.559 : {List U8, U64} = CallByName List.145 List.440 List.565 List.441;
+            let List.560 : {List U8, U64} = CallByName List.145 List.441 List.566 List.442;
-            let List.562 : U64 = 1i64;
+            let List.563 : U64 = 1i64;
-            let List.561 : U64 = CallByName Num.19 List.442 List.562;
+            let List.562 : U64 = CallByName Num.51 List.443 List.563;
-            jump List.556 List.439 List.559 List.441 List.561 List.443;
+            jump List.557 List.440 List.560 List.442 List.562 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.556 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
+    jump List.557 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.554 : U64 = 0i64;
+    let List.555 : U64 = 0i64;
-    let List.555 : U64 = CallByName List.6 List.436;
+    let List.556 : U64 = CallByName List.6 List.437;
-    let List.553 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.554 List.555;
+    let List.554 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.555 List.556;
-    ret List.553;
+    ret List.554;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.574 : U64 = 0i64;
+    let List.575 : U64 = 0i64;
-    let List.575 : U64 = CallByName List.6 List.436;
+    let List.576 : U64 = CallByName List.6 List.437;
-    let List.573 : List U8 = CallByName List.80 List.436 List.437 List.438 List.574 List.575;
+    let List.574 : List U8 = CallByName List.80 List.437 List.438 List.439 List.575 List.576;
-    ret List.573;
+    ret List.574;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.645 : U64 = 0i64;
+    let List.646 : U64 = 0i64;
-    let List.646 : U64 = CallByName List.6 List.436;
+    let List.647 : U64 = CallByName List.6 List.437;
-    let List.644 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.645 List.646;
+    let List.645 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.646 List.647;
-    ret List.644;
+    ret List.645;
 
 procedure Num.127 (#Attr.2):
     let Num.297 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.297;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.306 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.301 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.306;
+    ret Num.301;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.310 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.298 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.310;
+    ret Num.298;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.303 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -298,6 +298,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.311 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.311;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.306 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.306;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.310 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.310;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.302 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.302;

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -16,138 +16,134 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.552 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    let List.553 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.552;
+    ret List.553;
 
 procedure List.18 (List.142, List.143, List.144):
-    let List.534 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    let List.535 : List U8 = CallByName List.93 List.142 List.143 List.144;
-    ret List.534;
+    ret List.535;
 
 procedure List.26 (List.159, List.160, List.161):
-    let List.569 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.570 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.572 : U8 = 1i64;
+    let List.573 : U8 = 1i64;
-    let List.573 : U8 = GetTagId List.569;
+    let List.574 : U8 = GetTagId List.570;
-    let List.574 : Int1 = lowlevel Eq List.572 List.573;
+    let List.575 : Int1 = lowlevel Eq List.573 List.574;
-    if List.574 then
+    if List.575 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.569;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.570;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.569;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.570;
         ret List.163;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.561 : U64 = StructAtIndex 0 List.377;
+    let List.562 : U64 = StructAtIndex 0 List.378;
-    let List.562 : U64 = 0i64;
+    let List.563 : U64 = 0i64;
-    let List.559 : Int1 = CallByName Bool.11 List.561 List.562;
+    let List.560 : Int1 = CallByName Bool.11 List.562 List.563;
-    if List.559 then
+    if List.560 then
-        dec List.376;
+        dec List.377;
-        let List.560 : List U8 = Array [];
+        let List.561 : List U8 = Array [];
-        ret List.560;
+        ret List.561;
     else
-        let List.556 : U64 = StructAtIndex 1 List.377;
+        let List.557 : U64 = StructAtIndex 1 List.378;
-        let List.557 : U64 = StructAtIndex 0 List.377;
+        let List.558 : U64 = StructAtIndex 0 List.378;
-        let List.555 : List U8 = CallByName List.72 List.376 List.556 List.557;
+        let List.556 : List U8 = CallByName List.72 List.377 List.557 List.558;
-        ret List.555;
+        ret List.556;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.567 List.394:
+    joinpoint List.568 List.395:
-        let List.565 : U64 = 0i64;
+        let List.566 : U64 = 0i64;
-        let List.564 : {U64, U64} = Struct {List.394, List.565};
+        let List.565 : {U64, U64} = Struct {List.395, List.566};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.564;
+        let List.396 : List U8 = CallByName List.49 List.392 List.565;
-        let List.563 : U64 = CallByName Num.20 List.393 List.394;
+        let List.564 : U64 = CallByName Num.75 List.394 List.395;
-        let List.554 : {U64, U64} = Struct {List.563, List.394};
+        let List.555 : {U64, U64} = Struct {List.564, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.554;
+        let List.397 : List U8 = CallByName List.49 List.392 List.555;
-        let List.553 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.554 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.553;
+        ret List.554;
     in
-    let List.568 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.569 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.568 then
+    if List.569 then
-        jump List.567 List.392;
+        jump List.568 List.393;
     else
-        jump List.567 List.393;
+        jump List.568 List.394;
 
 procedure List.6 (#Attr.2):
-    let List.533 : U64 = lowlevel ListLen #Attr.2;
+    let List.534 : U64 = lowlevel ListLen #Attr.2;
-    ret List.533;
+    ret List.534;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.550 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.551 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.550;
+    ret List.551;
 
 procedure List.68 (#Attr.2):
-    let List.531 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.532 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.531;
+    ret List.532;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.558 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.559 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.558;
+    ret List.559;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.529 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.530 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.529;
+    ret List.530;
 
 procedure List.80 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
-    joinpoint List.540 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.541 List.440 List.441 List.442 List.443 List.444:
-        let List.542 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.543 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.542 then
+        if List.543 then
-            let List.549 : U8 = CallByName List.66 List.439 List.442;
+            let List.550 : U8 = CallByName List.66 List.440 List.443;
-            let List.543 : List U8 = CallByName List.145 List.440 List.549 List.441;
+            let List.544 : List U8 = CallByName List.145 List.441 List.550 List.442;
-            let List.546 : U64 = 1i64;
+            let List.547 : U64 = 1i64;
-            let List.545 : U64 = CallByName Num.19 List.442 List.546;
+            let List.546 : U64 = CallByName Num.51 List.443 List.547;
-            jump List.540 List.439 List.543 List.441 List.545 List.443;
+            jump List.541 List.440 List.544 List.442 List.546 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.540 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump List.541 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
 
 procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
-    joinpoint List.578 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.579 List.440 List.441 List.442 List.443 List.444:
-        let List.580 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.581 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.580 then
+        if List.581 then
-            let List.589 : U8 = CallByName List.66 List.439 List.442;
+            let List.590 : U8 = CallByName List.66 List.440 List.443;
-            let List.581 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.589;
+            let List.582 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.590;
-            let List.586 : U8 = 1i64;
+            let List.587 : U8 = 1i64;
-            let List.587 : U8 = GetTagId List.581;
+            let List.588 : U8 = GetTagId List.582;
-            let List.588 : Int1 = lowlevel Eq List.586 List.587;
+            let List.589 : Int1 = lowlevel Eq List.587 List.588;
-            if List.588 then
+            if List.589 then
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.581;
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.582;
-                let List.584 : U64 = 1i64;
+                let List.585 : U64 = 1i64;
-                let List.583 : U64 = CallByName Num.19 List.442 List.584;
+                let List.584 : U64 = CallByName Num.51 List.443 List.585;
-                jump List.578 List.439 List.444 List.441 List.583 List.443;
+                jump List.579 List.440 List.445 List.442 List.584 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.581;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.582;
-                let List.585 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
+                let List.586 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
-                ret List.585;
+                ret List.586;
         else
-            dec List.439;
+            dec List.440;
-            let List.579 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            let List.580 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
-            ret List.579;
+            ret List.580;
     in
-    jump List.578 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
+    jump List.579 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.538 : U64 = 0i64;
+    let List.539 : U64 = 0i64;
-    let List.539 : U64 = CallByName List.6 List.436;
+    let List.540 : U64 = CallByName List.6 List.437;
-    let List.537 : List U8 = CallByName List.80 List.436 List.437 List.438 List.538 List.539;
+    let List.538 : List U8 = CallByName List.80 List.437 List.438 List.439 List.539 List.540;
-    ret List.537;
+    ret List.538;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.576 : U64 = 0i64;
+    let List.577 : U64 = 0i64;
-    let List.577 : U64 = CallByName List.6 List.436;
+    let List.578 : U64 = CallByName List.6 List.437;
-    let List.575 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.576 List.577;
+    let List.576 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.577 List.578;
-    ret List.575;
+    ret List.576;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.297 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.293 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.297;
+    ret Num.293;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.300 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.300;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.295 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -161,6 +157,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.301 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.301;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.297;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.300 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.300;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.294 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.294;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -45,194 +45,194 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.567 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
+    let List.568 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
-    ret List.567;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.587 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.587;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.548 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.548;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.568 : List U8 = CallByName List.93 List.142 List.143 List.144;
     ret List.568;
 
+procedure List.145 (List.146, List.147, List.144):
+    let List.588 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    ret List.588;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.549 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.549;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.569 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    ret List.569;
+
 procedure List.26 (List.159, List.160, List.161):
-    let List.618 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.619 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.621 : U8 = 1i64;
+    let List.622 : U8 = 1i64;
-    let List.622 : U8 = GetTagId List.618;
+    let List.623 : U8 = GetTagId List.619;
-    let List.623 : Int1 = lowlevel Eq List.621 List.622;
+    let List.624 : Int1 = lowlevel Eq List.622 List.623;
-    if List.623 then
+    if List.624 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.618;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.619;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.618;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.619;
         ret List.163;
 
 procedure List.4 (List.113, List.114):
-    let List.547 : U64 = 1i64;
+    let List.548 : U64 = 1i64;
-    let List.546 : List U8 = CallByName List.70 List.113 List.547;
+    let List.547 : List U8 = CallByName List.70 List.113 List.548;
-    let List.545 : List U8 = CallByName List.71 List.546 List.114;
+    let List.546 : List U8 = CallByName List.71 List.547 List.114;
-    ret List.545;
+    ret List.546;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.610 : U64 = StructAtIndex 0 List.377;
+    let List.611 : U64 = StructAtIndex 0 List.378;
-    let List.611 : U64 = 0i64;
+    let List.612 : U64 = 0i64;
-    let List.608 : Int1 = CallByName Bool.11 List.610 List.611;
+    let List.609 : Int1 = CallByName Bool.11 List.611 List.612;
-    if List.608 then
+    if List.609 then
-        dec List.376;
+        dec List.377;
-        let List.609 : List U8 = Array [];
+        let List.610 : List U8 = Array [];
-        ret List.609;
+        ret List.610;
     else
-        let List.605 : U64 = StructAtIndex 1 List.377;
+        let List.606 : U64 = StructAtIndex 1 List.378;
-        let List.606 : U64 = StructAtIndex 0 List.377;
+        let List.607 : U64 = StructAtIndex 0 List.378;
-        let List.604 : List U8 = CallByName List.72 List.376 List.605 List.606;
+        let List.605 : List U8 = CallByName List.72 List.377 List.606 List.607;
-        ret List.604;
+        ret List.605;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.616 List.394:
+    joinpoint List.617 List.395:
-        let List.614 : U64 = 0i64;
+        let List.615 : U64 = 0i64;
-        let List.613 : {U64, U64} = Struct {List.394, List.614};
+        let List.614 : {U64, U64} = Struct {List.395, List.615};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.613;
+        let List.396 : List U8 = CallByName List.49 List.392 List.614;
-        let List.612 : U64 = CallByName Num.20 List.393 List.394;
+        let List.613 : U64 = CallByName Num.75 List.394 List.395;
-        let List.603 : {U64, U64} = Struct {List.612, List.394};
+        let List.604 : {U64, U64} = Struct {List.613, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.603;
+        let List.397 : List U8 = CallByName List.49 List.392 List.604;
-        let List.602 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.603 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.602;
+        ret List.603;
     in
-    let List.617 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.618 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.617 then
+    if List.618 then
-        jump List.616 List.392;
+        jump List.617 List.393;
     else
-        jump List.616 List.393;
+        jump List.617 List.394;
 
 procedure List.6 (#Attr.2):
-    let List.588 : U64 = lowlevel ListLen #Attr.2;
+    let List.589 : U64 = lowlevel ListLen #Attr.2;
-    ret List.588;
+    ret List.589;
 
 procedure List.6 (#Attr.2):
-    let List.590 : U64 = lowlevel ListLen #Attr.2;
+    let List.591 : U64 = lowlevel ListLen #Attr.2;
-    ret List.590;
+    ret List.591;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.564 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.565 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.564;
+    ret List.565;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.584 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.585 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.584;
+    ret List.585;
 
 procedure List.68 (#Attr.2):
-    let List.601 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.602 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.601;
+    ret List.602;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.526 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.527 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.524 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.525 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.524;
+    ret List.525;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.607 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.608 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.607;
+    ret List.608;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.599 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.600 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.599;
+    ret List.600;
 
-procedure List.80 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
+procedure List.80 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
-    joinpoint List.627 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.575 List.440 List.441 List.442 List.443 List.444:
-        let List.629 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.577 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.629 then
+        if List.577 then
-            let List.638 : U8 = CallByName List.66 List.439 List.442;
+            let List.584 : U8 = CallByName List.66 List.440 List.443;
-            let List.630 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.638;
+            let List.578 : List U8 = CallByName List.145 List.441 List.584 List.442;
-            let List.635 : U8 = 1i64;
+            let List.581 : U64 = 1i64;
-            let List.636 : U8 = GetTagId List.630;
+            let List.580 : U64 = CallByName Num.51 List.443 List.581;
-            let List.637 : Int1 = lowlevel Eq List.635 List.636;
+            jump List.575 List.440 List.578 List.442 List.580 List.444;
-            if List.637 then
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.630;
-                let List.633 : U64 = 1i64;
-                let List.632 : U64 = CallByName Num.19 List.442 List.633;
-                jump List.627 List.439 List.444 List.441 List.632 List.443;
-            else
-                dec List.439;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.630;
-                let List.634 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
-                ret List.634;
         else
-            dec List.439;
+            dec List.440;
-            let List.628 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            ret List.441;
-            ret List.628;
     in
-    jump List.627 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
+    jump List.575 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
 procedure List.80 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
-    joinpoint List.574 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.628 List.440 List.441 List.442 List.443 List.444:
-        let List.576 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.630 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.576 then
+        if List.630 then
-            let List.583 : U8 = CallByName List.66 List.439 List.442;
+            let List.639 : U8 = CallByName List.66 List.440 List.443;
-            let List.577 : List U8 = CallByName List.145 List.440 List.583 List.441;
+            let List.631 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.639;
-            let List.580 : U64 = 1i64;
+            let List.636 : U8 = 1i64;
-            let List.579 : U64 = CallByName Num.19 List.442 List.580;
+            let List.637 : U8 = GetTagId List.631;
-            jump List.574 List.439 List.577 List.441 List.579 List.443;
+            let List.638 : Int1 = lowlevel Eq List.636 List.637;
+            if List.638 then
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.631;
+                let List.634 : U64 = 1i64;
+                let List.633 : U64 = CallByName Num.51 List.443 List.634;
+                jump List.628 List.440 List.445 List.442 List.633 List.444;
+            else
+                dec List.440;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.631;
+                let List.635 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
+                ret List.635;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            let List.629 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
+            ret List.629;
     in
-    jump List.574 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
+    jump List.628 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
 
 procedure List.80 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
-    joinpoint List.554 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.555 List.440 List.441 List.442 List.443 List.444:
-        let List.556 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.557 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.556 then
+        if List.557 then
-            let List.563 : Str = CallByName List.66 List.439 List.442;
+            let List.564 : Str = CallByName List.66 List.440 List.443;
-            inc List.563;
+            inc List.564;
-            let List.557 : {List U8, U64} = CallByName List.145 List.440 List.563 List.441;
+            let List.558 : {List U8, U64} = CallByName List.145 List.441 List.564 List.442;
-            let List.560 : U64 = 1i64;
+            let List.561 : U64 = 1i64;
-            let List.559 : U64 = CallByName Num.19 List.442 List.560;
+            let List.560 : U64 = CallByName Num.51 List.443 List.561;
-            jump List.554 List.439 List.557 List.441 List.559 List.443;
+            jump List.555 List.440 List.558 List.442 List.560 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.554 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
+    jump List.555 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.552 : U64 = 0i64;
+    let List.553 : U64 = 0i64;
-    let List.553 : U64 = CallByName List.6 List.436;
+    let List.554 : U64 = CallByName List.6 List.437;
-    let List.551 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.552 List.553;
+    let List.552 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.553 List.554;
-    ret List.551;
+    ret List.552;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.572 : U64 = 0i64;
+    let List.573 : U64 = 0i64;
-    let List.573 : U64 = CallByName List.6 List.436;
+    let List.574 : U64 = CallByName List.6 List.437;
-    let List.571 : List U8 = CallByName List.80 List.436 List.437 List.438 List.572 List.573;
+    let List.572 : List U8 = CallByName List.80 List.437 List.438 List.439 List.573 List.574;
-    ret List.571;
+    ret List.572;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.625 : U64 = 0i64;
+    let List.626 : U64 = 0i64;
-    let List.626 : U64 = CallByName List.6 List.436;
+    let List.627 : U64 = CallByName List.6 List.437;
-    let List.624 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.625 List.626;
+    let List.625 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.626 List.627;
-    ret List.624;
+    ret List.625;
 
 procedure Num.127 (#Attr.2):
     let Num.299 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.299;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.308 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.303 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.308;
+    ret Num.303;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.312 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.300 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.312;
+    ret Num.300;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.305 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -246,6 +246,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.313 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.313;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.308 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.308;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.312 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.312;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.304 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.304;

crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt

@@ -48,194 +48,194 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.567 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
+    let List.568 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
-    ret List.567;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.587 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.587;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.548 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.548;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.568 : List U8 = CallByName List.93 List.142 List.143 List.144;
     ret List.568;
 
+procedure List.145 (List.146, List.147, List.144):
+    let List.588 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    ret List.588;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.549 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.549;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.569 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    ret List.569;
+
 procedure List.26 (List.159, List.160, List.161):
-    let List.618 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.619 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.621 : U8 = 1i64;
+    let List.622 : U8 = 1i64;
-    let List.622 : U8 = GetTagId List.618;
+    let List.623 : U8 = GetTagId List.619;
-    let List.623 : Int1 = lowlevel Eq List.621 List.622;
+    let List.624 : Int1 = lowlevel Eq List.622 List.623;
-    if List.623 then
+    if List.624 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.618;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.619;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.618;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.619;
         ret List.163;
 
 procedure List.4 (List.113, List.114):
-    let List.547 : U64 = 1i64;
+    let List.548 : U64 = 1i64;
-    let List.546 : List U8 = CallByName List.70 List.113 List.547;
+    let List.547 : List U8 = CallByName List.70 List.113 List.548;
-    let List.545 : List U8 = CallByName List.71 List.546 List.114;
+    let List.546 : List U8 = CallByName List.71 List.547 List.114;
-    ret List.545;
+    ret List.546;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.610 : U64 = StructAtIndex 0 List.377;
+    let List.611 : U64 = StructAtIndex 0 List.378;
-    let List.611 : U64 = 0i64;
+    let List.612 : U64 = 0i64;
-    let List.608 : Int1 = CallByName Bool.11 List.610 List.611;
+    let List.609 : Int1 = CallByName Bool.11 List.611 List.612;
-    if List.608 then
+    if List.609 then
-        dec List.376;
+        dec List.377;
-        let List.609 : List U8 = Array [];
+        let List.610 : List U8 = Array [];
-        ret List.609;
+        ret List.610;
     else
-        let List.605 : U64 = StructAtIndex 1 List.377;
+        let List.606 : U64 = StructAtIndex 1 List.378;
-        let List.606 : U64 = StructAtIndex 0 List.377;
+        let List.607 : U64 = StructAtIndex 0 List.378;
-        let List.604 : List U8 = CallByName List.72 List.376 List.605 List.606;
+        let List.605 : List U8 = CallByName List.72 List.377 List.606 List.607;
-        ret List.604;
+        ret List.605;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.616 List.394:
+    joinpoint List.617 List.395:
-        let List.614 : U64 = 0i64;
+        let List.615 : U64 = 0i64;
-        let List.613 : {U64, U64} = Struct {List.394, List.614};
+        let List.614 : {U64, U64} = Struct {List.395, List.615};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.613;
+        let List.396 : List U8 = CallByName List.49 List.392 List.614;
-        let List.612 : U64 = CallByName Num.20 List.393 List.394;
+        let List.613 : U64 = CallByName Num.75 List.394 List.395;
-        let List.603 : {U64, U64} = Struct {List.612, List.394};
+        let List.604 : {U64, U64} = Struct {List.613, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.603;
+        let List.397 : List U8 = CallByName List.49 List.392 List.604;
-        let List.602 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.603 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.602;
+        ret List.603;
     in
-    let List.617 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.618 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.617 then
+    if List.618 then
-        jump List.616 List.392;
+        jump List.617 List.393;
     else
-        jump List.616 List.393;
+        jump List.617 List.394;
 
 procedure List.6 (#Attr.2):
-    let List.588 : U64 = lowlevel ListLen #Attr.2;
+    let List.589 : U64 = lowlevel ListLen #Attr.2;
-    ret List.588;
+    ret List.589;
 
 procedure List.6 (#Attr.2):
-    let List.590 : U64 = lowlevel ListLen #Attr.2;
+    let List.591 : U64 = lowlevel ListLen #Attr.2;
-    ret List.590;
+    ret List.591;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.564 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.565 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.564;
+    ret List.565;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.584 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.585 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.584;
+    ret List.585;
 
 procedure List.68 (#Attr.2):
-    let List.601 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.602 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.601;
+    ret List.602;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.526 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.527 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.524 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.525 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.524;
+    ret List.525;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.607 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.608 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.607;
+    ret List.608;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.599 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.600 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.599;
+    ret List.600;
 
 procedure List.80 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
-    joinpoint List.627 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.628 List.440 List.441 List.442 List.443 List.444:
-        let List.629 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.630 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.629 then
+        if List.630 then
-            let List.638 : U8 = CallByName List.66 List.439 List.442;
+            let List.639 : U8 = CallByName List.66 List.440 List.443;
-            let List.630 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.638;
+            let List.631 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.639;
-            let List.635 : U8 = 1i64;
+            let List.636 : U8 = 1i64;
-            let List.636 : U8 = GetTagId List.630;
+            let List.637 : U8 = GetTagId List.631;
-            let List.637 : Int1 = lowlevel Eq List.635 List.636;
+            let List.638 : Int1 = lowlevel Eq List.636 List.637;
-            if List.637 then
+            if List.638 then
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.630;
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.631;
-                let List.633 : U64 = 1i64;
+                let List.634 : U64 = 1i64;
-                let List.632 : U64 = CallByName Num.19 List.442 List.633;
+                let List.633 : U64 = CallByName Num.51 List.443 List.634;
-                jump List.627 List.439 List.444 List.441 List.632 List.443;
+                jump List.628 List.440 List.445 List.442 List.633 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.630;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.631;
-                let List.634 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
+                let List.635 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
-                ret List.634;
+                ret List.635;
         else
-            dec List.439;
+            dec List.440;
-            let List.628 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            let List.629 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
-            ret List.628;
+            ret List.629;
     in
-    jump List.627 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
+    jump List.628 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
 
 procedure List.80 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
-    joinpoint List.554 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.555 List.440 List.441 List.442 List.443 List.444:
-        let List.556 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.557 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.556 then
+        if List.557 then
-            let List.563 : Str = CallByName List.66 List.439 List.442;
+            let List.564 : Str = CallByName List.66 List.440 List.443;
-            inc List.563;
+            inc List.564;
-            let List.557 : {List U8, U64} = CallByName List.145 List.440 List.563 List.441;
+            let List.558 : {List U8, U64} = CallByName List.145 List.441 List.564 List.442;
-            let List.560 : U64 = 1i64;
+            let List.561 : U64 = 1i64;
-            let List.559 : U64 = CallByName Num.19 List.442 List.560;
+            let List.560 : U64 = CallByName Num.51 List.443 List.561;
-            jump List.554 List.439 List.557 List.441 List.559 List.443;
+            jump List.555 List.440 List.558 List.442 List.560 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.554 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
+    jump List.555 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
 
-procedure List.80 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
+procedure List.80 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
-    joinpoint List.574 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.575 List.440 List.441 List.442 List.443 List.444:
-        let List.576 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.577 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.576 then
+        if List.577 then
-            let List.583 : U8 = CallByName List.66 List.439 List.442;
+            let List.584 : U8 = CallByName List.66 List.440 List.443;
-            let List.577 : List U8 = CallByName List.145 List.440 List.583 List.441;
+            let List.578 : List U8 = CallByName List.145 List.441 List.584 List.442;
-            let List.580 : U64 = 1i64;
+            let List.581 : U64 = 1i64;
-            let List.579 : U64 = CallByName Num.19 List.442 List.580;
+            let List.580 : U64 = CallByName Num.51 List.443 List.581;
-            jump List.574 List.439 List.577 List.441 List.579 List.443;
+            jump List.575 List.440 List.578 List.442 List.580 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
+    jump List.575 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.552 : U64 = 0i64;
+    let List.553 : U64 = 0i64;
-    let List.553 : U64 = CallByName List.6 List.436;
+    let List.554 : U64 = CallByName List.6 List.437;
-    let List.551 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.552 List.553;
+    let List.552 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.553 List.554;
-    ret List.551;
+    ret List.552;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.572 : U64 = 0i64;
+    let List.573 : U64 = 0i64;
-    let List.573 : U64 = CallByName List.6 List.436;
+    let List.574 : U64 = CallByName List.6 List.437;
-    let List.571 : List U8 = CallByName List.80 List.436 List.437 List.438 List.572 List.573;
+    let List.572 : List U8 = CallByName List.80 List.437 List.438 List.439 List.573 List.574;
-    ret List.571;
+    ret List.572;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.625 : U64 = 0i64;
+    let List.626 : U64 = 0i64;
-    let List.626 : U64 = CallByName List.6 List.436;
+    let List.627 : U64 = CallByName List.6 List.437;
-    let List.624 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.625 List.626;
+    let List.625 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.626 List.627;
-    ret List.624;
+    ret List.625;
 
 procedure Num.127 (#Attr.2):
     let Num.299 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.299;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.308 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.303 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.308;
+    ret Num.303;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.312 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.300 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.312;
+    ret Num.300;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.305 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -249,6 +249,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.313 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.313;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.308 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.308;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.312 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.312;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.304 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.304;

crates/compiler/test_mono/generated/ir_int_add.txt

@@ -1,6 +1,6 @@
 procedure List.6 (#Attr.2):
-    let List.521 : U64 = lowlevel ListLen #Attr.2;
+    let List.522 : U64 = lowlevel ListLen #Attr.2;
-    ret List.521;
+    ret List.522;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.294 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -7,41 +7,41 @@ procedure Bool.2 ():
     ret Bool.23;
 
 procedure List.2 (List.97, List.98):
-    let List.535 : U64 = CallByName List.6 List.97;
+    let List.536 : U64 = CallByName List.6 List.97;
-    let List.531 : Int1 = CallByName Num.22 List.98 List.535;
+    let List.532 : Int1 = CallByName Num.22 List.98 List.536;
-    if List.531 then
+    if List.532 then
-        let List.533 : I64 = CallByName List.66 List.97 List.98;
+        let List.534 : I64 = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.532 : [C {}, C I64] = TagId(1) List.533;
+        let List.533 : [C {}, C I64] = TagId(1) List.534;
-        ret List.532;
+        ret List.533;
     else
         dec List.97;
-        let List.530 : {} = Struct {};
+        let List.531 : {} = Struct {};
-        let List.529 : [C {}, C I64] = TagId(0) List.530;
+        let List.530 : [C {}, C I64] = TagId(0) List.531;
-        ret List.529;
+        ret List.530;
 
 procedure List.6 (#Attr.2):
-    let List.536 : U64 = lowlevel ListLen #Attr.2;
+    let List.537 : U64 = lowlevel ListLen #Attr.2;
-    ret List.536;
+    ret List.537;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.534 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.535 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.534;
+    ret List.535;
 
 procedure List.9 (List.293):
-    let List.528 : U64 = 0i64;
+    let List.529 : U64 = 0i64;
-    let List.521 : [C {}, C I64] = CallByName List.2 List.293 List.528;
+    let List.522 : [C {}, C I64] = CallByName List.2 List.293 List.529;
-    let List.525 : U8 = 1i64;
+    let List.526 : U8 = 1i64;
-    let List.526 : U8 = GetTagId List.521;
+    let List.527 : U8 = GetTagId List.522;
-    let List.527 : Int1 = lowlevel Eq List.525 List.526;
+    let List.528 : Int1 = lowlevel Eq List.526 List.527;
-    if List.527 then
+    if List.528 then
-        let List.294 : I64 = UnionAtIndex (Id 1) (Index 0) List.521;
+        let List.294 : I64 = UnionAtIndex (Id 1) (Index 0) List.522;
-        let List.522 : [C Int1, C I64] = TagId(1) List.294;
+        let List.523 : [C Int1, C I64] = TagId(1) List.294;
-        ret List.522;
-    else
-        let List.524 : Int1 = true;
-        let List.523 : [C Int1, C I64] = TagId(0) List.524;
         ret List.523;
+    else
+        let List.525 : Int1 = true;
+        let List.524 : [C Int1, C I64] = TagId(0) List.525;
+        ret List.524;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/issue_4749.txt

@@ -65,143 +65,143 @@ procedure Decode.27 (Decode.107, Decode.108):
         ret Decode.123;
 
 procedure List.1 (List.96):
-    let List.588 : U64 = CallByName List.6 List.96;
+    let List.589 : U64 = CallByName List.6 List.96;
     dec List.96;
-    let List.589 : U64 = 0i64;
+    let List.590 : U64 = 0i64;
-    let List.587 : Int1 = CallByName Bool.11 List.588 List.589;
+    let List.588 : Int1 = CallByName Bool.11 List.589 List.590;
-    ret List.587;
+    ret List.588;
 
 procedure List.2 (List.97, List.98):
-    let List.571 : U64 = CallByName List.6 List.97;
+    let List.572 : U64 = CallByName List.6 List.97;
-    let List.568 : Int1 = CallByName Num.22 List.98 List.571;
+    let List.569 : Int1 = CallByName Num.22 List.98 List.572;
-    if List.568 then
+    if List.569 then
-        let List.570 : U8 = CallByName List.66 List.97 List.98;
+        let List.571 : U8 = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.569 : [C {}, C U8] = TagId(1) List.570;
+        let List.570 : [C {}, C U8] = TagId(1) List.571;
-        ret List.569;
+        ret List.570;
     else
         dec List.97;
-        let List.567 : {} = Struct {};
+        let List.568 : {} = Struct {};
-        let List.566 : [C {}, C U8] = TagId(0) List.567;
+        let List.567 : [C {}, C U8] = TagId(0) List.568;
-        ret List.566;
+        ret List.567;
 
 procedure List.26 (List.159, List.160, List.161):
-    let List.590 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.93 List.159 List.160 List.161;
+    let List.591 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.93 List.159 List.160 List.161;
-    let List.593 : U8 = 1i64;
+    let List.594 : U8 = 1i64;
-    let List.594 : U8 = GetTagId List.590;
+    let List.595 : U8 = GetTagId List.591;
-    let List.595 : Int1 = lowlevel Eq List.593 List.594;
+    let List.596 : Int1 = lowlevel Eq List.594 List.595;
-    if List.595 then
+    if List.596 then
-        let List.162 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.590;
+        let List.162 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.591;
         ret List.162;
     else
-        let List.163 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.590;
+        let List.163 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.591;
         ret List.163;
 
 procedure List.29 (List.304, List.305):
-    let List.545 : U64 = CallByName List.6 List.304;
+    let List.546 : U64 = CallByName List.6 List.304;
-    let List.306 : U64 = CallByName Num.77 List.545 List.305;
+    let List.306 : U64 = CallByName Num.77 List.546 List.305;
-    let List.544 : List U8 = CallByName List.43 List.304 List.306;
+    let List.545 : List U8 = CallByName List.43 List.304 List.306;
-    ret List.544;
+    ret List.545;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.558 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.559 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.558;
+    ret List.559;
 
 procedure List.38 (List.298):
-    let List.557 : U64 = 0i64;
+    let List.558 : U64 = 0i64;
-    let List.556 : List U8 = CallByName List.31 List.298 List.557;
+    let List.557 : List U8 = CallByName List.31 List.298 List.558;
-    ret List.556;
+    ret List.557;
 
 procedure List.4 (List.113, List.114):
-    let List.555 : U64 = 1i64;
+    let List.556 : U64 = 1i64;
-    let List.554 : List U8 = CallByName List.70 List.113 List.555;
+    let List.555 : List U8 = CallByName List.70 List.113 List.556;
-    let List.553 : List U8 = CallByName List.71 List.554 List.114;
+    let List.554 : List U8 = CallByName List.71 List.555 List.114;
-    ret List.553;
+    ret List.554;
 
 procedure List.43 (List.302, List.303):
-    let List.537 : U64 = CallByName List.6 List.302;
+    let List.538 : U64 = CallByName List.6 List.302;
-    let List.536 : U64 = CallByName Num.77 List.537 List.303;
+    let List.537 : U64 = CallByName Num.77 List.538 List.303;
-    let List.527 : {U64, U64} = Struct {List.303, List.536};
+    let List.528 : {U64, U64} = Struct {List.303, List.537};
-    let List.526 : List U8 = CallByName List.49 List.302 List.527;
+    let List.527 : List U8 = CallByName List.49 List.302 List.528;
-    ret List.526;
+    ret List.527;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.584 : U64 = StructAtIndex 0 List.377;
+    let List.585 : U64 = StructAtIndex 0 List.378;
-    let List.585 : U64 = 0i64;
+    let List.586 : U64 = 0i64;
-    let List.582 : Int1 = CallByName Bool.11 List.584 List.585;
+    let List.583 : Int1 = CallByName Bool.11 List.585 List.586;
-    if List.582 then
+    if List.583 then
-        dec List.376;
+        dec List.377;
-        let List.583 : List U8 = Array [];
+        let List.584 : List U8 = Array [];
-        ret List.583;
+        ret List.584;
     else
-        let List.580 : U64 = StructAtIndex 1 List.377;
+        let List.581 : U64 = StructAtIndex 1 List.378;
-        let List.581 : U64 = StructAtIndex 0 List.377;
+        let List.582 : U64 = StructAtIndex 0 List.378;
-        let List.579 : List U8 = CallByName List.72 List.376 List.580 List.581;
+        let List.580 : List U8 = CallByName List.72 List.377 List.581 List.582;
-        ret List.579;
+        ret List.580;
 
 procedure List.6 (#Attr.2):
-    let List.611 : U64 = lowlevel ListLen #Attr.2;
+    let List.612 : U64 = lowlevel ListLen #Attr.2;
-    ret List.611;
+    ret List.612;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.564 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.565 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.564;
+    ret List.565;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.552 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.553 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.552;
+    ret List.553;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.550 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.551 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.550;
+    ret List.551;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.531 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.532 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.531;
+    ret List.532;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.547 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.548 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.547;
+    ret List.548;
 
-procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
+procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.599 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.600 List.440 List.441 List.442 List.443 List.444:
-        let List.601 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.602 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.601 then
+        if List.602 then
-            let List.610 : U8 = CallByName List.66 List.439 List.442;
+            let List.611 : U8 = CallByName List.66 List.440 List.443;
-            let List.602 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.440 List.610;
+            let List.603 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.441 List.611;
-            let List.607 : U8 = 1i64;
+            let List.608 : U8 = 1i64;
-            let List.608 : U8 = GetTagId List.602;
+            let List.609 : U8 = GetTagId List.603;
-            let List.609 : Int1 = lowlevel Eq List.607 List.608;
+            let List.610 : Int1 = lowlevel Eq List.608 List.609;
-            if List.609 then
+            if List.610 then
-                let List.444 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.602;
+                let List.445 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.603;
-                let List.605 : U64 = 1i64;
+                let List.606 : U64 = 1i64;
-                let List.604 : U64 = CallByName Num.19 List.442 List.605;
+                let List.605 : U64 = CallByName Num.51 List.443 List.606;
-                jump List.599 List.439 List.444 List.441 List.604 List.443;
+                jump List.600 List.440 List.445 List.442 List.605 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.602;
+                let List.446 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.603;
-                let List.606 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.445;
+                let List.607 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.446;
-                ret List.606;
+                ret List.607;
         else
-            dec List.439;
+            dec List.440;
-            let List.600 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.440;
+            let List.601 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.441;
-            ret List.600;
+            ret List.601;
     in
-    jump List.599 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.600 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.597 : U64 = 0i64;
+    let List.598 : U64 = 0i64;
-    let List.598 : U64 = CallByName List.6 List.436;
+    let List.599 : U64 = CallByName List.6 List.437;
-    let List.596 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.436 List.437 List.438 List.597 List.598;
+    let List.597 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.437 List.438 List.439 List.598 List.599;
-    ret List.596;
+    ret List.597;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.295 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.295;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.329 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.304 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.329;
+    ret Num.304;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.307 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
@@ -219,6 +219,10 @@ procedure Num.25 (#Attr.2, #Attr.3):
     let Num.319 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
     ret Num.319;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.329 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.329;
+
 procedure Num.71 (#Attr.2, #Attr.3):
     let Num.292 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
     ret Num.292;
@@ -247,8 +251,8 @@ procedure Str.9 (Str.79):
     else
         let Str.291 : U8 = StructAtIndex 3 Str.80;
         let Str.292 : U64 = StructAtIndex 0 Str.80;
-        let #Derived_gen.7 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.6 : Str = StructAtIndex 1 Str.80;
-        dec #Derived_gen.7;
+        dec #Derived_gen.6;
         let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
         let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
         ret Str.289;
@@ -361,8 +365,8 @@ procedure TotallyNotJson.534 (TotallyNotJson.535):
 
 procedure TotallyNotJson.536 (TotallyNotJson.1192):
     let TotallyNotJson.1193 : List U8 = StructAtIndex 1 TotallyNotJson.1192;
-    let #Derived_gen.6 : List U8 = StructAtIndex 0 TotallyNotJson.1192;
+    let #Derived_gen.7 : List U8 = StructAtIndex 0 TotallyNotJson.1192;
-    dec #Derived_gen.6;
+    dec #Derived_gen.7;
     ret TotallyNotJson.1193;
 
 procedure TotallyNotJson.60 ():
@@ -729,7 +733,7 @@ procedure TotallyNotJson.69 ():
     let TotallyNotJson.1247 : List U8 = CallByName TotallyNotJson.68 TotallyNotJson.1248 TotallyNotJson.1249 TotallyNotJson.1250 TotallyNotJson.1251;
     ret TotallyNotJson.1247;
 
-procedure TotallyNotJson.70 (#Derived_gen.0):
+procedure TotallyNotJson.70 (#Derived_gen.5):
     joinpoint TotallyNotJson.1198 TotallyNotJson.1166:
         let TotallyNotJson.600 : List U8 = StructAtIndex 0 TotallyNotJson.1166;
         inc 4 TotallyNotJson.600;
@@ -830,7 +834,7 @@ procedure TotallyNotJson.70 (#Derived_gen.0):
             let TotallyNotJson.1276 : {List U8, List U8} = Struct {TotallyNotJson.600, TotallyNotJson.601};
             ret TotallyNotJson.1276;
     in
-    jump TotallyNotJson.1198 #Derived_gen.0;
+    jump TotallyNotJson.1198 #Derived_gen.5;
 
 procedure TotallyNotJson.8 ():
     let TotallyNotJson.1172 : [C , C [], C , C , C , C ] = TagId(2) ;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -6,84 +6,80 @@ procedure Bool.2 ():
     let Bool.24 : Int1 = true;
     ret Bool.24;
 
-procedure List.194 (List.523, List.195, List.193):
+procedure List.194 (List.524, List.195, List.193):
-    let List.553 : Int1 = CallByName Test.1 List.195;
+    let List.554 : Int1 = CallByName Test.1 List.195;
-    if List.553 then
+    if List.554 then
-        let List.555 : {} = Struct {};
+        let List.556 : {} = Struct {};
-        let List.554 : [C {}, C {}] = TagId(1) List.555;
+        let List.555 : [C {}, C {}] = TagId(1) List.556;
-        ret List.554;
+        ret List.555;
     else
-        let List.552 : {} = Struct {};
+        let List.553 : {} = Struct {};
-        let List.551 : [C {}, C {}] = TagId(0) List.552;
+        let List.552 : [C {}, C {}] = TagId(0) List.553;
-        ret List.551;
+        ret List.552;
 
 procedure List.23 (#Attr.2, #Attr.3, #Attr.4):
-    let List.556 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListMap2 { xs: `#Attr.#arg1`, ys: `#Attr.#arg2` } #Attr.2 #Attr.3 Test.15 #Attr.4;
+    let List.557 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListMap2 { xs: `#Attr.#arg1`, ys: `#Attr.#arg2` } #Attr.2 #Attr.3 Test.15 #Attr.4;
     decref #Attr.3;
     decref #Attr.2;
-    ret List.556;
+    ret List.557;
 
 procedure List.56 (List.192, List.193):
-    let List.532 : {} = Struct {};
+    let List.533 : {} = Struct {};
-    let List.524 : [C {}, C {}] = CallByName List.93 List.192 List.532 List.193;
+    let List.525 : [C {}, C {}] = CallByName List.93 List.192 List.533 List.193;
-    let List.529 : U8 = 1i64;
+    let List.530 : U8 = 1i64;
-    let List.530 : U8 = GetTagId List.524;
+    let List.531 : U8 = GetTagId List.525;
-    let List.531 : Int1 = lowlevel Eq List.529 List.530;
+    let List.532 : Int1 = lowlevel Eq List.530 List.531;
-    if List.531 then
+    if List.532 then
-        let List.525 : Int1 = CallByName Bool.2;
+        let List.526 : Int1 = CallByName Bool.2;
-        ret List.525;
-    else
-        let List.526 : Int1 = CallByName Bool.1;
         ret List.526;
+    else
+        let List.527 : Int1 = CallByName Bool.1;
+        ret List.527;
 
 procedure List.6 (#Attr.2):
-    let List.522 : U64 = lowlevel ListLen #Attr.2;
+    let List.523 : U64 = lowlevel ListLen #Attr.2;
-    ret List.522;
+    ret List.523;
 
 procedure List.6 (#Attr.2):
-    let List.550 : U64 = lowlevel ListLen #Attr.2;
+    let List.551 : U64 = lowlevel ListLen #Attr.2;
-    ret List.550;
+    ret List.551;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.549 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.550 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.549;
+    ret List.550;
 
 procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
-    joinpoint List.537 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.538 List.440 List.441 List.442 List.443 List.444:
-        let List.539 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.540 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.539 then
+        if List.540 then
-            let List.548 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.439 List.442;
+            let List.549 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.440 List.443;
-            inc List.548;
+            inc List.549;
-            let List.540 : [C {}, C {}] = CallByName List.194 List.440 List.548 List.441;
+            let List.541 : [C {}, C {}] = CallByName List.194 List.441 List.549 List.442;
-            let List.545 : U8 = 1i64;
+            let List.546 : U8 = 1i64;
-            let List.546 : U8 = GetTagId List.540;
+            let List.547 : U8 = GetTagId List.541;
-            let List.547 : Int1 = lowlevel Eq List.545 List.546;
+            let List.548 : Int1 = lowlevel Eq List.546 List.547;
-            if List.547 then
+            if List.548 then
-                let List.444 : {} = UnionAtIndex (Id 1) (Index 0) List.540;
+                let List.445 : {} = UnionAtIndex (Id 1) (Index 0) List.541;
-                let List.543 : U64 = 1i64;
+                let List.544 : U64 = 1i64;
-                let List.542 : U64 = CallByName Num.19 List.442 List.543;
+                let List.543 : U64 = CallByName Num.51 List.443 List.544;
-                jump List.537 List.439 List.444 List.441 List.542 List.443;
+                jump List.538 List.440 List.445 List.442 List.543 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : {} = UnionAtIndex (Id 0) (Index 0) List.540;
+                let List.446 : {} = UnionAtIndex (Id 0) (Index 0) List.541;
-                let List.544 : [C {}, C {}] = TagId(0) List.445;
+                let List.545 : [C {}, C {}] = TagId(0) List.446;
-                ret List.544;
+                ret List.545;
         else
-            dec List.439;
+            dec List.440;
-            let List.538 : [C {}, C {}] = TagId(1) List.440;
+            let List.539 : [C {}, C {}] = TagId(1) List.441;
-            ret List.538;
+            ret List.539;
     in
-    jump List.537 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.538 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.535 : U64 = 0i64;
+    let List.536 : U64 = 0i64;
-    let List.536 : U64 = CallByName List.6 List.436;
+    let List.537 : U64 = CallByName List.6 List.437;
-    let List.534 : [C {}, C {}] = CallByName List.80 List.436 List.437 List.438 List.535 List.536;
+    let List.535 : [C {}, C {}] = CallByName List.80 List.437 List.438 List.439 List.536 List.537;
-    ret List.534;
+    ret List.535;
-
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
@@ -93,6 +89,10 @@ procedure Num.22 (#Attr.2, #Attr.3):
     let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.295;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.294;
+
 procedure Test.1 (#Derived_gen.0):
     joinpoint Test.26 Test.6:
         let Test.65 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;

crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt

@@ -39,143 +39,143 @@ procedure Decode.26 (Decode.105, Decode.106):
     ret Decode.122;
 
 procedure List.1 (List.96):
-    let List.584 : U64 = CallByName List.6 List.96;
+    let List.585 : U64 = CallByName List.6 List.96;
     dec List.96;
-    let List.585 : U64 = 0i64;
+    let List.586 : U64 = 0i64;
-    let List.583 : Int1 = CallByName Bool.11 List.584 List.585;
+    let List.584 : Int1 = CallByName Bool.11 List.585 List.586;
-    ret List.583;
+    ret List.584;
 
 procedure List.2 (List.97, List.98):
-    let List.567 : U64 = CallByName List.6 List.97;
+    let List.568 : U64 = CallByName List.6 List.97;
-    let List.564 : Int1 = CallByName Num.22 List.98 List.567;
+    let List.565 : Int1 = CallByName Num.22 List.98 List.568;
-    if List.564 then
+    if List.565 then
-        let List.566 : U8 = CallByName List.66 List.97 List.98;
+        let List.567 : U8 = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.565 : [C {}, C U8] = TagId(1) List.566;
+        let List.566 : [C {}, C U8] = TagId(1) List.567;
-        ret List.565;
+        ret List.566;
     else
         dec List.97;
-        let List.563 : {} = Struct {};
+        let List.564 : {} = Struct {};
-        let List.562 : [C {}, C U8] = TagId(0) List.563;
+        let List.563 : [C {}, C U8] = TagId(0) List.564;
-        ret List.562;
+        ret List.563;
 
 procedure List.26 (List.159, List.160, List.161):
-    let List.586 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.93 List.159 List.160 List.161;
+    let List.587 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.93 List.159 List.160 List.161;
-    let List.589 : U8 = 1i64;
+    let List.590 : U8 = 1i64;
-    let List.590 : U8 = GetTagId List.586;
+    let List.591 : U8 = GetTagId List.587;
-    let List.591 : Int1 = lowlevel Eq List.589 List.590;
+    let List.592 : Int1 = lowlevel Eq List.590 List.591;
-    if List.591 then
+    if List.592 then
-        let List.162 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.586;
+        let List.162 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.587;
         ret List.162;
     else
-        let List.163 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.586;
+        let List.163 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.587;
         ret List.163;
 
 procedure List.29 (List.304, List.305):
-    let List.541 : U64 = CallByName List.6 List.304;
+    let List.542 : U64 = CallByName List.6 List.304;
-    let List.306 : U64 = CallByName Num.77 List.541 List.305;
+    let List.306 : U64 = CallByName Num.77 List.542 List.305;
-    let List.540 : List U8 = CallByName List.43 List.304 List.306;
+    let List.541 : List U8 = CallByName List.43 List.304 List.306;
-    ret List.540;
+    ret List.541;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.554 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.555 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.554;
+    ret List.555;
 
 procedure List.38 (List.298):
-    let List.553 : U64 = 0i64;
+    let List.554 : U64 = 0i64;
-    let List.552 : List U8 = CallByName List.31 List.298 List.553;
+    let List.553 : List U8 = CallByName List.31 List.298 List.554;
-    ret List.552;
+    ret List.553;
 
 procedure List.4 (List.113, List.114):
-    let List.551 : U64 = 1i64;
+    let List.552 : U64 = 1i64;
-    let List.550 : List U8 = CallByName List.70 List.113 List.551;
+    let List.551 : List U8 = CallByName List.70 List.113 List.552;
-    let List.549 : List U8 = CallByName List.71 List.550 List.114;
+    let List.550 : List U8 = CallByName List.71 List.551 List.114;
-    ret List.549;
+    ret List.550;
 
 procedure List.43 (List.302, List.303):
-    let List.533 : U64 = CallByName List.6 List.302;
+    let List.534 : U64 = CallByName List.6 List.302;
-    let List.532 : U64 = CallByName Num.77 List.533 List.303;
+    let List.533 : U64 = CallByName Num.77 List.534 List.303;
-    let List.523 : {U64, U64} = Struct {List.303, List.532};
+    let List.524 : {U64, U64} = Struct {List.303, List.533};
-    let List.522 : List U8 = CallByName List.49 List.302 List.523;
+    let List.523 : List U8 = CallByName List.49 List.302 List.524;
-    ret List.522;
+    ret List.523;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.580 : U64 = StructAtIndex 0 List.377;
+    let List.581 : U64 = StructAtIndex 0 List.378;
-    let List.581 : U64 = 0i64;
+    let List.582 : U64 = 0i64;
-    let List.578 : Int1 = CallByName Bool.11 List.580 List.581;
+    let List.579 : Int1 = CallByName Bool.11 List.581 List.582;
-    if List.578 then
+    if List.579 then
-        dec List.376;
+        dec List.377;
-        let List.579 : List U8 = Array [];
+        let List.580 : List U8 = Array [];
-        ret List.579;
+        ret List.580;
     else
-        let List.576 : U64 = StructAtIndex 1 List.377;
+        let List.577 : U64 = StructAtIndex 1 List.378;
-        let List.577 : U64 = StructAtIndex 0 List.377;
+        let List.578 : U64 = StructAtIndex 0 List.378;
-        let List.575 : List U8 = CallByName List.72 List.376 List.576 List.577;
+        let List.576 : List U8 = CallByName List.72 List.377 List.577 List.578;
-        ret List.575;
+        ret List.576;
 
 procedure List.6 (#Attr.2):
-    let List.607 : U64 = lowlevel ListLen #Attr.2;
+    let List.608 : U64 = lowlevel ListLen #Attr.2;
-    ret List.607;
+    ret List.608;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.560 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.561 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.560;
+    ret List.561;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.548 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.549 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.548;
+    ret List.549;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.546 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.547 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.546;
+    ret List.547;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.527 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.528 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.527;
+    ret List.528;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.543 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.544 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.543;
+    ret List.544;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.595 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.596 List.440 List.441 List.442 List.443 List.444:
-        let List.597 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.598 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.597 then
+        if List.598 then
-            let List.606 : U8 = CallByName List.66 List.439 List.442;
+            let List.607 : U8 = CallByName List.66 List.440 List.443;
-            let List.598 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.440 List.606;
+            let List.599 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.441 List.607;
-            let List.603 : U8 = 1i64;
+            let List.604 : U8 = 1i64;
-            let List.604 : U8 = GetTagId List.598;
+            let List.605 : U8 = GetTagId List.599;
-            let List.605 : Int1 = lowlevel Eq List.603 List.604;
+            let List.606 : Int1 = lowlevel Eq List.604 List.605;
-            if List.605 then
+            if List.606 then
-                let List.444 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.598;
+                let List.445 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.599;
-                let List.601 : U64 = 1i64;
+                let List.602 : U64 = 1i64;
-                let List.600 : U64 = CallByName Num.19 List.442 List.601;
+                let List.601 : U64 = CallByName Num.51 List.443 List.602;
-                jump List.595 List.439 List.444 List.441 List.600 List.443;
+                jump List.596 List.440 List.445 List.442 List.601 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.598;
+                let List.446 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.599;
-                let List.602 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.445;
+                let List.603 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.446;
-                ret List.602;
+                ret List.603;
         else
-            dec List.439;
+            dec List.440;
-            let List.596 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.440;
+            let List.597 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.441;
-            ret List.596;
+            ret List.597;
     in
-    jump List.595 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.596 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.593 : U64 = 0i64;
+    let List.594 : U64 = 0i64;
-    let List.594 : U64 = CallByName List.6 List.436;
+    let List.595 : U64 = CallByName List.6 List.437;
-    let List.592 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.436 List.437 List.438 List.593 List.594;
+    let List.593 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.437 List.438 List.439 List.594 List.595;
-    ret List.592;
+    ret List.593;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.295 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.295;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.329 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.304 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.329;
+    ret Num.304;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.307 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
@@ -193,6 +193,10 @@ procedure Num.25 (#Attr.2, #Attr.3):
     let Num.319 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
     ret Num.319;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.329 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.329;
+
 procedure Num.71 (#Attr.2, #Attr.3):
     let Num.292 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
     ret Num.292;

crates/compiler/test_mono/generated/layout_cache_structure_with_multiple_recursive_structures.txt

@@ -1,49 +1,49 @@
 procedure List.145 (List.146, List.147, List.144):
-    let List.540 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.146 List.147;
+    let List.541 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.146 List.147;
-    ret List.540;
+    ret List.541;
 
 procedure List.18 (List.142, List.143, List.144):
-    let List.521 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.93 List.142 List.143 List.144;
+    let List.522 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.93 List.142 List.143 List.144;
-    ret List.521;
+    ret List.522;
 
 procedure List.6 (#Attr.2):
-    let List.538 : U64 = lowlevel ListLen #Attr.2;
+    let List.539 : U64 = lowlevel ListLen #Attr.2;
-    ret List.538;
+    ret List.539;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.537 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.538 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.537;
+    ret List.538;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.527 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.528 List.440 List.441 List.442 List.443 List.444:
-        let List.529 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.530 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.529 then
+        if List.530 then
-            let List.536 : [<rnu>C *self, <null>] = CallByName List.66 List.439 List.442;
+            let List.537 : [<rnu>C *self, <null>] = CallByName List.66 List.440 List.443;
-            inc List.536;
+            inc List.537;
-            let List.530 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.145 List.440 List.536 List.441;
+            let List.531 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.145 List.441 List.537 List.442;
-            let List.533 : U64 = 1i64;
+            let List.534 : U64 = 1i64;
-            let List.532 : U64 = CallByName Num.19 List.442 List.533;
+            let List.533 : U64 = CallByName Num.51 List.443 List.534;
-            jump List.527 List.439 List.530 List.441 List.532 List.443;
+            jump List.528 List.440 List.531 List.442 List.533 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.527 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.528 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.525 : U64 = 0i64;
+    let List.526 : U64 = 0i64;
-    let List.526 : U64 = CallByName List.6 List.436;
+    let List.527 : U64 = CallByName List.6 List.437;
-    let List.524 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.80 List.436 List.437 List.438 List.525 List.526;
+    let List.525 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.80 List.437 List.438 List.439 List.526 List.527;
-    ret List.524;
+    ret List.525;
-
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.292;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.293 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.293;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
+
 procedure Test.7 (Test.11, Test.12):
     let Test.17 : {[<rnu>C *self, <null>], [<rnu><null>, C {[<rnu>C *self, <null>], *self}]} = Struct {Test.12, Test.11};
     let Test.16 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = TagId(0) Test.17;

crates/compiler/test_mono/generated/list_append.txt

@@ -1,16 +1,16 @@
 procedure List.4 (List.113, List.114):
-    let List.524 : U64 = 1i64;
+    let List.525 : U64 = 1i64;
-    let List.522 : List I64 = CallByName List.70 List.113 List.524;
+    let List.523 : List I64 = CallByName List.70 List.113 List.525;
-    let List.521 : List I64 = CallByName List.71 List.522 List.114;
+    let List.522 : List I64 = CallByName List.71 List.523 List.114;
-    ret List.521;
+    ret List.522;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.525 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.526 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.525;
+    ret List.526;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.523 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.524 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.523;
+    ret List.524;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [1i64];

crates/compiler/test_mono/generated/list_append_closure.txt

@@ -1,16 +1,16 @@
 procedure List.4 (List.113, List.114):
-    let List.524 : U64 = 1i64;
+    let List.525 : U64 = 1i64;
-    let List.522 : List I64 = CallByName List.70 List.113 List.524;
+    let List.523 : List I64 = CallByName List.70 List.113 List.525;
-    let List.521 : List I64 = CallByName List.71 List.522 List.114;
+    let List.522 : List I64 = CallByName List.71 List.523 List.114;
-    ret List.521;
+    ret List.522;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.525 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.526 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.525;
+    ret List.526;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.523 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.524 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.523;
+    ret List.524;
 
 procedure Test.1 (Test.2):
     let Test.6 : I64 = 42i64;

crates/compiler/test_mono/generated/list_cannot_update_inplace.txt

@@ -1,25 +1,25 @@
 procedure List.3 (List.105, List.106, List.107):
-    let List.524 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
+    let List.525 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
-    let List.523 : List I64 = StructAtIndex 0 List.524;
+    let List.524 : List I64 = StructAtIndex 0 List.525;
-    ret List.523;
+    ret List.524;
 
 procedure List.6 (#Attr.2):
-    let List.522 : U64 = lowlevel ListLen #Attr.2;
+    let List.523 : U64 = lowlevel ListLen #Attr.2;
-    ret List.522;
+    ret List.523;
 
 procedure List.64 (List.102, List.103, List.104):
-    let List.529 : U64 = CallByName List.6 List.102;
+    let List.530 : U64 = CallByName List.6 List.102;
-    let List.526 : Int1 = CallByName Num.22 List.103 List.529;
+    let List.527 : Int1 = CallByName Num.22 List.103 List.530;
-    if List.526 then
+    if List.527 then
-        let List.527 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
+        let List.528 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
-        ret List.527;
+        ret List.528;
     else
-        let List.525 : {List I64, I64} = Struct {List.102, List.104};
+        let List.526 : {List I64, I64} = Struct {List.102, List.104};
-        ret List.525;
+        ret List.526;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.528 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    let List.529 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.528;
+    ret List.529;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_get.txt

@@ -1,24 +1,24 @@
 procedure List.2 (List.97, List.98):
-    let List.527 : U64 = CallByName List.6 List.97;
+    let List.528 : U64 = CallByName List.6 List.97;
-    let List.523 : Int1 = CallByName Num.22 List.98 List.527;
+    let List.524 : Int1 = CallByName Num.22 List.98 List.528;
-    if List.523 then
+    if List.524 then
-        let List.525 : I64 = CallByName List.66 List.97 List.98;
+        let List.526 : I64 = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.524 : [C {}, C I64] = TagId(1) List.525;
+        let List.525 : [C {}, C I64] = TagId(1) List.526;
-        ret List.524;
+        ret List.525;
     else
         dec List.97;
-        let List.522 : {} = Struct {};
+        let List.523 : {} = Struct {};
-        let List.521 : [C {}, C I64] = TagId(0) List.522;
+        let List.522 : [C {}, C I64] = TagId(0) List.523;
-        ret List.521;
+        ret List.522;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.526 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.527 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_len.txt

@@ -1,11 +1,11 @@
-procedure List.6 (#Attr.2):
-    let List.521 : U64 = lowlevel ListLen #Attr.2;
-    ret List.521;
-
 procedure List.6 (#Attr.2):
     let List.522 : U64 = lowlevel ListLen #Attr.2;
     ret List.522;
 
+procedure List.6 (#Attr.2):
+    let List.523 : U64 = lowlevel ListLen #Attr.2;
+    ret List.523;
+
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.292;

crates/compiler/test_mono/generated/list_map_closure_borrows.txt

@@ -1,30 +1,30 @@
 procedure List.2 (List.97, List.98):
-    let List.527 : U64 = CallByName List.6 List.97;
+    let List.528 : U64 = CallByName List.6 List.97;
-    let List.523 : Int1 = CallByName Num.22 List.98 List.527;
+    let List.524 : Int1 = CallByName Num.22 List.98 List.528;
-    if List.523 then
+    if List.524 then
-        let List.525 : Str = CallByName List.66 List.97 List.98;
+        let List.526 : Str = CallByName List.66 List.97 List.98;
-        inc List.525;
+        inc List.526;
         dec List.97;
-        let List.524 : [C {}, C Str] = TagId(1) List.525;
+        let List.525 : [C {}, C Str] = TagId(1) List.526;
-        ret List.524;
+        ret List.525;
     else
         dec List.97;
-        let List.522 : {} = Struct {};
+        let List.523 : {} = Struct {};
-        let List.521 : [C {}, C Str] = TagId(0) List.522;
+        let List.522 : [C {}, C Str] = TagId(0) List.523;
-        ret List.521;
+        ret List.522;
 
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.529 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
+    let List.530 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
     decref #Attr.2;
-    ret List.529;
+    ret List.530;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.526 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.527 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_closure_owns.txt

@@ -1,30 +1,30 @@
 procedure List.2 (List.97, List.98):
-    let List.527 : U64 = CallByName List.6 List.97;
+    let List.528 : U64 = CallByName List.6 List.97;
-    let List.523 : Int1 = CallByName Num.22 List.98 List.527;
+    let List.524 : Int1 = CallByName Num.22 List.98 List.528;
-    if List.523 then
+    if List.524 then
-        let List.525 : Str = CallByName List.66 List.97 List.98;
+        let List.526 : Str = CallByName List.66 List.97 List.98;
-        inc List.525;
+        inc List.526;
         dec List.97;
-        let List.524 : [C {}, C Str] = TagId(1) List.525;
+        let List.525 : [C {}, C Str] = TagId(1) List.526;
-        ret List.524;
+        ret List.525;
     else
         dec List.97;
-        let List.522 : {} = Struct {};
+        let List.523 : {} = Struct {};
-        let List.521 : [C {}, C Str] = TagId(0) List.522;
+        let List.522 : [C {}, C Str] = TagId(0) List.523;
-        ret List.521;
+        ret List.522;
 
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.529 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
+    let List.530 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
     decref #Attr.2;
-    ret List.529;
+    ret List.530;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.526 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.527 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_take_capturing_or_noncapturing.txt

@@ -1,23 +1,23 @@
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.522 : U8 = GetTagId #Attr.3;
+    let List.523 : U8 = GetTagId #Attr.3;
-    joinpoint List.523 List.521:
+    joinpoint List.524 List.522:
-        ret List.521;
+        ret List.522;
     in
-    switch List.522:
+    switch List.523:
         case 0:
-            let List.524 : List U8 = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.4 #Attr.3;
+            let List.525 : List U8 = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.4 #Attr.3;
             decref #Attr.2;
-            jump List.523 List.524;
+            jump List.524 List.525;
     
         case 1:
-            let List.525 : List U8 = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.6 #Attr.3;
+            let List.526 : List U8 = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.6 #Attr.3;
             decref #Attr.2;
-            jump List.523 List.525;
+            jump List.524 List.526;
     
         default:
-            let List.526 : List U8 = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.8 #Attr.3;
+            let List.527 : List U8 = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.8 #Attr.3;
             decref #Attr.2;
-            jump List.523 List.526;
+            jump List.524 List.527;
     
 
 procedure Num.19 (#Attr.2, #Attr.3):

crates/compiler/test_mono/generated/list_pass_to_function.txt

@@ -1,25 +1,25 @@
 procedure List.3 (List.105, List.106, List.107):
-    let List.522 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
+    let List.523 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
-    let List.521 : List I64 = StructAtIndex 0 List.522;
+    let List.522 : List I64 = StructAtIndex 0 List.523;
-    ret List.521;
+    ret List.522;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.64 (List.102, List.103, List.104):
-    let List.527 : U64 = CallByName List.6 List.102;
+    let List.528 : U64 = CallByName List.6 List.102;
-    let List.524 : Int1 = CallByName Num.22 List.103 List.527;
+    let List.525 : Int1 = CallByName Num.22 List.103 List.528;
-    if List.524 then
+    if List.525 then
-        let List.525 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
+        let List.526 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
-        ret List.525;
+        ret List.526;
     else
-        let List.523 : {List I64, I64} = Struct {List.102, List.104};
+        let List.524 : {List I64, I64} = Struct {List.102, List.104};
-        ret List.523;
+        ret List.524;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.526 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    let List.527 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_sort_asc.txt

@@ -1,11 +1,11 @@
 procedure List.28 (#Attr.2, #Attr.3):
-    let List.523 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
+    let List.524 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
-    ret List.523;
+    ret List.524;
 
 procedure List.59 (List.288):
-    let List.522 : {} = Struct {};
+    let List.523 : {} = Struct {};
-    let List.521 : List I64 = CallByName List.28 List.288 List.522;
+    let List.522 : List I64 = CallByName List.28 List.288 List.523;
-    ret List.521;
+    ret List.522;
 
 procedure Num.46 (#Attr.2, #Attr.3):
     let Num.292 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/quicksort_swap.txt

@@ -1,43 +1,43 @@
 procedure List.2 (List.97, List.98):
-    let List.543 : U64 = CallByName List.6 List.97;
+    let List.544 : U64 = CallByName List.6 List.97;
-    let List.540 : Int1 = CallByName Num.22 List.98 List.543;
+    let List.541 : Int1 = CallByName Num.22 List.98 List.544;
-    if List.540 then
+    if List.541 then
-        let List.542 : I64 = CallByName List.66 List.97 List.98;
+        let List.543 : I64 = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.541 : [C {}, C I64] = TagId(1) List.542;
+        let List.542 : [C {}, C I64] = TagId(1) List.543;
-        ret List.541;
+        ret List.542;
     else
         dec List.97;
-        let List.539 : {} = Struct {};
+        let List.540 : {} = Struct {};
-        let List.538 : [C {}, C I64] = TagId(0) List.539;
+        let List.539 : [C {}, C I64] = TagId(0) List.540;
-        ret List.538;
+        ret List.539;
 
 procedure List.3 (List.105, List.106, List.107):
-    let List.530 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
+    let List.531 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
-    let List.529 : List I64 = StructAtIndex 0 List.530;
+    let List.530 : List I64 = StructAtIndex 0 List.531;
-    ret List.529;
+    ret List.530;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.64 (List.102, List.103, List.104):
-    let List.527 : U64 = CallByName List.6 List.102;
+    let List.528 : U64 = CallByName List.6 List.102;
-    let List.524 : Int1 = CallByName Num.22 List.103 List.527;
+    let List.525 : Int1 = CallByName Num.22 List.103 List.528;
-    if List.524 then
+    if List.525 then
-        let List.525 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
+        let List.526 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
-        ret List.525;
+        ret List.526;
     else
-        let List.523 : {List I64, I64} = Struct {List.102, List.104};
+        let List.524 : {List I64, I64} = Struct {List.102, List.104};
-        ret List.523;
+        ret List.524;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.536 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.537 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.536;
+    ret List.537;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.526 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    let List.527 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/record_update.txt

@@ -1,25 +1,25 @@
 procedure List.3 (List.105, List.106, List.107):
-    let List.530 : {List U64, U64} = CallByName List.64 List.105 List.106 List.107;
+    let List.531 : {List U64, U64} = CallByName List.64 List.105 List.106 List.107;
-    let List.529 : List U64 = StructAtIndex 0 List.530;
+    let List.530 : List U64 = StructAtIndex 0 List.531;
-    ret List.529;
+    ret List.530;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.64 (List.102, List.103, List.104):
-    let List.527 : U64 = CallByName List.6 List.102;
+    let List.528 : U64 = CallByName List.6 List.102;
-    let List.524 : Int1 = CallByName Num.22 List.103 List.527;
+    let List.525 : Int1 = CallByName Num.22 List.103 List.528;
-    if List.524 then
+    if List.525 then
-        let List.525 : {List U64, U64} = CallByName List.67 List.102 List.103 List.104;
+        let List.526 : {List U64, U64} = CallByName List.67 List.102 List.103 List.104;
-        ret List.525;
+        ret List.526;
     else
-        let List.523 : {List U64, U64} = Struct {List.102, List.104};
+        let List.524 : {List U64, U64} = Struct {List.102, List.104};
-        ret List.523;
+        ret List.524;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.526 : {List U64, U64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    let List.527 : {List U64, U64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/recursive_function_and_union_with_inference_hole.txt

@@ -1,7 +1,7 @@
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.521 : List [<rnnu>C List *self] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
+    let List.522 : List [<rnnu>C List *self] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
     decref #Attr.2;
-    ret List.521;
+    ret List.522;
 
 procedure Test.2 (Test.5):
     let Test.6 : List [<rnnu>C List *self] = UnionAtIndex (Id 0) (Index 0) Test.5;

crates/compiler/test_mono/generated/rigids.txt

@@ -1,43 +1,43 @@
 procedure List.2 (List.97, List.98):
-    let List.543 : U64 = CallByName List.6 List.97;
+    let List.544 : U64 = CallByName List.6 List.97;
-    let List.540 : Int1 = CallByName Num.22 List.98 List.543;
+    let List.541 : Int1 = CallByName Num.22 List.98 List.544;
-    if List.540 then
+    if List.541 then
-        let List.542 : I64 = CallByName List.66 List.97 List.98;
+        let List.543 : I64 = CallByName List.66 List.97 List.98;
         dec List.97;
-        let List.541 : [C {}, C I64] = TagId(1) List.542;
+        let List.542 : [C {}, C I64] = TagId(1) List.543;
-        ret List.541;
+        ret List.542;
     else
         dec List.97;
-        let List.539 : {} = Struct {};
+        let List.540 : {} = Struct {};
-        let List.538 : [C {}, C I64] = TagId(0) List.539;
+        let List.539 : [C {}, C I64] = TagId(0) List.540;
-        ret List.538;
+        ret List.539;
 
 procedure List.3 (List.105, List.106, List.107):
-    let List.530 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
+    let List.531 : {List I64, I64} = CallByName List.64 List.105 List.106 List.107;
-    let List.529 : List I64 = StructAtIndex 0 List.530;
+    let List.530 : List I64 = StructAtIndex 0 List.531;
-    ret List.529;
+    ret List.530;
 
 procedure List.6 (#Attr.2):
-    let List.528 : U64 = lowlevel ListLen #Attr.2;
+    let List.529 : U64 = lowlevel ListLen #Attr.2;
-    ret List.528;
+    ret List.529;
 
 procedure List.64 (List.102, List.103, List.104):
-    let List.527 : U64 = CallByName List.6 List.102;
+    let List.528 : U64 = CallByName List.6 List.102;
-    let List.524 : Int1 = CallByName Num.22 List.103 List.527;
+    let List.525 : Int1 = CallByName Num.22 List.103 List.528;
-    if List.524 then
+    if List.525 then
-        let List.525 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
+        let List.526 : {List I64, I64} = CallByName List.67 List.102 List.103 List.104;
-        ret List.525;
+        ret List.526;
     else
-        let List.523 : {List I64, I64} = Struct {List.102, List.104};
+        let List.524 : {List I64, I64} = Struct {List.102, List.104};
-        ret List.523;
+        ret List.524;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.536 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.537 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.536;
+    ret List.537;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.526 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    let List.527 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.526;
+    ret List.527;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt

@@ -34,194 +34,194 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.566 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
+    let List.567 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
-    ret List.566;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.586 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
-    ret List.586;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.547 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.547;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.567 : List U8 = CallByName List.93 List.142 List.143 List.144;
     ret List.567;
 
+procedure List.145 (List.146, List.147, List.144):
+    let List.587 : List U8 = CallByName TotallyNotJson.215 List.146 List.147;
+    ret List.587;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.548 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
+    ret List.548;
+
+procedure List.18 (List.142, List.143, List.144):
+    let List.568 : List U8 = CallByName List.93 List.142 List.143 List.144;
+    ret List.568;
+
 procedure List.26 (List.159, List.160, List.161):
-    let List.617 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
+    let List.618 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.93 List.159 List.160 List.161;
-    let List.620 : U8 = 1i64;
+    let List.621 : U8 = 1i64;
-    let List.621 : U8 = GetTagId List.617;
+    let List.622 : U8 = GetTagId List.618;
-    let List.622 : Int1 = lowlevel Eq List.620 List.621;
+    let List.623 : Int1 = lowlevel Eq List.621 List.622;
-    if List.622 then
+    if List.623 then
-        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.617;
+        let List.162 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.618;
         ret List.162;
     else
-        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.617;
+        let List.163 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.618;
         ret List.163;
 
 procedure List.4 (List.113, List.114):
-    let List.546 : U64 = 1i64;
+    let List.547 : U64 = 1i64;
-    let List.545 : List U8 = CallByName List.70 List.113 List.546;
+    let List.546 : List U8 = CallByName List.70 List.113 List.547;
-    let List.544 : List U8 = CallByName List.71 List.545 List.114;
+    let List.545 : List U8 = CallByName List.71 List.546 List.114;
-    ret List.544;
+    ret List.545;
 
-procedure List.49 (List.376, List.377):
+procedure List.49 (List.377, List.378):
-    let List.609 : U64 = StructAtIndex 0 List.377;
+    let List.610 : U64 = StructAtIndex 0 List.378;
-    let List.610 : U64 = 0i64;
+    let List.611 : U64 = 0i64;
-    let List.607 : Int1 = CallByName Bool.11 List.609 List.610;
+    let List.608 : Int1 = CallByName Bool.11 List.610 List.611;
-    if List.607 then
+    if List.608 then
-        dec List.376;
+        dec List.377;
-        let List.608 : List U8 = Array [];
+        let List.609 : List U8 = Array [];
-        ret List.608;
+        ret List.609;
     else
-        let List.604 : U64 = StructAtIndex 1 List.377;
+        let List.605 : U64 = StructAtIndex 1 List.378;
-        let List.605 : U64 = StructAtIndex 0 List.377;
+        let List.606 : U64 = StructAtIndex 0 List.378;
-        let List.603 : List U8 = CallByName List.72 List.376 List.604 List.605;
+        let List.604 : List U8 = CallByName List.72 List.377 List.605 List.606;
-        ret List.603;
+        ret List.604;
 
-procedure List.52 (List.391, List.392):
+procedure List.52 (List.392, List.393):
-    let List.393 : U64 = CallByName List.6 List.391;
+    let List.394 : U64 = CallByName List.6 List.392;
-    joinpoint List.615 List.394:
+    joinpoint List.616 List.395:
-        let List.613 : U64 = 0i64;
+        let List.614 : U64 = 0i64;
-        let List.612 : {U64, U64} = Struct {List.394, List.613};
+        let List.613 : {U64, U64} = Struct {List.395, List.614};
-        inc List.391;
+        inc List.392;
-        let List.395 : List U8 = CallByName List.49 List.391 List.612;
+        let List.396 : List U8 = CallByName List.49 List.392 List.613;
-        let List.611 : U64 = CallByName Num.20 List.393 List.394;
+        let List.612 : U64 = CallByName Num.75 List.394 List.395;
-        let List.602 : {U64, U64} = Struct {List.611, List.394};
+        let List.603 : {U64, U64} = Struct {List.612, List.395};
-        let List.396 : List U8 = CallByName List.49 List.391 List.602;
+        let List.397 : List U8 = CallByName List.49 List.392 List.603;
-        let List.601 : {List U8, List U8} = Struct {List.395, List.396};
+        let List.602 : {List U8, List U8} = Struct {List.396, List.397};
-        ret List.601;
+        ret List.602;
     in
-    let List.616 : Int1 = CallByName Num.24 List.393 List.392;
+    let List.617 : Int1 = CallByName Num.24 List.394 List.393;
-    if List.616 then
+    if List.617 then
-        jump List.615 List.392;
+        jump List.616 List.393;
     else
-        jump List.615 List.393;
+        jump List.616 List.394;
 
 procedure List.6 (#Attr.2):
-    let List.587 : U64 = lowlevel ListLen #Attr.2;
+    let List.588 : U64 = lowlevel ListLen #Attr.2;
-    ret List.587;
+    ret List.588;
 
 procedure List.6 (#Attr.2):
-    let List.589 : U64 = lowlevel ListLen #Attr.2;
+    let List.590 : U64 = lowlevel ListLen #Attr.2;
-    ret List.589;
+    ret List.590;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.563 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.564 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.563;
+    ret List.564;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.583 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.584 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.583;
+    ret List.584;
 
 procedure List.68 (#Attr.2):
-    let List.600 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.601 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.600;
+    ret List.601;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.525 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.526 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.525;
+    ret List.526;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.523 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.524 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.523;
+    ret List.524;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.606 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.607 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.606;
+    ret List.607;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.598 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.599 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.598;
+    ret List.599;
 
 procedure List.80 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
-    joinpoint List.553 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.554 List.440 List.441 List.442 List.443 List.444:
-        let List.555 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.556 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.555 then
+        if List.556 then
-            let List.562 : Str = CallByName List.66 List.439 List.442;
+            let List.563 : Str = CallByName List.66 List.440 List.443;
-            inc List.562;
+            inc List.563;
-            let List.556 : {List U8, U64} = CallByName List.145 List.440 List.562 List.441;
+            let List.557 : {List U8, U64} = CallByName List.145 List.441 List.563 List.442;
-            let List.559 : U64 = 1i64;
+            let List.560 : U64 = 1i64;
-            let List.558 : U64 = CallByName Num.19 List.442 List.559;
+            let List.559 : U64 = CallByName Num.51 List.443 List.560;
-            jump List.553 List.439 List.556 List.441 List.558 List.443;
+            jump List.554 List.440 List.557 List.442 List.559 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.553 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
+    jump List.554 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
 
 procedure List.80 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
-    joinpoint List.573 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.627 List.440 List.441 List.442 List.443 List.444:
-        let List.575 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.629 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.575 then
+        if List.629 then
-            let List.582 : U8 = CallByName List.66 List.439 List.442;
+            let List.638 : U8 = CallByName List.66 List.440 List.443;
-            let List.576 : List U8 = CallByName List.145 List.440 List.582 List.441;
+            let List.630 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.441 List.638;
-            let List.579 : U64 = 1i64;
+            let List.635 : U8 = 1i64;
-            let List.578 : U64 = CallByName Num.19 List.442 List.579;
+            let List.636 : U8 = GetTagId List.630;
-            jump List.573 List.439 List.576 List.441 List.578 List.443;
+            let List.637 : Int1 = lowlevel Eq List.635 List.636;
+            if List.637 then
+                let List.445 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.630;
+                let List.633 : U64 = 1i64;
+                let List.632 : U64 = CallByName Num.51 List.443 List.633;
+                jump List.627 List.440 List.445 List.442 List.632 List.444;
+            else
+                dec List.440;
+                let List.446 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.630;
+                let List.634 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.446;
+                ret List.634;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            let List.628 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.441;
+            ret List.628;
     in
-    jump List.573 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump List.627 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
 
 procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
-    joinpoint List.626 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.574 List.440 List.441 List.442 List.443 List.444:
-        let List.628 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.576 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.628 then
+        if List.576 then
-            let List.637 : U8 = CallByName List.66 List.439 List.442;
+            let List.583 : U8 = CallByName List.66 List.440 List.443;
-            let List.629 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.440 List.637;
+            let List.577 : List U8 = CallByName List.145 List.441 List.583 List.442;
-            let List.634 : U8 = 1i64;
+            let List.580 : U64 = 1i64;
-            let List.635 : U8 = GetTagId List.629;
+            let List.579 : U64 = CallByName Num.51 List.443 List.580;
-            let List.636 : Int1 = lowlevel Eq List.634 List.635;
+            jump List.574 List.440 List.577 List.442 List.579 List.444;
-            if List.636 then
-                let List.444 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.629;
-                let List.632 : U64 = 1i64;
-                let List.631 : U64 = CallByName Num.19 List.442 List.632;
-                jump List.626 List.439 List.444 List.441 List.631 List.443;
-            else
-                dec List.439;
-                let List.445 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.629;
-                let List.633 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.445;
-                ret List.633;
         else
-            dec List.439;
+            dec List.440;
-            let List.627 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.440;
+            ret List.441;
-            ret List.627;
     in
-    jump List.626 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
+    jump List.574 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.551 : U64 = 0i64;
+    let List.552 : U64 = 0i64;
-    let List.552 : U64 = CallByName List.6 List.436;
+    let List.553 : U64 = CallByName List.6 List.437;
-    let List.550 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.551 List.552;
+    let List.551 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.552 List.553;
-    ret List.550;
+    ret List.551;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.571 : U64 = 0i64;
+    let List.572 : U64 = 0i64;
-    let List.572 : U64 = CallByName List.6 List.436;
+    let List.573 : U64 = CallByName List.6 List.437;
-    let List.570 : List U8 = CallByName List.80 List.436 List.437 List.438 List.571 List.572;
+    let List.571 : List U8 = CallByName List.80 List.437 List.438 List.439 List.572 List.573;
-    ret List.570;
+    ret List.571;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.624 : U64 = 0i64;
+    let List.625 : U64 = 0i64;
-    let List.625 : U64 = CallByName List.6 List.436;
+    let List.626 : U64 = CallByName List.6 List.437;
-    let List.623 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.436 List.437 List.438 List.624 List.625;
+    let List.624 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.437 List.438 List.439 List.625 List.626;
-    ret List.623;
+    ret List.624;
 
 procedure Num.127 (#Attr.2):
     let Num.299 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.299;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.308 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.303 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.308;
+    ret Num.303;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.312 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.300 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.312;
+    ret Num.300;
 
 procedure Num.21 (#Attr.2, #Attr.3):
     let Num.305 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -235,6 +235,14 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.313 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.313;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.308 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.308;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.312 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.312;
+
 procedure Num.94 (#Attr.2, #Attr.3):
     let Num.304 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
     ret Num.304;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt

@@ -82,105 +82,101 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.145 (List.146, List.147, List.144):
-    let List.566 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
+    let List.567 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
-    ret List.566;
-
-procedure List.145 (List.146, List.147, List.144):
-    let List.614 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
-    ret List.614;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.547 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.547;
-
-procedure List.18 (List.142, List.143, List.144):
-    let List.595 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.595;
-
-procedure List.4 (List.113, List.114):
-    let List.594 : U64 = 1i64;
-    let List.593 : List U8 = CallByName List.70 List.113 List.594;
-    let List.592 : List U8 = CallByName List.71 List.593 List.114;
-    ret List.592;
-
-procedure List.6 (#Attr.2):
-    let List.567 : U64 = lowlevel ListLen #Attr.2;
     ret List.567;
 
-procedure List.6 (#Attr.2):
+procedure List.145 (List.146, List.147, List.144):
-    let List.615 : U64 = lowlevel ListLen #Attr.2;
+    let List.615 : {List U8, U64} = CallByName TotallyNotJson.267 List.146 List.147 List.144;
     ret List.615;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.142, List.143, List.144):
-    let List.563 : [C {}, C {}] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.548 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.563;
+    ret List.548;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.142, List.143, List.144):
-    let List.611 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.596 : {List U8, U64} = CallByName List.93 List.142 List.143 List.144;
-    ret List.611;
+    ret List.596;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.113, List.114):
-    let List.573 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.595 : U64 = 1i64;
-    ret List.573;
+    let List.594 : List U8 = CallByName List.70 List.113 List.595;
+    let List.593 : List U8 = CallByName List.71 List.594 List.114;
+    ret List.593;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.6 (#Attr.2):
-    let List.571 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.568 : U64 = lowlevel ListLen #Attr.2;
-    ret List.571;
+    ret List.568;
 
-procedure List.8 (#Attr.2, #Attr.3):
+procedure List.6 (#Attr.2):
-    let List.616 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.616 : U64 = lowlevel ListLen #Attr.2;
     ret List.616;
 
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.564 : [C {}, C {}] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.564;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.612 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.612;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.574 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.574;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.572 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.572;
+
+procedure List.8 (#Attr.2, #Attr.3):
+    let List.617 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.617;
+
 procedure List.80 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
-    joinpoint List.601 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.602 List.440 List.441 List.442 List.443 List.444:
-        let List.603 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.604 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.603 then
+        if List.604 then
-            let List.610 : [] = CallByName List.66 List.439 List.442;
+            let List.611 : [] = CallByName List.66 List.440 List.443;
-            let List.604 : {List U8, U64} = CallByName List.145 List.440 List.610 List.441;
+            let List.605 : {List U8, U64} = CallByName List.145 List.441 List.611 List.442;
-            let List.607 : U64 = 1i64;
+            let List.608 : U64 = 1i64;
-            let List.606 : U64 = CallByName Num.19 List.442 List.607;
+            let List.607 : U64 = CallByName Num.51 List.443 List.608;
-            jump List.601 List.439 List.604 List.441 List.606 List.443;
+            jump List.602 List.440 List.605 List.442 List.607 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.601 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
+    jump List.602 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
 
 procedure List.80 (#Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42):
-    joinpoint List.553 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.554 List.440 List.441 List.442 List.443 List.444:
-        let List.555 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.556 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.555 then
+        if List.556 then
-            let List.562 : [C {}, C {}] = CallByName List.66 List.439 List.442;
+            let List.563 : [C {}, C {}] = CallByName List.66 List.440 List.443;
-            let List.556 : {List U8, U64} = CallByName List.145 List.440 List.562 List.441;
+            let List.557 : {List U8, U64} = CallByName List.145 List.441 List.563 List.442;
-            let List.559 : U64 = 1i64;
+            let List.560 : U64 = 1i64;
-            let List.558 : U64 = CallByName Num.19 List.442 List.559;
+            let List.559 : U64 = CallByName Num.51 List.443 List.560;
-            jump List.553 List.439 List.556 List.441 List.558 List.443;
+            jump List.554 List.440 List.557 List.442 List.559 List.444;
         else
-            dec List.439;
+            dec List.440;
-            ret List.440;
+            ret List.441;
     in
-    jump List.553 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42;
+    jump List.554 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.551 : U64 = 0i64;
+    let List.552 : U64 = 0i64;
-    let List.552 : U64 = CallByName List.6 List.436;
+    let List.553 : U64 = CallByName List.6 List.437;
-    let List.550 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.551 List.552;
+    let List.551 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.552 List.553;
-    ret List.550;
+    ret List.551;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.599 : U64 = 0i64;
+    let List.600 : U64 = 0i64;
-    let List.600 : U64 = CallByName List.6 List.436;
+    let List.601 : U64 = CallByName List.6 List.437;
-    let List.598 : {List U8, U64} = CallByName List.80 List.436 List.437 List.438 List.599 List.600;
+    let List.599 : {List U8, U64} = CallByName List.80 List.437 List.438 List.439 List.600 List.601;
-    ret List.598;
+    ret List.599;
 
 procedure Num.127 (#Attr.2):
     let Num.311 : U8 = lowlevel NumIntCast #Attr.2;
     ret Num.311;
 
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.314 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.314;
-
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.312 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.312;
@@ -193,6 +189,10 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.313 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.313;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.314 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.314;
+
 procedure Str.12 (#Attr.2):
     let Str.290 : List U8 = lowlevel StrToUtf8 #Attr.2;
     ret Str.290;

crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt

@@ -3,96 +3,96 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     ret Bool.24;
 
 procedure List.26 (List.159, List.160, List.161):
-    let List.536 : [C U64, C U64] = CallByName List.93 List.159 List.160 List.161;
+    let List.537 : [C U64, C U64] = CallByName List.93 List.159 List.160 List.161;
-    let List.539 : U8 = 1i64;
+    let List.540 : U8 = 1i64;
-    let List.540 : U8 = GetTagId List.536;
+    let List.541 : U8 = GetTagId List.537;
-    let List.541 : Int1 = lowlevel Eq List.539 List.540;
+    let List.542 : Int1 = lowlevel Eq List.540 List.541;
-    if List.541 then
+    if List.542 then
-        let List.162 : U64 = UnionAtIndex (Id 1) (Index 0) List.536;
+        let List.162 : U64 = UnionAtIndex (Id 1) (Index 0) List.537;
         ret List.162;
     else
-        let List.163 : U64 = UnionAtIndex (Id 0) (Index 0) List.536;
+        let List.163 : U64 = UnionAtIndex (Id 0) (Index 0) List.537;
         ret List.163;
 
 procedure List.29 (List.304, List.305):
-    let List.535 : U64 = CallByName List.6 List.304;
+    let List.536 : U64 = CallByName List.6 List.304;
-    let List.306 : U64 = CallByName Num.77 List.535 List.305;
+    let List.306 : U64 = CallByName Num.77 List.536 List.305;
-    let List.521 : List U8 = CallByName List.43 List.304 List.306;
+    let List.522 : List U8 = CallByName List.43 List.304 List.306;
-    ret List.521;
-
-procedure List.43 (List.302, List.303):
-    let List.533 : U64 = CallByName List.6 List.302;
-    let List.532 : U64 = CallByName Num.77 List.533 List.303;
-    let List.523 : {U64, U64} = Struct {List.303, List.532};
-    let List.522 : List U8 = CallByName List.49 List.302 List.523;
     ret List.522;
 
-procedure List.49 (List.376, List.377):
+procedure List.43 (List.302, List.303):
-    let List.530 : U64 = StructAtIndex 0 List.377;
+    let List.534 : U64 = CallByName List.6 List.302;
-    let List.531 : U64 = 0i64;
+    let List.533 : U64 = CallByName Num.77 List.534 List.303;
-    let List.528 : Int1 = CallByName Bool.11 List.530 List.531;
+    let List.524 : {U64, U64} = Struct {List.303, List.533};
-    if List.528 then
+    let List.523 : List U8 = CallByName List.49 List.302 List.524;
-        dec List.376;
+    ret List.523;
-        let List.529 : List U8 = Array [];
+
-        ret List.529;
+procedure List.49 (List.377, List.378):
+    let List.531 : U64 = StructAtIndex 0 List.378;
+    let List.532 : U64 = 0i64;
+    let List.529 : Int1 = CallByName Bool.11 List.531 List.532;
+    if List.529 then
+        dec List.377;
+        let List.530 : List U8 = Array [];
+        ret List.530;
     else
-        let List.525 : U64 = StructAtIndex 1 List.377;
+        let List.526 : U64 = StructAtIndex 1 List.378;
-        let List.526 : U64 = StructAtIndex 0 List.377;
+        let List.527 : U64 = StructAtIndex 0 List.378;
-        let List.524 : List U8 = CallByName List.72 List.376 List.525 List.526;
+        let List.525 : List U8 = CallByName List.72 List.377 List.526 List.527;
-        ret List.524;
+        ret List.525;
 
 procedure List.6 (#Attr.2):
-    let List.534 : U64 = lowlevel ListLen #Attr.2;
+    let List.535 : U64 = lowlevel ListLen #Attr.2;
-    ret List.534;
+    ret List.535;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.557 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.558 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.557;
+    ret List.558;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.527 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.528 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.527;
+    ret List.528;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.545 List.439 List.440 List.441 List.442 List.443:
+    joinpoint List.546 List.440 List.441 List.442 List.443 List.444:
-        let List.547 : Int1 = CallByName Num.22 List.442 List.443;
+        let List.548 : Int1 = CallByName Num.22 List.443 List.444;
-        if List.547 then
+        if List.548 then
-            let List.556 : U8 = CallByName List.66 List.439 List.442;
+            let List.557 : U8 = CallByName List.66 List.440 List.443;
-            let List.548 : [C U64, C U64] = CallByName Test.3 List.440 List.556;
+            let List.549 : [C U64, C U64] = CallByName Test.3 List.441 List.557;
-            let List.553 : U8 = 1i64;
+            let List.554 : U8 = 1i64;
-            let List.554 : U8 = GetTagId List.548;
+            let List.555 : U8 = GetTagId List.549;
-            let List.555 : Int1 = lowlevel Eq List.553 List.554;
+            let List.556 : Int1 = lowlevel Eq List.554 List.555;
-            if List.555 then
+            if List.556 then
-                let List.444 : U64 = UnionAtIndex (Id 1) (Index 0) List.548;
+                let List.445 : U64 = UnionAtIndex (Id 1) (Index 0) List.549;
-                let List.551 : U64 = 1i64;
+                let List.552 : U64 = 1i64;
-                let List.550 : U64 = CallByName Num.19 List.442 List.551;
+                let List.551 : U64 = CallByName Num.51 List.443 List.552;
-                jump List.545 List.439 List.444 List.441 List.550 List.443;
+                jump List.546 List.440 List.445 List.442 List.551 List.444;
             else
-                dec List.439;
+                dec List.440;
-                let List.445 : U64 = UnionAtIndex (Id 0) (Index 0) List.548;
+                let List.446 : U64 = UnionAtIndex (Id 0) (Index 0) List.549;
-                let List.552 : [C U64, C U64] = TagId(0) List.445;
+                let List.553 : [C U64, C U64] = TagId(0) List.446;
-                ret List.552;
+                ret List.553;
         else
-            dec List.439;
+            dec List.440;
-            let List.546 : [C U64, C U64] = TagId(1) List.440;
+            let List.547 : [C U64, C U64] = TagId(1) List.441;
-            ret List.546;
+            ret List.547;
     in
-    jump List.545 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.546 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.93 (List.436, List.437, List.438):
+procedure List.93 (List.437, List.438, List.439):
-    let List.543 : U64 = 0i64;
+    let List.544 : U64 = 0i64;
-    let List.544 : U64 = CallByName List.6 List.436;
+    let List.545 : U64 = CallByName List.6 List.437;
-    let List.542 : [C U64, C U64] = CallByName List.80 List.436 List.437 List.438 List.543 List.544;
+    let List.543 : [C U64, C U64] = CallByName List.80 List.437 List.438 List.439 List.544 List.545;
-    ret List.542;
+    ret List.543;
-
-procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.295;
 
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.294;
+
 procedure Num.77 (#Attr.2, #Attr.3):
     let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
     ret Num.293;

crates/docs/src/lib.rs

@@ -11,6 +11,7 @@ use roc_load::{ExecutionMode, LoadConfig, LoadedModule, LoadingProblem, Threadin
 use roc_module::symbol::{Interns, Symbol};
 use roc_packaging::cache::{self, RocCacheDir};
 use roc_parse::ident::{parse_ident, Accessor, Ident};
+use roc_parse::keyword;
 use roc_parse::state::State;
 use roc_region::all::Region;
 use std::fs;
@@ -260,7 +261,13 @@ fn render_module_documentation(
                     let type_ann = &doc_def.type_annotation;
 
                     if !matches!(type_ann, TypeAnnotation::NoTypeAnn) {
-                        content.push_str(" : ");
+                        // Ability declarations don't have ":" after the name, just `implements`
+                        if !matches!(type_ann, TypeAnnotation::Ability { .. }) {
+                            content.push_str(" :");
+                        }
+
+                        content.push(' ');
+
                         type_annotation_to_html(0, &mut content, type_ann, false);
                     }
 
@@ -626,6 +633,7 @@ fn type_annotation_to_html(
         TypeAnnotation::Function { args, output } => {
             let mut paren_is_open = false;
             let mut peekable_args = args.iter().peekable();
+
             while let Some(arg) = peekable_args.next() {
                 if is_multiline {
                     if !should_be_multiline(arg) {
@@ -638,8 +646,7 @@ fn type_annotation_to_html(
                     paren_is_open = true;
                 }
 
-                let child_needs_parens =
+                let child_needs_parens = matches!(arg, TypeAnnotation::Function { .. });
-                    matches!(arg, TypeAnnotation::Function { args: _, output: _ });
                 type_annotation_to_html(indent_level, buf, arg, child_needs_parens);
 
                 if peekable_args.peek().is_some() {
@@ -650,9 +657,11 @@ fn type_annotation_to_html(
             if is_multiline {
                 new_line(buf);
                 indent(buf, indent_level + 1);
+            } else {
+                buf.push(' ');
             }
 
-            buf.push_str(" -> ");
+            buf.push_str("-> ");
 
             let mut next_indent_level = indent_level;
 
@@ -665,8 +674,54 @@ fn type_annotation_to_html(
                 buf.push(')');
             }
         }
-        TypeAnnotation::Ability { members: _ } => {
+        TypeAnnotation::Ability { members } => {
-            // TODO(abilities): fill me in
+            buf.push_str(keyword::IMPLEMENTS);
+
+            for member in members {
+                new_line(buf);
+                indent(buf, indent_level + 1);
+
+                // TODO use member.docs somehow. This doesn't look good though:
+                // if let Some(docs) = &member.docs {
+                //     buf.push_str("## ");
+                //     buf.push_str(docs);
+
+                //     new_line(buf);
+                //     indent(buf, indent_level + 1);
+                // }
+
+                buf.push_str(&member.name);
+                buf.push_str(" : ");
+
+                type_annotation_to_html(indent_level + 1, buf, &member.type_annotation, false);
+
+                if !member.able_variables.is_empty() {
+                    new_line(buf);
+                    indent(buf, indent_level + 2);
+                    buf.push_str(keyword::WHERE);
+
+                    for (index, (name, type_anns)) in member.able_variables.iter().enumerate() {
+                        if index != 0 {
+                            buf.push(',');
+                        }
+
+                        buf.push(' ');
+                        buf.push_str(name);
+                        buf.push(' ');
+                        buf.push_str(keyword::IMPLEMENTS);
+
+                        for (index, ann) in type_anns.iter().enumerate() {
+                            if index != 0 {
+                                buf.push_str(" &");
+                            }
+
+                            buf.push(' ');
+
+                            type_annotation_to_html(indent_level + 2, buf, ann, false);
+                        }
+                    }
+                }
+            }
         }
         TypeAnnotation::ObscuredTagUnion => {
             buf.push_str("[@..]");
@@ -676,77 +731,146 @@ fn type_annotation_to_html(
         }
         TypeAnnotation::NoTypeAnn => {}
         TypeAnnotation::Wildcard => buf.push('*'),
+        TypeAnnotation::Tuple { elems, extension } => {
+            let elems_len = elems.len();
+            let tuple_indent = indent_level + 1;
+
+            if is_multiline {
+                new_line(buf);
+                indent(buf, tuple_indent);
+            }
+
+            buf.push('(');
+
+            if is_multiline {
+                new_line(buf);
+            }
+
+            let next_indent_level = tuple_indent + 1;
+
+            for (index, elem) in elems.iter().enumerate() {
+                if is_multiline {
+                    indent(buf, next_indent_level);
+                }
+
+                type_annotation_to_html(next_indent_level, buf, elem, false);
+
+                if is_multiline {
+                    if index < (elems_len - 1) {
+                        buf.push(',');
+                    }
+
+                    new_line(buf);
+                }
+            }
+
+            if is_multiline {
+                indent(buf, tuple_indent);
+            }
+
+            buf.push(')');
+
+            type_annotation_to_html(indent_level, buf, extension, true);
+        }
+        TypeAnnotation::Where { ann, implements } => {
+            type_annotation_to_html(indent_level, buf, ann, false);
+
+            new_line(buf);
+            indent(buf, indent_level + 1);
+
+            buf.push_str(keyword::WHERE);
+
+            let multiline_implements = implements
+                .iter()
+                .any(|imp| imp.abilities.iter().any(should_be_multiline));
+
+            for (index, imp) in implements.iter().enumerate() {
+                if index != 0 {
+                    buf.push(',');
+                }
+
+                if multiline_implements {
+                    new_line(buf);
+                    indent(buf, indent_level + 2);
+                } else {
+                    buf.push(' ')
+                }
+
+                buf.push_str(&imp.name);
+                buf.push(' ');
+                buf.push_str(keyword::IMPLEMENTS);
+                buf.push(' ');
+
+                for (index, ability) in imp.abilities.iter().enumerate() {
+                    if index != 0 {
+                        buf.push_str(" & ");
+                    }
+
+                    type_annotation_to_html(indent_level, buf, ability, false);
+                }
+            }
+        }
+        TypeAnnotation::As { ann, name, vars } => {
+            type_annotation_to_html(indent_level, buf, ann, true);
+            buf.push(' ');
+            buf.push_str(name);
+
+            for var in vars {
+                buf.push(' ');
+                buf.push_str(var);
+            }
+        }
     }
 }
 
 fn should_be_multiline(type_ann: &TypeAnnotation) -> bool {
     match type_ann {
         TypeAnnotation::TagUnion { tags, extension } => {
-            let mut is_multiline = should_be_multiline(extension) || tags.len() > 1;
+            tags.len() > 1
-
+                || should_be_multiline(extension)
-            for tag in tags {
+                || tags
-                for value in &tag.values {
+                    .iter()
-                    if is_multiline {
+                    .any(|tag| tag.values.iter().any(should_be_multiline))
-                        break;
-                    }
-                    is_multiline = should_be_multiline(value);
-                }
-            }
-
-            is_multiline
         }
         TypeAnnotation::Function { args, output } => {
-            let mut is_multiline = should_be_multiline(output) || args.len() > 2;
+            args.len() > 2 || should_be_multiline(output) || args.iter().any(should_be_multiline)
-
-            for arg in args {
-                if is_multiline {
-                    break;
-                }
-
-                is_multiline = should_be_multiline(arg);
-            }
-
-            is_multiline
         }
         TypeAnnotation::ObscuredTagUnion => false,
         TypeAnnotation::ObscuredRecord => false,
         TypeAnnotation::BoundVariable(_) => false,
-        TypeAnnotation::Apply { parts, .. } => {
+        TypeAnnotation::Apply { parts, .. } => parts.iter().any(should_be_multiline),
-            let mut is_multiline = false;
-
-            for part in parts {
-                is_multiline = should_be_multiline(part);
-
-                if is_multiline {
-                    break;
-                }
-            }
-
-            is_multiline
-        }
         TypeAnnotation::Record { fields, extension } => {
-            let mut is_multiline = should_be_multiline(extension) || fields.len() > 1;
+            fields.len() > 1
-
+                || should_be_multiline(extension)
-            for field in fields {
+                || fields.iter().any(|field| match field {
-                if is_multiline {
-                    break;
-                }
-                match field {
                     RecordField::RecordField {
                         type_annotation, ..
-                    } => is_multiline = should_be_multiline(type_annotation),
+                    } => should_be_multiline(type_annotation),
                     RecordField::OptionalField {
                         type_annotation, ..
-                    } => is_multiline = should_be_multiline(type_annotation),
+                    } => should_be_multiline(type_annotation),
-                    RecordField::LabelOnly { .. } => {}
+                    RecordField::LabelOnly { .. } => false,
-                }
+                })
-            }
-
-            is_multiline
         }
         TypeAnnotation::Ability { .. } => true,
         TypeAnnotation::Wildcard => false,
         TypeAnnotation::NoTypeAnn => false,
+        TypeAnnotation::Tuple { elems, extension } => {
+            elems.len() > 1
+                || should_be_multiline(extension)
+                || elems.iter().any(should_be_multiline)
+        }
+        TypeAnnotation::Where { ann, implements } => {
+            should_be_multiline(ann)
+                || implements
+                    .iter()
+                    .any(|imp| imp.abilities.iter().any(should_be_multiline))
+        }
+        TypeAnnotation::As {
+            ann,
+            name: _,
+            vars: _,
+        } => should_be_multiline(ann),
     }
 }
 

crates/reporting/src/error/type.rs

@@ -4115,21 +4115,21 @@ mod report_text {
                 alloc.text("()")
             } else {
                 alloc
-                    .text("( ")
+                    .text("(")
-                    .append(alloc.ellipsis().append(alloc.text(" }")))
+                    .append(alloc.ellipsis().append(alloc.text(")")))
             }
             .append(ext_doc)
         } else if entries.len() == 1 {
             // Single-field records get printed on one line; multi-field records get multiple lines
             alloc
-                .text("( ")
+                .text("(")
                 .append(entries.into_iter().next().unwrap())
                 .append(if fields_omitted == 0 {
                     alloc.text("")
                 } else {
                     alloc.text(", ").append(alloc.ellipsis())
                 })
-                .append(alloc.text(" )"))
+                .append(alloc.text(")"))
                 .append(ext_doc)
         } else {
             let ending = if fields_omitted == 0 {
@@ -4142,7 +4142,7 @@ mod report_text {
             }
             .append(ext_doc);
 
-            // Multi-elem tuple get printed on multiple lines
+            // Multi-elem tuples get printed on multiple lines
             alloc.vcat(
                 std::iter::once(alloc.reflow("(")).chain(
                     entries

www/wip_new_website/main.roc

@@ -1,7 +1,7 @@
 app "roc-website"
     packages { pf: "../../examples/static-site-gen/platform/main.roc" }
     imports [
-        pf.Html.{ html, head, body, footer, br, div, main, text, nav, a, link, meta },
+        pf.Html.{ html, head, body, footer, div, main, text, nav, a, link, meta },
         pf.Html.Attributes.{ content, name, id, href, rel, lang, class, title, charset },
     ]
     provides [transformFileContent] to pf