Sema: KeyPath literals should be read-only when referring to unavailable setters.

Part of rdar://problem/65152582, where key paths were generating references to setters in contexts where they weren't
available.

Author: jckarter

lib/Sema/CSSimplify.cpp

@@ -6268,7 +6268,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
           // If this is an attempt to access read-only member via
           // writable key path, let's fail this choice early.
           auto &ctx = getASTContext();
-          if (isReadOnlyKeyPathComponent(storage) &&
+          if (isReadOnlyKeyPathComponent(storage, SourceLoc()) &&
               (keyPath == ctx.getWritableKeyPathDecl() ||
                keyPath == ctx.getReferenceWritableKeyPathDecl())) {
             result.addUnviable(
@@ -8020,7 +8020,7 @@ ConstraintSystem::simplifyKeyPathConstraint(
       if (!storage)
         return SolutionKind::Error;
 
-      if (isReadOnlyKeyPathComponent(storage)) {
+      if (isReadOnlyKeyPathComponent(storage, component.getLoc())) {
         capability = ReadOnly;
         continue;
       }

lib/Sema/ConstraintSystem.h

@@ -4617,7 +4617,8 @@ class ConstraintSystem {
                                   bool restoreOnFail,
                                   llvm::function_ref<bool(Constraint *)> pred);
 
-  bool isReadOnlyKeyPathComponent(const AbstractStorageDecl *storage) {
+  bool isReadOnlyKeyPathComponent(const AbstractStorageDecl *storage,
+                                  SourceLoc referenceLoc) {
     // See whether key paths can store to this component. (Key paths don't
     // get any special power from being formed in certain contexts, such
     // as the ability to assign to `let`s in initialization contexts, so
@@ -4638,6 +4639,17 @@ class ConstraintSystem {
       // a reference-writable component shows up later.
       return true;
     }
+    
+    // If the setter is unavailable, then the keypath ought to be read-only
+    // in this context.
+    if (auto setter = storage->getOpaqueAccessor(AccessorKind::Set)) {
+      auto maybeUnavail = TypeChecker::checkDeclarationAvailability(setter,
+                                                                    referenceLoc,
+                                                                    DC);
+      if (maybeUnavail.hasValue()) {
+        return true;
+      }
+    }
 
     return false;
   }

test/expr/unary/keypath/keypath-availability.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-frontend -target x86_64-apple-macosx10.9 -typecheck -verify %s
+// REQUIRES: OS=macosx
+
+struct Butt {
+    var setter_conditionally_available: Int {
+        get { fatalError() }
+
+        @available(macOS 10.10, *)
+        set { fatalError() }
+    }
+}
+
+func assertExactType<T>(of _: inout T, is _: T.Type) {}
+
+@available(macOS 10.9, *)
+public func unavailableSetterContext() {
+    var kp = \Butt.setter_conditionally_available
+    assertExactType(of: &kp, is: KeyPath<Butt, Int>.self)
+}
+@available(macOS 10.10, *)
+public func availableSetterContext() {
+    var kp = \Butt.setter_conditionally_available
+    assertExactType(of: &kp, is: WritableKeyPath<Butt, Int>.self)
+}
+@available(macOS 10.9, *)
+public func conditionalAvailableSetterContext() {
+    if #available(macOS 10.10, *) {
+        var kp = \Butt.setter_conditionally_available
+        assertExactType(of: &kp, is: WritableKeyPath<Butt, Int>.self)
+    } else {
+        var kp = \Butt.setter_conditionally_available
+        assertExactType(of: &kp, is: KeyPath<Butt, Int>.self)
+    }
+}
+