Generated file changes for the isolated(any) change.

rjmccall · rjmccall · commit 6c92d16f416f · 2024-02-06T02:31:17.000-05:00
diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift
@@ -231,6 +231,8 @@ extension SyntaxKind {
       return "'is'"
     case .isTypePattern:
       return "'is' pattern"
+    case .isolatedAttributeArguments:
+      return "@isolated arguments"
     case .keyPathComponent:
       return "key path component"
     case .keyPathExpr:
diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md
@@ -326,6 +326,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax
 - <doc:SwiftSyntax/EffectsAttributeArgumentListSyntax>
 - <doc:SwiftSyntax/ExposeAttributeArgumentsSyntax>
 - <doc:SwiftSyntax/ImplementsAttributeArgumentsSyntax>
+- <doc:SwiftSyntax/IsolatedAttributeArgumentsSyntax>
 - <doc:SwiftSyntax/LabeledSpecializeArgumentSyntax>
 - <doc:SwiftSyntax/ObjCSelectorPieceListSyntax>
 - <doc:SwiftSyntax/ObjCSelectorPieceSyntax>
diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -1861,6 +1861,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "type"
   case \IsTypePatternSyntax.unexpectedAfterType:
     return "unexpectedAfterType"
+  case \IsolatedAttributeArgumentsSyntax.unexpectedBeforeIsolationKind:
+    return "unexpectedBeforeIsolationKind"
+  case \IsolatedAttributeArgumentsSyntax.isolationKind:
+    return "isolationKind"
+  case \IsolatedAttributeArgumentsSyntax.unexpectedAfterIsolationKind:
+    return "unexpectedAfterIsolationKind"
   case \KeyPathComponentSyntax.unexpectedBeforePeriod:
     return "unexpectedBeforePeriod"
   case \KeyPathComponentSyntax.period:
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -1254,6 +1254,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
   
+  override open func visit(_ node: IsolatedAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+  
+  override open func visitPost(_ node: IsolatedAttributeArgumentsSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  
   override open func visit(_ node: KeyPathComponentListSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -1668,6 +1668,7 @@ extension Syntax {
           .node(IntegerLiteralExprSyntax.self),
           .node(IsExprSyntax.self),
           .node(IsTypePatternSyntax.self),
+          .node(IsolatedAttributeArgumentsSyntax.self),
           .node(KeyPathComponentListSyntax.self),
           .node(KeyPathComponentSyntax.self),
           .node(KeyPathExprSyntax.self),
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -167,6 +167,7 @@ public enum SyntaxEnum: Sendable {
   case integerLiteralExpr(IntegerLiteralExprSyntax)
   case isExpr(IsExprSyntax)
   case isTypePattern(IsTypePatternSyntax)
+  case isolatedAttributeArguments(IsolatedAttributeArgumentsSyntax)
   case keyPathComponentList(KeyPathComponentListSyntax)
   case keyPathComponent(KeyPathComponentSyntax)
   case keyPathExpr(KeyPathExprSyntax)
@@ -605,6 +606,8 @@ public extension Syntax {
       return .isExpr(IsExprSyntax(self)!)
     case .isTypePattern:
       return .isTypePattern(IsTypePatternSyntax(self)!)
+    case .isolatedAttributeArguments:
+      return .isolatedAttributeArguments(IsolatedAttributeArgumentsSyntax(self)!)
     case .keyPathComponentList:
       return .keyPathComponentList(KeyPathComponentListSyntax(self)!)
     case .keyPathComponent:
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -167,6 +167,7 @@ public enum SyntaxKind: Sendable {
   case integerLiteralExpr
   case isExpr
   case isTypePattern
+  case isolatedAttributeArguments
   case keyPathComponentList
   case keyPathComponent
   case keyPathExpr
@@ -726,6 +727,8 @@ public enum SyntaxKind: Sendable {
       return IsExprSyntax.self
     case .isTypePattern:
       return IsTypePatternSyntax.self
+    case .isolatedAttributeArguments:
+      return IsolatedAttributeArgumentsSyntax.self
     case .keyPathComponentList:
       return KeyPathComponentListSyntax.self
     case .keyPathComponent:
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -1126,6 +1126,13 @@ open class SyntaxRewriter {
     return PatternSyntax(visitChildren(node))
   }
   
+  /// Visit a ``IsolatedAttributeArgumentsSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: IsolatedAttributeArgumentsSyntax) -> IsolatedAttributeArgumentsSyntax {
+    return visitChildren(node)
+  }
+  
   /// Visit a ``KeyPathComponentListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2712,6 +2719,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl($0, IsTypePatternSyntax.self, self.visit)
       }
+    case .isolatedAttributeArguments:
+      return {
+        self.visitImpl($0, IsolatedAttributeArgumentsSyntax.self, self.visit)
+      }
     case .keyPathComponentList:
       return {
         self.visitImpl($0, KeyPathComponentListSyntax.self, self.visit)
@@ -3536,6 +3547,8 @@ open class SyntaxRewriter {
       return visitImpl(node, IsExprSyntax.self, visit)
     case .isTypePattern:
       return visitImpl(node, IsTypePatternSyntax.self, visit)
+    case .isolatedAttributeArguments:
+      return visitImpl(node, IsolatedAttributeArgumentsSyntax.self, visit)
     case .keyPathComponentList:
       return visitImpl(node, KeyPathComponentListSyntax.self, visit)
     case .keyPathComponent:
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -1828,6 +1828,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: IsTypePatternSyntax) {
   }
   
+  /// Visiting ``IsolatedAttributeArgumentsSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: IsolatedAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+  
+  /// The function called after visiting ``IsolatedAttributeArgumentsSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: IsolatedAttributeArgumentsSyntax) {
+  }
+  
   /// Visiting ``KeyPathComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4040,6 +4052,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl($0, IsTypePatternSyntax.self, self.visit, self.visitPost)
       }
+    case .isolatedAttributeArguments:
+      return {
+        self.visitImpl($0, IsolatedAttributeArgumentsSyntax.self, self.visit, self.visitPost)
+      }
     case .keyPathComponentList:
       return {
         self.visitImpl($0, KeyPathComponentListSyntax.self, self.visit, self.visitPost)
@@ -4867,6 +4883,8 @@ open class SyntaxVisitor {
       visitImpl(node, IsExprSyntax.self, visit, visitPost)
     case .isTypePattern:
       visitImpl(node, IsTypePatternSyntax.self, visit, visitPost)
+    case .isolatedAttributeArguments:
+      visitImpl(node, IsolatedAttributeArgumentsSyntax.self, visit, visitPost)
     case .keyPathComponentList:
       visitImpl(node, KeyPathComponentListSyntax.self, visit, visitPost)
     case .keyPathComponent:
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift
@@ -1325,9 +1325,10 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
     case `unavailableFromAsyncArguments`(RawUnavailableFromAsyncAttributeArgumentsSyntax)
     case `effectsArguments`(RawEffectsAttributeArgumentListSyntax)
     case `documentationArguments`(RawDocumentationAttributeArgumentListSyntax)
+    case `isolatedArguments`(RawIsolatedAttributeArgumentsSyntax)
     
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      return RawLabeledExprListSyntax.isKindOf(raw) || RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilityArgumentListSyntax.isKindOf(raw) || RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) || RawObjCSelectorPieceListSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) || RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) || RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) || RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) || RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) || RawEffectsAttributeArgumentListSyntax.isKindOf(raw) || RawDocumentationAttributeArgumentListSyntax.isKindOf(raw)
+      return RawLabeledExprListSyntax.isKindOf(raw) || RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilityArgumentListSyntax.isKindOf(raw) || RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) || RawObjCSelectorPieceListSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) || RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) || RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) || RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) || RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) || RawEffectsAttributeArgumentListSyntax.isKindOf(raw) || RawDocumentationAttributeArgumentListSyntax.isKindOf(raw) || RawIsolatedAttributeArgumentsSyntax.isKindOf(raw)
     }
     
     public var raw: RawSyntax {
@@ -1372,6 +1373,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
         return node.raw
       case .documentationArguments(let node):
         return node.raw
+      case .isolatedArguments(let node):
+        return node.raw
       }
     }
     
