redo parsing so it's within parseType to match C++ parser

kavon · kavon · commit 019a02d69ab6 · 2023-04-25T17:48:12.000-07:00
diff --git a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift
@@ -1029,14 +1029,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")
diff --git a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift b/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",
diff --git a/Sources/SwiftParser/Declarations.swift b/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)) {
diff --git a/Sources/SwiftParser/Nominals.swift b/Sources/SwiftParser/Nominals.swift
@@ -279,7 +279,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(
@@ -289,14 +288,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
diff --git a/Sources/SwiftParser/Types.swift b/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)
   }
 
diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift
@@ -341,6 +341,8 @@ extension SyntaxKind {
       return "subscript"
     case .subscriptExpr:
       return "subscript"
+    case .suppressedType:
+      return "suppressed type conformance"
     case .switchCase:
       return "switch case"
     case .switchExpr:
diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md
@@ -186,6 +186,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/PackExpansionTypeSyntax>
 - <doc:SwiftSyntax/PackReferenceTypeSyntax>
 - <doc:SwiftSyntax/SimpleTypeIdentifierSyntax>
+- <doc:SwiftSyntax/SuppressedTypeSyntax>
 - <doc:SwiftSyntax/TupleTypeSyntax>
 
 ### Collections
diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -1712,12 +1712,8 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "rightOperand"
   case \InfixOperatorExprSyntax.unexpectedAfterRightOperand:
     return "unexpectedAfterRightOperand"
-  case \InheritedTypeSyntax.unexpectedBeforeWithoutTilde:
-    return "unexpectedBeforeWithoutTilde"
-  case \InheritedTypeSyntax.withoutTilde:
-    return "withoutTilde"
-  case \InheritedTypeSyntax.unexpectedBetweenWithoutTildeAndTypeName:
-    return "unexpectedBetweenWithoutTildeAndTypeName"
+  case \InheritedTypeSyntax.unexpectedBeforeTypeName:
+    return "unexpectedBeforeTypeName"
   case \InheritedTypeSyntax.typeName:
     return "typeName"
   case \InheritedTypeSyntax.unexpectedBetweenTypeNameAndTrailingComma:
@@ -2848,6 +2844,16 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "superKeyword"
   case \SuperRefExprSyntax.unexpectedAfterSuperKeyword:
     return "unexpectedAfterSuperKeyword"
+  case \SuppressedTypeSyntax.unexpectedBeforeWithoutTilde:
+    return "unexpectedBeforeWithoutTilde"
+  case \SuppressedTypeSyntax.withoutTilde:
+    return "withoutTilde"
+  case \SuppressedTypeSyntax.unexpectedBetweenWithoutTildeAndPatternType:
+    return "unexpectedBetweenWithoutTildeAndPatternType"
+  case \SuppressedTypeSyntax.patternType:
+    return "patternType"
+  case \SuppressedTypeSyntax.unexpectedAfterPatternType:
+    return "unexpectedAfterPatternType"
   case \SwitchCaseLabelSyntax.unexpectedBeforeCaseKeyword:
     return "unexpectedBeforeCaseKeyword"
   case \SwitchCaseLabelSyntax.caseKeyword:
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -1869,6 +1869,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
   
+  override open func visit(_ node: SuppressedTypeSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+  
+  override open func visitPost(_ node: SuppressedTypeSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  
   override open func visit(_ node: SwitchCaseLabelSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -610,7 +610,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType:
+    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .suppressedType, .tupleType:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -622,7 +622,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
-    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType:
+    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .suppressedType, .tupleType:
       break
     default:
       preconditionFailure("Unable to create TypeSyntax from \(data.raw.kind)")
@@ -674,6 +674,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
           .node(PackExpansionTypeSyntax.self), 
           .node(PackReferenceTypeSyntax.self), 
           .node(SimpleTypeIdentifierSyntax.self), 
+          .node(SuppressedTypeSyntax.self), 
           .node(TupleTypeSyntax.self)
         ])
   }
@@ -910,6 +911,7 @@ extension Syntax {
           .node(SubscriptDeclSyntax.self), 
           .node(SubscriptExprSyntax.self), 
           .node(SuperRefExprSyntax.self), 
+          .node(SuppressedTypeSyntax.self), 
           .node(SwitchCaseLabelSyntax.self), 
           .node(SwitchCaseListSyntax.self), 
           .node(SwitchCaseSyntax.self), 
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -243,6 +243,7 @@ public enum SyntaxEnum {
   case subscriptDecl(SubscriptDeclSyntax)
   case subscriptExpr(SubscriptExprSyntax)
   case superRefExpr(SuperRefExprSyntax)
+  case suppressedType(SuppressedTypeSyntax)
   case switchCaseLabel(SwitchCaseLabelSyntax)
   case switchCaseList(SwitchCaseListSyntax)
   case switchCase(SwitchCaseSyntax)
@@ -746,6 +747,8 @@ public extension Syntax {
       return .subscriptExpr(SubscriptExprSyntax(self)!)
     case .superRefExpr:
       return .superRefExpr(SuperRefExprSyntax(self)!)
+    case .suppressedType:
+      return .suppressedType(SuppressedTypeSyntax(self)!)
     case .switchCaseLabel:
       return .switchCaseLabel(SwitchCaseLabelSyntax(self)!)
     case .switchCaseList:
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -243,6 +243,7 @@ public enum SyntaxKind {
   case subscriptDecl
   case subscriptExpr
   case superRefExpr
+  case suppressedType
   case switchCaseLabel
   case switchCaseList
   case switchCase
@@ -861,6 +862,8 @@ public enum SyntaxKind {
       return SubscriptExprSyntax.self
     case .superRefExpr:
       return SuperRefExprSyntax.self
+    case .suppressedType:
+      return SuppressedTypeSyntax.self
     case .switchCaseLabel:
       return SwitchCaseLabelSyntax.self
     case .switchCaseList:
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -1614,6 +1614,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
   
+  /// Visit a `SuppressedTypeSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: SuppressedTypeSyntax) -> TypeSyntax {
+    return TypeSyntax(visitChildren(node))
+  }
+  
   /// Visit a `SwitchCaseLabelSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -5153,6 +5160,20 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
   
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplSuppressedTypeSyntax(_ data: SyntaxData) -> Syntax {
+    let node = SuppressedTypeSyntax(data)
+    // Accessing _syntaxNode directly is faster than calling Syntax(node)
+    visitPre(node._syntaxNode)
+    defer { 
+      visitPost(node._syntaxNode) 
+    }
+    if let newNode = visitAny(node._syntaxNode) { 
+      return newNode 
+    }
+    return Syntax(visit(node))
+  }
+  
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplSwitchCaseLabelSyntax(_ data: SyntaxData) -> Syntax {
     let node = SwitchCaseLabelSyntax(data)
@@ -6223,6 +6244,8 @@ open class SyntaxRewriter {
       return visitImplSubscriptExprSyntax
     case .superRefExpr:
       return visitImplSuperRefExprSyntax
+    case .suppressedType:
+      return visitImplSuppressedTypeSyntax
     case .switchCaseLabel:
       return visitImplSwitchCaseLabelSyntax
     case .switchCaseList:
@@ -6769,6 +6792,8 @@ open class SyntaxRewriter {
       return visitImplSubscriptExprSyntax(data)
     case .superRefExpr:
       return visitImplSuperRefExprSyntax(data)
+    case .suppressedType:
+      return visitImplSuppressedTypeSyntax(data)
     case .switchCaseLabel:
       return visitImplSwitchCaseLabelSyntax(data)
     case .switchCaseList:
diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift
@@ -1154,6 +1154,11 @@ public protocol SyntaxTransformVisitor {
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SuperRefExprSyntax) -> ResultType
   
+  /// Visiting `SuppressedTypeSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: the sum of whatever the child visitors return.
+  func visit(_ node: SuppressedTypeSyntax) -> ResultType
+  
   /// Visiting `SwitchCaseLabelSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -2954,6 +2959,13 @@ extension SyntaxTransformVisitor {
     visitAny(Syntax(node))
   }
   
+  /// Visiting `SuppressedTypeSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  public func visit(_ node: SuppressedTypeSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
+  
   /// Visiting `SwitchCaseLabelSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -3699,6 +3711,8 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .superRefExpr(let derived):
       return visit(derived)
+    case .suppressedType(let derived):
+      return visit(derived)
     case .switchCaseLabel(let derived):
       return visit(derived)
     case .switchCaseList(let derived):
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -2758,6 +2758,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: SuperRefExprSyntax) {
   }
   
+  /// Visiting `SuppressedTypeSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: SuppressedTypeSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+  
+  /// The function called after visiting `SuppressedTypeSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: SuppressedTypeSyntax) {
+  }
+  
   /// Visiting `SwitchCaseLabelSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -5759,6 +5771,17 @@ open class SyntaxVisitor {
     visitPost(node)
   }
   
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplSuppressedTypeSyntax(_ data: SyntaxData) {
+    let node = SuppressedTypeSyntax(data)
+    let needsChildren = (visit(node) == .visitChildren)
+    // Avoid calling into visitChildren if possible.
+    if needsChildren && !node.raw.layoutView!.children.isEmpty {
+      visitChildren(node)
+    }
+    visitPost(node)
+  }
+  
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplSwitchCaseLabelSyntax(_ data: SyntaxData) {
     let node = SwitchCaseLabelSyntax(data)
@@ -6671,6 +6694,8 @@ open class SyntaxVisitor {
       visitImplSubscriptExprSyntax(data)
     case .superRefExpr:
       visitImplSuperRefExprSyntax(data)
+    case .suppressedType:
+      visitImplSuppressedTypeSyntax(data)
     case .switchCaseLabel:
       visitImplSwitchCaseLabelSyntax(data)
     case .switchCaseList:
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,18 @@ extension Parser {`
`37`	`37`	`)`
`38`	`38`	`}`
`39`	`39`
	`40`	`+ // Parse without operator preceding a type '~ T'.`
	`41`	`+ if let withoutTilde = self.consumeIfContextualPunctuator("~", remapping: .prefixOperator) {`
	`42`	`+ let type = self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)`
	`43`	`+ return RawTypeSyntax(`
	`44`	`+ RawSuppressedTypeSyntax(`
	`45`	`+ withoutTilde: withoutTilde,`
	`46`	`+ patternType: type,`
	`47`	`+ arena: self.arena`
	`48`	`+ )`
	`49`	`+ )`
	`50`	`+ }`
	`51`	`+`
`40`	`52`	`return self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)`
`41`	`53`	`}`
`42`	`54`
Original file line number	Diff line number	Diff line change
`@@ -1869,6 +1869,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {`
`1869`	`1869`	`visitAnyPost(node._syntaxNode)`
`1870`	`1870`	`}`
`1871`	`1871`
	`1872`	`+ override open func visit(_ node: SuppressedTypeSyntax) -> SyntaxVisitorContinueKind {`
	`1873`	`+ return visitAny(node._syntaxNode)`
	`1874`	`+ }`
	`1875`	`+`
	`1876`	`+ override open func visitPost(_ node: SuppressedTypeSyntax) {`
	`1877`	`+ visitAnyPost(node._syntaxNode)`
	`1878`	`+ }`
	`1879`	`+`
`1872`	`1880`	`override open func visit(_ node: SwitchCaseLabelSyntax) -> SyntaxVisitorContinueKind {`
`1873`	`1881`	`return visitAny(node._syntaxNode)`
`1874`	`1882`	`}`