Add a recursive hasError flag to RawSyntax

This allows us to check whether a subtree contains a syntax error in O(1).

rdar://98575249

Author: ahoppen

Sources/SwiftSyntax/RawSyntax.swift

@@ -13,6 +13,20 @@
 typealias RawSyntaxBuffer = UnsafeBufferPointer<RawSyntax?>
 typealias RawTriviaPieceBuffer = UnsafeBufferPointer<RawTriviaPiece>
 
+fileprivate extension SyntaxKind {
+  /// Whether this node kind should be considered as `hasError` for purposes of `RecursiveRawSyntaxFlags`.
+  var hasError: Bool {
+    return self == .unexpectedNodes || self.isMissing
+  }
+}
+
+struct RecursiveRawSyntaxFlags: OptionSet {
+  let rawValue: UInt8
+
+  /// Whether the tree contained by this layout has any missing or unexpected nodes.
+  static let hasError = RecursiveRawSyntaxFlags(rawValue: 1 << 0)
+}
+
 /// Node data for RawSyntax tree. Tagged union plus common data.
 internal struct RawSyntaxData {
   internal enum Payload {
@@ -54,6 +68,7 @@ internal struct RawSyntaxData {
     var byteLength: Int
     /// Number of nodes in this subtree, excluding this node.
     var descendantCount: Int
+    var recursiveFlags: RecursiveRawSyntaxFlags
   }
 
   fileprivate var payload: Payload
@@ -215,6 +230,19 @@ extension RawSyntax {
     kind.isUnknown
   }
 
+  var recursiveFlags: RecursiveRawSyntaxFlags {
+    switch rawData.payload {
+    case .materializedToken, .parsedToken:
+      var recursiveFlags: RecursiveRawSyntaxFlags = []
+      if presence == .missing {
+        recursiveFlags.insert(.hasError)
+      }
+      return recursiveFlags
+    case .layout(let dat):
+      return dat.recursiveFlags
+    }
+  }
+
   /// Child nodes.
   var children: RawSyntaxBuffer {
     switch rawData.payload {
@@ -815,12 +843,13 @@ extension RawSyntax {
     layout: RawSyntaxBuffer,
     byteLength: Int,
     descendantCount: Int,
+    recursiveFlags: RecursiveRawSyntaxFlags,
     arena: SyntaxArena
   ) -> RawSyntax {
     validateLayout(layout: layout, as: kind)
     let payload = RawSyntaxData.Layout(
       kind: kind, layout: layout,
-      byteLength: byteLength, descendantCount: descendantCount)
+      byteLength: byteLength, descendantCount: descendantCount, recursiveFlags: recursiveFlags)
     return RawSyntax(arena: arena, payload: .layout(payload))
   }
 
@@ -844,23 +873,42 @@ extension RawSyntax {
     // Calculate the "byte width".
     var byteLength = 0
     var descendantCount = 0
+    var recursiveFlags = RecursiveRawSyntaxFlags()
+    if kind.hasError {
+      recursiveFlags.insert(.hasError)
+    }
     for case let node? in layoutBuffer {
       byteLength += node.byteLength
       descendantCount += node.totalNodes
+      recursiveFlags.insert(node.recursiveFlags)
       arena.addChild(node.arenaReference)
     }
     return .layout(
-      kind: kind, layout: RawSyntaxBuffer(layoutBuffer),
-      byteLength: byteLength, descendantCount: descendantCount, arena: arena)
+      kind: kind,
+      layout: RawSyntaxBuffer(layoutBuffer),
+      byteLength: byteLength,
+      descendantCount: descendantCount,
+      recursiveFlags: recursiveFlags,
+      arena: arena
+    )
   }
 
   static func makeEmptyLayout(
     kind: SyntaxKind,
     arena: SyntaxArena
   ) -> RawSyntax {
+    var recursiveFlags = RecursiveRawSyntaxFlags()
+    if kind.hasError {
+      recursiveFlags.insert(.hasError)
+    }
     return .layout(
-      kind: kind, layout: .init(start: nil, count: 0),
-      byteLength: 0, descendantCount: 0, arena: arena)
+      kind: kind,
+      layout: .init(start: nil, count: 0),
+      byteLength: 0,
+      descendantCount: 0,
+      recursiveFlags: recursiveFlags,
+      arena: arena
+    )
   }
 
   static func makeLayout<C: Collection>(

Sources/SwiftSyntax/Syntax.swift

@@ -174,6 +174,11 @@ public extension SyntaxProtocol {
     return raw.kind.isUnknown
   }
 
+  /// Whether this tree contains a missing token or unexpected node.
+  var hasError: Bool {
+    return raw.recursiveFlags.contains(.hasError)
+  }
+
   /// The parent of this syntax node, or `nil` if this node is the root.
   var parent: Syntax? {
     return data.parent

Sources/SwiftSyntax/SyntaxKind.swift.gyb

@@ -49,6 +49,18 @@ internal enum SyntaxKind: CSyntaxKind {
     default: return false
     }
   }
+
+  var isMissing: Bool {
+    switch self {
+% for name in SYNTAX_BASE_KINDS:
+%   if name not in ["Syntax", "SyntaxCollection"]:
+    case .missing${name}: return true
+%   end
+% end
+    case .missing: return true
+    default: return false
+    }
+  }
 }
 
 extension SyntaxKind {

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -339,6 +339,18 @@ internal enum SyntaxKind: CSyntaxKind {
     default: return false
     }
   }
+
+  var isMissing: Bool {
+    switch self {
+    case .missingDecl: return true
+    case .missingExpr: return true
+    case .missingPattern: return true
+    case .missingStmt: return true
+    case .missingType: return true
+    case .missing: return true
+    default: return false
+    }
+  }
 }
 
 extension SyntaxKind {

Tests/SwiftSyntaxTest/SyntaxTests.swift

@@ -0,0 +1,28 @@
+//===--- SyntaxTests.swift ------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import XCTest
+import SwiftSyntax
+
+public class SyntaxTests: XCTestCase {
+
+  public func testHasError() {
+    XCTAssertTrue(TokenSyntax.funcKeyword(presence: .missing).hasError)
+    XCTAssertFalse(TokenSyntax.funcKeyword(presence: .present).hasError)
+    XCTAssertTrue(UnexpectedNodesSyntax([]).hasError)
+    XCTAssertTrue(MissingExprSyntax().hasError)
+    XCTAssertFalse(CodeBlockItemListSyntax([]).hasError)
+
+    XCTAssertTrue(TokenListSyntax([TokenSyntax.funcKeyword(presence: .missing)]).hasError)
+    XCTAssertFalse(TokenListSyntax([TokenSyntax.funcKeyword(presence: .present)]).hasError)
+  }
+}