[TypeChecker] Fix dynamic member declaration validation to check labels

Author: xedin

lib/Sema/TypeCheckAttr.cpp

@@ -975,13 +975,17 @@ visitDynamicCallableAttr(DynamicCallableAttr *attr) {
   }
 }
 
-static bool hasSingleNonVariadicParam(SubscriptDecl *decl) {
+static bool hasSingleNonVariadicParam(SubscriptDecl *decl,
+                                      Identifier expectedLabel) {
   auto *indices = decl->getIndices();
   if (decl->isInvalid() || indices->size() != 1)
     return false;
 
   auto *index = indices->get(0);
-  return !index->isVariadic() && index->hasValidSignature();
+  if (index->isVariadic() || !index->hasValidSignature())
+    return false;
+
+  return index->getArgumentName() == expectedLabel;
 }
 
 /// Returns true if the given subscript method is an valid implementation of
@@ -1004,7 +1008,7 @@ bool swift::isValidStringDynamicMemberLookup(SubscriptDecl *decl,
   // There are two requirements:
   // - The subscript method has exactly one, non-variadic parameter.
   // - The parameter type conforms to `ExpressibleByStringLiteral`.
-  if (!hasSingleNonVariadicParam(decl))
+  if (!hasSingleNonVariadicParam(decl, TC.Context.Id_dynamicMember))
     return false;
 
   const auto *param = decl->getIndices()->get(0);
@@ -1020,7 +1024,7 @@ bool swift::isValidStringDynamicMemberLookup(SubscriptDecl *decl,
 
 bool swift::isValidKeyPathDynamicMemberLookup(SubscriptDecl *decl,
                                               TypeChecker &TC) {
-  if (!hasSingleNonVariadicParam(decl))
+  if (!hasSingleNonVariadicParam(decl, TC.Context.Id_dynamicMember))
     return false;
 
   const auto *param = decl->getIndices()->get(0);

test/Constraints/keypath_dynamic_member_lookup.swift

@@ -179,3 +179,30 @@ func dot_class_test(_ lens: inout DotLens<DotClass>) {
   // CHECK: keypath $ReferenceWritableKeyPath<DotClass, Int>, (root $DotClass; settable_property $Int,  id #DotClass.y!getter.1 : (DotClass) -> () -> Int, getter @$s29keypath_dynamic_member_lookup8DotClassC1ySivpACTK : {{.*}})
   let _ = lens.y
 }
+
+@dynamicMemberLookup
+struct OverloadedLens<T> {
+  var value: T
+
+  subscript<U>(keyPath: KeyPath<T, U>) -> U {
+    get { return value[keyPath: keyPath] }
+  }
+
+  subscript<U>(dynamicMember keyPath: KeyPath<T, U>) -> U {
+    get { return value[keyPath: keyPath] }
+  }
+}
+
+// Make sure if there is a subscript which accepts key path,
+// existing dynamic member overloads wouldn't interfere.
+func test_direct_subscript_ref(_ lens: OverloadedLens<Point>) {
+  // CHECK: function_ref @$s29keypath_dynamic_member_lookup14OverloadedLensVyqd__s7KeyPathCyxqd__Gcluig
+  _ = lens[\.x]
+  // CHECK: function_ref @$s29keypath_dynamic_member_lookup14OverloadedLensVyqd__s7KeyPathCyxqd__Gcluig
+  _ = lens[\.y]
+
+  // CHECK: function_ref @$s29keypath_dynamic_member_lookup14OverloadedLensV0B6Memberqd__s7KeyPathCyxqd__G_tcluig
+  _ = lens.x
+  // CHECK: function_ref @$s29keypath_dynamic_member_lookup14OverloadedLensV0B6Memberqd__s7KeyPathCyxqd__G_tcluig
+  _ = lens.y
+}

test/attr/attr_dynamic_member_lookup.swift

@@ -576,7 +576,7 @@ func keypath_with_subscripts(_ arr: SubscriptLens<[Int]>,
   _ = arr["hello"]  // Ok
   _ = dict["hello"] // Ok
 
-  _ = arr["hello"] = 42 // expected-error {{cannot assign through subscript: 'arr' is a 'let' constant}}
+  _ = arr["hello"] = 42 // expected-error {{cannot assign through subscript: subscript is get-only}}
   _ = dict["hello"] = 0 // Ok
 
   _ = arr[0] = 42 // expected-error {{cannot assign through subscript: 'arr' is a 'let' constant}}

test/expr/unary/keypath/keypath.swift

@@ -350,9 +350,9 @@ func testKeyPathSubscript(readonly: ZwithSubscript, writable: inout ZwithSubscri
   sink = writable[keyPath: wkp]
   sink = readonly[keyPath: rkp]
   sink = writable[keyPath: rkp]
-  readonly[keyPath: kp] = sink  // expected-error {{cannot assign through subscript: 'kp' is a read-only key path}}
-  writable[keyPath: kp] = sink  // expected-error {{cannot assign through subscript: 'kp' is a read-only key path}}
-  readonly[keyPath: wkp] = sink // expected-error {{cannot assign through subscript: 'readonly' is a 'let' constant}}
+  readonly[keyPath: kp] = sink  // expected-error {{cannot assign through subscript: subscript is get-only}}
+  writable[keyPath: kp] = sink  // expected-error {{cannot assign through subscript: subscript is get-only}}
+  readonly[keyPath: wkp] = sink // expected-error {{cannot assign through subscript: subscript is get-only}}
   // FIXME: silently falls back to keypath application, which seems inconsistent
   writable[keyPath: wkp] = sink
   // FIXME: silently falls back to keypath application, which seems inconsistent