[AST] Mark parameter declarations as caller isolated

When `nonisolated(nonsending)` parameter specifier is present
mark the declaration as caller isolated.

(cherry picked from commit 9bc96d4)

Author: xedin

include/swift/AST/Decl.h

@@ -6911,6 +6911,9 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this parameter is 'sending'.
     IsSending = 1 << 4,
+
+    /// Whether or not this parameter is isolated to a caller.
+    IsCallerIsolated = 1 << 5,
   };
 
   /// The type repr and 3 bits used for flags.
@@ -7199,6 +7202,18 @@ class ParamDecl : public VarDecl {
       removeFlag(Flag::IsSending);
   }
 
+  /// Whether or not this parameter is marked with 'nonisolated(nonsending)'.
+  bool isCallerIsolated() const {
+    return getOptions().contains(Flag::IsCallerIsolated);
+  }
+
+  void setCallerIsolated(bool value = true) {
+    if (value)
+      addFlag(Flag::IsCallerIsolated);
+    else
+      removeFlag(Flag::IsCallerIsolated);
+  }
+
   /// Whether or not this parameter is marked with '@_addressable'.
   bool isAddressable() const {
     return getOptions().contains(Flag::IsAddressable);

lib/AST/Decl.cpp

@@ -9010,6 +9010,12 @@ void ParamDecl::setTypeRepr(TypeRepr *repr) {
         continue;
       }
 
+      if (auto *callerIsolated =
+              dyn_cast<CallerIsolatedTypeRepr>(unwrappedType)) {
+        setCallerIsolated(true);
+        unwrappedType = callerIsolated->getBase();
+      }
+
       break;
     }
   }
@@ -11095,6 +11101,9 @@ AccessorDecl *AccessorDecl::createParsed(
       if (subscriptParam->isSending())
         param->setSending();
 
+      if (subscriptParam->isCallerIsolated())
+        param->setCallerIsolated();
+
       newParams.push_back(param);
     }
 

lib/Serialization/Deserialization.cpp

@@ -4117,6 +4117,7 @@ class DeclDeserializer {
     bool isIsolated;
     bool isCompileTimeLiteral, isConstValue;
     bool isSending;
+    bool isCallerIsolated;
     uint8_t rawDefaultArg;
     TypeID defaultExprType;
     uint8_t rawDefaultArgIsolation;
@@ -4129,6 +4130,7 @@ class DeclDeserializer {
                                          isCompileTimeLiteral,
                                          isConstValue,
                                          isSending,
+                                         isCallerIsolated,
                                          rawDefaultArg,
                                          defaultExprType,
                                          rawDefaultArgIsolation,
@@ -4174,6 +4176,7 @@ class DeclDeserializer {
     param->setCompileTimeLiteral(isCompileTimeLiteral);
     param->setConstValue(isConstValue);
     param->setSending(isSending);
+    param->setCallerIsolated(isCallerIsolated);
 
     // Decode the default argument kind.
     // FIXME: Default argument expression, if available.

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 937; // remove @execution attr
+const uint16_t SWIFTMODULE_VERSION_MINOR = 938; // `isCallerIsolated` parameter flag
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1733,6 +1733,7 @@ namespace decls_block {
     BCFixed<1>,              // isCompileTimeLiteral?
     BCFixed<1>,              // isConst?
     BCFixed<1>,              // isSending?
+    BCFixed<1>,              // isCallerIsolated?
     DefaultArgumentField,    // default argument kind
     TypeIDField,             // default argument type
     ActorIsolationField,     // default argument isolation

lib/Serialization/Serialization.cpp

@@ -4750,6 +4750,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
         param->isCompileTimeLiteral(),
         param->isConstVal(),
         param->isSending(),
+        param->isCallerIsolated(),
         getRawStableDefaultArgumentKind(argKind),
         S.addTypeRef(defaultExprType),
         getRawStableActorIsolationKind(isolation.getKind()),