fix: narrow nullable scalar switches once

A nullable scalar switch could become an outer null check followed by a second Option match. The second match kept a dead Null Access throw in generated Rust.

Recognize the same compiler-generated alias shape when its final local sits inside transparent one-item blocks. Emit one Option match, while keeping all existing source-local, type, and Copy-value checks.

The portable and metal snapshots cover direct Int and Float switches plus a called try-and-close flow that produces the nested alias shape. Focused generation, formatting, Cargo build, Clippy, snapshot comparison, and the corrected codex-hxrust consumer replay pass.

The full harness passed all guards and 31 semantic-difference cases. Six unrelated semantic-difference cases exceeded the fixed 180-second timeout on the contended host.

Author: fullofcaffeine

docs/rust-raw-authority-inventory.json

@@ -71,7 +71,7 @@
     },
     {
       "path": "src/reflaxe/rust/RustCompiler.hx",
-      "line": 17483,
+      "line": 17491,
       "enclosingFunction": "addSpec",
       "factory": "traitImplementationAt",
       "authorityId": "metadata-owned",

scripts/lint/dynamic_allowlist.txt

@@ -17,7 +17,7 @@ src/reflaxe/rust/RustCompiler.hx:2814
 src/reflaxe/rust/RustCompiler.hx:10839
 src/reflaxe/rust/RustCompiler.hx:13641
 src/reflaxe/rust/RustCompiler.hx:13660
-src/reflaxe/rust/RustCompiler.hx:19972
+src/reflaxe/rust/RustCompiler.hx:19980
 src/reflaxe/rust/RustSourceMap.hx:419
 src/reflaxe/rust/analyze/RepresentationAnalysisSnapshot.hx:77
 src/reflaxe/rust/analyze/RepresentationAnalysisSnapshot.hx:81

src/reflaxe/rust/RustCompiler.hx

@@ -14205,6 +14205,7 @@ class RustCompiler extends GenericCompiler<RustFile, RustFile, RustExpr, RustFil
 
 		How
 		- Requires the null comparison, alias initializer, and alias tail to name the same Haxe local.
+		- Peels only metadata, parentheses, and transparent singleton blocks around the alias tail.
 		- Requires a Copy inner type and the exact non-null Rust result type, then compiles the source once.
 		- Returns `null` for every other conditional so ordinary Haxe null behavior stays unchanged.
 	**/
@@ -14259,7 +14260,14 @@ class RustCompiler extends GenericCompiler<RustFile, RustFile, RustExpr, RustFil
 			case TLocal(variable): variable.id == comparedLocal.id;
 			case _: false;
 		};
