Address review comments

Author: kovdan01

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -29,6 +29,10 @@ public class Decl: CustomStringConvertible, Hashable {
   // True if this declaration is imported from C/C++/ObjC.
   public var hasClangNode: Bool { bridged.hasClangNode() }
 
+  public var declContext: DeclContext { bridgedDecl.declContext }
+
+  var bridgedDecl: BridgedDecl { BridgedDecl(raw: bridged.obj) }
+
   public static func ==(lhs: Decl, rhs: Decl) -> Bool { lhs === rhs }
 
   public func hash(into hasher: inout Hasher) {
@@ -39,7 +43,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 baseIdentifier: Identifier { bridged.Value_getBaseIdentifier() }
   final public var isObjC: Bool { bridged.Value_isObjC() }
 }
 
@@ -58,8 +62,8 @@ public class NominalTypeDecl: GenericTypeDecl {
     bridged.NominalType_getValueTypeDestructor().getAs(DestructorDecl.self)
   }
 
-  public var declaredInterfaceType : AST.`Type` {
-    AST.`Type`(bridged: bridged.NominalType_getDeclaredInterfaceType())
+  public var declaredInterfaceType: Type {
+    Type(bridged: bridged.NominalType_getDeclaredInterfaceType())
   }
 }
 
@@ -123,8 +127,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()) }
+  public var parameterList: ParameterList { bridged.EnumElementDecl_getParameterList() }
+  public var name: StringRef { StringRef(bridged: bridged.EnumElementDecl_getNameStr()) }
 }
 
 final public class ExtensionDecl: Decl {}
@@ -172,3 +176,150 @@ extension Optional where Wrapped == Decl {
     OptionalBridgedDeclObj(self?.bridged.obj)
   }
 }
+
+public typealias Identifier = swift.Identifier
+
+public typealias GenericTypeParamKind = swift.GenericTypeParamKind
+
+public typealias ASTContext = BridgedASTContext
+
+public typealias DeclContext = BridgedDeclContext
+
+public typealias Expr = BridgedExpr
+
+public typealias ParameterList = BridgedParameterList
+
+public typealias SourceFile = BridgedSourceFile
+
+public typealias FileUnit = BridgedFileUnit
+
+public typealias GenericParamList = BridgedGenericParamList
+
+public typealias TrailingWhereClause = BridgedTrailingWhereClause
+
+public typealias BridgedParamDecl = ASTBridging.BridgedParamDecl
+
+public typealias BridgedGenericTypeParamDecl = ASTBridging.BridgedGenericTypeParamDecl
+
+public typealias BridgedEnumDecl = ASTBridging.BridgedEnumDecl
+
+public typealias BridgedEnumElementDecl = ASTBridging.BridgedEnumElementDecl
+
+extension ParameterList {
+  public subscript(_ index: Int) -> BridgedParamDecl {
+    return get(index)
+  }
+
+  public static func createParsed(
+    _ astContext: ASTContext, leftParenLoc: SourceLoc?, parameters: [BridgedParamDecl],
+    rightParenLoc: SourceLoc?
+  ) -> ParameterList {
+    parameters.withBridgedArrayRef {
+      ParameterList.createParsed(
+        astContext, leftParenLoc: leftParenLoc.bridgedLocation, parameters: $0,
+        rightParenLoc: rightParenLoc.bridgedLocation)
+    }
+  }
+}
+
+extension GenericParamList {
+  public static func createParsed(
+    _ astContext: ASTContext, leftAngleLoc: SourceLoc?, parameters: [BridgedGenericTypeParamDecl],
+    genericWhereClause: TrailingWhereClause?,
+    rightAngleLoc: SourceLoc?
+  ) -> GenericParamList {
+    return parameters.withBridgedArrayRef {
+      GenericParamList.createParsed(
+        astContext, leftAngleLoc: leftAngleLoc.bridgedLocation, parameters: $0,
+        genericWhereClause: genericWhereClause.bridged, rightAngleLoc: rightAngleLoc.bridgedLocation
+      )
+    }
+  }
+}
+
+extension BridgedDecl {
+  public var declObj: BridgedDeclObj {
+    BridgedDeclObj(SwiftObject(raw.bindMemory(to: BridgedSwiftObject.self, capacity: 1)))
+  }
+  public var decl: Decl { declObj.decl }
+}
+
+extension BridgedEnumDecl {
+  public static func createParsed(
+    _ astContext: ASTContext, declContext: DeclContext, enumKeywordLoc: SourceLoc?, name: String,
+    nameLoc: SourceLoc?, genericParamList: GenericParamList?, inheritedTypes: [Type],
+    genericWhereClause: TrailingWhereClause?, braceRange: SourceRange
+  ) -> BridgedEnumDecl {
+    return name.withCString { strPtr in
+      inheritedTypes.withBridgedArrayRef { types in
+        BridgedEnumDecl.createParsed(
+          astContext, declContext: declContext,
+          enumKeywordLoc: enumKeywordLoc.bridgedLocation,
+          name: astContext.getIdentifier(BridgedStringRef(data: strPtr, count: name.count)),
+          nameLoc: nameLoc.bridgedLocation,
+          genericParamList: genericParamList.bridged,
+          inheritedTypes: types,
+          genericWhereClause: genericWhereClause.bridged,
+          braceRange: braceRange.bridged)
+      }
+    }
+  }
+}
+
+extension BridgedEnumElementDecl {
+  public static func createParsed(
+    _ astContext: ASTContext, declContext: DeclContext,
+    name: Identifier, nameLoc: SourceLoc?,
+    parameterList: ParameterList?,
+    equalsLoc: SourceLoc?, rawValue: Expr?
+  ) -> BridgedEnumElementDecl {
+    BridgedEnumElementDecl.createParsed(
+      astContext, declContext: declContext,
+      name: name, nameLoc: nameLoc.bridgedLocation,
+      parameterList: parameterList.bridged,
+      equalsLoc: equalsLoc.bridgedLocation, rawValue: rawValue.bridged)
+  }
+}
+
+extension SourceFile {
+  public init?(bridged: BridgedNullableSourceFile) {
+    guard let raw = bridged.raw else {
+      return nil
+    }
+    self.init(raw: raw)
+  }
+}
+
+extension FileUnit {
+  public var asSourceFile: SourceFile? { SourceFile(bridged: self.castToSourceFile()) }
+}
+
+extension BridgedParamDecl {
+  public func setInterfaceType(type: Type) {
+    self.setInterfaceType(type.bridged)
+  }
+}
+
+extension ParameterList? {
+  public var bridged: BridgedNullableParameterList {
+    BridgedNullableParameterList(raw: self?.raw)
+  }
+}
+
+extension GenericParamList? {
+  public var bridged: BridgedNullableGenericParamList {
+    BridgedNullableGenericParamList(raw: self?.raw)
+  }
+}
+
+extension Expr? {
+  public var bridged: BridgedNullableExpr {
+    BridgedNullableExpr(raw: self?.raw)
+  }
+}
+
+extension TrailingWhereClause? {
+  public var bridged: BridgedNullableTrailingWhereClause {
+    BridgedNullableTrailingWhereClause(raw: self?.raw)
+  }
+}