@@ -1456,6 +1459,10 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
         self = .documentationArguments(node)
         return
       }
+      if let node = RawIsolatedAttributeArgumentsSyntax(other) {
+        self = .isolatedArguments(node)
+        return
+      }
       return nil
     }
   }
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift
@@ -2525,3 +2525,61 @@ public struct RawIsTypePatternSyntax: RawPatternSyntaxNodeProtocol {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
+
+@_spi(RawSyntax)
+public struct RawIsolatedAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+  
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .isolatedAttributeArguments
+  }
+  
+  public var raw: RawSyntax
+  
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+  
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+  
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+  
+  public init(
+      _ unexpectedBeforeIsolationKind: RawUnexpectedNodesSyntax? = nil, 
+      isolationKind: RawTokenSyntax, 
+      _ unexpectedAfterIsolationKind: RawUnexpectedNodesSyntax? = nil, 
+      arena: __shared SyntaxArena
+    ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .isolatedAttributeArguments, uninitializedCount: 3, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeIsolationKind?.raw
+      layout[1] = isolationKind.raw
+      layout[2] = unexpectedAfterIsolationKind?.raw
+    }
+    self.init(unchecked: raw)
+  }
+  
+  public var unexpectedBeforeIsolationKind: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var isolationKind: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  
+  public var unexpectedAfterIsolationKind: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -1611,6 +1611,11 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTypeSyntax.self))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+  case .isolatedAttributeArguments:
+    assert(layout.count == 3)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
   case .keyPathComponentList:
     for (index, element) in layout.enumerated() {
       assertNoError(kind, index, verify(element, as: RawKeyPathComponentSyntax.self))
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift
@@ -2339,7 +2339,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea
 ///  - `atSign`: `@`
 ///  - `attributeName`: ``TypeSyntax``
 ///  - `leftParen`: `(`?
-///  - `arguments`: (``LabeledExprListSyntax`` | ``TokenSyntax`` | ``StringLiteralExprSyntax`` | ``AvailabilityArgumentListSyntax`` | ``SpecializeAttributeArgumentListSyntax`` | ``ObjCSelectorPieceListSyntax`` | ``ImplementsAttributeArgumentsSyntax`` | ``DifferentiableAttributeArgumentsSyntax`` | ``DerivativeAttributeArgumentsSyntax`` | ``BackDeployedAttributeArgumentsSyntax`` | ``ConventionAttributeArgumentsSyntax`` | ``ConventionWitnessMethodAttributeArgumentsSyntax`` | ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` | ``ExposeAttributeArgumentsSyntax`` | ``OriginallyDefinedInAttributeArgumentsSyntax`` | ``UnderscorePrivateAttributeArgumentsSyntax`` | ``DynamicReplacementAttributeArgumentsSyntax`` | ``UnavailableFromAsyncAttributeArgumentsSyntax`` | ``EffectsAttributeArgumentListSyntax`` | ``DocumentationAttributeArgumentListSyntax``)?
+///  - `arguments`: (``LabeledExprListSyntax`` | ``TokenSyntax`` | ``StringLiteralExprSyntax`` | ``AvailabilityArgumentListSyntax`` | ``SpecializeAttributeArgumentListSyntax`` | ``ObjCSelectorPieceListSyntax`` | ``ImplementsAttributeArgumentsSyntax`` | ``DifferentiableAttributeArgumentsSyntax`` | ``DerivativeAttributeArgumentsSyntax`` | ``BackDeployedAttributeArgumentsSyntax`` | ``ConventionAttributeArgumentsSyntax`` | ``ConventionWitnessMethodAttributeArgumentsSyntax`` | ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` | ``ExposeAttributeArgumentsSyntax`` | ``OriginallyDefinedInAttributeArgumentsSyntax`` | ``UnderscorePrivateAttributeArgumentsSyntax`` | ``DynamicReplacementAttributeArgumentsSyntax`` | ``UnavailableFromAsyncAttributeArgumentsSyntax`` | ``EffectsAttributeArgumentListSyntax`` | ``DocumentationAttributeArgumentListSyntax`` | ``IsolatedAttributeArgumentsSyntax``)?
 ///  - `rightParen`: `)`?
 ///
 /// ### Contained in
@@ -2368,6 +2368,7 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
     case `unavailableFromAsyncArguments`(UnavailableFromAsyncAttributeArgumentsSyntax)
     case `effectsArguments`(EffectsAttributeArgumentListSyntax)
     case `documentationArguments`(DocumentationAttributeArgumentListSyntax)
+    case `isolatedArguments`(IsolatedAttributeArgumentsSyntax)
     
     public var _syntaxNode: Syntax {
       switch self {
@@ -2411,6 +2412,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
         return node._syntaxNode
       case .documentationArguments(let node):
         return node._syntaxNode
+      case .isolatedArguments(let node):
+        return node._syntaxNode
       }
     }
     
@@ -2494,6 +2497,10 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
       self = .documentationArguments(node)
     }
     
