Merge pull request #1875 from rintaro/macros-openexistential

rintaro · web-flow · commit 1561a9e02903 · 2023-07-03T15:44:34.000-07:00
Stop using _openExistential
diff --git a/Sources/SwiftSyntaxMacroExpansion/MacroExpansion.swift b/Sources/SwiftSyntaxMacroExpansion/MacroExpansion.swift
@@ -91,41 +91,38 @@ public func expandFreestandingMacro(
   in context: some MacroExpansionContext
 ) -> String? {
   do {
-    func _expand(node: some FreestandingMacroExpansionSyntax) throws -> String {
-      let expandedSyntax: Syntax
-      switch (macroRole, definition) {
-      case (.expression, let exprMacroDef as ExpressionMacro.Type):
-        expandedSyntax = try Syntax(exprMacroDef.expansion(of: node, in: context))
-
-      case (.declaration, let declMacroDef as DeclarationMacro.Type):
-        var rewritten = try declMacroDef.expansion(of: node, in: context)
-        // Copy attributes and modifiers to the generated decls.
-        if let expansionDecl = node.as(MacroExpansionDeclSyntax.self) {
-          let attributes = declMacroDef.propagateFreestandingMacroAttributes ? expansionDecl.attributes : nil
-          let modifiers = declMacroDef.propagateFreestandingMacroModifiers ? expansionDecl.modifiers : nil
-          rewritten = rewritten.map {
-            $0.applying(attributes: attributes, modifiers: modifiers)
-          }
+    let expandedSyntax: Syntax
+    switch (macroRole, definition) {
+    case (.expression, let exprMacroDef as ExpressionMacro.Type):
+      expandedSyntax = try Syntax(exprMacroDef.expansion(of: node, in: context))
+
+    case (.declaration, let declMacroDef as DeclarationMacro.Type):
+      var rewritten = try declMacroDef.expansion(of: node, in: context)
+      // Copy attributes and modifiers to the generated decls.
+      if let expansionDecl = node.as(MacroExpansionDeclSyntax.self) {
+        let attributes = declMacroDef.propagateFreestandingMacroAttributes ? expansionDecl.attributes : nil
+        let modifiers = declMacroDef.propagateFreestandingMacroModifiers ? expansionDecl.modifiers : nil
+        rewritten = rewritten.map {
+          $0.applying(attributes: attributes, modifiers: modifiers)
         }
-        expandedSyntax = Syntax(
-          CodeBlockItemListSyntax(
-            rewritten.map {
-              CodeBlockItemSyntax(item: .decl($0))
-            }
-          )
+      }
+      expandedSyntax = Syntax(
+        CodeBlockItemListSyntax(
+          rewritten.map {
+            CodeBlockItemSyntax(item: .decl($0))
+          }
         )
+      )
 
-      case (.codeItem, let codeItemMacroDef as CodeItemMacro.Type):
-        let rewritten = try codeItemMacroDef.expansion(of: node, in: context)
-        expandedSyntax = Syntax(CodeBlockItemListSyntax(rewritten))
+    case (.codeItem, let codeItemMacroDef as CodeItemMacro.Type):
+      let rewritten = try codeItemMacroDef.expansion(of: node, in: context)
+      expandedSyntax = Syntax(CodeBlockItemListSyntax(rewritten))
 
-      case (.accessor, _), (.memberAttribute, _), (.member, _), (.peer, _), (.conformance, _), (.extension, _), (.expression, _), (.declaration, _),
-        (.codeItem, _):
-        throw MacroExpansionError.unmatchedMacroRole(definition, macroRole)
-      }
-      return expandedSyntax.formattedExpansion(definition.formatMode)
+    case (.accessor, _), (.memberAttribute, _), (.member, _), (.peer, _), (.conformance, _), (.extension, _), (.expression, _), (.declaration, _),
+      (.codeItem, _):
+      throw MacroExpansionError.unmatchedMacroRole(definition, macroRole)
     }
-    return try _openExistential(node, do: _expand)
+    return expandedSyntax.formattedExpansion(definition.formatMode)
   } catch {
     context.addDiagnostics(from: error, node: node)
     return nil
@@ -208,22 +205,11 @@ public func expandAttachedMacroWithoutCollapsing<Context: MacroExpansionContext>
         throw MacroExpansionError.parentDeclGroupNil
       }
 
-      // Local function to expand a member attribute macro once we've opened up
-      // the existential.
-      func expandMemberAttributeMacro(
-        _ node: some DeclGroupSyntax
-      ) throws -> [AttributeSyntax] {
-        return try attachedMacro.expansion(
-          of: attributeNode,
-          attachedTo: node,
-          providingAttributesFor: declarationNode,
-          in: context
-        )
-      }
-
-      let attributes = try _openExistential(
-        parentDeclGroup,
-        do: expandMemberAttributeMacro
+      let attributes = try attachedMacro.expansion(
+        of: attributeNode,
+        attachedTo: parentDeclGroup,
+        providingAttributesFor: declarationNode,
+        in: context
       )
 
       // Form a buffer containing an attribute list to return to the caller.
@@ -238,19 +224,11 @@ public func expandAttachedMacroWithoutCollapsing<Context: MacroExpansionContext>
         throw MacroExpansionError.declarationNotDeclGroup
       }
 
-      // Local function to expand a member macro once we've opened up
-      // the existential.
-      func expandMemberMacro(
-        _ node: some DeclGroupSyntax
-      ) throws -> [DeclSyntax] {
-        return try attachedMacro.expansion(
-          of: attributeNode,
-          providingMembersOf: node,
-          in: context
-        )
-      }
-
-      let members = try _openExistential(declGroup, do: expandMemberMacro)
+      let members = try attachedMacro.expansion(
+        of: attributeNode,
+        providingMembersOf: declGroup,
+        in: context
+      )
 
       // Form a buffer of member declarations to return to the caller.
       return members.map { $0.formattedExpansion(definition.formatMode) }
@@ -279,23 +257,12 @@ public func expandAttachedMacroWithoutCollapsing<Context: MacroExpansionContext>
 
       let protocols = conformanceList?.map(\.typeName) ?? []
 
-      // Local function to expand an extension macro once we've opened up
-      // the existential.
-      func expandExtensionMacro(
-        _ node: some DeclGroupSyntax
-      ) throws -> [ExtensionDeclSyntax] {
-        return try attachedMacro.expansion(
-          of: attributeNode,
-          attachedTo: node,
-          providingExtensionsOf: extendedType,
-          conformingTo: protocols,
-          in: context
-        )
-      }
-
-      let extensions = try _openExistential(
-        declGroup,
-        do: expandExtensionMacro
+      let extensions = try attachedMacro.expansion(
+        of: attributeNode,
+        attachedTo: declGroup,
+        providingExtensionsOf: extendedType,
+        conformingTo: protocols,
+        in: context
       )
 
       // Form a buffer of peer declarations to return to the caller.
diff --git a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
@@ -14,26 +14,6 @@ import SwiftDiagnostics
 import SwiftSyntax
 @_spi(MacroExpansion) import SwiftSyntaxMacros
 
-private func expandMemberAttributeMacro(attribute: AttributeSyntax, attachedTo: DeclSyntax) -> AttributeListSyntax {
-  fatalError("unimplemented")
-}
-
-private func expandMemberMacro(attribute: AttributeSyntax, attachedTo: DeclGroupSyntax) -> MemberDeclListSyntax {
-  fatalError("unimplemented")
-}
-
-private func expandPeerMacro(attribute: AttributeSyntax, attachedTo: DeclSyntax) -> CodeBlockItemListSyntax {
-  fatalError("unimplemented")
-}
-
-private func expandConformanceMacro(attribute: AttributeSyntax, attachedTo: DeclSyntax) -> CodeBlockItemListSyntax {
-  fatalError("unimplemented")
-}
-
-private func expandAccessorMacro(attribute: AttributeSyntax, attachedTo: DeclSyntax) -> AccessorListSyntax {
-  fatalError("unimplemented")
-}
-
 /// Describes the kinds of errors that can occur within a macro system.
 enum MacroSystemError: Error {
   /// Indicates that a macro with the given name has already been defined.
@@ -155,7 +135,7 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
       if let expansion = item.item.asProtocol(FreestandingMacroExpansionSyntax.self),
         let macro = macroSystem.macros[expansion.macro.text]
       {
-        func _expand(expansion: some FreestandingMacroExpansionSyntax) throws {
+        do {
           if let macro = macro as? CodeItemMacro.Type {
             let expandedItemList = try macro.expansion(
               of: expansion,
@@ -186,9 +166,6 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
             )
             newItems.append(CodeBlockItemSyntax(item: .init(expandedExpr)))
           }
-        }
-        do {
-          try _openExistential(expansion, do: _expand)
         } catch {
           context.addDiagnostics(from: error, node: node)
         }
@@ -493,27 +470,6 @@ extension MacroApplication {
     )
   }
 
-  private func expandMemberAttribute(
-    attribute: AttributeSyntax,
-    macro: MemberAttributeMacro.Type,
-    decl: DeclGroupSyntax,
-    member: DeclSyntax,
-    in context: MacroExpansionContext
-  ) throws -> [AttributeSyntax] {
-    #if false
-    _openExistential(decl) { d in
-      return try! macro.expansion(
-        of: attribute,
-        attachedTo: d,
-        annotating: member,
-        in: context
-      )
-    }
-    #else
-    return []
-    #endif
-  }
-
   private func expandAttributes(
     for macroAttributes: [(AttributeSyntax, MemberAttributeMacro.Type)],
     attachedTo decl: DeclSyntax,
@@ -527,18 +483,13 @@ extension MacroApplication {
     for (attribute, attributeMacro) in macroAttributes {
       do {
         let typedDecl = decl.asProtocol(DeclGroupSyntax.self)!
-
-        func expand(_ decl: some DeclGroupSyntax) throws -> [AttributeSyntax] {
-          return try attributeMacro.expansion(
+        attributes.append(
+          contentsOf: try attributeMacro.expansion(
             of: attribute,
-            attachedTo: decl,
+            attachedTo: typedDecl,
             providingAttributesFor: member.decl,
             in: context
           )
-        }
-
-        attributes.append(
-          contentsOf: try _openExistential(typedDecl, do: expand)
         )
       } catch {
         context.addDiagnostics(from: error, node: attribute)
diff --git a/Sources/SwiftSyntaxMacros/MacroSystem.swift b/Sources/SwiftSyntaxMacros/MacroSystem.swift
@@ -134,7 +134,7 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
       if let expansion = item.item.asProtocol(FreestandingMacroExpansionSyntax.self),
         let macro = macroSystem.macros[expansion.macro.text]
       {
-        func _expand(expansion: some FreestandingMacroExpansionSyntax) throws {
+        do {
           if let macro = macro as? CodeItemMacro.Type {
             let expandedItemList = try macro.expansion(
               of: expansion,
@@ -165,9 +165,6 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
             )
             newItems.append(CodeBlockItemSyntax(item: .init(expandedExpr)))
           }
-        }
-        do {
-          try _openExistential(expansion, do: _expand)
         } catch {
           context.addDiagnostics(from: error, node: node)
         }
@@ -472,27 +469,6 @@ extension MacroApplication {
     )
   }
 
-  private func expandMemberAttribute(
-    attribute: AttributeSyntax,
-    macro: MemberAttributeMacro.Type,
-    decl: DeclGroupSyntax,
-    member: DeclSyntax,
-    in context: MacroExpansionContext
-  ) throws -> [AttributeSyntax] {
-    #if false
-    _openExistential(decl) { d in
-      return try! macro.expansion(
-        of: attribute,
-        attachedTo: d,
-        annotating: member,
-        in: context
-      )
-    }
-    #else
-    return []
-    #endif
-  }
-
   private func expandAttributes(
     for macroAttributes: [(AttributeSyntax, MemberAttributeMacro.Type)],
     attachedTo decl: DeclSyntax,
@@ -506,18 +482,13 @@ extension MacroApplication {
     for (attribute, attributeMacro) in macroAttributes {
       do {
         let typedDecl = decl.asProtocol(DeclGroupSyntax.self)!
-
-        func expand(_ decl: some DeclGroupSyntax) throws -> [AttributeSyntax] {
-          return try attributeMacro.expansion(
+        attributes.append(
+          contentsOf: try attributeMacro.expansion(
             of: attribute,
-            attachedTo: decl,
+            attachedTo: typedDecl,
             providingAttributesFor: member.decl,
             in: context
           )
-        }
-
-        attributes.append(
-          contentsOf: try _openExistential(typedDecl, do: expand)
         )
       } catch {
         context.addDiagnostics(from: error, node: attribute)
