[interop] C++ parameter of reference type should be imported as its pointee type in Swift even if parameter's type is type alias

This finally allows std::vector.push_back to be called with the pushed value directly passed into it

Author: hyp

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

@@ -6832,3 +6832,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,20 +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;
-    }
+  }
 
-    // We don't support rvalue reference types, just bail.
-    if (refType->isRValueReferenceType()) {
-      return None;
-    }
+  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;
+      }
 
-    paramTy = refType->getPointeeType();
-    if (!paramTy.isConstQualified())
-      isInOut = true;
+      // We don't support rvalue reference types, just bail.
+      if (paramTy->isRValueReferenceType()) {
+        // FIXME: add import diagnostic.
+        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-module-interface.swift

@@ -10,6 +10,8 @@
 // CHECK: func setConstStaticIntRef(_: 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>
 

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

@@ -51,3 +51,21 @@ func setCxxConstRef() {
 // CHECK: sil hidden @$s4main14setCxxConstRefyyF : $@convention(thin) () -> ()
 // CHECK: [[REF:%.*]] = function_ref @{{_Z20setConstStaticIntRefRKi|\?setConstStaticIntRef@@YAXAEBH@Z}} : $@convention(c) (@in_guaranteed Int32) -> ()
 // CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@in_guaranteed Int32) -> ()
+
+func setCxxConstRefTypealias() {
+  let val: CInt = 21
+  setConstStaticIntRefTypealias(val)
+}
+
+// CHECK: sil hidden @$s4main23setCxxConstRefTypealiasyyF : $@convention(thin) () -> ()
+// CHECK: [[REF:%.*]] = function_ref @{{_Z29setConstStaticIntRefTypealiasRKi|\?setConstStaticIntRefTypealias@@YAXAEBH@Z}} : $@convention(c) (@in_guaranteed Int32) -> ()
+// CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@in_guaranteed Int32) -> ()
+
+func setStaticIntRefTypealias() {
+  var val: CInt = 21
+  setStaticIntRefTypealias(&val)
+}
+
+// CHECK: sil hidden @$s4main24setStaticIntRefTypealiasyyF : $@convention(thin) () -> ()
+// CHECK: [[REF:%.*]] = function_ref @{{_Z24setStaticIntRefTypealiasRi|\?setStaticIntRefTypealias@@YAXAEAH@Z}} : $@convention(c) (@inout Int32) -> ()
+// CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@inout Int32) -> ()

test/Interop/Cxx/reference/reference.swift

@@ -42,13 +42,18 @@ ReferenceTestSuite.test("pass-lvalue-reference") {
   var val: CInt = 21
   setStaticIntRef(&val)
   expectEqual(21, getStaticInt())
+  val = 111
+  setStaticIntRefTypealias(&val)
+  expectEqual(getStaticInt(), 111)
 }
 
 ReferenceTestSuite.test("pass-const-lvalue-reference") {
   expectNotEqual(22, getStaticInt())
   let val: CInt = 22
   setConstStaticIntRef(val)
   expectEqual(22, getStaticInt())
+  setConstStaticIntRefTypealias(112)
+  expectEqual(getStaticInt(), 112)
 }
 
 ReferenceTestSuite.test("func-reference") {

test/Interop/Cxx/stdlib/use-std-vector.swift

@@ -19,18 +19,17 @@ StdVectorTestSuite.test("init") {
 
 StdVectorTestSuite.test("push back") {
     var v = Vector()
-    var _42: CInt = 42
-    v.push_back(&_42)
+    let _42: CInt = 42
+    v.push_back(_42)
     expectEqual(v.size(), 1)
     expectFalse(v.empty())
     expectEqual(v[0], 42)
 }
 
 func fill(vector v: inout Vector) {
-    var _1: CInt = 1, _2: CInt = 2, _3: CInt = 3
-    v.push_back(&_1)
-    v.push_back(&_2)
-    v.push_back(&_3)
+    v.push_back(1)
+    v.push_back(2)
+    v.push_back(CInt(3))
 }
 
 // TODO: in some configurations the stdlib emits a "initializeWithCopy" where the arguments