Merge pull request #76978 from rintaro/astgen-placeholderexpr

[ASTGen] Generate EditorPlaceholderExpr and 'do' expressions

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -1321,6 +1321,13 @@ BridgedDotSelfExpr BridgedDotSelfExpr_createParsed(BridgedASTContext cContext,
                                                    BridgedSourceLoc cDotLoc,
                                                    BridgedSourceLoc cSelfLoc);
 
+SWIFT_NAME("BridgedEditorPlaceholderExpr.createParsed(_:placeholder:loc:"
+           "placeholderType:expansionType:)")
+BridgedEditorPlaceholderExpr BridgedEditorPlaceholderExpr_createParsed(
+    BridgedASTContext cContext, BridgedIdentifier cPlaceholderId,
+    BridgedSourceLoc cLoc, BridgedNullableTypeRepr cPlaceholderTyR,
+    BridgedNullableTypeRepr cExpansionTyR);
+
 SWIFT_NAME("BridgedErrorExpr.create(_:loc:)")
 BridgedErrorExpr BridgedErrorExpr_create(BridgedASTContext cContext,
                                          BridgedSourceRange cRange);

lib/AST/Bridging/ExprBridging.cpp

@@ -198,6 +198,15 @@ BridgedDotSelfExpr BridgedDotSelfExpr_createParsed(BridgedASTContext cContext,
       cSubExpr.unbridged(), cDotLoc.unbridged(), cSelfLoc.unbridged());
 }
 
