Swift SIL: add some APIs

* `AssignInst`
* `Function.isDestructor`
* `MarkUninitializedInst.kind`
* `Type.isMoveOnly`
* `RefElementAddrInst.isImmutable` and `RefElementAddrInst.set(isImmutable:)`
* `BeginBorrowInst.endBorrows`
* `Context.hadError` and `Context.silStage`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -27,6 +27,17 @@ extension Context {
     let bridgeCA = _bridged.getCalleeAnalysis()
     return CalleeAnalysis(bridged: bridgeCA)
   }
+
+  var hadError: Bool { _bridged.hadError() }
+
+  var silStage: SILStage {
+    switch _bridged.getSILStage() {
+      case .Raw:       return .raw
+      case .Canonical: return .canonical
+      case .Lowered:   return .lowered
+      default:         fatalError("unhandled SILStage case")
+    }
+  }
 }
 
 /// A context which allows mutation of a function's SIL.
@@ -462,6 +473,14 @@ extension AllocRefInst {
   }
 }
 
+extension RefElementAddrInst {
+  func set(isImmutable: Bool, _ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.RefElementAddrInst_setImmutable(isImmutable)
+    context.notifyInstructionChanged(self)
+  }
+}
+
 extension GlobalValueInst {
   func setIsBare(_ context: some MutatingContext) {
     context.notifyInstructionsChanged()

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -137,6 +137,8 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   /// It's called from a `[global_init]` function via a `builtin "once"`.
   public var isGlobalInitOnceFunction: Bool { bridged.isGlobalInitOnceFunction() }
 
+  public var isDestructor: Bool { bridged.isDestructor() }
+
   public var isGenericFunction: Bool { bridged.isGenericFunction() }
 
   /// Kinds of effect attributes which can be defined for a Swift function.

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -259,6 +259,17 @@ final public class StoreInst : Instruction, StoringInstruction {
 final public class StoreWeakInst : Instruction, StoringInstruction { }
 final public class StoreUnownedInst : Instruction, StoringInstruction { }
 
+final public class AssignInst : Instruction, StoringInstruction {
+  // must match with enum class swift::AssignOwnershipQualifier
+  public enum AssignOwnership: Int {
+    case unknown = 0, reassign = 1, reinitialize = 2, initialize = 3
+  }
+
+  public var assignOwnership: AssignOwnership {
+    AssignOwnership(rawValue: bridged.AssignInst_getAssignOwnership())!
+  }
+}
+
 final public class CopyAddrInst : Instruction {
   public var sourceOperand: Operand { return operands[0] }
   public var destinationOperand: Operand { return operands[1] }
@@ -282,6 +293,42 @@ final public class EndAccessInst : Instruction, UnaryInstruction {
 final public class EndBorrowInst : Instruction, UnaryInstruction {}
 
 final public class MarkUninitializedInst : SingleValueInstruction, UnaryInstruction {
+
+  /// This enum captures what the mark_uninitialized instruction is designating.
+  ///
+  // Warning: this enum must be in sync with MarkUninitializedInst::Kind
+  public enum Kind: Int {
+    /// The start of a normal variable live range.
+    case variable = 0
+
+    /// "self" in a struct, enum, or root class.
+    case rootSelf = 1
+
+    /// The same as "RootSelf", but in a case where it's not really safe to treat 'self' as root
+    /// because the original module might add more stored properties.
+    ///
+    /// This is only used for Swift 4 compatibility. In Swift 5, cross-module initializers are always delegatingSelf.
+    case crossModuleRootSelf = 2
+
+    /// "self" in a derived (non-root) class.
+    case derivedSelf = 3
+
+    /// "self" in a derived (non-root) class whose stored properties have already been initialized.
+    case derivedSelfOnly = 4
+
+    /// "self" on a struct, enum, or class in a delegating constructor (one that calls self.init).
+    case delegatingSelf = 5
+
+    /// "self" in a delegating class initializer where memory has already been allocated.
+    case delegatingSelfAllocated = 6
+
+    /// An indirectly returned result which has to be checked for initialization.
+    case indirectResult = 7
+  }
+
+  public var kind: Kind { Kind(rawValue: bridged.MarkUninitializedInst_getKind())! }
+
+  public var canForwardGuaranteedValues: Bool { false }
 }
 
 final public class CondFailInst : Instruction, UnaryInstruction {
@@ -396,9 +443,13 @@ final public class DeallocExistentialBoxInst : Instruction, UnaryInstruction, De
 final public class UnimplementedSingleValueInst : SingleValueInstruction {
 }
 
-final public class LoadInst : SingleValueInstruction, UnaryInstruction {
+public protocol LoadInstruction: SingleValueInstruction, UnaryInstruction {}
+
+extension LoadInstruction {
   public var address: Value { operand.value }
+}
 
+final public class LoadInst : SingleValueInstruction, LoadInstruction {
   // must match with enum class LoadOwnershipQualifier
   public enum LoadOwnership: Int {
     case unqualified = 0, take = 1, copy = 2, trivial = 3
@@ -408,9 +459,9 @@ final public class LoadInst : SingleValueInstruction, UnaryInstruction {
   }
 }
 
-final public class LoadWeakInst : SingleValueInstruction, UnaryInstruction {}
-final public class LoadUnownedInst : SingleValueInstruction, UnaryInstruction {}
-final public class LoadBorrowInst : SingleValueInstruction, UnaryInstruction {}
+final public class LoadWeakInst : SingleValueInstruction, LoadInstruction {}
+final public class LoadUnownedInst : SingleValueInstruction, LoadInstruction {}
+final public class LoadBorrowInst : SingleValueInstruction, LoadInstruction {}
 
 final public class BuiltinInst : SingleValueInstruction {
   public typealias ID = swift.BuiltinValueKind
@@ -643,6 +694,8 @@ final public class RefElementAddrInst : SingleValueInstruction, UnaryInstruction
   public var fieldIndex: Int { bridged.RefElementAddrInst_fieldIndex() }
 
   public var fieldIsLet: Bool { bridged.RefElementAddrInst_fieldIsLet() }
+
+  public var isImmutable: Bool { bridged.RefElementAddrInst_isImmutable() }
 }
 
 final public class RefTailAddrInst : SingleValueInstruction, UnaryInstruction {
@@ -742,6 +795,13 @@ extension BeginAccessInst : ScopedInstruction {
 
 final public class BeginBorrowInst : SingleValueInstruction, UnaryInstruction {
   public var borrowedValue: Value { operand.value }
+
+  public typealias EndBorrowSequence = LazyMapSequence<LazyFilterSequence<LazyMapSequence<UseList, EndBorrowInst?>>,
+                                                       EndBorrowInst>
+
+  public var endBorrows: EndBorrowSequence {
+    uses.lazy.compactMap({ $0.instruction as? EndBorrowInst })
+  }
 }
 
 final public class ProjectBoxInst : SingleValueInstruction, UnaryInstruction {

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -41,6 +41,7 @@ public func registerSILClasses() {
   register(StoreInst.self)
   register(StoreWeakInst.self)
   register(StoreUnownedInst.self)
+  register(AssignInst.self)
   register(CopyAddrInst.self)
   register(EndAccessInst.self)
   register(EndBorrowInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -60,6 +60,8 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
 
   public var canBeClass: swift.TypeTraitResult { bridged.canBeClass() }
 
+  public var isMoveOnly: Bool { bridged.isMoveOnly() }
+
   /// Can only be used if the type is in fact a nominal type (`isNominal` is true).
   public var nominal: NominalTypeDecl {
     NominalTypeDecl(_bridged: BridgedNominalTypeDecl(decl: bridged.getNominalOrBoundGenericNominal()))

SwiftCompilerSources/Sources/SIL/Utils.swift

@@ -17,6 +17,39 @@ import SILBridging
 // Otherwise The Optimizer would fall back to Swift's assert implementation.
 @_exported import Basic
 
+//===----------------------------------------------------------------------===//
+//                                 SIL Stage
+//===----------------------------------------------------------------------===//
+
+public enum SILStage: Int {
+  /// "Raw" SIL, emitted by SILGen, but not yet run through guaranteed
+  /// optimization and diagnostic passes.
+  ///
+  /// Raw SIL does not have fully-constructed SSA and may contain undiagnosed
+  /// dataflow errors.
+  case raw
+
+  /// Canonical SIL, which has been run through at least the guaranteed
+  /// optimization and diagnostic passes.
+  ///
+  /// Canonical SIL has stricter invariants than raw SIL. It must not contain
+  /// dataflow errors, and some instructions must be canonicalized to simpler
+  /// forms.
+  case canonical
+
+  /// Lowered SIL, which has been prepared for IRGen and will no longer
+  /// be passed to canonical SIL transform passes.
+  ///
+  /// In lowered SIL, the SILType of all SILValues is its SIL storage
+  /// type. Explicit storage is required for all address-only and resilient
+  /// types.
+  ///
+  /// Generating the initial Raw SIL is typically referred to as lowering (from
+  /// the AST). To disambiguate, refer to the process of generating the lowered
+  /// stage of SIL as "address lowering".
+  case lowered
+}
+
 //===----------------------------------------------------------------------===//
 //                            Sequence Utilities
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILBridging.h

@@ -260,6 +260,13 @@ struct BridgedFunction {
     return getFunction()->isGlobalInitOnceFunction();
   }
 
+  bool isDestructor() const {
+    if (auto *declCtxt = getFunction()->getDeclContext()) {
+      return llvm::isa<swift::DestructorDecl>(declCtxt);
+    }
+    return false;
+  }
+
   bool isGenericFunction() const {
     return !getFunction()->getGenericSignature().isNull();
   }
@@ -655,6 +662,14 @@ struct BridgedInstruction {
     return getAs<swift::RefElementAddrInst>()->getField()->isLet();
   }
 
+  bool RefElementAddrInst_isImmutable() const {
+    return getAs<swift::RefElementAddrInst>()->isImmutable();
+  }
+
+  void RefElementAddrInst_setImmutable(bool isImmutable) const {
+    getAs<swift::RefElementAddrInst>()->setImmutable(isImmutable);
+  }
+
   SwiftInt PartialApplyInst_numArguments() const {
     return getAs<swift::PartialApplyInst>()->getNumArguments();
   }
@@ -739,6 +754,10 @@ struct BridgedInstruction {
     return (SwiftInt)getAs<swift::StoreInst>()->getOwnershipQualifier();
   }
 
+  SwiftInt AssignInst_getAssignOwnership() const {
+    return (SwiftInt)getAs<swift::AssignInst>()->getOwnershipQualifier();
+  }
+
   swift::SILAccessKind BeginAccessInst_getAccessKind() const {
     return getAs<swift::BeginAccessInst>()->getAccessKind();
   }
@@ -755,6 +774,10 @@ struct BridgedInstruction {
     return getAs<swift::CopyAddrInst>()->isInitializationOfDest();
   }
 
+  SwiftInt MarkUninitializedInst_getKind() const {
+    return (SwiftInt)getAs<swift::MarkUninitializedInst>()->getMarkUninitializedKind();
+  }
+
   void RefCountingInst_setIsAtomic(bool isAtomic) const {
     getAs<swift::RefCountingInst>()->setAtomicity(
         isAtomic ? swift::RefCountingInst::Atomicity::Atomic

include/swift/SIL/SILInstruction.h

@@ -4931,6 +4931,8 @@ class MarkUninitializedInst
 
 public:
   /// This enum captures what the mark_uninitialized instruction is designating.
+  ///
+  /// Warning: this enum must be in sync with the swift `MarkUninitializedInst.Kind`
   enum Kind {
     /// Var designates the start of a normal variable live range.
     Var,

include/swift/SILOptimizer/OptimizerBridging.h

@@ -190,6 +190,14 @@ struct BridgedPassContext {
     return {invocation->getPassManager()->getAnalysis<swift::BasicCalleeAnalysis>()};
   }
 
+  bool hadError() const {
+    return invocation->getPassManager()->getModule()->getASTContext().hadError();
+  }
+
+  swift::SILStage getSILStage() const {
+    return invocation->getPassManager()->getModule()->getStage();
+  }
+
   SWIFT_IMPORT_UNSAFE
   BridgedDeadEndBlocksAnalysis getDeadEndBlocksAnalysis() const {
     auto *dba = invocation->getPassManager()->getAnalysis<swift::DeadEndBlocksAnalysis>();