Support foreign reference types when C++ interop is disabled.

Author: zoecarver

include/swift/ClangImporter/ClangImporterRequests.h

@@ -315,10 +315,10 @@ enum class CxxRecordSemanticsKind {
 };
 
 struct CxxRecordSemanticsDescriptor final {
-  const clang::CXXRecordDecl *decl;
+  const clang::RecordDecl *decl;
   ASTContext &ctx;
 
-  CxxRecordSemanticsDescriptor(const clang::CXXRecordDecl *decl,
+  CxxRecordSemanticsDescriptor(const clang::RecordDecl *decl,
                                ASTContext &ctx)
       : decl(decl), ctx(ctx) {}
 

lib/ClangImporter/ClangImporter.cpp

@@ -6328,37 +6328,41 @@ CxxRecordSemantics::evaluate(Evaluator &evaluator,
     return CxxRecordSemanticsKind::Reference;
   }
 
-  if (!hasRequiredValueTypeOperations(decl)) {
-    if (hasUnsafeAPIAttr(decl))
+  auto cxxDecl = dyn_cast<clang::CXXRecordDecl>(decl);
+  if (!cxxDecl)
+    return CxxRecordSemanticsKind::Trivial;
+
+  if (!hasRequiredValueTypeOperations(cxxDecl)) {
+    if (hasUnsafeAPIAttr(cxxDecl))
       desc.ctx.Diags.diagnose({}, diag::api_pattern_attr_ignored,
                               "import_unsafe", decl->getNameAsString());
-    if (hasOwnedValueAttr(decl))
+    if (hasOwnedValueAttr(cxxDecl))
       desc.ctx.Diags.diagnose({}, diag::api_pattern_attr_ignored,
                               "import_owned", decl->getNameAsString());
-    if (hasIteratorAPIAttr(decl))
+    if (hasIteratorAPIAttr(cxxDecl))
       desc.ctx.Diags.diagnose({}, diag::api_pattern_attr_ignored,
                               "import_iterator", decl->getNameAsString());
 
     return CxxRecordSemanticsKind::MissingLifetimeOperation;
   }
 
-  if (hasUnsafeAPIAttr(decl)) {
+  if (hasUnsafeAPIAttr(cxxDecl)) {
     return CxxRecordSemanticsKind::ExplicitlyUnsafe;
   }
 
-  if (hasOwnedValueAttr(decl)) {
+  if (hasOwnedValueAttr(cxxDecl)) {
     return CxxRecordSemanticsKind::Owned;
   }
 
-  if (hasIteratorAPIAttr(decl) || isIterator(decl)) {
+  if (hasIteratorAPIAttr(cxxDecl) || isIterator(cxxDecl)) {
     return CxxRecordSemanticsKind::Iterator;
   }
 
-  if (hasPointerInSubobjects(decl)) {
+  if (hasPointerInSubobjects(cxxDecl)) {
     return CxxRecordSemanticsKind::UnsafePointerMember;
   }
 
-  if (isSufficientlyTrivial(decl)) {
+  if (isSufficientlyTrivial(cxxDecl)) {
     return CxxRecordSemanticsKind::Trivial;
   }
 

lib/ClangImporter/ImportDecl.cpp

@@ -1945,14 +1945,10 @@ namespace {
     }
 
     bool recordHasReferenceSemantics(const clang::RecordDecl *decl) {
-      if (auto cxxRecord = dyn_cast<clang::CXXRecordDecl>(decl)) {
-        auto semanticsKind = evaluateOrDefault(
-            Impl.SwiftContext.evaluator,
-            CxxRecordSemantics({cxxRecord, Impl.SwiftContext}), {});
-        return semanticsKind == CxxRecordSemanticsKind::Reference;
-      }
-
-      return false;
+      auto semanticsKind = evaluateOrDefault(
+          Impl.SwiftContext.evaluator,
+          CxxRecordSemantics({decl, Impl.SwiftContext}), {});
+      return semanticsKind == CxxRecordSemanticsKind::Reference;
     }
 
     Decl *VisitRecordDecl(const clang::RecordDecl *decl) {

test/Interop/C/struct/Inputs/foreign-reference.h

@@ -0,0 +1,64 @@
+#ifndef TEST_INTEROP_C_INPUTS_FOREIGN_REFERENCE_H
+#define TEST_INTEROP_C_INPUTS_FOREIGN_REFERENCE_H
+
+#include <stdlib.h>
+
+#if __has_feature(nullability)
+// Provide macros to temporarily suppress warning about the use of
+// _Nullable and _Nonnull.
+# define SWIFT_BEGIN_NULLABILITY_ANNOTATIONS                                   \
+  _Pragma("clang diagnostic push")                                             \
+  _Pragma("clang diagnostic ignored \"-Wnullability-extension\"")              \
+  _Pragma("clang assume_nonnull begin")
+# define SWIFT_END_NULLABILITY_ANNOTATIONS                                     \
+  _Pragma("clang diagnostic pop")                                              \
+  _Pragma("clang assume_nonnull end")
+
+#else
+// #define _Nullable and _Nonnull to nothing if we're not being built
+// with a compiler that supports them.
+# define _Nullable
+# define _Nonnull
+# define _Null_unspecified
+# define SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
+# define SWIFT_END_NULLABILITY_ANNOTATIONS
+#endif
+
+SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
+
+struct
+    __attribute__((swift_attr("import_as_ref")))
+    __attribute__((swift_attr("retain:LCRetain")))
+    __attribute__((swift_attr("release:LCRelease")))
+LocalCount {
+  int value;
+};
+
+static inline struct LocalCount *createLocalCount() {
+  struct LocalCount *ptr = malloc(sizeof(struct LocalCount));
+  ptr->value = 1;
+  return ptr;
+}
+
+static inline void LCRetain(struct LocalCount *x) { x->value++; }
+static inline void LCRelease(struct LocalCount *x) { x->value--; }
+
+static int globalCount = 0;
+
+struct
+    __attribute__((swift_attr("import_as_ref")))
+    __attribute__((swift_attr("retain:GCRetain")))
+    __attribute__((swift_attr("release:GCRelease")))
+GlobalCount {};
+
+static inline struct GlobalCount *createGlobalCount() {
+  globalCount++;
+  return malloc(sizeof(struct GlobalCount));
+}
+
+static inline void GCRetain(struct GlobalCount *x) { globalCount++; }
+static inline void GCRelease(struct GlobalCount *x) { globalCount--; }
+
+SWIFT_END_NULLABILITY_ANNOTATIONS
+
+#endif // TEST_INTEROP_C_INPUTS_FOREIGN_REFERENCE_H

test/Interop/C/struct/Inputs/module.modulemap

@@ -2,3 +2,7 @@ module StructDeclContext {
   header "struct-decl-context.h"
   export *
 }
+
+module ForeignReference {
+  header "foreign-reference.h"
+}

test/Interop/C/struct/foreign-reference.swift

@@ -0,0 +1,44 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs/ -Xfrontend -validate-tbd-against-ir=none)
+//
+// REQUIRES: executable_test
+// TODO: This should work without ObjC interop in the future rdar://97497120
+// REQUIRES: objc_interop
+
+import StdlibUnittest
+import ForeignReference
+
+var ReferenceCountedTestSuite = TestSuite("Foreign reference types that have reference counts")
+
+@inline(never)
+public func blackHole<T>(_ _: T) {  }
+
+ReferenceCountedTestSuite.test("Local") {
+    var x = createLocalCount()
+    expectEqual(x.value, 6) // This is 6 because of "var x" "x.value" * 2 and "(x, x, x)".
+
+    let t = (x, x, x)
+    expectEqual(x.value, 5)
+}
+
+@inline(never)
+func globalTest1() {
+    var x = createGlobalCount()
+    let t = (x, x, x)
+    expectEqual(globalCount, 4)
+    blackHole(t)
+}
+
+@inline(never)
+func globalTest2() {
+    var x = createGlobalCount()
+    expectEqual(globalCount, 1)
+}
+
+ReferenceCountedTestSuite.test("Global") {
+    expectEqual(globalCount, 0)
+    globalTest1()
+    globalTest2()
+    expectEqual(globalCount, 0)
+}
+
+runAllTests()