SwiftCompilerSources/Sources/AST/GenericSignature.swift

@@ -36,10 +36,12 @@ public struct GenericSignature: CustomStringConvertible, NoReflectionChildren {
 
   public var isEmpty: Bool { bridged.impl == nil }
 
-  public var canonicalSignature: CanGenericSignature { CanGenericSignature(bridged: bridged.getCanonicalSignature()) }
+  public var canonicalSignature: CanonicalGenericSignature {
+    CanonicalGenericSignature(bridged: bridged.getCanonicalSignature())
+  }
 }
 
-public struct CanGenericSignature {
+public struct CanonicalGenericSignature {
   public let bridged: BridgedCanGenericSignature
 
   public init(bridged: BridgedCanGenericSignature) {
@@ -48,5 +50,7 @@ public struct CanGenericSignature {
 
   public var isEmpty: Bool { bridged.impl == nil }
 
-  public var genericSignature: GenericSignature { GenericSignature(bridged: bridged.getGenericSignature()) }
+  public var genericSignature: GenericSignature {
+    GenericSignature(bridged: bridged.getGenericSignature())
+  }
 }

SwiftCompilerSources/Sources/AST/Type.swift

@@ -71,24 +71,26 @@ public struct Type: TypeProperties, CustomStringConvertible, NoReflectionChildre
     return Type(bridged: bridged.mapTypeOutOfContext())
   }
 
-  public func getReducedType(sig: GenericSignature) -> CanonicalType {
-    CanonicalType(bridged: bridged.getReducedType(sig.bridged))
+  /// Returns a stronger canonicalization which folds away equivalent
+  /// associated types, or type parameters that have been made concrete.
+  public func getReducedType(of signature: GenericSignature) -> CanonicalType {
+    CanonicalType(bridged: bridged.getReducedType(signature.bridged))
   }
 
-  public func GenericTypeParam_getName() -> swift.Identifier {
-    return bridged.GenericTypeParam_getName()
+  public var nameOfGenericTypeParameter: Identifier {
+    bridged.GenericTypeParam_getName()
   }
 
-  public func GenericTypeParam_getDepth() -> UInt {
-    return bridged.GenericTypeParam_getDepth()
+  public var depthOfGenericTypeParameter: Int {
+    bridged.GenericTypeParam_getDepth()
   }
 
-  public func GenericTypeParam_getIndex() -> UInt {
-    return bridged.GenericTypeParam_getIndex()
+  public var indexOfGenericTypeParameter: Int {
+    bridged.GenericTypeParam_getIndex()
   }
 
-  public func GenericTypeParam_getParamKind() -> swift.GenericTypeParamKind {
-    return bridged.GenericTypeParam_getParamKind()
+  public var kindOfGenericTypeParameter: GenericTypeParameterKind {
+    bridged.GenericTypeParam_getParamKind()
   }
 }
 
@@ -110,10 +112,6 @@ 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`.
@@ -270,6 +268,12 @@ extension TypeProperties {
   public func checkConformance(to protocol: ProtocolDecl) -> Conformance {
     return Conformance(bridged: rawType.bridged.checkConformance(`protocol`.bridged))
   }
+
+  /// The generic signature that the component types are specified in terms of, if any.
+  public var substitutedGenericSignatureOfFunctionType: CanonicalGenericSignature {
+    CanonicalGenericSignature(
+      bridged: rawType.canonical.bridged.SILFunctionType_getSubstGenericSignature())
+  }
 }
 
 public struct TypeArray : RandomAccessCollection, CustomReflectable {
@@ -327,3 +331,5 @@ extension CanonicalType: Equatable {
     lhs.rawType == rhs.rawType
   }
 }
+
+public typealias GenericTypeParameterKind = swift.GenericTypeParamKind

SwiftCompilerSources/Sources/Basic/SourceLoc.swift

@@ -35,6 +35,14 @@ extension Optional<SourceLoc> {
   }
 }
 
+public struct SourceRange {
+  public let bridged: swift.SourceRange
+
+  public init(start: SourceLoc?) {
+    self.bridged = swift.SourceRange(start: start.bridgedLocation)
+  }
+}
+
 public struct CharSourceRange {
   public let start: SourceLoc
   public let byteLength: UInt32

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -50,10 +50,6 @@ 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,7 +68,9 @@ 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 {
+  public func insertPhiArgument(
+    atPosition: Int, type: Type, ownership: Ownership, _ context: some MutatingContext
+  ) -> Argument {
     context.notifyInstructionsChanged()
     return bridged.insertPhiArgument(atPosition, type.bridged, ownership._bridged).argument
   }

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -662,13 +662,6 @@ 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

@@ -49,10 +49,7 @@ extension Context {
   public func getBuiltinIntegerType(bitWidth: Int) -> Type { _bridged.getBuiltinIntegerType(bitWidth).type }
 
   public func getTupleType(elements: [Type]) -> AST.`Type` {
-    let bridgedElements = elements.map { $0.bridged }
-    return bridgedElements.withBridgedArrayRef {
-      AST.`Type`(bridged: _bridged.getTupleType($0))
-    }
+    return getTupleType(elements: elements.map{ $0.rawType })
   }
 
   public func getTupleType(elements: [AST.`Type`]) -> AST.`Type` {
@@ -62,11 +59,10 @@ extension Context {
     }
   }
 
-  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 func getTupleType(elements: [(label: Identifier, type: AST.`Type`)]) -> AST.`Type` {
+    return elements.map{$0.type}.withBridgedArrayRef{
+      types in elements.map{$0.label}.withBridgedArrayRef{labels in
+      AST.`Type`(bridged: _bridged.getTupleTypeWithLabels(types, labels))}}
   }
 
   public var swiftArrayDecl: NominalTypeDecl {

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -26,9 +26,7 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     return Location(bridged: bridged.getLocation())
   }
 
-  public var sourceFile: BridgedNullableSourceFile {
-    return bridged.getSourceFile()
-  }
+  public var sourceFile: SourceFile? { SourceFile(bridged: bridged.getSourceFile()) }
 
   final public var description: String {
     return String(taking: bridged.getDebugDescription())

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1351,7 +1351,6 @@ 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 {
@@ -1930,7 +1929,6 @@ 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
@@ -1949,6 +1947,8 @@ final public class SwitchEnumInst : TermInst {
     zip(caseIndices, successors)
   }
 
+  public var numCases: Int { caseIndices.count }
+
   // This does not handle the special case where the default covers exactly
   // the "missing" case.
   public func getUniqueSuccessor(forCaseIndex: Int) -> BasicBlock? {