Tree-sitter grammar: support Dicts

backend/testfiles/execution/stdlib/parser.dark

@@ -212,10 +212,14 @@ module TextToTextRoundtripping =
     ("type MyFloat = Float" |> roundtripCliScript) = "type MyFloat =\n  Float"
     ("type MyChar = Char" |> roundtripCliScript) = "type MyChar =\n  Char"
     ("type MyString = String" |> roundtripCliScript) = "type MyString =\n  String"
+
     ("type MyList = List<String>" |> roundtripCliScript) = "type MyList =\n  List<String>"
     ("type MyList = List<List<String>>" |> roundtripCliScript) = "type MyList =\n  List<List<String>>"
     ("type MyList = List<MyString>" |> roundtripCliScript) = "type MyList =\n  List<MyString>"
 
+    ("type MyDict = Dict<Int64>" |> roundtripCliScript) = "type MyDict =\n  Dict<Int64>"
+    ("type MyDict = Dict<MyList>" |> roundtripCliScript) = "type MyDict =\n  Dict<MyList>"
+
     ("type MyTuple2 = (String * Int64)" |> roundtripCliScript) = "type MyTuple2 =\n  (String * Int64)"
     ("type MyTuple3 = (String * Int64 * Bool)" |> roundtripCliScript) = "type MyTuple3 =\n  (String * Int64 * Bool)"
     ("type MyTuple = (String * Int64 * Bool * Unit)" |> roundtripCliScript) = "type MyTuple =\n  (String * Int64 * Bool * Unit)"
@@ -282,6 +286,13 @@ module TextToTextRoundtripping =
     ("[1L; 2L; 3L;]" |> roundtripCliScript) = "[1L; 2L; 3L]"
     ("[true; false; true; false]" |> roundtripCliScript) = "[true; false; true; false]"
     ("[[1L; 2L]; [3L; 4L]]" |> roundtripCliScript) = "[[1L; 2L]; [3L; 4L]]"
+
+    // dict literal
+    ("Dict { }" |> roundtripCliScript) = "Dict {  }"
+    ("Dict { a = 1L }" |> roundtripCliScript) = "Dict { a = 1L }"
+    ("Dict { a = \"hello\"; b = \"test\" }" |> roundtripCliScript) = "Dict { a = \"hello\"; b = \"test\" }"
+    ("Dict { a = 1L; b = 2L; c = 3L }" |> roundtripCliScript) = "Dict { a = 1L; b = 2L; c = 3L }"
+
     // tuple literals
     ("(1L, \"hello\")" |> roundtripCliScript) = "(1L, \"hello\")"
     ("(1L, \"hello\", 2L)" |> roundtripCliScript) = "(1L, \"hello\", 2L)"

packages/darklang/languageTools/semanticTokens.dark

@@ -126,6 +126,14 @@ module Darklang =
                   (TypeReference.tokenize t)
                   [ makeToken rc TokenType.Symbol ] ]
               )
+            | TDict(r, rk, ro, t, rc) ->
+              Stdlib.List.flatten (
+                [ [ makeToken r TokenType.TypeName ]
+                  [ makeToken rk TokenType.Keyword ]
+                  [ makeToken ro TokenType.Symbol ]
+                  (TypeReference.tokenize t)
+                  [ makeToken rc TokenType.Symbol ] ]
+              )
             | TTuple(r, first, ra, second, rest, ro, rc) ->
               [ [ makeToken r TokenType.Symbol ]
                 // (
@@ -285,6 +293,26 @@ module Darklang =
               [ makeToken symbolRightBracket TokenType.Symbol ] ]
             |> Stdlib.List.flatten
 
