Update and lock swift-syntax version to latest snapshot while fixing errors/warnings (#2)

- Updated and locked swift-syntax version
- Fixed deprecation warnings
- Fixed compilation errors
- Fixed tests
-----
Couldn't fix AddAsync/AddCompletionHandler macros, they are called multiple times and produce diagnostic errors

Author: maximkrouk

Package.resolved

@@ -15,7 +15,8 @@ let package = Package(
     dependencies: [
         .package(
             url: "https://github.com/apple/swift-syntax.git",
-            from: "509.0.0-swift-5.9-DEVELOPMENT-SNAPSHOT-2023-04-25-b"),
+            exact: "509.0.0-swift-DEVELOPMENT-SNAPSHOT-2023-08-15-a"
+        ),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
         .package(url: "https://github.com/SwiftPackageIndex/SPIManifest.git", from: "0.12.0"),
     ],

Package.swift

@@ -13,7 +13,7 @@ public struct Attribute {
     /// Creates a new attribute with the given name.
     public init(named name: String) {
         _syntax = AttributeSyntax(
-            attributeName: SimpleTypeIdentifierSyntax(
+            attributeName: IdentifierTypeSyntax(
                 name: .identifier("DictionaryStorage")
             )
         )

Sources/MacroToolkit/Attribute.swift

@@ -42,7 +42,7 @@ extension Sequence where Element == AttributeListElement {
                     element = .ifConfigDecl(
                         conditionalCompilationBlock._syntax.with(\.trailingTrivia, [.spaces(1)]))
             }
-            list = list.appending(element)
+            list += [element]
         }
         return list
     }

Sources/MacroToolkit/AttributeListElement.swift

@@ -10,6 +10,6 @@ public struct BooleanLiteral: LiteralProtocol {
     }
 
     public var value: Bool {
-        _syntax.booleanLiteral.tokenKind == .keyword(.true)
+        _syntax.literal.tokenKind == .keyword(.true)
     }
 }

Sources/MacroToolkit/BooleanLiteral.swift

@@ -2,11 +2,11 @@ import SwiftSyntax
 
 /// Wraps a constrained sugar type (i.e. `any Protocol` or `some Protocol`).
 public struct ConstrainedSugarType: TypeProtocol {
-    public var _baseSyntax: ConstrainedSugarTypeSyntax
+    public var _baseSyntax: SomeOrAnyTypeSyntax
     public var _attributedSyntax: AttributedTypeSyntax?
 
     public init(
-        _ syntax: ConstrainedSugarTypeSyntax,
+        _ syntax: SomeOrAnyTypeSyntax,
         attributedSyntax: AttributedTypeSyntax? = nil
     ) {
         _baseSyntax = syntax

Sources/MacroToolkit/ConstrainedSugarType.swift

@@ -16,7 +16,7 @@ public struct Enum {
     }
 
     public var identifier: String {
-        _syntax.identifier.withoutTrivia().text
+        _syntax.name.withoutTrivia().text
     }
 
     public var cases: [EnumCase] {

Sources/MacroToolkit/Enum.swift

@@ -10,15 +10,15 @@ public struct EnumCase {
 
     /// The case's name
     public var identifier: String {
-        _syntax.identifier.withoutTrivia().description
+        _syntax.name.withoutTrivia().description
     }
 
     /// The value associated with the enum case (either associated or raw).
     public var value: EnumCaseValue? {
         if let rawValue = _syntax.rawValue {
             return .rawValue(rawValue)
-        } else if let associatedValue = _syntax.associatedValue {
-            let parameters = Array(associatedValue.parameterList)
+        } else if let associatedValue = _syntax.parameterClause {
+            let parameters = Array(associatedValue.parameters)
                 .map(EnumCaseAssociatedValueParameter.init)
             return .associatedValue(parameters)
         } else {
@@ -27,6 +27,6 @@ public struct EnumCase {
     }
 
     public func withoutValue() -> Self {
-        EnumCase(_syntax.with(\.rawValue, nil).with(\.associatedValue, nil))
+        EnumCase(_syntax.with(\.rawValue, nil).with(\.parameterClause, nil))
     }
 }

Sources/MacroToolkit/EnumCase.swift

@@ -17,8 +17,8 @@ public struct FloatLiteral: LiteralProtocol {
     public init?(_ syntax: any ExprSyntaxProtocol) {
         guard
             let operatorSyntax = syntax.as(PrefixOperatorExprSyntax.self),
-            operatorSyntax.operatorToken?.tokenKind == .prefixOperator("-"),
-            let literalSyntax = operatorSyntax.postfixExpression.as(FloatLiteralExprSyntax.self)
+            operatorSyntax.operator.tokenKind == .prefixOperator("-"),
+            let literalSyntax = operatorSyntax.expression.as(FloatLiteralExprSyntax.self)
         else {
             // Just treat it as a regular integer literal
             guard let literal = syntax.as(FloatLiteralExprSyntax.self).map(Self.init) else {
@@ -32,7 +32,7 @@ public struct FloatLiteral: LiteralProtocol {
     }
 
     public var value: Double {
-        let string = _syntax.floatingDigits.text
+        let string = _syntax.literal.text
 
         let isHexadecimal: Bool
         let stringWithoutPrefix: String

Sources/MacroToolkit/FloatLiteral.swift

@@ -16,11 +16,11 @@ public struct Function {
     }
 
     public var identifier: String {
-        _syntax.identifier.text
+        _syntax.name.text
     }
 
     public var returnType: Type? {
-        (_syntax.signature.output?.returnType).map(Type.init)
+        (_syntax.signature.returnClause?.type).map(Type.init)
     }
 
     public var returnsVoid: Bool {
@@ -36,17 +36,17 @@ public struct Function {
     }
 
     public var parameters: [FunctionParameter] {
-        Array(_syntax.signature.input.parameterList).map(FunctionParameter.init)
+        Array(_syntax.signature.parameterClause.parameters).map(FunctionParameter.init)
     }
 
     public var attributes: [AttributeListElement] {
-        _syntax.attributes.map(Array.init)?.map { attribute in
+        _syntax.attributes.map { attribute in
             switch attribute {
                 case .attribute(let attributeSyntax):
                     return .attribute(Attribute(attributeSyntax))
                 case .ifConfigDecl(let ifConfigDeclSyntax):
                     return .conditionalCompilationBlock(ConditionalCompilationBlock(ifConfigDeclSyntax))
             }
-        } ?? []
+        }
     }
 }