Partial application of @objc protocol methods

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -1849,7 +1849,6 @@ ERROR(partial_application_of_function_invalid,tce_sema,none,
       "partial application of %select{"
         "function with 'inout' parameters|"
         "'mutating' method|"
-        "method in @objc protocol|"
         "'super.init' initializer chain|"
         "'self.init' initializer delegation"
       "}0 is not allowed",

lib/SIL/SILDeclRef.cpp

@@ -336,6 +336,11 @@ bool SILDeclRef::isForeignToNativeThunk() const {
   // Otherwise, match whether we have a clang node with whether we're foreign.
   if (isa<FuncDecl>(getDecl()) && getDecl()->hasClangNode())
     return !isForeign;
+  // Objective-C protocol methods also require a foreign to native thunk.
+  auto dc = getDecl()->getDeclContext();
+  if (auto proto = dyn_cast<ProtocolDecl>(dc))
+    if (proto->isObjC())
+      return !isForeign;
   // ObjC initializing constructors and factories are foreign.
   // We emit a special native allocating constructor though.
   if (isa<ConstructorDecl>(getDecl())

lib/SILGen/SILGenBridging.cpp

@@ -968,14 +968,30 @@ getThunkedForeignFunctionRef(SILGenFunction &gen,
                              SILLocation loc,
                              SILDeclRef foreign,
                              ArrayRef<ManagedValue> args,
+                             ArrayRef<Substitution> subs,
                              const SILConstantInfo &foreignCI) {
   assert(!foreign.isCurried
          && "should not thunk calling convention when curried");
 
-  // Produce a class_method when thunking ObjC methods.
-  auto foreignTy = foreignCI.SILFnType;
-  if (foreignTy->getRepresentation()
+  // Produce a witness_method when thunking ObjC protocol methods.
+  auto dc = foreign.getDecl()->getDeclContext();
+  if (isa<ProtocolDecl>(dc) && cast<ProtocolDecl>(dc)->isObjC()) {
+    assert(subs.size() == 1);
+    auto thisType = subs[0].getReplacement()->getCanonicalType();
+    assert(isa<ArchetypeType>(thisType) && "no archetype for witness?!");
+    SILValue thisArg = args.back().getValue();
+
+    SILValue OpenedExistential;
+    if (!cast<ArchetypeType>(thisType)->getOpenedExistentialType().isNull())
+      OpenedExistential = thisArg;
+    return gen.B.createWitnessMethod(loc, thisType, nullptr, foreign,
+                                     foreignCI.getSILType(),
+                                     OpenedExistential);
+
+  // Produce a class_method when thunking imported ObjC methods.
+  } else if (foreignCI.SILFnType->getRepresentation()
         == SILFunctionTypeRepresentation::ObjCMethod) {
+    assert(subs.empty());
     SILValue thisArg = args.back().getValue();
 
     return gen.B.createClassMethod(loc, thisArg, foreign,
@@ -1101,12 +1117,19 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
     maybeAddForeignErrorArg();
 
     // Call the original.
-    auto fn = getThunkedForeignFunctionRef(*this, fd, foreignDeclRef, args,
+    auto subs = getForwardingSubstitutions();
+    auto fn = getThunkedForeignFunctionRef(*this, fd, foreignDeclRef, args, subs,
                                            foreignCI);
-    result = emitMonomorphicApply(fd, ManagedValue::forUnmanaged(fn),
-                                  args,
-                                  nativeFormalResultTy,
-                                  ApplyOptions::None, None, foreignError)
+
+    auto fnType = fn.getType().castTo<SILFunctionType>();
+    fnType = fnType->substGenericArgs(SGM.M, SGM.SwiftModule, subs);
+
+    result = emitApply(fd, ManagedValue::forUnmanaged(fn),
+                       subs, args, fnType,
+                       AbstractionPattern(nativeFormalResultTy),
+                       nativeFormalResultTy,
+                       ApplyOptions::None, None, foreignError,
+                       SGFContext())
       .forward(*this);
   }
   B.createReturn(ImplicitReturnLocation::getImplicitReturnLoc(fd), result);

lib/SILGen/SILGenFunction.cpp

@@ -146,8 +146,16 @@ SILValue SILGenFunction::emitGlobalFunctionRef(SILLocation loc,
                                  constant.uncurryLevel + 1);
       // If the function is fully uncurried and natively foreign, reference its
       // foreign entry point.
-      if (!next.isCurried && vd->hasClangNode())
-        next = next.asForeign();
+      if (!next.isCurried) {
+        if (vd->hasClangNode())
+          next = next.asForeign();
+
+        // Objective-C protocol methods also require a foreign to native thunk.
+        auto dc = vd->getDeclContext();
+        if (auto proto = dyn_cast<ProtocolDecl>(dc))
+          if (proto->isObjC())
+            next = next.asForeign();
+      }
 
       // Preserve whether the curry thunks lead to a direct reference to the
       // method implementation.

lib/Sema/MiscDiagnostics.cpp

@@ -115,7 +115,6 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
       enum : unsigned {
         Function,
         MutatingMethod,
-        ObjCProtocolMethod,
         SuperInit,
         SelfInit,
       };
@@ -136,32 +135,6 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
       }
     }
 
-    /// If this is an application of a function that cannot be partially
-    /// applied, arrange for us to check that it gets fully applied.
-    void recordUnsupportedPartialApply(DeclRefExpr *expr) {
-      bool requiresFullApply = false;
-      unsigned kind;
-
-      auto fn = dyn_cast<FuncDecl>(expr->getDecl());
-      if (!fn)
-        return;
-
-      // @objc protocol methods cannot be partially applied.
-      if (auto proto = fn->getDeclContext()->isProtocolOrProtocolExtensionContext()) {
-        if (proto->isObjC()) {
-          requiresFullApply = true;
-          kind = PartialApplication::ObjCProtocolMethod;
-        }
-      }
-
-      if (requiresFullApply) {
-        // We need to apply all argument clauses.
-        InvalidPartialApplications.insert({
-          expr, {fn->getNaturalArgumentCount(), kind}
-        });
-      }
-    }
-
     /// If this is an application of a function that cannot be partially
     /// applied, arrange for us to check that it gets fully applied.
     void recordUnsupportedPartialApply(ApplyExpr *expr, Expr *fnExpr) {
@@ -181,8 +154,6 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
       if (!fnDeclRef)
         return;
 
-      recordUnsupportedPartialApply(fnDeclRef);
-
       auto fn = dyn_cast<FuncDecl>(fnDeclRef->getDecl());
       if (!fn)
         return;
@@ -203,11 +174,6 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
     /// This method is called in post-order over the AST to validate that
     /// methods are fully applied when they can't support partial application.
     void checkInvalidPartialApplication(Expr *E) {
-      if (auto DRE = dyn_cast<DeclRefExpr>(E)) {
-        recordUnsupportedPartialApply(DRE);
-        return;
-      }
-
       if (auto AE = dyn_cast<ApplyExpr>(E)) {
         Expr *fnExpr = AE->getFn()->getSemanticsProvidingExpr();
         if (auto forceExpr = dyn_cast<ForceValueExpr>(fnExpr))

test/Constraints/members_objc.swift

@@ -5,18 +5,18 @@ import Swift
 @objc
 protocol P2 {
   func bar(x: Int)
+  static func pub(x: Int)
 }
 
 func existential(p2 : P2) {
-  _ = p2.bar // expected-error{{partial application of method in @objc protocol is not allowed}}
+  _ = p2.bar
+  _ = P2.bar
 }
 
 func archetype<T: P2>(p2 : T) {
-  _ = p2.bar // expected-error{{partial application of method in @objc protocol is not allowed}}
-}
-
-func archetypeMeta<T: P2>(p2 : T) {
-  _ = T.bar // expected-error {{partial application of method in @objc protocol is not allowed}}
+  _ = p2.bar
+  _ = T.bar
+  _ = T.pub
 }
 
 // rdar://problem/22012606 - test applications of subscript members of class-constrained protocols
@@ -31,4 +31,4 @@ func archetypeMeta<T: P2>(p2 : T) {
 func test_subject_ClassConstrainedSubscript() {
   let list: subject_ClassConstrainedSubscript! = test_HasSubscript()
   list[0]
-}
+}

test/SILGen/objc_protocols.swift

@@ -10,6 +10,8 @@ import objc_protocols_Bas
   func copyRuncing() -> NSObject
 
   func foo()
+
+  static func mince() -> NSObject
 }
 
 @objc protocol NSFunging {
@@ -37,6 +39,47 @@ func objc_generic<T : NSRuncing>(x: T) -> (NSObject, NSObject) {
   // CHECK: release [[THIS2]]
 }
 
+func objc_generic_partial_apply<T : NSRuncing>(x: T) {
+  // CHECK:      [[FN:%.*]] = function_ref @_TTOFP14objc_protocols9NSRuncing5runceFT_CSo8NSObject
+  // CHECK-NEXT: strong_retain %0
+  // CHECK-NEXT: [[METHOD:%.*]] = apply [[FN]]<T>(%0)
+  // CHECK-NEXT: strong_release [[METHOD]]
+  _ = x.runce
+
+  // CHECK:      [[FN:%.*]] = function_ref @_TTOFP14objc_protocols9NSRuncing5runceFT_CSo8NSObject
+  // CHECK-NEXT: [[METHOD:%.*]] = partial_apply [[FN]]<T>()
+  // CHECK-NEXT: strong_release [[METHOD]]
+  _ = T.runce
+
+  // CHECK:      [[FN:%.*]] = function_ref @_TTOZFP14objc_protocols9NSRuncing5minceFT_CSo8NSObject
+  // CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thick T.Type
+  // CHECK-NEXT: [[METHOD:%.*]] = apply [[FN]]<T>([[METATYPE]])
+  // CHECK-NEXT: strong_release [[METHOD:%.*]]
+  _ = T.mince
+}
+
+// CHECK-LABEL: sil shared @_TTOFP14objc_protocols9NSRuncing5runceFT_CSo8NSObject
+// CHECK:      [[FN:%.*]] = function_ref @_TTOFP14objc_protocols9NSRuncing5runcefT_CSo8NSObject
+// CHECK-NEXT: [[METHOD:%.*]] = partial_apply [[FN]]<Self>(%0)
+// CHECK-NEXT: return [[METHOD]]
+
+// CHECK-LABEL: sil shared @_TTOFP14objc_protocols9NSRuncing5runcefT_CSo8NSObject
+// CHECK:      strong_retain %0
+// CHECK-NEXT: [[FN:%.*]] = witness_method $Self, #NSRuncing.runce!1.foreign
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]]<Self>(%0)
+// CHECK-NEXT: strong_release %0
+// CHECK-NEXT: return [[RESULT]]
+
+// CHECK-LABEL: sil shared @_TTOZFP14objc_protocols9NSRuncing5minceFT_CSo8NSObject
+// CHECK:      [[FN:%.*]] = function_ref @_TTOZFP14objc_protocols9NSRuncing5mincefT_CSo8NSObject
+// CHECK-NEXT: [[METHOD:%.*]] = partial_apply [[FN]]<Self>(%0)
+// CHECK-NEXT: return [[METHOD]]
+
+// CHECK-LABEL: sil shared @_TTOZFP14objc_protocols9NSRuncing5mincefT_CSo8NSObject
+// CHECK:      [[FN:%.*]] = witness_method $Self, #NSRuncing.mince!1.foreign
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]]<Self>(%0)
+// CHECK-NEXT: return [[RESULT]]
+
 // CHECK-LABEL: sil hidden  @_TF14objc_protocols13objc_protocol
 func objc_protocol(x: NSRuncing) -> (NSObject, NSObject) {
   return (x.runce(), x.copyRuncing())
@@ -54,6 +97,19 @@ func objc_protocol(x: NSRuncing) -> (NSObject, NSObject) {
   // CHECK: release [[THIS2_ORIG]]
 }
 
+func objc_protocol_partial_apply(x: NSRuncing) {
+  // CHECK: [[THIS1:%.*]] = open_existential_ref %0 : $NSRuncing to $[[OPENED:@opened(.*) NSRuncing]]
+  // CHECK: [[FN:%.*]] = function_ref @_TTOFP14objc_protocols9NSRuncing5runceFT_CSo8NSObject
+  // CHECK: strong_retain [[THIS1]]
+  // CHECK: [[RESULT:%.*]] = apply [[FN]]<[[OPENED]]>([[THIS1]])
+  // CHECK: strong_release [[RESULT]]
+  // CHECK: strong_release %0
+  _ = x.runce
+
+  // FIXME: rdar://21289579
+  // _ = NSRuncing.runce
+}
+
 // CHECK-LABEL: sil hidden  @_TF14objc_protocols25objc_protocol_composition
 func objc_protocol_composition(x: protocol<NSRuncing, NSFunging>) {
   // CHECK: [[THIS:%.*]] = open_existential_ref [[THIS_ORIG:%.*]] : $protocol<NSFunging, NSRuncing> to $[[OPENED:@opened(.*) protocol<NSFunging, NSRuncing>]]
@@ -73,6 +129,8 @@ class Foo : NSRuncing, NSFunging, Ansible {
   @objc func runce() -> NSObject { return NSObject() }
   @objc func copyRuncing() -> NSObject { return NSObject() }
 
+  @objc static func mince() -> NSObject { return NSObject() }
+
   // -- NSFunging
   @objc func funge() {}
 
@@ -95,6 +153,7 @@ extension Bar : NSRuncing {
   @objc func runce() -> NSObject { return NSObject() }
   @objc func copyRuncing() -> NSObject { return NSObject() }
   @objc func foo() {}
+  @objc static func mince() -> NSObject { return NSObject() }
 }
 
 // CHECK-LABEL: sil hidden [thunk] @_TToFC14objc_protocols3Bar5runce
@@ -106,6 +165,7 @@ extension Bas : NSRuncing {
   // runce() implementation from the original definition of Bas
   @objc func copyRuncing() -> NSObject { return NSObject() }
   @objc func foo() {}
+  @objc static func mince() -> NSObject { return NSObject() }
 }
 
 // CHECK-LABEL: sil hidden [thunk] @_TToFE14objc_protocolsC18objc_protocols_Bas3Bas11copyRuncing