Merge pull request #12265 from slavapestov/sil-dynamic-method

Fold dynamic_method into objc_method

Author: slavapestov

docs/SIL.rst

@@ -1034,8 +1034,7 @@ VTables
   sil-vtable-entry ::= sil-decl-ref ':' sil-linkage? sil-function-name
 
 SIL represents dynamic dispatch for class methods using the `class_method`_,
-`super_method`_, `objc_method`_, `objc_super_method`_ and `dynamic_method`_
-instructions.
+`super_method`_, `objc_method`_, and `objc_super_method`_ instructions.
 
 The potential destinations for `class_method`_ and `super_method`_ are
 tracked in ``sil_vtable`` declarations for every class type. The declaration
@@ -2945,10 +2944,9 @@ These instructions perform dynamic lookup of class and generic methods.
 The ``class_method`` and ``super_method`` instructions must reference
 Swift native methods and always use vtable dispatch.
 
-The ``objc_method``, ``objc_super_method`` and ``dynamic_method``
-instructions must reference Objective-C methods (indicated by the
-``foreign`` marker on a method reference, as in
-``#NSObject.description!1.foreign``).
+The ``objc_method`` and ``objc_super_method`` instructions must reference
+Objective-C methods (indicated by the ``foreign`` marker on a method
+reference, as in ``#NSObject.description!1.foreign``).
 
 Note that ``objc_msgSend`` invocations can only be used as the callee
 of an ``apply`` instruction or ``partial_apply`` instruction. They cannot
@@ -3046,40 +3044,6 @@ archetype of the original protocol and have the ``witness_method`` calling
 convention. If the referenced protocol is an ``@objc`` protocol, the
 resulting type has the ``objc`` calling convention.
 
-dynamic_method
-``````````````
-::
-
-  sil-instruction ::= 'dynamic_method' sil-method-attributes?
-                      sil-operand ',' sil-decl-ref ':' sil-type
-
-  %1 = dynamic_method %0 : $P, #X.method!1 : $@convention(thin) U -> V
-  // %0 must be of a protocol or protocol composition type $P,
-  // where $P contains the Swift.DynamicLookup protocol
-  // #X.method!1 must be a reference to an @objc method of any class
-  // or protocol type
-  //
-  // The "self" argument of the method type $@convention(thin) U -> V must be
-  //   AnyObject
-
-Looks up the implementation of an Objective-C method with the same
-selector as the named method for the dynamic type of the
-value inside an existential container. The "self" operand of the result
-function value is represented using an opaque type, the value for which must
-be projected out as a value of type ``AnyObject``.
-
-It is undefined behavior if the dynamic type of the operand does not
-have an implementation for the Objective-C method with the selector to
-which the ``dynamic_method`` instruction refers, or if that
-implementation has parameter or result types that are incompatible
-with the method referenced by ``dynamic_method``.
-This instruction should only be used in cases where its result will be
-immediately consumed by an operation that performs the selector check
-itself (e.g., an ``apply`` that lowers to ``objc_msgSend``).
-To query whether the operand has an implementation for the given
-method and safely handle the case where it does not, use
-`dynamic_method_br`_.
-
 Function Application
 ~~~~~~~~~~~~~~~~~~~~
 

include/swift/SIL/PatternMatch.h

@@ -370,7 +370,6 @@ UNARY_OP_MATCH_WITH_ARG_MATCHER(ClassMethodInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ObjCMethodInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(SuperMethodInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ObjCSuperMethodInst)
-UNARY_OP_MATCH_WITH_ARG_MATCHER(DynamicMethodInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(OpenExistentialAddrInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(OpenExistentialRefInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(OpenExistentialValueInst)

include/swift/SIL/SILBuilder.h

@@ -1198,8 +1198,9 @@ class SILBuilder {
 
   ObjCMethodInst *createObjCMethod(SILLocation Loc, SILValue Operand,
                                    SILDeclRef Member, SILType MethodTy) {
-    return insert(new (getModule()) ObjCMethodInst(
-        getSILDebugLocation(Loc), Operand, Member, MethodTy));
+    return insert(ObjCMethodInst::create(
+        getSILDebugLocation(Loc), Operand, Member, MethodTy,
+        &getFunction(), OpenedArchetypes));
   }
 
   ObjCSuperMethodInst *createObjCSuperMethod(SILLocation Loc, SILValue Operand,
@@ -1217,13 +1218,6 @@ class SILBuilder {
         &getFunction(), OpenedArchetypes, Volatile));
   }
 
-  DynamicMethodInst *createDynamicMethod(SILLocation Loc, SILValue Operand,
-                                         SILDeclRef Member, SILType MethodTy) {
-    return insert(DynamicMethodInst::create(
-        getSILDebugLocation(Loc), Operand, Member, MethodTy,
-        &getFunction(), OpenedArchetypes));
-  }
-
   OpenExistentialAddrInst *
   createOpenExistentialAddr(SILLocation Loc, SILValue Operand, SILType SelfTy,
                             OpenedExistentialAccess ForAccess) {

include/swift/SIL/SILCloner.h

@@ -1557,7 +1557,7 @@ SILCloner<ImplClass>::visitObjCMethodInst(ObjCMethodInst *Inst) {
     getBuilder().createObjCMethod(getOpLocation(Inst->getLoc()),
                                   getOpValue(Inst->getOperand()),
                                   Inst->getMember(),
-                                  Inst->getType()));
+                                  getOpType(Inst->getType())));
 }
 
 template<typename ImplClass>
@@ -1601,17 +1601,6 @@ SILCloner<ImplClass>::visitWitnessMethodInst(WitnessMethodInst *Inst) {
               Inst->isVolatile()));
 }
 
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::visitDynamicMethodInst(DynamicMethodInst *Inst) {
-  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  doPostProcess(Inst,
-    getBuilder().createDynamicMethod(getOpLocation(Inst->getLoc()),
-                                     getOpValue(Inst->getOperand()),
-                                     Inst->getMember(),
-                                     getOpType(Inst->getType())));
-}
-
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitOpenExistentialAddrInst(OpenExistentialAddrInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -4870,15 +4870,24 @@ class SuperMethodInst
 /// ObjCMethodInst - Given the address of a value of class type and a method
 /// constant, extracts the implementation of that method for the dynamic
 /// instance type of the class.
-class ObjCMethodInst
-    : public UnaryInstructionBase<SILInstructionKind::ObjCMethodInst,
-                                  MethodInst>
+class ObjCMethodInst final
+    : public UnaryInstructionWithTypeDependentOperandsBase<
+          SILInstructionKind::ObjCMethodInst,
+          ObjCMethodInst,
+          MethodInst>
 {
   friend SILBuilder;
 
   ObjCMethodInst(SILDebugLocation DebugLoc, SILValue Operand,
+                 ArrayRef<SILValue> TypeDependentOperands,
                  SILDeclRef Member, SILType Ty)
-      : UnaryInstructionBase(DebugLoc, Operand, Ty, Member) {}
+      : UnaryInstructionWithTypeDependentOperandsBase(DebugLoc, Operand,
+                               TypeDependentOperands, Ty, Member) {}
+
+  static ObjCMethodInst *
+  create(SILDebugLocation DebugLoc, SILValue Operand,
+         SILDeclRef Member, SILType Ty, SILFunction *F,
+         SILOpenedArchetypesState &OpenedArchetypes);
 };
 
 /// ObjCSuperMethodInst - Given the address of a value of class type and a method
@@ -4921,6 +4930,18 @@ class WitnessMethodInst final
                                            TypeDependentOperands);
   }
 
+  /// Create a witness method call of a protocol requirement, passing in a lookup
+  /// type and conformance.
+  ///
+  /// At runtime, the witness is looked up in the conformance of the lookup type
+  /// to the protocol.
+  ///
+  /// The lookup type is usually an archetype, but it will be concrete if the
+  /// witness_method instruction is inside a function body that was specialized.
+  ///
+  /// The conformance must exactly match the requirement; the caller must handle
+  /// the case where the requirement is defined in a base protocol that is
+  /// refined by the conforming protocol.
   static WitnessMethodInst *
   create(SILDebugLocation DebugLoc, CanType LookupType,
          ProtocolConformanceRef Conformance, SILDeclRef Member, SILType Ty,
@@ -4962,30 +4983,6 @@ class WitnessMethodInst final
   }
 };
 
