feat: Implement generic traits

[jfecher]

Description

Problem*

Resolves #3471
Resolves #3474

Summary*

Implements support for generics on the trait directly. E.g. trait Into<T> { ... }

Additional Context

The old trait_generics test has been renamed to trait_impl_generics - I think this is more accurate. There is a new test in trait_generics now which tests the generic traits added by this PR.

I've discovered two new bugs in writing this PR, which are commented in the trait_generics test. I'll make issues for them now.

Documentation*

Check one:

• No documentation needed.
• Documentation included in this PR.
• [Exceptional Case] Documentation to be submitted in a separate PR.

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[jfecher]

Issue/PR #4000 🎉

[jfecher]

Ah, forgot to update some code I commented out. PR is not done yet, apologies.

[github-actions]

🚀 Deployed on https://65a6cb852f63ed0a9a42b57a--noir-docs.netlify.app

[Thunkar]

Just checked to avoid duplicating work. This fixes #3474 !

False alarm, will keep working on it

Yup, it is fixed

[jfecher]

@Thunkar I didn't finish rewriting the check for the parameters / return type of a trait method yet at the time. I tested again after fixing the trait_impl_generics test and #3474 is fixed now in this PR

[jfecher]

@kevaundray @TomAFrench @vezenovm, this PR is ready to review again

[sirasistant]

One question, this fails on me with the code in this PR:

trait Serializable<N> {
    fn serialize(self) -> [Field; N];
}

global DATA_LEN = 2;

struct Data {
    a: Field,
    b: Field,
}

impl Serializable<DATA_LEN> for Data {
    fn serialize(self) -> [Field; DATA_LEN] {
        [self.a, self.b]
    }
}

fn sum<T, N>(data: T) -> Field where T: Serializable<N> {
    let serialized = data.serialize();
    serialized.fold(0, |acc, elem| acc + elem)
}

fn main(data: Data) -> pub Field {
    sum(data)
}

It generates invalid SSA:

Initial SSA:
acir fn main f0 {
  b0(v0: Field, v1: Field):
    v3 = call f1(v0, v1)
    return v3
}
acir fn sum f1 {
  b0(v0: Field, v1: Field):
    v3, v4 = call f2(v0, v1) 
    inc_rc v4
    inc_rc v4
    v8 = call f3(v3, v4, Field 0, f4)
    return v8
}
acir fn serialize f2 {
  b0(v0: Field, v1: Field):
    return [v0, v1]
}
acir fn fold f3 {
  b0(v0: Field, v1: [Field], v2: Field, v4: function):
    v3 = allocate
    store v2 at v3
    inc_rc v1
    inc_rc v1
    jmp b1(Field 0)
  b1(v5: Field):
    v8 = lt v5, v0
    jmpif v8 then: b2, else: b3
  b2():
    v10 = cast v0 as u64
    v11 = lt v5, v10
    constrain v11 == u1 1 'Index out of bounds'
    v13 = array_get v1, index v5
    v14 = load v3
    v15 = call v4(v14, v13)
    store v15 at v3
    v16 = add v5, Field 1
    jmp b1(v16)
  b3():
    v17 = load v3
    return v17
}
acir fn lambda f4 {
  b0(v0: Field, v1: Field):
    v2 = add v0, v1
    return v2
}

It thinks that serialize returns a slice instead of a fixed length array
Crashes with

The application panicked (crashed).
Message:  assertion failed: `(left == right)`
  left: `2`,
 right: `1`
Location: compiler/noirc_evaluator/src/ssa/opt/inlining.rs:420

I think it fails to inline serialize because the return values in serialize (one return value, an array) don't match with the return values at the callsite (two return values, one length and one slice)

[jfecher]

Thanks for the test @sirasistant, it turned out to be a very good one since it highlighted a lot of requirements I hadn't yet done. I had thought I was missing something since the original PR was quite small, and indeed I was missing a lot. I also thought the Into<T> test was sufficient, but your example highlights the need to test more. I added your example as a test, and added a variant of it where the trait method is called with a static method which gave me some additional issues while testing that are resolved now.

This PR should be ready for review now.