Allow multiple type specifiers on a type

Having multiple type specifiers on a type is valid in the C++ parser but not in the Swift parser.

rdar://118125715

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -285,6 +285,8 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case typeEffectSpecifiers
   case typeExpr
   case typeInitializerClause
+  case typeSpecifier
+  case typeSpecifierList
   case unavailableFromAsyncAttributeArguments
   case underscorePrivateAttributeArguments
   case unexpectedNodes

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -35,12 +35,10 @@ public let TYPE_NODES: [Node] = [
   ),
 
   Node(
-    kind: .attributedType,
-    base: .type,
-    nameForDiagnostics: "type",
-    traits: [
-      "WithAttributes"
-    ],
+    kind: .typeSpecifier,
+    base: .syntax,
+    nameForDiagnostics: nil,
+    documentation: "A specifier that can be attached to a type to eg. mark a parameter as `inout` or `consuming`",
     children: [
       Child(
         name: "specifier",
@@ -54,8 +52,29 @@ public let TYPE_NODES: [Node] = [
           .keyword(.consuming),
           .keyword(.transferring),
           .keyword(._resultDependsOn),
-        ]),
-        isOptional: true
+        ])
+      )
+    ]
+  ),
+
+  Node(
+    kind: .typeSpecifierList,
+    base: .syntaxCollection,
+    nameForDiagnostics: nil,
+    elementChoices: [.typeSpecifier]
+  ),
+
+  Node(
+    kind: .attributedType,
+    base: .type,
+    nameForDiagnostics: "type",
+    traits: [
+      "WithAttributes"
+    ],
+    children: [
+      Child(
+        name: "specifiers",
+        kind: .collection(kind: .typeSpecifierList, collectionElementName: "Specifier", defaultsToEmpty: true)
       ),
       Child(
         name: "attributes",

Release Notes/600.md

@@ -62,6 +62,10 @@
   - Description: `IncrementalEdit` used to store the range that was replaced and the length of the replacement but not the replacement bytes by itself. `IncrementalEdit` now has a `replacement` property that contains the replacement bytes.
   - Pull Request: https://github.com/apple/swift-syntax/pull/2527
 
+- `TypeSpecifierListSyntax` and `TypeSpecifierSyntax`
+  - Description: `AttributedTypeSyntax` can now contain multiple specifiers and these types are used to model the list of specifiers.
+  - Pull request: https://github.com/apple/swift-syntax/pull/2433
+  
 ## API Behavior Changes
 
 ## Deprecations
@@ -87,6 +91,10 @@
   - Description: `EditorPlaceholderDeclSyntax` and `EditorPlaceholderExprSyntax` are now deprecated and placeholders are instead parsed as identifiers within a `MissingDeclSyntax` or `DeclReferenceExprSyntax`.
   - Pull request: https://github.com/apple/swift-syntax/pull/2237
 
+- `AttributedTypeSyntax.specifier` has renamed and changed to be a collection
+  - Description: Types can have multiple specifiers now and the syntax tree has been modified to reflect that.
+  - Pull request: https://github.com/apple/swift-syntax/pull/2433
+
 ## API-Incompatible Changes
 
 - `MacroDefinition` used for expanding macros:

Sources/SwiftParser/Parser.swift

@@ -178,6 +178,19 @@ public struct Parser {
     return _emptyRawAttributeListSyntax!
   }
 
+  var _emptyRawTypeSpecifierListSyntax: RawTypeSpecifierListSyntax?
+
+  /// Create an empty collection of the given type.
+  ///
+  /// These empty collections are only created once and the same node is returned
+  /// on subsequent calls, reducing memory usage.
+  mutating func emptyCollection(_: RawTypeSpecifierListSyntax.Type) -> RawTypeSpecifierListSyntax {
+    if _emptyRawTypeSpecifierListSyntax == nil {
+      _emptyRawTypeSpecifierListSyntax = RawTypeSpecifierListSyntax(elements: [], arena: self.arena)
+    }
+    return _emptyRawTypeSpecifierListSyntax!
+  }
+
   /// The delegated initializer for the parser.
   ///
   /// - Parameters

Sources/SwiftParser/Types.swift

@@ -31,7 +31,7 @@ extension Parser {
   }
 
   mutating func parseTypeScalar(misplacedSpecifiers: [RawTokenSyntax] = []) -> RawTypeSyntax {
-    let (specifier, unexpectedBeforeAttrList, attrList) = self.parseTypeAttributeList(misplacedSpecifiers: misplacedSpecifiers)
+    let specifiersAndAttributes = self.parseTypeAttributeList(misplacedSpecifiers: misplacedSpecifiers)
     var base = RawTypeSyntax(self.parseSimpleOrCompositionType())
     if self.withLookahead({ $0.atFunctionTypeArrow() }) {
       var effectSpecifiers = self.parseTypeEffectSpecifiers()
@@ -88,12 +88,11 @@ extension Parser {
       )
     }
 
-    if unexpectedBeforeAttrList != nil || specifier != nil || !attrList.isEmpty {
+    if let specifiersAndAttributes {
       return RawTypeSyntax(
         RawAttributedTypeSyntax(
-          specifier: specifier,
-          unexpectedBeforeAttrList,
-          attributes: attrList,
+          specifiers: specifiersAndAttributes.specifiers,
+          attributes: specifiersAndAttributes.attributes,
           baseType: base,
           arena: self.arena
         )
@@ -891,35 +890,44 @@ extension Parser.Lookahead {
 }
 
 extension Parser {
-  mutating func parseTypeAttributeList(misplacedSpecifiers: [RawTokenSyntax] = []) -> (
-    specifier: RawTokenSyntax?, unexpectedBeforeAttributes: RawUnexpectedNodesSyntax?, attributes: RawAttributeListSyntax
-  ) {
-    var specifier: RawTokenSyntax? = nil
-    if canHaveParameterSpecifier {
-      specifier = self.consume(ifAnyIn: TypeSpecifier.self)
+  mutating func parseTypeAttributeList(
+    misplacedSpecifiers: [RawTokenSyntax] = []
+  ) -> (
+    specifiers: RawTypeSpecifierListSyntax,
+    attributes: RawAttributeListSyntax
+  )? {
+    var specifiers: [RawTypeSpecifierSyntax] = []
+    while canHaveParameterSpecifier, let specifier = self.consume(ifAnyIn: TypeSpecifierSyntax.SpecifierOptions.self) {
+      specifiers.append(RawTypeSpecifierSyntax(specifier: specifier, arena: arena))
     }
-    // We can only stick one specifier on this type. Let's pick the first one
-    if specifier == nil, let misplacedSpecifier = misplacedSpecifiers.first {
-      specifier = missingToken(misplacedSpecifier.tokenKind, text: misplacedSpecifier.tokenText)
-    }
-    var extraneousSpecifiers: [RawTokenSyntax] = []
-
-    while canHaveParameterSpecifier,
-      let extraSpecifier = self.consume(ifAnyIn: AttributedTypeSyntax.SpecifierOptions.self)
-    {
-      if specifier == nil {
-        specifier = extraSpecifier
-      } else {
-        extraneousSpecifiers.append(extraSpecifier)
+    if !misplacedSpecifiers.isEmpty {
+      specifiers += misplacedSpecifiers.map {
+        RawTypeSpecifierSyntax(specifier: missingToken($0.tokenKind, text: $0.tokenText), arena: arena)
       }
     }
-    let unexpectedBeforeAttributeList = RawUnexpectedNodesSyntax(extraneousSpecifiers, arena: self.arena)
 
+    let attributes: RawAttributeListSyntax?
     if self.at(.atSign) {
-      return (specifier, unexpectedBeforeAttributeList, self.parseTypeAttributeListPresent())
+      attributes = self.parseTypeAttributeListPresent()
+    } else {
+      attributes = nil
     }
 
-    return (specifier, unexpectedBeforeAttributeList, self.emptyCollection(RawAttributeListSyntax.self))
+    guard !specifiers.isEmpty || attributes != nil else {
+      // No specifiers or attributes on this type
+      return nil
+    }
+    let specifierList: RawTypeSpecifierListSyntax
+    if specifiers.isEmpty {
+      specifierList = self.emptyCollection(RawTypeSpecifierListSyntax.self)
+    } else {
+      specifierList = RawTypeSpecifierListSyntax(elements: specifiers, arena: arena)
+    }
+
+    return (
+      specifierList,
+      attributes ?? self.emptyCollection(RawAttributeListSyntax.self)
+    )
   }
 
   mutating func parseTypeAttributeListPresent() -> RawAttributeListSyntax {

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -177,98 +177,6 @@ extension AsExprSyntax {
   }
 }
 
-extension AttributedTypeSyntax {
-  @_spi(Diagnostics)
-  public enum SpecifierOptions: TokenSpecSet {
-    case `inout`
-    case __shared
-    case __owned
-    case isolated
-    case _const
-    case borrowing
-    case consuming
-    @_spi(ExperimentalLanguageFeatures)
-    case transferring
-    @_spi(ExperimentalLanguageFeatures)
-    case _resultDependsOn
-    
-    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
-      switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(.inout):
-        self = .inout
-      case TokenSpec(.__shared):
-        self = .__shared
-      case TokenSpec(.__owned):
-        self = .__owned
-      case TokenSpec(.isolated):
-        self = .isolated
-      case TokenSpec(._const):
-        self = ._const
-      case TokenSpec(.borrowing):
-        self = .borrowing
-      case TokenSpec(.consuming):
-        self = .consuming
-      case TokenSpec(.transferring) where experimentalFeatures.contains(.transferringArgsAndResults):
-        self = .transferring
-      case TokenSpec(._resultDependsOn) where experimentalFeatures.contains(.nonescapableTypes):
-        self = ._resultDependsOn
-      default:
-        return nil
-      }
-    }
-    
-    var spec: TokenSpec {
-      switch self {
-      case .inout:
-        return .keyword(.inout)
-      case .__shared:
-        return .keyword(.__shared)
-      case .__owned:
-        return .keyword(.__owned)
-      case .isolated:
-        return .keyword(.isolated)
-      case ._const:
-        return .keyword(._const)
-      case .borrowing:
-        return .keyword(.borrowing)
-      case .consuming:
-        return .keyword(.consuming)
-      case .transferring:
-        return .keyword(.transferring)
-      case ._resultDependsOn:
-        return .keyword(._resultDependsOn)
-      }
-    }
-    
-    /// Returns a token that satisfies the `TokenSpec` of this case.
-    ///
-    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
-    @_spi(Diagnostics)
-    public var tokenSyntax: TokenSyntax {
-      switch self {
-      case .inout:
-        return .keyword(.inout)
-      case .__shared:
-        return .keyword(.__shared)
-      case .__owned:
-        return .keyword(.__owned)
-      case .isolated:
-        return .keyword(.isolated)
-      case ._const:
-        return .keyword(._const)
-      case .borrowing:
-        return .keyword(.borrowing)
-      case .consuming:
-        return .keyword(.consuming)
-      case .transferring:
-        return .keyword(.transferring)
-      case ._resultDependsOn:
-        return .keyword(._resultDependsOn)
-      }
-    }
-  }
-}
-
 extension AvailabilityConditionSyntax {
   @_spi(Diagnostics)
   public enum AvailabilityKeywordOptions: TokenSpecSet {
@@ -2960,6 +2868,98 @@ extension TupleTypeElementSyntax {
   }
 }
 
+extension TypeSpecifierSyntax {
+  @_spi(Diagnostics)
+  public enum SpecifierOptions: TokenSpecSet {
+    case `inout`
+    case __shared
+    case __owned
+    case isolated
+    case _const
+    case borrowing
+    case consuming
+    @_spi(ExperimentalLanguageFeatures)
+    case transferring
+    @_spi(ExperimentalLanguageFeatures)
+    case _resultDependsOn
+    
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.inout):
+        self = .inout
+      case TokenSpec(.__shared):
+        self = .__shared
+      case TokenSpec(.__owned):
+        self = .__owned
+      case TokenSpec(.isolated):
+        self = .isolated
+      case TokenSpec(._const):
+        self = ._const
+      case TokenSpec(.borrowing):
+        self = .borrowing
+      case TokenSpec(.consuming):
+        self = .consuming
+      case TokenSpec(.transferring) where experimentalFeatures.contains(.transferringArgsAndResults):
+        self = .transferring
+      case TokenSpec(._resultDependsOn) where experimentalFeatures.contains(.nonescapableTypes):
+        self = ._resultDependsOn
+      default:
+        return nil
+      }
+    }
+    
+    var spec: TokenSpec {
+      switch self {
+      case .inout:
+        return .keyword(.inout)
+      case .__shared:
+        return .keyword(.__shared)
+      case .__owned:
+        return .keyword(.__owned)
+      case .isolated:
+        return .keyword(.isolated)
+      case ._const:
+        return .keyword(._const)
+      case .borrowing:
+        return .keyword(.borrowing)
+      case .consuming:
+        return .keyword(.consuming)
+      case .transferring:
+        return .keyword(.transferring)
+      case ._resultDependsOn:
+        return .keyword(._resultDependsOn)
+      }
+    }
+    
+    /// Returns a token that satisfies the `TokenSpec` of this case.
+    ///
+    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
+    @_spi(Diagnostics)
+    public var tokenSyntax: TokenSyntax {
+      switch self {
+      case .inout:
+        return .keyword(.inout)
+      case .__shared:
+        return .keyword(.__shared)
+      case .__owned:
+        return .keyword(.__owned)
+      case .isolated:
+        return .keyword(.isolated)
+      case ._const:
+        return .keyword(._const)
+      case .borrowing:
+        return .keyword(.borrowing)
+      case .consuming:
+        return .keyword(.consuming)
+      case .transferring:
+        return .keyword(.transferring)
+      case ._resultDependsOn:
+        return .keyword(._resultDependsOn)
+      }
+    }
+  }
+}
+
 extension UnresolvedAsExprSyntax {
   @_spi(Diagnostics)
   public enum QuestionOrExclamationMarkOptions: TokenSpecSet {