-/// Given the address of a value of AnyObject protocol type and a method
-/// constant referring to some Objective-C method, performs dynamic method
-/// lookup to extract the implementation of that method. This method lookup
-/// can fail at run-time
-class DynamicMethodInst final
-  : public UnaryInstructionWithTypeDependentOperandsBase<
-                                   SILInstructionKind::DynamicMethodInst,
-                                   DynamicMethodInst,
-                                   MethodInst>
-{
-  friend SILBuilder;
-
-  DynamicMethodInst(SILDebugLocation DebugLoc, SILValue Operand,
-                    ArrayRef<SILValue> TypeDependentOperands,
-                    SILDeclRef Member, SILType Ty)
-      : UnaryInstructionWithTypeDependentOperandsBase(DebugLoc, Operand,
-                               TypeDependentOperands, Ty, Member) {}
-
-  static DynamicMethodInst *
-  create(SILDebugLocation DebugLoc, SILValue Operand,
-         SILDeclRef Member, SILType Ty, SILFunction *F,
-         SILOpenedArchetypesState &OpenedArchetypes);
-};
-
 /// Access allowed to the opened value by the open_existential_addr instruction.
 /// Allowing mutable access to the opened existential requires a boxed
 /// existential value's box to be unique.

include/swift/SIL/SILNodes.def

