Fixes regression in match with qualified enums.

Author: modlfo

src/core/inference.ml

@@ -1723,6 +1723,15 @@ let makeIfOfMatch env e cases =
         (* Constant: create a constant reference for comparison *)
         makeEq e Syntax.{ e = SEId id; loc }
       | _ -> Error.raiseError ("Pattern '" ^ id ^ "' is not a valid enum constructor or constant") loc)
+    | _, { p = SPMember ({ p = SPId module_name; _ }, variant_name); loc } -> (
+      (* Handle qualified enum constructor patterns like Button.Push *)
+      let id_path : path = { id = variant_name; n = Some module_name; loc } in
+      match Env.lookupExpressionSymbol env id_path normal_context with
+      | ExprEnum (_, _, _) -> makeEq e Syntax.{ e = SEMember (Syntax.{ e = SEId module_name; loc }, variant_name); loc }
+      | _ -> Error.raiseError ("Pattern '" ^ module_name ^ "." ^ variant_name ^ "' is not a valid enum constructor") loc
+      )
+    | _, { p = SPMember _; loc } ->
+      Error.raiseError "Invalid qualified pattern. Only Module.Variant patterns are supported" loc
   in
   let if_stmt =
     CCList.fold_right

src/driver/loader.ml

@@ -97,6 +97,7 @@ module Dependencies = struct
     | SPId _ -> set
     | SPTuple elems -> list pattern set elems
     | SPGroup e -> pattern set e
+    | SPMember (p, _) -> pattern set p
 
 
   let rec dexp set d =

src/pparser/parse.ml

@@ -611,11 +611,16 @@ and pair_pattern (buffer : Stream.stream) (token : 'kind token) (left : pattern)
   { p = SPTuple (elems1 @ elems2); loc = left.loc }
 
 
-and pattern_member (_ : Stream.stream) (token : 'kind token) (_ : pattern) : pattern =
-  let message =
-    Error.PointedError (token.loc, "Pattern member access is not supported. Use simple patterns in match expressions")
-  in
-  raise (ParserError message)
+and pattern_member (buffer : Stream.stream) (token : 'kind token) (left : pattern) : pattern =
+  let right = pattern (getExpLbp token) buffer in
+  match right.p with
+  | SPMember (({ p = SPId id; _ } as i), n) -> { right with p = SPMember ({ i with p = SPMember (left, id) }, n) }
+  | SPId id -> { right with p = SPMember (left, id) }
+  | _ ->
+    let message =
+      Error.PointedError (token.loc, "Invalid pattern member access. Expected an identifier after the dot")
+    in
+    raise (ParserError message)
 
 
 and exp_member (buffer : Stream.stream) (token : 'kind token) (left : exp) : exp =

src/pparser/syntax.ml

@@ -89,6 +89,7 @@ type pattern_d =
   | SPId of string
   | SPTuple of pattern list
   | SPGroup of pattern
+  | SPMember of pattern * string
 
 and pattern =
   { p : pattern_d
@@ -335,6 +336,9 @@ module Print = struct
     | SPGroup e ->
       let e = pattern e in
       {%pla|(<#e#>)|}
+    | SPMember (p, m) ->
+      let p = pattern p in
+      {%pla|<#p#>.<#m#s>|}
 
 
   let rec lexp (l : lexp) = lexp_d l.l
@@ -1498,6 +1502,7 @@ module SExpr = struct
       | SPId id -> "(SPId " ^ id ^ ")"
       | SPTuple lst -> "(SPTuple " ^ print_list print_pattern lst ^ ")"
       | SPGroup p -> "(SPGroup " ^ print_pattern p ^ ")"
+      | SPMember (p, m) -> "(SPMember " ^ print_pattern p ^ " " ^ m ^ ")"
     in
     "(pattern " ^ p_str ^ ")"
 

src/pparser/syntaxSexp.ml

@@ -123,6 +123,7 @@ and pattern_d (p : pattern_d) : string =
     let patterns_str = String.concat " " (List.map pattern patterns) in
     Printf.sprintf "(tuple %s)" patterns_str
   | SPGroup p -> Printf.sprintf "(group %s)" (pattern p)
+  | SPMember (p, m) -> Printf.sprintf "(member %s %s)" (pattern p) m
 
 
 and lexp (l : lexp) : string = Printf.sprintf "(lexp %s %s)" (lexp_d l.l) (Loc.to_string l.loc)

test/interpreter/ButtonEnum.vult

@@ -0,0 +1,6 @@
+// Module defining the Button enum for cross-module qualified pattern tests
+enum state {
+   Push,
+   Release,
+   Hold
+}

test/interpreter/qualified_enum_patterns.vult

@@ -0,0 +1,40 @@
+// Test for qualified enum patterns in match expressions
+// Tests cross-module access to enum variants like ButtonEnum.Push
+
+// Test function using qualified enum patterns in match
+fun handleButton(b : ButtonEnum.state) : int {
+   match (b) {
+      ButtonEnum.Push -> return 1;
+      ButtonEnum.Release -> return 2;
+      ButtonEnum.Hold -> return 3;
+   }
+}
+
+// Test with mixed patterns (qualified and wildcard)
+fun handleButtonWithDefault(b : ButtonEnum.state) : int {
+   match (b) {
+      ButtonEnum.Push -> return 10;
+      _ -> return 0;
+   }
+}
+
+// Main test function
+fun main() : int {
+   // Test basic qualified enum patterns
+   val result1 = handleButton(ButtonEnum.Push);    // Should return 1
+   val result2 = handleButton(ButtonEnum.Release); // Should return 2
+   val result3 = handleButton(ButtonEnum.Hold);    // Should return 3
+   
+   // Test with default case
+   val result4 = handleButtonWithDefault(ButtonEnum.Push);    // Should return 10
+   val result5 = handleButtonWithDefault(ButtonEnum.Release); // Should return 0
+   
+   // Verify all results
+   if (result1 == 1 && result2 == 2 && result3 == 3) {
+      if (result4 == 10 && result5 == 0) {
+         return 100; // All tests passed
+      }
+   }
+   
+   return -1; // Some test failed
+}

test/test.ml

@@ -200,6 +200,7 @@ let interpreter =
   ; "instance_state.vult"
   ; "int16_test.vult"
   ; "memory_state.vult"
+  ; "qualified_enum_patterns.vult"
   ; "strength_reduction.vult"
   ]