bugfix: issue-5283 (repro and fix) (#5412)

Fix for issue #5283.

The await translation would crash in obscure cases. Turns out its due to a bug in ir/rename.ml that wasn't properly distinguishing labels from identifiers when renaming them.

The counter-example is this code from the repro

```
                       label satset for (satset in [1,2,4].vals()) {
                          if (4==5) {
                            
                            break satset;
                          }
                        };
```

This uses a label and identifier with the same name, and unless kept distinct, after broken renaming,  would result in the inner break referencing the new identifier for (inner) satset rather than the new label for (outer) satset.

The fix is for renaming to use a map with a domain that distinguishes identifers from labels. 
Even better would be if we didn't use the same type (string, yuck) for identifiers and labels, but that is a bigger refactoring for later.

Author: crusso

Changelog.md

@@ -1,5 +1,9 @@
 # Motoko compiler changelog
 
+* motoko (`moc`)
+
+  * bugfix: fix rare compiler crash when using a label and identifier of the same name in the same scope (#5283, #5412).
+
 ## 0.16.0 (2025-08-19)
 
 * motoko (`moc`)
@@ -20,7 +24,7 @@
     Weak reference operations are only supported with --enhanced-orthogonal-persistence and cannot be used with the classic compiler.
 
   * bugfix: the EOP dynamic stable compatibility check incorrectly rejected upgrades from `Null` to `?T` (#5404).
-  
+
   * More explanatory upgrade error messages with detailing of cause (#5391).
 
   * Improved type inference for calling generic functions (#5180).

src/ir_def/ir.ml

@@ -273,7 +273,7 @@ let replace_obj_pat pfs pats =
 
 (* Helper for transforming prims, without missing embedded typs and ids *)
 
-let map_prim t_typ t_id p =
+let map_prim t_typ t_lab p =
   match p with
   | CallPrim ts -> CallPrim (List.map t_typ ts)
   | UnPrim (ot, op) -> UnPrim (t_typ ot, op)
@@ -292,7 +292,7 @@ let map_prim t_typ t_id p =
   | EqArrayOffset
   | DerefArrayOffset
   | GetLastArrayOffset -> p
-  | BreakPrim id -> BreakPrim (t_id id)
+  | BreakPrim id -> BreakPrim (t_lab id)
   | RetPrim
   | AwaitPrim _
   | AssertPrim

src/ir_def/rename.ml

@@ -1,32 +1,56 @@
 open Source
 open Ir
 
-module Renaming = Map.Make(String)
+(* Identifiers and labels reside in different namespaces
+   so we need to distinguish them when renaming to avoid capture  *)
+
+module Binder = struct
+  type t = Id of id | Lab of id
+  let compare t1 t2 =
+    match t1, t2 with
+    | (Id id1, Id id2) -> String.compare id1 id2
+    | (Lab lab1, Lab lab2) -> String.compare lab1 lab2
+    | (Id _, Lab _) -> -1
+    | (Lab _, Id _) -> 1
+end
+
+module Renaming = Map.Make(Binder)
+
 
 (* One traversal for each syntactic category, named by that category *)
 
 let fresh_id id = Construct.fresh_id id ()
 
 let id rho i =
-  try Renaming.find i rho
-  with Not_found -> i
+  match Renaming.find_opt (Binder.Id i) rho with
+  | Some i1 -> i1
+  | None -> i
+
+let lab rho l =
+  match Renaming.find_opt (Binder.Lab l) rho with
+  | Some l1 -> l1
+  | None -> l
 
 let id_bind rho i =
   let i' = fresh_id i in
-  (i', Renaming.add i i' rho)
+  (i', Renaming.add (Binder.Id i) i' rho)
 
 let rec ids_bind rho = function
   | [] -> rho
   | i::is' ->
     let (i', rho') = id_bind rho i in
     ids_bind rho' is'
 
+let lab_bind rho i =
+  let i' = fresh_id i in
+  (i', Renaming.add (Binder.Lab i) i' rho)
+
 let arg_bind rho a =
-  let i' = fresh_id a.it in
-  ({a with it = i'}, Renaming.add a.it i' rho)
+  let i', rho' = id_bind rho a.it in
+  ({a with it = i'}, rho')
 
 let rec prim rho p =
-  Ir.map_prim Fun.id (id rho) p (* rename BreakPrim id etc *)
+  Ir.map_prim Fun.id (lab rho) p (* rename BreakPrim id etc *)
 
 and exp rho e  =  {e with it = exp' rho e.it}
 and exp' rho = function
@@ -56,7 +80,7 @@ and exp' rho = function
   | IfE (e1, e2, e3)    -> IfE (exp rho e1, exp rho e2, exp rho e3)
   | SwitchE (e, cs)     -> SwitchE (exp rho e, cases rho cs)
   | LoopE e1            -> LoopE (exp rho e1)
-  | LabelE (i, t, e)    -> let i',rho' = id_bind rho i in
+  | LabelE (i, t, e)    -> let i', rho' = lab_bind rho i in
                            LabelE(i', t, exp rho' e)
   | AsyncE (s, tb, e, t) -> AsyncE (s, tb, exp rho e, t)
   | DeclareE (i, t, e)  -> let i',rho' = id_bind rho i in

test/run-drun/issue-5283.mo

@@ -0,0 +1,14 @@
+persistent actor {
+
+ class C() = this {
+   public func m() : async () {
+     label l {
+       for (l in [0, 1, 2, 3].values()) {
+         ignore l == 0;
+         break l; // label l, not identifier l!
+       }
+     }
+   }
+ }
+
+};

test/run-drun/ok/issue-5283.drun-run.ok

@@ -0,0 +1,2 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000

test/run-drun/ok/issue-5283.tc.ok

@@ -0,0 +1 @@
+issue-5283.mo:3.8-3.9: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)