[Runtime] SE-0143: Evaluate conditional conformances at runtime.

CHANGELOG.md

@@ -29,6 +29,12 @@ Swift 5.0
   circumstances with very simple values, so this is unlikely to affect
   real-world code.)
 
+* [SE-0143][]
+
+	Runtime query of conditional conformances is now implemented. Therefore,
+	a dynamic cast such as `value as? P`, where the dynamic type of `value`
+	conditional conforms to `P`, will succeed when the conditional
+	requirements are met.
 
 Swift 4.1
 ---------

include/swift/Runtime/Metadata.h

@@ -2278,6 +2278,13 @@ struct TargetTypeMetadataRecord {
 
 using TypeMetadataRecord = TargetTypeMetadataRecord<InProcess>;
 
+template<typename Runtime> struct TargetContextDescriptor;
+
+template<typename Runtime>
+using RelativeContextPointer =
+  RelativeIndirectablePointer<const TargetContextDescriptor<Runtime>,
+                              /*nullable*/ true>;
+
 /// The structure of a protocol reference record.
 template <typename Runtime>
 struct TargetProtocolRecord {
@@ -2290,18 +2297,37 @@ struct TargetProtocolRecord {
 };
 using ProtocolRecord = TargetProtocolRecord<InProcess>;
 
+template<typename Runtime> class TargetGenericRequirementDescriptor;
+
 /// The structure of a protocol conformance.
 ///
 /// This contains enough static information to recover the witness table for a
 /// type's conformance to a protocol.
 template <typename Runtime>
-struct TargetProtocolConformanceDescriptor {
+struct TargetProtocolConformanceDescriptor final
+  : public swift::ABI::TrailingObjects<
+             TargetProtocolConformanceDescriptor<Runtime>,
+             RelativeContextPointer<Runtime>,
+             TargetGenericRequirementDescriptor<Runtime>> {
+
+  using TrailingObjects = swift::ABI::TrailingObjects<
+                             TargetProtocolConformanceDescriptor<Runtime>,
+                             RelativeContextPointer<Runtime>,
+                             TargetGenericRequirementDescriptor<Runtime>>;
+  friend TrailingObjects;
+
+  template<typename T>
+  using OverloadToken = typename TrailingObjects::template OverloadToken<T>;
+
 public:
   using WitnessTableAccessorFn
     = const TargetWitnessTable<Runtime> *(const TargetMetadata<Runtime>*,
                                           const TargetWitnessTable<Runtime> **,
                                           size_t);
 
+  using GenericRequirementDescriptor =
+    TargetGenericRequirementDescriptor<Runtime>;
+
 private:
   /// The protocol being conformed to.
   ///
@@ -2381,7 +2407,22 @@ struct TargetProtocolConformanceDescriptor {
 
     return nullptr;
   }
-
+
+  /// Retrieve the context of a retroactive conformance.
+  const TargetContextDescriptor<Runtime> *getRetroactiveContext() const {
+    if (!Flags.isRetroactive()) return nullptr;
+
+    return this->template getTrailingObjects<RelativeContextPointer<Runtime>>();
+  }
+
+  /// Retrieve the conditional requirements that must also be
+  /// satisfied
+  llvm::ArrayRef<GenericRequirementDescriptor>
+  getConditionalRequirements() const {
+    return {this->template getTrailingObjects<GenericRequirementDescriptor>(),
+            Flags.getNumConditionalRequirements()};
+  }
+
   /// Get the directly-referenced static witness table.
   const swift::TargetWitnessTable<Runtime> *getStaticWitnessTable() const {
     switch (getConformanceKind()) {
@@ -2416,7 +2457,7 @@ struct TargetProtocolConformanceDescriptor {
   /// type.
   const swift::TargetWitnessTable<Runtime> *
   getWitnessTable(const TargetMetadata<Runtime> *type) const;
-  
+
 #if !defined(NDEBUG) && SWIFT_OBJC_INTEROP
   void dump() const;
 #endif
@@ -2430,6 +2471,16 @@ struct TargetProtocolConformanceDescriptor {
   /// 2. Has a valid conformance kind.
   void verify() const LLVM_ATTRIBUTE_USED;
 #endif
+
+private:
+  size_t numTrailingObjects(
+                        OverloadToken<RelativeContextPointer<Runtime>>) const {
+    return Flags.isRetroactive() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericRequirementDescriptor>) const {
+    return Flags.getNumConditionalRequirements();
+  }
 };
 using ProtocolConformanceDescriptor
   = TargetProtocolConformanceDescriptor<InProcess>;
@@ -2441,14 +2492,6 @@ using TargetProtocolConformanceRecord =
 
 using ProtocolConformanceRecord = TargetProtocolConformanceRecord<InProcess>;
 
-
-template<typename Runtime> struct TargetContextDescriptor;
-
-template<typename Runtime>
-using RelativeContextPointer =
-  RelativeIndirectablePointer<const TargetContextDescriptor<Runtime>,
-                              /*nullable*/ true>;
-
 template<typename Runtime>
 struct TargetGenericContext;
 
@@ -2702,7 +2745,25 @@ class TargetGenericRequirementDescriptor {
     assert(getKind() == GenericRequirementKind::Layout);
     return Layout;
   }
+
+  /// Determine whether this generic requirement has a known kind.
+  ///
+  /// \returns \c false for any future generic requirement kinds.
+  bool hasKnownKind() const {
+    switch (getKind()) {
+    case GenericRequirementKind::BaseClass:
+    case GenericRequirementKind::Layout:
+    case GenericRequirementKind::Protocol:
+    case GenericRequirementKind::SameConformance:
+    case GenericRequirementKind::SameType:
+      return true;
+    }
+
+    return false;
+  }
 };
+using GenericRequirementDescriptor =
+  TargetGenericRequirementDescriptor<InProcess>;
 
 /// CRTP class for a context descriptor that includes trailing generic
 /// context description.

lib/IRGen/GenDecl.cpp

@@ -2579,6 +2579,8 @@ namespace {
       addConformingType();
       addWitnessTable();
       addFlags();
+      addContext();
+      addConditionalRequirements();
 
       B.suggestType(IGM.ProtocolConformanceDescriptorTy);
     }
@@ -2650,6 +2652,27 @@ namespace {
       // Add the flags.
       B.addInt32(Flags.getIntValue());
     }
+
+    void addContext() {
+      if (!Conformance->isRetroactive())
+        return;
+
+      auto moduleContext =
+        Conformance->getDeclContext()->getModuleScopeContext();
+      ConstantReference moduleContextRef =
+        IGM.getAddrOfParentContextDescriptor(moduleContext);
+      B.addRelativeAddress(moduleContextRef);
+    }
+
+    void addConditionalRequirements() {
+      if (Conformance->getConditionalRequirements().empty())
+        return;
+
+      auto nominal = Conformance->getType()->getAnyNominal();
+      irgen::addGenericRequirements(IGM, B,
+                                    nominal->getGenericSignatureOfContext(),
+                                    Conformance->getConditionalRequirements());
+    }
   };
 }