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

@@ -56,6 +56,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 +122,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 name: 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/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

@@ -88,6 +88,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/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,12 @@ public struct Type : TypeProperties, CustomStringConvertible, NoReflectionChildr
     }
     return false
   }
+
+  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 +273,7 @@ public struct NominalFieldsArray : RandomAccessCollection, FormattedLikeArray {
 }
 
 public struct EnumCase {
+  public let enumElementDecl : EnumElementDecl
   public let payload: Type?
   public let index: Int
 }
@@ -288,7 +296,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 +313,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