Add representation and parser support for the @isolated type attribute

As part of this, I had to update the attribute parser to not recurse into
the full parseType routine since that would attempt to parse attributes
again right after the `@`.  Doing so allows some genuinely bizarre constructs
that we obviously don't want and will reject in semantic analysis anyway.
For `@isolated` specifically, it creates an artificial parsing conflict
with the `isolated` parameter specifier and possible future declaration
modifier, just in case you wanted attributes to apply to your attributes.

Author: rjmccall

Sources/SwiftParser/Attributes.swift

@@ -177,7 +177,7 @@ extension Parser {
     parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments
   ) -> RawAttributeListSyntax.Element {
     let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
-    let attributeName = self.parseType()
+    let attributeName = self.parseAttributeName()
     let shouldParseArgument: Bool
     switch argumentMode {
     case .required:
@@ -358,21 +358,40 @@ extension Parser {
   }
 }
 
-extension Parser {
-  mutating func parseMacroRoleArguments() -> [RawLabeledExprSyntax] {
-    let (unexpectedBeforeRole, role) = self.expect(.identifier, TokenSpec(.extension, remapping: .identifier), default: .identifier)
-    let roleTrailingComma = self.consume(if: .comma)
-    let roleElement = RawLabeledExprSyntax(
+extension RawLabeledExprSyntax {
+  fileprivate init(
+    _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil,
+    identifier: RawTokenSyntax,
+    _ unexpectedBetweenIdentifierAndTrailingComma: RawUnexpectedNodesSyntax? = nil,
+    trailingComma: RawTokenSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    self.init(
       label: nil,
       colon: nil,
       expression: RawExprSyntax(
         RawDeclReferenceExprSyntax(
-          unexpectedBeforeRole,
-          baseName: role,
+          unexpectedBeforeIdentifier,
+          baseName: identifier,
           argumentNames: nil,
-          arena: self.arena
+          arena: arena
         )
       ),
+      unexpectedBetweenIdentifierAndTrailingComma,
+      trailingComma: trailingComma,
+      arena: arena
+    )
+  }
+}
+
+extension Parser {
+  mutating func parseMacroRoleArguments() -> [RawLabeledExprSyntax] {
+    let (unexpectedBeforeRole, role) = self.expect(.identifier, TokenSpec(.extension, remapping: .identifier), default: .identifier)
+    let roleTrailingComma = self.consume(if: .comma)
+
+    let roleElement = RawLabeledExprSyntax(
+      unexpectedBeforeRole,
+      identifier: role,
       trailingComma: roleTrailingComma,
       arena: self.arena
     )
@@ -848,6 +867,23 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseIsolatedAttributeArguments() -> RawLabeledExprListSyntax {
+    let (unexpectedBeforeIsolationKind, isolationKind) =
+      self.expectIdentifier(allowKeywordsAsIdentifier: true)
+    let isolationKindElement = RawLabeledExprSyntax(
+      unexpectedBeforeIsolationKind,
+      identifier: isolationKind,
+      arena: self.arena
+    )
+
+    return RawLabeledExprListSyntax(
+      elements: [isolationKindElement],
+      arena: self.arena
+    )
+  }
+}
+
 extension Parser {
   mutating func parseBackDeployedAttributeArguments() -> RawBackDeployedAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.before))

Sources/SwiftParser/Lookahead.swift

@@ -163,7 +163,7 @@ extension Parser.Lookahead {
       // Ok, it is a valid attribute, eat it, and then process it.
       self.eat(handle)
       switch attr {
-      case .convention:
+      case .convention, .isolated:
         self.skipSingle()
       default:
         break

Sources/SwiftParser/TokenPrecedence.swift

@@ -252,6 +252,7 @@ enum TokenPrecedence: Comparable {
       .Sendable,
       .retroactive,
       .unchecked:
+      // Note that .isolated is preferred as a decl keyword
       self = .exprKeyword
 
     case  // `DeclarationAttributeWithSpecialSyntax`

Sources/SwiftParser/TokenSpecSet.swift

@@ -643,6 +643,7 @@ enum TypeAttribute: TokenSpecSet {
   case retroactive
   case Sendable
   case unchecked
+  case isolated
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -660,6 +661,7 @@ enum TypeAttribute: TokenSpecSet {
     case TokenSpec(.Sendable): self = .Sendable
     case TokenSpec(.retroactive): self = .retroactive
     case TokenSpec(.unchecked): self = .unchecked
+    case TokenSpec(.isolated): self = .isolated
     default: return nil
     }
   }
@@ -680,6 +682,7 @@ enum TypeAttribute: TokenSpecSet {
     case .retroactive: return .keyword(.retroactive)
     case .Sendable: return .keyword(.Sendable)
     case .unchecked: return .keyword(.unchecked)
+    case .isolated: return .keyword(.isolated)
     }
   }
 }

Sources/SwiftParser/Types.swift

@@ -179,9 +179,15 @@ extension Parser {
     }
   }
 
+  /// Parse the subset of types that we allow in attribute names.
+  mutating func parseAttributeName() -> RawTypeSyntax {
+    return parseSimpleType(forAttributeName: true)
+  }
+
   /// Parse a "simple" type
   mutating func parseSimpleType(
-    stopAtFirstPeriod: Bool = false
+    stopAtFirstPeriod: Bool = false,
+    forAttributeName: Bool = false
   ) -> RawTypeSyntax {
     enum TypeBaseStart: TokenSpecSet {
       case `Self`
@@ -303,6 +309,11 @@ extension Parser {
         continue
       }
 
+      // Do not allow ? or ! suffixes when parsing attribute names.
+      if forAttributeName {
+        break
+      }
+
       if self.at(TokenSpec(.postfixQuestionMark, allowAtStartOfLine: false)) {
         base = RawTypeSyntax(self.parseOptionalType(base))
         continue
@@ -937,6 +948,10 @@ extension Parser {
       return parseAttribute(argumentMode: .required) { parser in
         return .opaqueReturnTypeOfAttributeArguments(parser.parseOpaqueReturnTypeOfAttributeArguments())
       }
+    case .isolated:
+      return parseAttribute(argumentMode: .required) { parser in
+        return .argumentList(parser.parseIsolatedAttributeArguments())
+      }
     case nil:  // Custom attribute
       return parseAttribute(argumentMode: .customAttribute) { parser in
         let arguments = parser.parseArgumentListElements(pattern: .none)

Tests/SwiftParserTest/AttributeTests.swift

@@ -907,4 +907,44 @@ final class AttributeTests: ParserTestCase {
       )
     )
   }
+
+  func testIsolatedTypeAttribute() {
+    assertParse(
+      """
+      var fn: @isolated(any) () -> ()
+      """
+    )
+
+    // We don't validate the kind in the parser
+    assertParse(
+      """
+      var fn: @isolated(sdfhsdfi) () -> ()
+      """
+    )
+
+    // Check that this combines correctly with other attributs.
+    // This is not a valid combination, but we don't validate that here.
+    assertParse(
+      """
+      var fn: @isolated(any) @convention(swift) () -> ()
+      """
+    )
+    assertParse(
+      """
+      var fn: @convention(swift) @isolated(any) () -> ()
+      """
+    )
+
+    // Test that lookahead correctly skips the argument clause.
+    assertParse(
+      """
+      var array = [@isolated(any) @convention(swift) () -> ()]()
+      """
+    )
+    assertParse(
+      """
+      var array = [@convention(swift) @isolated(any) () -> ()]()
+      """
+    )
+  }
 }