-		var tailMatches = switch (unwrapMetaParen(expressions[1]).expr) {
+		function unwrapAliasTail(expression:TypedExpr):TypedExpr {
+			var current = unwrapMetaParen(expression);
+			return switch (current.expr) {
+				case TBlock(items) if (items.length == 1): unwrapAliasTail(items[0]);
+				case _: current;
+			};
+		}
+		var tailMatches = switch (unwrapAliasTail(expressions[1]).expr) {
 			case TLocal(variable): variable.id == alias.id;
 			case _: false;
 		};

test/snapshot/nullable_scalar_switch_narrowing/Main.hx

@@ -1,4 +1,24 @@
 class Main {
+	static function readExit(value:Null<Int>):Null<Int> {
+		return value;
+	}
+
+	static function closeSource():Void {}
+
+	static function narrowRead(value:Null<Int>):Int {
+		try {
+			final exit = readExit(value);
+			closeSource();
+			final concreteExit:Int = switch (exit) {
+				case null: -1;
+				case concrete: concrete;
+			}
+			return concreteExit;
+		} catch (_:haxe.Exception) {
+			return -2;
+		}
+	}
+
 	static function narrow(value:Null<Int>):Int {
 		return switch (value) {
 			case null: -1;
@@ -14,6 +34,8 @@ class Main {
 	}
 
 	static function main():Void {
+		if (narrowRead(9) != 9) throw "read narrowing failed";
+		if (narrowRead(null) != -1) throw "null read narrowing failed";
 		if (narrow(7) != 7) throw "non-null narrowing failed";
 		if (narrow(null) != -1) throw "null narrowing failed";
 		if (narrowFloat(2.5) != 2.5) throw "non-null Float narrowing failed";

test/snapshot/nullable_scalar_switch_narrowing/intended/src/main.rs

@@ -23,6 +23,34 @@ pub(crate) fn __hx_is_subtype_type_id(actual: u32, expected: u32) -> bool {
     false
 }
 
+fn read_exit(value: Option<i32>) -> Option<i32> {
+    return value;
+}
+
+fn close_source() {}
+
+fn narrow_read(value: Option<i32>) -> i32 {
+    match hxrt::exception::catch_unwind(|| {
+        let exit: Option<i32> = read_exit(value);
+        close_source();
+        let concrete_exit: i32 = match exit {
+            None => -1,
+            Some(__hx_value) => __hx_value,
+        };
+        return concrete_exit;
+    }) {
+        Ok(__hx_ok) => __hx_ok,
+        Err(__hx_ex) => {
+            match __hx_ex.downcast::<crate::HxRef<crate::haxe_exception::Exception>>() {
+                Ok(_) => {
+                    return -2;
+                }
+                Err(__hx_ex) => hxrt::exception::rethrow(__hx_ex),
+            }
+        }
+    }
+}
+
 fn narrow(value: Option<i32>) -> i32 {
     return match value {
         None => -1,
@@ -38,6 +66,16 @@ fn narrow_float(value: Option<f64>) -> f64 {
 }
 
 fn main() {
+    if narrow_read(Some(9)) != 9 {
+        hxrt::exception::throw(hxrt::dynamic::from(hxrt::string::HxString::from(
+            "read narrowing failed",
+        )));
+    }
+    if narrow_read(None) != -1 {
+        hxrt::exception::throw(hxrt::dynamic::from(hxrt::string::HxString::from(
+            "null read narrowing failed",
+        )));
+    }
     if narrow(Some(7)) != 7 {
         hxrt::exception::throw(hxrt::dynamic::from(hxrt::string::HxString::from(
             "non-null narrowing failed",

test/snapshot/nullable_scalar_switch_narrowing/intended_metal/src/main.rs

@@ -23,6 +23,34 @@ pub(crate) fn __hx_is_subtype_type_id(actual: u32, expected: u32) -> bool {
     false
 }
 
+fn read_exit(value: Option<i32>) -> Option<i32> {
+    return value;
+}
+
+fn close_source() {}
+
+fn narrow_read(value: Option<i32>) -> i32 {
+    match hxrt::exception::catch_unwind(|| {
+        let exit: Option<i32> = read_exit(value);
+        close_source();
+        let concrete_exit: i32 = match exit {
+            None => -1,
+            Some(__hx_value) => __hx_value,
+        };
+        return concrete_exit;
+    }) {
+        Ok(__hx_ok) => __hx_ok,
+        Err(__hx_ex) => {
+            match __hx_ex.downcast::<crate::HxRef<crate::haxe_exception::Exception>>() {
+                Ok(_) => {
+                    return -2;
+                }
+                Err(__hx_ex) => hxrt::exception::rethrow(__hx_ex),
+            }
+        }
+    }
+}
+
 fn narrow(value: Option<i32>) -> i32 {
     return match value {
         None => -1,
@@ -38,6 +66,14 @@ fn narrow_float(value: Option<f64>) -> f64 {
 }
 
 fn main() {
+    if narrow_read(Some(9)) != 9 {
+        hxrt::exception::throw(hxrt::dynamic::from(String::from("read narrowing failed")));
+    }
+    if narrow_read(None) != -1 {
+        hxrt::exception::throw(hxrt::dynamic::from(String::from(
+            "null read narrowing failed",
+        )));
+    }
     if narrow(Some(7)) != 7 {
         hxrt::exception::throw(hxrt::dynamic::from(String::from(
             "non-null narrowing failed",