+BridgedEditorPlaceholderExpr BridgedEditorPlaceholderExpr_createParsed(
+    BridgedASTContext cContext, BridgedIdentifier cPlaceholderId,
+    BridgedSourceLoc cLoc, BridgedNullableTypeRepr cPlaceholderTyR,
+    BridgedNullableTypeRepr cExpansionTyR) {
+  return new (cContext.unbridged()) EditorPlaceholderExpr(
+      cPlaceholderId.unbridged(), cLoc.unbridged(), cPlaceholderTyR.unbridged(),
+      cExpansionTyR.unbridged());
+}
+
 BridgedErrorExpr BridgedErrorExpr_create(BridgedASTContext cContext,
                                          BridgedSourceRange cRange) {
   return new (cContext.unbridged()) ErrorExpr(cRange.unbridged());

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -12,6 +12,7 @@
 
 import ASTBridging
 import SwiftDiagnostics
+@_spi(Compiler) import SwiftParser
 @_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
 
 /// Check if an `ExprSyntax` can be generated using ASTGen.
@@ -42,20 +43,18 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
     // Known implemented kinds.
     case .asExpr, .arrayExpr, .arrowExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr,
       .booleanLiteralExpr, .borrowExpr, .closureExpr, .consumeExpr, .copyExpr,
-      .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr, .floatLiteralExpr,
-      .functionCallExpr, .ifExpr,
-      .infixOperatorExpr, .inOutExpr, .integerLiteralExpr, .memberAccessExpr,
+      .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr, .doExpr,
+      .editorPlaceholderExpr, .floatLiteralExpr, .functionCallExpr, .genericSpecializationExpr,
+      .ifExpr, .infixOperatorExpr, .inOutExpr, .integerLiteralExpr, .isExpr, .memberAccessExpr,
       .nilLiteralExpr, .packElementExpr, .packExpansionExpr, .patternExpr,
       .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr,
       .simpleStringLiteralExpr, .subscriptCallExpr, .stringLiteralExpr, .superExpr,
-      .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr,
+      .switchExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr,
       .unresolvedTernaryExpr, .ternaryExpr:
       break
 
     // Known unimplemented kinds.
-    case .doExpr, .editorPlaceholderExpr, .forceUnwrapExpr, .isExpr, .keyPathExpr, .macroExpansionExpr,
-      .optionalChainingExpr, .postfixIfConfigExpr, .genericSpecializationExpr,
-      .switchExpr:
+    case .forceUnwrapExpr, .keyPathExpr, .macroExpansionExpr, .optionalChainingExpr, .postfixIfConfigExpr:
       return false
 
     // Unknown expr kinds.
@@ -102,15 +101,15 @@ extension ASTGenVisitor {
     case .copyExpr(let node):
       return self.generate(copyExpr: node).asExpr
     case .declReferenceExpr(let node):
-      return self.generate(declReferenceExpr: node).asExpr
+      return self.generate(declReferenceExpr: node)
     case .dictionaryExpr(let node):
       return self.generate(dictionaryExpr: node).asExpr
     case .discardAssignmentExpr(let node):
       return self.generate(discardAssignmentExpr: node).asExpr
-    case .doExpr:
-      break
+    case .doExpr(let node):
+      return self.generate(doExpr: node).asExpr
     case .editorPlaceholderExpr:
-      break
+      preconditionFailure("EditorPlaceholderExpr is no longer generated by the parser")
     case .floatLiteralExpr(let node):
       return self.generate(floatLiteralExpr: node).asExpr
     case .forceUnwrapExpr:
@@ -128,7 +127,7 @@ extension ASTGenVisitor {
     case .integerLiteralExpr(let node):
       return self.generate(integerLiteralExpr: node).asExpr
     case .isExpr:
-      break
+      preconditionFailure("IsExprSyntax only appear after operator folding")
     case .keyPathExpr:
       break
     case .macroExpansionExpr:
@@ -428,20 +427,67 @@ extension ASTGenVisitor {
     }
   }
 
-  func generate(declReferenceExpr node: DeclReferenceExprSyntax) -> BridgedUnresolvedDeclRefExpr {
-    let nameAndLoc = generateDeclNameRef(declReferenceExpr: node)
+  func generateEditorPlaceholderExpr(token: TokenSyntax) -> BridgedEditorPlaceholderExpr {
+    guard let data = token.rawEditorPlaceHolderData else {
+      preconditionFailure("EditorPlaceholderExprSyntax.placeholder must be a placeholder token")
+    }
+    let (identifier, loc) = self.generateIdentifierAndSourceLoc(token)
+    let placeholderTyR: BridgedTypeRepr?
+    let expansionTyR: BridgedTypeRepr?
+    func parseType(text: SyntaxText) -> BridgedTypeRepr {
+      var parser = Parser(UnsafeBufferPointer(start: text.baseAddress, count: text.count))
+      let syntax = TypeSyntax.parse(from: &parser)
+      return self.generate(type: syntax)
+    }
+    if let typeText = data.typeText {
+      placeholderTyR = parseType(text: typeText)
+    } else {
+      placeholderTyR = nil
+    }
+    if data.typeText == data.typeForExpansionText {
+      expansionTyR = placeholderTyR
+    } else {
+      // `typeForExpansionText` is guaranteed to be non-nil if `typeText` is non-nil,
+      expansionTyR = parseType(text: data.typeForExpansionText!)
+    }
     return .createParsed(
+      self.ctx,
+      placeholder: identifier,
+      loc: loc,
+      placeholderType: placeholderTyR.asNullable,
+      expansionType: expansionTyR.asNullable
+    )
+  }
+
+  func generate(declReferenceExpr node: DeclReferenceExprSyntax) -> BridgedExpr {
+    if node.baseName.isEditorPlaceholder {
+      return generateEditorPlaceholderExpr(token: node.baseName).asExpr
+    }
+    let nameAndLoc = generateDeclNameRef(declReferenceExpr: node)
+    return BridgedUnresolvedDeclRefExpr.createParsed(
       self.ctx,
       name: nameAndLoc.name,
       kind: .ordinary,
       loc: nameAndLoc.loc
-    )
+    ).asExpr
   }
 
   func generate(discardAssignmentExpr node: DiscardAssignmentExprSyntax) -> BridgedDiscardAssignmentExpr {
     return .createParsed(self.ctx, loc: self.generateSourceLoc(node.wildcard))
   }
 
+  func generate(doExpr node: DoExprSyntax) -> BridgedSingleValueStmtExpr {
+    let stmt = self.generate(doStmtOrExpr: node)
+
+    // Wrap in a SingleValueStmtExpr to embed as an expression.
+    return .createWithWrappedBranches(
+      ctx,
+      stmt: stmt,
+      declContext: declContext,
+      mustBeExpr: true
+    )
+  }
+
   func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr {
     let dotLoc = self.generateSourceLoc(node.period)
     let nameAndLoc = generateDeclNameRef(declReferenceExpr: node.declName)

lib/ASTGen/Sources/ASTGen/Stmts.swift

@@ -14,6 +14,18 @@ import ASTBridging
 import SwiftDiagnostics
 @_spi(ExperimentalLanguageFeatures) import SwiftSyntax
 
+protocol DoStmtOrExprSyntax {
+  var doKeyword: TokenSyntax { get }
+  var throwsClause: ThrowsClauseSyntax? { get }
+  var body: CodeBlockSyntax { get }
+  var catchClauses: CatchClauseListSyntax { get }
+}
+extension DoStmtSyntax: DoStmtOrExprSyntax {}
+extension DoExprSyntax: DoStmtOrExprSyntax {
+  // FIXME: DoExprSyntax is missing throwsClause?
+  var throwsClause: ThrowsClauseSyntax? { return nil }
+}
+
 extension ASTGenVisitor {
   func generate(stmt node: StmtSyntax) -> BridgedStmt {
     switch node.as(StmtSyntaxEnum.self) {
@@ -262,6 +274,13 @@ extension ASTGenVisitor {
   }
 
   func generate(doStmt node: DoStmtSyntax, labelInfo: BridgedLabeledStmtInfo = nil) -> BridgedStmt {
+    return self.generate(doStmtOrExpr: node, labelInfo: labelInfo)
+  }
+
+  func generate(
+    doStmtOrExpr node: some DoStmtOrExprSyntax,
+    labelInfo: BridgedLabeledStmtInfo = nil
+  ) -> BridgedStmt {
     if node.catchClauses.isEmpty {
       // FIXME: Handle
       precondition(node.throwsClause == nil)

lib/Parse/ParseDecl.cpp

@@ -356,9 +356,11 @@ void Parser::parseSourceFileViaASTGen(
                                        appendToVector);
 
     // Spin the C++ parser to the end; we won't be using it.
+    DiagnosticTransaction noDiag(Context.Diags);
     while (!Tok.is(tok::eof)) {
       consumeToken();
     }
+    noDiag.abort();
   }
 #endif
 }

test/ASTGen/diagnostics.swift

@@ -0,0 +1,30 @@
+// RUN: %empty-directory(%t)
+
+// RUN: not %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-bare-slash-regex -enable-experimental-feature ParserASTGen > %t/astgen.ast.raw
+// RUN: not %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-bare-slash-regex > %t/cpp-parser.ast.raw
+
+// Filter out any addresses in the dump, since they can differ.
+// RUN: sed -E 's#0x[0-9a-fA-F]+##g' %t/cpp-parser.ast.raw > %t/cpp-parser.ast
+// RUN: sed -E 's#0x[0-9a-fA-F]+##g' %t/astgen.ast.raw > %t/astgen.ast
+
+// RUN: %diff -u %t/astgen.ast %t/cpp-parser.ast
+
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-bare-slash-regex -enable-experimental-feature ParserASTGen
+
+// REQUIRES: swift_swift_parser
+// -enable-experimental-feature requires an asserts build
+// REQUIRES: asserts
+// rdar://116686158
+// UNSUPPORTED: asan
+
+func testRegexLiteral() {
+  _ = (#/[*/#, #/+]/#, #/.]/#)
+  // expected-error@-1:18 {{cannot parse regular expression: quantifier '+' must appear after expression}}
+  // expected-error@-2:12 {{cannot parse regular expression: expected ']'}}
+}
+
+func testEditorPlaceholder() -> Int {
+  func foo(_ x: String) {}
+  foo(<#T##x: String##String#>) // expected-error {{editor placeholder in source file}})
+  return <#T##Int#> // expected-error {{editor placeholder in source file}}
+}

test/ASTGen/do_expr.swift

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-experimental-feature DoExpressions -enable-experimental-feature ParserASTGen > %t/astgen.ast.raw
+// RUN: %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-experimental-feature DoExpressions > %t/cpp-parser.ast.raw
+
+// Filter out any addresses in the dump, since they can differ.
+// RUN: sed -E 's#0x[0-9a-fA-F]+##g' %t/cpp-parser.ast.raw > %t/cpp-parser.ast
+// RUN: sed -E 's#0x[0-9a-fA-F]+##g' %t/astgen.ast.raw > %t/astgen.ast
+
+// RUN: %diff -u %t/astgen.ast %t/cpp-parser.ast
+
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-feature DoExpressions -enable-experimental-feature ParserASTGen
+
+// REQUIRES: swift_swift_parser
+// -enable-experimental-feature requires an asserts build
+// REQUIRES: asserts
+// rdar://116686158
+// UNSUPPORTED: asan
+
+func fn() async throws -> Int { 6 }
+struct Err: Error {}
+
+func testDoExpr() async throws {
+  let _: Int = do { 5 }
+  let _: Int = do { try await fn() } catch { throw Err() }
+}