Bridging: Implement bridges required for ongoing AutoDiff changes

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

This patch introduces these missing bridges. See the list of the changes below.

**AST:**

* Define `.asValueDecl` on each BridgedXXXDecl type that's also a ValueDecl.

* Define `.asNominalTypeDecl` on each BridgedXXXDecl type that's also a NominalTypeDecl.

* Define `.asGenericContext` on each BridgedXXXDecl type that's also a GenericContext.

* `class BridgedSourceFile`:
  - Make nullable
  - `func addTopLevelDecl(_ decl: BridgedDecl)`

* `class BridgedFileUnit`:
  - `func castToSourceFile() -> BridgedNullableSourceFile`

* `class BridgedDecl`:
  - `func getDeclContext() -> BridgedDeclContext`

* `class BridgedParamDecl`:
  - `func cloneWithoutType() -> BridgedParamDecl`
  - `func setInterfaceType(_ type : BridgedASTType)`

* Define `BridgedDecl.setImplicit()` instead of `BridgedParamDecl.setImplicit()`

* `class BridgedGenericContext`:
  - `setGenericSignature(_ genSig: BridgedGenericSignature)`

* Change return type of `BridgedEnumDecl.createParsed(/*...*/)` from `BridgedNominalTypeDecl` to `BridgedEnumDecl`

* `class BridgedValueDecl`:
  - `func setAccess(_ accessLevel: swift.AccessLevel)`

* `class BridgedNominalTypeDecl`:
  - `func addMember(_ member: BridgedDecl)`

* `class BridgedGenericTypeParamDecl`:
  - `func createImplicit(declContext: BridgedDeclContext, name: swift.Identifier, depth: UInt, index: UInt, paramKind: swift.GenericTypeParamKind)`

* `class ValueDecl`:
  - `var baseIdentifier: swift.Identifier`

* `class NominalTypeDecl`:
  - `var declaredInterfaceType: Type`

* `class EnumElementDecl`:
  - `var parameterList: BridgedParameterList`
  - `var nameStr: StringRef`

* `struct GenericSignature`:
  - `var canonicalSignature: CanGenericSignature`

* `struct CanGenericSignature`:
  - `var isEmpty: Bool`
  - `var genericSignature: GenericSignature`

* `struct Type`:
  - `func mapTypeOutOfContext() -> Type`
  - `func getReducedType(sig: GenericSignature) -> CanonicalType`
  - `func GenericTypeParam_getName() -> swift.Identifier`
  - `func GenericTypeParam_getDepth() -> UInt`
  - `func GenericTypeParam_getIndex() -> UInt`
  - `func GenericTypeParam_getParamKind() -> swift.GenericTypeParamKind`

* `struct CanonicalType`:
  - `func SILFunctionType_getSubstGenericSignature() -> CanGenericSignature`
  - `func loweredType(in function: SIL.Function) -> SIL.Type`

**SIL:**

* `class Argument`:
  - `func replaceAllUsesWith(newArg: Argument)`

* `class BasicBlock`:
  - `func insertPhiArgument(atPosition: Int, type: Type, ownership: Ownership, _ context: some MutatingContext) -> Argument`

* `struct Builder`:
  - `func createTuple(elements: [Value]) -> TupleInst`

* `protocol Context`:
  - `func getTupleType(elements: [AST.Type]) -> AST.Type`
  - `func getTupleTypeWithLabels(elements: [AST.Type], labels: [swift.Identifier]) -> AST.Type`

* `class Function`:
  - `var sourceFile: BridgedNullableSourceFile`
  - `func mapTypeIntoContext(_ type: Type) -> Type`

* `class PartialApplyInst`:
  - `var substitutionMap: SubstitutionMap`

* `class SwitchEnumInst`:
  - `var numCases: Int`
  - `public func getSuccessorForDefault() -> BasicBlock?`

* `Type`:
  - `var category: ValueCategory`
  - `func getEnumCasePayload(caseIdx: Int, function: Function) -> Type`
  - `func mapTypeOutOfContext() -> Type`
  - `static func getPrimitiveType(canType: CanonicalType, silValueCategory: ValueCategory) -> Type`

* `struct EnumCase`:
  - `let enumElementDecl: EnumElementDecl`

* `struct TupleElementArray`:
  - `func label(at index: Int) -> swift.Identifier`

* Define `enum ValueCategory` with `address` and `object` elements

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,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? {