Add errors for properly handling let x = _ cases.

src/passes/1-parser/reasonligo.ml

@@ -68,6 +68,18 @@ module Errors =
         ("location",
          fun () -> Format.asprintf "%a" Location.pp_lift @@ expression_loc)]
       in error ~data title message
+    
+    let invalid_wild (expr: AST.expr) = 
+      let title () = "" in
+      let message () = 
+        "It looks you are using a wild pattern where it cannot be used."
+      in
+      let expression_loc = AST.expr_to_region expr in
+      let data = [
+        ("location",
+         fun () -> Format.asprintf "%a" Location.pp_lift @@ expression_loc)]
+      in error ~data title message
+
   end
 
 let parse (module IO : IO) parser =
@@ -127,6 +139,8 @@ let parse (module IO : IO) parser =
 
   | exception SyntaxError.Error (SyntaxError.WrongFunctionArguments expr) ->
       Trace.fail @@ Errors.wrong_function_arguments expr
+  | exception SyntaxError.Error (SyntaxError.InvalidWild expr) ->
+      Trace.fail @@ Errors.wrong_function_arguments expr
 
 let parse_file (source: string) =
   let module IO =

src/passes/1-parser/reasonligo/Parser.mly

@@ -40,6 +40,13 @@ let rec curry hd = function
     in TFun {value; region}
 | [] -> hd
 
+let wild_error e = 
+  match e with 
+    | EVar { value = "_"; _} as e -> 
+      let open! SyntaxError in
+      raise (Error (InvalidWild e)) 
+    | _ -> ()
+
 (* END HEADER *)
 %}
 
@@ -262,24 +269,30 @@ let_declaration:
 
 let_binding:
   "<ident>" type_annotation? "=" expr {
+    wild_error $4;    
     Scoping.check_reserved_name $1;
     {binders = PVar $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | "_" type_annotation? "=" expr {
+    wild_error $4;   
     {binders = PWild $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | unit type_annotation? "=" expr {
+    wild_error $4;   
     {binders = PUnit $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | record_pattern type_annotation? "=" expr {
+    wild_error $4;   
     Scoping.check_pattern (PRecord $1);
     {binders = PRecord $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | par(closed_irrefutable) type_annotation? "=" expr {
+    wild_error $4;   
     Scoping.check_pattern $1.value.inside;
     {binders = PPar $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | tuple(sub_irrefutable) type_annotation? "=" expr {
+    wild_error $4;   
     Utils.nsepseq_iter Scoping.check_pattern $1;
     let hd, tl  = $1 in
     let start   = pattern_to_region hd in
@@ -408,7 +421,9 @@ expr:
   base_cond__open(expr) | switch_expr(base_cond) { $1 }
 
 base_cond__open(x):
-  base_expr(x) | conditional(expr_with_let_expr) { $1 }
+  base_expr(x) | conditional(expr_with_let_expr) { 
+    wild_error $1;
+    $1 }
 
 base_cond:
   base_cond__open(base_cond) { $1 }

src/passes/1-parser/reasonligo/ParserMain.ml

@@ -48,7 +48,12 @@ let parse parser : ('a, string Region.reg) Stdlib.result =
     in Stdlib.Error Region.{value=error; region}
 
   (* Scoping errors *)
-
+  | SyntaxError.Error (SyntaxError.InvalidWild expr) ->
+      let msg = "It looks you are using a wild pattern where it cannot be used.\n"
+      and region = AST.expr_to_region expr in
+      let error  = Unit.short_error ~offsets:IO.options#offsets
+                                     IO.options#mode msg region
+      in Stdlib.Error Region.{value=error; region}
   | Scoping.Error (Scoping.Reserved_name name) ->
       let token =
         Lexer.Token.mk_ident name.Region.value name.Region.region in

src/passes/1-parser/reasonligo/SyntaxError.ml

@@ -1,4 +1,5 @@
 type error = 
   | WrongFunctionArguments of AST.expr
+  | InvalidWild of AST.expr
 
 exception Error of error

src/passes/1-parser/reasonligo/SyntaxError.mli

@@ -1,4 +1,5 @@
 type error =
   | WrongFunctionArguments of AST.expr
+  | InvalidWild of AST.expr
 
 exception Error of error