Pattern matching for dicts (#7059)

* Draft dict pattern matching.

Works for this:

```
type myDict = {name?:string, anyOtherField?: int}

let tst = (d: myDict) => switch d {
    | {name:n, something:i} => String.length(n) + i
    | {name:n} => String.length(n)
    | {something:i} => i
    | _ => 0
}
```

* Avoid mis-firing when a field is legit missing.

* Make lbl_all mutable.

With lbl_all mutable, it can be extended when new fields are used in pattern matching.

This handles examples with multiple fields:

```
type myDict = {name?:string, anyOtherField?: int}

let tst = (d: myDict) => switch d {
    | {a:i, b:j} => i + j
    | _ => 0
}

```

* Add test for the various aspects of first class dicts.

* update tests

* make builtin dict type be a record with anyOtherField catch all

* make typechecker account for res.dictPattern attribute to infer record pattern as dict pattern match when the type is not already known

* format

* add some tests, and disallow direct record field access on dicts

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

* remove now irrelevant test since we reduced scope to just focus on dicts in the first iteration, not record-with-some-and-some-unknown-properties

* remove lingering file

* format

* make sure coercion is disallowed for dicts

* add internal test making sure dict labels dont stack

* add more fields to test

* comment + rename file

* share a few definitions

* no need to check tvar

* remove comment

* add more comments

* syntax support

* cleanup

* add broken dict pattern parsing test

* fix pattern matching of dict

* comments and changelog

* a few more comment tests

* undo changelog formatting

* fixes

* simplify

* add live attribute suppressing dead code analysis for dicts since they can't be statically analysed for unused fields

---------

Co-authored-by: Cristiano Calcagno <[email protected]>
Co-authored-by: Paul Tsnobiladzé <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -21,6 +21,7 @@
 - Use FORCE_COLOR environmental variable to force colorized output https://github.com/rescript-lang/rescript-compiler/pull/7033
 - Allow spreads of variants in patterns (`| ...someVariant as v => `) when the variant spread is a subtype of the variant matched on. https://github.com/rescript-lang/rescript-compiler/pull/6721
 - Fix the issue where dynamic imports are not working for function-defined externals. https://github.com/rescript-lang/rescript-compiler/pull/7060 
+- Allow pattern matching on dicts. `switch someDict { | dict{"one": 1} => Js.log("one is one") }` https://github.com/rescript-lang/rescript-compiler/pull/7059
 
 #### :bug: Bug fix
 

jscomp/build_tests/super_errors/expected/dict_coercion.res.expected

@@ -0,0 +1,10 @@
+
+  We've found a bug for you!
+  /.../fixtures/dict_coercion.res:7:10-30
+
+  5 │ type fakeDict<'t> = {dictValuesType?: 't}
+  6 │ 
+  7 │ let d = (dict :> fakeDict<int>)
+  8 │ 
+
+  Type Js.Dict.t<int> = dict<int> is not a subtype of fakeDict<int>

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/expected/dict_pattern_inference.res.expected

@@ -0,0 +1,12 @@
+
+  We've found a bug for you!
+  /.../fixtures/dict_pattern_inference.res:3:27-33
+
+  1 │ let foo = dict =>
+  2 │   switch dict {
+  3 │   | dict{"one": 1, "two": "hello"} => Js.log("one")
+  4 │   | _ => Js.log("not one")
+  5 │   }
+
+  This pattern matches values of type string
+  but a pattern was expected which matches values of type int

jscomp/build_tests/super_errors/expected/dict_pattern_inference_constrained.res.expected

@@ -0,0 +1,17 @@
+
+  We've found a bug for you!
+  /.../fixtures/dict_pattern_inference_constrained.res:4:27-30
+
+  2 ┆ switch dict {
+  3 ┆ | dict{"one": 1} =>
+  4 ┆   let _: dict<string> = dict
+  5 ┆   Js.log("one")
+  6 ┆ | _ => Js.log("not one")
+
+  This has type: dict<int>
+  But it's expected to have type: dict<string>
+  
+  The incompatible parts:
+    int vs string
+  
+  You can convert int to string with Belt.Int.toString.

jscomp/build_tests/super_errors/expected/dict_pattern_regular_record.res.expected

@@ -0,0 +1,12 @@
+
+  We've found a bug for you!
+  /.../fixtures/dict_pattern_regular_record.res:5:5-22
+
+  3 │ let constrainedAsDict = (dict: x) =>
+  4 │   switch dict {
+  5 │   | dict{"one": "one"} => Js.log("one")
+  6 │   | _ => Js.log("not one")
+  7 │   }
+
+  This pattern matches values of type dict<string>
+  but a pattern was expected which matches values of type x

jscomp/build_tests/super_errors/expected/dict_record_style_field_access.res.expected

@@ -0,0 +1,9 @@
+
+  We've found a bug for you!
+  /.../fixtures/dict_record_style_field_access.res:5:20-23
+
+  3 │ }
+  4 │ 
+  5 │ let x = stringDict.name
+
+  Direct field access on a dict is not supported. Use Dict.get instead.

jscomp/build_tests/super_errors/fixtures/dict_coercion.res

@@ -0,0 +1,7 @@
+let dict = Js.Dict.empty()
+dict->Js.Dict.set("someKey1", 1)
+dict->Js.Dict.set("someKey2", 2)
+
+type fakeDict<'t> = {dictValuesType?: 't}
+
+let d = (dict :> fakeDict<int>)

jscomp/build_tests/super_errors/fixtures/dict_magic_field_on_non_dict.res

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

jscomp/build_tests/super_errors/fixtures/dict_pattern_inference.res

@@ -0,0 +1,5 @@
+let foo = dict =>
+  switch dict {
+  | dict{"one": 1, "two": "hello"} => Js.log("one")
+  | _ => Js.log("not one")
+  }