Expected identical type with arithmetic generics

[jfecher]

Aim

/// A trait for types that can be decoded from a calldata field array
trait FromCallData<let N: u32, let M: u32> {
    /// Decodes Self by consuming it from the head of calldata, returning the remaining calldata
    fn from_calldata(calldata: [Field; N]) -> (Self, [Field; M]);
}

struct Point { x: Field, y: Field }

impl <let N: u32> FromCallData<N, N - 1> for Field {
    fn from_calldata(calldata: [Field; N]) -> (Self, [Field; (N - 1)]) {
        let slice = calldata.as_slice();
        let (value, slice) = slice.pop_front();
        (value, slice.as_array())
    }
}

impl <let N: u32> FromCallData<N, N - 2> for Point {
    fn from_calldata(calldata: [Field; N]) -> (Self, [Field; (N - 2)]) {
        let (x, calldata) = FromCallData::from_calldata(calldata);
        let (y, calldata) = (1, foo(calldata));//FromCallData::from_calldata(calldata);
        (Self { x, y }, calldata)
    }
}

fn foo<let N: u32>(_a: [Field; N]) -> [Field; N - 1] {
    std::mem::zeroed()
}

fn main() {
    let calldata = [1, 2];
    let _: (Point, _) = FromCallData::from_calldata(calldata);
}

Expected Behavior

The program to type check correctly

Bug

error: expected type (Point, [Field; (N - 2)]), found type (Point, [Field; (N - 2)])
   ┌─ src/main.nr:18:47
   │
18 │     fn from_calldata(calldata: [Field; N]) -> (Self, [Field; (N - 2)]) {
   │                                               ------------------------ expected (Point, [Field; (N - 2)]) because of return type
   ·
21 │         (Self { x, y }, calldata)
   │         ------------------------- (Point, [Field; (N - 2)]) returned here
   │

(The error changes if the foo call is replaced with another from_call_data call)

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