WIP

Author: shulhi

analysis/examples/larger-project/src/res_printer.res

@@ -28,7 +28,6 @@ let convertBsExternalAttribute = x =>
   | "bs.ignore" => "ignore"
   | "bs.inline" => "inline"
   | "bs.int" => "int"
-  | "bs.meth" => "meth"
   | "bs.module" => "module"
   | "bs.new" => "new"
   | "bs.obj" => "obj"

analysis/src/CompletionDecorators.ml

@@ -117,13 +117,6 @@ could potentially raise.
 
 Hint: Did you know you can run an interactive code analysis in your project by running the command `> ReScript: Start Code Analyzer`? Try it!|};
       ] );
-    ( "meth",
-      None,
-      [
-        {|The `@meth` decorator is used to call a function on a JavaScript object, and avoid issues with currying.
-
-[Read more and see examples in the documentation](https://rescript-lang.org/syntax-lookup#meth-decorator).|};
-      ] );
     ( "module",
       Some "module(\"$0\")",
       [

breadcrumb.md

@@ -0,0 +1,78 @@
+# ReScript Parser Breadcrumbs
+
+## What are Breadcrumbs?
+
+Breadcrumbs are a **parsing context tracking mechanism** that helps provide better error messages by keeping track of what grammatical constructs the parser is currently inside.
+
+## How they work:
+
+### 1. **Data Structure**
+```ocaml
+mutable breadcrumbs: (Grammar.t * Lexing.position) list;
+```
+- A list of tuples containing:
+  - `Grammar.t`: The type of grammar construct (like `AtomicTypExpr`, `ExprOperand`, etc.)
+  - `Lexing.position`: Where this construct started in the source code
+
+### 2. **Stack-based tracking**
+- **`leave_breadcrumb p circumstance`** (line 142): Pushes a new context onto the stack
+- **`eat_breadcrumb p`** (line 146): Pops the top context off the stack
+
+### 3. **Usage Pattern**
+```ocaml
+(* When entering a parsing function *)
+Parser.leave_breadcrumb p Grammar.AtomicTypExpr;
+(* ... parse the construct ... *)
+Parser.eat_breadcrumb p;  (* When exiting *)
+```
+
+## How they improve error messages:
+
+### 1. **Contextual error reporting**
+In `res_diagnostics.ml` lines 80-104, breadcrumbs are used to generate context-specific error messages:
+
+```ocaml
+| (AtomicTypExpr, _) :: breadcrumbs -> 
+  (* We're inside a type expression *)
+  "I'm missing a type here"
+  
+| (ExprOperand, _) :: breadcrumbs ->
+  (* We're inside an expression operand *)
+  "Did you forget to write an expression here?"
+```
+
+### 2. **Grammar-aware recovery**
+In `Recover.should_abort_list_parse` (line 46), breadcrumbs help determine if parsing should abort:
+- Checks if current token makes sense in the context of outer grammatical constructs
+- Prevents infinite loops in error recovery
+
+### 3. **Nested context awareness**
+The stack nature allows checking multiple levels:
+```ocaml
+| (ExprBlock, _) :: _, Rbrace ->
+  "It seems that this expression block is empty"
+| (ExprArrayMutation, _) :: _, _ ->
+  "Seems that an expression is missing, with what do I mutate the array?"
+```
+
+## Example in `parse_atomic_typ_expr`:
+
+```ocaml
+Parser.leave_breadcrumb p Grammar.AtomicTypExpr;  (* Push context *)
+let typ = (* parse the type *) in
+Parser.eat_breadcrumb p;  (* Pop context *)
+```
+
+If an error occurs while parsing the type, the error reporting can see:
+- "We're currently in an `AtomicTypExpr`"
+- "The outer context might be a record field, function parameter, etc."
+- Generate appropriate error message like "I'm missing a type here"
+
+## Benefits:
+
+1. **Better error messages**: Instead of generic "unexpected token", users get contextual hints
+2. **Error recovery**: Helps parser decide how to recover from errors
+3. **Debugging**: Provides parsing context for diagnostics
+4. **User experience**: Makes compiler errors more helpful and actionable
+
+The breadcrumb system is essentially a **parsing call stack** that enables sophisticated error reporting and recovery in the ReScript parser.

compiler/frontend/ast_attributes.ml

@@ -74,15 +74,13 @@ let process_method_attributes_rev (attrs : t) =
         ({st with set = Some result}, acc)
       | _ -> (st, attr :: acc))
 
-type attr_kind = Nothing | Meth_callback of attr | Method of attr
+type attr_kind = Nothing | Meth_callback of attr
 
 let process_attributes_rev (attrs : t) : attr_kind * t =
   Ext_list.fold_left attrs (Nothing, [])
-    (fun (st, acc) (({txt; loc}, _) as attr) ->
+    (fun (st, acc) (({txt}, _) as attr) ->
       match (txt, st) with
       | "this", (Nothing | Meth_callback _) -> (Meth_callback attr, acc)
-      | "meth", (Nothing | Method _) -> (Method attr, acc)
-      | "this", _ -> Bs_syntaxerr.err loc Conflict_bs_bs_this_bs_meth
       | _, _ -> (st, attr :: acc))
 
 let external_attrs =

compiler/frontend/ast_attributes.mli

@@ -29,7 +29,7 @@ type ('a, 'b) st = {get: 'a option; set: 'b option}
 
 val process_method_attributes_rev : t -> (bool * bool, [`Get | `No_get]) st * t
 
-type attr_kind = Nothing | Meth_callback of attr | Method of attr
+type attr_kind = Nothing | Meth_callback of attr
 
 val process_attributes_rev : t -> attr_kind * t
 

compiler/frontend/ast_core_type_class_type.ml

@@ -75,7 +75,6 @@ let typ_mapper (self : Bs_ast_mapper.mapper) (ty : Parsetree.core_type) =
     match fst (Ast_attributes.process_attributes_rev ty.ptyp_attributes) with
     | Meth_callback _ ->
       Ast_typ_uncurry.to_method_callback_type loc self ~arity ty
-    | Method _ -> Bs_ast_mapper.default_mapper.typ self ty
     | Nothing -> Bs_ast_mapper.default_mapper.typ self ty)
   | Ptyp_object (methods, closed_flag) ->
     let ( +> ) attr (typ : Parsetree.core_type) =
@@ -90,8 +89,6 @@ let typ_mapper (self : Bs_ast_mapper.mapper) (ty : Parsetree.core_type) =
               let attrs, core_type =
                 match Ast_attributes.process_attributes_rev attrs with
                 | Nothing, attrs -> (attrs, ty) (* #1678 *)
-                | Method _, _ ->
-                  Location.raise_errorf ~loc "%@get/set conflicts with %@meth"
                 | Meth_callback attr, attrs -> (attrs, attr +> ty)
               in
               Ast_compatible.object_field name attrs (self.typ self core_type)
@@ -100,8 +97,6 @@ let typ_mapper (self : Bs_ast_mapper.mapper) (ty : Parsetree.core_type) =
               let attrs, core_type =
                 match Ast_attributes.process_attributes_rev attrs with
                 | Nothing, attrs -> (attrs, ty)
-                | Method _, _ ->
-                  Location.raise_errorf ~loc "%@get/set conflicts with %@meth"
                 | Meth_callback attr, attrs -> (attrs, attr +> ty)
               in
               Ast_compatible.object_field name attrs
@@ -113,7 +108,6 @@ let typ_mapper (self : Bs_ast_mapper.mapper) (ty : Parsetree.core_type) =
               let attrs, core_type =
                 match Ast_attributes.process_attributes_rev ptyp_attrs with
                 | Nothing, attrs -> (attrs, ty)
-                | Method attr, attrs -> (attrs, attr +> ty)
                 | Meth_callback attr, attrs -> (attrs, attr +> ty)
               in
               Ast_compatible.object_field label attrs (self.typ self core_type)

compiler/frontend/bs_builtin_ppx.ml

@@ -102,9 +102,6 @@ let expr_mapper ~async_context ~in_function_def (self : mapper)
       async_context := (old_in_function_def && !async_context) || async;
       in_function_def := true;
       Ast_async.make_function_async ~async (default_expr_mapper self e)
-    | Method _, _ ->
-      Location.raise_errorf ~loc:e.pexp_loc
-        "%@meth is not supported in function expression"
     | Meth_callback _, pexp_attributes ->
       (* FIXME: does it make sense to have a label for [this] ? *)
       async_context := false;

lib/bs/build.ninja

@@ -0,0 +1 @@
+75521