Merge pull request #10482 from huonw/symbol-list-9-4.0

[4.0] More TBD work

Author: ematejska

include/swift/AST/Decl.h

@@ -4097,6 +4097,10 @@ class AbstractStorageDecl : public ValueDecl {
 
   FuncDecl *getAccessorFunction(AccessorKind accessor) const;
 
+  /// \brief Push all of the accessor functions associated with this VarDecl
+  /// onto `decls`.
+  void getAllAccessorFunctions(SmallVectorImpl<Decl *> &decls) const;
+
   /// \brief Turn this into a computed variable, providing a getter and setter.
   void makeComputed(SourceLoc LBraceLoc, FuncDecl *Get, FuncDecl *Set,
                     FuncDecl *MaterializeForSet, SourceLoc RBraceLoc);

include/swift/AST/ProtocolConformance.h

@@ -392,7 +392,7 @@ class NormalProtocolConformance : public ProtocolConformance,
   AbstractStorageDecl *getBehaviorDecl() const {
     return ContextAndInvalid.getPointer().dyn_cast<AbstractStorageDecl *>();
   }
-  
+
   /// Retrieve the type witness and type decl (if one exists)
   /// for the given associated type.
   std::pair<Type, TypeDecl *>

include/swift/SIL/SILLinkage.h

@@ -252,6 +252,20 @@ inline SILLinkage effectiveLinkageForClassMember(SILLinkage linkage,
   return linkage;
 }
 
+// FIXME: This should not be necessary, but it looks like visibility rules for
+// extension members are slightly bogus, and so some protocol witness thunks
+// need to be public.
+//
+// We allow a 'public' member of an extension to witness a public
+// protocol requirement, even if the extended type is not public;
+// then SILGen gives the member private linkage, ignoring the more
+// visible accessibility it was given in the AST.
+inline bool
+fixmeWitnessHasLinkageThatNeedsToBePublic(SILLinkage witnessLinkage) {
+  return !hasPublicVisibility(witnessLinkage) &&
+         !hasSharedVisibility(witnessLinkage);
+}
+
 } // end swift namespace
 
 #endif

include/swift/SIL/SILWitnessTable.h

@@ -34,8 +34,10 @@ namespace swift {
 
 class SILFunction;
 class SILModule;
+class ProtocolConformance;
 class NormalProtocolConformance;
 enum IsSerialized_t : unsigned char;
+enum class ResilienceStrategy : unsigned;
 
 /// A mapping from each requirement of a protocol to the SIL-level entity
 /// satisfying the requirement for a concrete type.
@@ -269,13 +271,18 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
   void convertToDefinition(ArrayRef<Entry> newEntries,
                            IsSerialized_t isSerialized);
 
+  // Whether a conformance should be serialized.
+  static bool conformanceIsSerialized(ProtocolConformance *conformance,
+                                      ResilienceStrategy strategy,
+                                      bool silSerializeWitnessTables);
+
   /// Print the witness table.
   void print(llvm::raw_ostream &OS, bool Verbose = false) const;
 
   /// Dump the witness table to stderr.
   void dump() const;
 };
-  
+
 } // end swift namespace
 
 //===----------------------------------------------------------------------===//

include/swift/TBDGen/TBDGen.h

@@ -18,7 +18,8 @@ namespace swift {
 class FileUnit;
 
 void enumeratePublicSymbols(FileUnit *module, llvm::StringSet<> &symbols,
-                            bool hasMultipleIRGenThreads, bool isWholeModule);
+                            bool hasMultipleIRGenThreads, bool isWholeModule,
+                            bool silSerializeWitnessTables);
 } // end namespace swift
 
 #endif

lib/AST/Decl.cpp

@@ -3430,6 +3430,28 @@ FuncDecl *AbstractStorageDecl::getAccessorFunction(AccessorKind kind) const {
   llvm_unreachable("bad accessor kind!");
 }
 
