[Parser] Stop parsing #colorLiteral, #fileLiteral, and #imageLiteral

Remove the "object literal" parsing grammar entirely, sending
`#colorLiteral`, `#fileLiteral`, and `#imageLiteral` through the normal
macro-expansion expressions. Implement `FileLiteral` and `ImageLiteral`
macros in the example macro system.

Author: DougGregor

Sources/SwiftParser/Expressions.swift

@@ -1104,11 +1104,6 @@ extension Parser {
     case (.poundKeyPathKeyword, _)?:
       return RawExprSyntax(self.parseObjectiveCKeyPathExpression())
 
-    case (.poundColorLiteralKeyword, _)?,
-         (.poundImageLiteralKeyword, _)?,
-         (.poundFileLiteralKeyword, _)?:
-      return RawExprSyntax(self.parseObjectLiteralExpression())
-
     case (.leftBrace, _)?:     // expr-closure
       return RawExprSyntax(self.parseClosureExpression())
     case (.period, let handle)?,              //=.foo
@@ -1170,32 +1165,6 @@ extension Parser {
   }
 }
 
-extension Parser {
-  /// Parse an identifier as an expression.
-  ///
-  /// Grammar
-  /// =======
-  ///
-  ///     playground-literal → '#colorLiteral' '(' red ':' expression , green ':' expression , blue ':' expression , alpha ':' expression )
-  ///     playground-literal → '#fileLiteral' '(' resourceName ':' expression ')'
-  ///     playground-literal → '#imageLiteral' '(' resourceName ':' expression ')'
-  @_spi(RawSyntax)
-  public mutating func parseObjectLiteralExpression() -> RawObjectLiteralExprSyntax {
-    let poundKeyword = self.consumeAnyToken()
-    let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-    let arguments = self.parseArgumentListElements(pattern: .none)
-    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-    return RawObjectLiteralExprSyntax(
-      identifier: poundKeyword,
-      unexpectedBeforeLeftParen,
-      leftParen: leftParen,
-      arguments: RawTupleExprElementListSyntax(elements: arguments, arena: self.arena),
-      unexpectedBeforeRightParen,
-      rightParen: rightParen,
-      arena: self.arena)
-  }
-}
-
 extension Parser {
   /// Parse a macro expansion as an expression.
   ///

Sources/SwiftParser/Lexer.swift

@@ -1553,9 +1553,6 @@ extension Lexer.Cursor {
     case "endif": kind = .poundEndifKeyword
     case "available": kind = .poundAvailableKeyword
     case "unavailable": kind = .poundUnavailableKeyword
-    case "fileLiteral": kind = .poundFileLiteralKeyword
-    case "imageLiteral": kind = .poundImageLiteralKeyword
-    case "colorLiteral": kind = .poundColorLiteralKeyword
     case "_hasSymbol": kind = .poundHasSymbolKeyword
     default:
       // If we didn't find a match, then just return `.pound`.  This is highly

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -738,12 +738,9 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
   case nilKeyword
   case period
   case pound
-  case poundColorLiteralKeyword
   case poundFileIDKeyword
   case poundFileKeyword
-  case poundFileLiteralKeyword
   case poundFilePathKeyword
-  case poundImageLiteralKeyword
   case poundKeyPathKeyword
   case poundSelectorKeyword
   case prefixPeriod
@@ -774,12 +771,9 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .nilKeyword: self = .nilKeyword
     case .period: self = .period
     case .pound: self = .pound
-    case .poundColorLiteralKeyword: self = .poundColorLiteralKeyword
     case .poundFileIDKeyword: self = .poundFileIDKeyword
     case .poundFileKeyword: self = .poundFileKeyword
-    case .poundFileLiteralKeyword: self = .poundFileLiteralKeyword
     case .poundFilePathKeyword: self = .poundFilePathKeyword
-    case .poundImageLiteralKeyword: self = .poundImageLiteralKeyword
     case .poundKeyPathKeyword: self = .poundKeyPathKeyword
     case .poundSelectorKeyword: self = .poundSelectorKeyword
     case .prefixPeriod: self = .prefixPeriod
@@ -813,12 +807,9 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .nilKeyword: return .nilKeyword
     case .period: return .period
     case .pound: return .pound
-    case .poundColorLiteralKeyword: return .poundColorLiteralKeyword
     case .poundFileIDKeyword: return .poundFileIDKeyword
     case .poundFileKeyword: return .poundFileKeyword
-    case .poundFileLiteralKeyword: return .poundFileLiteralKeyword
     case .poundFilePathKeyword: return .poundFilePathKeyword
-    case .poundImageLiteralKeyword: return .poundImageLiteralKeyword
     case .poundKeyPathKeyword: return .poundKeyPathKeyword
     case .poundSelectorKeyword: return .poundSelectorKeyword
     case .prefixPeriod: return .prefixPeriod

Sources/SwiftSyntaxMacros/MacroSystem+Examples.swift

@@ -145,7 +145,7 @@ struct FunctionMacro: ExpressionMacro {
   }
 }
 
-struct Stringify: ExpressionMacro {
+struct StringifyMacro: ExpressionMacro {
   static var name: String { "stringify" }
 
   static func apply(
@@ -160,8 +160,36 @@ struct Stringify: ExpressionMacro {
   }
 }
 
-struct ColorLiteral: ExpressionMacro {
-  static var name: String { "myColorLiteral" }
+struct ColorLiteralMacro: ExpressionMacro {
+  static var name: String { "colorLiteral" }
+
+  static func apply(
+    _ macro: MacroExpansionExprSyntax, in context: MacroEvaluationContext
+  ) -> MacroResult<ExprSyntax> {
+    let initSyntax: ExprSyntax = ".init(\(macro.argumentList))"
+    if let leadingTrivia = macro.leadingTrivia {
+      return MacroResult(initSyntax.withLeadingTrivia(leadingTrivia))
+    }
+    return MacroResult(initSyntax)
+  }
+}
+
+struct FileLiteralMacro: ExpressionMacro {
+  static var name: String { "fileLiteral" }
+
+  static func apply(
+    _ macro: MacroExpansionExprSyntax, in context: MacroEvaluationContext
+  ) -> MacroResult<ExprSyntax> {
+    let initSyntax: ExprSyntax = ".init(\(macro.argumentList))"
+    if let leadingTrivia = macro.leadingTrivia {
+      return MacroResult(initSyntax.withLeadingTrivia(leadingTrivia))
+    }
+    return MacroResult(initSyntax)
+  }
+}
+
+struct ImageLiteralMacro: ExpressionMacro {
+  static var name: String { "imageLiteral" }
 
   static func apply(
     _ macro: MacroExpansionExprSyntax, in context: MacroEvaluationContext
@@ -177,11 +205,13 @@ struct ColorLiteral: ExpressionMacro {
 extension MacroSystem {
   public static var exampleSystem: MacroSystem {
     var macroSystem = MacroSystem()
+    try! macroSystem.add(ColorLiteralMacro.self)
     try! macroSystem.add(ColumnMacro.self)
+    try! macroSystem.add(FileLiteralMacro.self)
     try! macroSystem.add(FunctionMacro.self)
+    try! macroSystem.add(ImageLiteralMacro.self)
     try! macroSystem.add(LineMacro.self)
-    try! macroSystem.add(Stringify.self)
-    try! macroSystem.add(ColorLiteral.self)
+    try! macroSystem.add(StringifyMacro.self)
     return macroSystem
   }
 }

Sources/SwiftSyntaxMacros/SwiftSyntaxMacros.docc/SwiftSyntaxMacros.md

@@ -25,8 +25,10 @@ Use `swift-parser-cli` to test out your macros and see what kind of syntactic tr
 A number of example macros have been implemented in the file `MacroSytem+Examples.swift`. They include:
 
 * `#line`: Implements the `#line` expression.
+* `#column`: Implements the `#column` expression.
+* `#function`: Implements the `#function` expression.
 * `#stringify(x)`: returns both the value `x` and the string form of its expression, as a tuple.
-* `#myColorLiteral(red: <value>, green: <value>, blue: <value>, alpha: <value>)`: behaves like the `#colorLiteral` expression.
+* `#colorLiteral(red: <value>, green: <value>, blue: <value>, alpha: <value>)`: Implements the `#colorLiteral` expression.
 
 New example macros can be added by defining new types that conform to the appropriate `*Macro` protocols, and adding those macros to the example macro system created by `MacroSystem.exampleSystem`. Have fun!
 

Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift

@@ -11,7 +11,7 @@ final class MacroSystemTests: XCTestCase {
       #line
       let a = (#line)
       let b = #stringify(x + y)
-      #myColorLiteral(red: 0.5, green: 0.5, blue: 0.25, alpha: 1.0)
+      #colorLiteral(red: 0.5, green: 0.5, blue: 0.25, alpha: 1.0)
       let c = #column
       """
     let converter = SourceLocationConverter(file: "test.swift", tree: sf)