Keep the open-row field read marker request-local

Requests type-checked concurrently on separate domains shared the
open_row_field_read ref, so one request could overwrite another's marker
between typing a callee and reading it, and report warning 20 on an open
JS object method call. The marker is now a Request_local key.

A compiler request test compiles open-object method calls in two concurrent
requests with warning 20 enabled and expects no warning; it failed on every
run with the shared ref.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kr4cjoUi2f5VpMvE6wT9bo
Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

compiler/ml/typecore.ml

@@ -2519,8 +2519,10 @@ type targs = (Asttypes.arg_label * Typedtree.expression option) list
    to an open object row ([obj["m"]] with [obj: {..}]), [None] after any other
    read. Only the [Pexp_apply] case reads it: it resets it before typing the
    callee and checks it right after, where it is only meaningful when the
-   callee itself is such a read. *)
-let open_row_field_read : type_expr option ref = ref None
+   callee itself is such a read. Request-local, so requests type-checked
+   concurrently on other domains cannot overwrite it in between. *)
+let open_row_field_read : type_expr option ref Request_local.key =
+  Request_local.new_key (fun () -> ref None)
 
 (* Eliminate an object-field scheme for a read. A declared field payload is
    wrapped in [Tpoly]: an empty binder list needs ordinary instantiation, while
@@ -2790,7 +2792,7 @@ and type_expect_ ?deprecated_context ~context ?(recarg = Rejected)
     assert (sargs <> []);
     begin_def ();
     (* one more level for non-returning functions *)
-    open_row_field_read := None;
+    Request_local.get open_row_field_read := None;
     let funct =
       type_exp ~deprecated_context:FunctionCall ~context:None env sfunct
     in
@@ -2799,7 +2801,7 @@ and type_expect_ ?deprecated_context ~context ?(recarg = Rejected)
        like that of a callee that never returns, but the method receives its
        arguments, so [type_application] must not report them as unused. *)
     let open_row_method =
-      match (funct.exp_desc, !open_row_field_read) with
+      match (funct.exp_desc, !(Request_local.get open_row_field_read)) with
       | Texp_object_get _, Some ty -> repr ty == repr funct.exp_type
       | _ -> false
     in
@@ -3699,7 +3701,8 @@ and type_expect_ ?deprecated_context ~context ?(recarg = Rejected)
          requiring or adding write capability. *)
       let typ = filter_method env met obj.exp_type in
       let typ = object_field_use_type env typ in
-      open_row_field_read := if adds_field_to_row then Some typ else None;
+      Request_local.get open_row_field_read
+      := if adds_field_to_row then Some typ else None;
       rue
         {
           exp_desc = Texp_object_get (obj, met_loc);

tests/ounit_tests/ounit_compiler_request_tests.ml

@@ -1505,6 +1505,38 @@ let concurrent_jsx_diagnostic_tests _context =
         assert_equal right_expected.stderr (Domain.join right).stderr
       done)
 
+(* Calls of open JS object methods mark their callee in request-local typing
+   state. Another request typing applications at the same time must not
+   overwrite that mark, which would report the method's arguments as unused
+   (warning 20, off by default and enabled here). *)
+let concurrent_open_object_method_tests _context =
+  with_temp_dir "rewatch-driver-open-method-" (fun root ->
+      let source =
+        "@get external obj: string => {..} = \"obj\"\n"
+        ^ String.concat ""
+            (List.init 200 (fun i ->
+                 Printf.sprintf "let v%d = obj(\"e\")[\"m\"](\"a\", \"b\")\n" i))
+      in
+      let setup name =
+        let directory = Filename.concat root name in
+        ensure_dir directory;
+        write directory "Calls.res" source;
+        fun () -> snd (run directory ~extra:["-w"; "+20"] "Calls.res")
+      in
+      let left_request = setup "left" in
+      let right_request = setup "right" in
+      let expect_clean result =
+        expect_code 0 result;
+        assert_equal ~printer:Fun.id "" result.Rescript_compiler_driver.stderr
+      in
+      expect_clean (left_request ());
+      for _ = 1 to 5 do
+        let left = Domain.spawn left_request in
+        let right = Domain.spawn right_request in
+        expect_clean (Domain.join left);
+        expect_clean (Domain.join right)
+      done)
+
 (* Exercise concurrent compiler requests without the process-worker boundary. *)
 let concurrent_request_isolation_tests _context =
   with_temp_dir "rewatch-driver-domains-" (fun root ->
@@ -1710,6 +1742,7 @@ let suites =
          "concurrent_diagnostic_recovery"
          >:: concurrent_diagnostic_recovery_tests;
          "concurrent_jsx_diagnostic" >:: concurrent_jsx_diagnostic_tests;
+         "concurrent_open_object_method" >:: concurrent_open_object_method_tests;
          "concurrent_request_isolation" >:: concurrent_request_isolation_tests;
          "concurrent_async_context" >:: concurrent_async_context_tests;
        ]