SR-12802: Disambiguate functions with lvalue and rvalue reference parameters in the same overload set

Author: cabmeurer

lib/ClangImporter/ImportType.cpp

@@ -2291,9 +2291,11 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
         return nullptr;
       }
 
-      paramTy = refType->getPointeeType();
-      if (!paramTy.isConstQualified())
-        isInOut = true;
+        paramTy = refType->getPointeeType();
+        if (isa<clang::LValueReferenceType>(paramTy)
+            && !paramTy.isConstQualified()) {
+            isInOut = true;
+        }
     }
 
     if (!swiftParamTy) {

lib/SIL/IR/SILFunctionType.cpp

@@ -1327,9 +1327,25 @@ 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())
-    return true;
+    
+    /*
+     Why does this not compile?
+     if (clangTy->getPointeeType().isConstQualified() ||
+         clangTy->isRValueReferenceType()) {
+         
+         return true;
+     }
+     */
+    if (clangTy->isReferenceType()) {
+        if (clangTy->getPointeeType().isConstQualified() ||
+            //The tests in Interop/Cxx/stdlib/use-std-vector.swift fails if we dont have this check.
+            clangTy->isRValueReferenceType()) {
+            
+//            printf("clangTy->getPointeeType(): %s", clangTy->getPointeeType().getAsString().c_str());
+            
+            return true;
+        }
+    }
 
   return false;
 }

test/Interop/Cxx/class/method/ambiguous-methods-module-interface.swift

@@ -3,11 +3,11 @@
 // CHECK: func increment(_ a: Int32) -> Int32
 // CHECK: mutating func incrementMutating(_ a: Int32) -> Int32
 
-// CHECK: mutating func incrementMutating(_ a: Int32, _ b: Int32, _ c: inout Int32)
-// CHECK: func increment(_ a: Int32, _ b: Int32, _ c: inout Int32)
+// CHECK: mutating func incrementMutating(_ a: Int32, _ b: Int32, _ c: Int32)
+// CHECK: func increment(_ a: Int32, _ b: Int32, _ c: Int32)
 
-// CHECK: mutating func incrementMutating(_ a: inout Int32, _ b: Int32)
-// CHECK: func increment(_ a: inout Int32, _ b: Int32)
+// CHECK: mutating func incrementMutating(_ a: Int32, _ b: Int32)
+// CHECK: func increment(_ a: Int32, _ b: Int32)
 
 // CHECK: func numberOfMutableMethodsCalled() -> Int32
 // CHECK: mutating func numberOfMutableMethodsCalledMutating() -> Int32

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

@@ -32,7 +32,7 @@ public func getConstCxxRvalueRef() -> UnsafePointer<CInt> {
 
 public func setCxxRef() {
   var val: CInt = 21
-  setStaticIntRef(&val)
+  setStaticIntRef(val)
 }
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main9setCxxRefyyF"()
@@ -48,7 +48,7 @@ public func setCxxConstRef() {
 
 public func setCxxRvalueRef() {
   var val: CInt = 21
-  setStaticIntRvalueRef(&val)
+  setStaticIntRvalueRef(val)
 }
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main15setCxxRvalueRefyyF"()

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

@@ -24,18 +24,16 @@ StdVectorTestSuite.test("init") {
 
 StdVectorTestSuite.test("push back") {
     var v = Vector()
-    var _42: CInt = 42
-    v.push_back(&_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(3)
 }
 
 // TODO: in some configurations the stdlib emits a "initializeWithCopy" where the arguments