[Completion] Complete .isolation for @isolated(any) functions

This was added in SE-0431.

rdar://124615036

Author: hamishknight

include/swift/IDE/CompletionLookup.h

@@ -510,6 +510,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   bool tryTupleExprCompletions(Type ExprType);
 
+  /// Try add the completion for '.isolation' for @isolated(any) function types.
+  void tryFunctionIsolationCompletion(Type ExprType);
+
   bool tryFunctionCallCompletions(
       Type ExprType, const ValueDecl *VD,
       std::optional<SemanticContextKind> SemanticContext = std::nullopt);
@@ -522,7 +525,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   /// \return true if the given type was Optional .
   bool tryUnwrappedCompletions(Type ExprType, bool isIUO);
 
-  void getPostfixKeywordCompletions(Type ExprType, Expr *ParsedExpr);
+  void getPostfixBuiltinCompletions(Type ExprType, Expr *ParsedExpr);
 
   /// Add code completion results after an expression of type \p ExprType.
   /// This includes members as well as call patterns if \p ExprType is a

lib/IDE/CompletionLookup.cpp

@@ -2302,6 +2302,18 @@ bool CompletionLookup::tryTupleExprCompletions(Type ExprType) {
   return true;
 }
 
+void CompletionLookup::tryFunctionIsolationCompletion(Type ExprType) {
+  auto *FT = ExprType->getAs<FunctionType>();
+  if (!FT || !FT->getIsolation().isErased())
+    return;
+
+  // The type of `.isolation` is `(any Actor)?`
+  auto *actorProto = Ctx.getProtocol(KnownProtocolKind::Actor);
+  auto memberTy = OptionalType::get(actorProto->getDeclaredExistentialType());
+
+  addBuiltinMemberRef(Ctx.Id_isolation.str(), memberTy);
+}
+
 bool CompletionLookup::tryFunctionCallCompletions(
     Type ExprType, const ValueDecl *VD,
     std::optional<SemanticContextKind> SemanticContext) {
@@ -2392,13 +2404,16 @@ bool CompletionLookup::tryUnwrappedCompletions(Type ExprType, bool isIUO) {
   return false;
 }
 
-void CompletionLookup::getPostfixKeywordCompletions(Type ExprType,
+void CompletionLookup::getPostfixBuiltinCompletions(Type ExprType,
                                                     Expr *ParsedExpr) {
   if (IsSuperRefExpr)
     return;
 
   NeedLeadingDot = !HaveDot;
 
+  // Add '.isolation' to @isolated(any) functions.
+  tryFunctionIsolationCompletion(ExprType);
+
   if (!ExprType->getAs<ModuleType>()) {
     addKeyword(getTokenText(tok::kw_self), ExprType->getRValueType(),
                SemanticContextKind::CurrentNominal,

lib/IDE/PostfixCompletion.cpp

@@ -432,7 +432,7 @@ void PostfixCompletionCallback::collectResults(
     Lookup.setClosureActorIsolations(Result.ClosureActorIsolations);
     Lookup.setIsStaticMetatype(Result.BaseIsStaticMetaType);
     if (!ProcessedBaseTypes.contains(Result.BaseTy)) {
-      Lookup.getPostfixKeywordCompletions(Result.BaseTy, BaseExpr);
+      Lookup.getPostfixBuiltinCompletions(Result.BaseTy, BaseExpr);
     }
     Lookup.setExpectedTypes(Result.ExpectedTypes, Result.IsImpliedResult,
                             Result.ExpectsNonVoid);

test/IDE/complete_function_isolation.swift

@@ -0,0 +1,18 @@
+// RUN: %batch-code-completion
+
+// REQUIRES: concurrency
+
+func test1(_ x: () -> Void) {
+  x.#^NORMAL_FN^#
+  // NORMAL_FN:     Begin completions, 2 items
+  // NORMAL_FN-DAG: Keyword[self]/CurrNominal: self[#() -> Void#]; name=self
+  // NORMAL_FN-DAG: Pattern/CurrModule/Flair[ArgLabels]/Erase[1]: ()[#Void#]; name=()
+}
+
+func test2(_ x: @isolated(any) () -> Void) {
+  x.#^ISOLATED_ANY_FN^#
+  // ISOLATED_ANY_FN:     Begin completions, 3 items
+  // ISOLATED_ANY_FN-DAG: Pattern/CurrNominal: isolation[#(any Actor)?#]; name=isolation
+  // ISOLATED_ANY_FN-DAG: Keyword[self]/CurrNominal: self[#@isolated(any) () -> Void#]; name=self
+  // ISOLATED_ANY_FN-DAG: Pattern/CurrModule/Flair[ArgLabels]/Erase[1]: ()[#Void#]; name=()
+}