[ASTGen] Implement dictionary literal expression generation

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -661,12 +661,6 @@ BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext,
                                              BridgedExpr fn,
                                              BridgedTupleExpr args);
 
-SWIFT_NAME("BridgedDotSelfExpr.createParsed(_:subExpr:dotLoc:selfLoc:)")
-BridgedDotSelfExpr BridgedDotSelfExpr_createParsed(BridgedASTContext cContext,
-                                                   BridgedExpr cSubExpr,
-                                                   BridgedSourceLoc cDotLoc,
-                                                   BridgedSourceLoc cSelfLoc);
-
 SWIFT_NAME("BridgedClosureExpr.createParsed(_:declContext:body:)")
 BridgedClosureExpr
 BridgedClosureExpr_createParsed(BridgedASTContext cContext,
@@ -691,6 +685,19 @@ BridgedDiscardAssignmentExpr
 BridgedDiscardAssignmentExpr_createParsed(BridgedASTContext cContext,
                                           BridgedSourceLoc cLoc);
 
+SWIFT_NAME("BridgedDictionaryExpr.createParsed(_:lBracketLoc:elements:"
+           "colonLocs:rBracketLoc:)")
+BridgedDictionaryExpr BridgedDictionaryExpr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cLBracketLoc,
+    BridgedArrayRef cElements, BridgedArrayRef cCommaLocs,
+    BridgedSourceLoc cRBracketLoc);
+
+SWIFT_NAME("BridgedDotSelfExpr.createParsed(_:subExpr:dotLoc:selfLoc:)")
+BridgedDotSelfExpr BridgedDotSelfExpr_createParsed(BridgedASTContext cContext,
+                                                   BridgedExpr cSubExpr,
+                                                   BridgedSourceLoc cDotLoc,
+                                                   BridgedSourceLoc cSelfLoc);
+
 SWIFT_NAME(
     "BridgedForcedCheckedCastExpr.createParsed(_:asLoc:exclaimLoc:type:)")
 BridgedForcedCheckedCastExpr BridgedForcedCheckedCastExpr_createParsed(
@@ -729,6 +736,10 @@ BridgedTupleExpr BridgedTupleExpr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cLParen, BridgedArrayRef subs,
     BridgedArrayRef names, BridgedArrayRef cNameLocs, BridgedSourceLoc cRParen);
 
+SWIFT_NAME("BridgedTupleExpr.createParsedDictionaryElement(_:key:value:)")
+BridgedTupleExpr BridgedTupleExpr_createParsedDictionaryElement(
+    BridgedASTContext cContext, BridgedExpr cKeyExpr, BridgedExpr cValueExpr);
+
 SWIFT_NAME("BridgedIntegerLiteralExpr.createParsed(_:value:loc:)")
 BridgedIntegerLiteralExpr
 BridgedIntegerLiteralExpr_createParsed(BridgedASTContext cContext,

lib/AST/ASTBridging.cpp

@@ -917,6 +917,16 @@ BridgedDiscardAssignmentExpr_createParsed(BridgedASTContext cContext,
       DiscardAssignmentExpr(cLoc.unbridged(), /*Implicit=*/false);
 }
 
+BridgedDictionaryExpr BridgedDictionaryExpr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cLBracketLoc,
+    BridgedArrayRef cElements, BridgedArrayRef cCommaLocs,
+    BridgedSourceLoc cRBracketLoc) {
+  return DictionaryExpr::create(cContext.unbridged(), cLBracketLoc.unbridged(),
+                                cElements.unbridged<Expr *>(),
+                                cCommaLocs.unbridged<SourceLoc>(),
+                                cRBracketLoc.unbridged());
+}
+
 BridgedForcedCheckedCastExpr BridgedForcedCheckedCastExpr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cAsLoc,
     BridgedSourceLoc cExclaimLoc, BridgedTypeRepr cType) {
@@ -959,6 +969,12 @@ BridgedTupleExpr BridgedTupleExpr_createParsed(BridgedASTContext cContext,
       cRParen.unbridged(), /*Implicit*/ false);
 }
 
