Bridging: Implement bridges required for ongoing AutoDiff changes

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -39,6 +39,7 @@ public class Decl: CustomStringConvertible, Hashable {
 public class ValueDecl: Decl {
   final public var nameLoc: SourceLoc? { SourceLoc(bridged: bridged.Value_getNameLoc()) }
   final public var userFacingName: StringRef { StringRef(bridged: bridged.Value_getUserFacingName()) }
+  final public var baseIdentifier: swift.Identifier { bridged.Value_getBaseIdentifier() }
   final public var isObjC: Bool { bridged.Value_isObjC() }
 }
 
@@ -56,6 +57,10 @@ public class NominalTypeDecl: GenericTypeDecl {
   final public var valueTypeDestructor: DestructorDecl? {
     bridged.NominalType_getValueTypeDestructor().getAs(DestructorDecl.self)
   }
+
+  public var declaredInterfaceType : AST.`Type` {
+    AST.`Type`(bridged: bridged.NominalType_getDeclaredInterfaceType())
+  }
 }
 
 final public class EnumDecl: NominalTypeDecl {
@@ -118,6 +123,8 @@ final public class MacroDecl: ValueDecl {}
 
 final public class EnumElementDecl: ValueDecl {
   public var hasAssociatedValues: Bool { bridged.EnumElementDecl_hasAssociatedValues() }
+  public var parameterList: BridgedParameterList { bridged.EnumElementDecl_getParameterList() }
+  public var nameStr: StringRef { StringRef(bridged: bridged.EnumElementDecl_getNameStr()) }
 }
 
 final public class ExtensionDecl: Decl {}

SwiftCompilerSources/Sources/AST/GenericSignature.swift

@@ -35,4 +35,18 @@ public struct GenericSignature: CustomStringConvertible, NoReflectionChildren {
   }
 
   public var isEmpty: Bool { bridged.impl == nil }
+
+  public var canonicalSignature: CanGenericSignature { CanGenericSignature(bridged: bridged.getCanonicalSignature()) }
+}
+
+public struct CanGenericSignature {
+  public let bridged: BridgedCanGenericSignature
+
+  public init(bridged: BridgedCanGenericSignature) {
+    self.bridged = bridged
+  }
+
+  public var isEmpty: Bool { bridged.impl == nil }
+
+  public var genericSignature: GenericSignature { GenericSignature(bridged: bridged.getGenericSignature()) }
 }

SwiftCompilerSources/Sources/AST/Type.swift

@@ -66,6 +66,30 @@ public struct Type: TypeProperties, CustomStringConvertible, NoReflectionChildre
   public func subst(with substitutionMap: SubstitutionMap) -> Type {
     return Type(bridged: bridged.subst(substitutionMap.bridged))
   }
+
+  public func mapTypeOutOfContext() -> Type {
+    return Type(bridged: bridged.mapTypeOutOfContext())
+  }
+
+  public func getReducedType(sig: GenericSignature) -> CanonicalType {
+    CanonicalType(bridged: bridged.getReducedType(sig.bridged))
+  }
+
+  public func GenericTypeParam_getName() -> swift.Identifier {
+    return bridged.GenericTypeParam_getName()
+  }
+
+  public func GenericTypeParam_getDepth() -> UInt {
+    return bridged.GenericTypeParam_getDepth()
+  }
+
+  public func GenericTypeParam_getIndex() -> UInt {
+    return bridged.GenericTypeParam_getIndex()
+  }
+
+  public func GenericTypeParam_getParamKind() -> swift.GenericTypeParamKind {
+    return bridged.GenericTypeParam_getParamKind()
+  }
 }
 
 /// A Type that is statically known to be canonical.
@@ -86,6 +110,10 @@ public struct CanonicalType: TypeProperties, CustomStringConvertible, NoReflecti
   public func subst(with substitutionMap: SubstitutionMap) -> CanonicalType {
     return rawType.subst(with: substitutionMap).canonical
   }
+
+  public func SILFunctionType_getSubstGenericSignature() -> CanGenericSignature {
+    CanGenericSignature(bridged: bridged.SILFunctionType_getSubstGenericSignature())
+  }
 }
 
 /// Implements the common members of `AST.Type`, `AST.CanonicalType` and `SIL.Type`.

SwiftCompilerSources/Sources/SIL/ASTExtensions.swift

