Introduce subtyping rule for functions with "isolated" parameters.

With isolated parameters being part of a function's type, check to
ensure that isolated and non-isolated parameters aren't incorrectly
matched. Specifically, it is okay to add `isolated` to a parameter
when there is a subtyping relationship, but not remove it:

```swift
actor A { }
func f(_: isolated A) { }
func g(_: A) { }

func test() {
  let _: (isolated A) -> Void = g    // okay to add 'isolated'
  let _: (A) -> Void = f             // error when removing 'isolated'
}
```

Author: DougGregor

lib/Parse/ParsePattern.cpp

@@ -574,16 +574,33 @@ mapParsedParameters(Parser &parser,
 
       param->setTypeRepr(type);
 
-      // If there is `@autoclosure` attribute associated with the type
-      // let's mark that in the declaration as well, because it
-      // belongs to both type flags and declaration.
-      if (auto *ATR = dyn_cast<AttributedTypeRepr>(type)) {
-        auto &attrs = ATR->getAttrs();
-        // At this point we actually don't know if that's valid to mark
-        // this parameter declaration as `autoclosure` because type has
-        // not been resolved yet - it should either be a function type
-        // or typealias with underlying function type.
-        param->setAutoClosure(attrs.has(TypeAttrKind::TAK_autoclosure));
+      // Dig through the type to find any attributes or modifiers that are
+      // associated with the type but should also be reflected on the
+      // declaration.
+      {
+        auto unwrappedType = type;
+        while (true) {
+          if (auto *ATR = dyn_cast<AttributedTypeRepr>(unwrappedType)) {
+            auto &attrs = ATR->getAttrs();
+            // At this point we actually don't know if that's valid to mark
+            // this parameter declaration as `autoclosure` because type has
+            // not been resolved yet - it should either be a function type
+            // or typealias with underlying function type.
+            param->setAutoClosure(attrs.has(TypeAttrKind::TAK_autoclosure));
+
+            unwrappedType = ATR->getTypeRepr();
+            continue;
+          }
+
+          if (auto *STR = dyn_cast<SpecifierTypeRepr>(unwrappedType)) {
+            if (isa<IsolatedTypeRepr>(STR))
+              param->setIsolated(true);
+            unwrappedType = STR->getBase();
+            continue;;
+          }
+
+          break;
+        }
       }
     } else if (paramInfo.SpecifierLoc.isValid()) {
       StringRef specifier;

lib/Sema/CSSimplify.cpp

@@ -2461,6 +2461,12 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
       hasLabelingFailures = true;
     }
 
+    // "isolated" can be added as a subtype relation, but otherwise must match.
+    if (func1Param.isIsolated() != func2Param.isIsolated() &&
+        !(func2Param.isIsolated() && subKind >= ConstraintKind::Subtype)) {
+      return getTypeMatchFailure(argumentLocator);
+    }
+
     // FIXME: We should check value ownership too, but it's not completely
     // trivial because of inout-to-pointer conversions.
 

test/Concurrency/isolated_parameters.swift

@@ -24,3 +24,13 @@ func testA<T: Actor>(
 
 @available(SwiftStdlib 5.5, *)
 typealias Fn = (isolated A) -> Void
+
+@available(SwiftStdlib 5.5, *)
+func globalFunc(_: A) { }
+
+@available(SwiftStdlib 5.5, *)
+func globalFuncIsolated(_: isolated A) {
+  let _: Int = globalFuncIsolated // expected-error{{cannot convert value of type '(isolated A) -> ()' to specified type 'Int'}}
+  let _: (A) -> Void = globalFuncIsolated // expected-error{{cannot convert value of type '(isolated A) -> ()' to specified type '(A) -> Void'}}
+  let _: Fn = globalFunc // okay
+}