Macros do not cast to signed types about millfork

[agg23]

This fix appears to be optimized out by O3 or greater in some scenarios (though it does not repro for this example in particular). Resulted in some strange bugs though.

[KarolS]

I finally found some time to sit down and think about it, and I think that it was a mistake to allow this to compile. Macro parameters are l-values, and those cannot be converted automatically in a sensible way.

However, to support more freeform macros, I decided to allow declaring macro parameters as void, which can be thought an arbitrary generic type, to allow reusing macros regardless of the actual argument types.

I'll tweak it a bit more in the upcoming week and I'm open to suggestions.

[agg23]

That seems reasonable. In scenarios such as this, what is the expected calling pattern?

[KarolS]

Sorry for a long wait.
I was thinking for a bit about the macros in general and I decided to not change most of how they work now.
As for your example, then I can suggest you match the type of the parameter to the type of the variable you pass in, so either:

sbyte input @0

or

macro void test_signed_macro(byte value) {
    if sbyte(value) > 3 {
        output = 1
    }
}

This should always work.

I'm currently thinking about implementing macros that can take any right-hand-side parameter, with usual type conversions, but that's still not finalized.

[KarolS]

I've added some new capabilities to macros. Similarly how you can declare parameters to asm macros as either ref, const or register, you can now declare parameters to non-asm macros as ref (default), const and call. ref is as before, a left-hand-side expression with strict type checking. const is simply required to be a constant, with standard type conversions. call is inserted as an expression evaluated at every occurrence within the macro body, cast to the declared type.

So now this should work: if you have

macro void test_signed_macro(sbyte call value) {
    if value > 3 {
        output = 1
    }
}

then test_signed_macro(input) expands to if sbyte(input) > 3 { output = 1 } and you get exactly what you wanted.

Note that the argument is evaluated at every occurrence, which might be dangerous, but also allows this silly thing:

macro twice(void call f) {
    f
    f
}
void inc() {
    output += 1
}
twice(inc())

Not all expressions can be used as such parameters (in particular, no assignments, so twice(output+=1) won't compile), but I think this is a neat emergent functionality.

Now you probably think about how to use this in conjunction with local variables declared within a macro, to avoid multiple evaluations while keeping the type casting, but macros aren't too hygienic right now and implementing that is an idea for a much further future.

Thanks for making me look deeper into this, I find what I arrived to a much better than what was before.