@@ -36,6 +36,10 @@ extension CanonicalType {
     precondition(isBox)
     return BoxFieldsArray(boxType: self, function: function)
   }
+
+  public func loweredType(in function: Function) -> Type {
+    function.bridged.getLoweredType(bridged).type
+  }
 }
 
 extension Decl {

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -50,6 +50,10 @@ public class Argument : Value, Hashable {
 
   public var sourceLoc: SourceLoc? { findVarDecl()?.nameLoc }
 
+  public func replaceAllUsesWith(newArg: Argument) {
+    bridged.replaceAllUsesWith(newArg.bridged)
+  }
+
   public static func ==(lhs: Argument, rhs: Argument) -> Bool {
     lhs === rhs
   }

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -68,6 +68,11 @@ final public class BasicBlock : CustomStringConvertible, HasShortDescription, Ha
                                           (decl as Decl?).bridged).argument as! FunctionArgument
   }
 
+  public func insertPhiArgument(atPosition: Int, type: Type, ownership: Ownership, _ context: some MutatingContext) -> Argument {
+    context.notifyInstructionsChanged()
+    return bridged.insertPhiArgument(atPosition, type.bridged, ownership._bridged).argument
+  }
+
   public func eraseArgument(at index: Int, _ context: some MutatingContext) {
     context.notifyInstructionsChanged()
     bridged.eraseArgument(index)

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -662,6 +662,13 @@ public struct Builder {
     return notifyNew(tuple.getAs(TupleInst.self))
   }
 
+  public func createTuple(elements: [Value]) -> TupleInst {
+    let tuple = elements.withBridgedValues { valuesRef in
+      return bridged.createTuple(valuesRef)
+    }
+    return notifyNew(tuple.getAs(TupleInst.self))
+  }
+
   public func createTupleExtract(tuple: Value, elementIndex: Int) -> TupleExtractInst {
     return notifyNew(bridged.createTupleExtract(tuple.bridged, elementIndex).getAs(TupleExtractInst.self))
   }

SwiftCompilerSources/Sources/SIL/Context.swift

@@ -55,6 +55,20 @@ extension Context {
     }
   }
 
+  public func getTupleType(elements: [AST.`Type`]) -> AST.`Type` {
+    let bridgedElements = elements.map { $0.bridged }
+    return bridgedElements.withBridgedArrayRef {
+      AST.`Type`(bridged: _bridged.getTupleType($0))
+    }
+  }
+
+  public func getTupleTypeWithLabels(elements: [AST.`Type`], labels: [swift.Identifier]) -> AST.`Type` {
+    assert(elements.count == labels.count)
+    return elements.withBridgedArrayRef{
+      eltArr in labels.withBridgedArrayRef{labelsArr in
+      AST.`Type`(bridged: _bridged.getTupleTypeWithLabels(eltArr, labelsArr))}}
+  }
+
   public var swiftArrayDecl: NominalTypeDecl {
     _bridged.getSwiftArrayDecl().getAs(NominalTypeDecl.self)
   }

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -26,6 +26,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     return Location(bridged: bridged.getLocation())
   }
 
+  public var sourceFile: BridgedNullableSourceFile {
+    return bridged.getSourceFile()
+  }
+
   final public var description: String {
     return String(taking: bridged.getDebugDescription())
   }
@@ -88,6 +92,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     return AST.`Type`(bridged: bridged.mapTypeIntoContext(type.bridged))
   }
 
