Re: [PATCH 2/2] WIP union hir-lowering and type support

[Mark Wielaard <mark@klomp.org>]

Hi,

On Sun, Aug 01, 2021 at 01:29:16PM +0200, Mark Wielaard wrote:
> And you cannot use unions as function arguments or return values.
> This example (sorry for the funny naming, union isn't a keyword, so
> you can call basically anything a union, including a union, a union
> field, function argument, etc.) doesn't pass the type checker:
> 
> union union { union: u32, funion: f32 }
> 
> fn funion (union: &union) -> union
> {
>   let v = unsafe { union.union };
>   union { union: v }
> }
> 
> pub fn main ()
> {
>   let union = union { union: 1 };
>   let u = unsafe { union.union };
>   let f = unsafe { union.funion };
>   let r = funion (&union);
>   let _r3 = unsafe { r.union } + unsafe { union.union } + u;
>   let _f2 = f + unsafe { r.funion };
> }
> 
> $ gcc/gccrs -Bgcc -g fn_union.rs 
> fn_union.rs:5:20: error: expected algebraic data type got: [& union{union:Uint:u32:(Ref: 20 TyRef: 3[3,]), funion:Float:f32:(Ref: 23 TyRef: 12[12,])}]
>     5 |   let v = unsafe { union.union };
>       |                    ^
> fn_union.rs:5:20: error: failed to type resolve expression
> fn_union.rs:6:3: error: expected an ADT type for constructor
>     6 |   union { union: v }
>       |   ^
> fn_union.rs:3:1: error: expected [union{union:Uint:u32:(Ref: 20 TyRef: 3[3,]), funion:Float:f32:(Ref: 23 TyRef: 12[12,])}] got [<tyty::error>]
>     3 | fn funion (union: &union) -> union
>       | ^                            ~

This example might be slightly hard to read because it uses "union"
also as identifier for things that aren't unions (which is allowed
since union is a weak keyword). So here is a simpler hopefully more
clear example to show the issue:

union U
{
  v1: u64,
  v2: i8
}

fn f (u: &U) -> U
{
  let v = unsafe { u.v2 };
  U { v2: v }
}

pub fn main ()
{
  let u = U { v1: 356 };
  let r = f (u);
  let _v100 = unsafe { r.v1 };
}

$ gcc/gccrs -Bgcc -g union_call.rs 
union_call.rs:9:20: error: expected algebraic data type got: [& U{v1:Uint:u64:(Ref: 20 TyRef: 4[4,]), v2:Int:i8:(Ref: 23 TyRef: 6[6,])}]
    9 |   let v = unsafe { u.v2 };
      |                    ^
union_call.rs:9:20: error: failed to type resolve expression
union_call.rs:9:3: error: Failed to resolve IdentifierExpr type: ( v ([C: 0 Nid: 42 Hid: 40]))
    9 |   let v = unsafe { u.v2 };
      |   ^
union_call.rs:10:11: error: failed to type resolve expression
   10 |   U { v2: v }
      |           ^
union_call.rs:10:11: error: expected [i8] got [<tyty::error>]

I am a little lost where the typechecking goes wrong.
Could someone give me a hint?

Thanks,

Mark