Haxe 4 Int-to-Float coercion behaves differently on JS and eval targets after migrating shared numeric code

Answer to the question

1. Which targets permit implicit Int↔Float coercion?

• JavaScript (hxnodejs, browser) – the compiler accepts an Int where a Float is expected and injects a runtime cast. The same applies to Float → Int when the target language can represent the value.
• Eval – the compiler rejects any implicit conversion between Int and Float. Both arithmetic expressions and typed function signatures require an explicit cast (e.g. Std.int / Float).

2. Do arithmetic and function signatures behave the same?

• Arithmetic expressions – on JS the compiler silently promotes Int literals to Float and inserts a cast where needed. On eval, the same expression causes a compile‑time error unless you cast explicitly.
• Typed function signatures – JS accepts function foo(x:Float) and allows foo(42) without error. Eval requires foo(42) to be written as foo(42.0) or foo(Std.int(42)) (or a @:fast annotation).

3. Can a flag or typedef make the behaviour uniform?

• No compiler flag exists that switches the implicit coercion rules for all targets.
• To keep a single source tree you must either:
  • explicitly cast every value that crosses a target boundary, or
  • define a typedef FloatOrInt = Float (or a wrapper type) and use that in signatures, then perform the cast inside the function body.

Practical verification steps

1. Create a small test file Test.hx:

   class Test {
       static function main() {
           trace(f(42)); // Int literal
       }
       static function f(x:Float):Float {
           return x * 2;
       }
   }

2. Compile for JS:

   haxe -main Test -js test.js
   node test.js
   # Output: 84

3. Compile for eval:

   haxe -main Test -eval
   # You will see: "Error: Incompatible types: Int and Float"

4. Fix the eval error by adding a cast:

   static function f(x:Float):Float {
       return x * 2;
   }
   static function main() {
       trace(f(42.0));
   }

Missing diagnostic detail

What exact Haxe version are you using? The coercion rules are stable across 4.x, but minor releases can introduce subtle changes, so confirming the version will help rule out version‑specific quirks.