[CS] Remove CTP_ImpliedReturnStmt

Unify with `CTP_ReturnStmt`, and have the
SyntacticElementTarget carry the ReturnStmt for
regular type-checking, which we can use to record
implied returns.

Author: hamishknight

include/swift/Sema/ConstraintLocator.h

@@ -50,8 +50,6 @@ enum ContextualTypePurpose : uint8_t {
   CTP_Unused,            ///< No contextual type is specified.
   CTP_Initialization,    ///< Pattern binding initialization.
   CTP_ReturnStmt,        ///< Value specified to a 'return' statement.
-  CTP_ImpliedReturnStmt, ///< Value from an implied 'return', e.g a single expr
-                         ///  function body.
   CTP_YieldByValue,      ///< By-value yield operand.
   CTP_YieldByReference,  ///< By-reference yield operand.
   CTP_ThrowStmt,         ///< Value specified to a 'throw' statement.

include/swift/Sema/ConstraintSystem.h

@@ -1469,8 +1469,8 @@ struct PotentialThrowSite {
 };
 
 enum class ImpliedResultKind {
-  /// A regular implied result, this applies to e.g implied 'then' statements
-  /// outside of closures.
+  /// A regular implied result, this applies to e.g single expression bodies of
+  /// function decls, and implied 'then' statements outside of closures.
   Regular,
 
   /// An implied result for a closure, e.g a single expression body.

include/swift/Sema/SyntacticElementTarget.h

@@ -91,6 +91,9 @@ class SyntacticElementTarget {
       /// pattern.
       Pattern *pattern;
 
+      /// The parent return statement if any.
+      ReturnStmt *parentReturnStmt;
+
       struct {
         /// The variable to which property wrappers have been applied, if
         /// this is an initialization involving a property wrapper.
@@ -261,6 +264,10 @@ class SyntacticElementTarget {
                     PatternBindingDecl *patternBinding,
                     unsigned patternBindingIndex, bool bindPatternVarsOneWay);
 
+  /// Form an expression target for a ReturnStmt.
+  static SyntacticElementTarget
+  forReturn(ReturnStmt *returnStmt, Type contextTy, DeclContext *dc);
+
   /// Form a target for a for-in loop.
   static SyntacticElementTarget
   forForEachStmt(ForEachStmt *stmt, DeclContext *dc,
@@ -457,6 +464,11 @@ class SyntacticElementTarget {
     return cast<ExprPattern>(expression.pattern);
   }
 
+  ReturnStmt *getParentReturnStmt() const {
+    assert(kind == Kind::expression);
+    return expression.parentReturnStmt;
+  }
+
   Type getClosureContextualType() const {
     assert(kind == Kind::closure);
     return closure.convertType;

lib/IDE/TypeCheckCompletionCallback.cpp

@@ -156,10 +156,6 @@ void WithSolutionSpecificVarTypesRAII::setInterfaceType(VarDecl *VD, Type Ty) {
 }
 
 bool swift::ide::isImpliedResult(const Solution &S, Expr *CompletionExpr) {
-  auto &CS = S.getConstraintSystem();
-  if (CS.getContextualTypePurpose(CompletionExpr) == CTP_ImpliedReturnStmt)
-    return true;
-
   return S.isImpliedResult(CompletionExpr).has_value();
 }
 

lib/Sema/CSApply.cpp

@@ -9430,7 +9430,6 @@ ExprWalker::rewriteTarget(SyntacticElementTarget target) {
     case CTP_ExprPattern:
     case CTP_ForEachStmt:
     case CTP_ForEachSequence:
-    case CTP_ImpliedReturnStmt:
     case CTP_YieldByValue:
     case CTP_YieldByReference:
     case CTP_ThrowStmt:
@@ -9637,8 +9636,7 @@ ExprWalker::rewriteTarget(SyntacticElementTarget target) {
 
       if (solution.simplifyType(convertType)->isVoid()) {
         auto contextPurpose = cs.getContextualTypePurpose(target.getAsExpr());
-        if (contextPurpose == CTP_ImpliedReturnStmt ||
-            contextPurpose == CTP_ClosureResult ||
+        if (contextPurpose == CTP_ClosureResult ||
             contextPurpose == CTP_SingleValueStmtBranch) {
           return false;
         }

lib/Sema/CSDiagnostics.cpp

@@ -306,10 +306,8 @@ ValueDecl *RequirementFailure::getDeclRef() const {
     // and its contextual requirements, it means that affected declaration
     // is a declarer of a contextual "result" type e.g. member of a
     // type, local function etc.
-    if (contextualPurpose == CTP_ReturnStmt ||
-        contextualPurpose == CTP_ImpliedReturnStmt) {
+    if (contextualPurpose == CTP_ReturnStmt)
       return cast<ValueDecl>(getDC()->getAsDecl());
-    }
 
     if (contextualPurpose == CTP_DefaultParameter ||
         contextualPurpose == CTP_AutoclosureDefaultParameter) {
@@ -772,7 +770,6 @@ GenericArgumentsMismatchFailure::getDiagnosticFor(
   case CTP_AssignSource:
     return diag::cannot_convert_assign;
   case CTP_ReturnStmt:
-  case CTP_ImpliedReturnStmt:
     return diag::cannot_convert_to_return_type;
   case CTP_DefaultParameter:
   case CTP_AutoclosureDefaultParameter:
@@ -2483,7 +2480,7 @@ bool ContextualFailure::diagnoseAsError() {
   auto anchor = getAnchor();
   auto path = getLocator()->getPath();
 
-  if (CTP == CTP_ImpliedReturnStmt || CTP == CTP_ReturnStmt) {
+  if (CTP == CTP_ReturnStmt) {
     // Special case the "conversion to void".
     if (getToType()->isVoid()) {
       emitDiagnostic(diag::cannot_return_value_from_void_func)
@@ -2824,7 +2821,6 @@ getContextualNilDiagnostic(ContextualTypePurpose CTP) {
   case CTP_Initialization:
     return diag::cannot_convert_initializer_value_nil;
 
-  case CTP_ImpliedReturnStmt:
   case CTP_ReturnStmt:
     return diag::cannot_convert_to_return_type_nil;
 
@@ -3568,8 +3564,7 @@ ContextualFailure::getDiagnosticFor(ContextualTypePurpose context,
     return forProtocol ? diag::cannot_convert_initializer_value_protocol
                        : diag::cannot_convert_initializer_value;
   }
-  case CTP_ReturnStmt:
-  case CTP_ImpliedReturnStmt: {
+  case CTP_ReturnStmt: {
     if (contextualType->isAnyObject())
       return diag::cannot_convert_return_type_to_anyobject;
 

lib/Sema/CSGen.cpp

@@ -4771,6 +4771,12 @@ bool ConstraintSystem::generateConstraints(
       target.setExprConversionType(TypeChecker::getOptionalType(expr->getLoc(), var));
     }
 
+    // If we have a parent return statement, record whether it's implied.
+    if (auto *RS = target.getParentReturnStmt()) {
+      if (RS->isImplied())
+        recordImpliedResult(expr, ImpliedResultKind::Regular);
+    }
+
     expr = buildTypeErasedExpr(expr, target.getDeclContext(),
                                target.getExprContextualType(),
                                target.getExprContextualTypePurpose());

lib/Sema/CSSimplify.cpp

@@ -6077,8 +6077,7 @@ bool ConstraintSystem::repairFailures(
       return true;
 
     auto purpose = getContextualTypePurpose(anchor);
-    if (rhs->isVoid() &&
-        (purpose == CTP_ReturnStmt || purpose == CTP_ImpliedReturnStmt)) {
+    if (rhs->isVoid() && purpose == CTP_ReturnStmt) {
       conversionsOrFixes.push_back(
           RemoveReturn::create(*this, lhs, getConstraintLocator(locator)));
       return true;
@@ -7859,14 +7858,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   if (auto elt = locator.last()) {
     if (kind >= ConstraintKind::Subtype &&
         (type1->isUninhabited() || type2->isVoid())) {
-      // Function with an implied `return`, e.g a single expression body.
-      if (auto contextualType = elt->getAs<LocatorPathElt::ContextualType>()) {
-        if (contextualType->isFor(CTP_ImpliedReturnStmt)) {
-          increaseScore(SK_FunctionConversion, locator);
-          return getTypeMatchSuccess();
-        }
-      }
-
       // Implied results can occur for closure bodies, returns, and if/switch
       // expression branches.
       //
@@ -7877,6 +7868,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
       // Never conversion.
       auto *loc = getConstraintLocator(locator);
       if (elt->is<LocatorPathElt::ClosureBody>() || 
+          loc->isForContextualType(CTP_ReturnStmt) ||
           loc->isForContextualType(CTP_ClosureResult) ||
           loc->isForSingleValueStmtBranch()) {
         bool allowConversion = false;
@@ -15599,7 +15591,6 @@ void ConstraintSystem::addContextualConversionConstraint(
   auto constraintKind = ConstraintKind::Conversion;
   switch (purpose) {
   case CTP_ReturnStmt:
-  case CTP_ImpliedReturnStmt:
   case CTP_Initialization: {
     if (conversionType->is<OpaqueTypeArchetypeType>())
       constraintKind = ConstraintKind::Equal;

lib/Sema/ConstraintSystem.cpp

@@ -1217,15 +1217,11 @@ Type ConstraintSystem::openOpaqueType(Type type, ContextualTypePurpose context,
   if (!type || !type->hasOpaqueArchetype())
     return type;
 
-  auto inReturnContext = [](ContextualTypePurpose context) {
-    return context == CTP_ReturnStmt || context == CTP_ImpliedReturnStmt;
-  };
-
-  if (!(context == CTP_Initialization || inReturnContext(context)))
+  if (!(context == CTP_Initialization || context == CTP_ReturnStmt))
     return type;
 
   auto shouldOpen = [&](OpaqueTypeArchetypeType *opaqueType) {
-    if (!inReturnContext(context))
+    if (context != CTP_ReturnStmt)
       return true;
 
     if (auto *func = dyn_cast<AbstractFunctionDecl>(DC))
@@ -7034,7 +7030,7 @@ Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
 Expr *ConstraintSystem::buildTypeErasedExpr(Expr *expr, DeclContext *dc,
                                             Type contextualType,
                                             ContextualTypePurpose purpose) {
-  if (!(purpose == CTP_ReturnStmt || purpose == CTP_ImpliedReturnStmt))
+  if (purpose != CTP_ReturnStmt)
     return expr;
 
   auto *decl = dyn_cast_or_null<ValueDecl>(dc->getAsDecl());

lib/Sema/MiscDiagnostics.cpp

@@ -3863,7 +3863,6 @@ class SingleValueStmtUsageChecker final : public ASTWalker {
     // Allowed in returns, throws, and bindings.
     switch (ctp) {
     case CTP_ReturnStmt:
-    case CTP_ImpliedReturnStmt:
     case CTP_ThrowStmt:
     case CTP_Initialization:
       markValidSingleValueStmt(E);