fix: SSA typing for loop bounds

[sirasistant]

Description

Problem*

Partial work towards #4275

Summary*

The frontend is not enforcing typing on loop bounds in some cases:

fn loop_from<N, K>(_arr: [Field; N], _another: [Field; K]) -> u32 {
    let mut acc = 0;
    // N and K are type Field but the iterator is u32
    for i in N..K {
        acc += i;
    }
    acc
}

fn main() -> pub u32 {
    loop_from([0; 10], [0; 20])
}

This PR casts the types of the bounds at the SSA level with the iterator type but we might want to enforce this in the frontend instead. I think the mismatch only happens on generic bounds so it might be painful to fix.

Additional Context

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]

The frontend does unify the type for loop bounds. The issue is related to #4118 where the frontend does not actually have a type for "any integer except Field." Once that PR is fixed & merged this issue should be fixed as well.

[sirasistant]

Thanks Jake! Will it also fix a case like this one?:

  fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
            let mut out = Point::zero();
            
            for i in 0..N {
                out = self.add(
                    self.add(out, out),
                    if(bits[N - i - 1] == 0) {Point::zero()} else {p});
            }

            out
        }

Where the N is not only used in the end range, but also in bits[N - i - 1] ? I think I'm seeing mismatched types in the loop end range but also in the binary operations to compute the bits index

[sirasistant]

Oh, I think your message in that PR addresses exactly that

[sirasistant]

@jfecher @michaeljklein just tested on master after #4118 was merged and we still have different types in the example in the description:

Types of loop: index Numeric(Unsigned { bit_size: 32 }), start Numeric(NativeField), end Numeric(NativeField)

[jfecher]

@sirasistant yep, sorry that is expected. We decided to split that PR into one that adds the new type variable kind, and then another later PR to use the new type variable kind in for loops and bitwise operations. I'll update this thread when the second PR is up

[jfecher]

@sirasistant #4376 should fix the issue

[sirasistant]

fixed in #4386