+    public init(_ node: IsolatedAttributeArgumentsSyntax) {
+      self = .isolatedArguments(node)
+    }
+    
     public init?(_ node: some SyntaxProtocol) {
       if let node = node.as(LabeledExprListSyntax.self) {
         self = .argumentList(node)
@@ -2575,6 +2582,10 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
         self = .documentationArguments(node)
         return
       }
+      if let node = node.as(IsolatedAttributeArgumentsSyntax.self) {
+        self = .isolatedArguments(node)
+        return
+      }
       return nil
     }
     
@@ -2599,7 +2610,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
             .node(DynamicReplacementAttributeArgumentsSyntax.self), 
             .node(UnavailableFromAsyncAttributeArgumentsSyntax.self), 
             .node(EffectsAttributeArgumentListSyntax.self), 
-            .node(DocumentationAttributeArgumentListSyntax.self)
+            .node(DocumentationAttributeArgumentListSyntax.self), 
+            .node(IsolatedAttributeArgumentsSyntax.self)
           ])
     }
     
@@ -3042,6 +3054,28 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
     public func cast(_ syntaxType: DocumentationAttributeArgumentListSyntax.Type) -> DocumentationAttributeArgumentListSyntax {
       return self.as(DocumentationAttributeArgumentListSyntax.self)!
     }
