AST: Accept @_weakLinked on import decls to force weak linkage of symbols from a module.

The effect of declaring an import `@_weakLinked` is to treat every declaration from the module as if it were declared with `@_weakLinked`. This is useful in environments where entire modules may not be present at runtime. Although it is already possible to instruct the linker to weakly link an entire dylib, a Swift attribute provides a way to declare intent in source code and also opens the door to diagnostics and other compiler behaviors that depend on knowing that all the module's symbols will be weakly linked.

rdar://96098097

Author: tshortli

include/swift/AST/Attr.def

@@ -456,7 +456,8 @@ DECL_ATTR(_clangImporterSynthesizedType, ClangImporterSynthesizedType,
   74)
 SIMPLE_DECL_ATTR(_weakLinked, WeakLinked,
   OnNominalType | OnAssociatedType | OnFunc | OnAccessor | OnVar |
-  OnSubscript | OnConstructor | OnEnumElement | OnExtension | UserInaccessible |
+  OnSubscript | OnConstructor | OnEnumElement | OnExtension | OnImport |
+  UserInaccessible |
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   75)
 SIMPLE_DECL_ATTR(frozen, Frozen,

include/swift/AST/FileUnit.h

@@ -123,6 +123,10 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
                             const ModuleDecl *importedModule,
                             SmallSetVector<Identifier, 4> &spiGroups) const {};
 
+  virtual bool importsModuleAsWeakLinked(const ModuleDecl *module) const {
+    return false;
+  }
+
   virtual Optional<Fingerprint>
   loadFingerprint(const IterableDeclContext *IDC) const { return None; }
 

include/swift/AST/Import.h

@@ -84,6 +84,9 @@ enum class ImportFlags {
   /// concurrency.
   Preconcurrency = 0x20,
 
+  /// The module's symbols are linked weakly.
+  WeakLinked = 0x40,
+
   /// Used for DenseMap.
   Reserved = 0x80
 };

include/swift/AST/Module.h

@@ -686,6 +686,9 @@ class ModuleDecl
   // Is \p spiGroup accessible as an explicitly imported SPI from this module?
   bool isImportedAsSPI(Identifier spiGroup, const ModuleDecl *fromModule) const;
 