+void AbstractStorageDecl::getAllAccessorFunctions(
+    SmallVectorImpl<Decl *> &decls) const {
+  auto tryPush = [&](Decl *decl) {
+    if (decl)
+      decls.push_back(decl);
+  };
+
+  tryPush(getGetter());
+  tryPush(getSetter());
+  tryPush(getMaterializeForSetFunc());
+
+  if (hasObservers()) {
+    tryPush(getDidSetFunc());
+    tryPush(getWillSetFunc());
+  }
+
+  if (hasAddressors()) {
+    tryPush(getAddressor());
+    tryPush(getMutableAddressor());
+  }
+}
+
 void AbstractStorageDecl::configureGetSetRecord(GetSetRecord *getSetInfo,
                                                 FuncDecl *getter,
                                                 FuncDecl *setter,

lib/FrontendTool/FrontendTool.cpp

@@ -665,8 +665,10 @@ static bool performCompile(CompilerInstance &Instance,
   }
 
   if (Action == FrontendOptions::EmitTBD) {
-    auto hasMultipleIRGenThreads = Invocation.getSILOptions().NumThreads > 1;
+    const auto &silOpts = Invocation.getSILOptions();
+    auto hasMultipleIRGenThreads = silOpts.NumThreads > 1;
     return writeTBD(Instance.getMainModule(), hasMultipleIRGenThreads,
+                    silOpts.SILSerializeWitnessTables,
                     opts.getSingleOutputFilename());
   }
 
@@ -942,14 +944,16 @@ static bool performCompile(CompilerInstance &Instance,
         !astGuaranteedToCorrespondToSIL)
       break;
 
-    auto hasMultipleIRGenThreads = Invocation.getSILOptions().NumThreads > 1;
+    const auto &silOpts = Invocation.getSILOptions();
+    auto hasMultipleIRGenThreads = silOpts.NumThreads > 1;
     bool error;
     if (PrimarySourceFile)
       error = validateTBD(PrimarySourceFile, *IRModule, hasMultipleIRGenThreads,
-                          allSymbols);
+                          silOpts.SILSerializeWitnessTables, allSymbols);
     else
       error = validateTBD(Instance.getMainModule(), *IRModule,
-                          hasMultipleIRGenThreads, allSymbols);
+                          hasMultipleIRGenThreads,
+                          silOpts.SILSerializeWitnessTables, allSymbols);
     if (error)
       return true;
 

lib/FrontendTool/TBD.cpp

@@ -39,7 +39,7 @@ static std::vector<StringRef> sortSymbols(llvm::StringSet<> &symbols) {
 }
 
 bool swift::writeTBD(ModuleDecl *M, bool hasMultipleIRGenThreads,
-                     StringRef OutputFilename) {
+                     bool silSerializeWitnessTables, StringRef OutputFilename) {
   std::error_code EC;
   llvm::raw_fd_ostream OS(OutputFilename, EC, llvm::sys::fs::F_None);
   if (EC) {
@@ -50,7 +50,7 @@ bool swift::writeTBD(ModuleDecl *M, bool hasMultipleIRGenThreads,
   llvm::StringSet<> symbols;
   for (auto file : M->getFiles())
     enumeratePublicSymbols(file, symbols, hasMultipleIRGenThreads,
-                           /*isWholeModule=*/true);
+                           /*isWholeModule=*/true, silSerializeWitnessTables);
 
   // Ensure the order is stable.
   for (auto &symbol : sortSymbols(symbols)) {
@@ -125,22 +125,24 @@ static bool validateSymbolSet(DiagnosticEngine &diags,
 
 bool swift::validateTBD(ModuleDecl *M, llvm::Module &IRModule,
                         bool hasMultipleIRGenThreads,
+                        bool silSerializeWitnessTables,
                         bool diagnoseExtraSymbolsInTBD) {
   llvm::StringSet<> symbols;
   for (auto file : M->getFiles())
     enumeratePublicSymbols(file, symbols, hasMultipleIRGenThreads,
-                           /*isWholeModule=*/true);
+                           /*isWholeModule=*/true, silSerializeWitnessTables);
 
   return validateSymbolSet(M->getASTContext().Diags, symbols, IRModule,
                            diagnoseExtraSymbolsInTBD);
 }
 
 bool swift::validateTBD(FileUnit *file, llvm::Module &IRModule,
                         bool hasMultipleIRGenThreads,
+                        bool silSerializeWitnessTables,
                         bool diagnoseExtraSymbolsInTBD) {
   llvm::StringSet<> symbols;
   enumeratePublicSymbols(file, symbols, hasMultipleIRGenThreads,
-                         /*isWholeModule=*/false);
+                         /*isWholeModule=*/false, silSerializeWitnessTables);
 
   return validateSymbolSet(file->getParentModule()->getASTContext().Diags,
                            symbols, IRModule, diagnoseExtraSymbolsInTBD);

lib/FrontendTool/TBD.h

@@ -25,12 +25,14 @@ class FileUnit;
 class FrontendOptions;
 
 bool writeTBD(ModuleDecl *M, bool hasMultipleIRGenThreads,
-              llvm::StringRef OutputFilename);
+              bool silSerializeWitnessTables, llvm::StringRef OutputFilename);
 bool inputFileKindCanHaveTBDValidated(InputFileKind kind);
 bool validateTBD(ModuleDecl *M, llvm::Module &IRModule,
-                 bool hasMultipleIRGenThreads, bool diagnoseExtraSymbolsInTBD);
+                 bool hasMultipleIRGenThreads, bool silSerializeWitnessTables,
+                 bool diagnoseExtraSymbolsInTBD);
 bool validateTBD(FileUnit *M, llvm::Module &IRModule,
-                 bool hasMultipleIRGenThreads, bool diagnoseExtraSymbolsInTBD);
+                 bool hasMultipleIRGenThreads, bool silSerializeWitnessTables,
+                 bool diagnoseExtraSymbolsInTBD);
 }
 
 #endif

