Update for Swift 5.2

.github/workflows/ci.yml

@@ -3,24 +3,20 @@ name: CI
 on: [push]
 
 jobs:
-  macos:
-    runs-on: macOS-latest
+  # macos:
+  #   runs-on: macOS-latest
 
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v1
-      - name: Build and Test
-        run: swift test
+  #   steps:
+  #     - name: Checkout
+  #       uses: actions/checkout@v1
+  #     - name: Build and Test
+  #       run: swift test
 
   linux:
     runs-on: ubuntu-latest
 
-    strategy:
-      matrix:
-        swift: ["5.1"]
-
     container:
-      image: swift:${{ matrix.swift }}
+      image: swiftlang/swift:nightly-5.2-xenial
 
     steps:
       - name: Checkout

Package.swift

@@ -14,7 +14,7 @@ let package = Package(
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.
-        .package(url: "https://github.com/apple/swift-syntax.git", .exact("0.50100.0")),
+        .package(url: "https://github.com/apple/swift-syntax.git", .exact("0.50200.0")),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.

Sources/SwiftSemantics/DeclarationCollector.swift

@@ -20,7 +20,7 @@ import SwiftSyntax
  collector.enumerations.first?.name // "E"
  ```
  */
-open class DeclarationCollector {
+open class DeclarationCollector: SyntaxVisitor {
     /// The collected associated type declarations.
     public private(set) var associatedTypes: [AssociatedType] = []
 
@@ -73,110 +73,108 @@ open class DeclarationCollector {
     public private(set) var variables: [Variable] = []
 
     /// Creates a new declaration collector.
-    public init() {}
-}
+    public override init() {}
 
-// MARK: - SyntaxVisitor
+    // MARK: - SyntaxVisitor
 
-extension DeclarationCollector: SyntaxVisitor {
     /// Called when visiting an `AssociatedtypeDeclSyntax` node
-    public func visit(_ node: AssociatedtypeDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: AssociatedtypeDeclSyntax) -> SyntaxVisitorContinueKind {
         associatedTypes.append(AssociatedType(node))
         return .skipChildren
     }
 
     /// Called when visiting a `ClassDeclSyntax` node
-    public func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
         classes.append(Class(node))
         return .visitChildren
     }
 
     /// Called when visiting a `DeinitializerDeclSyntax` node
-    public func visit(_ node: DeinitializerDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: DeinitializerDeclSyntax) -> SyntaxVisitorContinueKind {
         deinitializers.append(Deinitializer(node))
         return .skipChildren
     }
 
     /// Called when visiting an `EnumDeclSyntax` node
-    public func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
         enumerations.append(Enumeration(node))
         return .visitChildren
     }
 
     /// Called when visiting an `EnumCaseDeclSyntax` node
-    public func visit(_ node: EnumCaseDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: EnumCaseDeclSyntax) -> SyntaxVisitorContinueKind {
         enumerationCases.append(contentsOf: Enumeration.Case.cases(from: node))
         return .skipChildren
     }
 
     /// Called when visiting an `ExtensionDeclSyntax` node
-    public func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {
         extensions.append(Extension(node))
         return .visitChildren
     }
 
     /// Called when visiting a `FunctionDeclSyntax` node
-    public func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind {
         functions.append(Function(node))
         return .skipChildren
     }
 
     /// Called when visiting an `IfConfigDeclSyntax` node
-    public func visit(_ node: IfConfigDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: IfConfigDeclSyntax) -> SyntaxVisitorContinueKind {
         conditionalCompilationBlocks.append(ConditionalCompilationBlock(node))
         return .visitChildren
     }
 
     /// Called when visiting an `ImportDeclSyntax` node
-    public func visit(_ node: ImportDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: ImportDeclSyntax) -> SyntaxVisitorContinueKind {
         imports.append(Import(node))
         return .skipChildren
     }
 
     /// Called when visiting an `InitializerDeclSyntax` node
-    public func visit(_ node: InitializerDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: InitializerDeclSyntax) -> SyntaxVisitorContinueKind {
         initializers.append(Initializer(node))
         return .skipChildren
     }
 
     /// Called when visiting an `OperatorDeclSyntax` node
-    public func visit(_ node: OperatorDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: OperatorDeclSyntax) -> SyntaxVisitorContinueKind {
         operators.append(Operator(node))
         return .skipChildren
     }
 
     /// Called when visiting a `PrecedenceGroupDeclSyntax` node
-    public func visit(_ node: PrecedenceGroupDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: PrecedenceGroupDeclSyntax) -> SyntaxVisitorContinueKind {
         precedenceGroups.append(PrecedenceGroup(node))
         return .skipChildren
     }
 
     /// Called when visiting a `ProtocolDeclSyntax` node
-    public func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
         protocols.append(Protocol(node))
         return .visitChildren
     }
 
     /// Called when visiting a `SubscriptDeclSyntax` node
-    public func visit(_ node: SubscriptDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override  func visit(_ node: SubscriptDeclSyntax) -> SyntaxVisitorContinueKind {
         subscripts.append(Subscript(node))
         return .skipChildren
     }
 
     /// Called when visiting a `StructDeclSyntax` node
-    public func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
         structures.append(Structure(node))
         return .visitChildren
     }
 
     /// Called when visiting a `TypealiasDeclSyntax` node
-    public func visit(_ node: TypealiasDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: TypealiasDeclSyntax) -> SyntaxVisitorContinueKind {
         typealiases.append(Typealias(node))
         return .skipChildren
     }
 
     /// Called when visiting a `VariableDeclSyntax` node
-    public func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {
+    public override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {
         variables.append(contentsOf: Variable.variables(from: node))
         return .skipChildren
     }

Sources/SwiftSemantics/Declarations/AssociatedType.swift

@@ -20,7 +20,7 @@ public struct AssociatedType: Declaration, Hashable, Codable {
 extension AssociatedType: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: AssociatedtypeDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.associatedtypeKeyword.text.trimmed
         name = node.identifier.text.trimmed

Sources/SwiftSemantics/Declarations/Class.swift

@@ -69,7 +69,7 @@ public struct Class: Declaration, Hashable, Codable {
 extension Class: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: ClassDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.classKeyword.text.trimmed
         name = node.identifier.text.trimmed

Sources/SwiftSemantics/Declarations/Deinitializer.swift

@@ -17,7 +17,7 @@ public struct Deinitializer: Declaration, Hashable, Codable {
 extension Deinitializer: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: DeinitializerDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.deinitKeyword.text.trimmed
     }

Sources/SwiftSemantics/Declarations/Enumeration.swift

@@ -120,7 +120,7 @@ extension Enumeration.Case: CustomStringConvertible {
 extension Enumeration: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: EnumDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.enumKeyword.text.trimmed
         name = node.identifier.text.trimmed
@@ -143,12 +143,12 @@ extension Enumeration.Case {
             return nil
         }
 
-        attributes = parent.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = parent.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = parent.modifiers?.map { Modifier($0) } ?? []
         keyword = parent.caseKeyword.text.trimmed
 
         name = node.identifier.text.trimmed
         associatedValue = node.associatedValue?.parameterList.map { Function.Parameter($0) }
-        rawValue = node.rawValue?.children.first { $0.isExpr }?.description
+        rawValue = node.rawValue?.value.description.trimmed
     }
 }

Sources/SwiftSemantics/Declarations/Extension.swift

@@ -52,7 +52,7 @@ public struct Extension: Declaration, Hashable, Codable {
 extension Extension: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: ExtensionDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.extensionKeyword.text.trimmed
         extendedType = node.extendedType.description.trimmed

Sources/SwiftSemantics/Declarations/Function.swift

@@ -148,7 +148,7 @@ public struct Function: Declaration, Hashable, Codable {
 extension Function: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: FunctionDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.funcKeyword.text.trimmed
         identifier = node.identifier.text.trimmed
@@ -161,7 +161,7 @@ extension Function: ExpressibleBySyntax {
 extension Function.Parameter: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: FunctionParameterSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         firstName = node.firstName?.text.trimmed
         secondName = node.secondName?.text.trimmed
         type = node.type?.description.trimmed

Sources/SwiftSemantics/Declarations/Import.swift

@@ -20,7 +20,7 @@ public struct Import: Declaration, Hashable, Codable {
 extension Import: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: ImportDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.importTok.text.trimmed
         kind = node.importKind?.text.trimmed

Sources/SwiftSemantics/Declarations/Initializer.swift

@@ -55,7 +55,7 @@ public struct Initializer: Declaration, Hashable, Codable {
 extension Initializer: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: InitializerDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.initKeyword.text.trimmed
         optional = node.optionalMark != nil

Sources/SwiftSemantics/Declarations/Operator.swift

@@ -132,7 +132,7 @@ public struct Operator: Declaration, Hashable, Codable {
 extension Operator: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: OperatorDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.operatorKeyword.text.trimmed
         name = node.identifier.text.trimmed

Sources/SwiftSemantics/Declarations/PrecedenceGroup.swift

@@ -139,7 +139,7 @@ extension PrecedenceGroup.Relation: Codable {
 extension PrecedenceGroup: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: PrecedenceGroupDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.precedencegroupKeyword.text.trimmed
         name = node.identifier.text.trimmed
@@ -149,17 +149,14 @@ extension PrecedenceGroup: ExpressibleBySyntax {
         var relations: [Relation] = []
 
         for attribute in node.groupAttributes {
-            switch attribute {
-            case let attribute as PrecedenceGroupAssignmentSyntax:
+            if let attribute = PrecedenceGroupAssignmentSyntax(attribute) {
                 assignment = Bool(attribute)
-            case let attribute as PrecedenceGroupAssociativitySyntax:
+            } else if let attribute = PrecedenceGroupAssociativitySyntax(attribute) {
                 associativity = Associativity(attribute)
-            case let attribute as PrecedenceGroupRelationSyntax:
+            } else if let attribute = PrecedenceGroupRelationSyntax(attribute) {
                 if let relation = Relation(attribute) {
                     relations.append(relation)
                 }
-            default:
-                continue
             }
         }
 

Sources/SwiftSemantics/Declarations/Protocol.swift

@@ -34,7 +34,7 @@ public struct Protocol: Declaration, Hashable, Codable {
 extension Protocol: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: ProtocolDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.protocolKeyword.text.trimmed
         name = node.identifier.text.trimmed

Sources/SwiftSemantics/Declarations/Structure.swift

@@ -64,7 +64,7 @@ public struct Structure: Declaration, Hashable, Codable {
 extension Structure: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: StructDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.structKeyword.text.trimmed
         name = node.identifier.text.trimmed

Sources/SwiftSemantics/Declarations/Subscript.swift

@@ -55,14 +55,14 @@ public struct Subscript: Declaration, Hashable, Codable {
 extension Subscript: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: SubscriptDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.subscriptKeyword.text.trimmed
         indices = node.indices.parameterList.map { Function.Parameter($0) }
         genericParameters = node.genericParameterClause?.genericParameterList.map { GenericParameter($0) } ?? []
         returnType = node.result.returnType.description.trimmed
         genericRequirements = GenericRequirement.genericRequirements(from: node.genericWhereClause?.requirementList)
-        accessors = Variable.Accessor.accessors(from: node.accessor as? AccessorBlockSyntax)
+        accessors = Variable.Accessor.accessors(from: node.accessor?.as(AccessorBlockSyntax.self))
     }
 }
 

Sources/SwiftSemantics/Declarations/Typealias.swift

@@ -52,7 +52,7 @@ public struct Typealias: Declaration, Hashable, Codable {
 extension Typealias: ExpressibleBySyntax {
     /// Creates an instance initialized with the given syntax node.
     public init(_ node: TypealiasDeclSyntax) {
-        attributes = node.attributes?.compactMap{ $0 as? AttributeSyntax }.map { Attribute($0) } ?? []
+        attributes = node.attributes?.compactMap{ $0.as(AttributeSyntax.self) }.map { Attribute($0) } ?? []
         modifiers = node.modifiers?.map { Modifier($0) } ?? []
         keyword = node.typealiasKeyword.text.trimmed
         name = node.identifier.text.trimmed