Merge pull request swiftlang#79374 from rintaro/astgen-objectliteralexpr

[ASTGen] Generate ObjectLiteralExpr

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -1774,6 +1774,21 @@ BridgedNilLiteralExpr
 BridgedNilLiteralExpr_createParsed(BridgedASTContext cContext,
                                    BridgedSourceLoc cNilKeywordLoc);
 
+enum ENUM_EXTENSIBILITY_ATTR(open) BridgedObjectLiteralKind : size_t {
+#define POUND_OBJECT_LITERAL(Name, Desc, Proto) BridgedObjectLiteralKind_##Name,
+#include "swift/AST/TokenKinds.def"
+  BridgedObjectLiteralKind_none,
+};
+
+SWIFT_NAME("BridgedObjectLiteralKind.init(from:)")
+BridgedObjectLiteralKind
+BridgedObjectLiteralKind_fromString(BridgedStringRef cStr);
+
+SWIFT_NAME("BridgedObjectLiteralExpr.createParsed(_:poundLoc:kind:args:)")
+BridgedObjectLiteralExpr BridgedObjectLiteralExpr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cPoundLoc,
+    BridgedObjectLiteralKind cKind, BridgedArgumentList args);
+
 SWIFT_NAME("BridgedOptionalTryExpr.createParsed(_:tryLoc:subExpr:questionLoc:)")
 BridgedOptionalTryExpr BridgedOptionalTryExpr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr,

lib/AST/Bridging/ExprBridging.cpp

@@ -403,6 +403,7 @@ unbridge(BridgedMagicIdentifierLiteralKind cKind) {
   case BridgedMagicIdentifierLiteralKindNone:
     return std::nullopt;
   }
+  llvm_unreachable("unhandled enum value");
 }
 
 BridgedMagicIdentifierLiteralExpr
@@ -419,6 +420,38 @@ BridgedNilLiteralExpr_createParsed(BridgedASTContext cContext,
   return new (cContext.unbridged()) NilLiteralExpr(cNilKeywordLoc.unbridged());
 }
 
+SWIFT_NAME("BridgedObjectLiteralKind.init(from:)")
+BridgedObjectLiteralKind
+BridgedObjectLiteralKind_fromString(BridgedStringRef cStr) {
+  return llvm::StringSwitch<BridgedObjectLiteralKind>(cStr.unbridged())
+#define POUND_OBJECT_LITERAL(Name, Desc, Proto)                                \
+  .Case(#Name, BridgedObjectLiteralKind_##Name)
+#include "swift/AST/TokenKinds.def"
+      .Default(BridgedObjectLiteralKind_none);
+}
+
+static std::optional<ObjectLiteralExpr::LiteralKind>
+unbridge(BridgedObjectLiteralKind kind) {
+  switch (kind) {
+#define POUND_OBJECT_LITERAL(Name, Desc, Proto)                                \
+  case BridgedObjectLiteralKind_##Name:                                        \
+    return ObjectLiteralExpr::LiteralKind::Name;
+#include "swift/AST/TokenKinds.def"
+  case BridgedObjectLiteralKind_none:
+    return std::nullopt;
+  }
+  llvm_unreachable("unhandled enum value");
+}
+
+SWIFT_NAME("BridgedObjectLiteralExpr.createParsed(_:poundLoc:kind:args:)")
+BridgedObjectLiteralExpr BridgedObjectLiteralExpr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cPoundLoc,
+    BridgedObjectLiteralKind cKind, BridgedArgumentList cArgs) {
+  return ObjectLiteralExpr::create(cContext.unbridged(), cPoundLoc.unbridged(),
+                                   *unbridge(cKind), cArgs.unbridged(),
+                                   /*implicit=*/false);
+}
+
 BridgedOptionalTryExpr BridgedOptionalTryExpr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr,
     BridgedSourceLoc cQuestionLoc) {

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -797,6 +797,44 @@ extension ASTGenVisitor {
     )
   }
 
+  func generateMagicIdentifierExpr(macroExpansionExpr node: MacroExpansionExprSyntax, kind: BridgedMagicIdentifierLiteralKind) -> BridgedMagicIdentifierLiteralExpr {
+    guard node.lastToken(viewMode: .sourceAccurate) == node.macroName else {
+      // TODO: Diagnose.
+      fatalError("magic identifier token with arguments")
+    }
+
+    return BridgedMagicIdentifierLiteralExpr.createParsed(
+      self.ctx,
+      kind: kind,
+      loc: self.generateSourceLoc(node.macroName)
+    )
+
+  }
+
+  func generateObjectLiteralExpr(macroExpansionExpr node: MacroExpansionExprSyntax, kind: BridgedObjectLiteralKind) -> BridgedObjectLiteralExpr {
+    guard
+      node.genericArgumentClause == nil,
+      node.trailingClosure == nil,
+      node.additionalTrailingClosures.isEmpty
+    else {
+      // TODO: Diagnose.
+      fatalError("object identifier with generic specialization")
+    }
+
+    return BridgedObjectLiteralExpr.createParsed(
+      self.ctx,
+      poundLoc: self.generateSourceLoc(node.pound),
+      kind: kind,
+      args: self.generateArgumentList(
+        leftParen: node.leftParen,
+        labeledExprList: node.arguments,
+        rightParen: node.rightParen,
+        trailingClosure: nil,
+        additionalTrailingClosures: nil
+      )
+    )
+  }
+
   func generateObjCSelectorExpr(macroExpansionExpr node: MacroExpansionExprSyntax) -> BridgedObjCSelectorExpr {
     fatalError("unimplemented")
   }
