SILGen: Handle key paths with @objc optional property components

Author: AnthonyLatsis

lib/SILGen/SILGenExpr.cpp

@@ -2843,13 +2843,27 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
   auto subscriptIndices =
     loadIndexValuesForKeyPathComponent(subSGF, loc, property,
                                        indexes, indexPtrArg);
-  
-  auto resultSubst = subSGF.emitRValueForStorageLoad(loc, baseSubstValue,
-                                   baseType, /*super*/false,
-                                   property, std::move(subscriptIndices),
-                                   subs, AccessSemantics::Ordinary,
-                                   propertyType, SGFContext())
-    .getAsSingleValue(subSGF, loc);
+
+  ManagedValue resultSubst;
+  {
+    RValue resultRValue;
+
+    // Emit a dynamic method branch if the storage decl is an @objc optional
+    // requirement, or just a load otherwise.
+    if (property->getAttrs().hasAttribute<OptionalAttr>() &&
+        isa<VarDecl>(property)) {
+      resultRValue = subSGF.emitDynamicMemberRef(
+          loc, baseSubstValue.getValue(), ConcreteDeclRef(property, subs),
+          propertyType, SGFContext());
+    } else {
+      resultRValue = subSGF.emitRValueForStorageLoad(
+          loc, baseSubstValue, baseType, /*super*/ false, property,
+          std::move(subscriptIndices), subs, AccessSemantics::Ordinary,
+          propertyType, SGFContext());
+    }
+    resultSubst = std::move(resultRValue).getAsSingleValue(subSGF, loc);
+  }
+
   if (resultSubst.getType().getAddressType() != resultArg->getType())
     resultSubst = subSGF.emitSubstToOrigValue(loc, resultSubst,
                                          AbstractionPattern::getOpaque(),
@@ -3561,6 +3575,12 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
           ->mapTypeOutOfContext()
           ->getCanonicalType(
                       genericEnv ? genericEnv->getGenericSignature() : nullptr);
+
+      // The component type for an @objc optional requirement needs to be
+      // wrapped in an optional.
+      if (var->getAttrs().hasAttribute<OptionalAttr>()) {
+        componentTy = OptionalType::get(componentTy)->getCanonicalType();
+      }
     }
 
     if (canStorageUseStoredKeyPathComponent(var, expansion)) {

test/SILGen/keypaths_objc.swift

@@ -156,4 +156,21 @@ func dynamicMemberLookupMixedKeypaths(foo: DynamicClass<Foo>) {
   // CHECK: keypath $KeyPath<Foo, NonObjC>, (root
   // CHECK: keypath $KeyPath<NonObjC, NSObject>, (root
   _ = foo.bar.foo.nonobjc.y 
-}
+}
+
+@objc protocol ObjCProtoOptional {
+  @objc optional var optionalProperty: Bool { get }
+}
+
+// CHECK-LABEL: sil hidden [ossa] @{{.*}}0B28ProtocolOptionalRequirementsyyF
+// CHECK: keypath $KeyPath<ObjCProtoOptional, Optional<Bool>>, (objc "optionalProperty"; root $ObjCProtoOptional; gettable_property $Optional<Bool>,  id #ObjCProtoOptional.optionalProperty!getter.foreign : <Self where Self : ObjCProtoOptional> (Self) -> () -> Bool, getter @$[[PROP_GETTER:[_a-zA-Z0-9]+]]
+// CHECK: } // end sil function '${{.*}}0B28ProtocolOptionalRequirementsyyF'
+//
+// CHECK: sil shared [thunk] [ossa] @$[[PROP_GETTER]] : $@convention(thin) (@in_guaranteed ObjCProtoOptional) -> @out Optional<Bool> {
+// CHECK:   [[BASE:%[0-9]+]] = open_existential_ref {{%[0-9]+}} : $ObjCProtoOptional to $[[OPENED_TY:@opened\("[-A-F0-9]+"\) ObjCProtoOptional]]
+// CHECK:   dynamic_method_br [[BASE]] : $[[OPENED_TY]], #ObjCProtoOptional.optionalProperty!getter.foreign, bb1
+// CHECK: bb1({{%[0-9]+}} : $@convention(objc_method) ([[OPENED_TY]]) -> ObjCBool)
+// CHECK: } // end sil function '$[[PROP_GETTER]]'
+func objcProtocolOptionalRequirements() {
+  _ = \ObjCProtoOptional.optionalProperty
+}