Bridging: Implement bridges required for ongoing AutoDiff changes

In swiftlang#83926, part of the changes resolving swiftlang#68944 is submitted. The
AutoDiff closure specialization optimizer pass relies on several
AST-level bridges not implemented yet.

This patch introduces these missing bridges.

Author: kovdan01

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,14 @@ 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))
+  }
 }
 
 /// A Type that is statically known to be canonical.
@@ -86,6 +94,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,22 @@ 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 createPayloadTupleForBranchTracingEnum(elements: [Value], tupleWithLabels: Type)
+    -> TupleInst
+  {
+    let tuple = elements.withBridgedValues { valuesRef in
+      return bridged.createPayloadTupleForBranchTracingEnum(valuesRef, tupleWithLabels.bridged)
+    }
+    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? {