[ASTGen] Handle several missing syntax

* MissingExpr: Generate ErrorExpr with previous token location
* MissingType: Generate ErrorTypeRepr with previous token location
* MissingPattern: Generate implicit '_' pattern for recovery

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -2790,6 +2790,9 @@ SWIFT_NAME("BridgedAnyPattern.createParsed(_:loc:)")
 BridgedAnyPattern BridgedAnyPattern_createParsed(BridgedASTContext cContext,
                                                  BridgedSourceLoc cLoc);
 
+SWIFT_NAME("BridgedAnyPattern.createImplicit(_:)")
+BridgedAnyPattern BridgedAnyPattern_createImplicit(BridgedASTContext cContext);
+
 SWIFT_NAME("BridgedBindingPattern.createParsed(_:keywordLoc:isLet:subPattern:)")
 BridgedBindingPattern
 BridgedBindingPattern_createParsed(BridgedASTContext cContext,

lib/AST/Bridging/PatternBridging.cpp

@@ -42,6 +42,10 @@ BridgedAnyPattern BridgedAnyPattern_createParsed(BridgedASTContext cContext,
   return new (cContext.unbridged()) AnyPattern(cLoc.unbridged());
 }
 
+BridgedAnyPattern BridgedAnyPattern_createImplicit(BridgedASTContext cContext) {
+  return AnyPattern::createImplicit(cContext.unbridged());
+}
+
 BridgedBindingPattern
 BridgedBindingPattern_createParsed(BridgedASTContext cContext,
                                    BridgedSourceLoc cKeywordLoc, bool isLet,

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -74,8 +74,8 @@ extension ASTGenVisitor {
       return self.generate(macroExpansionExpr: node)
     case .memberAccessExpr(let node):
       return self.generate(memberAccessExpr: node)
-    case .missingExpr:
-      fatalError("unimplemented")
+    case .missingExpr(let node):
+      return self.generate(missingExpr: node)
     case .nilLiteralExpr(let node):
       return self.generate(nilLiteralExpr: node).asExpr
     case .optionalChainingExpr(let node):
@@ -931,6 +931,14 @@ extension ASTGenVisitor {
     }
   }
 
+  func generate(missingExpr node: MissingExprSyntax) -> BridgedExpr {
+    let loc = self.generateSourceLoc(node.previousToken(viewMode: .sourceAccurate))
+    return BridgedErrorExpr.create(
+      self.ctx,
+      loc: BridgedSourceRange(start: loc, end: loc)
+    ).asExpr
+  }
+
   func generate(genericSpecializationExpr node: GenericSpecializationExprSyntax) -> BridgedUnresolvedSpecializeExpr {
     let base = self.generate(expr: node.expression)
     let generics = node.genericArgumentClause

lib/ASTGen/Sources/ASTGen/Patterns.swift

@@ -77,7 +77,8 @@ extension ASTGenVisitor {
   }
 
   func generate(missingPattern node: MissingPatternSyntax) -> BridgedPattern {
-    fatalError("unimplemented")
+    // Recover by creating implicit '_' pattern.
+    return BridgedAnyPattern.createImplicit(self.ctx).asPattern
   }
 
   func generate(tuplePattern node: TuplePatternSyntax) -> BridgedPattern {

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -176,9 +176,10 @@ extension ASTGenVisitor {
   }
 
   func generate(missingType node: MissingTypeSyntax) -> BridgedTypeRepr {
+    let loc = self.generateSourceLoc(node.previousToken(viewMode: .sourceAccurate))
     return BridgedErrorTypeRepr.create(
       self.ctx,
-      range: self.generateSourceRange(node)
+      range: BridgedSourceRange(start: loc, end: loc)
     ).asTypeRepr
   }
 

test/ASTGen/diagnostics.swift

@@ -51,3 +51,18 @@ class TestDiagnosticInNominalTy {
 #if FLAG_NOT_ENABLED
   #error("error in inactive") // no diagnostis
 #endif
+
+func misisngExprTest() {
+  func fn(x: Int, y: Int) {}
+  fn(x: 1, y:) // expected-error {{expected value in function call}}
+               // expected-note@-1 {{insert value}} {{14-14= <#expression#>}}
+}
+
+func misisngTypeTest() {
+  func fn() -> {} // expected-error {{expected return type in function signature}}
+                  // expected-note@-1 {{insert return type}} {{16-16=<#type#> }}
+}
+func misisngPatternTest(arr: [Int]) {
+  for {} // expected-error {{expected pattern, 'in', and expression in 'for' statement}}
+         // expected-note@-1 {{insert pattern, 'in', and expression}} {{7-7=<#pattern#> }} {{7-7=in }} {{7-7=<#expression#> }}
+}