Handle dict literal syntax

Closes #6545

Author: bloodyowl

jscomp/others/belt_HashSetInt.resi

@@ -23,12 +23,12 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
 /***
-This module is [`Belt.HashSet`]() specialized with key type to be a primitive type.
+  This module is [`Belt.HashSet`]() specialized with key type to be a primitive type.
 
-It is more efficient in general, the  API is the same with [`Belt.HashSet`]() except its key type is fixed,
-and identity is not needed(using the built-in one)
+  It is more efficient in general, the  API is the same with [`Belt.HashSet`]() except its key type is fixed,
+  and identity is not needed(using the built-in one)
 
-**See** [`Belt.HashSet`]()
+  **See** [`Belt.HashSet`]()
 */
 
 type key = int

jscomp/others/belt_HashSetString.resi

@@ -23,12 +23,12 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
 /***
-This module is [`Belt.HashSet`]() specialized with key type to be a primitive type.
+  This module is [`Belt.HashSet`]() specialized with key type to be a primitive type.
 
-It is more efficient in general, the  API is the same with [`Belt.HashSet`]() except its key type is fixed,
-and identity is not needed(using the built-in one)
+  It is more efficient in general, the  API is the same with [`Belt.HashSet`]() except its key type is fixed,
+  and identity is not needed(using the built-in one)
 
-**See** [`Belt.HashSet`]()
+  **See** [`Belt.HashSet`]()
 */
 
 type key = string

jscomp/syntax/src/res_core.ml

@@ -229,6 +229,7 @@ let getClosingToken = function
   | Lbrace -> Rbrace
   | Lbracket -> Rbracket
   | List -> Rbrace
+  | Dict -> Rbrace
   | LessThan -> GreaterThan
   | _ -> assert false
 
@@ -240,7 +241,7 @@ let rec goToClosing closingToken state =
   | GreaterThan, GreaterThan ->
     Parser.next state;
     ()
-  | ((Token.Lbracket | Lparen | Lbrace | List | LessThan) as t), _ ->
+  | ((Token.Lbracket | Lparen | Lbrace | List | Dict | LessThan) as t), _ ->
     Parser.next state;
     goToClosing (getClosingToken t) state;
     goToClosing closingToken state
@@ -1918,6 +1919,9 @@ and parseAtomicExpr p =
     | List ->
       Parser.next p;
       parseListExpr ~startPos p
+    | Dict ->
+      Parser.next p;
+      parseDictExpr ~startPos p
     | Module ->
       Parser.next p;
       parseFirstClassModuleExpr ~startPos p
@@ -3130,6 +3134,20 @@ and parseRecordExprRow p =
     | _ -> None)
   | _ -> None
 
+and parseDictExprRow p =
+  match p.Parser.token with
+  | String s -> (
+    let loc = mkLoc p.startPos p.endPos in
+    Parser.next p;
+    let field = Location.mkloc (Longident.Lident s) loc in
+    match p.Parser.token with
+    | Colon ->
+      Parser.next p;
+      let fieldExpr = parseExpr p in
+      Some (field, fieldExpr)
+    | _ -> Some (field, Ast_helper.Exp.ident ~loc:field.loc field))
+  | _ -> None
+
 and parseRecordExprWithStringKeys ~startPos firstRow p =
   let rows =
     firstRow
@@ -3923,6 +3941,30 @@ and parseListExpr ~startPos p =
             loc))
       [(Asttypes.Nolabel, Ast_helper.Exp.array ~loc listExprs)]
 
+and parseDictExpr ~startPos p =
+  let exprs =
+    parseCommaDelimitedRegion ~grammar:Grammar.DictRows ~closing:Rbrace
+      ~f:parseDictExprRow p
+  in
+  let loc = mkLoc startPos p.prevEndPos in
+  let toKeyValuePair recordItem =
+    match recordItem with
+    | {Location.txt = Longident.Lident key}, valueExpr ->
+      Some
+        (Ast_helper.Exp.tuple ~loc
+           [Ast_helper.Exp.constant ~loc (Pconst_string (key, None)); valueExpr])
+    | _ -> None
+  in
+  let keyValuePairs = List.filter_map toKeyValuePair exprs in
+  Parser.expect Rbrace p;
+  Ast_helper.Exp.apply ~loc
+    (Ast_helper.Exp.ident ~loc
+       (Location.mkloc
+          (Longident.Ldot
+             (Longident.Ldot (Longident.Lident "Js", "Dict"), "fromArray"))
+          loc))
+    [(Asttypes.Nolabel, Ast_helper.Exp.array ~loc keyValuePairs)]
+
 and parseArrayExp p =
   let startPos = p.Parser.startPos in
   Parser.expect Lbracket p;

