module edwards25519

fn check_aliasing_onearg(f fn (mut v Scalar, x Scalar) Scalar, mut v Scalar, x Scalar) bool {
    x1, mut v1 := x, x

    // Calculate a reference f(x) without aliasing.
    mut out := f(mut v, x)
    if out != v || !is_reduced(out) {
        return false
    }

    // Test aliasing the argument and the receiver.
    out2 := f(mut v1, v1)
    if out2 != v1 || v1 != v || !is_reduced(out2) {
        return false
    }

    // Ensure the arguments was not modified.
    return x == x1
}

fn negate_aliasing(mut v Scalar, x Scalar) Scalar {
    // mut t := v
    return v.negate(x)
}

fn test_check_aliasing_oneargs() {
    x := generate_notzero_scalar(10)!
    mut v := generate_notzero_scalar(10)!
    out := check_aliasing_onearg(negate_aliasing, mut v, x)
    assert out == true
}

fn multiply_aliasing(mut v Scalar, x Scalar, y Scalar) Scalar {
    return v.multiply(x, y)
}

fn add_aliasing(mut v Scalar, x Scalar, y Scalar) Scalar {
    return v.add(x, y)
}

fn subtract_aliasing(mut v Scalar, x Scalar, y Scalar) Scalar {
    return v.subtract(x, y)
}

fn test_check_aliasing_twoargs() {
    fn_with_twoargs := [add_aliasing, multiply_aliasing, subtract_aliasing]
    for f in fn_with_twoargs {
        mut v := generate_notzero_scalar(10)!
        x := generate_notzero_scalar(10)!
        y := generate_notzero_scalar(10)!
        out := check_aliasing_twoargs(f, mut v, x, y)
        assert out == true
    }
}

fn check_aliasing_twoargs(f fn (mut v Scalar, x Scalar, y Scalar) Scalar, mut v Scalar, x Scalar, y Scalar) bool {
    x1, y1, mut v1 := x, y, Scalar{}

    // Calculate a reference f(x, y) without aliasing.
    mut out := f(mut v, x, y)
    if out != v || !is_reduced(out) {
        return false
    }

    // Test aliasing the first argument and the receiver.
    v1 = x
    out2 := f(mut v1, v1, y)
    if out2 != v1 || v1 != v || !is_reduced(out2) {
        return false
    }
    // Test aliasing the second argument and the receiver.
    v1 = y
    out3 := f(mut v1, x, v1)
    if out3 != v1 || v1 != v || !is_reduced(out3) {
        return false
    }

    // Calculate a reference f(x, x) without aliasing.
    out4 := f(mut v, x, x)
    if out4 != v || !is_reduced(out4) {
        return false
    }

    // Test aliasing the first argument and the receiver.
    v1 = x
    out5 := f(mut v1, v1, x)
    if out5 != v1 || v1 != v || !is_reduced(out5) {
        return false
    }
    // Test aliasing the second argument and the receiver.
    v1 = x
    out6 := f(mut v1, x, v1)
    if out6 != v1 || v1 != v || !is_reduced(out6) {
        return false
    }
    // Test aliasing both arguments and the receiver.
    v1 = x
    out7 := f(mut v1, v1, v1)
    if out7 != v1 || v1 != v || !is_reduced(out7) {
        return false
    }

    // Ensure the arguments were not modified.
    return x == x1 && y == y1
}