SILGen: Remove RValue::rewriteType()

Author: slavapestov

lib/SILGen/RValue.h

@@ -308,42 +308,6 @@ class RValue {
   /// be returned. Otherwise, an object will be returned. So this is a
   /// convenient way to determine if an RValue needs an address.
   SILType getLoweredImplodedTupleType(SILGenFunction &SGF) const &;
-
-  /// Rewrite the type of this r-value.
-  void rewriteType(CanType newType) & {
-#ifndef NDEBUG
-    static const auto areSimilarTypes = [](CanType l, CanType r) {
-      if (l == r) return true;
-
-      // Allow function types to disagree about 'noescape'.
-      if (auto lf = dyn_cast<FunctionType>(l)) {
-        if (auto rf = dyn_cast<FunctionType>(r)) {
-          auto lParams = lf.getParams();
-          auto rParams = rf.getParams();
-          return AnyFunctionType::equalParams(lParams, rParams) &&
-                 lf.getResult() == rf.getResult() &&
-                 lf->getExtInfo().withNoEscape(false) ==
-                     rf->getExtInfo().withNoEscape(false);
-        }
-      }
-      return false;
-    };
-
-    static const auto isSingleElementTuple = [](CanType type, CanType eltType) {
-      if (auto tupleType = dyn_cast<TupleType>(type)) {
-        return tupleType->getNumElements() == 1 &&
-               areSimilarTypes(tupleType.getElementType(0), eltType);
-      }
-      return false;
-    };
-
-    // We only allow a very modest set of changes to a type.
-    assert(areSimilarTypes(newType, type) ||
-           isSingleElementTuple(newType, type) ||
-           isSingleElementTuple(type, newType));
-#endif
-    type = newType;
-  }
 
   /// Emit an equivalent value with independent ownership.
   RValue copy(SILGenFunction &SGF, SILLocation loc) const &;

lib/SILGen/SILGenApply.cpp

@@ -5635,20 +5635,7 @@ RValue SILGenFunction::emitLiteral(LiteralExpr *literal, SGFContext C) {
     }
   }
 
-  // Helper routine to add an argument label if we need one.
-  auto relabelArgument = [&](ConcreteDeclRef callee, RValue &arg) {
-    auto name = callee.getDecl()->getFullName();
-    auto argLabels = name.getArgumentNames();
-    if (argLabels.size() == 1 && !argLabels[0].empty() &&
-        !isa<TupleType>(arg.getType())) {
-      Type newType = TupleType::get({TupleTypeElt(arg.getType(), argLabels[0])},
-                                    getASTContext());
-      arg.rewriteType(newType->getCanonicalType());
-    }
-  };
-
   // Call the builtin initializer.
-  relabelArgument(builtinInit, builtinLiteralArgs);
   RValue builtinLiteral =
     emitApplyAllocatingInitializer(literal, builtinInit,
                                    std::move(builtinLiteralArgs),
@@ -5659,7 +5646,6 @@ RValue SILGenFunction::emitLiteral(LiteralExpr *literal, SGFContext C) {
   if (!init) return builtinLiteral;
 
   // Otherwise, perform the second initialization step.
-  relabelArgument(init, builtinLiteral);
   RValue result = emitApplyAllocatingInitializer(literal, init,
                                                  std::move(builtinLiteral),
                                                  literal->getType(), C);
@@ -6189,14 +6175,9 @@ void SILGenFunction::emitSetAccessor(SILLocation loc, SILDeclRef set,
   values.addArbitrary(std::move(setValue));
 
   if (!subscriptIndices.isNull()) {
-    unsigned paramIndex = 1;
     for (auto &component : std::move(subscriptIndices).getSources()) {
-      auto param = accessType.getParams()[paramIndex++];
-      auto paramType = param.getParameterType();
-
       auto argLoc = component.getKnownRValueLocation();
       RValue &&arg = std::move(component).asKnownRValue(*this);
-      arg.rewriteType(paramType);
       values.add(argLoc, std::move(arg));
     }
   }

lib/SILGen/SILGenExpr.cpp

@@ -3656,13 +3656,11 @@ visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *E, SGFContext C) {
 RValue RValueEmitter::visitArrayExpr(ArrayExpr *E, SGFContext C) {
   auto loc = SILLocation(E);
   ArgumentScope scope(SGF, loc);
-  auto init = E->getInitializer();
-  auto *decl = dyn_cast<AbstractFunctionDecl>(init.getDecl());
-  Type elementType = E->getElementType();
-  ArrayRef<Identifier> argLabels = decl->getFullName().getArgumentNames();
+
+  CanType elementType = E->getElementType()->getCanonicalType();
   CanType arrayTy = ArraySliceType::get(elementType)->getCanonicalType();
   VarargsInfo varargsInfo =
-      emitBeginVarargs(SGF, loc, elementType->getCanonicalType(), arrayTy,
+      emitBeginVarargs(SGF, loc, elementType, arrayTy,
                        E->getNumElements(), {});
 
   for (unsigned index : range(E->getNumElements())) {
@@ -3686,17 +3684,9 @@ RValue RValueEmitter::visitArrayExpr(ArrayExpr *E, SGFContext C) {
 
   arg = scope.popPreservingValue(std::move(arg));
 
-  // Add an argument label for init(arrayLiteral: T...) as the above tuple is of
-  // the form (T...) with no label.
-  assert(argLabels.size() == 1 && !argLabels[0].empty() &&
-         !isa<TupleType>(arg.getType()));
-  Type newType = TupleType::get({TupleTypeElt(arg.getType(), argLabels[0])},
-                                SGF.getASTContext());
-  arg.rewriteType(newType->getCanonicalType());
-
   // Call the builtin initializer.
   return SGF.emitApplyAllocatingInitializer(
-      loc, init, std::move(arg), E->getType(), C);
+      loc, E->getInitializer(), std::move(arg), E->getType(), C);
 }
 
 RValue RValueEmitter::visitDictionaryExpr(DictionaryExpr *E, SGFContext C) {