jscomp/syntax/src/res_grammar.ml

@@ -59,6 +59,7 @@ type t =
   | Pattern
   | AttributePayload
   | TagNames
+  | DictRows
 
 let toString = function
   | OpenDescription -> "an open description"
@@ -120,6 +121,7 @@ let toString = function
   | ExprFor -> "a for expression"
   | AttributePayload -> "an attribute payload"
   | TagNames -> "tag names"
+  | DictRows -> "rows of a dict"
 
 let isSignatureItemStart = function
   | Token.At | Let | Typ | External | Exception | Open | Include | Module | AtAt
@@ -219,6 +221,10 @@ let isModExprStart = function
     true
   | _ -> false
 
+let isDictRowStart = function
+  | Token.String _ -> true
+  | _ -> false
+
 let isRecordRowStart = function
   | Token.DotDotDot -> true
   | Token.Uident _ | Lident _ -> true
@@ -278,6 +284,7 @@ let isListElement grammar token =
   | FunctorArgs -> isFunctorArgStart token
   | ModExprList -> isModExprStart token
   | TypeParameters -> isTypeParameterStart token
+  | DictRows -> isDictRowStart token
   | RecordRows -> isRecordRowStart token
   | RecordRowsStringKey -> isRecordRowStringKeyStart token
   | ArgumentList -> isArgumentStart token

jscomp/syntax/src/res_printer.ml

@@ -427,6 +427,16 @@ let isValidNumericPolyvarNumber (x : string) =
          | _ -> false)
   else a >= 48
 
+let isTupleArray (expr : Parsetree.expression) =
+  let isPlainTuple (expr : Parsetree.expression) =
+    match expr with
+    | {pexp_desc = Pexp_tuple _} -> true
+    | _ -> false
+  in
+  match expr with
+  | {pexp_desc = Pexp_array items} -> List.for_all isPlainTuple items
+  | _ -> false
+
 (* Exotic identifiers in poly-vars have a "lighter" syntax: #"ease-in" *)
 let printPolyVarIdent txt =
   (* numeric poly-vars don't need quotes: #644 *)
@@ -1377,6 +1387,45 @@ and printRecordDeclaration ~state (lds : Parsetree.label_declaration list)
          Doc.rbrace;
        ])
 
+and printLiteralDictExpr ~state (e : Parsetree.expression) cmtTbl =
+  let forceBreak =
+    e.pexp_loc.loc_start.pos_lnum < e.pexp_loc.loc_end.pos_lnum
+  in
+  let tupleToRow (e : Parsetree.expression) =
+    match e with
+    | {
+     pexp_desc =
+       Pexp_tuple
+         [
+           {pexp_desc = Pexp_constant (Pconst_string (name, _)); pexp_loc}; value;
+         ];
+    } ->
+      Some (Location.mkloc (Longident.Lident name) pexp_loc, value)
+    | _ -> None
+  in
+  let rows =
+    match e with
+    | {pexp_desc = Pexp_array expressions} ->
+      List.filter_map tupleToRow expressions
+    | _ -> []
+  in
+  Doc.breakableGroup ~forceBreak
+    (Doc.concat
+       [
+         Doc.indent
+           (Doc.concat
+              [
+                Doc.softLine;
+                Doc.join
+                  ~sep:(Doc.concat [Doc.text ","; Doc.line])
+                  (List.map
+                     (fun row -> printBsObjectRow ~state row cmtTbl)
+                     rows);
+              ]);
+         Doc.trailingComma;
+         Doc.softLine;
+       ])
+
 and printConstructorDeclarations ~state ~privateFlag
     (cds : Parsetree.constructor_declaration list) cmtTbl =
   let forceBreak =
@@ -3956,6 +4005,24 @@ and printPexpApply ~state expr cmtTbl =
     | [] -> doc
     | attrs -> Doc.group (Doc.concat [printAttributes ~state attrs cmtTbl; doc])
     )
+  | Pexp_apply
+      ( {
+          pexp_desc =
+            Pexp_ident
+              {
+                txt =
+                  Longident.Ldot
+                    (Longident.Ldot (Lident "Js", "Dict"), "fromArray");
+              };
+        },
+        [(Nolabel, keyValues)] )
+    when isTupleArray keyValues ->
+    Doc.concat
+      [
+        Doc.text "dict{";
+        printLiteralDictExpr ~state keyValues cmtTbl;
+        Doc.rbrace;
+      ]
   | Pexp_apply
       ( {pexp_desc = Pexp_ident {txt = Longident.Ldot (Lident "Array", "get")}},
         [(Nolabel, parentExpr); (Nolabel, memberExpr)] )

jscomp/syntax/src/res_scanner.ml