+    
+    /// Checks if the current syntax node can be cast to ``IsolatedAttributeArgumentsSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: IsolatedAttributeArgumentsSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+    
+    /// Attempts to cast the current syntax node to ``IsolatedAttributeArgumentsSyntax``.
+    ///
+    /// - Returns: An instance of ``IsolatedAttributeArgumentsSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: IsolatedAttributeArgumentsSyntax.Type) -> IsolatedAttributeArgumentsSyntax? {
+      return IsolatedAttributeArgumentsSyntax.init(self)
+    }
+    
+    /// Force-casts the current syntax node to ``IsolatedAttributeArgumentsSyntax``.
+    ///
+    /// - Returns: An instance of ``IsolatedAttributeArgumentsSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: IsolatedAttributeArgumentsSyntax.Type) -> IsolatedAttributeArgumentsSyntax {
+      return self.as(IsolatedAttributeArgumentsSyntax.self)!
+    }
   }
   
   public let _syntaxNode: Syntax
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift

Original file line number	Diff line number	Diff line change
`@@ -1254,6 +1254,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {`
`1254`	`1254`	`visitAnyPost(node._syntaxNode)`
`1255`	`1255`	`}`
`1256`	`1256`
	`1257`	`+ override open func visit(_ node: IsolatedAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {`
	`1258`	`+ return visitAny(node._syntaxNode)`
	`1259`	`+ }`
	`1260`	`+`
	`1261`	`+ override open func visitPost(_ node: IsolatedAttributeArgumentsSyntax) {`
	`1262`	`+ visitAnyPost(node._syntaxNode)`
	`1263`	`+ }`
	`1264`	`+`