@@ -806,27 +844,35 @@ extension ASTGenVisitor {
   }
 
   func generate(macroExpansionExpr node: MacroExpansionExprSyntax) -> BridgedExpr {
+    let macroNameText = node.macroName.rawText;
+
     // '#file', '#line' etc.
-    let magicIdentifierKind = BridgedMagicIdentifierLiteralKind(from: node.macroName.rawText.bridged)
+    let magicIdentifierKind = BridgedMagicIdentifierLiteralKind(from: macroNameText.bridged)
     if magicIdentifierKind != .none {
-      guard node.lastToken(viewMode: .sourceAccurate) == node.macroName else {
-        // TODO: Diagnose
-        fatalError("magic identifier token with arguments")
-      }
+      return self.generateMagicIdentifierExpr(
+        macroExpansionExpr: node,
+        kind: magicIdentifierKind
+      ).asExpr
+    }
 
-      return BridgedMagicIdentifierLiteralExpr.createParsed(
-        self.ctx,
-        kind: magicIdentifierKind,
-        loc: self.generateSourceLoc(node.macroName)
+    // '#colorLiteral' et al.
+    let objectLiteralKind = BridgedObjectLiteralKind(from: macroNameText.bridged)
+    if objectLiteralKind != .none {
+      return self.generateObjectLiteralExpr(
+        macroExpansionExpr: node,
+        kind: objectLiteralKind
       ).asExpr
     }
 
     // Other built-in pound expressions.
-    switch node.macroName.rawText {
+    switch macroNameText {
     case "selector":
       return self.generateObjCSelectorExpr(macroExpansionExpr: node).asExpr
     case "keyPath":  
       return self.generateObjCKeyPathExpr(macroExpansionExpr: node).asExpr
+    case "assert" where ctx.langOptsHasFeature(.StaticAssert), "error", "warning":
+      // TODO: Diagnose.
+      fatalError("Directives in expression position");
     default:
       // Fallback to MacroExpansionExpr.
       break

test/ASTGen/object_literals.swift

@@ -0,0 +1,34 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature ParserASTGen
+// REQUIRES: OS=macosx
+// REQUIRES: swift_swift_parser
+// REQUIRES: swift_feature_ParserASTGen
+
+struct S: _ExpressibleByColorLiteral {
+  init(_colorLiteralRed: Float, green: Float, blue: Float, alpha: Float) {}
+}
+
+let y: S = #colorLiteral(red: 1, green: 0, blue: 0, alpha: 1)
+let y2 = #colorLiteral(red: 1, green: 0, blue: 0, alpha: 1) // expected-error{{could not infer type of color literal}}
+// expected-note@-1{{import AppKit to use 'NSColor' as the default color literal type}}
+let y3 = #colorLiteral(red: 1, bleen: 0, grue: 0, alpha: 1)
+// expected-error@-1 {{could not infer type of color literal}}
+// expected-note@-2 {{import AppKit to use 'NSColor' as the default color literal type}}
+
+let _: S = #colorLiteral(red: 1, bleen: 0, grue: 0, alpha: 1)
+// expected-error@-1{{incorrect argument labels in call (have 'red:bleen:grue:alpha:', expected 'red:green:blue:alpha:')}} {{34-39=green}} {{44-48=blue}}
+
+struct I: _ExpressibleByImageLiteral {
+  init(imageLiteralResourceName: String) {}
+}
+
+let z: I = #imageLiteral(resourceName: "hello.png")
+let z2 = #imageLiteral(resourceName: "hello.png") // expected-error{{could not infer type of image literal}}
+// expected-note@-1{{import AppKit to use 'NSImage' as the default image literal type}}
+
+struct Path: _ExpressibleByFileReferenceLiteral {
+  init(fileReferenceLiteralResourceName: String) {}
+}
+
+let p1: Path = #fileLiteral(resourceName: "what.txt")
+let p2 = #fileLiteral(resourceName: "what.txt") // expected-error{{could not infer type of file reference literal}}
+// expected-note@-1{{import Foundation to use 'URL' as the default file reference literal type}}