add parsing for ~ (the 'without' operator)

Author: kavon

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1029,6 +1029,14 @@ public let DECL_NODES: [Node] = [
       "WithTrailingComma"
     ],
     children: [
+      /// Indicates whether the 'without' operator was applied to the type to
+      /// indicate the suppression of implicit conformance to this type.
+      /// This child stores the token representing the 'without' operator.
+      Child(
+        name: "HasWithout",
+        kind: .token(choices: [.token(tokenKind: "PrefixOperatorToken")]),
+        isOptional: true
+      ),
       Child(
         name: "TypeName",
         kind: .node(kind: "Type")

Sources/SwiftParser/Nominals.swift

@@ -279,6 +279,7 @@ extension Parser {
       var keepGoing: RawTokenSyntax? = nil
       var loopProgress = LoopProgressCondition()
       repeat {
+        var withoutToken: RawTokenSyntax? = nil
         let type: RawTypeSyntax
         if let classKeyword = self.consume(if: .keyword(.class)) {
           type = RawTypeSyntax(
@@ -288,12 +289,16 @@ extension Parser {
             )
           )
         } else {
+          if self.currentToken.starts(with: "~") {
+            withoutToken = self.consumePrefix("~", as: .prefixOperator)
+          }
           type = self.parseType()
         }
 
         keepGoing = self.consume(if: .comma)
         elements.append(
           RawInheritedTypeSyntax(
+            hasWithout: withoutToken,
             typeName: type,
             trailingComma: keepGoing,
             arena: self.arena

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1713,8 +1713,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "rightOperand"
   case \InfixOperatorExprSyntax.unexpectedAfterRightOperand:
     return "unexpectedAfterRightOperand"
-  case \InheritedTypeSyntax.unexpectedBeforeTypeName:
-    return "unexpectedBeforeTypeName"
+  case \InheritedTypeSyntax.unexpectedBeforeHasWithout:
+    return "unexpectedBeforeHasWithout"
+  case \InheritedTypeSyntax.hasWithout:
+    return "hasWithout"
+  case \InheritedTypeSyntax.unexpectedBetweenHasWithoutAndTypeName:
+    return "unexpectedBetweenHasWithoutAndTypeName"
   case \InheritedTypeSyntax.typeName:
     return "typeName"
   case \InheritedTypeSyntax.unexpectedBetweenTypeNameAndTrailingComma:

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -11708,43 +11708,55 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol {
   }
 
   public init(
-      _ unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBeforeHasWithout: RawUnexpectedNodesSyntax? = nil, 
+      hasWithout: RawTokenSyntax?, 
+      _ unexpectedBetweenHasWithoutAndTypeName: RawUnexpectedNodesSyntax? = nil, 
       typeName: RawTypeSyntax, 
       _ unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, 
       trailingComma: RawTokenSyntax?, 
       _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .inheritedType, uninitializedCount: 5, arena: arena) { layout in
+      kind: .inheritedType, uninitializedCount: 7, arena: arena) { layout in
       layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeTypeName?.raw
-      layout[1] = typeName.raw
-      layout[2] = unexpectedBetweenTypeNameAndTrailingComma?.raw
-      layout[3] = trailingComma?.raw
-      layout[4] = unexpectedAfterTrailingComma?.raw
+      layout[0] = unexpectedBeforeHasWithout?.raw
+      layout[1] = hasWithout?.raw
+      layout[2] = unexpectedBetweenHasWithoutAndTypeName?.raw
+      layout[3] = typeName.raw
+      layout[4] = unexpectedBetweenTypeNameAndTrailingComma?.raw
+      layout[5] = trailingComma?.raw
+      layout[6] = unexpectedAfterTrailingComma?.raw
     }
     self.init(unchecked: raw)
   }
 
-  public var unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? {
+  public var unexpectedBeforeHasWithout: RawUnexpectedNodesSyntax? {
     layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
+  public var hasWithout: RawTokenSyntax? {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
+  }
+  
+  public var unexpectedBetweenHasWithoutAndTypeName: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
   public var typeName: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
 
   public var unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw:))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
 
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -1503,12 +1503,14 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
       assertNoError(kind, index, verify(element, as: RawInheritedTypeSyntax.self))
     }
   case .inheritedType:
-    assert(layout.count == 5)
+    assert(layout.count == 7)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTypeSyntax.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.prefixOperator)]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
+    assertNoError(kind, 3, verify(layout[3], as: RawTypeSyntax.self))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
+    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
   case .initializerClause:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift

@@ -10564,7 +10564,9 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
 
   public init<T: TypeSyntaxProtocol>(
       leadingTrivia: Trivia? = nil,
-      _ unexpectedBeforeTypeName: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBeforeHasWithout: UnexpectedNodesSyntax? = nil,
+      hasWithout: TokenSyntax? = nil,
+      _ unexpectedBetweenHasWithoutAndTypeName: UnexpectedNodesSyntax? = nil,
       typeName: T,
       _ unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? = nil,
       trailingComma: TokenSyntax? = nil,
@@ -10575,14 +10577,18 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
     // before they can be added as children of the new arena.
     let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (
-            unexpectedBeforeTypeName, 
+            unexpectedBeforeHasWithout, 
+            hasWithout, 
+            unexpectedBetweenHasWithoutAndTypeName, 
             typeName, 
             unexpectedBetweenTypeNameAndTrailingComma, 
             trailingComma, 
             unexpectedAfterTrailingComma
           ))) {(arena, _) in
       let layout: [RawSyntax?] = [
-          unexpectedBeforeTypeName?.raw, 
+          unexpectedBeforeHasWithout?.raw, 
+          hasWithout?.raw, 
+          unexpectedBetweenHasWithoutAndTypeName?.raw, 
           typeName.raw, 
           unexpectedBetweenTypeNameAndTrailingComma?.raw, 
           trailingComma?.raw, 
@@ -10601,7 +10607,7 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     self.init(data)
   }
 
-  public var unexpectedBeforeTypeName: UnexpectedNodesSyntax? {
+  public var unexpectedBeforeHasWithout: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -10610,16 +10616,16 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
 
-  public var typeName: TypeSyntax {
+  public var hasWithout: TokenSyntax? {
     get {
-      return TypeSyntax(data.child(at: 1, parent: Syntax(self))!)
+      return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init)
     }
     set(value) {
-      self = InheritedTypeSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena()))
+      self = InheritedTypeSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena()))
     }
   }
 