`1257`	`1265`	`override open func visit(_ node: KeyPathComponentListSyntax) -> SyntaxVisitorContinueKind {`
`1258`	`1266`	`return visitAny(node._syntaxNode)`
`1259`	`1267`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1325,9 +1325,10 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {`
`1325`	`1325`	case `unavailableFromAsyncArguments`(RawUnavailableFromAsyncAttributeArgumentsSyntax)
`1326`	`1326`	case `effectsArguments`(RawEffectsAttributeArgumentListSyntax)
`1327`	`1327`	case `documentationArguments`(RawDocumentationAttributeArgumentListSyntax)
	`1328`	+ case `isolatedArguments`(RawIsolatedAttributeArgumentsSyntax)
`1328`	`1329`
`1329`	`1330`	`public static func isKindOf(_ raw: RawSyntax) -> Bool {`
`1330`		- return RawLabeledExprListSyntax.isKindOf(raw) \|\| RawTokenSyntax.isKindOf(raw) \|\| RawStringLiteralExprSyntax.isKindOf(raw) \|\| RawAvailabilityArgumentListSyntax.isKindOf(raw) \|\| RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) \|\| RawObjCSelectorPieceListSyntax.isKindOf(raw) \|\| RawImplementsAttributeArgumentsSyntax.isKindOf(raw) \|\| RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) \|\| RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) \|\| RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) \|\| RawConventionAttributeArgumentsSyntax.isKindOf(raw) \|\| RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) \|\| RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) \|\| RawExposeAttributeArgumentsSyntax.isKindOf(raw) \|\| RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) \|\| RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) \|\| RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) \|\| RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) \|\| RawEffectsAttributeArgumentListSyntax.isKindOf(raw) \|\| RawDocumentationAttributeArgumentListSyntax.isKindOf(raw)
	`1331`	+ return RawLabeledExprListSyntax.isKindOf(raw) \|\| RawTokenSyntax.isKindOf(raw) \|\| RawStringLiteralExprSyntax.isKindOf(raw) \|\| RawAvailabilityArgumentListSyntax.isKindOf(raw) \|\| RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) \|\| RawObjCSelectorPieceListSyntax.isKindOf(raw) \|\| RawImplementsAttributeArgumentsSyntax.isKindOf(raw) \|\| RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) \|\| RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) \|\| RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) \|\| RawConventionAttributeArgumentsSyntax.isKindOf(raw) \|\| RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) \|\| RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) \|\| RawExposeAttributeArgumentsSyntax.isKindOf(raw) \|\| RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) \|\| RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) \|\| RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) \|\| RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) \|\| RawEffectsAttributeArgumentListSyntax.isKindOf(raw) \|\| RawDocumentationAttributeArgumentListSyntax.isKindOf(raw) \|\| RawIsolatedAttributeArgumentsSyntax.isKindOf(raw)
`1331`	`1332`	`}`
`1332`	`1333`
`1333`	`1334`	`public var raw: RawSyntax {`
`@@ -1372,6 +1373,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {`
`1372`	`1373`	`return node.raw`
`1373`	`1374`	`case .documentationArguments(let node):`
`1374`	`1375`	`return node.raw`
	`1376`	`+ case .isolatedArguments(let node):`
	`1377`	`+ return node.raw`
`1375`	`1378`	`}`
`1376`	`1379`	`}`
`1377`	`1380`
`@@ -1456,6 +1459,10 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {`
`1456`	`1459`	`self = .documentationArguments(node)`
`1457`	`1460`	`return`
`1458`	`1461`	`}`
	`1462`	`+ if let node = RawIsolatedAttributeArgumentsSyntax(other) {`
	`1463`	`+ self = .isolatedArguments(node)`
	`1464`	`+ return`
	`1465`	`+ }`
`1459`	`1466`	`return nil`
`1460`	`1467`	`}`
`1461`	`1468`	`}`