[cxx-interop] Prohibit weak references to foreign reference types

This fixes a runtime crash when a `weak` reference to a C++ foreign reference type is used.

Instead of a runtime crash, Swift would now emit a compiler error saying that `weak` keyword is incompatible with foreign reference types.

rdar://124040825 / resolves #83080

Author: egorzhdan

include/swift/AST/Decl.h

@@ -707,7 +707,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     KnownProtocol : 8 // '8' for speed. This only needs 6.
   );
 
-  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 1+1+2+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 1+1+2+1+1+1+1+1+1+1,
     /// Whether this class inherits its superclass's convenience initializers.
     InheritsSuperclassInits : 1,
     ComputedInheritsSuperclassInits : 1,
@@ -721,9 +721,9 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     HasMissingVTableEntries : 1,
     ComputedHasMissingVTableEntries : 1,
 
-    /// Whether instances of this class are incompatible
-    /// with weak and unowned references.
+    /// Whether instances of this class are incompatible with weak references.
     IsIncompatibleWithWeakReferences : 1,
+    IsIncompatibleWithUnownedReferences : 1,
 
     /// Set when the class represents an actor
     IsActor : 1
@@ -5272,8 +5272,7 @@ class ClassDecl final : public NominalTypeDecl {
     Bits.ClassDecl.HasMissingVTableEntries = newValue;
   }
 
-  /// Returns true if this class cannot be used with weak or unowned
-  /// references.
+  /// Returns true if this class cannot be used with weak references.
   /// 
   /// Note that this is true if this class or any of its ancestor classes
   /// are marked incompatible.
@@ -5283,6 +5282,16 @@ class ClassDecl final : public NominalTypeDecl {
     Bits.ClassDecl.IsIncompatibleWithWeakReferences = newValue;
   }
 
+  /// Returns true if this class cannot be used with unowned references.
+  /// 
+  /// Note that this is true if this class or any of its ancestor classes
+  /// are marked incompatible.
+  bool isIncompatibleWithUnownedReferences() const;
+
+  void setIsIncompatibleWithUnownedReferences(bool newValue = true) {
+    Bits.ClassDecl.IsIncompatibleWithUnownedReferences = newValue;
+  }
+
   /// Find a method of a class that overrides a given method.
   /// Return nullptr, if no such method exists.
   AbstractFunctionDecl *findOverridingDecl(

lib/AST/Decl.cpp

@@ -6594,6 +6594,7 @@ ClassDecl::ClassDecl(SourceLoc ClassLoc, Identifier Name, SourceLoc NameLoc,
   Bits.ClassDecl.HasMissingVTableEntries = 0;
   Bits.ClassDecl.ComputedHasMissingVTableEntries = 0;
   Bits.ClassDecl.IsIncompatibleWithWeakReferences = 0;
+  Bits.ClassDecl.IsIncompatibleWithUnownedReferences = 0;
   Bits.ClassDecl.IsActor = isActor;
 }
 
@@ -6719,6 +6720,16 @@ bool ClassDecl::isIncompatibleWithWeakReferences() const {
   return false;
 }
 
+bool ClassDecl::isIncompatibleWithUnownedReferences() const {
+  if (Bits.ClassDecl.IsIncompatibleWithUnownedReferences) {
+    return true;
+  }
+  if (auto superclass = getSuperclassDecl()) {
+    return superclass->isIncompatibleWithUnownedReferences();
+  }
+  return false;
+}
+
 bool ClassDecl::inheritsSuperclassInitializers() const {
   // If there's no superclass, there's nothing to inherit.
   if (!getSuperclassDecl())

lib/ClangImporter/ImportDecl.cpp

@@ -2594,6 +2594,14 @@ namespace {
         }
       }
 
+      if (auto classResult = dyn_cast<ClassDecl>(result)) {
+        // Foreign reference types cannot be held as weak references, since the
+        // Swift runtime has no way to make the pointer null when the object is
+        // deallocated.
+        // Unowned references to foreign reference types are supported.
+        classResult->setIsIncompatibleWithWeakReferences();
+      }
+
       if (cxxRecordDecl) {
         if (auto structResult = dyn_cast<StructDecl>(result)) {
           // Address-only type is a type that can't be passed in registers.

lib/Sema/TypeCheckAttr.cpp

@@ -5451,7 +5451,11 @@ Type TypeChecker::checkReferenceOwnershipAttr(VarDecl *var, Type type,
   }
 
   ClassDecl *underlyingClass = underlyingType->getClassOrBoundGenericClass();
-  if (underlyingClass && underlyingClass->isIncompatibleWithWeakReferences()) {
+  if (underlyingClass &&
+      ((ownershipKind == ReferenceOwnership::Weak &&
+        underlyingClass->isIncompatibleWithWeakReferences()) ||
+       (ownershipKind == ReferenceOwnership::Unowned &&
+        underlyingClass->isIncompatibleWithUnownedReferences()))) {
     Diags
         .diagnose(attr->getLocation(),
                   diag::invalid_ownership_incompatible_class, underlyingType,

test/Interop/Cxx/foreign-reference/weak-reference-typechecker.swift

@@ -0,0 +1,11 @@
+// RUN: %target-typecheck-verify-swift -cxx-interoperability-mode=default -I %S/Inputs -disable-availability-checking
+
+import POD
+
+struct HasWeakReference {
+  weak var x: Empty? // expected-error {{'Empty' is incompatible with 'weak' references}}
+}
+
+struct HasUnownedReference {
+  unowned var x: Empty!
+}