fix: wrap required interfaces for optional parameters

Required interface values were emitted as Rust trait-object Arcs, while optional interface parameters use the nullable HxDynRef carrier. Forwarding a typed interface local into an optional constructor parameter therefore produced a Rust E0308 type mismatch.

The shared typed coercion boundary now recognizes that exact representation edge and wraps the existing trait-object handle without adding runtime dispatch. It requires equal source and destination trait-object types, so interface-inheritance upcasts remain outside this change. A framework-neutral portable and metal snapshot preserves the failure and checks the generated HxDynRef construction.

Focused interface snapshots, repository guards, pre-commit checks, and the independent codex-hxrust generated-Cargo smoke pass. Hosted pull-request checks provide broad validation before merge.

Author: fullofcaffeine

docs/rust-raw-authority-inventory.json

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

docs/semantic-confidence-summary.json

@@ -18,7 +18,7 @@
     "portableCandidateMissingFromTier2": 0,
     "portableSemanticDiffCases": 37,
     "laneSemanticDiffCases": 2,
-    "snapshotCases": 138,
+    "snapshotCases": 139,
     "bucketsByClass": {
       "compile_inventory": 2,
       "targeted_semantic_parity": 8,

docs/semantic-confidence-summary.md

@@ -26,7 +26,7 @@ This summary rolls up the current evidence buckets without pretending that Tier2
 - Portable candidate missing from Tier2: `0`
 - Portable semantic-diff cases: `37`
 - Lane semantic-diff cases: `2`
-- Snapshot cases: `138`
+- Snapshot cases: `139`
 - Compile/inventory buckets: `2`
 - Targeted semantic/runtime buckets: `8`
 - Snapshot/smoke-only buckets: `7`

scripts/lint/dynamic_allowlist.txt

@@ -15,9 +15,9 @@ src/reflaxe/rust/RustCompiler.hx:2768
 src/reflaxe/rust/RustCompiler.hx:2771
 src/reflaxe/rust/RustCompiler.hx:2779
 src/reflaxe/rust/RustCompiler.hx:10829
-src/reflaxe/rust/RustCompiler.hx:13582
-src/reflaxe/rust/RustCompiler.hx:13601
-src/reflaxe/rust/RustCompiler.hx:19673
+src/reflaxe/rust/RustCompiler.hx:13626
+src/reflaxe/rust/RustCompiler.hx:13645
+src/reflaxe/rust/RustCompiler.hx:19717
 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

@@ -13265,6 +13265,50 @@ class RustCompiler extends GenericCompiler<RustFile, RustFile, RustExpr, RustFil
 			});
 		}
 
+		/**
+			Wraps a required trait-object handle when its destination admits null.
+
+			Why
+			- Haxe types an optional interface parameter as `Null<Interface>`, while a required
+			  interface argument remains the same non-null interface at the call site.
+			- Rust represents those values differently: the required value is an `Arc<dyn Trait>`
+			  and the nullable destination is `HxDynRef<dyn Trait>`.
+
+			What
+			- Converts the already type-checked required interface value into the nullable carrier.
+			- Leaves concrete-class upcasts to the existing conversion below.
+
+			How
+			- Detects only the closed `Arc<dyn Trait>` to `HxDynRef<dyn Trait>` representation edge,
+			  requires structurally equal trait-object inner types, and constructs the nullable wrapper
+			  directly around the compiled value. Interface-inheritance upcasts remain unadmitted.
+		**/
+		var requiredTraitSource = unwrapMetaParen(valueExpr);
+		while (true) {
+			switch (requiredTraitSource.expr) {
+				case TCast(inner, _):
+					requiredTraitSource = unwrapMetaParen(inner);
+					continue;
+				case _:
+			}
+			break;
+		}
+		var requiredTraitSourceType = switch (requiredTraitSource.expr) {
+			case TLocal(variable): variable.t;
+			case _: requiredTraitSource.t;
+		};
+		var requiredTraitSourceRust = toRustType(requiredTraitSourceType, requiredTraitSource.pos);
+		var requiredTraitExpectedInner = rustTypeSingleGenericArgument(expectedRust);
+		var requiredTraitSourceInner = rustTypeSingleGenericArgument(requiredTraitSourceRust);
+		if (rustTypeIsDynRefCarrier(expectedRust)
+			&& rustTypeContainsTraitObject(expectedRust)
+			&& rustTypeIsRcTraitObject(requiredTraitSourceRust)
+			&& requiredTraitExpectedInner != null
+			&& requiredTraitSourceInner != null
+			&& rustTypesEqual(requiredTraitExpectedInner, requiredTraitSourceInner)) {
+			return ECall(rustDynRefMemberExpr("new"), [compiled]);
+		}
+
 		// `Null<T>` (Option<T>) used where a non-null `T` is expected.
 		//
 		// Haxe allows this implicitly in many places (especially in upstream stdlib for "dynamic-ish"

test/snapshot/interface_optional_constructor_forwarding/Channel.hx

@@ -0,0 +1,7 @@
+class Channel implements IChannel {
+	public function new() {}
+
+	public function label():String {
+		return "ready";
+	}
+}

test/snapshot/interface_optional_constructor_forwarding/ChannelOwner.hx

@@ -0,0 +1,11 @@
+class ChannelOwner {
+	final channel:Null<IChannel>;
+
+	public function new(?channel:IChannel) {
+		this.channel = channel;
+	}
+
+	public function label():String {
+		return channel == null ? "missing" : channel.label();
+	}
+}

test/snapshot/interface_optional_constructor_forwarding/IChannel.hx

@@ -0,0 +1,3 @@
+interface IChannel {
+	public function label():String;
+}

test/snapshot/interface_optional_constructor_forwarding/Main.hx

@@ -0,0 +1,10 @@
+class Main {
+	static function forward(channel:IChannel):ChannelOwner {
+		return new ChannelOwner(channel);
+	}
+
+	static function main() {
+		var channel:IChannel = new Channel();
+		Sys.println(forward(channel).label());
+	}
+}

test/snapshot/interface_optional_constructor_forwarding/compile.hxml

@@ -0,0 +1,7 @@
+-cp .
+-lib reflaxe.rust
+-D reflaxe_rust_strict_examples
+-D rust_output=out
+-D rust_deny_warnings
+-D reflaxe.dont_output_metadata_id
+-main Main