Roc does not detect type mismatch error when performing math on values defined in separate file

[imclerran]

Crash message:

This expectation crashed while running:

10│  expect foo 1u8 == 1 + externalDerivedValue
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The crash reported this message:

Hit an erroneous type when creating a layout for `4.IdentId(21)`
1 failed and 0 passed in 333 ms.

OR:

thread 'main' panicked at crates/compiler/alias_analysis/src/lib.rs:612:38:
no entry found for key

(Min repro for both below)

Expected behavior

Preferred behavior:

• Fail to compile with message about type mismatch.

Alternative acceptable behavior:

• Crash with message about Integer overflow

Description of error case

To reproduce, the following criteria must be met:

1. The constant must be defined in another file
2. The constant must be derived from another constant The failure mode will vary depending on whether the constant is defined by a literal, or based on another another constant.
3. The constant must be operated on with another value typed as Int *
4. A value of set type must be passed into the Int *
5. The constant must exceed on its own, the maximum value of the type held by the Int *

Note that point 5 means that if you do instStar + constant, where intStar holds 1u8, and constant == 255, Roc will crash with an integer overflow error. However, if constant == 256, it will trigger the Hit an erroneous type when creating a layout for '4.IdentId(21)' error described here.

Minimum reproduction

# MinRepro.roc
interface MinRepro
    exposes []
    imports [
        External.{ 
            # externalBaseValue,
            externalDerivedValue,
        }
    ]
    
# internalBaseValue = 256 # use in foo to to compile but produce mathematically incorrect result (expect fails)
# internalDerivedValue = 1 * internalBaseConst # use in foo to get *correct/expected* type mismatch error 

foo : Int * -> U16
foo = \n -> Num.toU16 (n + externalDerivedValue) # replacing with externalBaseValue will produce rust panic

expect 
    res = foo 1u8 # if using internalBaseValue, res == 1  (should == 257)
    res == 1 + externalDerivedValue

# External.roc
interface External
    exposes [
        externalBaseValue,
        externalDerivedValue,
    ]
    imports []

externalBaseValue = 256
externalDerivedValue = 1 * externalBaseValue

[imclerran]

4 ways to define a value == 3 failure modes + 1 success

Note that behavior varies wildly depending on how and where the value is defined. I have identified 4 different distinct failure modes:

1. Failure mode 1 ❌
   • Value : is defined in the same file, and is not derived from any other value.
   • Result: compiles, treats the constant like a zero, operation is mathematically incorrect.
2. Success ✅
   • Value: is defined in the same file, and is derived from another value.
   • Result: Type mismatch error.
3. Failure mode 2 ❌
   • Value: is defined in separate file, and is not derived from any other value.
   • Result: Rust panics and crashes with "no entry found for key"
4. Failure mode 3 ❌
   • Value: is defined in separate file, and is derived from another value.
   • Result: Roc crashes with "Hit an erroneous type when creating a layout for 4.IdentId(21)"