Merge pull request #71006 from hamishknight/implicit-last-expression

Introduce implicit last expression results

Author: hamishknight

include/swift/AST/Expr.h

@@ -6204,12 +6204,19 @@ class SingleValueStmtExpr : public Expr {
   /// SingleValueStmtExpr.
   static SingleValueStmtExpr *tryDigOutSingleValueStmtExpr(Expr *E);
 
+  /// Whether the last ASTNode in the given BraceStmt can potentially be used as
+  /// the implicit result for a SingleValueStmtExpr. If \p mustBeSingleValueStmt
+  /// is \c true, a result will be considered even if it may not be valid.
+  static bool isLastElementImplicitResult(BraceStmt *BS, ASTContext &ctx,
+                                          bool mustBeSingleValueStmt);
+
   /// Retrieves a resulting ThenStmt from the given BraceStmt, or \c nullptr if
   /// the brace does not have a resulting ThenStmt.
   static ThenStmt *getThenStmtFrom(BraceStmt *BS);
 
   /// Whether the given BraceStmt has a result to be produced from a parent
-  /// SingleValueStmtExpr.
+  /// SingleValueStmtExpr. Note this does not consider elements that may
+  /// implicitly become results, check \c isLastElementImplicitResult for that.
   static bool hasResult(BraceStmt *BS) {
     return getThenStmtFrom(BS);
   }

include/swift/AST/Stmt.h

@@ -269,8 +269,8 @@ class ReturnStmt : public Stmt {
     return createImplicit(ctx, SourceLoc(), result);
   }
 
-  /// Create an implicit implied ReturnStmt for a single expression body.
-  static ReturnStmt *forSingleExprBody(ASTContext &ctx, Expr *result) {
+  /// Create an implicit implied ReturnStmt for e.g a single expression body.
+  static ReturnStmt *createImplied(ASTContext &ctx, Expr *result) {
     assert(result && "Result must be present to be implied");
     auto *RS = createImplicit(ctx, result);
     RS->Bits.ReturnStmt.IsImplied = true;

include/swift/AST/TypeCheckRequests.h

@@ -3397,10 +3397,10 @@ class ScopedImportLookupRequest
   bool isCached() const { return true; }
 };
 
-/// Determine whether closure body has any explicit `return`
+/// Determine whether closure body has any `return`
 /// statements which could produce a non-void result.
-class ClosureHasExplicitResultRequest
-    : public SimpleRequest<ClosureHasExplicitResultRequest, bool(ClosureExpr *),
+class ClosureHasResultExprRequest
+    : public SimpleRequest<ClosureHasResultExprRequest, bool(ClosureExpr *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -4258,9 +4258,13 @@ class IsSingleValueStmtResult {
     return InvalidJumps;
   }
 
-  explicit operator bool() const {
+  bool isValid() const {
     return TheKind == Kind::Valid;
   }
+
+  explicit operator bool() const {
+    return isValid();
+  }
 };
 
 /// Computes whether a given statement can be treated as a SingleValueStmtExpr.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -444,7 +444,7 @@ SWIFT_REQUEST(TypeChecker, PatternTypeRequest,
               Cached, HasNearestLocation)
 SWIFT_REQUEST(TypeChecker, ScopedImportLookupRequest,
               ArrayRef<ValueDecl *>(ImportDecl *), Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, ClosureHasExplicitResultRequest,
+SWIFT_REQUEST(TypeChecker, ClosureHasResultExprRequest,
               bool(ClosureExpr *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, LookupAllConformancesInContextRequest,
               ProtocolConformanceLookupResult(const IterableDeclContext *),

include/swift/Basic/Features.def

@@ -231,6 +231,10 @@ EXPERIMENTAL_FEATURE(ThenStatements, false)
 /// Enable 'do' expressions.
 EXPERIMENTAL_FEATURE(DoExpressions, false)
 
+/// Enable implicitly treating the last expression in a function, closure,
+/// and 'if'/'switch' expression as the result.
+EXPERIMENTAL_FEATURE(ImplicitLastExprResults, false)
+
 /// Enable the `@_rawLayout` attribute.
 EXPERIMENTAL_FEATURE(RawLayout, true)
 

include/swift/IDE/AfterPoundExprCompletion.h

@@ -26,7 +26,7 @@ namespace ide {
 class AfterPoundExprCompletion : public TypeCheckCompletionCallback {
   struct Result {
     Type ExpectedTy;
-    bool IsImplicitSingleExpressionReturn;
+    bool IsImpliedResult;
 
     /// Whether the surrounding context is async and thus calling async
     /// functions is supported.

include/swift/IDE/CodeCompletionContext.h

@@ -39,10 +39,10 @@ class CodeCompletionContext {
     /// There is no known contextual type. All types are equally good.
     None,
 
-    /// There is a contextual type from a single-expression closure/function
-    /// body. The context is a hint, and enables unresolved member completion,
-    /// but should not hide any results.
-    SingleExpressionBody,
+    /// There is a contextual type from e.g a single-expression closure/function
+    /// body, where the return is implied. The context is a hint, and enables
+    /// unresolved member completion, but should not hide any results.
+    Implied,
 
     /// There are known contextual types, or there aren't but a nonvoid type is
     /// expected.

include/swift/IDE/CodeCompletionResultType.h

@@ -44,12 +44,12 @@ class ExpectedTypeContext {
   /// Pre typechecked type of the expression at the completion position.
   Type IdealType;
 
-  /// Whether the `ExpectedTypes` comes from a single-expression body, e.g.
+  /// Whether the `ExpectedTypes` comes from an implied result, e.g.
   /// `foo({ here })`.
   ///
   /// Since the input may be incomplete, we take into account that the types are
   /// only a hint.
-  bool IsImplicitSingleExpressionReturn = false;
+  bool IsImpliedResult = false;
   bool PreferNonVoid = false;
 
   /// If not empty, \c PossibleTypes are ignored and types that have an
@@ -86,7 +86,7 @@ class ExpectedTypeContext {
     if (!IdealType || !Other.IdealType || !IdealType->isEqual(Other.IdealType)) {
       IdealType = Type();
     }
-    IsImplicitSingleExpressionReturn |= Other.IsImplicitSingleExpressionReturn;
+    IsImpliedResult |= Other.IsImpliedResult;
     PreferNonVoid &= Other.PreferNonVoid;
     ExpectedCustomAttributeKinds |= Other.ExpectedCustomAttributeKinds;
   }
@@ -96,7 +96,7 @@ class ExpectedTypeContext {
   void setIdealType(Type IdealType) { this->IdealType = IdealType; }
 
   bool requiresNonVoid() const {
-    if (IsImplicitSingleExpressionReturn)
+    if (IsImpliedResult)
       return false;
     if (PreferNonVoid)
       return true;
@@ -105,13 +105,12 @@ class ExpectedTypeContext {
     return llvm::all_of(PossibleTypes, [](Type Ty) { return !Ty->isVoid(); });
   }
 
-  bool isImplicitSingleExpressionReturn() const {
-    return IsImplicitSingleExpressionReturn;
+  bool isImpliedResult() const {
+    return IsImpliedResult;
   }
 
-  void
-  setIsImplicitSingleExpressionReturn(bool IsImplicitSingleExpressionReturn) {
-    this->IsImplicitSingleExpressionReturn = IsImplicitSingleExpressionReturn;
+  void setIsImpliedResult(bool IsImpliedResult) {
+    this->IsImpliedResult = IsImpliedResult;
   }
 
   bool getPreferNonVoid() const { return PreferNonVoid; }

include/swift/IDE/CompletionLookup.h

@@ -234,11 +234,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void setIsStaticMetatype(bool value) { IsStaticMetatype = value; }
 
   void setExpectedTypes(
-      ArrayRef<Type> Types, bool isImplicitSingleExpressionReturn,
-      bool preferNonVoid = false,
+      ArrayRef<Type> Types, bool isImpliedResult, bool preferNonVoid = false,
       OptionSet<CustomAttributeKind> expectedCustomAttributeKinds = {}) {
-    expectedTypeContext.setIsImplicitSingleExpressionReturn(
-        isImplicitSingleExpressionReturn);
+    expectedTypeContext.setIsImpliedResult(isImpliedResult);
     expectedTypeContext.setPreferNonVoid(preferNonVoid);
     expectedTypeContext.setPossibleTypes(Types);
     expectedTypeContext.setExpectedCustomAttributeKinds(
@@ -269,8 +267,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     if (expectedTypeContext.empty() &&
         !expectedTypeContext.getPreferNonVoid()) {
       return CodeCompletionContext::TypeContextKind::None;
-    } else if (expectedTypeContext.isImplicitSingleExpressionReturn()) {
-      return CodeCompletionContext::TypeContextKind::SingleExpressionBody;
+    } else if (expectedTypeContext.isImpliedResult()) {
+      return CodeCompletionContext::TypeContextKind::Implied;
     } else {
       return CodeCompletionContext::TypeContextKind::Required;
     }

include/swift/IDE/ExprCompletion.h

@@ -23,9 +23,9 @@ namespace ide {
 class ExprTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
 public:
   struct Result {
-    /// If the code completion expression is an implicit return in a
+    /// If the code completion expression is an implied result, e.g in a
     /// single-expression closure.
-    bool IsImplicitSingleExpressionReturn;
+    bool IsImpliedResult;
 
     /// Whether the surrounding context is async and thus calling async
     /// functions is supported.
@@ -75,7 +75,7 @@ class ExprTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
   /// If \c AddUnresolvedMemberCompletions is false, the
   /// \p UnresolvedMemberBaseType is ignored.
   void addResult(
-      bool IsImplicitSingleExpressionReturn, bool IsInAsyncContext,
+      bool IsImpliedResult, bool IsInAsyncContext,
       Type UnresolvedMemberBaseType,
       llvm::SmallDenseMap<const VarDecl *, Type> SolutionSpecificVarTypes);