@@ -255,9 +255,7 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                       MethodInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(WitnessMethodInst, witness_method,
                       MethodInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(DynamicMethodInst, dynamic_method,
-                      MethodInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST_RANGE(MethodInst, ClassMethodInst, DynamicMethodInst)
+    SINGLE_VALUE_INST_RANGE(MethodInst, ClassMethodInst, WitnessMethodInst)
 
   // Conversions
   ABSTRACT_SINGLE_VALUE_INST(ConversionInst, SingleValueInstruction)

lib/IRGen/IRGenSIL.cpp

@@ -895,7 +895,6 @@ class IRGenSILFunction :
   void visitObjCMethodInst(ObjCMethodInst *i);
   void visitObjCSuperMethodInst(ObjCSuperMethodInst *i);
   void visitWitnessMethodInst(WitnessMethodInst *i);
-  void visitDynamicMethodInst(DynamicMethodInst *i);
 
   void visitAllocValueBufferInst(AllocValueBufferInst *i);
   void visitProjectValueBufferInst(ProjectValueBufferInst *i);
@@ -5001,12 +5000,6 @@ IRGenSILFunction::visitProjectExistentialBoxInst(ProjectExistentialBoxInst *i) {
   }
 }
 
-void IRGenSILFunction::visitDynamicMethodInst(DynamicMethodInst *i) {
-  assert(i->getMember().isForeign && "dynamic_method requires [objc] method");
-  setLoweredObjCMethod(i, i->getMember());
-  return;
-}
-
 void IRGenSILFunction::visitWitnessMethodInst(swift::WitnessMethodInst *i) {
   // For Objective-C classes we need to arrange for a msgSend
   // to happen when the method is called.

lib/IRGen/LoadableByAddress.cpp

@@ -478,7 +478,6 @@ void LargeValueVisitor::mapValueStorage() {
       case SILInstructionKind::SuperMethodInst:
       case SILInstructionKind::ObjCMethodInst:
       case SILInstructionKind::ObjCSuperMethodInst:
-      case SILInstructionKind::DynamicMethodInst:
       case SILInstructionKind::WitnessMethodInst: {
         // TODO Any more instructions to add here?
         auto *MI = dyn_cast<MethodInst>(currIns);
@@ -2037,14 +2036,6 @@ static void rewriteFunction(StructLoweringState &pass,
                                                  newSILType);
       break;
     }
-    case SILInstructionKind::DynamicMethodInst: {
-      auto *DMI = dyn_cast<DynamicMethodInst>(instr);
-      assert(DMI && "ValueKind is Witness Method but dyn_cast failed");
-      SILValue selfValue = instr->getOperand(0);
-      newInstr = methodBuilder.createDynamicMethod(loc, selfValue, member,
-                                                   newSILType);
-      break;
-    }
     case SILInstructionKind::WitnessMethodInst: {
       auto *WMI = dyn_cast<WitnessMethodInst>(instr);
       assert(!WMI->isVolatile());

lib/ParseSIL/ParseSIL.cpp

@@ -3784,8 +3784,7 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
   case SILInstructionKind::ClassMethodInst:
   case SILInstructionKind::SuperMethodInst:
   case SILInstructionKind::ObjCMethodInst:
-  case SILInstructionKind::ObjCSuperMethodInst:
-  case SILInstructionKind::DynamicMethodInst: {
+  case SILInstructionKind::ObjCSuperMethodInst: {
     SILDeclRef Member;
     SILType MethodTy;
     SourceLoc TyLoc;
@@ -3816,9 +3815,6 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     case SILInstructionKind::ObjCSuperMethodInst:
       ResultVal = B.createObjCSuperMethod(InstLoc, Val, Member, MethodTy);
       break;
-    case SILInstructionKind::DynamicMethodInst:
-      ResultVal = B.createDynamicMethod(InstLoc, Val, Member, MethodTy);
-      break;
     }
     break;
   }

lib/SIL/SILInstructions.cpp

@@ -1592,18 +1592,6 @@ DynamicMethodBranchInst::create(SILDebugLocation Loc, SILValue Operand,
       DynamicMethodBranchInst(Loc, Operand, Member, HasMethodBB, NoMethodBB);
 }
 
-/// Create a witness method call of a protocol requirement, passing in a lookup
-/// type and conformance.
-///
-/// At runtime, the witness is looked up in the conformance of the lookup type
-/// to the protocol.
-///
-/// The lookup type is usually an archetype, but it will be concrete if the
-/// witness_method instruction is inside a function body that was specialized.
-///
-/// The conformance must exactly match the requirement; the caller must handle
-/// the case where the requirement is defined in a base protocol that is
-/// refined by the conforming protocol.
 WitnessMethodInst *
 WitnessMethodInst::create(SILDebugLocation Loc, CanType LookupType,
                           ProtocolConformanceRef Conformance, SILDeclRef Member,
@@ -1627,21 +1615,21 @@ WitnessMethodInst::create(SILDebugLocation Loc, CanType LookupType,
                                           Ty, TypeDependentOperands, Volatile);
 }
 
-DynamicMethodInst *
-DynamicMethodInst::create(SILDebugLocation DebugLoc, SILValue Operand,
-                          SILDeclRef Member, SILType Ty, SILFunction *F,
-                          SILOpenedArchetypesState &OpenedArchetypes) {
+ObjCMethodInst *
+ObjCMethodInst::create(SILDebugLocation DebugLoc, SILValue Operand,
+                       SILDeclRef Member, SILType Ty, SILFunction *F,
+                       SILOpenedArchetypesState &OpenedArchetypes) {
   SILModule &Mod = F->getModule();
   SmallVector<SILValue, 8> TypeDependentOperands;
   collectTypeDependentOperands(TypeDependentOperands, OpenedArchetypes, *F,
                                Ty.getSwiftRValueType());
 
   unsigned size =
       totalSizeToAlloc<swift::Operand>(1 + TypeDependentOperands.size());
-  void *Buffer = Mod.allocateInst(size, alignof(DynamicMethodInst));
-  return ::new (Buffer) DynamicMethodInst(DebugLoc, Operand,
-                                          TypeDependentOperands,
-                                          Member, Ty);
+  void *Buffer = Mod.allocateInst(size, alignof(ObjCMethodInst));
+  return ::new (Buffer) ObjCMethodInst(DebugLoc, Operand,
+                                       TypeDependentOperands,
+                                       Member, Ty);
 }
 
 InitExistentialAddrInst *InitExistentialAddrInst::create(

lib/SIL/SILOwnershipVerifier.cpp

@@ -609,7 +609,6 @@ ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, SuperMethod)
 ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, ObjCSuperMethod)
 ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, BridgeObjectToWord)
 ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, CopyBlock)
-ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, DynamicMethod)
 ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, OpenExistentialBox)
 ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, RefTailAddr)
 ACCEPTS_ANY_NONTRIVIAL_OWNERSHIP(MustBeLive, RefToRawPointer)

lib/SIL/SILPrinter.cpp

@@ -1631,12 +1631,6 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
     *this << " : " << WMI->getType();
   }
-  void visitDynamicMethodInst(DynamicMethodInst *DMI) {
-    printMethodInst(DMI, DMI->getOperand());
-    *this << " : " << DMI->getMember().getDecl()->getInterfaceType();
-    *this << ", ";
-    *this << DMI->getType();
-  }
   void visitOpenExistentialAddrInst(OpenExistentialAddrInst *OI) {
     if (OI->getAccessKind() == OpenedExistentialAccess::Immutable)
       *this << "immutable_access ";