Fix formatting of Quoted values

[asterite]

Problem

Unquoting inside string literals doesn't work

Happy Case

This should work:

fn main() {
    comptime {
        let x = 3;
        let q = quote { x is $x };
        assert(false, f"q = {q}");
    }
}

Right now it gives this error:

error: q = quote { x is (UnquoteMarker) }
  ┌─ src/main.nr:5:16
  │
5 │         assert(false, f"q = {q}");
  │                ----- Assertion failed
  │

Workaround

None

Workaround Description

No response

Additional Context

No response

Project Impact

None

Blocker Context

No response

Would you like to submit a PR for this Issue?

None

Support Needs

No response

[jfecher]

We don't need to allow unquoting inside string literals - you can use format strings to format them which the example shows. The error is only because of the assert(false, _) and is just meant to show that when Quoted values are turned to strings we don't recursively handle converting each token to a string with the interner. We just call .to_string() on all of them which gives us (UnquoteMarker) strings.

[asterite]

Ah, great! I didn't know if the issue was only about converting Quoted values to string. It seems #5899 fixes this, then.

[asterite]

@jfecher I'm not sure this is solved.

For example this program:

fn main() {
    comptime
    {
        let name = quote { bar };
        assert_param(name);
    }
}

comptime fn assert_param(name: Quoted) {
    assert(false, f"Param {name} failed assertion");
}

Maybe I'd expect the output to be:

Param bar failed assertion

but right now this is the error:

Param quote { bar } failed assertion

That is, Quoted values are interpolated together with the surrounding quote { ... } but maybe that surrounding should be removed?

Mainly thinking about the original use case that triggered this:

assert(false, "Param $a_quote of type $a_type_quote is not supported as an argument")

As a side note, I'm also wondering if format strings wouldn't be useful to constructor identifiers. Something like this:

let hello = quote { hello };
let world = quote { world };
let name = f"{hello}_{world}";
let identifier: Quoted = name.as_identifier().unwrap(); 
println(identifier); // Prints "quote { hello_world }";

That way we wouldn't need to "glue" tokens because format strings kind of do that now. I'm also thinking about Elixir here, I guess in their macros you can operate with strings and eventually call String.to_atom to convert them to an atom that you can use to create a function, etc.

[jfecher]

I like the thought of using format strings for name formatting as well, then re-converting them into Quoted values.

As far as the Param quote { bar } failed assertion issue goes that seems like a tough one. Even if we remove the quote { } portion, users wouldn't be able to control the amount of spaces between each token in the Quoted value.
If we just want to consider the name use case we can just ignore this I suppose and expect each Quoted value to only have a single token.