make code path handling the magic record field for dicts just work on the predefined dict

Author: zth

jscomp/build_tests/super_errors/expected/dict_magic_field_on_non_dict.res.expected

@@ -0,0 +1,13 @@
+
+  We've found a bug for you!
+  /.../fixtures/dict_magic_field_on_non_dict.res:5:6-23
+
+  3 │ let foo = (fakeDict: fakeDict<'a>) => {
+  4 │   switch fakeDict {
+  5 │   | {someUndefinedField: 1} => Js.log("one")
+  6 │   | _ => Js.log("not one")
+  7 │   }
+
+  The field someUndefinedField does not belong to type fakeDict
+  
+  This record pattern is expected to have type fakeDict<'a>

jscomp/build_tests/super_errors/fixtures/dict_magic_field_on_non_dict.res

@@ -0,0 +1,8 @@
+type fakeDict<'t> = {anyOtherField?: 't}
+
+let foo = (fakeDict: fakeDict<'a>) => {
+  switch fakeDict {
+  | {someUndefinedField: 1} => Js.log("one")
+  | _ => Js.log("not one")
+  }
+}

jscomp/ml/predef.ml

@@ -227,7 +227,7 @@ let common_initial_env add_type add_extension empty_env =
       type_variance = [Variance.full];
       type_kind = Type_record ([{
           ld_id = ident_anyOtherField;
-          ld_attributes = [(Location.mknoloc "res.optional", Parsetree.PStr [])];
+          ld_attributes = [(Location.mknoloc "res.optional", Parsetree.PStr []); (Location.mknoloc "res.dictMagicField", Parsetree.PStr [])];
           ld_loc = Location.none;
           ld_mutable = Immutable; (* TODO(dict-pattern-matching) Should probably be mutable? *) 
           ld_type = newgenty (Tconstr (path_option, [tvar], ref Mnil));

jscomp/ml/typecore.ml

@@ -804,18 +804,31 @@ end) = struct
   let lookup_from_type env tpath (lid : Longident.t loc) : Name.t =
     let descrs = get_descrs (Env.find_type_descrs tpath env) in
     Env.mark_type_used env (Path.last tpath) (Env.find_type tpath env);
-    match lid.txt with
-      Longident.Lident s_ -> begin
-        let s = 
-          if List.exists (fun nd -> get_name nd = s_) descrs
-          || not (List.exists (fun nd -> get_name nd = "anyOtherField") descrs)
-          then s_
-          else "anyOtherField" in 
+    (* TODO(dict-pattern-matching): also lookup the actual definition and check for @res.dict? *)
+    let is_dict = Path.same tpath Predef.path_dict in
+    if is_dict then (
+      match lid.txt with
+        Longident.Lident s_ -> begin
+          let s = 
+            if List.exists (fun nd -> get_name nd = s_) descrs
+            || not (List.exists (fun nd -> get_name nd = "anyOtherField") descrs)
+            then s_
+            else "anyOtherField" in 
+          try
+            let x = List.find (fun nd -> get_name nd = s) descrs in
+            if s = "anyOtherField"
+              then add_with_name x s_
+              else x
+          with Not_found ->
+            let names = List.map get_name descrs in
+            raise (Error (lid.loc, env,
+                          Wrong_name ("", newvar (), type_kind, tpath, s, names)))
+        end
+    | _ -> raise Not_found) 
+    else match lid.txt with
+      Longident.Lident s -> begin
         try
-          let x = List.find (fun nd -> get_name nd = s) descrs in
-          if s = "anyOtherField"
-            then add_with_name x s_
-            else x
+          List.find (fun nd -> get_name nd = s) descrs
         with Not_found ->
           let names = List.map get_name descrs in
           raise (Error (lid.loc, env,