Types cannot be unquoted to call static methods

[Thunkar]

Aim

Given

mod types {
    use std::meta::type_of;

    struct Foo {
        x: Field,
    }

    impl Foo {
        fn static() -> Field {
            3
        }
    }

    comptime fn add_static_call(m: Module) -> Quoted {
        // If I want this to be resolved in AMod, I need to use the type, since the struct name is just Foo and I need types::Foo
        let type_of_foo =quote { Foo }.as_type();
        quote {
            fn call_static() -> Field{
                $type_of_foo::static()
            }
        }
    }
}

use types::add_static_call;

#[add_static_call]
mod AMod {}

Expected Behavior

The code above should compile, so that Foo can be used in AMod even if it was resolved in its own mod.

Bug

The compiler fails to parse the macro token stream

To Reproduce

Workaround

None

Workaround Description

No response

Additional Context

No response

Project Impact

Blocker

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

[asterite]

This can be solved with a trick Jake told me today (I needed to do something similar and I didn't want to use a fully qualified name):

mod types {
    struct Foo {
        x: Field,
    }

    impl Foo {
        fn static() -> Field {
            3
        }
    }

    pub comptime fn add_static_call(m: Module) -> Quoted {
        let static_call = Foo::static;
        quote {
            fn call_static() -> Field {
                $static_call()
            }
        }
    }
}

use types::add_static_call;

#[add_static_call]
mod AMod {}

[asterite]

I also tried doing this but it didn't work:

let foo = std::meta::type_of(Foo { x: 1 });
quote {
  fn call_static() -> Field {
    $foo::static()
  }
}

The reason is that $foo in that parsing position must be a Path, not a Type.

Unrelated, but I'm thinking it would be nice to be able to somehow convert a type to a Type. We can do that with std::meta::type_of, but we have to pass an actual instance.

But, we can also do this:

struct Foo {
    x: Field
}

comptime fn get_type<T>() -> Type {
    let exp: T = std::mem::zeroed();
    std::meta::type_of(exp)
}

fn main() {
    comptime
    {
        let foo = get_type::<Foo>();
        println(foo);
    }
}

[jfecher]

This can be solved with a trick Jake told me today (I needed to do something similar and I didn't want to use a fully qualified name):

This is true, I'm assuming @Thunkar's full example could be using a non-statically known type from user code somewhere so we'd still need this feature to do:

comptime fn add_static_call(m: Module, t: Type) -> Quoted {
    quote {
        fn call_static() -> Field {
            $t::static()
        }
    }
}

So I'm working on this issue since we should also support this usecase

[asterite]

I don't know how you are going to implement this, but some weeks ago I wanted to implement being able to do Field::method(), i32::method(), etc. I just pushed the branch I had. I changed the parsing a bit to allow type :: name ( .. ) to be parsed, but only for primitive types. I guess allowing that for interned types would be similar, and it might enable being able to call primitive "static" methods (though in my PR it didn't work because primitive methods are assumed to have a self argument, I think)