[Concurrency] Make "self" parameter of actor-isolated functions 'isolated'.

The notion of "actor-isolated" currently exists at the declaration level.
For functions, it is going to be captured in the function type itself,
where 'self' is declared to be 'isolated'. Model isolation both
ways: the 'self' of a method that is isolated to an actor instance
will be 'isolated' as well.

We are still using declaration-based checking of actor isolation.
However, by mirroring this information we can move more incrementally
over to doing checking based on 'isolated' parameters.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4526,9 +4526,6 @@ ERROR(nonisolated_local_var,none,
       "'nonisolated' can not be applied to local variables",
       ())
 
-ERROR(isolated_param_non_actor,none,
-      "'isolated' parameter cannot have not-actor type %0", (Type))
-
 ERROR(actor_instance_property_wrapper,none,
       "%0 property in property wrapper type %1 cannot be isolated to "
       "the actor instance; consider 'nonisolated'",

include/swift/AST/TypeCheckRequests.h

@@ -1020,6 +1020,20 @@ class ActorIsolationRequest :
   bool isCached() const { return true; }
 };
 
+/// Determine whether the given function should have an isolated 'self'.
+class HasIsolatedSelfRequest :
+    public SimpleRequest<HasIsolatedSelfRequest,
+                         bool(ValueDecl *),
+                         RequestFlags::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, ValueDecl *func) const;
+};
+
 /// Request whether the storage has a mutating getter.
 class IsGetterMutatingRequest :
     public SimpleRequest<IsGetterMutatingRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -114,6 +114,9 @@ SWIFT_REQUEST(TypeChecker, GlobalActorAttributeRequest,
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,
               ActorIsolationState(ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, HasIsolatedSelfRequest,
+              bool(ValueDecl *),
+              Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, FunctionOperatorRequest, OperatorDecl *(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(NameLookup, GenericSignatureRequest,

include/swift/AST/Types.h

@@ -2866,6 +2866,9 @@ class AnyFunctionType : public TypeBase {
     /// Whether the parameter is marked '@_nonEphemeral'
     bool isNonEphemeral() const { return Flags.isNonEphemeral(); }
 
+    /// Whether the parameter is 'isolated'.
+    bool isIsolated() const { return Flags.isIsolated(); }
+
     /// Whether the parameter is marked '@noDerivative'.
     bool isNoDerivative() const { return Flags.isNoDerivative(); }
 

include/swift/Parse/Parser.h

@@ -1370,6 +1370,9 @@ class Parser {
     EnumElement,
   };
 
+  /// Whether we are at the start of a parameter name when parsing a parameter.
+  bool startsParameterName(bool isClosure);
+
   /// Parse a parameter-clause.
   ///
   /// \verbatim

lib/AST/ASTContext.cpp

@@ -2790,6 +2790,7 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
   bool isStatic = false;
   SelfAccessKind selfAccess = SelfAccessKind::NonMutating;
   bool isDynamicSelf = false;
+  bool isIsolated = false;
 
   if (auto *FD = dyn_cast<FuncDecl>(AFD)) {
     isStatic = FD->isStatic();
@@ -2806,6 +2807,11 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
     // FIXME: All methods of non-final classes should have this.
     else if (wantDynamicSelf && FD->hasDynamicSelfResult())
       isDynamicSelf = true;
+
+    // If this is a non-static method within an actor, the 'self' parameter
+    // is isolated if this declaration is isolated.
+    isIsolated = evaluateOrDefault(
+        Ctx.evaluator, HasIsolatedSelfRequest{AFD}, false);
   } else if (auto *CD = dyn_cast<ConstructorDecl>(AFD)) {
     if (isInitializingCtor) {
       // initializing constructors of value types always have an implicitly
@@ -2839,7 +2845,7 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
   if (isStatic)
     return AnyFunctionType::Param(MetatypeType::get(selfTy, Ctx));
 
-  auto flags = ParameterTypeFlags();
+  auto flags = ParameterTypeFlags().withIsolated(isIsolated);
   switch (selfAccess) {
   case SelfAccessKind::Consuming:
     flags = flags.withOwned(true);

lib/AST/ASTPrinter.cpp

@@ -3234,6 +3234,9 @@ static void printParameterFlags(ASTPrinter &printer,
     break;
   }
 
+  if (flags.isIsolated())
+    printer.printKeyword("isolated", options, " ");
+
   if (!options.excludeAttrKind(TAK_escaping) && escaping)
     printer.printKeyword("@escaping", options, " ");
 }

lib/AST/ASTVerifier.cpp

@@ -1758,6 +1758,26 @@ class Verifier : public ASTWalker {
       }
     }
 
+    /// A version of AnyFunctionType::equalParams() that ignores "isolated"
+    /// parameters, which aren't represented in the type system.
+    static bool equalParamsIgnoringIsolation(
+        ArrayRef<AnyFunctionType::Param> a,
+        ArrayRef<AnyFunctionType::Param> b) {
+      auto withoutIsolation = [](AnyFunctionType::Param param) {
+        return param.withFlags(param.getParameterFlags().withIsolated(false));
+      };
+
+      if (a.size() != b.size())
+        return false;
+
+      for (unsigned i = 0, n = a.size(); i != n; ++i) {
+        if (withoutIsolation(a[i]) != withoutIsolation(b[i]))
+          return false;
+      }
+
+      return true;
+    }
+
     void verifyChecked(ApplyExpr *E) {
       PrettyStackTraceExpr debugStack(Ctx, "verifying ApplyExpr", E);
 
@@ -1782,7 +1802,7 @@ class Verifier : public ASTWalker {
       Type InputExprTy = E->getArg()->getType();
       AnyFunctionType::decomposeInput(InputExprTy, Args);
       auto Params = FT->getParams();
-      if (!AnyFunctionType::equalParams(Args, Params)) {
+      if (!equalParamsIgnoringIsolation(Args, Params)) {
         Out << "Argument type does not match parameter type in ApplyExpr:"
                "\nArgument type: ";
         InputExprTy.print(Out);

lib/Parse/ParsePattern.cpp

@@ -150,22 +150,37 @@ static ParserStatus parseDefaultArgument(
 
 /// Determine whether we are at the start of a parameter name when
 /// parsing a parameter.
-static bool startsParameterName(Parser &parser, bool isClosure) {
+bool Parser::startsParameterName(bool isClosure) {
   // '_' cannot be a type, so it must be a parameter name.
-  if (parser.Tok.is(tok::kw__))
+  if (Tok.is(tok::kw__))
     return true;
 
   // To have a parameter name here, we need a name.
-  if (!parser.Tok.canBeArgumentLabel())
+  if (!Tok.canBeArgumentLabel())
     return false;
 
-  // If the next token can be an argument label or is ':', this is a name.
-  const auto &nextTok = parser.peekToken();
-  if (nextTok.is(tok::colon) || nextTok.canBeArgumentLabel())
+  // If the next token is ':', this is a name.
+  const auto &nextTok = peekToken();
+  if (nextTok.is(tok::colon))
     return true;
 
-  if (parser.isOptionalToken(nextTok)
-      || parser.isImplicitlyUnwrappedOptionalToken(nextTok))
+  // If the next token can be an argument label, we might have a name.
+  if (nextTok.canBeArgumentLabel()) {
+    // If the first name wasn't "isolated", we're done.
+    if (!Tok.isContextualKeyword("isolated"))
+      return true;
+
+    // "isolated" can be an argument label, but it's also a contextual keyword,
+    // so look ahead one more token see if we have a ':' that would indicate
+    // that this is an argument label.
+    BacktrackingScope backtrackScope(*this);
+    consumeToken();
+    consumeToken();
+    return Tok.is(tok::colon);
+  }
+
+  if (isOptionalToken(nextTok)
+      || isImplicitlyUnwrappedOptionalToken(nextTok))
     return false;
 
   // The identifier could be a name or it could be a type. In a closure, we
@@ -289,7 +304,7 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
         .fixItReplace(Tok.getLoc(), "`" + Tok.getText().str() + "`");
     }
 
-    if (startsParameterName(*this, isClosure)) {
+    if (startsParameterName(isClosure)) {
       // identifier-or-none for the first name
       param.FirstNameLoc = consumeArgumentLabel(param.FirstName,
                                                 /*diagnoseDollarPrefix=*/!isClosure);

lib/Parse/ParseType.cpp

@@ -1027,9 +1027,7 @@ ParserResult<TypeRepr> Parser::parseTypeTupleBody() {
     // If the tuple element starts with a potential argument label followed by a
     // ':' or another potential argument label, then the identifier is an
     // element tag, and it is followed by a type annotation.
-    if (Tok.canBeArgumentLabel()
-        && (peekToken().is(tok::colon)
-            || peekToken().canBeArgumentLabel())) {
+    if (startsParameterName(false)) {
       // Consume a name.
       element.NameLoc = consumeArgumentLabel(element.Name,
                                              /*diagnoseDollarPrefix=*/true);