Merge pull request #13732 from rudkx/add-implicitly-unwrapped-function-conversion-expr

Author: swift-ci

include/swift/AST/Expr.h

@@ -3033,6 +3033,26 @@ class CovariantReturnConversionExpr : public ImplicitConversionExpr {
   }
 };
 
+/// Perform a function conversion from a function returning an
+/// Optional<T> to a function returning T.
+///
+/// This is generated during expression type checking in places where
+/// we need to force the result type of a function being called. When
+/// we go to rewrite the call, we remove this node and force the
+/// result of the call to the underlying function. It should never
+/// exist outside of this final stage of expression type checking.
+class ImplicitlyUnwrappedFunctionConversionExpr
+    : public ImplicitConversionExpr {
+public:
+  ImplicitlyUnwrappedFunctionConversionExpr(Expr *subExpr, Type type)
+      : ImplicitConversionExpr(ExprKind::ImplicitlyUnwrappedFunctionConversion,
+                               subExpr, type) {}
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ImplicitlyUnwrappedFunctionConversion;
+  }
+};
+
 /// MetatypeConversionExpr - Convert a metatype to another metatype
 /// using essentially a derived-to-base conversion.
 class MetatypeConversionExpr : public ImplicitConversionExpr {

include/swift/AST/ExprNodes.def

@@ -138,6 +138,7 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(FunctionConversion, ImplicitConversionExpr)
   EXPR(CovariantFunctionConversion, ImplicitConversionExpr)
   EXPR(CovariantReturnConversion, ImplicitConversionExpr)
+  EXPR(ImplicitlyUnwrappedFunctionConversion, ImplicitConversionExpr)
   EXPR(MetatypeConversion, ImplicitConversionExpr)
   EXPR(CollectionUpcastConversion, ImplicitConversionExpr)
   EXPR(Erasure, ImplicitConversionExpr)

lib/AST/ASTDumper.cpp

@@ -2037,6 +2037,13 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitImplicitlyUnwrappedFunctionConversionExpr(
+      ImplicitlyUnwrappedFunctionConversionExpr *E) {
+    printCommon(E, "implicitly_unwrapped_function_conversion_expr") << '\n';
+    printRec(E->getSubExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitErasureExpr(ErasureExpr *E) {
     printCommon(E, "erasure_expr") << '\n';
     for (auto conf : E->getConformances()) {

lib/AST/Expr.cpp

@@ -486,6 +486,7 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   PASS_THROUGH_REFERENCE(FunctionConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(CovariantFunctionConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(CovariantReturnConversion, getSubExpr);
+  PASS_THROUGH_REFERENCE(ImplicitlyUnwrappedFunctionConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(MetatypeConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(CollectionUpcastConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(Erasure, getSubExpr);
@@ -775,6 +776,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::FunctionConversion:
   case ExprKind::CovariantFunctionConversion:
   case ExprKind::CovariantReturnConversion:
+  case ExprKind::ImplicitlyUnwrappedFunctionConversion:
   case ExprKind::MetatypeConversion:
   case ExprKind::CollectionUpcastConversion:
   case ExprKind::Erasure:

lib/SILGen/SILGenApply.cpp

@@ -1051,6 +1051,13 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     visitExpr(e);
   }
 
+  void visitImplicitlyUnwrappedFunctionConversionExpr(
+      ImplicitlyUnwrappedFunctionConversionExpr *e) {
+    // These are generated for short term use in the type checker.
+    llvm_unreachable(
+        "We should not see ImplicitlyUnwrappedFunctionConversionExpr here");
+  }
+
   void visitIdentityExpr(IdentityExpr *e) {
     visit(e->getSubExpr());
   }

lib/SILGen/SILGenExpr.cpp

@@ -447,6 +447,8 @@ namespace {
     RValue visitCovariantReturnConversionExpr(
              CovariantReturnConversionExpr *E,
              SGFContext C);
+    RValue visitImplicitlyUnwrappedFunctionConversionExpr(
+        ImplicitlyUnwrappedFunctionConversionExpr *E, SGFContext C);
     RValue visitErasureExpr(ErasureExpr *E, SGFContext C);
     RValue visitAnyHashableErasureExpr(AnyHashableErasureExpr *E, SGFContext C);
     RValue visitForcedCheckedCastExpr(ForcedCheckedCastExpr *E,
@@ -2091,6 +2093,13 @@ RValue RValueEmitter::visitCovariantReturnConversionExpr(
   return RValue(SGF, e, result);
 }
 
+RValue RValueEmitter::visitImplicitlyUnwrappedFunctionConversionExpr(
+    ImplicitlyUnwrappedFunctionConversionExpr *e, SGFContext C) {
+  // These are generated for short term use in the type checker.
+  llvm_unreachable(
+      "We should not see ImplicitlyUnwrappedFunctionConversionExpr here");
+}
+
 RValue RValueEmitter::visitErasureExpr(ErasureExpr *E, SGFContext C) {
   if (auto result = tryEmitAsBridgingConversion(SGF, E, false, C)) {
     return RValue(SGF, E, *result);