+  /// Is \p importedModule imported as \c @_weakLinked from this module?
+  bool importsModuleAsWeakLinked(const ModuleDecl *importedModule) const;
+
   /// \sa getImportedModules
   enum class ImportFilterKind {
     /// Include imports declared with `@_exported`.

include/swift/AST/SourceFile.h

@@ -356,6 +356,9 @@ class SourceFile final : public FileUnit {
                 const ModuleDecl *importedModule,
                 llvm::SmallSetVector<Identifier, 4> &spiGroups) const override;
 
+  /// Is \p module imported as \c @_weakLinked by this file?
+  bool importsModuleAsWeakLinked(const ModuleDecl *module) const override;
+
   // Is \p targetDecl accessible as an explicitly imported SPI from this file?
   bool isImportedAsSPI(const ValueDecl *targetDecl) const;
 

include/swift/SIL/SILFunction.h

@@ -64,6 +64,11 @@ enum IsDistributed_t {
   IsNotDistributed,
   IsDistributed,
 };
+enum IsWeakImported_t {
+  IsNotWeakImported,
+  IsWeakImportedByModule,
+  IsAlwaysWeakImported,
+};
 
 enum class PerformanceConstraints : uint8_t {
   None = 0,
@@ -317,9 +322,8 @@ class SILFunction
   /// would indicate.
   unsigned HasCReferences : 1;
 
-  /// Whether cross-module references to this function should always use
-  /// weak linking.
-  unsigned IsWeakImported : 1;
+  /// Whether cross-module references to this function should use weak linking.
+  unsigned IsWeakImported : 2;
 
   /// Whether the implementation can be dynamically replaced.
   unsigned IsDynamicReplaceable : 1;
@@ -801,12 +805,18 @@ class SILFunction
 
   /// Returns whether this function's symbol must always be weakly referenced
   /// across module boundaries.
-  bool isAlwaysWeakImported() const { return IsWeakImported; }
+  bool isAlwaysWeakImported() const {
+    return IsWeakImported == IsWeakImported_t::IsAlwaysWeakImported;
+  }
 
-  void setAlwaysWeakImported(bool value) {
-    IsWeakImported = value;
+  /// Returns whether this function's symbol was referenced by a module that
+  /// imports the defining module \c @_weakLinked.
+  bool isWeakImportedByModule() const {
+    return IsWeakImported == IsWeakImported_t::IsWeakImportedByModule;
   }
 
+  void setIsWeakImported(IsWeakImported_t value) { IsWeakImported = value; }
+
   bool isWeakImported() const;
 
   /// Returns whether this function implementation can be dynamically replaced.

lib/AST/Decl.cpp

@@ -1002,6 +1002,9 @@ bool Decl::isWeakImported(ModuleDecl *fromModule) const {
   if (isAlwaysWeakImported())
     return true;
 
+  if (fromModule->importsModuleAsWeakLinked(getModuleContext()))
+    return true;
+
   auto availability = getAvailabilityForLinkage();
   if (availability.isAlwaysAvailable())
     return false;

lib/AST/Module.cpp

@@ -2573,6 +2573,15 @@ bool SourceFile::isImportedAsSPI(const ValueDecl *targetDecl) const {
   return false;
 }
 
+bool SourceFile::importsModuleAsWeakLinked(const ModuleDecl *module) const {
+  for (auto &import : *Imports) {
+    if (import.options.contains(ImportFlags::WeakLinked) &&
+        module == import.module.importedModule)
+      return true;
+  }
+  return false;
+}
+
 bool ModuleDecl::isImportedAsSPI(const SpecializeAttr *attr,
                                  const ValueDecl *targetDecl) const {
   auto targetModule = targetDecl->getModuleContext();
@@ -2598,6 +2607,15 @@ bool ModuleDecl::isImportedAsSPI(Identifier spiGroup,
   return importedSPIGroups.count(spiGroup);
 }
 
+bool ModuleDecl::importsModuleAsWeakLinked(
+    const ModuleDecl *importedModule) const {
+  for (auto file : getFiles()) {
+    if (file->importsModuleAsWeakLinked(importedModule))
+      return true;
+  }
+  return false;
+}
+
 bool Decl::isSPI() const {
   return !getSPIGroups().empty();
 }

lib/SIL/IR/SILFunction.cpp

@@ -471,7 +471,7 @@ bool SILFunction::isWeakImported() const {
   if (!isAvailableExternally())
     return false;
 
-  if (isAlwaysWeakImported())
+  if (isAlwaysWeakImported() || isWeakImportedByModule())
     return true;
 
   if (Availability.isAlwaysAvailable())

lib/SIL/IR/SILFunctionBuilder.cpp

@@ -312,7 +312,14 @@ SILFunction *SILFunctionBuilder::getOrCreateFunction(
       F->setClangNodeOwner(decl);
 
     F->setAvailabilityForLinkage(decl->getAvailabilityForLinkage());
-    F->setAlwaysWeakImported(decl->isAlwaysWeakImported());
+
+    if (decl->isAlwaysWeakImported()) {
+      F->setIsWeakImported(IsWeakImported_t::IsAlwaysWeakImported);
+    } else if (decl->isWeakImported(mod.getSwiftModule())) {
+      F->setIsWeakImported(IsWeakImported_t::IsWeakImportedByModule);
+    } else {
+      F->setIsWeakImported(IsWeakImported_t::IsNotWeakImported);
+    }
 
     if (auto *accessor = dyn_cast<AccessorDecl>(decl)) {
       auto *storage = accessor->getStorage();

lib/SIL/Parser/ParseSIL.cpp

@@ -6483,7 +6483,9 @@ bool SILParserState::parseDeclSIL(Parser &P) {
     if (!objCReplacementFor.empty())
       FunctionState.F->setObjCReplacement(objCReplacementFor);
     FunctionState.F->setSpecialPurpose(specialPurpose);
-    FunctionState.F->setAlwaysWeakImported(isWeakImported);
+    FunctionState.F->setIsWeakImported(
+        isWeakImported ? IsWeakImported_t::IsAlwaysWeakImported
+                       : IsWeakImported_t::IsNotWeakImported);
     FunctionState.F->setAvailabilityForLinkage(availability);
     FunctionState.F->setWithoutActuallyEscapingThunk(
       isWithoutActuallyEscapingThunk);

lib/Sema/ImportResolution.cpp

@@ -554,6 +554,9 @@ UnboundImport::UnboundImport(ImportDecl *ID)
     import.options |= ImportFlags::Preconcurrency;
     import.preconcurrencyRange = attr->getRangeWithAt();
   }
+
+  if (auto attr = ID->getAttrs().getAttribute<WeakLinkedAttr>())
+    import.options |= ImportFlags::WeakLinked;
 }
 
 bool UnboundImport::checkNotTautological(const SourceFile &SF) {

lib/Serialization/DeserializeSIL.cpp

@@ -661,7 +661,9 @@ SILDeserializer::readSILFunctionChecked(DeclID FID, SILFunction *existingFn,
     fn->setEffectsKind(EffectsKind(effect));
     fn->setOptimizationMode(OptimizationMode(optimizationMode));
     fn->setPerfConstraints((PerformanceConstraints)perfConstr);
-    fn->setAlwaysWeakImported(isWeakImported);
+    fn->setIsWeakImported(isWeakImported
+                              ? IsWeakImported_t::IsAlwaysWeakImported
+                              : IsWeakImported_t::IsNotWeakImported);
     fn->setClassSubclassScope(SubclassScope(subclassScope));
     fn->setHasCReferences(bool(hasCReferences));
 

test/IRGen/Inputs/weaklinked_import_helper.swift

@@ -0,0 +1,82 @@
+public func fn() {}
+
+public var globalStored = 0
+
+public var globalComputed: Int {
+  get { return 1 }
+  set {}
+}
+
+public struct S {
+  public func fn() {}
+
+  public var storedProp = 0
+
+  public var computedProp: Int {
+    get { return 1 }
+    set {}
+  }
+
+  public init() {}
+
+  public subscript(_: Int) -> Int {
+    get { return 1 }
+    set {}
+  }
+}
+
+public enum E {
+  case basic
+  case assoc(Int)
+}
+
+open class C {
+  open func fn() {}
+
+  open var storedProp = 0
+
+  open var computedProp: Int {
+    get { return 1 }
+    set {}
+  }
+
+  public init() {}
+
+  open subscript(_: Int) -> Int {
+    get { return 1 }
+    set {}
+  }
+}
+
+public protocol P {
+  func fn()
+
+  var prop: Int { get set }
+
+  init()
+
+  subscript(_: Int) -> Int { get set }
+}
+
+public struct GenericS<T> {}
+
+public enum GenericE<T> {}
+
+open class GenericC<T> {
+  public init() {}
+}
+
+public protocol OtherProtocol {}
+public struct ConcreteType: OtherProtocol {}
+
+public protocol ProtocolWithAssoc {
+  associatedtype T: OtherProtocol = ConcreteType
+  func f()
+}
+
+extension ProtocolWithAssoc {
+  public func f() {}
+}
+
+public protocol BaseP {}
+extension S: BaseP {}