Mark Syntax.Info.info as nonisolated(unsafe)

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/Node.swift

@@ -233,7 +233,11 @@ public class Node {
           // This will repeat the syntax type before and after the dot, which is
           // a little unfortunate, but it's the only way I found to get docc to
           // generate a fully-qualified type + member.
-          return " - \($0.node.doccLink).``\($0.node.syntaxType)/\(childName)``"
+          if $0.node.isAvailableInDocc {
+            return " - \($0.node.doccLink).``\($0.node.syntaxType)/\(childName)``"
+          } else {
+            return " - \($0.node.doccLink).`\($0.node.syntaxType)/\(childName)`"
+          }
         } else {
           return " - \($0.node.doccLink)"
         }

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -355,14 +355,25 @@ public enum SyntaxNodeKind: String, CaseIterable {
     }
   }
 
+  /// Whether the node is public API and not underscored/deprecated and can thus be referenced in docc links.
+  public var isAvailableInDocc: Bool {
+    if let node = SYNTAX_NODE_MAP[self], node.isExperimental {
+      return false
+    } else if isDeprecated {
+      return false
+    } else {
+      return true
+    }
+  }
+
   /// If this node is non-experimental a docc link wrapped in two backticks.
   ///
   /// For experimental nodes, the node's type name in code font.
   public var doccLink: String {
-    if let node = SYNTAX_NODE_MAP[self], node.isExperimental {
-      return "`\(syntaxType)`"
-    } else {
+    if isAvailableInDocc {
       return "``\(syntaxType)``"
+    } else {
+      return "`\(syntaxType)`"
     }
   }
 

Sources/SwiftParser/Declarations.swift

@@ -711,7 +711,7 @@ extension Parser {
 extension Parser {
   mutating func parseMemberBlockItem() -> RawMemberBlockItemSyntax? {
     let startToken = self.currentToken
-    if let syntax = self.loadCurrentSyntaxNodeFromCache(for: .memberBlockItemList) {
+    if let syntax = self.loadCurrentSyntaxNodeFromCache(for: .memberBlockItem) {
       self.registerNodeForIncrementalParse(node: syntax.raw, startToken: startToken)
       return RawMemberBlockItemSyntax(syntax.raw)
     }

Sources/SwiftSyntax/Syntax.swift

@@ -46,7 +46,11 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
     /// - Important: Must only be set to `nil` when `Syntax.Info` is used in a memory recycling pool
     ///    (eg. in `SyntaxVisitor`). In that case the `Syntax.Info` is considered garbage memory that can be re-used
     ///    later. `info` needs to be set to a real value when `Syntax.Info` is recycled from the memory recycling pool.
+    #if compiler(>=6.0)
+    nonisolated(unsafe) var info: InfoImpl!
+    #else
     var info: InfoImpl!
+    #endif
   }
 
   /// Reference to the node's parent or, if this node is the root of a tree, a reference to the `SyntaxArena` to keep

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -283,14 +283,14 @@ open class SyntaxRewriter {
     return StmtSyntax(visitChildren(node))
   }
 
-  /// Visit a ``_CanImportExprSyntax``.
+  /// Visit a `_CanImportExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: _CanImportExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
 
-  /// Visit a ``_CanImportVersionInfoSyntax``.
+  /// Visit a `_CanImportVersionInfoSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: _CanImportVersionInfoSyntax) -> ExprSyntax {

Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -377,26 +377,26 @@ open class SyntaxVisitor {
   open func visitPost(_ node: BreakStmtSyntax) {
   }
 
-  /// Visiting ``_CanImportExprSyntax`` specifically.
+  /// Visiting `_CanImportExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: _CanImportExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
 
-  /// The function called after visiting ``_CanImportExprSyntax`` and its descendants.
+  /// The function called after visiting `_CanImportExprSyntax` and its descendants.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: _CanImportExprSyntax) {
   }
 
-  /// Visiting ``_CanImportVersionInfoSyntax`` specifically.
+  /// Visiting `_CanImportVersionInfoSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: _CanImportVersionInfoSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
 
-  /// The function called after visiting ``_CanImportVersionInfoSyntax`` and its descendants.
+  /// The function called after visiting `_CanImportVersionInfoSyntax` and its descendants.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: _CanImportVersionInfoSyntax) {
   }

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift

@@ -19,7 +19,7 @@
 ///  - `canImportKeyword`: `canImport`
 ///  - `leftParen`: `(`
 ///  - `importPath`: `<identifier>`
-///  - `versionInfo`: ``_CanImportVersionInfoSyntax``?
+///  - `versionInfo`: `_CanImportVersionInfoSyntax`?
 ///  - `rightParen`: `)`
 public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
@@ -229,7 +229,7 @@ public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp
 ///
 /// ### Contained in
 /// 
-///  - ``_CanImportExprSyntax``.``_CanImportExprSyntax/versionInfo``
+///  - `_CanImportExprSyntax`.`_CanImportExprSyntax/versionInfo`
 public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift

@@ -3796,7 +3796,7 @@ public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
 /// ### Contained in
 /// 
 ///  - ``AvailabilityLabeledArgumentSyntax``.``AvailabilityLabeledArgumentSyntax/value``
-///  - ``_CanImportVersionInfoSyntax``.``_CanImportVersionInfoSyntax/version``
+///  - `_CanImportVersionInfoSyntax`.`_CanImportVersionInfoSyntax/version`
 ///  - ``PlatformVersionSyntax``.``PlatformVersionSyntax/version``
 public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
   public let _syntaxNode: Syntax

Tests/SwiftParserTest/IncrementalParsingTests.swift

@@ -23,7 +23,7 @@ class IncrementalParsingTests: ParserTestCase {
       struct A⏩️⏸️A⏪️ { func f() {
       """,
       reusedNodes: [
-        ReusedNodeSpec("func f() {", kind: .memberDeclListItem)
+        ReusedNodeSpec("func f() {", kind: .memberBlockItem)
       ]
     )
   }
@@ -191,10 +191,10 @@ class IncrementalParsingTests: ParserTestCase {
       }
       """,
       reusedNodes: [
-        ReusedNodeSpec("let a: Int", kind: .memberDeclListItem),
-        ReusedNodeSpec("let b: Int", kind: .memberDeclListItem),
-        ReusedNodeSpec("let c: Int", kind: .memberDeclListItem),
-        ReusedNodeSpec("let g: Int", kind: .memberDeclListItem),
+        ReusedNodeSpec("let a: Int", kind: .memberBlockItem),
+        ReusedNodeSpec("let b: Int", kind: .memberBlockItem),
+        ReusedNodeSpec("let c: Int", kind: .memberBlockItem),
+        ReusedNodeSpec("let g: Int", kind: .memberBlockItem),
       ]
     )
   }