-  public var unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenHasWithoutAndTypeName: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -10628,16 +10634,16 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
 
-  public var trailingComma: TokenSyntax? {
+  public var typeName: TypeSyntax {
     get {
-      return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init)
+      return TypeSyntax(data.child(at: 3, parent: Syntax(self))!)
     }
     set(value) {
-      self = InheritedTypeSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena()))
+      self = InheritedTypeSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena()))
     }
   }
 
-  public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -10646,9 +10652,29 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
 
+  public var trailingComma: TokenSyntax? {
+    get {
+      return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init)
+    }
+    set(value) {
+      self = InheritedTypeSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena()))
+    }
+  }
+  
+  public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? {
+    get {
+      return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
+    }
+    set(value) {
+      self = InheritedTypeSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena()))
+    }
+  }
+  
   public static var structure: SyntaxNodeStructure {
     return .layout([
-          \Self.unexpectedBeforeTypeName, 
+          \Self.unexpectedBeforeHasWithout, 
+          \Self.hasWithout, 
+          \Self.unexpectedBetweenHasWithoutAndTypeName, 
           \Self.typeName, 
           \Self.unexpectedBetweenTypeNameAndTrailingComma, 
           \Self.trailingComma, 

Tests/SwiftParserTest/Assertions.swift

@@ -12,7 +12,7 @@
 
 import XCTest
 @_spi(RawSyntax) import SwiftSyntax
-@_spi(Testing)@_spi(RawSyntax) import SwiftParser
+@_spi(Testing) @_spi(RawSyntax) import SwiftParser
 @_spi(RawSyntax) import SwiftParserDiagnostics
 import SwiftDiagnostics
 import _SwiftSyntaxTestSupport

Tests/SwiftParserTest/DeclarationTests.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 @_spi(RawSyntax) import SwiftSyntax
-@_spi(Testing)@_spi(RawSyntax) import SwiftParser
+@_spi(Testing) @_spi(RawSyntax) import SwiftParser
 import SwiftSyntaxBuilder
 import SwiftBasicFormat
 import XCTest
@@ -1561,6 +1561,16 @@ final class DeclarationTests: XCTestCase {
       ]
     )
   }
+
+  func testSuppressedImplicitConformance() {
+    assertParse(
+      """
+      struct Hello: ~Copyable {}
+
+      enum Whatever: Int, ~ Hashable, Equatable {}
+      """
+    )
+  }
 }
 
 extension Parser.DeclAttributes {