[Concurrency] Teach the constraint system about .isolation on dynamically

isolated function values.

Author: hborla

include/swift/AST/Expr.h

@@ -3530,7 +3530,7 @@ class ExtractFunctionIsolationExpr : public Expr {
 
 public:
   ExtractFunctionIsolationExpr(Expr *fnExpr, SourceLoc isolationLoc,
-                               Type type, bool implicit)
+                               Type type, bool implicit = false)
       : Expr(ExprKind::ExtractFunctionIsolation, implicit, type),
         fnExpr(fnExpr), isolationLoc(isolationLoc) {}
 

include/swift/Sema/OverloadChoice.h

@@ -56,6 +56,9 @@ enum class OverloadChoiceKind : int {
   DeclViaUnwrappedOptional,
   /// The overload choice materializes a pack from a tuple.
   MaterializePack,
+  /// The overload choice extracts the isolation of a dynamically isolated
+  /// function value.
+  ExtractFunctionIsolation,
   /// The overload choice indexes into a tuple. Index zero will
   /// have the value of this enumerator, index one will have the value of this
   /// enumerator + 1, and so on. Thus, this enumerator must always be last.

lib/IDE/SelectedOverloadInfo.cpp

@@ -89,6 +89,7 @@ swift::ide::getSelectedOverloadInfo(const Solution &S,
   case OverloadChoiceKind::DynamicMemberLookup:
   case OverloadChoiceKind::TupleIndex:
   case OverloadChoiceKind::MaterializePack:
+  case OverloadChoiceKind::ExtractFunctionIsolation:
     // If it's DynamicMemberLookup, we don't know which function is being
     // called, so we can't extract any information from it.
     // TupleIndex isn't a function call and is not relevant for argument

lib/Sema/CSApply.cpp

@@ -3423,6 +3423,15 @@ namespace {
                                         packType));
       }
 
+      case OverloadChoiceKind::ExtractFunctionIsolation: {
+        auto isolationType = solution.getResolvedType(expr);
+        auto *extractExpr = new (cs.getASTContext())
+          ExtractFunctionIsolationExpr(base,
+                                       expr->getEndLoc(),
+                                       isolationType);
+        return cs.cacheType(extractExpr);
+      }
+
       case OverloadChoiceKind::KeyPathApplication:
         llvm_unreachable("should only happen in a subscript");
 

lib/Sema/CSRanking.cpp

@@ -205,6 +205,7 @@ static bool sameOverloadChoice(const OverloadChoice &x,
     return x.getTupleIndex() == y.getTupleIndex();
 
   case OverloadChoiceKind::MaterializePack:
+  case OverloadChoiceKind::ExtractFunctionIsolation:
     return true;
   }
 