+          | EDict(range,
+                  contentsMaybe,
+                  keywordDict,
+                  symbolOpenBrace,
+                  symbolCloseBrace) ->
+            let contents =
+              contentsMaybe
+              |> Stdlib.List.map (fun (_, key, value) -> Expr.tokenize value)
+              |> Stdlib.List.flatten
+
+            [ // Dict
+              [ makeToken keywordDict TokenType.Keyword ]
+              // {
+              [ makeToken symbolOpenBrace TokenType.Symbol ]
+              // a = 1 ; b = 2 ; c = 3
+              contents
+              // }
+              [ makeToken symbolCloseBrace TokenType.Symbol ] ]
+            |> Stdlib.List.flatten
+
           // (1, 2, 3)
           | ETuple(range,
                    first,

packages/darklang/languageTools/writtenTypes.dark

@@ -59,6 +59,13 @@ module Darklang =
             typ: TypeReference.TypeReference *
             closeBracket: SourceRange
 
+          | TDict of
+            SourceRange *
+            keywordDict: SourceRange *
+            openBrace: SourceRange *
+            typ: TypeReference.TypeReference *
+            closeBrace: SourceRange
+
           | TTuple of
             SourceRange *
             first: TypeReference *
@@ -177,6 +184,13 @@ module Darklang =
           symbolOpenBracket: SourceRange *
           symbolCloseBracket: SourceRange
 
+        | EDict of
+          SourceRange *
+          contents: List<SourceRange * String * Expr> *
+          keywordDict: SourceRange *
+          symbolOpenBrace: SourceRange *
+          symbolCloseBrace: SourceRange
+
         | ETuple of
           SourceRange *
           first: Expr *

packages/darklang/languageTools/writtenTypesToProgramTypes.dark

@@ -82,6 +82,11 @@ module Darklang =
               let typ = TypeReference.toPT resolver typ
               ProgramTypes.TypeReference.TList(typ)
 
+            | TDict(_range, _, _, valueType, _) ->
+              let valueType = TypeReference.toPT resolver valueType
+
+              ProgramTypes.TypeReference.TDict valueType
+
             | TTuple(_range, firstType, _, secondType, restTypes, _, _) ->
               let firstType = TypeReference.toPT resolver firstType
               let secondType = TypeReference.toPT resolver secondType
@@ -231,6 +236,12 @@ module Darklang =
               Stdlib.List.map contents (fun (expr, _) -> toPT resolver expr)
             )
 
+          | EDict(_, contents, _, _, _) ->
+            ProgramTypes.Expr.EDict(
+              gid (),
+              Stdlib.List.map contents (fun (_, k, v) -> (k, toPT resolver v))
+            )
+
           | ETuple(_, first, _, second, rest, _, _) ->
             let first = toPT resolver first
             let second = toPT resolver second

packages/darklang/prettyPrinter/programTypes.dark

@@ -679,7 +679,7 @@ module Darklang =
             |> Stdlib.String.join "; "
             |> fun parts -> "{ " ++ parts ++ " }"
 
-          $"(Dict {pairPart})"
+          $"Dict {pairPart}"
 
 
         | ETuple(_id, first, second, theRest) ->

tree-sitter-darklang/grammar.js

@@ -85,6 +85,7 @@ module.exports = grammar({
         $.char_literal,
         $.list_literal,
         $.tuple_literal,
+        $.dict_literal,
 
         $.let_expression,
         $.variable_identifier,
@@ -311,6 +312,29 @@ module.exports = grammar({
         optional(alias(";", $.symbol)),
       ),
 
+    //
+    // Dict
+    dict_literal: $ =>
+      seq(
+        field("keyword_dict", alias("Dict", $.keyword)),
+        field("symbol_open_brace", alias("{", $.symbol)),
+        field("content", optional($.dict_content)),
+        field("symbol_close_brace", alias("}", $.symbol)),
+      ),
+
+    dict_content: $ =>
+      seq(
+        $.dict_pair,
+        repeat(seq(field("dict_separator", alias(";", $.symbol)), $.dict_pair)),
+      ),
+
+    dict_pair: $ =>
+      seq(
+        field("key", $.expression),
+        field("symbol_equals", alias("=", $.symbol)),
+        field("value", $.expression),
+      ),
+
     //
     // Tuples
     tuple_literal: $ =>
@@ -354,6 +378,7 @@ module.exports = grammar({
         /String/,
         $.list_type_reference,
         $.tuple_type_reference,
+        $.dict_type_reference,
         /DateTime/,
         /Uuid/,
       ),
@@ -388,6 +413,16 @@ module.exports = grammar({
         ),
       ),
 
+    //
+    // Dict<T>
+    dict_type_reference: $ =>
+      seq(
+        field("keyword_type_constructor", alias("Dict", $.keyword)),
+        field("symbol_open_angle", alias("<", $.symbol)),
+        field("value_type", $.type_reference),
+        field("symbol_close_angle", alias(">", $.symbol)),
+      ),
+
     //
     // Identifiers
     qualified_fn_name: $ =>