FunctionDefinition::as_typed_expr fails when the trait impl has a where clause

[asterite]

Aim

This code:

trait Trait {}

impl Trait for i32 {}

trait Packable<let N: u32> {
    fn pack(self);
}

struct Foo<T> {}

impl<T> Packable<10> for Foo<T>
where
    T: Trait,
{
    fn pack(self) {}
}

fn main() {
    comptime {
        let foo = quote { Foo<i32> }.as_type();
        let t = quote { Packable<10> }.as_trait_constraint();
        let method = foo.get_trait_impl(t).unwrap().methods().filter(|method| {
            method.name() == quote { pack }
        })[0]
            .as_typed_expr();
    }
}

Expected Behavior

It should compile.

Bug

It fails with this error:

error: Object type is unknown in method call
   ┌─ src/main.nr:23:22
   │
23 │             let method = foo.get_trait_impl(t).unwrap().methods().filter(|method| {
   │ ╭────────────────────────'
   │ │ ╭──────────────────────'
24 │ │ │             method.name() == quote { pack }
25 │ │ │         })[0]
26 │ │ │             .as_typed_expr();
   │ ╰─│────────────────────────────' Type must be known by this point to know which method to call
   │   ╰────────────────────────────' While evaluating `FunctionDefinition::as_typed_expr

The compiler is trying to solve T: Trait in the trait impl and fails, but T at that point is an unbound type variable.

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