no method named `is_refcounted` found for reference `&ManuallyDrop<T>` in the current scope
found the following associated functions; to be used as methods, functions must have a `self` parameter

impl<T, E> RocRefcounted for RocResult<T, E>
where
    T: RocRefcounted,
    E: RocRefcounted,
{
    fn inc(&mut self) {
        match self.as_result_of_refs() {
            Ok(payload) if payload.is_refcounted() => {
                payload.inc();
            }
            Err(payload) if payload.is_refcounted() => {
                payload.inc();
            }
            _ => {}
        }
    }
    fn dec(&mut self) {
        todo!()
    }
    fn is_refcounted() -> bool {
        todo!()
    }
}

impl<T, E> RocRefcounted for RocResult<T, E>
where
    T: RocRefcounted,
    E: RocRefcounted,
{
    fn inc(&mut self) {
        unsafe {
            match self.tag {
                RocResultTag::RocOk => (*self.payload.ok).inc(),
                RocResultTag::RocErr => (*self.payload.err).inc(),
            }
        }
    }
    fn dec(&mut self) {
        unsafe {
            match self.tag {
                RocResultTag::RocOk => (*self.payload.ok).dec(),
                RocResultTag::RocErr => (*self.payload.err).dec(),
            }
        }
    }
    fn is_refcounted() -> bool {
        unsafe {
            match self.tag {
                RocResultTag::RocOk => (self.payload.ok).is_refcounted(),
                RocResultTag::RocErr => (self.payload.err).is_refcounted(),
            }
        }
    }
}

pub trait RocRefcounted {
    /// Increments the refcount.
    fn inc(&mut self);

    /// Decrements the refcount potentially freeing the underlying allocation.
    fn dec(&mut self);

    /// Returns true if the type is actually refcounted by roc.
    fn is_refcounted() -> bool;
}

fn is_refcounted() -> bool {
        T::is_refcounted() || E::is_refcounted()
}

impl roc_std::RocRefcounted for SQLiteValue {
    fn inc(&mut self) {
        unimplemented!();
    }
    fn dec(&mut self) {
        unimplemented!();
    }
    fn is_refcounted() -> bool {
        true
    }
}

#[repr(C)]
pub struct InternalResponse {
    body: RocList<u8>,
    metadata: Metadata,
    variant: RocStr,
}

#[repr(C)]
pub struct Metadata {
    headers: RocList<Header>,
    url: RocStr,
    statusCode: u16,
    statusText: RocStr,
}

$ EXAMPLES_DIR=examples/ expect ci/expect_scripts/args.exp
spawn examples//args div -n 5 -d 20
args(82068,0x201c58c00) malloc: Heap corruption detected, free list is damaged at 0x600000f48080
*** Incorrect guard value: 145982044012671
args(82068,0x201c58c00) malloc: *** set a breakpoint in malloc_error_break to debug

Error: output was different from expected value.

# Probably reading heap size on a list allocated without a heap size?
=56308== Invalid read of size 8
==56308==    at 0x1CDF43: ??? (roc_app:0)
==56308==    by 0x1D1E03: ??? (roc_app:0)
==56308==    by 0x1AAAB7: List_walkTryHelp_147f9a29f721bc6a47c431ffbf897368d53af6834eae9416f984da7fc2dd89 (roc_app:0)


# Double free
==56308==  Address 0x4b6d4b0 is 0 bytes inside a block of size 9 free'd
==56308==    at 0x48469E4: free (in /nix/store/78zxvxfy6klvwfc2s95y71y0b284fd6v-valgrind-3.22.0/libexec/valgrind/vgpreload_memcheck-amd64-linux.so)
==56308==    by 0x1D4882: roc_dealloc (lib.rs:81)
==56308==    by 0x1CE2CA: decrement_refcounted_ptr_8 (roc_app:0)
==56308==    by 0x1CE27D: ??? (roc_app:0)
==56308==    by 0x18DB36: #Attr_#generic_rc_by_ref_2_dec (roc_app:0)
==56308==    by 0x18DB36: Arg.Parser_constructSetOfOptions_3655121d7ba98da90331d38b92032d451b515e695221ee2a9d34aa692cd2c (roc_app:0)

