Swift Bridging: use C++ instead of C bridging for BridgedBuilder

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -64,80 +64,78 @@ public struct Builder {
       operandType: Type, resultType: Type, arguments: [Value]) -> BuiltinInst {
     return arguments.withBridgedValues { valuesRef in
       return name._withStringRef { nameStr in
-        let bi = SILBuilder_createBuiltinBinaryFunction(
-          bridged, nameStr, operandType.bridged, resultType.bridged, valuesRef)
+        let bi = bridged.createBuiltinBinaryFunction(
+          nameStr, operandType.bridged, resultType.bridged, valuesRef)
         return notifyNew(bi.getAs(BuiltinInst.self))
       }
     }
   }
 
   public func createCondFail(condition: Value, message: String) -> CondFailInst {
     return message._withStringRef { messageStr in
-      let cf = SILBuilder_createCondFail(bridged, condition.bridged, messageStr)
+      let cf = bridged.createCondFail(condition.bridged, messageStr)
       return notifyNew(cf.getAs(CondFailInst.self))
     }
   }
 
   public func createIntegerLiteral(_ value: Int, type: Type) -> IntegerLiteralInst {
-    let literal = SILBuilder_createIntegerLiteral(bridged, type.bridged, value)
+    let literal = bridged.createIntegerLiteral(type.bridged, value)
     return notifyNew(literal.getAs(IntegerLiteralInst.self))
   }
 
   public func createAllocStack(_ type: Type, hasDynamicLifetime: Bool = false,
-                               isLexical: Bool = false,
-                               usesMoveableValueDebugInfo: Bool = false) -> AllocStackInst {
-    let dr = SILBuilder_createAllocStack(bridged, type.bridged, hasDynamicLifetime ? 1 : 0,
-                                         isLexical ? 1 : 0, usesMoveableValueDebugInfo ? 1 : 0)
+                               isLexical: Bool = false, usesMoveableValueDebugInfo: Bool = false) -> AllocStackInst {
+    let dr = bridged.createAllocStack(type.bridged, hasDynamicLifetime, isLexical, usesMoveableValueDebugInfo)
     return notifyNew(dr.getAs(AllocStackInst.self))
   }
 
   @discardableResult
   public func createDeallocStack(_ operand: Value) -> DeallocStackInst {
-    let dr = SILBuilder_createDeallocStack(bridged, operand.bridged)
+    let dr = bridged.createDeallocStack(operand.bridged)
     return notifyNew(dr.getAs(DeallocStackInst.self))
   }
 
   @discardableResult
   public func createDeallocStackRef(_ operand: Value) -> DeallocStackRefInst {
-    let dr = SILBuilder_createDeallocStackRef(bridged, operand.bridged)
+    let dr = bridged.createDeallocStackRef(operand.bridged)
     return notifyNew(dr.getAs(DeallocStackRefInst.self))
   }
 
   public func createUncheckedRefCast(object: Value, type: Type) -> UncheckedRefCastInst {
-    let object = SILBuilder_createUncheckedRefCast(bridged, object.bridged, type.bridged)
+    let object = bridged.createUncheckedRefCast(object.bridged, type.bridged)
     return notifyNew(object.getAs(UncheckedRefCastInst.self))
   }
 
   @discardableResult
   public func createSetDeallocating(operand: Value, isAtomic: Bool) -> SetDeallocatingInst {
-    let setDeallocating = SILBuilder_createSetDeallocating(bridged, operand.bridged, isAtomic)
+    let setDeallocating = bridged.createSetDeallocating(operand.bridged, isAtomic)
     return notifyNew(setDeallocating.getAs(SetDeallocatingInst.self))
   }
 
   public func createFunctionRef(_ function: Function) -> FunctionRefInst {
-    let functionRef = SILBuilder_createFunctionRef(bridged, function.bridged)
+    let functionRef = bridged.createFunctionRef(function.bridged)
     return notifyNew(functionRef.getAs(FunctionRefInst.self))
   }
 
   public func createCopyValue(operand: Value) -> CopyValueInst {
-    return notifyNew(SILBuilder_createCopyValue(bridged, operand.bridged).getAs(CopyValueInst.self))
+    return notifyNew(bridged.createCopyValue(operand.bridged).getAs(CopyValueInst.self))
   }
 
   @discardableResult
   public func createCopyAddr(from fromAddr: Value, to toAddr: Value,
                              takeSource: Bool = false, initializeDest: Bool = false) -> CopyAddrInst {
-    return notifyNew(SILBuilder_createCopyAddr(bridged, fromAddr.bridged, toAddr.bridged,
-                                     takeSource ? 1 : 0, initializeDest ? 1 : 0).getAs(CopyAddrInst.self))
+    return notifyNew(bridged.createCopyAddr(fromAddr.bridged, toAddr.bridged,
+                                            takeSource, initializeDest).getAs(CopyAddrInst.self))
   }
 
   @discardableResult
   public func createDestroyValue(operand: Value) -> DestroyValueInst {
-    return notifyNew(SILBuilder_createDestroyValue(bridged, operand.bridged).getAs(DestroyValueInst.self))
+    return notifyNew(bridged.createDestroyValue(operand.bridged).getAs(DestroyValueInst.self))
   }
 
   @discardableResult
   public func createDebugStep() -> DebugStepInst {
-    return notifyNew(SILBuilder_createDebugStep(bridged).getAs(DebugStepInst.self))
+    return notifyNew(bridged.createDebugStep().getAs(DebugStepInst.self))
   }
 
   @discardableResult
