[AST] Introduce Argument::implicitInOut

This will allow us to abstract away the creation
of InOutExpr for bits of code synthesis.

Author: hamishknight

include/swift/AST/ArgumentList.h

@@ -51,6 +51,9 @@ class Argument final {
     return Argument(SourceLoc(), Identifier(), expr);
   }
 
+  /// Make an implicit unlabeled 'inout' argument.
+  static Argument implicitInOut(ASTContext &ctx, Expr *expr);
+
   SourceLoc getStartLoc() const { return getSourceRange().Start; }
   SourceLoc getEndLoc() const { return getSourceRange().End; }
   SourceRange getSourceRange() const;

lib/AST/ArgumentList.cpp

@@ -35,6 +35,19 @@ SourceRange Argument::getSourceRange() const {
   return SourceRange(labelLoc, exprEndLoc);
 }
 
+Argument Argument::implicitInOut(ASTContext &ctx, Expr *expr) {
+  assert(!isa<InOutExpr>(expr) && "Cannot nest InOutExpr");
+
+  // Eventually this will set an 'inout' bit on Argument, but for now,
+  // synthesize in the InOutExpr.
+  Type objectTy;
+  if (auto subTy = expr->getType())
+    objectTy = subTy->castTo<LValueType>()->getObjectType();
+
+  return Argument::unlabeled(
+      new (ctx) InOutExpr(SourceLoc(), expr, objectTy, /*isImplicit*/ true));
+}
+
 bool Argument::isInOut() const {
   return ArgExpr->isSemanticallyInOutExpr();
 }

lib/ClangImporter/ClangImporter.cpp

@@ -5417,30 +5417,30 @@ synthesizeDependentTypeThunkParamForwarding(AbstractFunctionDecl *afd, void *con
       paramIndex++;
       continue;
     }
+    auto paramTy = param->getType();
+    auto isInOut = param->isInOut();
+    auto specParamTy =
+        specializedFuncDecl->getParameters()->get(paramIndex)->getType();
 
     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(param->getType())) {
-      argExpr = paramRefExpr;
-    } else {
-      argExpr = ForcedCheckedCastExpr::createImplicit(ctx, paramRefExpr,
-                                                      specParamTy);
-    }
+    paramRefExpr->setType(isInOut ? LValueType::get(paramTy) : paramTy);
 
-    forwardingParams.push_back(Argument(SourceLoc(), Identifier(), argExpr));
+    Argument arg = [&]() {
+      if (isInOut) {
+        assert(specParamTy->isEqual(paramTy));
+        return Argument::implicitInOut(ctx, paramRefExpr);
+      }
+      Expr *argExpr = nullptr;
+      if (specParamTy->isEqual(paramTy)) {
+        argExpr = paramRefExpr;
+      } else {
+        argExpr = ForcedCheckedCastExpr::createImplicit(ctx, paramRefExpr,
+                                                        specParamTy);
+      }
+      return Argument::unlabeled(argExpr);
+    }();
+    forwardingParams.push_back(arg);
     paramIndex++;
   }
 
@@ -5559,19 +5559,16 @@ synthesizeForwardingThunkBody(AbstractFunctionDecl *afd, void *context) {
     if (isa<MetatypeType>(param->getType().getPointer())) {
       continue;
     }
+    auto paramTy = param->getType();
+    auto isInOut = param->isInOut();
+
     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()));
-    }
+    paramRefExpr->setType(isInOut ? LValueType::get(paramTy) : paramTy);
 
-    forwardingParams.push_back(Argument(SourceLoc(), Identifier(), paramRefExpr));
+    auto arg = isInOut ? Argument::implicitInOut(ctx, paramRefExpr)
+                       : Argument::unlabeled(paramRefExpr);
+    forwardingParams.push_back(arg);
   }
 
   Expr *specializedFuncDeclRef = new (ctx) DeclRefExpr(ConcreteDeclRef(specializedFuncDecl),

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -1821,26 +1821,22 @@ synthesizeOperatorMethodBody(AbstractFunctionDecl *afd, void *context) {
   auto methodDecl =
       static_cast<FuncDecl *>(context); /* Swift version of CXXMethod */
 
-  SmallVector<Expr *, 8> forwardingParams;
+  SmallVector<Argument, 8> forwardingArgs;
 
   // We start from +1 since the first param is our lhs. All other params are
   // forwarded
   for (auto itr = funcDecl->getParameters()->begin() + 1;
        itr != funcDecl->getParameters()->end(); itr++) {
     auto param = *itr;
+    auto isInOut = param->isInOut();
+    auto paramTy = param->getType();
     Expr *paramRefExpr =
         new (ctx) DeclRefExpr(param, DeclNameLoc(), /*Implicit*/ true);
-    paramRefExpr->setType(param->getType());
+    paramRefExpr->setType(isInOut ? LValueType::get(paramTy) : paramTy);
 
-    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(paramRefExpr);
+    auto arg = isInOut ? Argument::implicitInOut(ctx, paramRefExpr)
+                       : Argument::unlabeled(paramRefExpr);
+    forwardingArgs.push_back(arg);
   }
 
   auto methodExpr =
@@ -1865,7 +1861,7 @@ synthesizeOperatorMethodBody(AbstractFunctionDecl *afd, void *context) {
   dotCallExpr->setType(methodDecl->getMethodInterfaceType());
   dotCallExpr->setThrows(false);
 
-  auto *argList = ArgumentList::forImplicitUnlabeled(ctx, forwardingParams);
+  auto *argList = ArgumentList::createImplicit(ctx, forwardingArgs);
   auto callExpr = CallExpr::createImplicit(ctx, dotCallExpr, argList);
   callExpr->setType(funcDecl->getResultInterfaceType());
   callExpr->setThrows(false);