# Use after free
==56308== Invalid write of size 8
==56308==    at 0x1CDF64: ??? (roc_app:0)
==56308==    by 0x1D1E03: ??? (roc_app:0)
==56308==    by 0x1AAAB7: List_walkTryHelp_147f9a29f721bc6a47c431ffbf897368d53af6834eae9416f984da7fc2dd89 (roc_app:0)
==56308==    by 0x194BAE: List_walkTry_1d346aa605d9beef3d3c8b59d397858b899a3c7efdcede8d0efd4953334f936 (roc_app:0)

app [main] {
    pf: platform "../platform/main.roc",
}

import pf.Stdout
import pf.Task exposing [Task]

Arg : [
    Short Str,
    ShortGroup { names : List Str, complete : [Complete, Partial] },
    Long { name : Str, value : Result Str [NoValue] },
    Parameter Str,
]

constructSetOfOptions : Str -> Arg
constructSetOfOptions = \combined ->
    options =
        combined
        |> Str.toUtf8
        |> List.keepOks \c -> Str.fromUtf8 [c]

    when options is
        [alone] -> Short alone
        other -> ShortGroup { names: other, complete: Complete }

main =
    ["-d"]
    |> List.map \x ->
        when Str.splitFirst x "-" is
            Ok {after} ->
                constructSetOfOptions after
            Err _ ->
                Parameter "err"
    |> List.len
    |> Num.toStr
    |> Stdout.line

constructSetOfOptions : Str -> Arg
constructSetOfOptions = \combined ->
    options =
        combined
        |> Str.toUtf8
        |> List.keepOks \c -> Str.fromUtf8 [c]

    dbg options
    when options is
        [alone] ->
            dbg alone
            Short alone
        other -> ShortGroup { names: other, complete: Complete }

main =
    ["-d"]
    |> List.map \x ->
        when Str.splitFirst x "-" is
            Ok {after} ->
                out = constructSetOfOptions after
                dbg out
                out
            Err _ ->
                Parameter "err"
    |> List.len
    |> Num.toStr
    |> Stdout.line

[examples/args.roc:22] options = ["d"]
[examples/args.roc:25] alone = "d"
[examples/args.roc:35] out = (Short "�")

    if List.len options == 1 then
        when List.get options 0 is
            Ok alone -> Short alone
            _ -> crash "impossible"
    else
        ShortGroup { names: options, complete: Complete }

main =
    in = [Str.fromUtf8 ['d']]
    out =
        when in is
            [alone] -> [alone]
            other -> other
    out
    |> List.len
    |> Num.toStr
    |> Stdout.line

thread 'tokio-runtime-worker' panicked at crates/roc_host/src/roc.rs:42:5:
The Roc app crashed with: NoImplementationNamed { def_symbol: `38.IdentId(2)` }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread 'tokio-runtime-worker' panicked at crates/roc_host/src/http_server.rs:87:26:
called `Result::unwrap()` on an `Err` value: JoinError::Panic(Id(10), ...)

+ allocated u8@60000166c040 (1 bytes with alignment 8)
+ allocated u8@600001a600c0 (32 bytes with alignment 8)
decref list: (8,32,true,fn(?[*]u8) callconv(.C) void@1049a9420)
freeing underlying elements from: (u8@600001a600d0, 1)
| decrement isize@60000166c040: 1 - 1 = 0!
💀 freed u8@60000166c040
| decrement isize@600001a600c8: 1 - 1 = 0!
💀 freed u8@600001a600c0
+ allocated u8@600001a600c0 (32 bytes with alignment 8)
decref list: (8,32,true,fn(?[*]u8) callconv(.C) void@1049a9420)
freeing underlying elements from: (u8@600001a600d0, 1)
| decrement isize@60000166c040: 9223523571393151041 - 1 = 9223523571393151040!
| decrement isize@600001a600c8: 1 - 1 = 0!
💀 freed u8@600001a600c0

