[Sema] Diagnose partial and unapplied func sendability

i.e.
     `S().f` is sendable if `S()` is a Sendable type

Partial apply and unapplied methods of Sendable types should be
marked as Sendable in the constraint system, including declarations
and unapplied functions as parameters.

Author: angela-laar

lib/Sema/ConstraintSystem.cpp

@@ -1160,7 +1160,7 @@ FunctionType *ConstraintSystem::openFunctionType(
        DeclContext *outerDC) {
   if (auto *genericFn = funcType->getAs<GenericFunctionType>()) {
     auto signature = genericFn->getGenericSignature();
-
+    //TO-DO Maybe update here
     openGenericParameters(outerDC, signature, replacements, locator);
 
     openGenericRequirements(outerDC, signature,
@@ -1672,6 +1672,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
 
     OpenedTypeMap replacements;
 
+    // TO-DO check for sendable here and update type
     AnyFunctionType *funcType = func->getInterfaceType()
         ->castTo<AnyFunctionType>();
     auto openedType = openFunctionType(
@@ -1711,6 +1712,10 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     auto numLabelsToRemove = getNumRemovedArgumentLabels(
         funcDecl, /*isCurriedInstanceReference=*/false, functionRefKind);
 
+
+    //check the base ... let's check
+    //funcType = funcType->withExtInfo(functy->getExtInfo().withConcurrent())->castTo<AnyFunctionType>();
+    
     auto openedType = openFunctionType(funcType, locator, replacements,
                                        funcDecl->getDeclContext())
                           ->removeArgumentLabels(numLabelsToRemove);
@@ -2624,6 +2629,14 @@ ConstraintSystem::getTypeOfMemberReference(
     auto *functionType = fullFunctionType->getResult()->getAs<FunctionType>();
     functionType = unwrapPropertyWrapperParameterTypes(*this, funcDecl, functionRefKind,
                                                        functionType, locator);
+    auto sendableProtocol = useDC->getParentModule()->getASTContext().getProtocol(KnownProtocolKind::Sendable);
+    // FIXME: Handle conditional conformances
+    auto baseSendable = TypeChecker::conformsToProtocol( baseOpenedTy, sendableProtocol, useDC->getParentModule());
+    
+    if (!baseSendable.isInvalid()) {
+          functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
+    }
+    
     // FIXME: Verify ExtInfo state is correct, not working by accident.
     FunctionType::ExtInfo info;
     openedType =

lib/Sema/TypeCheckConcurrency.cpp

@@ -2469,6 +2469,11 @@ namespace {
         auto value = valueRef.getDecl();
         auto loc = declRef->getLoc();
 
+//        for (auto arg : *declRef->getArgs()) {
+////          if (swift::isSendableType(getDeclContext()->getParentModule(), arg))
+//          value->getAttrs().add(new (ctx) SendableAttr(true));
+//        }
+        
         //FIXME: Should this be subsumed in reference checking?
         if (value->isLocalCapture())
           checkLocalCapture(valueRef, loc, declRef);
@@ -2489,6 +2494,12 @@ namespace {
                 partialApply->base, memberRef->first, memberRef->second,
                 partialApply);
 
+            if (diagnosePartialApplySendability(partialApply->fn, partialApply->base, getDeclContext())){
+              if(auto funcdecl = dyn_cast<FuncDecl>(memberRef->first.getDecl())){
+                // Mark with @Sendable attribute implicitly if type is Sendable
+                    funcdecl->getAttrs().add(new (ctx) SendableAttr(true));
+              }
+            }
             partialApply->base->walk(*this);
 
             return Action::SkipChildren(expr);
@@ -3105,6 +3116,11 @@ namespace {
           getContextIsolation().isActorIsolated())
         unsatisfiedIsolation = ActorIsolation::forNonisolated();
 
+      // move check for sendability of arguments earlier
+      if (!ctx.LangOpts.hasFeature(Feature::DeferredSendableChecking)) {
+        diagnoseApplyArgSendability(apply, getDeclContext());
+      }
+
       // If there was no unsatisfied actor isolation, we're done.
       if (!unsatisfiedIsolation)
         return false;

lib/Sema/TypeCheckConcurrency.h

@@ -548,6 +548,11 @@ bool isPotentiallyIsolatedActor(
     VarDecl *var, llvm::function_ref<bool(ParamDecl *)> isIsolated =
                       [](ParamDecl *P) { return P->isIsolated(); });
 
+/// Check whether the given PartialApplyThunk makes an unsatisfied isolation jump
+/// and if so, emit diagnostics for any nonsendable arguments to the apply.
+/// Add the Sendable attribute if this is a patial apply of a Sendable Type.
+bool diagnosePartialApplySendability(Expr *decl, Expr *base, const DeclContext *declContext);
+
 /// Check whether the given ApplyExpr makes an unsatisfied isolation jump
 /// and if so, emit diagnostics for any nonsendable arguments to the apply
 bool diagnoseApplyArgSendability(