Merge pull request #21014 from slavapestov/backward-deployment-5.0

Backward deployment fixes and tests [5.0]

Author: AnnaZaks

include/swift/ABI/Metadata.h

@@ -845,13 +845,15 @@ struct TargetVTableDescriptorHeader {
 template <typename Runtime>
 struct TargetMethodOverrideDescriptor {
   /// The class containing the base method.
-  TargetRelativeIndirectablePointer<Runtime, TargetClassDescriptor<Runtime>> Class;
+  TargetRelativeIndirectablePointer<Runtime, TargetClassDescriptor<Runtime>,
+                                    /*nullable*/ true> Class;
 
   /// The base method.
-  TargetRelativeIndirectablePointer<Runtime, TargetMethodDescriptor<Runtime>> Method;
+  TargetRelativeIndirectablePointer<Runtime, TargetMethodDescriptor<Runtime>,
+                                    /*nullable*/ true> Method;
 
   /// The implementation of the override.
-  TargetRelativeDirectPointer<Runtime, void, /*Nullable=*/true> Impl;
+  TargetRelativeDirectPointer<Runtime, void, /*nullable*/ true> Impl;
 };
 
 /// Header for a class vtable override descriptor. This is a variable-sized

include/swift/AST/Attr.def

@@ -362,7 +362,7 @@ DECL_ATTR(_clangImporterSynthesizedType, ClangImporterSynthesizedType,
   NotSerialized, 74)
 SIMPLE_DECL_ATTR(_weakLinked, WeakLinked,
   OnNominalType | OnAssociatedType | OnFunc | OnAccessor | OnVar |
-  OnSubscript | OnConstructor | OnEnumElement | UserInaccessible,
+  OnSubscript | OnConstructor | OnEnumElement | OnExtension | UserInaccessible,
   75)
 SIMPLE_DECL_ATTR(_frozen, Frozen,
   OnEnum |

include/swift/AST/ProtocolConformance.h

@@ -356,6 +356,9 @@ class RootProtocolConformance : public ProtocolConformance {
 
   bool isInvalid() const;
 
+  /// Whether this conformance is weak-imported.
+  bool isWeakImported(ModuleDecl *fromModule) const;
+
   bool hasWitness(ValueDecl *requirement) const;
   Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
 

lib/AST/Decl.cpp

@@ -557,6 +557,12 @@ bool Decl::isWeakImported(ModuleDecl *fromModule) const {
   if (auto *dtor = dyn_cast<DestructorDecl>(this))
     return cast<ClassDecl>(dtor->getDeclContext())->isWeakImported(fromModule);
 
+  auto *dc = getDeclContext();
+  if (auto *ext = dyn_cast<ExtensionDecl>(dc))
+    return ext->isWeakImported(fromModule);
+  if (auto *ntd = dyn_cast<NominalTypeDecl>(dc))
+    return ntd->isWeakImported(fromModule);
+
   // FIXME: Also check availability when containingModule is resilient.
   return false;
 }

lib/AST/ProtocolConformance.cpp

@@ -394,6 +394,29 @@ SourceLoc RootProtocolConformance::getLoc() const {
   ROOT_CONFORMANCE_SUBCLASS_DISPATCH(getLoc, ())
 }
 
+bool RootProtocolConformance::isWeakImported(ModuleDecl *fromModule) const {
+  auto *dc = getDeclContext();
+  if (dc->getParentModule() == fromModule)
+    return false;
+
+  // If the protocol is weak imported, so are any conformances to it.
+  if (getProtocol()->isWeakImported(fromModule))
+    return true;
+
+  // If the conforming type is weak imported, so are any of its conformances.
+  if (auto *nominal = getType()->getAnyNominal())
+    if (nominal->isWeakImported(fromModule))
+      return true;
+
+  // If the conformance is declared in an extension with the @_weakLinked
+  // attribute, it is weak imported.
+  if (auto *ext = dyn_cast<ExtensionDecl>(dc))
+    if (ext->isWeakImported(fromModule))
+      return true;
+
+  return false;
+}
+
 bool RootProtocolConformance::hasWitness(ValueDecl *requirement) const {
   ROOT_CONFORMANCE_SUBCLASS_DISPATCH(hasWitness, (requirement))
 }

lib/IRGen/Linking.cpp

@@ -917,6 +917,11 @@ bool LinkEntity::isWeakImported(ModuleDecl *module) const {
   case Kind::DynamicallyReplaceableFunctionImpl:
     return getDecl()->isWeakImported(module);
 
+  case Kind::ProtocolWitnessTable:
+  case Kind::ProtocolConformanceDescriptor:
+    return getProtocolConformance()->getRootConformance()
+                                   ->isWeakImported(module);
+
   // TODO: Revisit some of the below, for weak conformances.
   case Kind::TypeMetadataPattern:
   case Kind::TypeMetadataInstantiationCache:
@@ -925,12 +930,10 @@ bool LinkEntity::isWeakImported(ModuleDecl *module) const {
   case Kind::TypeMetadataCompletionFunction:
   case Kind::ExtensionDescriptor:
   case Kind::AnonymousDescriptor:
-  case Kind::ProtocolWitnessTable:
   case Kind::ProtocolWitnessTablePattern:
   case Kind::GenericProtocolWitnessTableInstantiationFunction:
   case Kind::AssociatedTypeWitnessTableAccessFunction:
   case Kind::ReflectionAssociatedTypeDescriptor:
-  case Kind::ProtocolConformanceDescriptor:
   case Kind::ProtocolWitnessTableLazyAccessFunction:
   case Kind::ProtocolWitnessTableLazyCacheVariable:
   case Kind::ValueWitness:

stdlib/public/runtime/Metadata.cpp

@@ -2364,6 +2364,11 @@ static void initClassVTable(ClassMetadata *self) {
       auto *baseClass = descriptor.Class.get();
       auto *baseMethod = descriptor.Method.get();
 
+      // If the base method is null, it's an unavailable weak-linked
+      // symbol.
+      if (baseClass == nullptr || baseMethod == nullptr)
+        continue;
+
       // Calculate the base method's vtable offset from the
       // base method descriptor. The offset will be relative
       // to the base class's vtable start offset.

test/IRGen/Inputs/weak_import_native_helper.swift

@@ -83,7 +83,10 @@ public protocol P {
 }
 
 @_weakLinked
-public struct WeakS {}
+public struct WeakS {
+  public init() {}
+  public func weakMember() {}
+}
 
 @_weakLinked
 public enum WeakE {}
@@ -115,3 +118,6 @@ public protocol ProtocolWithWeakMembers {
 extension ProtocolWithWeakMembers {
   @_weakLinked public func f() {}
 }
+
+public protocol BaseP {}
+@_weakLinked extension S : BaseP {}

test/IRGen/weak_import_native.swift

@@ -55,6 +55,10 @@ func testStruct() {
   let z = s[0]
   s[0] = z
   s[0] += 1
+
+  // CHECK-DAG: declare extern_weak {{.+}} @"$s25weak_import_native_helper5WeakSV0A6MemberyyF"
+  let w = WeakS()
+  w.weakMember()
 }
 
 func testEnum() {
@@ -166,3 +170,8 @@ class WeakGenericSub: GenericC<Int> {
     // CHECK-DAG: declare extern_weak swiftcc {{.+}} @"$s25weak_import_native_helper8GenericCCfd"
   }
 }
+
+protocol RefinesP : BaseP {}
+
+// CHECK-DAG: @"$s25weak_import_native_helper1SVAA5BasePAAWP" = extern_weak global i8*
+extension S : RefinesP {}

test/lit.cfg

@@ -1139,11 +1139,17 @@ config.target_sil_nm = (
     '%s -target %s %s'
     % (config.sil_nm, config.variant_triple, mcp_opt))
 
+rth_flags = ''
+if swift_execution_tests_extra_flags:
+    rth_flags = swift_execution_tests_extra_flags + ' -wmo'
+
 config.target_resilience_test = (
      '%s --target-build-swift "%s" --target-run "%s" --t %%t --S %%S --s %%s '
-     '--lib-prefix "%s" --lib-suffix ".%s" --target-codesign "%s"'
+     '--lib-prefix "%s" --lib-suffix ".%s" --target-codesign "%s" '
+     '--additional-compile-flags "%s"'
      % (config.rth, config.target_build_swift, config.target_run, 'lib',
-        config.target_dylib_extension, config.target_codesign))
+        config.target_dylib_extension, config.target_codesign,
+        rth_flags))
 
 # FIXME: Get symbol diffing working with binutils nm as well. The flags are slightly
 # different.