SIL: Remove type lowering support for InOutType

There is still some unfortunate hackery around InOutType in
SILGenProlog.cpp, but I don't want to clean it up yet.

Author: slavapestov

lib/SIL/SILFunctionType.cpp

@@ -686,10 +686,16 @@ class DestructureInputs {
 
     unsigned origParamIndex = NextOrigParamIndex++;
 
+    bool isInout = false;
+    if (auto inoutType = dyn_cast<InOutType>(substType)) {
+      isInout = true;
+      substType = inoutType.getObjectType();
+      origType = origType.getWithoutSpecifierType();
+    }
+
     auto &substTL = M.Types.getTypeLowering(origType, substType);
     ParameterConvention convention;
-    if (isa<InOutType>(substType)) {
-      assert(origType.isTypeParameter() || origType.getAs<InOutType>());
+    if (isInout) {
       convention = ParameterConvention::Indirect_Inout;
     } else if (isFormallyPassedIndirectly(origType, substType, substTL)) {
       if (forSelf && rep == SILFunctionTypeRepresentation::WitnessMethod)

lib/SIL/TypeLowering.cpp

@@ -1301,7 +1301,7 @@ TypeConverter::~TypeConverter() {
     CanType srcType = ti.first.OrigType;
     if (!srcType) continue;
     CanType mappedType = ti.second->getLoweredType().getASTType();
-    if (srcType == mappedType || isa<InOutType>(srcType))
+    if (srcType == mappedType)
       ti.second->~TypeLowering();
   }
 }
@@ -1440,26 +1440,11 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
 
   assert((!key.isDependent() || getCurGenericContext())
          && "dependent type outside of generic context?!");
-  
+  assert(!substType->is<InOutType>());
+
   if (auto existing = find(key))
     return *existing;
 
-  // inout types are a special case for lowering, because they get
-  // completely removed and represented as 'address' SILTypes.
-  if (isa<InOutType>(substType)) {
-    // Derive SILType for InOutType from the object type.
-    CanType substObjectType = substType.getWithoutSpecifierType();
-    AbstractionPattern origObjectType = origType.getWithoutSpecifierType();
-
-    SILType loweredType = getLoweredType(origObjectType, substObjectType)
-      .getAddressType();
-
-    auto *theInfo = new (*this, key.isDependent())
-      TrivialTypeLowering(loweredType);
-    insert(key, theInfo);
-    return *theInfo;
-  }
-
   // Lower the type.
   CanType loweredSubstType =
     getLoweredRValueType(origType, substType);

lib/SILGen/SILGenApply.cpp

@@ -2417,6 +2417,9 @@ class ArgEmitter {
     // pass the entire tuple indirectly, but if it's not
     // materializable, the convention is actually to break it up
     // into materializable chunks.  See the comment in SILType.cpp.
+    //
+    // FIXME: Once -swift-version 3 code generation goes away, we
+    // can simplify this.
     if (isUnmaterializableTupleType(substArgType)) {
       assert(origParamType.isTypeParameter());
       emitExpanded(std::move(arg), origParamType);
@@ -2441,10 +2444,19 @@ class ArgEmitter {
     SILParameterInfo param = claimNextParameter();
     ArgSpecialDest *specialDest = claimNextSpecialDest();
 
+    // Unwrap InOutType here.
+    assert(isa<InOutType>(substArgType) == param.isIndirectInOut());
+    if (auto inoutType = dyn_cast<InOutType>(substArgType))
+      substArgType = inoutType.getObjectType();
+
     // Make sure we use the same value category for these so that we
     // can hereafter just use simple equality checks to test for
     // abstraction.
     SILType loweredSubstArgType = SGF.getLoweredType(substArgType);
+    if (param.isIndirectInOut()) {
+      loweredSubstArgType =
+        SILType::getPrimitiveAddressType(loweredSubstArgType.getASTType());
+    }
     SILType loweredSubstParamType =
       SILType::getPrimitiveType(param.getType(),
                                 loweredSubstArgType.getCategory());
@@ -2453,7 +2465,6 @@ class ArgEmitter {
     // inout type.
     if (param.isIndirectInOut()) {
       assert(!specialDest);
-      assert(isa<InOutType>(substArgType));
       emitInOut(std::move(arg), loweredSubstArgType, loweredSubstParamType,
                 origParamType, substArgType);
       return;
@@ -2641,10 +2652,9 @@ class ArgEmitter {
         auto address = std::move(arg).asKnownRValue(SGF).getAsSingleValue(
             SGF, arg.getKnownRValueLocation());
         assert(address.isLValue());
-        auto substObjectType = cast<InOutType>(substType).getObjectType();
         return LValue::forAddress(address, None,
-                                  AbstractionPattern(substObjectType),
-                                  substObjectType);
+                                  AbstractionPattern(substType),
+                                  substType);
       } else {
         auto *e = cast<InOutExpr>(std::move(arg).asKnownExpr()->
                                   getSemanticsProvidingExpr());

lib/SILGen/SILGenProlog.cpp

@@ -93,7 +93,10 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
       parameters(parameters) {}
 
   ManagedValue visitType(CanType t) {
-    auto argType = SGF.getLoweredType(t);
+    auto argType = SGF.getLoweredType(t->getInOutObjectType());
+    if (t->is<InOutType>())
+      argType = SILType::getPrimitiveAddressType(argType.getASTType());
+
     // Pop the next parameter info.
     auto parameterInfo = parameters.front();
     parameters = parameters.slice(1);
@@ -225,11 +228,9 @@ struct ArgumentInitHelper {
     if (vd->isInOut()) {
       SILValue address = argrv.getUnmanagedValue();
 
-      CanType objectType = vd->getType()->getCanonicalType();
-
       // As a special case, don't introduce a local variable for
       // Builtin.UnsafeValueBuffer, which is not copyable.
-      if (isa<BuiltinUnsafeValueBufferType>(objectType)) {
+      if (isa<BuiltinUnsafeValueBufferType>(ty->getCanonicalType())) {
         // FIXME: mark a debug location?
         SGF.VarLocs[vd] = SILGenFunction::VarLoc::get(address);
         SGF.B.createDebugValueAddr(loc, address,
@@ -279,6 +280,8 @@ struct ArgumentInitHelper {
 
   void emitAnonymousParam(Type type, SILLocation paramLoc, ParamDecl *PD) {
     // Allow non-materializable tuples to be bound to anonymous parameters.
+    //
+    // FIXME: Remove this once -swift-version 3 code generation goes away.
     if (!type->isMaterializable()) {
       if (auto tupleType = type->getAs<TupleType>()) {
         for (auto eltType : tupleType->getElementTypes()) {
@@ -320,8 +323,10 @@ static void makeArgument(Type ty, ParamDecl *decl,
     for (auto fieldType : tupleTy->getElementTypes())
       makeArgument(fieldType, decl, args, SGF);
   } else {
-    auto arg =
-        SGF.F.begin()->createFunctionArgument(SGF.getLoweredType(ty), decl);
+    auto loweredTy = SGF.getLoweredType(ty);
+    if (decl->isInOut())
+      loweredTy = SILType::getPrimitiveAddressType(loweredTy.getASTType());
+    auto arg = SGF.F.begin()->createFunctionArgument(loweredTy, decl);
     args.push_back(arg);
   }
 }
@@ -333,8 +338,6 @@ void SILGenFunction::bindParametersForForwarding(const ParameterList *params,
     Type type = (param->hasType()
                  ? param->getType()
                  : F.mapTypeIntoContext(param->getInterfaceType()));
-    if (param->isInOut())
-      type = InOutType::get(type); // FIXME remove InOutType
     makeArgument(type->eraseDynamicSelfType(), param, parameters, *this);
   }
 }