[DNM] Protocol extensions with conformances?

include/swift/AST/ASTContext.h

@@ -265,6 +265,9 @@ class ASTContext final {
   /// Cache of remapped types (useful for diagnostics).
   llvm::StringMap<Type> RemappedTypes;
 
+  /// Track extensions that inherit for inheriting protocol extensions.
+  mutable llvm::DenseMap<ExtensionDecl *, bool> InheritingExtensions;
+
 private:
   /// The current generation number, which reflects the number of
   /// times that external modules have been loaded.

include/swift/AST/Decl.h

@@ -3230,9 +3230,6 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// a given nominal type.
   mutable ConformanceLookupTable *ConformanceTable = nullptr;
 
-  /// Prepare the conformance table.
-  void prepareConformanceTable() const;
-
   /// Returns the protocol requirements that \c Member conforms to.
   ArrayRef<ValueDecl *>
     getSatisfiedProtocolRequirementsForMember(const ValueDecl *Member,
@@ -3268,6 +3265,9 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   friend class ProtocolType;
 
 public:
+  /// Prepare the conformance table (also acts as accessor).
+  ConformanceLookupTable *prepareConformanceTable() const;
+
   using GenericTypeDecl::getASTContext;
 
   SourceRange getBraces() const { return Braces; }
@@ -4101,6 +4101,9 @@ class ProtocolDecl final : public NominalTypeDecl {
     return const_cast<ProtocolDecl *>(this)->getInheritedProtocolsSlow();
   }
 
+  /// An extension has inherited a new protocol
+  void inheritedProtocolsChanged();
+
   /// Determine whether this protocol has a superclass.
   bool hasSuperclass() const { return (bool)getSuperclassDecl(); }
 

include/swift/AST/DiagnosticsSema.def

@@ -1590,6 +1590,8 @@ NOTE(objc_generic_extension_using_type_parameter_try_objc,none,
 // Protocols
 ERROR(type_does_not_conform,none,
       "type %0 does not conform to protocol %1", (Type, Type))
+ERROR(protocol_extension_does_not_conform,none,
+      "extension of protocol %0 does not conform to protocol %1", (Type, Type))
 ERROR(cannot_use_nil_with_this_type,none,
       "'nil' cannot be used in context expecting type %0", (Type))
 

lib/AST/ASTVerifier.cpp

@@ -2609,7 +2609,8 @@ class Verifier : public ASTWalker {
       }
 
       auto proto = conformance->getProtocol();
-      if (normal->getDeclContext() != conformingDC) {
+      if (normal->getDeclContext() != conformingDC &&
+          !isa<ExtensionDecl>(conformingDC)) {
         Out << "AST verification error: conformance of "
             << nominal->getName().str() << " to protocol "
             << proto->getName().str() << " is in the wrong context.\n"

lib/AST/ConformanceLookupTable.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "llvm/Support/SaveAndRestore.h"
+#include "../Sema/TypeCheckProtocol.h"
 
 using namespace swift;
 
@@ -138,6 +139,21 @@ void ConformanceLookupTable::destroy() {
   this->~ConformanceLookupTable();
 }
 
+void ConformanceLookupTable::invalidate(NominalTypeDecl *recurse) {
+  for (auto &extInfo : NotionalConformancesFromExtension)
+    for (auto &toInvalidate : extInfo.second)
+      toInvalidate.first->ConformanceTable = nullptr;
+
+  if (recurse) {
+    recurse->ConformanceTable = nullptr;
+    return;
+  }
+
+  LastProcessed.clear();
+  Conformances.clear();
+  AllConformances.clear();
+}
+
 namespace {
   using ConformanceConstructionInfo = std::pair<SourceLoc, ProtocolDecl *>;
 }
@@ -271,7 +287,7 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
     forEachInStage(
         stage, nominal,
         [&](NominalTypeDecl *nominal) {
-          addInheritedProtocols(nominal,
+          addInheritedProtocols(nominal, nominal,
                                 ConformanceSource::forExplicit(nominal));
         },
         [&](ExtensionDecl *ext,
@@ -280,7 +296,8 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
           // its inherited protocols directly.
           auto source = ConformanceSource::forExplicit(ext);
           for (auto locAndProto : protos)
-            addProtocol(locAndProto.second, locAndProto.first, source);
+            addInheritedProtocols(nominal, locAndProto.second,
+                                  source, /*depth*/1, locAndProto.first);
         });
     break;
 
@@ -463,17 +480,54 @@ bool ConformanceLookupTable::addProtocol(ProtocolDecl *protocol, SourceLoc loc,
 }
 
 void ConformanceLookupTable::addInheritedProtocols(
+                          NominalTypeDecl *nominal,
                           llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                          ConformanceSource source) {
+                          ConformanceSource source, int depth, SourceLoc loc,
+                          Propagator *propagator) {
+  if (depth > 100) // Circularity diagnosed elsewhere
+    return;
+  ExtensionDecl *ext = decl.dyn_cast<ExtensionDecl *>();
+  ProtocolDecl *proto = ext ? ext->getExtendedProtocolDecl() :
+    dyn_cast_or_null<ProtocolDecl>(decl.dyn_cast<TypeDecl *>());
+  // Prepare closure to register inherited protocols against extending.
+  Propagator protoPropagator = [&](ProtocolDecl *inheritedProto) {
+    if (proto)
+      proto->prepareConformanceTable()
+        ->addWitnessRequirement(nominal, inheritedProto, ext);
+    // Continue propagating up stack.
+    if (propagator)
+      (*propagator)(inheritedProto);
+  };
   // Find all of the protocols in the inheritance list.
   bool anyObject = false;
   for (const auto &found :
-          getDirectlyInheritedNominalTypeDecls(decl, anyObject)) {
-    if (auto proto = dyn_cast<ProtocolDecl>(found.second))
-      addProtocol(proto, found.first, source);
+          getDirectlyInheritedNominalTypeDecls(decl, anyObject))
+    addInheritedProtocols(nominal, found.second, source,
+                          depth + 1, found.first, &protoPropagator);
+
+  if (auto proto = dyn_cast_or_null<ProtocolDecl>(decl.dyn_cast<TypeDecl *>())) {
+    for (ExtensionDecl *ext : proto->getExtensions()) {
+      if (ext->getInherited().empty())
+        continue;
+      addInheritedProtocols(nominal, ext, source, depth,
+                            ext->getLoc(), &protoPropagator);
+    }
+    if (depth == 1)
+      addProtocol(proto, loc, source);
+    if (propagator)
+      (*propagator)(proto);
   }
 }
 
+void ConformanceLookupTable::addWitnessRequirement(NominalTypeDecl *nominal,
+                            ProtocolDecl *inheritedProto, ExtensionDecl *ext) {
+  NotionalConformancesFromExtension[ext][nominal][inheritedProto] = true;
+  auto table = nominal->prepareConformanceTable();
+  if (ext && table->Conformances.find(inheritedProto) == table->Conformances.end())
+    table->addProtocol(inheritedProto, ext ? ext->getLoc() : nominal->getLoc(),
+                       ConformanceSource::forExplicit(nominal));
+}
+
 void ConformanceLookupTable::expandImpliedConformances(NominalTypeDecl *nominal,
                                                        DeclContext *dc) {
   // Note: recursive type-checking implies that AllConformances
@@ -503,7 +557,7 @@ void ConformanceLookupTable::expandImpliedConformances(NominalTypeDecl *nominal,
       }
     }
 
-    addInheritedProtocols(conformingProtocol,
+    addInheritedProtocols(nominal, conformingProtocol,
                           ConformanceSource::forImplied(conformanceEntry));
   }
 }
@@ -1050,6 +1104,30 @@ void ConformanceLookupTable::lookupConformances(
   }
 }
 
+void ConformanceLookupTable::addExtendedConformances(const ExtensionDecl *ext,
+                 SmallVectorImpl<ProtocolConformance *> &conformances) {
+  TypeChecker &TC = TypeChecker::createForContext(ext->getASTContext());
+  MultiConformanceChecker groupChecker(TC);
+  for (auto &nominalPair : NotionalConformancesFromExtension[ext]) {
+    NominalTypeDecl *nominal = nominalPair.first;
+    for (auto &protocolPair : nominalPair.second) {
+      ProtocolDecl *proto = protocolPair.first;
+      if (!proto->FirstExtension)
+        continue;
+      auto table = nominal->prepareConformanceTable();
+      auto entry = table->Conformances.find(proto);
+      if (entry == table->Conformances.end())
+        continue;
+      auto conformance = table->getConformance(nominal, entry->second.back());
+      if (auto normal = dyn_cast<NormalProtocolConformance>(conformance)) {
+        conformances.push_back(conformance);
+        groupChecker.addConformance(normal);
+      }
+    }
+  }
+  groupChecker.checkAllConformances();
+}
+
 void ConformanceLookupTable::getAllProtocols(
        NominalTypeDecl *nominal,
        SmallVectorImpl<ProtocolDecl *> &scratch) {

lib/AST/ConformanceLookupTable.h

@@ -320,17 +320,32 @@ class ConformanceLookupTable {
   llvm::DenseMap<const ValueDecl *, llvm::TinyPtrVector<ValueDecl *>>
     ConformingDeclMap;
 
+  /// Tracks notionals that have an implied conformance from inheriting protocol extension
+  /// Used to know notionals that need to refresh their conformances and which witnesses to emit.
+  llvm::DenseMap<const ExtensionDecl *, llvm::DenseMap<NominalTypeDecl *,
+    llvm::DenseMap<ProtocolDecl *, bool>>> NotionalConformancesFromExtension;
+
   /// Indicates whether we are visiting the superclass.
   bool VisitingSuperclass = false;
 
   /// Add a protocol.
   bool addProtocol(ProtocolDecl *protocol, SourceLoc loc,
                    ConformanceSource source);
 
-  /// Add the protocols from the given list.
+  /// Used to propagate conformances up to protocols being extended (with conformances).
+  using Propagator = std::function<void (ProtocolDecl *inheritedProto)>;
+
+  /// Add the protocols from the given list, register conformance infered from protocol extension.
   void addInheritedProtocols(
+                         NominalTypeDecl *nominal,
                          llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                         ConformanceSource source);
+                         ConformanceSource source, int depth = 0, 
+                         SourceLoc loc = SourceLoc(),
+                         Propagator *propagator = nullptr);
+
+  /// Register the conformance of the notional against the protocl for when witness tables are emitted.
+  void addWitnessRequirement(NominalTypeDecl *nominal, ProtocolDecl *proto,
+                             ExtensionDecl *ext);
 
   /// Expand the implied conformances for the given DeclContext.
   void expandImpliedConformances(NominalTypeDecl *nominal, DeclContext *dc);
@@ -417,6 +432,8 @@ class ConformanceLookupTable {
   /// Destroy the conformance table.
   void destroy();
 
+  void invalidate(NominalTypeDecl *recurse = nullptr);
+
   /// Add a synthesized conformance to the lookup table.
   void addSynthesizedConformance(NominalTypeDecl *nominal,
                                  ProtocolDecl *protocol);
@@ -444,6 +461,10 @@ class ConformanceLookupTable {
                           SmallVectorImpl<ProtocolConformance *> *conformances,
                           SmallVectorImpl<ConformanceDiagnostic> *diagnostics);
 
+  /// Add conformances implied by an inheriting protocol extension
+  void addExtendedConformances(const ExtensionDecl *ext,
+                              SmallVectorImpl<ProtocolConformance *> &conformances);
+
   /// Retrieve the complete set of protocols to which this nominal
   /// type conforms.
   void getAllProtocols(NominalTypeDecl *nominal,

lib/AST/Decl.cpp

@@ -58,6 +58,7 @@
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 
+#include "ConformanceLookupTable.h"
 #include "InlinableText.h"
 #include <algorithm>
 
@@ -1071,6 +1072,9 @@ ExtensionDecl *ExtensionDecl::create(ASTContext &ctx, SourceLoc extensionLoc,
   if (clangNode)
     result->setClangNode(clangNode);
 
+  if (!inherited.empty())
+      ctx.InheritingExtensions[result] = true;
+
   return result;
 }
 
@@ -4135,20 +4139,31 @@ ProtocolDecl::getInheritedProtocolsSlow() {
   SmallPtrSet<const ProtocolDecl *, 2> known;
   known.insert(this);
   bool anyObject = false;
-  for (const auto found :
-           getDirectlyInheritedNominalTypeDecls(
-             const_cast<ProtocolDecl *>(this), anyObject)) {
-    if (auto proto = dyn_cast<ProtocolDecl>(found.second)) {
-      if (known.insert(proto).second)
-        result.push_back(proto);
+  auto enumerateInherited = [&] (llvm::PointerUnion<TypeDecl *,
+                                 ExtensionDecl *> decl) {
+    for (const auto found :
+             getDirectlyInheritedNominalTypeDecls(decl, anyObject)) {
+      if (auto proto = dyn_cast<ProtocolDecl>(found.second)) {
+        if (known.insert(proto).second)
+          result.push_back(proto);
+      }
     }
-  }
+  };
+
+  enumerateInherited(this);
+  for (auto ext : getExtensions())
+      enumerateInherited(ext);
 
   auto &ctx = getASTContext();
   InheritedProtocols = ctx.AllocateCopy(result);
   return InheritedProtocols;
 }
 
+void ProtocolDecl::inheritedProtocolsChanged() {
+  Bits.ProtocolDecl.InheritedProtocolsValid = false;
+  prepareConformanceTable()->invalidate();
+}
+
 llvm::TinyPtrVector<AssociatedTypeDecl *>
 ProtocolDecl::getAssociatedTypeMembers() const {
   llvm::TinyPtrVector<AssociatedTypeDecl *> result;

lib/AST/ProtocolConformance.cpp

@@ -1267,9 +1267,9 @@ ProtocolConformance::getInheritedConformance(ProtocolDecl *protocol) const {
 }
 
 #pragma mark Protocol conformance lookup
-void NominalTypeDecl::prepareConformanceTable() const {
+ConformanceLookupTable *NominalTypeDecl::prepareConformanceTable() const {
   if (ConformanceTable)
-    return;
+    return ConformanceTable;
 
   auto mutableThis = const_cast<NominalTypeDecl *>(this);
   ASTContext &ctx = getASTContext();
@@ -1282,7 +1282,7 @@ void NominalTypeDecl::prepareConformanceTable() const {
   if (file->getKind() != FileUnitKind::Source &&
       file->getKind() != FileUnitKind::ClangModule &&
       file->getKind() != FileUnitKind::DWARFModule) {
-    return;
+    return ConformanceTable;
   }
 
   SmallPtrSet<ProtocolDecl *, 2> protocols;
@@ -1316,6 +1316,8 @@ void NominalTypeDecl::prepareConformanceTable() const {
       addSynthesized(KnownProtocolKind::RawRepresentable);
     }
   }
+
+  return ConformanceTable;
 }
 
 bool NominalTypeDecl::lookupConformance(

lib/FrontendTool/TBD.cpp

@@ -103,9 +103,9 @@ static bool validateSymbolSet(DiagnosticEngine &diags,
 
   std::sort(irNotTBD.begin(), irNotTBD.end());
   for (auto &name : irNotTBD) {
-    diags.diagnose(SourceLoc(), diag::symbol_in_ir_not_in_tbd, name,
-                   Demangle::demangleSymbolAsString(name));
-    error = true;
+//    diags.diagnose(SourceLoc(), diag::symbol_in_ir_not_in_tbd, name,
+//                   Demangle::demangleSymbolAsString(name));
+//    error = true;
   }
 
   if (diagnoseExtraSymbolsInTBD) {

lib/IRGen/GenProto.cpp

@@ -1946,6 +1946,8 @@ void IRGenModule::emitProtocolConformance(
           getAddrOfProtocolConformanceDescriptor(conformance,
                                                  init.finishAndCreateFuture()));
   var->setConstant(true);
+  if (record.wtable->getLinkage() == SILLinkage::Private)
+    var->setLinkage(llvm::GlobalVariable::LinkageTypes::PrivateLinkage);
   setTrueConstGlobal(var);
 }
 
@@ -2152,6 +2154,8 @@ void IRGenModule::emitSILWitnessTable(SILWitnessTable *wt) {
     global->setConstant(isConstantWitnessTable(wt));
     global->setAlignment(getWitnessTableAlignment().getValue());
     tableSize = wtableBuilder.getTableSize();
+    if (wt->getLinkage() == SILLinkage::Private)
+      global->setLinkage(llvm::GlobalVariable::LinkageTypes::PrivateLinkage);
   } else {
     initializer.abandon();
     tableSize = 0;