@@ -150,40 +148,40 @@ public struct Builder {
     specializationInfo: ApplyInst.SpecializationInfo = nil
   ) -> ApplyInst {
     let apply = arguments.withBridgedValues { valuesRef in
-      SILBuilder_createApply(bridged, function.bridged, substitutionMap.bridged, valuesRef,
-                             isNonThrowing, isNonAsync, specializationInfo)
+      bridged.createApply(function.bridged, substitutionMap.bridged, valuesRef,
+                          isNonThrowing, isNonAsync, specializationInfo)
     }
     return notifyNew(apply.getAs(ApplyInst.self))
   }
 
   public func createUncheckedEnumData(enum enumVal: Value,
                                       caseIndex: Int,
                                       resultType: Type) -> UncheckedEnumDataInst {
-    let ued = SILBuilder_createUncheckedEnumData(bridged, enumVal.bridged, caseIndex, resultType.bridged)
+    let ued = bridged.createUncheckedEnumData(enumVal.bridged, caseIndex, resultType.bridged)
     return notifyNew(ued.getAs(UncheckedEnumDataInst.self))
   }
   @discardableResult
   public func createSwitchEnum(enum enumVal: Value,
                                cases: [(Int, BasicBlock)],
                                defaultBlock: BasicBlock? = nil) -> SwitchEnumInst {
     let se = cases.withUnsafeBufferPointer { caseBuffer in
-      SILBuilder_createSwitchEnumInst(
-        bridged, enumVal.bridged, defaultBlock.bridged, caseBuffer.baseAddress, caseBuffer.count)
+      bridged.createSwitchEnumInst(enumVal.bridged, defaultBlock.bridged,
+                                   caseBuffer.baseAddress, caseBuffer.count)
     }
     return notifyNew(se.getAs(SwitchEnumInst.self))
   }
 
   @discardableResult
   public func createBranch(to destBlock: BasicBlock, arguments: [Value] = []) -> BranchInst {
     return arguments.withBridgedValues { valuesRef in
-      let bi = SILBuilder_createBranch(bridged, destBlock.bridged, valuesRef)
+      let bi = bridged.createBranch(destBlock.bridged, valuesRef)
       return notifyNew(bi.getAs(BranchInst.self))
     }
   }
 
   @discardableResult
   public func createUnreachable() -> UnreachableInst {
-    let ui = SILBuilder_createUnreachable(bridged)
+    let ui = bridged.createUnreachable()
     return notifyNew(ui.getAs(UnreachableInst.self))
   }
 }