+  public func mapTypeIntoContext(_ type: Type) -> Type {
+    return Type(bridged: bridged.mapTypeIntoContext(type.bridged))
+  }
+
   /// Returns true if the function is a definition and not only an external declaration.
   ///
   /// This is the case if the function contains a body, i.e. some basic blocks.

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1351,6 +1351,7 @@ final public class PartialApplyInst : SingleValueInstruction, ApplySite {
   public var hasUnknownResultIsolation: Bool { bridged.PartialApplyInst_hasUnknownResultIsolation() }
   public var unappliedArgumentCount: Int { bridged.PartialApply_getCalleeArgIndexOfFirstAppliedArg() }
   public var calleeConvention: ArgumentConvention { type.bridged.getCalleeConvention().convention }
+  public var substitutionMap: SubstitutionMap { SubstitutionMap(bridged: bridged.PartialApplyInst_getSubstitutionMap()) }
 }
 
 final public class ApplyInst : SingleValueInstruction, FullApplySite {
@@ -1929,6 +1930,7 @@ final public class SwitchValueInst : TermInst {
 final public class SwitchEnumInst : TermInst {
 
   public var enumOp: Value { operands[0].value }
+  public var numCases: Int { bridged.SwitchEnumInst_getNumCases() }
 
   public struct CaseIndexArray : RandomAccessCollection {
     fileprivate let switchEnum: SwitchEnumInst
@@ -1953,6 +1955,10 @@ final public class SwitchEnumInst : TermInst {
     cases.first(where: { $0.0 == forCaseIndex })?.1
   }
 
+  public func getSuccessorForDefault() -> BasicBlock? {
+    return self.bridged.SwitchEnumInst_getSuccessorForDefault().block
+  }
+
   // This does not handle the special case where the default covers exactly
   // the "missing" case.
   public func getUniqueCase(forSuccessor: BasicBlock) -> Int? {

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -27,6 +27,7 @@ public struct Type : TypeProperties, CustomStringConvertible, NoReflectionChildr
 
   public var isAddress: Bool { bridged.isAddress() }
   public var isObject: Bool { !isAddress }
+  public var category: ValueCategory { ValueCategory(bridged: bridged.getCategory()) }
 
   public var addressType: Type { bridged.getAddressType().type }
   public var objectType: Type { bridged.getObjectType().type }
@@ -214,6 +215,16 @@ public struct Type : TypeProperties, CustomStringConvertible, NoReflectionChildr
     }
     return false
   }
+
+  public func getEnumCasePayload(caseIdx: Int, function: Function) -> Type {
+    bridged.getEnumCasePayload(caseIdx, function.bridged).type
+  }
+
+  public func mapTypeOutOfContext() -> Type { bridged.mapTypeOutOfContext().type }
+
+  public static func getPrimitiveType(canType: CanonicalType, silValueCategory: ValueCategory) -> Type {
+    BridgedType.getPrimitiveType(canType: canType.bridged, silValueCategory: silValueCategory._bridged).type
+  }
 }
 
 extension Type: Equatable {
@@ -266,6 +277,7 @@ public struct NominalFieldsArray : RandomAccessCollection, FormattedLikeArray {
 }
 
 public struct EnumCase {
+  public let enumElementDecl : EnumElementDecl
   public let payload: Type?
   public let index: Int
 }
@@ -288,7 +300,8 @@ public struct EnumCases : CollectionLikeSequence, IteratorProtocol {
         caseIterator = caseIterator.getNext()
         caseIndex += 1
       }
-      return EnumCase(payload: enumType.bridged.getEnumCasePayload(caseIterator, function.bridged).typeOrNil,
+      return EnumCase(enumElementDecl: enumType.bridged.getEnumElementDecl(caseIterator).getAs(EnumElementDecl.self),
+                      payload: enumType.bridged.getEnumCasePayload(caseIterator, function.bridged).typeOrNil,
                       index: caseIndex)
     }
     return nil
@@ -304,6 +317,10 @@ public struct TupleElementArray : RandomAccessCollection, FormattedLikeArray {
   public subscript(_ index: Int) -> Type {
     type.bridged.getTupleElementType(index).type
   }
+
+  public func label(at index: Int) -> swift.Identifier {
+    type.bridged.getTupleElementLabel(index)
+  }
 }
 
 public struct BoxFieldsArray : RandomAccessCollection, FormattedLikeArray {

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -41,6 +41,27 @@ public protocol Value : AnyObject, CustomStringConvertible {
   var isLexical: Bool { get }
 }
 
+public enum ValueCategory {
+  case address
+  case object
+
+  public init(bridged: BridgedValueCategory) {
+    switch bridged {
+    case .Address: self = .address
+    case .Object:  self = .object
+    default:
+      fatalError("unsupported value category")
+    }
+  }
+
+  public var _bridged: BridgedValueCategory {
+    switch self {
+      case .address: return BridgedValueCategory.Address
+      case .object:  return BridgedValueCategory.Object
+    }
+  }
+}
+
 public enum Ownership {
   /// A Value with `unowned` ownership kind is an independent value that
   /// has a lifetime that is only guaranteed to last until the next program