@@ -195,11 +195,16 @@ let scanIdentifier scanner =
   let str =
     (String.sub [@doesNotRaise]) scanner.src startOff (scanner.offset - startOff)
   in
-  if '{' == scanner.ch && str = "list" then (
+  match (scanner, str) with
+  | {ch = '{'}, "list" ->
     next scanner;
     (* TODO: this isn't great *)
-    Token.lookupKeyword "list{")
-  else Token.lookupKeyword str
+    Token.lookupKeyword "list{"
+  | {ch = '{'}, "dict" ->
+    next scanner;
+    (* TODO: this isn't great *)
+    Token.lookupKeyword "dict{"
+  | _ -> Token.lookupKeyword str
 
 let scanDigits scanner ~base =
   if base <= 10 then

jscomp/syntax/src/res_token.ml

@@ -88,6 +88,7 @@ type t =
   | PercentPercent
   | Comment of Comment.t
   | List
+  | Dict
   | TemplateTail of string * Lexing.position
   | TemplatePart of string * Lexing.position
   | Backtick
@@ -198,6 +199,7 @@ let toString = function
   | PercentPercent -> "%%"
   | Comment c -> "Comment" ^ Comment.toString c
   | List -> "list{"
+  | Dict -> "dict{"
   | TemplatePart (text, _) -> text ^ "${"
   | TemplateTail (text, _) -> "TemplateTail(" ^ text ^ ")"
   | Backtick -> "`"
@@ -222,6 +224,7 @@ let keywordTable = function
   | "include" -> Include
   | "let" -> Let
   | "list{" -> List
+  | "dict{" -> Dict
   | "module" -> Module
   | "mutable" -> Mutable
   | "of" -> Of
@@ -240,7 +243,7 @@ let keywordTable = function
 let isKeyword = function
   | Await | And | As | Assert | Constraint | Else | Exception | External | False
   | For | If | In | Include | Land | Let | List | Lor | Module | Mutable | Of
-  | Open | Private | Rec | Switch | True | Try | Typ | When | While ->
+  | Open | Private | Rec | Switch | True | Try | Typ | When | While | Dict ->
     true
   | _ -> false
 

jscomp/syntax/tests/parsing/grammar/expressions/dict.res

@@ -0,0 +1,11 @@
+// empty dict
+let x = dict{}
+
+// one value
+let x = dict{"foo": "bar"}
+
+// two values
+let x = dict{"foo": "bar", "bar": "baz"}
+
+let baz = "foo"
+let x = dict{"foo": "bar", "bar": "baz", "baz": baz}

jscomp/syntax/tests/parsing/grammar/expressions/expected/dict.res.txt

@@ -0,0 +1,7 @@
+let x = Js.Dict.fromArray [||]
+let x = Js.Dict.fromArray [|("foo", {js|bar|js})|]
+let x = Js.Dict.fromArray [|("foo", {js|bar|js});("bar", {js|baz|js})|]
+let baz = {js|foo|js}
+let x =
+  Js.Dict.fromArray
+    [|("foo", {js|bar|js});("bar", {js|baz|js});("baz", baz)|]

jscomp/syntax/tests/printer/expr/dict.res

@@ -0,0 +1,27 @@
+// empty dict
+let x = dict{}
+
+// one value
+let x = dict{"foo": "bar"}
+
+// two values
+let x = dict{"foo": "bar", "bar": "baz"}
+
+let baz = "foo"
+let x = dict{"foo": "bar", "bar": "baz", "baz": baz}
+
+// multiline
+let x = dict{
+	"foo": "bar",
+	"bar": "baz",
+	"baz": baz
+}
+
+let x = Js.Dict.fromArray([("foo", "bar"), ("bar", "baz")])
+let x = Js.Dict.fromArray([("foo", "bar"), ("bar", "baz"), ("baz", baz)])
+
+let x = Js.Dict.fromArray([
+	("foo", "bar"),
+	("bar", "baz"),
+	("baz", baz)
+])

jscomp/syntax/tests/printer/expr/expected/dict.res.txt

@@ -0,0 +1,28 @@
+// empty dict
+let x = dict{}
+
+// one value
+let x = dict{"foo": "bar"}
+
+// two values
+let x = dict{"foo": "bar", "bar": "baz"}
+
+// punning
+let baz = "foo"
+let x = dict{"foo": "bar", "bar": "baz", "baz": baz}
+
+// multiline
+let x = dict{
+  "foo": "bar",
+  "bar": "baz",
+  "baz": baz,
+}
+
+let x = dict{"foo": "bar", "bar": "baz"}
+let x = dict{"foo": "bar", "bar": "baz", "baz": baz}
+
+let x = dict{
+  "foo": "bar",
+  "bar": "baz",
+  "baz": baz,
+}