Introduce new SILLinkage and FormalLinkage for package decls.

A package access level is currently set to SILLinkage::Public.
This limits ability to optimize around resilience and more
fine-grained control.
This PR sets up a separate SIL linkage for package decls and
pipes them down to IRGen.

Resolves rdar://121409846

Author: elsh

include/swift/IRGen/TBDGen.h

@@ -38,8 +38,8 @@ struct TBDGenOptions {
   /// Only collect linker directive symbols.
   bool LinkerDirectivesOnly = false;
 
-  /// Whether to include only symbols with public linkage.
-  bool PublicSymbolsOnly = true;
+  /// Whether to include only symbols with public or package linkage.
+  bool PublicOrPackageSymbolsOnly = true;
 
   /// Whether LLVM IR Virtual Function Elimination is enabled.
   bool VirtualFunctionElimination = false;
@@ -75,7 +75,7 @@ struct TBDGenOptions {
     return lhs.HasMultipleIGMs == rhs.HasMultipleIGMs &&
            lhs.IsInstallAPI == rhs.IsInstallAPI &&
            lhs.LinkerDirectivesOnly == rhs.LinkerDirectivesOnly &&
-           lhs.PublicSymbolsOnly == rhs.PublicSymbolsOnly &&
+           lhs.PublicOrPackageSymbolsOnly == rhs.PublicOrPackageSymbolsOnly &&
            lhs.VirtualFunctionElimination == rhs.VirtualFunctionElimination &&
            lhs.WitnessMethodElimination == rhs.WitnessMethodElimination &&
            lhs.InstallName == rhs.InstallName &&
@@ -94,7 +94,7 @@ struct TBDGenOptions {
     using namespace llvm;
     return hash_combine(
         opts.HasMultipleIGMs, opts.IsInstallAPI, opts.LinkerDirectivesOnly,
-        opts.PublicSymbolsOnly, opts.VirtualFunctionElimination,
+        opts.PublicOrPackageSymbolsOnly, opts.VirtualFunctionElimination,
         opts.WitnessMethodElimination,
         opts.InstallName, opts.ModuleLinkName,
         opts.CurrentVersion, opts.CompatibilityVersion,

include/swift/SIL/FormalLinkage.h

@@ -34,6 +34,10 @@ enum class FormalLinkage {
   /// have a unique file that is known to define it.
   PublicNonUnique,
 
+  /// This entity is visible in multiple Swift modules within a package
+  /// and has a unique file that is known to define it.
+  PackageUnique,
+
   /// This entity is visible in only a single Swift module and has a
   /// unique file that is known to define it.
   HiddenUnique,

include/swift/SIL/SILLinkage.h

@@ -58,6 +58,12 @@ enum class SILLinkage : uint8_t {
   /// PublicNonABI functions must be definitions.
   PublicNonABI,
 
+  /// Visible to multiple Swift modules within a package.
+  Package,
+
+  /// Used for default argument expressions and `@_alwaysEmitIntoClient`.
+  PackageNonABI,
+
   /// This object definition is visible only to the current Swift
   /// module (and thus should not be visible across linkage-unit
   /// boundaries).  There are no other object definitions with this
@@ -91,6 +97,9 @@ enum class SILLinkage : uint8_t {
   /// definition.
   PublicExternal,
 
+  /// Used to reference a package symbol in a different package.
+  PackageExternal,
+
   /// A Public or Hidden definition with the same name as this object
   /// will be defined by the current Swift module at runtime.
   ///
@@ -166,20 +175,35 @@ enum class SubclassScope : uint8_t {
 /// Strip external from public_external, hidden_external. Otherwise just return
 /// the linkage.
 inline SILLinkage stripExternalFromLinkage(SILLinkage linkage) {
-  if (linkage == SILLinkage::PublicExternal)
+  switch (linkage) {
+  case SILLinkage::PublicExternal:
     return SILLinkage::Public;
-  if (linkage == SILLinkage::HiddenExternal)
+  case SILLinkage::PackageExternal:
+    return SILLinkage::Package;
+  case SILLinkage::HiddenExternal:
     return SILLinkage::Hidden;
-  return linkage;
+  case SILLinkage::Public:
+  case SILLinkage::PublicNonABI:
+  case SILLinkage::Package:
+  case SILLinkage::PackageNonABI:
+  case SILLinkage::Hidden:
+  case SILLinkage::Shared:
+  case SILLinkage::Private:
+    return linkage;
+  }
+  llvm_unreachable("Unhandled SILLinkage in switch.");
 }
 
 /// Add the 'external' attribute to \p linkage.
 inline SILLinkage addExternalToLinkage(SILLinkage linkage) {
   switch (linkage) {
   case SILLinkage::Public:
     return SILLinkage::PublicExternal;
+  case SILLinkage::Package:
+    return SILLinkage::PackageExternal;
   case SILLinkage::PublicNonABI:
-    // An external reference to a public non-ABI function is only valid
+  case SILLinkage::PackageNonABI:
+    // An external reference to a public or package non-ABI function is only valid
     // if the function was emitted in another translation unit of the
     // same Swift module, so we treat it as hidden here.
     return SILLinkage::HiddenExternal;
@@ -188,6 +212,7 @@ inline SILLinkage addExternalToLinkage(SILLinkage linkage) {
   case SILLinkage::Shared:
   case SILLinkage::Private:
   case SILLinkage::PublicExternal:
+  case SILLinkage::PackageExternal:
   case SILLinkage::HiddenExternal:
     return linkage;
   }
@@ -198,15 +223,15 @@ inline SILLinkage addExternalToLinkage(SILLinkage linkage) {
 /// Return whether the linkage indicates that an object has a
 /// definition outside the current SILModule.
 inline bool isAvailableExternally(SILLinkage linkage) {
-  return linkage >= SILLinkage::PublicExternal;
+  return linkage >= SILLinkage::PublicExternal; // ESQ: package external
 }
 
 /// Return whether the given linkage indicates that an object's
 /// definition might be required outside the current SILModule.
 /// If \p is true then we are in whole-module compilation.
 inline bool isPossiblyUsedExternally(SILLinkage linkage, bool wholeModule) {
   if (wholeModule) {
-    return linkage <= SILLinkage::PublicNonABI;
+    return linkage <= SILLinkage::PackageNonABI; // ESQ: change this to linkage method
   }
   return linkage <= SILLinkage::Hidden;
 }
@@ -219,6 +244,9 @@ inline bool hasPublicVisibility(SILLinkage linkage) {
   case SILLinkage::PublicExternal:
   case SILLinkage::PublicNonABI:
     return true;
+  case SILLinkage::Package:
+  case SILLinkage::PackageExternal:
+  case SILLinkage::PackageNonABI:
   case SILLinkage::Hidden:
   case SILLinkage::Shared:
   case SILLinkage::Private:
@@ -236,6 +264,9 @@ inline bool hasSharedVisibility(SILLinkage linkage) {
   case SILLinkage::Public:
   case SILLinkage::PublicExternal:
   case SILLinkage::PublicNonABI:
+  case SILLinkage::Package:
+  case SILLinkage::PackageExternal:
+  case SILLinkage::PackageNonABI:
   case SILLinkage::Hidden:
   case SILLinkage::HiddenExternal:
   case SILLinkage::Private:
@@ -252,6 +283,9 @@ inline bool hasPrivateVisibility(SILLinkage linkage) {
   case SILLinkage::Public:
   case SILLinkage::PublicExternal:
   case SILLinkage::PublicNonABI:
+  case SILLinkage::Package:
+  case SILLinkage::PackageExternal:
+  case SILLinkage::PackageNonABI:
   case SILLinkage::Hidden:
   case SILLinkage::HiddenExternal:
   case SILLinkage::Shared:
@@ -266,9 +300,9 @@ inline SILLinkage effectiveLinkageForClassMember(SILLinkage linkage,
   switch (scope) {
   case SubclassScope::External:
     if (linkage == SILLinkage::Private || linkage == SILLinkage::Hidden)
-      return SILLinkage::Public;
+      return SILLinkage::Public; // ESQ: package?
     if (linkage == SILLinkage::HiddenExternal)
-      return SILLinkage::PublicExternal;
+      return SILLinkage::PublicExternal; // ESQ: package?
     break;
 
   case SubclassScope::Internal:

include/swift/SIL/SILSymbolVisitor.h

@@ -31,8 +31,8 @@ struct SILSymbolVisitorOptions {
   /// are needed (e.g. decls with `@_originallyDefinedIn`.
   bool LinkerDirectivesOnly = false;
 
-  /// Whether to only visit symbols with public linkage.
-  bool PublicSymbolsOnly = true;
+  /// Whether to only visit symbols with public or package linkage.
+  bool PublicOrPackageSymbolsOnly = true;
 
   /// Whether LLVM IR Virtual Function Elimination is enabled.
   bool VirtualFunctionElimination = false;

lib/IRGen/GenDecl.cpp

@@ -2330,11 +2330,13 @@ getIRLinkage(StringRef name, const UniversalLinkageInfo &info,
 
   switch (linkage) {
   case SILLinkage::Public:
+  case SILLinkage::Package:
     return {llvm::GlobalValue::ExternalLinkage, PublicDefinitionVisibility,
             info.Internalize ? llvm::GlobalValue::DefaultStorageClass
                              : ExportedStorage};
 
   case SILLinkage::PublicNonABI:
+  case SILLinkage::PackageNonABI:
     return isDefinition ? RESULT(WeakODR, Hidden, Default)
                         : RESULT(External, Hidden, Default);
 
@@ -2359,6 +2361,7 @@ getIRLinkage(StringRef name, const UniversalLinkageInfo &info,
     return {linkage, visibility, llvm::GlobalValue::DefaultStorageClass};
   }
 
+  case SILLinkage::PackageExternal:
   case SILLinkage::PublicExternal: {
     if (isDefinition)
       return RESULT(AvailableExternally, Default, Default);

lib/IRGen/GenDiffWitness.cpp

@@ -31,7 +31,7 @@ void IRGenModule::emitSILDifferentiabilityWitness(
   if (dw->isDeclaration())
     return;
   // Don't emit `public_external` witnesses.
-  if (dw->getLinkage() == SILLinkage::PublicExternal)
+  if (dw->getLinkage() == SILLinkage::PublicExternal) // ESQ: package external
     return;
   ConstantInitBuilder builder(*this);
   auto diffWitnessContents = builder.beginStruct();

lib/IRGen/GenInit.cpp

@@ -46,7 +46,8 @@ void IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
       auto DbgTy = DebugTypeInfo::getGlobal(var, Int8Ty, *this);
       DebugInfo->emitGlobalVariableDeclaration(
           nullptr, var->getDecl()->getName().str(), "", DbgTy,
-          var->getLinkage() != SILLinkage::Public, SILLocation(var->getDecl()));
+          var->getLinkage() != SILLinkage::Public, // ESQ: package
+                                               SILLocation(var->getDecl()));
     }
     return;
   }

lib/IRGen/GenMeta.cpp

@@ -2131,13 +2131,16 @@ namespace {
                 .getLinkage(NotForDefinition)) {
       case SILLinkage::Public:
       case SILLinkage::PublicExternal:
+      case SILLinkage::Package:
+      case SILLinkage::PackageExternal:
       case SILLinkage::Hidden:
       case SILLinkage::HiddenExternal:
       case SILLinkage::Private:
         return true;
 
       case SILLinkage::Shared:
       case SILLinkage::PublicNonABI:
+      case SILLinkage::PackageNonABI:
         return false;
       }
       llvm_unreachable("covered switch");
@@ -7017,7 +7020,7 @@ ExtendedExistentialTypeShapeInfo::get(
                                    .getCanonicalSignature();
 
   auto linkage = getExistentialShapeLinkage(genSig, shapeType);
-  assert(linkage != FormalLinkage::PublicUnique);
+  assert(linkage != FormalLinkage::PublicUnique && linkage != FormalLinkage::PackageUnique);
 
   return { genSig, shapeType, SubstitutionMap(), linkage };
 }

lib/IRGen/GenProto.cpp

@@ -2412,7 +2412,12 @@ static void addWTableTypeMetadata(IRGenModule &IGM,
     vis = VCallVisibility::VCallVisibilityLinkageUnit;
     break;
   case SILLinkage::Public:
-  default:
+  case SILLinkage::PublicExternal:
+  case SILLinkage::PublicNonABI:
+  case SILLinkage::Package:
+  case SILLinkage::PackageExternal:
+  case SILLinkage::PackageNonABI:
+  case SILLinkage::HiddenExternal:
     if (IGM.getOptions().InternalizeAtLink) {
       vis = VCallVisibility::VCallVisibilityLinkageUnit;
     }

lib/IRGen/IRGen.cpp

@@ -1085,7 +1085,7 @@ getSymbolSourcesToEmit(const IRGenDescriptor &desc) {
   // making sure to include non-public symbols.
   auto &ctx = desc.getParentModule()->getASTContext();
   auto tbdDesc = desc.getTBDGenDescriptor();
-  tbdDesc.getOptions().PublicSymbolsOnly = false;
+  tbdDesc.getOptions().PublicOrPackageSymbolsOnly = false;
   const auto *symbolMap =
       llvm::cantFail(ctx.evaluator(SymbolSourceMapRequest{std::move(tbdDesc)}));