lib/SIL/SILWitnessTable.cpp

@@ -21,6 +21,7 @@
 
 #include "swift/SIL/SILWitnessTable.h"
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/Module.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/SIL/SILModule.h"
 #include "llvm/ADT/SmallString.h"
@@ -155,3 +156,18 @@ void SILWitnessTable::convertToDefinition(ArrayRef<Entry> entries,
 Identifier SILWitnessTable::getIdentifier() const {
   return Mod.getASTContext().getIdentifier(Name);
 }
+
+bool SILWitnessTable::conformanceIsSerialized(ProtocolConformance *conformance,
+                                              ResilienceStrategy strategy,
+                                              bool silSerializeWitnessTables) {
+  auto *nominal = conformance->getType()->getAnyNominal();
+  // Only serialize if the witness table is sufficiently static, and resilience
+  // is explicitly enabled for this compilation or if we serialize all eligible
+  // witness tables.
+  auto moduleIsResilient = strategy == ResilienceStrategy::Resilient;
+  auto protocolIsPublic =
+      conformance->getProtocol()->getEffectiveAccess() >= Accessibility::Public;
+  auto typeIsPublic = nominal->getEffectiveAccess() >= Accessibility::Public;
+  return (moduleIsResilient || silSerializeWitnessTables) &&
+         nominal->hasFixedLayout() && protocolIsPublic && typeIsPublic;
+}

lib/SILGen/SILGenType.cpp

@@ -314,20 +314,14 @@ class SILGenConformance : public SILGenWitnessTable<SILGenConformance> {
     Serialized = IsNotSerialized;
 
     // Serialize the witness table if we're serializing everything with
-    // -sil-serialize-all.
+    // -sil-serialize-all...
     if (SGM.isMakeModuleFragile())
       Serialized = IsSerialized;
 
-    auto *nominal = Conformance->getType()->getAnyNominal();
-    // Serialize the witness table if the conformance itself thinks it should be
-    // and resilience is explicitly enabled for this compilaiton or if we serialize
-    // all eligible witness tables.
-    if ((SGM.M.getSwiftModule()->getResilienceStrategy() ==
-             ResilienceStrategy::Resilient ||
-         SGM.M.getOptions().SILSerializeWitnessTables) &&
-        nominal->hasFixedLayout() &&
-        proto->getEffectiveAccess() >= Accessibility::Public &&
-        nominal->getEffectiveAccess() >= Accessibility::Public)
+    // ... or if the conformance itself thinks it should be.
+    if (SILWitnessTable::conformanceIsSerialized(
+            Conformance, SGM.M.getSwiftModule()->getResilienceStrategy(),
+            SGM.M.getOptions().SILSerializeWitnessTables))
       Serialized = IsSerialized;
 
     // Not all protocols use witness tables; in this case we just skip
@@ -427,15 +421,7 @@ class SILGenConformance : public SILGenWitnessTable<SILGenConformance> {
     auto witnessLinkage = witnessRef.getLinkage(ForDefinition);
     auto witnessSerialized = Serialized;
     if (witnessSerialized &&
-        !hasPublicVisibility(witnessLinkage) &&
-        !hasSharedVisibility(witnessLinkage)) {
-      // FIXME: This should not happen, but it looks like visibility rules
-      // for extension members are slightly bogus.
-      //
-      // We allow a 'public' member of an extension to witness a public
-      // protocol requirement, even if the extended type is not public;
-      // then SILGen gives the member private linkage, ignoring the more
-      // visible accessibility it was given in the AST.
+        fixmeWitnessHasLinkageThatNeedsToBePublic(witnessLinkage)) {
       witnessLinkage = SILLinkage::Public;
       witnessSerialized = (SGM.isMakeModuleFragile()
                            ? IsSerialized