SwiftCompilerSources: better APIs for handling resilient nominal types

* add `NominalTypeDecl.isResilient`

* make the return type of `Type.getNominalFields` optional and return nil in case the nominal type is resilient.
This forces users of this API to think about what to do in case the nominal type is resilient.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -184,7 +184,10 @@ private func getSequenceOfElementStores(firstStore: StoreInst) -> ([StoreInst],
   if structAddr.type.isMoveOnly {
     return nil
   }
-  let numElements = structAddr.type.getNominalFields(in: firstStore.parentFunction).count
+  guard let fields = structAddr.type.getNominalFields(in: firstStore.parentFunction) else {
+    return nil
+  }
+  let numElements = fields.count
   var elementStores = Array<StoreInst?>(repeating: nil, count: numElements)
   var numStoresFound = 0
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -410,7 +410,7 @@ private extension AllocRefInstBase {
 
   var numClassFields: Int {
     assert(type.isClass)
-    return type.getNominalFields(in: parentFunction).count
+    return type.getNominalFields(in: parentFunction)!.count
   }
 
   var numStoresPerTailElement: Int {
@@ -475,7 +475,7 @@ private func replace(findStringCall: ApplyInst,
                      with cachedFindStringFunc: Function,
                      _ context: FunctionPassContext) {
   let cacheType = cachedFindStringFunc.argumentTypes[2].objectType
-  let wordTy = cacheType.getNominalFields(in: findStringCall.parentFunction)[0]
+  let wordTy = cacheType.getNominalFields(in: findStringCall.parentFunction)![0]
 
   let name = context.mangleOutlinedVariable(from: findStringCall.parentFunction)
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -167,7 +167,7 @@ private extension Type {
       return true
     }
     if isStruct {
-      return getNominalFields(in: function).containsSingleReference(in: function)
+      return getNominalFields(in: function)?.containsSingleReference(in: function) ?? false
     } else if isTuple {
       return tupleElements.containsSingleReference(in: function)
     } else {

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginBorrow.swift

@@ -192,7 +192,7 @@ private extension ForwardingInstruction {
         return false
       }
       let structFields = si.struct.type.getNominalFields(in: parentFunction)
-      return structFields.hasSingleNonTrivialElement(at: si.fieldIndex, in: parentFunction)
+      return structFields?.hasSingleNonTrivialElement(at: si.fieldIndex, in: parentFunction) ?? false
     case let ti as TupleExtractInst:
       return ti.tuple.type.tupleElements.hasSingleNonTrivialElement(at: ti.fieldIndex, in: parentFunction)
     default:

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -135,7 +135,10 @@ extension LoadInst : OnoneSimplifyable, SILCombineSimplifyable {
       case let sea as StructElementAddrInst:
         let structType = sea.struct.type
         if structType.nominal.name == "_SwiftArrayBodyStorage" {
-          switch structType.getNominalFields(in: parentFunction).getNameOfField(withIndex: sea.fieldIndex) {
+          guard let fields = structType.getNominalFields(in: parentFunction) else {
+            return false
+          }
+          switch fields.getNameOfField(withIndex: sea.fieldIndex) {
           case "count":
             break
           case "_capacityAndFlags":
@@ -153,7 +156,10 @@ extension LoadInst : OnoneSimplifyable, SILCombineSimplifyable {
         case "__RawDictionaryStorage",
               "__RawSetStorage":
           // For Dictionary and Set we support "count" and "capacity".
-          switch classType.getNominalFields(in: parentFunction).getNameOfField(withIndex: rea.fieldIndex) {
+          guard let fields = classType.getNominalFields(in: parentFunction) else {
+            return false
+          }
+          switch fields.getNameOfField(withIndex: rea.fieldIndex) {
           case "_count", "_capacity":
             break
           default:

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -239,7 +239,10 @@ extension StoreInst {
           builder.createStore(source: fieldValue, destination: destFieldAddr, ownership: splitOwnership(for: fieldValue))
         }
       } else {
-        for idx in 0..<type.getNominalFields(in: parentFunction).count {
+        guard let fields = type.getNominalFields(in: parentFunction) else {
+          return
+        }
+        for idx in 0..<fields.count {
           let srcField = builder.createStructExtract(struct: source, fieldIndex: idx)
           let fieldAddr = builder.createStructElementAddr(structAddress: destination, fieldIndex: idx)
           builder.createStore(source: srcField, destination: fieldAddr, ownership: splitOwnership(for: srcField))
@@ -283,7 +286,10 @@ extension LoadInst {
       if type.nominal.isStructWithUnreferenceableStorage {
         return
       }
-      for idx in 0..<type.getNominalFields(in: parentFunction).count {
+      guard let fields = type.getNominalFields(in: parentFunction) else {
+        return
+      }
+      for idx in 0..<fields.count {
         let fieldAddr = builder.createStructElementAddr(structAddress: address, fieldIndex: idx)
         let splitLoad = builder.createLoad(fromAddress: fieldAddr, ownership: self.splitOwnership(for: fieldAddr))
         elements.append(splitLoad)

SwiftCompilerSources/Sources/SIL/SmallProjectionPath.swift

@@ -543,7 +543,9 @@ extension StringParser {
         if !ty.isClass && !ty.isStruct {
           try throwError("unknown kind of nominal type")
         }
-        let nominalFields = ty.getNominalFields(in: function)
+        guard let nominalFields = ty.getNominalFields(in: function) else {
+          try throwError("resilient types are not supported")
+        }
         guard let fieldIdx = nominalFields.getIndexOfField(withName: name) else {
           try throwError("field not found")
         }

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -90,8 +90,14 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
 
   public var tupleElements: TupleElementArray { TupleElementArray(type: self) }
 
-  public func getNominalFields(in function: Function) -> NominalFieldsArray {
-    NominalFieldsArray(type: self, function: function)
+  /// Can only be used if the type is in fact a nominal type (`isNominal` is true).
+  /// Returns nil if the nominal is a resilient type because in this case the complete list
+  /// of fields is not known.
+  public func getNominalFields(in function: Function) -> NominalFieldsArray? {
+    if nominal.isResilient(in: function) {
+      return nil
+    }
+    return NominalFieldsArray(type: self, function: function)
   }
 
   public typealias MetatypeRepresentation = BridgedType.MetatypeRepresentation
@@ -227,6 +233,10 @@ public struct NominalTypeDecl : Equatable, Hashable {
     hasher.combine(bridged.raw)
   }
 
+  public func isResilient(in function: Function) -> Bool {
+    function.bridged.isResilientNominalDecl(bridged)
+  }
+
   public var isStructWithUnreferenceableStorage: Bool {
     bridged.isStructWithUnreferenceableStorage()
   }

include/swift/SIL/SILBridging.h

@@ -320,6 +320,7 @@ struct BridgedFunction {
   BRIDGED_INLINE bool hasValidLinkageForFragileRef() const;
   BRIDGED_INLINE bool needsStackProtection() const;
   BRIDGED_INLINE void setNeedStackProtection(bool needSP) const;
+  BRIDGED_INLINE bool isResilientNominalDecl(BridgedNominalTypeDecl decl) const;
 
   enum class ParseEffectsMode {
     argumentEffectsFromSource,

include/swift/SIL/SILBridgingImpl.h

@@ -529,6 +529,11 @@ void BridgedFunction::setNeedStackProtection(bool needSP) const {
   getFunction()->setNeedStackProtection(needSP);
 }
 
+bool BridgedFunction::isResilientNominalDecl(BridgedNominalTypeDecl decl) const {
+  return decl.unbridged()->isResilient(getFunction()->getModule().getSwiftModule(),
+                                       getFunction()->getResilienceExpansion());
+}
+
 
 //===----------------------------------------------------------------------===//
 //                                BridgedGlobalVar