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

CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift

@@ -141,6 +141,10 @@ public let ATTRIBUTE_NODES: [Node] = [
             name: "documentationArguments",
             kind: .node(kind: .documentationAttributeArgumentList)
           ),
+          Child(
+            name: "isolatedArguments",
+            kind: .node(kind: .isolatedAttributeArguments)
+          ),
         ]),
         documentation: """
           The arguments of the attribute.
@@ -611,6 +615,19 @@ public let ATTRIBUTE_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .isolatedAttributeArguments,
+    base: .syntax,
+    nameForDiagnostics: "@isolated arguments",
+    documentation: "The arguments of the '@isolated' attribute",
+    children: [
+      Child(
+        name: "isolationKind",
+        kind: .node(kind: .token)
+      )
+    ]
+  ),
+
   Node(
     kind: .labeledSpecializeArgument,
     base: .syntax,

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -171,6 +171,7 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case integerLiteralExpr
   case isExpr
   case isTypePattern
+  case isolatedAttributeArguments
   case keyPathComponent
   case keyPathComponentList
   case keyPathExpr

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:
@@ -848,6 +848,18 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseIsolatedAttributeArguments() -> RawIsolatedAttributeArgumentsSyntax {
+    let (unexpectedBeforeIsolationKind, label) =
+      self.expectIdentifier(allowKeywordsAsIdentifier: true)
+    return RawIsolatedAttributeArgumentsSyntax(
+      unexpectedBeforeIsolationKind,
+      isolationKind: label,
+      arena: self.arena
+    )
+  }
+}
+
 extension Parser {
   mutating func parseBackDeployedAttributeArguments() -> RawBackDeployedAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.before))

Sources/SwiftParser/Lookahead.swift

@@ -162,14 +162,11 @@ extension Parser.Lookahead {
     if let (attr, handle) = self.at(anyIn: TypeAttribute.self) {
       // Ok, it is a valid attribute, eat it, and then process it.
       self.eat(handle)
-      if case .convention = attr {
-        guard
-          self.consume(if: .leftParen) != nil,
-          self.consume(if: .identifier) != nil,
-          self.consume(if: .rightParen) != nil
-        else {
-          return
-        }
+      switch attr {
+      case .convention, .isolated:
+        self.skipSingle()
+      default:
+        break
       }
       return
     }

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 .isolatedArguments(parser.parseIsolatedAttributeArguments())
+      }
     case nil:  // Custom attribute
       return parseAttribute(argumentMode: .customAttribute) { parser in
         let arguments = parser.parseArgumentListElements(pattern: .none)

Tests/SwiftParserTest/AttributeTests.swift

@@ -886,4 +886,43 @@ 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) () -> ()
+      """
+    )
+
+    assertParse(
+      """
+      var array = [@isolated(any) @convention(swift) () -> ()]()
+      """
+    )
+    assertParse(
+      """
+      var array = [@convention(swift) @isolated(any) () -> ()]()
+      """
+    )
+  }
 }