redo parsing of without operator to match C++ parser

This basically moves the logic out from only when encountering an
inheritance entry and instead when generally parsing a type, since
that was a better way to go on the C++ side.

(cherry picked from commit d141df5)

Author: kavon

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -992,14 +992,6 @@ 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: "WithoutTilde",
-        kind: .token(choices: [.token(tokenKind: "PrefixOperatorToken")]),
-        isOptional: true
-      ),
       Child(
         name: "TypeName",
         kind: .node(kind: "Type")

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -349,6 +349,23 @@ public let TYPE_NODES: [Node] = [
     ]
   ),
 
+  // suppressed-type -> '~' type
+  Node(
+    name: "SuppressedType",
+    nameForDiagnostics: "suppressed type conformance",
+    kind: "Type",
+    children: [
+      Child(
+        name: "WithoutTilde",
+        kind: .token(choices: [.token(tokenKind: "PrefixOperatorToken")])
+      ),
+      Child(
+        name: "PatternType",
+        kind: .node(kind: "Type")
+      ),
+    ]
+  ),
+
   // pack-expansion-type -> type '...'
   Node(
     name: "PackExpansionType",

Sources/SwiftParser/Declarations.swift

@@ -497,7 +497,7 @@ extension Parser {
         let unexpectedBeforeInherited: RawUnexpectedNodesSyntax?
         let inherited: RawTypeSyntax?
         if colon != nil {
-          if self.at(.identifier, .keyword(.protocol), .keyword(.Any)) {
+          if self.at(.identifier, .keyword(.protocol), .keyword(.Any)) || self.atContextualPunctuator("~") {
             unexpectedBeforeInherited = nil
             inherited = self.parseType()
           } else if let classKeyword = self.consume(if: .keyword(.class)) {

Sources/SwiftParser/Nominals.swift

@@ -219,7 +219,6 @@ 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(
@@ -229,14 +228,12 @@ extension Parser {
             )
           )
         } else {
-          withoutToken = self.consumeIfContextualPunctuator("~", remapping: .prefixOperator)
           type = self.parseType()
         }
 
         keepGoing = self.consume(if: .comma)
         elements.append(
           RawInheritedTypeSyntax(
-            withoutTilde: withoutToken,
             typeName: type,
             trailingComma: keepGoing,
             arena: self.arena

Sources/SwiftParser/Types.swift

@@ -37,6 +37,18 @@ extension Parser {
       )
     }
 
+    // Parse without operator preceding a type '~ T'.
+    if let withoutTilde = self.consumeIfContextualPunctuator("~", remapping: .prefixOperator) {
+      let type = self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)
+      return RawTypeSyntax(
+        RawSuppressedTypeSyntax(
+          withoutTilde: withoutTilde,
+          patternType: type,
+          arena: self.arena
+        )
+      )
+    }
+
     return self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)
   }