Unquoting computed values in comptime fails in certain positions

[Thunkar]

Aim

#[derive_via(derive_serialize)]
trait Serialize<let N: u32> {
    fn serialize(self) -> [Field; N];
}

fn flatten_to_fields(name: Quoted, typ: Type) -> ([Quoted], [Quoted]) {
    // ...not important, aux function that given name/type
    // returns a slice of flattened Fields, for example: self.a, self.b self.nested.a, self.an_array[i] 
    // It also returns aux vars needed to generate said array
    // for example in case strings exist in the struct
    // and we need let field_as_str = str.to_bytes();
    (fields, aux_vars)
}

comptime fn derive_serialize(s: StructDefinition) -> Quoted {
    let typ = s.as_type();
    let (fields, aux_vars) = flatten_to_fields(quote { self }, typ);
    let aux_vars_quote = if aux_vars.len() > 0 {
        let joint = aux_vars.join(quote {;});
        quote { $joint; }
    } else {
        quote {}
    };

    let field_serializations = fields.join(quote {,});
    // Here comes trouble
    let serialized_len = fields.len(); // Setting this to a constant doesn't work either
    quote {
        impl Serialize<$serialized_len> for $typ {
            fn serialize(self) -> [Field; $serialized_len] {
                $aux_vars_quote
                [ $field_serializations ]
            }
        }
    }
}

In the above example, serialized_len cannot be unquoted into the trait impl generic, compiler fails with

error: Failed to parse macro's token stream into an expression
   ┌─ src/main.nr:75:1
   │    
75 │ ╭ ╭ #[derive(Serialize)]
76 │ │ │ struct Smol {
77 │ │ │     a: Field,
78 │ │ │     b: Field,
79 │ │ │ }
   │ ╰─│─'
   │   ╰─' expected <, where or { after impl type
   │    
   = The resulting token stream was: impl Serialize < (UnquoteMarker) > for (type) { fn serialize ( self ) -> [ Field ; (UnquoteMarker) ] { [ self . a as Field , self . b as Field ] } }
   = To avoid this error in the future, try adding input validation to your macro. Erroring out early with an `assert` can be a good way to provide a user-friendly error message

Expected Behavior

Example above should work

Bug

From a slack convo with @jfecher

Ahh, ok. So when we unquote expressions we actually usually keep them as expressions to avoid re-typechecking them and stuff. We leave little “UnquoteMarker” tokens where this happens, and these are later picked up by the parser as expressions. What is happening here is that the parser sees an UnquoteMarker in a type position and says “No, I wanted a Type, not an expression 😤.” Should be a quick fix.

To Reproduce

Workaround

None

Workaround Description

No response

Additional Context

No response

Project Impact

None

Blocker Context

No response

Nargo Version

No response

NoirJS Version

No response

Proving Backend Tooling & Version

No response

Would you like to submit a PR for this Issue?

None

Support Needs

No response