+BridgedTupleExpr BridgedTupleExpr_createParsedDictionaryElement(
+    BridgedASTContext cContext, BridgedExpr cKeyExpr, BridgedExpr cValueExpr) {
+  return TupleExpr::createImplicit(
+      cContext.unbridged(), {cKeyExpr.unbridged(), cValueExpr.unbridged()}, {});
+}
+
 BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext,
                                              BridgedExpr fn,
                                              BridgedTupleExpr args) {

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -42,10 +42,11 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
     case // Known implemented kinds.
         .arrayExpr, .arrowExpr, .assignmentExpr, .binaryOperatorExpr,
         .booleanLiteralExpr, .closureExpr, .discardAssignmentExpr,
-        .declReferenceExpr, .functionCallExpr, .ifExpr, .integerLiteralExpr,
-        .memberAccessExpr,  .nilLiteralExpr, .postfixOperatorExpr,
-        .prefixOperatorExpr, .sequenceExpr, .stringLiteralExpr, .tupleExpr,
-        .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
+        .declReferenceExpr, .dictionaryExpr, .functionCallExpr, .ifExpr,
+        .integerLiteralExpr, .memberAccessExpr,  .nilLiteralExpr,
+        .postfixOperatorExpr, .prefixOperatorExpr, .sequenceExpr,
+        .stringLiteralExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr,
+        .unresolvedIsExpr, .unresolvedTernaryExpr:
 
       // `generate(stringLiteralExpr:)` doesn't support interpolations.
       if let str = current.as(StringLiteralExprSyntax.self) {
@@ -57,15 +58,14 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
 
       break
     case // Known unimplemented kinds.
-        .asExpr, .awaitExpr,
-        .borrowExpr, .canImportExpr, .canImportVersionInfo, .dictionaryExpr,
-        .doExpr, .editorPlaceholderExpr,
-        .floatLiteralExpr, .forceUnwrapExpr, .inOutExpr, .infixOperatorExpr,
-        .isExpr, .keyPathExpr, .macroExpansionExpr, .consumeExpr, .copyExpr,
-        .optionalChainingExpr, .packElementExpr, .packExpansionExpr,
-        .postfixIfConfigExpr, .regexLiteralExpr, .genericSpecializationExpr,
-        .simpleStringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr,
-        .ternaryExpr, .tryExpr, .patternExpr:
+        .asExpr, .awaitExpr, .borrowExpr, .canImportExpr, .canImportVersionInfo,
+        .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr,
+        .inOutExpr, .infixOperatorExpr,  .isExpr, .keyPathExpr,
+        .macroExpansionExpr, .consumeExpr, .copyExpr,  .optionalChainingExpr,
+        .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr,
+        .regexLiteralExpr, .genericSpecializationExpr, .simpleStringLiteralExpr,
+        .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr,
+        .patternExpr:
       return false
     case // Unknown expr kinds.
       _ where current.is(ExprSyntax.self):
@@ -116,8 +116,8 @@ extension ASTGenVisitor {
       break
     case .declReferenceExpr(let node):
       return self.generate(declReferenceExpr: node).asExpr
-    case .dictionaryExpr:
-      break
+    case .dictionaryExpr(let node):
+      return self.generate(dictionaryExpr: node).asExpr
     case .discardAssignmentExpr(let node):
       return self.generate(discardAssignmentExpr: node).asExpr
     case .doExpr:

lib/ASTGen/Sources/ASTGen/Literals.swift

@@ -63,6 +63,41 @@ extension ASTGenVisitor {
     )
   }
 
+  private func generate(dictionaryElement node: DictionaryElementSyntax) -> BridgedTupleExpr {
+    return BridgedTupleExpr.createParsedDictionaryElement(
+      self.ctx,
+      key: self.generate(expr: node.key),
+      value: self.generate(expr: node.value)
+    )
+  }
+
+  public func generate(dictionaryExpr node: DictionaryExprSyntax) -> BridgedDictionaryExpr {
+    let lBracketLoc = self.generateSourceLoc(node.leftSquare)
+    let rBracketLoc = self.generateSourceLoc(node.rightSquare)
+    let elements: BridgedArrayRef
+    let colonLocs: BridgedArrayRef
+
+    switch node.content {
+    case .colon(_):
+      elements = BridgedArrayRef()
+      colonLocs = BridgedArrayRef()
+    case .elements(let elementNodes):
+      elements = elementNodes.lazy
+        .map({ self.generate(dictionaryElement: $0).asExpr })
+        .bridgedArray(in: self)
+      colonLocs = elementNodes.lazy
+        .map({ self.generateSourceLoc($0.colon) })
+        .bridgedArray(in: self)
+    }
+    return .createParsed(
+      self.ctx,
+      lBracketLoc: lBracketLoc,
+      elements: elements,
+      colonLocs: colonLocs,
+      rBracketLoc: rBracketLoc
+    )
+  }
+
   func generate(nilLiteralExpr node: NilLiteralExprSyntax) -> BridgedNilLiteralExpr {
     .createParsed(
       self.ctx,

test/ASTGen/verify-parse.swift

@@ -40,10 +40,15 @@ Int {
 
   let arlit = [0]
   let tuple = (0, 1)
+  let diclit = [0: 1, 2: 3]
 
   return fn(x)
 }
 
+func testEmptyDictionary() -> [Int: Int] {
+  return [:]
+}
+
 func test2(e b: Bool) {
   if b
   {