[cxx-interop] Fix crash when inout parameter is used in some "template contexts".

We used to incorrectly forward inout paramters in the thunk for both template paramters that aren't used in the signature and in the thunk for dependent types as Any.

Now this works in the simple case. We'll need to do something more complicated when we have an `inout Any` for dependent types because we will need to somehow cast without copying. This will probably require synthesising the SIL of the thunk manually.

Author: zoecarver

lib/Sema/CSApply.cpp

@@ -220,14 +220,22 @@ synthesizeDependentTypeThunkParamForwarding(AbstractFunctionDecl *afd, void *con
       continue;
     }
 
-    auto paramRefExpr = new (ctx) DeclRefExpr(param, DeclNameLoc(),
-                                              /*Implicit=*/true);
+    Expr *paramRefExpr = new (ctx) DeclRefExpr(param, DeclNameLoc(),
+                                               /*Implicit=*/true);
     paramRefExpr->setType(param->getType());
 
+    if (param->isInOut()) {
+      paramRefExpr->setType(LValueType::get(param->getType()));
+
+      paramRefExpr = new (ctx) InOutExpr(
+          SourceLoc(), paramRefExpr, param->getType(), /*isImplicit*/ true);
+      paramRefExpr->setType(InOutType::get(param->getType()));
+    }
+
     auto specParamTy = specializedFuncDecl->getParameters()->get(paramIndex)->getType();
 
     Expr *argExpr = nullptr;
-    if (specParamTy->isEqual(paramRefExpr->getType())) {
+    if (specParamTy->isEqual(param->getType())) {
       argExpr = paramRefExpr;
     } else {
       argExpr = ForcedCheckedCastExpr::createImplicit(ctx, paramRefExpr,
@@ -353,9 +361,18 @@ synthesizeForwardingThunkBody(AbstractFunctionDecl *afd, void *context) {
     if (isa<MetatypeType>(param->getType().getPointer())) {
       continue;
     }
-    auto paramRefExpr = new (ctx) DeclRefExpr(param, DeclNameLoc(),
-                                             /*Implicit=*/true);
+    Expr *paramRefExpr = new (ctx) DeclRefExpr(param, DeclNameLoc(),
+                                               /*Implicit=*/true);
     paramRefExpr->setType(param->getType());
+
+    if (param->isInOut()) {
+      paramRefExpr->setType(LValueType::get(param->getType()));
+
+      paramRefExpr = new (ctx) InOutExpr(
+          SourceLoc(), paramRefExpr, param->getType(), /*isImplicit*/ true);
+      paramRefExpr->setType(InOutType::get(param->getType()));
+    }
+
     forwardingParams.push_back(Argument(SourceLoc(), Identifier(), paramRefExpr));
   }
 

test/Interop/Cxx/templates/Inputs/template-type-parameter-not-in-signature.h

@@ -33,6 +33,9 @@ T templateTypeParamUsedInReturnType(int x) { return x; }
 template <typename T>
 T templateTypeParamUsedInReferenceParam(T &t) { return t; }
 
+template <typename T, typename U>
+T templateTypeParamNotUsedInSignatureWithRef(T &t) { return t; }
+
 template <typename T, typename U>
 void templateTypeParamNotUsedInSignatureWithVarargs(...) {}
 

test/Interop/Cxx/templates/dependent-types.swift

@@ -35,6 +35,13 @@ DependentTypesTestSuite.test("Multiple dependent arguments (not inferred).") {
   expectEqual(m.getValue(), 42)
 }
 
+DependentTypesTestSuite.test("Takes inout argument and returns dependent type.") {
+  var x = 42
+  let m = refToDependent(&x) as! M<Int>
+  expectEqual(m.getValue(), 42)
+}
+
+
 // We still have some problems calling methods on Windows: SR-13129 and rdar://88391102
 #if !os(Windows)
 DependentTypesTestSuite.test("Function template methods") {

test/Interop/Cxx/templates/template-type-parameter-not-in-signature.swift

@@ -39,4 +39,10 @@ TemplateNotInSignatureTestSuite.test("Member function templates (static)") {
   Struct.templateTypeParamNotUsedInSignatureStatic(T: Int.self)
 }
 
+TemplateNotInSignatureTestSuite.test("Type not used in signature and takes an inout parameter.") {
+  var x = 42
+  let out = templateTypeParamNotUsedInSignatureWithRef(&x, U: Int.self)
+  expectEqual(out, 42)
+}
+
 runAllTests()