Noncopyable: prevent keypaths from accessing

We don't yet have keypaths working correctly to allow access to
noncopyable fields, so we should raise a friendly error in Sema rather
than an error-out elsewhere vaguely.

resolves rdar://109287447

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -654,6 +654,8 @@ ERROR(expr_keypath_type_of_property,none,
       (DeclNameRef, Type))
 ERROR(expr_keypath_generic_type,none,
       "key path cannot refer to generic type %0", (Identifier))
+ERROR(expr_keypath_noncopyable_type,none,
+      "key path cannot refer to noncopyable type %0", (Type))
 ERROR(expr_keypath_not_property,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to %kind0",
       (const ValueDecl *, bool))

lib/Sema/MiscDiagnostics.cpp

@@ -168,10 +168,8 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       if (isa<TypeExpr>(Base))
         checkUseOfMetaTypeName(Base);
 
-      if (auto *KPE = dyn_cast<KeyPathExpr>(E)) {
-        // raise an error if this KeyPath contains an effectful member.
-        checkForEffectfulKeyPath(KPE);
-      }
+      if (auto *KPE = dyn_cast<KeyPathExpr>(E))
+        checkForInvalidKeyPath(KPE);
 
       // Check function calls, looking through implicit conversions on the
       // function and inspecting the arguments directly.
@@ -364,11 +362,15 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
     }
 
     /// Visit each component of the keypath and emit a diagnostic if they
-    /// refer to a member that has effects.
-    void checkForEffectfulKeyPath(KeyPathExpr *keyPath) {
+    /// refer to a member that meets any of the following:
+    ///   - has effects.
+    ///   - is a noncopyable type.
+    void checkForInvalidKeyPath(KeyPathExpr *keyPath) {
       for (const auto &component : keyPath->getComponents()) {
         if (component.hasDeclRef()) {
           auto decl = component.getDeclRef().getDecl();
+
+          // Check for effects
           if (auto asd = dyn_cast<AbstractStorageDecl>(decl)) {
             if (auto getter = asd->getEffectfulGetAccessor()) {
               Ctx.Diags.diagnose(component.getLoc(),
@@ -378,6 +380,13 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
                                  asd->getDescriptiveKind());
             }
           }
+
+          // Check for the ability to copy.
+          if (component.getComponentType()->isNoncopyable()) {
+            Ctx.Diags.diagnose(component.getLoc(),
+                               diag::expr_keypath_noncopyable_type,
+                               component.getComponentType()->getRValueType());
+          }
         }
       }
     }

test/Sema/keypaths_noncopyable.swift

@@ -0,0 +1,63 @@
+// RUN: %target-typecheck-verify-swift
+
+public protocol P: ~Copyable {
+    var protocolProp: String { get }
+}
+
+public struct NC: ~Copyable {
+   var data: [Int] = []
+   var next: Box<NC>? = nil
+}
+
+public struct M<T: ~Copyable & P>: ~Copyable {
+   var nc: NC
+   var string: String
+   let ncg: T
+   init(_ t: consuming T) {
+    self.string = ""
+    self.nc = NC()
+    self.ncg = t
+   }
+}
+
+public class Box<Wrapped: ~Copyable> {
+  var wrapped: Wrapped
+  init(_ t: consuming Wrapped) { self.wrapped = t }
+  func with<T: ~Copyable>(_ op: (borrowing Wrapped)->T) -> T { op(wrapped) }
+}
+
+class A {
+  var b: B
+  init(_ b: consuming B) { self.b = b }
+}
+struct B: ~Copyable {
+  var c: C
+}
+struct C {
+  var d: Int
+}
+
+// rdar://109287447
+public func testKeypath<V: ~Copyable>(m: consuming M<V>) {
+  _ = m[keyPath: \.nc] // expected-error {{key path cannot refer to noncopyable type 'NC'}}
+  _ = m[keyPath: \.nc.data] // expected-error {{key path cannot refer to noncopyable type 'NC'}}
+  _ = m[keyPath: \.ncg] // expected-error {{key path cannot refer to noncopyable type 'V'}}
+  _ = m[keyPath: \.ncg.protocolProp] // expected-error {{key path cannot refer to noncopyable type 'V'}}
+  _ = m[keyPath: \.string]
+
+  let b = Box(NC())
+  _ = b.with(\.data)
+  _ = b.with(\.next)
+  _ = b.with(\.next?.wrapped) // expected-error {{key path cannot refer to noncopyable type 'NC'}}
+  _ = b.with(\.next!.wrapped.data) // expected-error {{key path cannot refer to noncopyable type 'NC'}}
+}
+
+// rdar://109162739
+func testKeypath2(_ someA: A) -> Int {
+  let kp: KeyPath<A, Int> = \A.b.c.d  // expected-error {{key path cannot refer to noncopyable type 'B'}}
+  return someA[keyPath: kp]
+}
+func testAsFunc(_ someA: A) -> Int {
+  let fn: (A) -> Int = \A.b.c.d // expected-error {{key path cannot refer to noncopyable type 'B'}}
+  return fn(someA)
+}