We need to do this so that LLVM picks up the correct calling convention
- in particular, on AArch64, return-by-pointer parameters need to go in
x8 for the C callconv!
This ends up fixing all `cli_run` tests!
```
running 35 tests
WARNING: skipping testing example form.roc because the test is broken right now!
test cli_run::cli ... ok
test cli_run::exposed_not_defined ... ok
test cli_run::format_check_folders ... ok
test cli_run::format_check_good ... ok
test cli_run::format_check_reformatting_needed ... ok
test cli_run::effects ... ok
test cli_run::fib ... ok
test cli_run::helloC ... ok
test cli_run::closure ... ok
WARNING: skipping testing example helloWeb.roc because the test is broken right now!
test cli_run::helloWeb ... ok
test cli_run::cfold ... ok
test cli_run::base64 ... ok
test cli_run::helloWorld ... ok
test cli_run::known_type_error ... ok
test cli_run::helloRust ... ok
test cli_run::helloZig ... ok
WARNING: skipping testing benchmark QuicksortApp.roc because the test is broken right now!
test cli_run::quicksort_app ... ok
test cli_run::astar ... ok
test cli_run::quicksort ... ok
test cli_run::issue2279 ... ok
test cli_run::helloSwift ... ok
test cli_run::run_multi_dep_str_optimized ... ok
test cli_run::nqueens ... ok
test cli_run::false_interpreter ... ok
test cli_run::rbtree_ck ... ok
test cli_run::unknown_generates_with ... ok
test cli_run::rbtree_insert ... ok
test cli_run::unused_import ... ok
test cli_run::run_multi_dep_str_unoptimized ... ok
test cli_run::tui ... ok
test cli_run::run_multi_dep_thunk_optimized ... ok
test cli_run::run_multi_dep_thunk_unoptimized ... ok
test cli_run::deriv ... ok
test cli_run::breakout ... ok
test cli_run::gui ... ok
test result: ok. 35 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 12.09s
```
Closes#2535
See the referenced issue for longer discussion - here's the synopsis.
Consider this program
```
app "test" provides [ nums ] to "./platform"
alpha = { a: 1, b: 2 }
nums : List U8
nums =
[
alpha.a,
alpha.b,
]
```
Here's its IR:
```
procedure : `#UserApp.alpha` {I64, U8}
procedure = `#UserApp.alpha` ():
let `#UserApp.5` : Builtin(Int(I64)) = 1i64;
let `#UserApp.6` : Builtin(Int(U8)) = 2i64;
let `#UserApp.4` : Struct([Builtin(Int(I64)), Builtin(Int(U8))]) = Struct {`#UserApp.5`, `#UserApp.6`};
ret `#UserApp.4`;
procedure : `#UserApp.nums` List U8
procedure = `#UserApp.nums` ():
let `#UserApp.7` : Struct([Builtin(Int(I64)), Builtin(Int(U8))]) = CallByName `#UserApp.alpha`;
let `#UserApp.1` : Builtin(Int(U8)) = StructAtIndex 1 `#UserApp.7`;
let `#UserApp.3` : Struct([Builtin(Int(I64)), Builtin(Int(U8))]) = CallByName `#UserApp.alpha`;
let `#UserApp.2` : Builtin(Int(U8)) = StructAtIndex 1 `#UserApp.3`;
let `#UserApp.0` : Builtin(List(Builtin(Int(U8)))) = Array [`#UserApp.1`, `#UserApp.2`];
ret `#UserApp.0`;
```
What's happening is that we need to specialize `alpha` twice - once for the
type of a narrowed to a U8, another time for the type of b narrowed to a U8.
We do the specialization for alpha.b first - record fields are sorted by
layout, so we generate a record of type {i64, u8}. But then we go to
specialize alpha.a, but this has the same layout - {i64, u8} - so we reuse
the existing one! So (at least for records), we need to include record field
order associated with the sorted layout fields, so that we don't reuse
monomorphizations like this incorrectly!
