SILGen: Remove SILGenSILBuilder

This reverts commit 59cc3c1216fbb1719e5357dcef3f8b249528fc74.

Author: slavapestov

lib/SILGen/CMakeLists.txt

@@ -29,7 +29,6 @@ add_swift_host_library(swiftSILGen STATIC
   SILGenPoly.cpp
   SILGenProlog.cpp
   SILGenStmt.cpp
-  SILGenSILBuilder.cpp
   SILGenThunk.cpp
   SILGenType.cpp)
 target_link_libraries(swiftSILGen PRIVATE

lib/SILGen/SILGenApply.cpp

@@ -1781,21 +1781,19 @@ static void emitRawApply(SILGenFunction &SGF,
   }
 
   auto resultType = substFnConv.getSILResultType();
-  auto calleeType = SILType::getPrimitiveObjectType(substFnType);
 
   // If the function is a coroutine, we need to use 'begin_apply'.
   if (substFnType->isCoroutine()) {
     assert(!substFnType->hasErrorResult());
-    auto apply = SGF.B.createBeginApply(loc, fnValue, subs, argValues);
+    auto apply = SGF.B.createBeginApply(loc, fnValue, subs, argValues, false);
     for (auto result : apply->getAllResults())
       rawResults.push_back(result);
     return;
   }
 
   // If we don't have an error result, we can make a simple 'apply'.
   if (!substFnType->hasErrorResult()) {
-    auto result = SGF.B.createApply(loc, fnValue, calleeType,
-                                    resultType, subs, argValues);
+    auto result = SGF.B.createApply(loc, fnValue, subs, argValues, false);
     rawResults.push_back(result);
 
   // Otherwise, we need to create a try_apply.
@@ -1809,7 +1807,7 @@ static void emitRawApply(SILGenFunction &SGF,
       SGF.getTryApplyErrorDest(loc, substFnType->getErrorResult(),
                                options & ApplyOptions::DoesNotThrow);
 
-    SGF.B.createTryApply(loc, fnValue, calleeType, subs, argValues,
+    SGF.B.createTryApply(loc, fnValue, subs, argValues,
                          normalBB, errorBB);
     SGF.B.emitBlock(normalBB);
   }
@@ -4007,19 +4005,10 @@ CallEmission::applyPartiallyAppliedSuperMethod(SGFContext C) {
     S.pop();
   }
   auto calleeConvention = ParameterConvention::Direct_Guaranteed;
-  auto closureTy = SILGenBuilder::getPartialApplyResultType(
-      constantInfo.getSILType(), 1, SGF.B.getModule(), subs, calleeConvention);
 
-  auto &module = SGF.getFunction().getModule();
-
-  auto partialApplyTy = functionTy;
-  if (constantInfo.SILFnType->isPolymorphic() && !subs.empty())
-    partialApplyTy = partialApplyTy.substGenericArgs(module, subs);
-
-  ManagedValue pa = SGF.B.createPartialApply(loc, superMethod, partialApplyTy,
+  ManagedValue pa = SGF.B.createPartialApply(loc, superMethod,
                                              subs, {upcastedSelf},
-                                             closureTy);
-  assert(!closureTy.castTo<SILFunctionType>()->isNoEscape());
+                                             calleeConvention);
   firstLevelResult.value = RValue(SGF, loc, formalApplyType.getResult(), pa);
   return firstLevelResult;
 }
@@ -4544,12 +4533,12 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
   SILType resultType = fnConv.getSILResultType();
 
   if (!silFnType->hasErrorResult()) {
-    return B.createApply(loc, fn, substFnType, resultType, subs, args);
+    return B.createApply(loc, fn, subs, args, false);
   }
 
   SILBasicBlock *errorBB = createBasicBlock();
   SILBasicBlock *normalBB = createBasicBlock();
-  B.createTryApply(loc, fn, substFnType, subs, args, normalBB, errorBB);
+  B.createTryApply(loc, fn, subs, args, normalBB, errorBB);
 
   // Emit the rethrow logic.
   {
@@ -4578,7 +4567,7 @@ SILGenFunction::emitBeginApplyWithRethrow(SILLocation loc, SILValue fn,
   // TODO: adjust this to create try_begin_apply when appropriate.
   assert(!substFnType.castTo<SILFunctionType>()->hasErrorResult());
 
-  auto beginApply = B.createBeginApply(loc, fn, subs, args);
+  auto beginApply = B.createBeginApply(loc, fn, subs, args, false);
 
   auto yieldResults = beginApply->getYieldedValues();
   yields.append(yieldResults.begin(), yieldResults.end());
@@ -5728,26 +5717,20 @@ static ManagedValue emitDynamicPartialApply(SILGenFunction &SGF,
                                          CanAnyFunctionType nativeFormalType) {
   auto calleeConvention = ParameterConvention::Direct_Guaranteed;
 
-  auto partialApplyTy =
-      SILBuilder::getPartialApplyResultType(method->getType(),
-                                            /*argCount*/ 1, SGF.SGM.M,
-                                            /*subs*/ {}, calleeConvention);
-
   // Retain 'self' because the partial apply will take ownership.
   // We can't simply forward 'self' because the partial apply is conditional.
   if (!self->getType().isAddress())
     self = SGF.B.emitCopyValueOperation(loc, self);
 
   SILValue resultValue =
-    SGF.B.createPartialApply(loc, method, method->getType(), {},
-                             self, partialApplyTy);
+    SGF.B.createPartialApply(loc, method, {}, self, calleeConvention);
   ManagedValue result = SGF.emitManagedRValueWithCleanup(resultValue);
 
   // If necessary, thunk to the native ownership conventions and bridged types.
   auto nativeTy =
     SGF.getLoweredLoadableType(nativeFormalType).castTo<SILFunctionType>();
 
-  if (nativeTy != partialApplyTy.getASTType()) {
+  if (nativeTy != resultValue->getType().getASTType()) {
     result = SGF.emitBlockToFunc(loc, result, foreignFormalType,
                                  nativeFormalType, nativeTy);
   }

lib/SILGen/SILGenBridging.cpp

@@ -154,10 +154,9 @@ emitBridgeNativeToObjectiveC(SILGenFunction &SGF,
   }
 
   // Call the witness.
-  SILType resultTy = SGF.getLoweredType(objcType);
   SILValue bridgedValue =
-      SGF.B.createApply(loc, witnessRef, witnessFnTy, resultTy, typeSubMap,
-                        swiftValue.borrow(SGF, loc).getValue());
+      SGF.B.createApply(loc, witnessRef, typeSubMap,
+                        swiftValue.borrow(SGF, loc).getValue(), false);
 
   auto bridgedMV = SGF.emitManagedRValueWithCleanup(bridgedValue);
   bridgedMV = scope.popPreservingValue(bridgedMV);
@@ -252,11 +251,8 @@ static ManagedValue emitBridgeBoolToObjCBool(SILGenFunction &SGF,
   SILValue boolToObjCBoolFn
     = SGF.emitGlobalFunctionRef(loc, SGF.SGM.getBoolToObjCBoolFn());
 
-  SILType resultTy =SGF.getLoweredLoadableType(SGF.SGM.Types.getObjCBoolType());
-
   SILValue result = SGF.B.createApply(loc, boolToObjCBoolFn,
-                                      boolToObjCBoolFn->getType(),
-                                      resultTy, {}, swiftBool.forward(SGF));
+                                      {}, swiftBool.forward(SGF), false);
   return SGF.emitManagedRValueWithCleanup(result);
 }
 
@@ -267,12 +263,8 @@ static ManagedValue emitBridgeBoolToDarwinBoolean(SILGenFunction &SGF,
   SILValue boolToDarwinBooleanFn
     = SGF.emitGlobalFunctionRef(loc, SGF.SGM.getBoolToDarwinBooleanFn());
 
-  SILType resultTy =
-      SGF.getLoweredLoadableType(SGF.SGM.Types.getDarwinBooleanType());
-
   SILValue result = SGF.B.createApply(loc, boolToDarwinBooleanFn,
-                                      boolToDarwinBooleanFn->getType(),
-                                      resultTy, {}, swiftBool.forward(SGF));
+                                      {}, swiftBool.forward(SGF), false);
   return SGF.emitManagedRValueWithCleanup(result);
 }
 
@@ -283,10 +275,8 @@ static ManagedValue emitBridgeForeignBoolToBool(SILGenFunction &SGF,
   // func _convertObjCBoolToBool(ObjCBool) -> Bool
   SILValue bridgingFn = SGF.emitGlobalFunctionRef(loc, bridgingFnRef);
 
-  SILType resultTy = SGF.getLoweredLoadableType(SGF.SGM.Types.getBoolType());
-
-  SILValue result = SGF.B.createApply(loc, bridgingFn, bridgingFn->getType(),
-                                      resultTy, {}, foreignBool.forward(SGF));
+  SILValue result = SGF.B.createApply(loc, bridgingFn, {},
+                                      foreignBool.forward(SGF), false);
   return SGF.emitManagedRValueWithCleanup(result);
 }
 
@@ -960,9 +950,8 @@ SILGenFunction::emitBlockToFunc(SILLocation loc,
   // Create it in the current function.
   auto thunkValue = B.createFunctionRefFor(loc, thunk);
   ManagedValue thunkedFn = B.createPartialApply(
-      loc, thunkValue, SILType::getPrimitiveObjectType(substFnTy),
-      interfaceSubs, block,
-      SILType::getPrimitiveObjectType(loweredFuncTyWithoutNoEscape));
+      loc, thunkValue, interfaceSubs, block,
+      loweredFuncTy->getCalleeConvention());
 
   if (!loweredFuncTy->isNoEscape()) {
     return thunkedFn;
@@ -1143,18 +1132,17 @@ ManagedValue SILGenFunction::emitBridgedToNativeError(SILLocation loc,
   // a standard error for a nil NSError.
   auto bridgeFn = emitGlobalFunctionRef(loc, SGM.getNSErrorToErrorFn());
   auto bridgeFnType = bridgeFn->getType().castTo<SILFunctionType>();
-  SILFunctionConventions bridgeFnConv(bridgeFnType, SGM.M);
   assert(bridgeFnType->getNumResults() == 1);
   assert(bridgeFnType->getResults()[0].getConvention()
          == ResultConvention::Owned);
-  auto nativeErrorType = bridgeFnConv.getSILType(bridgeFnType->getResults()[0]);
 
-  assert(bridgeFnType->getParameters()[0].getConvention() ==
-	 ParameterConvention::Direct_Guaranteed);
+  assert(bridgeFnType->getParameters()[0].getConvention()
+	       == ParameterConvention::Direct_Guaranteed);
+  (void) bridgeFnType;
+
   SILValue arg = bridgedError.getValue();
 
-  SILValue nativeError = B.createApply(loc, bridgeFn, bridgeFn->getType(),
-                                       nativeErrorType, {}, arg);
+  SILValue nativeError = B.createApply(loc, bridgeFn, {}, arg, false);
   return emitManagedRValueWithCleanup(nativeError);
 }
 
@@ -1191,19 +1179,16 @@ ManagedValue SILGenFunction::emitNativeToBridgedError(SILLocation loc,
 
   auto bridgeFn = emitGlobalFunctionRef(loc, SGM.getErrorToNSErrorFn());
   auto bridgeFnType = bridgeFn->getType().castTo<SILFunctionType>();
-  SILFunctionConventions bridgeFnConv(bridgeFnType, SGM.M);
   assert(bridgeFnType->getNumResults() == 1);
   assert(bridgeFnType->getResults()[0].getConvention()
          == ResultConvention::Owned);
-  auto loweredBridgedErrorType =
-    bridgeFnConv.getSILType(bridgeFnType->getResults()[0]);
+  assert(bridgeFnType->getParameters()[0].getConvention()
+         == ParameterConvention::Direct_Guaranteed);
+  (void) bridgeFnType;
 
-  assert(bridgeFnType->getParameters()[0].getConvention() ==
-	 ParameterConvention::Direct_Guaranteed);
   SILValue arg = nativeError.getValue();
 
-  SILValue bridgedError = B.createApply(loc, bridgeFn, bridgeFn->getType(),
-                                        loweredBridgedErrorType, {}, arg);
+  SILValue bridgedError = B.createApply(loc, bridgeFn, {}, arg, false);
   return emitManagedRValueWithCleanup(bridgedError);
 }
 
@@ -1405,7 +1390,6 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   auto nativeInfo = getConstantInfo(native);
   auto subs = F.getForwardingSubstitutionMap();
   auto substTy = nativeInfo.SILFnType->substGenericArgs(SGM.M, subs);
-  SILType substSILTy = SILType::getPrimitiveObjectType(substTy);
   SILFunctionConventions substConv(substTy, SGM.M);
 
   // Use the same generic environment as the native entry point.
@@ -1506,8 +1490,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   assert(foreignError.hasValue() == substTy->hasErrorResult());
   if (!substTy->hasErrorResult()) {
     // Create the apply.
-    result = B.createApply(loc, nativeFn, substSILTy,
-                           swiftResultTy, subs, args);
+    result = B.createApply(loc, nativeFn, subs, args, false);
 
     if (substConv.hasIndirectSILResults()) {
       assert(substTy->getNumResults() == 1);
@@ -1525,8 +1508,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     SILBasicBlock *contBB = createBasicBlock();
     SILBasicBlock *errorBB = createBasicBlock();
     SILBasicBlock *normalBB = createBasicBlock();
-    B.createTryApply(loc, nativeFn, substSILTy, subs, args,
-                     normalBB, errorBB);
+    B.createTryApply(loc, nativeFn, subs, args, normalBB, errorBB);
 
     // Emit the non-error destination.
     {

lib/SILGen/SILGenBuilder.cpp

@@ -33,35 +33,30 @@ SILGenModule &SILGenBuilder::getSILGenModule() const { return SGF.SGM; }
 //===----------------------------------------------------------------------===//
 
 SILGenBuilder::SILGenBuilder(SILGenFunction &SGF)
-    : SILGenSILBuilder(SGF), SGF(SGF) {}
+    : SILBuilder(SGF.F), SGF(SGF) {}
 
 SILGenBuilder::SILGenBuilder(SILGenFunction &SGF, SILBasicBlock *insertBB,
                              SmallVectorImpl<SILInstruction *> *insertedInsts)
-    : SILGenSILBuilder(SGF, insertBB, insertedInsts), SGF(SGF) {}
+    : SILBuilder(insertBB, insertedInsts), SGF(SGF) {}
 
 SILGenBuilder::SILGenBuilder(SILGenFunction &SGF, SILBasicBlock *insertBB,
                              SILBasicBlock::iterator insertInst)
-    : SILGenSILBuilder(SGF, insertBB, insertInst), SGF(SGF) {}
+    : SILBuilder(insertBB, insertInst), SGF(SGF) {}
 
 //===----------------------------------------------------------------------===//
 //                             Managed Value APIs
 //===----------------------------------------------------------------------===//
-//
-// *NOTE* Please use SILGenBuilder SILValue APIs below. Otherwise, we
-// potentially do not get all of the conformances that we need.
-//
 
 ManagedValue SILGenBuilder::createPartialApply(SILLocation loc, SILValue fn,
-                                               SILType substFnTy,
                                                SubstitutionMap subs,
                                                ArrayRef<ManagedValue> args,
-                                               SILType closureTy) {
+                                               ParameterConvention calleeConvention) {
   llvm::SmallVector<SILValue, 8> values;
   transform(args, std::back_inserter(values), [&](ManagedValue mv) -> SILValue {
     return mv.forward(getSILGenFunction());
   });
   SILValue result =
-      createPartialApply(loc, fn, substFnTy, subs, values, closureTy);
+      createPartialApply(loc, fn, subs, values, calleeConvention);
   // Partial apply instructions create a box, so we need to put on a cleanup.
   return getSILGenFunction().emitManagedRValueWithCleanup(result);
 }