[SwiftParser] Support function body and type member skipping

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -2270,4 +2270,21 @@ public let DECL_NODES: [Node] = [
       ),
     ]
   ),
+
+  Node(
+    kind: .skippedDecl,
+    base: .decl,
+    nameForDiagnostics: "skipped body",
+    documentation: """
+      Represent skipped portion of the source.
+      """,
+    traits: [],
+    children: [
+      Child(
+        name: "text",
+        kind: .token(choices: [.token(.unknown)]),
+        nameForDiagnostics: "text"
+      ),
+    ]
+  ),
 ]

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -252,6 +252,7 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case stmt
   case simpleStringLiteralExpr
   case simpleStringLiteralSegmentList
+  case skippedDecl
   case stringLiteralExpr
   case stringLiteralSegmentList
   case stringSegment

Sources/SwiftParser/CMakeLists.txt

@@ -12,6 +12,7 @@ add_swift_syntax_library(SwiftParser
   CharacterInfo.swift
   CollectionNodes+Parsable.swift
   Declarations.swift
+  DelayedParsing.swift
   Directives.swift
   Expressions.swift
   IncrementalParseTransition.swift

Sources/SwiftParser/Declarations.swift

@@ -383,7 +383,7 @@ extension Parser {
     } else {
       whereClause = nil
     }
-    let memberBlock = self.parseMemberBlock(introducer: extensionKeyword)
+    let memberBlock = self.parseMemberBlock(introducer: extensionKeyword, allowSkip: true)
     return RawExtensionDeclSyntax(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,
@@ -777,9 +777,19 @@ extension Parser {
   /// `introducer` is the `struct`, `class`, ... keyword that is the cause that the member decl block is being parsed.
   /// If the left brace is missing, its indentation will be used to judge whether a following `}` was
   /// indented to close this code block or a surrounding context. See `expectRightBrace`.
-  mutating func parseMemberBlock(introducer: RawTokenSyntax? = nil) -> RawMemberBlockSyntax {
+  mutating func parseMemberBlock(introducer: RawTokenSyntax? = nil, allowSkip: Bool = false) -> RawMemberBlockSyntax {
     let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
-    let members = parseMemberDeclList()
+
+    let members: RawMemberBlockItemListSyntax
+    if allowSkip,
+       self.options.contains(.bodySkipping),
+       let skipped = self.skippedMemberBody() {
+      let member = RawMemberBlockItemSyntax(decl: .init(skipped), semicolon: nil, arena: self.arena)
+      members = RawMemberBlockItemListSyntax(elements: [member], arena: self.arena)
+    } else {
+      members = parseMemberDeclList()
+    }
+
     let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: introducer)
 
     return RawMemberBlockSyntax(

Sources/SwiftParser/DelayedParsing.swift

@@ -0,0 +1,117 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(RawSyntax) import SwiftSyntax
+
+extension Parser {
+  mutating func skippedFunctionBody() -> RawSkippedDeclSyntax? {
+    return self.skippedBraceBody(while: { tokenKind, tokenText in
+      // If the function body contains a type decl, don't skip.
+      if tokenKind == .keyword && (
+        tokenText == "enum" ||
+        tokenText == "struct" ||
+        tokenText == "class" ||
+        tokenText == "actor"
+      ) {
+        return false
+      }
+      return true
+    })
+  }
+
+  mutating func skippedMemberBody() -> RawSkippedDeclSyntax? {
+    var lastTokenWasFunc: Bool = false
+    return self.skippedBraceBody(while: { tokenKind, tokenText in
+
+      // '#' directives.
+      if tokenKind == .poundIf || tokenKind == .poundSourceLocation {
+        return false
+      }
+
+      // Nested class. Because?
+      if tokenKind == .keyword && tokenText == "class" {
+        return false
+      }
+
+      // Operator functions. Because they're visible from top-level.
+      if lastTokenWasFunc && (
+        tokenKind == .binaryOperator || tokenKind == .prefixOperator || tokenKind == .postfixOperator
+      ) {
+        return false
+      }
+      lastTokenWasFunc = tokenKind == .keyword && tokenText == "func"
+
+      return true
+    })
+  }
+
+  fileprivate mutating func skippedBraceBody(while condition: (_ tokenKind: RawTokenKind, _ tokenText: SyntaxText) -> Bool) -> RawSkippedDeclSyntax? {
+    return self.withLookahead { lookahead in
+      guard lookahead.advanceUntilMatchingRightBrace(while: condition) == .reachedToEnd else {
+        return nil
+      }
+
+      // Skipped region as a single SyntaxText.
+      let wholeText = SyntaxText(
+        baseAddress: self.currentToken.start,
+        count: self.currentToken.start.distance(to: lookahead.currentToken.start)
+      )
+
+      // Advance the Lexer to skipped position.
+      self.currentToken = lookahead.currentToken
+      self.lexemes = lookahead.lexemes
+
+      // Represent the skipped range with a single .unknown token.
+      let tok =  RawTokenSyntax(
+        kind: .unknown,
+        wholeText: wholeText,
+        textRange: wholeText.startIndex..<wholeText.endIndex,
+        presence: .present,
+        tokenDiagnostic: nil,
+        arena: self.arena
+      )
+      return RawSkippedDeclSyntax(text: tok, arena: self.arena)
+    }
+  }
+}
+
+fileprivate extension Parser.Lookahead {
+  enum SkipBodyResult {
+    case aborted
+    case reachedToEnd
+  }
+
+  mutating func advanceUntilMatchingRightBrace(while condition: (_ tokenKind: RawTokenKind, _ tokenText: SyntaxText) -> Bool) -> SkipBodyResult {
+    var openBraces = 1
+
+    while self.currentToken.rawTokenKind != .endOfFile {
+      let tokenKind = currentToken.rawTokenKind
+      let tokenText = currentToken.tokenText
+
+      guard condition(tokenKind, tokenText) else {
+        return .aborted
+      }
+
+      if tokenKind == .leftBrace {
+        openBraces += 1
+      } else if tokenKind == .rightBrace {
+        openBraces -= 1
+        if openBraces == 0 {
+          break
+        }
+      }
+      self.consumeAnyToken()
+    }
+
+    return .reachedToEnd
+  }
+}

Sources/SwiftParser/Nominals.swift

@@ -254,7 +254,7 @@ extension Parser {
       whereClause = nil
     }
 
-    let memberBlock = self.parseMemberBlock(introducer: introducerKeyword)
+    let memberBlock = self.parseMemberBlock(introducer: introducerKeyword, allowSkip: true)
     return T.init(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,

Sources/SwiftParser/ParseSourceFile.swift

@@ -16,29 +16,32 @@ extension Parser {
   /// Parse the source code in the given string as Swift source file. See
   /// `Parser.init` for more details.
   public static func parse(
-    source: String
+    source: String,
+    options: ParsingOptions = []
   ) -> SourceFileSyntax {
-    var parser = Parser(source)
+    var parser = Parser(source, options: options)
     return SourceFileSyntax.parse(from: &parser)
   }
 
   /// A compiler interface that allows the enabling of experimental features.
   @_spi(ExperimentalLanguageFeatures)
   public static func parse(
     source: UnsafeBufferPointer<UInt8>,
-    experimentalFeatures: ExperimentalFeatures
+    experimentalFeatures: ExperimentalFeatures,
+    options: ParsingOptions = []
   ) -> SourceFileSyntax {
-    var parser = Parser(source, experimentalFeatures: experimentalFeatures)
+    var parser = Parser(source, experimentalFeatures: experimentalFeatures, options: options)
     return SourceFileSyntax.parse(from: &parser)
   }
 
   /// Parse the source code in the given buffer as Swift source file. See
   /// `Parser.init` for more details.
   public static func parse(
     source: UnsafeBufferPointer<UInt8>,
-    maximumNestingLevel: Int? = nil
+    maximumNestingLevel: Int? = nil,
+    options: ParsingOptions = []
   ) -> SourceFileSyntax {
-    var parser = Parser(source, maximumNestingLevel: maximumNestingLevel)
+    var parser = Parser(source, maximumNestingLevel: maximumNestingLevel, options: options)
     return SourceFileSyntax.parse(from: &parser)
   }
 

Sources/SwiftParser/Parser.swift

@@ -87,6 +87,17 @@
 /// tokens as needed to disambiguate a parse. However, because lookahead
 /// operates on a copy of the lexical stream, no input tokens are lost..
 public struct Parser {
+  public struct ParsingOptions: OptionSet {
+    public let rawValue: UInt8
+    public init(rawValue: UInt8) {
+      self.rawValue = rawValue
+    }
+
+    public static let bodySkipping = Self(rawValue: 1 << 0)
+  }
+
+  var options: ParsingOptions
+
   var arena: ParsingSyntaxArena
 
   /// A view of the sequence of lexemes in the input.
@@ -168,7 +179,7 @@ public struct Parser {
     return _emptyRawAttributeListSyntax!
   }
 
-  /// The delegated initializer for the parser.
+  /// The designated initializer for the parser.
   ///
   /// - Parameters
   ///   - input: An input buffer containing Swift source text. If a non-`nil`
@@ -193,8 +204,10 @@ public struct Parser {
     maximumNestingLevel: Int?,
     parseTransition: IncrementalParseTransition?,
     arena: ParsingSyntaxArena?,
-    experimentalFeatures: ExperimentalFeatures
+    experimentalFeatures: ExperimentalFeatures,
+    options: ParsingOptions
   ) {
+    self.options = options
     var input = input
     if let arena {
       self.arena = arena
@@ -224,7 +237,8 @@ public struct Parser {
     string input: String,
     maximumNestingLevel: Int?,
     parseTransition: IncrementalParseTransition?,
-    experimentalFeatures: ExperimentalFeatures
+    experimentalFeatures: ExperimentalFeatures,
+    options: ParsingOptions
   ) {
     var input = input
     input.makeContiguousUTF8()
@@ -234,7 +248,8 @@ public struct Parser {
         maximumNestingLevel: maximumNestingLevel,
         parseTransition: parseTransition,
         arena: nil,
-        experimentalFeatures: experimentalFeatures
+        experimentalFeatures: experimentalFeatures,
+        options: options
       )
     }
   }
@@ -243,14 +258,16 @@ public struct Parser {
   public init(
     _ input: String,
     maximumNestingLevel: Int? = nil,
-    parseTransition: IncrementalParseTransition? = nil
+    parseTransition: IncrementalParseTransition? = nil,
+    options: ParsingOptions = []
   ) {
     // Chain to the private String initializer.
     self.init(
       string: input,
       maximumNestingLevel: maximumNestingLevel,
       parseTransition: parseTransition,
-      experimentalFeatures: []
+      experimentalFeatures: [],
+      options: options
     )
   }
 
@@ -277,15 +294,17 @@ public struct Parser {
     _ input: UnsafeBufferPointer<UInt8>,
     maximumNestingLevel: Int? = nil,
     parseTransition: IncrementalParseTransition? = nil,
-    arena: ParsingSyntaxArena? = nil
+    arena: ParsingSyntaxArena? = nil,
+    options: ParsingOptions = []
   ) {
     // Chain to the private buffer initializer.
     self.init(
       buffer: input,
       maximumNestingLevel: maximumNestingLevel,
       parseTransition: parseTransition,
       arena: arena,
-      experimentalFeatures: []
+      experimentalFeatures: [],
+      options: options
     )
   }
 
@@ -296,14 +315,16 @@ public struct Parser {
     _ input: String,
     maximumNestingLevel: Int? = nil,
     parseTransition: IncrementalParseTransition? = nil,
-    experimentalFeatures: ExperimentalFeatures
+    experimentalFeatures: ExperimentalFeatures,
+    options: ParsingOptions = []
   ) {
     // Chain to the private String initializer.
     self.init(
       string: input,
       maximumNestingLevel: maximumNestingLevel,
       parseTransition: parseTransition,
-      experimentalFeatures: experimentalFeatures
+      experimentalFeatures: experimentalFeatures,
+      options: options
     )
   }
 
@@ -315,15 +336,17 @@ public struct Parser {
     maximumNestingLevel: Int? = nil,
     parseTransition: IncrementalParseTransition? = nil,
     arena: ParsingSyntaxArena? = nil,
-    experimentalFeatures: ExperimentalFeatures
+    experimentalFeatures: ExperimentalFeatures,
+    options: ParsingOptions = []
   ) {
     // Chain to the private buffer initializer.
     self.init(
       buffer: input,
       maximumNestingLevel: maximumNestingLevel,
       parseTransition: parseTransition,
       arena: arena,
-      experimentalFeatures: experimentalFeatures
+      experimentalFeatures: experimentalFeatures,
+      options: options
     )
   }