Merge in latest master (#973)

- fix(rt): handle fun-type closure env refs in callee setup
[956](#956)
- fix(decode): accept signed enum tag scalars in _extract_tag
[954](#954)
- Added check for `FunType` in `setupCalleeClosure
[969](#969)

Author: mariaKt

kmir/src/kmir/decoding.py

@@ -445,10 +445,12 @@ def _extract_tag(*, data: bytes, tag_offset: MachineSize, tag: Scalar) -> tuple[
         case Initialized(
             value=PrimitiveInt(
                 length=length,
-                signed=False,
+                signed=_,
             ),
             valid_range=_,
         ):
+            # Stable MIR enum discriminants are represented against the raw tag bits.
+            # Use unsigned decoding even when the scalar metadata marks the tag as signed.
             tag_data = data[tag_offset.in_bytes : tag_offset.in_bytes + length.value]
             tag_value = int.from_bytes(tag_data, byteorder='little', signed=False)
             return tag_value, length

kmir/src/kmir/kdist/mir-semantics/kmir.md

@@ -551,8 +551,10 @@ Therefore a heuristics is used here:
      andBool isTypedValue(LOCALS[TUPLE])
      andBool isTupleType(lookupTy(tyOfLocal({LOCALS[TUPLE]}:>TypedLocal)))
      andBool isTypedLocal(LOCALS[CLOSURE])
-     andBool typeInfoVoidType ==K lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal))
-              // either the closure ref type is missing from type table
+     andBool (
+               typeInfoVoidType ==K lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal))
+               orBool isFunType(lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal)))
+             )
     [priority(40), preserves-definedness]
 
   rule [setupCalleeClosure2]: <k> #setUpCalleeData(
@@ -584,16 +586,22 @@ Therefore a heuristics is used here:
                // or the closure ref type pointee is missing from the type table
      andBool isRefType(lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal)))
      andBool isTy(pointeeTy(lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal))))
-     andBool lookupTy({pointeeTy(lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal)))}:>Ty) ==K typeInfoVoidType
+     andBool (
+               lookupTy({pointeeTy(lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal)))}:>Ty) ==K typeInfoVoidType
+               orBool isFunType(lookupTy({pointeeTy(lookupTy(tyOfLocal({LOCALS[CLOSURE]}:>TypedLocal)))}:>Ty))
+             )
     [priority(45), preserves-definedness]
 
   syntax Bool ::= isTupleType ( TypeInfo ) [function, total]
                 | isRefType ( TypeInfo ) [function, total]
+                | isFunType ( TypeInfo ) [function, total]
   // -------------------------------------------------------
   rule isTupleType(typeInfoTupleType(_, _)) => true
   rule isTupleType(    _                  ) => false [owise]
   rule isRefType(typeInfoRefType(_)) => true
   rule isRefType(    _             ) => false [owise]
+  rule isFunType(typeInfoFunType(_)) => true
+  rule isFunType(    _             ) => false [owise]
 
   syntax KItem ::= #setTupleArgs ( Int , Value )
                  | #setTupleArgs ( Int , List )

kmir/src/tests/integration/data/crate-tests/two-crate-bin/crate2::main.expected

@@ -2,7 +2,7 @@
 ┌─ 1 (root, init)
 │   #execTerminator ( terminator ( ... kind: terminatorKindCall ( ... func: operandC
 │
-│  (740 steps)
+│  (737 steps)
 ├─ 3 (terminal)
 │   #EndProgram ~> .K
 │

kmir/src/tests/integration/data/decode-value/enum-3-variants-0-fields-signed-tag.expected

@@ -0,0 +1 @@
+Aggregate ( variantIdx ( 1 ) , .List )

kmir/src/tests/integration/data/decode-value/enum-3-variants-0-fields-signed-tag.json

@@ -0,0 +1,138 @@
+{
+  "bytes": [
+    0
+  ],
+  "types": [],
+  "typeInfo": {
+    "EnumType": {
+      "name": "OrderingLike",
+      "adt_def": 72,
+      "discriminants": [
+        255,
+        0,
+        1
+      ],
+      "fields": [
+        [],
+        [],
+        []
+      ],
+      "layout": {
+        "fields": {
+          "Arbitrary": {
+            "offsets": [
+              {
+                "num_bits": 0
+              }
+            ]
+          }
+        },
+        "variants": {
+          "Multiple": {
+            "tag": {
+              "Initialized": {
+                "value": {
+                  "Int": {
+                    "length": "I8",
+                    "signed": true
+                  }
+                },
+                "valid_range": {
+                  "start": 255,
+                  "end": 1
+                }
+              }
+            },
+            "tag_encoding": "Direct",
+            "tag_field": 0,
+            "variants": [
+              {
+                "fields": {
+                  "Arbitrary": {
+                    "offsets": []
+                  }
+                },
+                "variants": {
+                  "Single": {
+                    "index": 0
+                  }
+                },
+                "abi": {
+                  "Aggregate": {
+                    "sized": true
+                  }
+                },
+                "abi_align": 1,
+                "size": {
+                  "num_bits": 8
+                }
+              },
+              {
+                "fields": {
+                  "Arbitrary": {
+                    "offsets": []
+                  }
+                },
+                "variants": {
+                  "Single": {
+                    "index": 1
+                  }
+                },
+                "abi": {
+                  "Aggregate": {
+                    "sized": true
+                  }
+                },
+                "abi_align": 1,
+                "size": {
+                  "num_bits": 8
+                }
+              },
+              {
+                "fields": {
+                  "Arbitrary": {
+                    "offsets": []
+                  }
+                },
+                "variants": {
+                  "Single": {
+                    "index": 2
+                  }
+                },
+                "abi": {
+                  "Aggregate": {
+                    "sized": true
+                  }
+                },
+                "abi_align": 1,
+                "size": {
+                  "num_bits": 8
+                }
+              }
+            ]
+          }
+        },
+        "abi": {
+          "Scalar": {
+            "Initialized": {
+              "value": {
+                "Int": {
+                  "length": "I8",
+                  "signed": true
+                }
+              },
+              "valid_range": {
+                "start": 255,
+                "end": 1
+              }
+            }
+          }
+        },
+        "abi_align": 1,
+        "size": {
+          "num_bits": 8
+        }
+      }
+    }
+  }
+}

…n/data/prove-rs/and_then_closure-fail.rs …ration/data/prove-rs/and_then_closure.rskmir/src/tests/integration/data/prove-rs/and_then_closure-fail.rs renamed to kmir/src/tests/integration/data/prove-rs/and_then_closure.rs kmir/src/tests/integration/data/prove-rs/and_then_closure-fail.rs renamed to kmir/src/tests/integration/data/prove-rs/and_then_closure.rs

@@ -0,0 +1,8 @@
+fn apply<F: FnOnce(u8, u8) -> u8>(f: F, a: u8, b: u8) -> u8 {
+    f(a, b)
+}
+
+fn main() {
+    let result = apply(|x, y| x + y, 10, 32);
+    assert_eq!(result, 42);
+}