08:44:37 ~/Documents/Github/basic-cli refactor-host$ roc --prebuilt-platform examples/args.roc -- div 5 2
free(): invalid next size (fast)

08:44:11 ~/Documents/Github/basic-webserver refactor-host$ roc --prebuilt-platform build.roc
free(): invalid pointer

procedure : `#UserApp.main` Str
procedure = `#UserApp.main` ():
    let `#UserApp.16` : U8 = 100i64;
    let `#UserApp.15` : List U8 = Array [`#UserApp.16`];
    let `#UserApp.inStr` : [C {U64, U8}, C Str] = CallByName `Str.fromUtf8` `#UserApp.15`;
    let `#UserApp.in` : List [C {U64, U8}, C Str] = Array [`#UserApp.inStr`];
    joinpoint `#UserApp.8` `#UserApp.out`:
        let `#UserApp.7` : U64 = CallByName `List.len` `#UserApp.out`;
        dec `#UserApp.out`;
        let `#UserApp.6` : Str = CallByName `Num.toStr` `#UserApp.7`;
        ret `#UserApp.6`;
    in
    let `#UserApp.12` : U64 = lowlevel ListLenUsize `#UserApp.in`;
    let `#UserApp.13` : U64 = 1i64;
    let `#UserApp.14` : Int1 = lowlevel Eq `#UserApp.12` `#UserApp.13`;
    if `#UserApp.14` then
        let `#UserApp.11` : U64 = 0i64;
        let `#UserApp.alone` : [C {U64, U8}, C Str] = lowlevel ListGetUnsafe `#UserApp.in` `#UserApp.11`;
        inc `#UserApp.alone`;
        dec `#UserApp.in`;
        let `#UserApp.9` : List [C {U64, U8}, C Str] = Array [`#UserApp.alone`];
        jump `#UserApp.8` `#UserApp.9`;
    else
        jump `#UserApp.8` `#UserApp.in`;

procedure : `#UserApp.main` Str
procedure = `#UserApp.main` ():
    let `#UserApp.16` : U8 = 100i64;
    let `#UserApp.15` : List U8 = Array [`#UserApp.16`];
    let `#UserApp.inStr` : [C {U64, U8}, C Str] = CallByName `Str.fromUtf8` `#UserApp.15`;
    let `#UserApp.in` : List [C {U64, U8}, C Str] = Array [`#UserApp.inStr`];
    joinpoint `#UserApp.8` `#UserApp.out`:
        let `#UserApp.7` : U64 = CallByName `List.len` `#UserApp.out`;
        dec `#UserApp.out`;
        let `#UserApp.6` : Str = CallByName `Num.toStr` `#UserApp.7`;
        ret `#UserApp.6`;
    in
    let `#UserApp.12` : U64 = lowlevel ListLenUsize `#UserApp.in`;
    let `#UserApp.13` : U64 = 1i64;
    let `#UserApp.14` : Int1 = lowlevel Eq `#UserApp.12` `#UserApp.13`;
    if `#UserApp.14` then
        let `#UserApp.11` : U64 = 0i64;
        let `#UserApp.alone` : [C {U64, U8}, C Str] = lowlevel ListGetUnsafe `#UserApp.in` `#UserApp.11`;
        decref `#UserApp.in`;
        let `#UserApp.9` : List [C {U64, U8}, C Str] = Array [`#UserApp.alone`];
        jump `#UserApp.8` `#UserApp.9`;
    else
        jump `#UserApp.8` `#UserApp.in`;

if (unique list)
  dec items
  free list
else
  decref list

if (unique list)
  free list
else
  inc item
  decref list

str = "some super long string that will definitely be allocated"
list = [str, str]
subList = List.dropFirst 1

# keep sublist alive and use it later

if (unique list)
  dec items (this includes all items in the entire allocation, they don't have to be in the current sublist)
  free list
else
  decref list

❯ ./examples/args div -n 5 -d 20
free(): invalid next size (fast)
Aborted (core dumped)