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

@@ -36,6 +36,8 @@ internal struct RawSyntaxData {
     var byteLength: Int
     /// Number of nodes in this subtree, excluding this node.
     var descendantCount: Int
+    /// Whether the tree contained by this layout has any missing or unexpected nodes.
+    var hasError: Bool
   }
 
   fileprivate var payload: Payload
@@ -172,6 +174,13 @@ extension RawSyntax {
     kind.isUnknown
   }
 
+  var hasError: Bool {
+    switch rawData.payload {
+    case .materializedToken(_): return self.presence == .missing
+    case .layout(let dat): return dat.hasError
+    }
+  }
+
   /// Child nodes.
   var children: RawSyntaxBuffer {
     switch rawData.payload {
@@ -736,9 +745,20 @@ extension RawSyntax {
     arena: SyntaxArena
   ) -> RawSyntax {
     validateLayout(layout: layout, as: kind)
+    var hasError = false
+    if kind == .unexpectedNodes || kind.isMissing {
+      hasError = true
+    } else {
+      for node in layout {
+        if let node = node, node.hasError {
+          hasError = true
+          break
+        }
+      }
+    }
     let payload = RawSyntaxData.Layout(
       kind: kind, layout: layout,
-      byteLength: byteLength, descendantCount: descendantCount)
+      byteLength: byteLength, descendantCount: descendantCount, hasError: hasError)
     return RawSyntax(arena: arena, payload: .layout(payload))
   }
 

Sources/SwiftSyntax/Syntax.swift

@@ -173,6 +173,11 @@ public extension SyntaxProtocol {
     return raw.kind.isUnknown
   }
 
+  /// Whether this tree contains a missing token or unexpected node.
+  var hasError: Bool {
+    return raw.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)
+  }
+}