@@ -1121,6 +1122,7 @@ SolutionCompareResult ConstraintSystem::compareSolutions(
     switch (choice1.getKind()) {
     case OverloadChoiceKind::TupleIndex:
     case OverloadChoiceKind::MaterializePack:
+    case OverloadChoiceKind::ExtractFunctionIsolation:
       continue;
 
     case OverloadChoiceKind::KeyPathApplication:

lib/Sema/CSSimplify.cpp

@@ -205,6 +205,7 @@ static bool areConservativelyCompatibleArgumentLabels(
   case OverloadChoiceKind::KeyPathDynamicMemberLookup:
   case OverloadChoiceKind::TupleIndex:
   case OverloadChoiceKind::MaterializePack:
+  case OverloadChoiceKind::ExtractFunctionIsolation:
     return true;
   }
 
@@ -9746,6 +9747,16 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
   if (auto *selfTy = instanceTy->getAs<DynamicSelfType>())
     instanceTy = selfTy->getSelfType();
 
+  // Dynamically isolated function types have a magic '.isolation'
+  // member that extracts the isolation value.
+  if (auto *fn = dyn_cast<FunctionType>(instanceTy)) {
+    if (fn->getIsolation().isErased() &&
+        memberName.getBaseIdentifier().str() == "isolation") {
+      result.ViableCandidates.push_back(
+        OverloadChoice(baseTy, OverloadChoiceKind::ExtractFunctionIsolation));
+    }
+  }
+
   if (!instanceTy->mayHaveMembers())
     return result;
 

lib/Sema/Constraint.cpp

@@ -534,6 +534,9 @@ void Constraint::print(llvm::raw_ostream &Out, SourceManager *sm,
     case OverloadChoiceKind::MaterializePack:
       Out << "materialize pack";
       break;
+    case OverloadChoiceKind::ExtractFunctionIsolation:
+      Out << "extract function islation";
+      break;
     case OverloadChoiceKind::KeyPathApplication:
       Out << "key path application";
       break;

lib/Sema/ConstraintSystem.cpp

@@ -2890,6 +2890,7 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
   case OverloadChoiceKind::KeyPathApplication:
   case OverloadChoiceKind::TupleIndex:
   case OverloadChoiceKind::MaterializePack:
+  case OverloadChoiceKind::ExtractFunctionIsolation:
     return Type();
   }
 
@@ -3569,6 +3570,7 @@ void ConstraintSystem::bindOverloadType(
   case OverloadChoiceKind::DeclViaUnwrappedOptional:
   case OverloadChoiceKind::TupleIndex:
   case OverloadChoiceKind::MaterializePack:
+  case OverloadChoiceKind::ExtractFunctionIsolation:
   case OverloadChoiceKind::KeyPathApplication:
     bindTypeOrIUO(openedType);
     return;
@@ -3829,6 +3831,15 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
     break;
   }
 
+  case OverloadChoiceKind::ExtractFunctionIsolation: {
+    // The type of `.isolation` is `(any Actor)?`
+    auto actor = getASTContext().getProtocol(KnownProtocolKind::Actor);
+    adjustedRefType =
+        OptionalType::get(actor->getDeclaredExistentialType());
+    refType = adjustedRefType;
+    break;
+  }
+
   case OverloadChoiceKind::KeyPathApplication: {
     // Key path application looks like a subscript(keyPath: KeyPath<Base, T>).
     // The element type is T or @lvalue T based on the key path subtype and
@@ -4466,6 +4477,7 @@ DeclName OverloadChoice::getName() const {
 
     case OverloadChoiceKind::MaterializePack:
     case OverloadChoiceKind::TupleIndex:
+    case OverloadChoiceKind::ExtractFunctionIsolation:
       llvm_unreachable("no name!");
   }
 
@@ -5830,6 +5842,7 @@ bool ConstraintSystem::diagnoseAmbiguity(ArrayRef<Solution> solutions) {
 
       case OverloadChoiceKind::TupleIndex:
       case OverloadChoiceKind::MaterializePack:
+      case OverloadChoiceKind::ExtractFunctionIsolation:
         // FIXME: Actually diagnose something here.
         break;
       }

lib/Sema/TypeCheckConstraints.cpp

@@ -1304,6 +1304,10 @@ void OverloadChoice::dump(Type adjustedOpenedType, SourceManager *sm,
   case OverloadChoiceKind::MaterializePack:
     out << "materialize pack from tuple " << getBaseType()->getString(PO);
     break;
+
+  case OverloadChoiceKind::ExtractFunctionIsolation:
+    out << "extract isolation from " << getBaseType()->getString(PO);
+    break;
   }
 }
 
@@ -1610,6 +1614,11 @@ void ConstraintSystem::print(raw_ostream &out) const {
         out << "materialize pack from tuple "
             << choice.getBaseType()->getString(PO);
         break;
+
+      case OverloadChoiceKind::ExtractFunctionIsolation:
+        out << "extract isolation from "
+            << choice.getBaseType()->getString(PO);
+        break;
       }
       out << " for ";
       elt.first->dump(&getASTContext().SourceMgr, out);