Merge pull request #65578 from zoecarver/disable-rvalue-ref

[cxx-interop] Disable rvalue references. We don't support them correc…

Author: zoecarver

include/swift/AST/DiagnosticsClangImporter.def

@@ -156,6 +156,7 @@ NOTE(macro_not_imported, none, "macro '%0' unavailable (cannot import)", (String
 
 NOTE(return_type_not_imported, none, "return type unavailable (cannot import)", ())
 NOTE(parameter_type_not_imported, none, "parameter %0 unavailable (cannot import)", (const clang::NamedDecl*))
+NOTE(rvalue_ref_params_not_imported, none, "C++ functions with rvalue reference parameters are unavailable in Swift", ())
 NOTE(incomplete_interface, none, "interface %0 is incomplete", (const clang::NamedDecl*))
 NOTE(incomplete_protocol, none, "protocol %0 is incomplete", (const clang::NamedDecl*))
 NOTE(incomplete_record, none, "record '%0' is not defined (incomplete)", (StringRef))

include/swift/ClangImporter/ClangImporter.h

@@ -588,6 +588,14 @@ namespace importer {
 /// Returns true if the given module has a 'cplusplus' requirement.
 bool requiresCPlusPlus(const clang::Module *module);
 
+/// Returns the pointee type if the given type is a C++ `const`
+/// reference type, `None` otherwise.
+llvm::Optional<clang::QualType>
+getCxxReferencePointeeTypeOrNone(const clang::Type *type);
+
+/// Returns true if the given type is a C++ `const` reference type.
+bool isCxxConstReferenceType(const clang::Type *type);
+
 } // namespace importer
 
 struct ClangInvocationFileMapping {

lib/ClangImporter/ClangImporter.cpp

@@ -6834,3 +6834,15 @@ bool importer::requiresCPlusPlus(const clang::Module *module) {
     return req.first == "cplusplus";
   });
 }
+
+llvm::Optional<clang::QualType>
+importer::getCxxReferencePointeeTypeOrNone(const clang::Type *type) {
+  if (type->isReferenceType())
+    return type->getPointeeType();
+  return {};
+}
+
+bool importer::isCxxConstReferenceType(const clang::Type *type) {
+  auto pointeeType = getCxxReferencePointeeTypeOrNone(type);
+  return pointeeType && pointeeType->isConstQualified();
+}

lib/ClangImporter/ImportType.cpp

@@ -2356,15 +2356,32 @@ ClangImporter::Implementation::importParameterType(
                  dyn_cast<clang::TemplateTypeParmType>(paramTy)) {
     swiftParamTy = findGenericTypeInGenericDecls(
         *this, templateParamType, genericParams, attrs, addImportDiagnosticFn);
-  } else if (auto refType = dyn_cast<clang::ReferenceType>(paramTy)) {
-    // We don't support reference type to a dependent type, just bail.
-    if (refType->getPointeeType()->isDependentType()) {
-      return None;
-    }
+  }
 
-    paramTy = refType->getPointeeType();
-    if (!paramTy.isConstQualified())
-      isInOut = true;
+  if (!swiftParamTy) {
+    // C++ reference types are brought in as direct
+    // types most commonly.
+    auto refPointeeType =
+        importer::getCxxReferencePointeeTypeOrNone(paramTy.getTypePtr());
+    if (refPointeeType) {
+      // We don't support reference type to a dependent type, just bail.
+      if ((*refPointeeType)->isDependentType()) {
+        return None;
+      }
+
+      // We don't support rvalue reference types, just bail.
+      if (paramTy->isRValueReferenceType()) {
+        addImportDiagnosticFn(Diagnostic(diag::rvalue_ref_params_not_imported));
+        return None;
+      }
+
+      // A C++ parameter of type `const <type> &` or `<type> &` becomes `<type>`
+      // or `inout <type>` in Swift. Note that SILGen will use the indirect
+      // parameter convention for such a type.
+      paramTy = *refPointeeType;
+      if (!paramTy.isConstQualified())
+        isInOut = true;
+    }
   }
 
   // Special case for NSDictionary's subscript.

lib/SIL/IR/SILFunctionType.cpp

@@ -1420,8 +1420,7 @@ static bool isClangTypeMoreIndirectThanSubstType(TypeConverter &TC,
   // Pass C++ const reference types indirectly. Right now there's no way to
   // express immutable borrowed params, so we have to have this hack.
   // Eventually, we should just express these correctly: rdar://89647503
-  if (clangTy->isReferenceType() &&
-      clangTy->getPointeeType().isConstQualified())
+  if (importer::isCxxConstReferenceType(clangTy))
     return true;
 
   return false;
@@ -3109,7 +3108,7 @@ static bool isCFTypedef(const TypeLowering &tl, clang::QualType type) {
 static ParameterConvention getIndirectCParameterConvention(clang::QualType type) {
   // Non-trivial C++ types would be Indirect_Inout (at least in Itanium).
   // A trivial const * parameter in C should be considered @in.
-  if (type->isReferenceType() && type->getPointeeType().isConstQualified())
+  if (importer::isCxxConstReferenceType(type.getTypePtr()))
     return ParameterConvention::Indirect_In_Guaranteed;
   return ParameterConvention::Indirect_In;
 }

test/Interop/Cxx/reference/Inputs/reference.cpp

@@ -20,3 +20,11 @@ auto getFuncRvalueRef() -> int (&&)() { return getStaticInt; }
 void takeConstRef(const int &value) {
   staticInt = value;
 }
+
+void setConstStaticIntRefTypealias(ConstIntRefTypealias ref) {
+  staticInt = ref;
+}
+
+void setStaticIntRefTypealias(IntRefTypealias ref) {
+  staticInt = ref;
+}

test/Interop/Cxx/reference/Inputs/reference.h

@@ -16,6 +16,14 @@ void setConstStaticIntRvalueRef(const int &&);
 auto getFuncRef() -> int (&)();
 auto getFuncRvalueRef() -> int (&&)();
 
+using ConstIntRefTypealias = const int &;
+
+void setConstStaticIntRefTypealias(ConstIntRefTypealias ref);
+
+using IntRefTypealias = int &;
+
+void setStaticIntRefTypealias(IntRefTypealias ref);
+
 template<class T>
 struct ClassTemplate {};
 

test/Interop/Cxx/reference/reference-cannot-import-diagnostic.swift

@@ -0,0 +1,24 @@
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: not %target-swift-frontend -typecheck -I %t/Inputs  %t/test.swift  -enable-experimental-cxx-interop 2>&1 | %FileCheck %s
+
+//--- Inputs/module.modulemap
+module Test {
+    header "test.h"
+    requires cplusplus
+}
+
+//--- Inputs/test.h
+
+void acceptRValueRef(int &&);
+
+//--- test.swift
+
+import Test
+
+public func test() {
+  var x: CInt = 2
+  acceptRValueRef(x)
+  // CHECK: note: function 'acceptRValueRef' unavailable (cannot import)
+  // CHECK: note: C++ functions with rvalue reference parameters are unavailable in Swift
+}

test/Interop/Cxx/reference/reference-irgen.swift

@@ -45,19 +45,3 @@ public func setCxxConstRef() {
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main14setCxxConstRefyyF"()
 // CHECK: call void @{{_Z20setConstStaticIntRefRKi|"\?setConstStaticIntRef@@YAXAEBH@Z"}}(i32* %{{.*}})
-
-public func setCxxRvalueRef() {
-  var val: CInt = 21
-  setStaticIntRvalueRef(&val)
-}
-
-// CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main15setCxxRvalueRefyyF"()
-// CHECK: call void @{{_Z21setStaticIntRvalueRefOi|"\?setStaticIntRvalueRef@@YAX\$\$QEAH@Z"}}(i32* %{{.*}})
-
-public func setCxxConstRvalueRef() {
-  let val: CInt = 21
-  setConstStaticIntRvalueRef(val)
-}
-
-// CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main20setCxxConstRvalueRefyyF"()
-// CHECK: call void @{{_Z26setConstStaticIntRvalueRefOKi|"\?setConstStaticIntRvalueRef@@YAX\$\$QEBH@Z"}}(i32* %{{.*}})

test/Interop/Cxx/reference/reference-module-interface.swift

@@ -7,14 +7,16 @@
 // CHECK: func getConstStaticIntRvalueRef() -> UnsafePointer<Int32>
 // CHECK: func setStaticInt(_: Int32)
 // CHECK: func setStaticIntRef(_: inout Int32)
-// CHECK: func setStaticIntRvalueRef(_: inout Int32)
 // CHECK: func setConstStaticIntRef(_: Int32)
-// CHECK: func setConstStaticIntRvalueRef(_: Int32)
 // CHECK: func getFuncRef() -> @convention(c) () -> Int32
 // CHECK: func getFuncRvalueRef() -> @convention(c) () -> Int32
+// CHECK: func setConstStaticIntRefTypealias(_ ref: Int32)
+// CHECK: func setStaticIntRefTypealias(_ ref: inout Int32)
 // CHECK: func refToTemplate<T>(_ t: inout T) -> UnsafeMutablePointer<T>
 // CHECK: func constRefToTemplate<T>(_ t: T) -> UnsafePointer<T>
 
 // CHECK-NOT: refToDependent
 // CHECK-NOT: refToDependentParam
 // CHECK-NOT: dontImportAtomicRef
+// CHECK-NOT: setStaticIntRvalueRef
+// CHECK-NOT: setConstStaticIntRvalueRef