SIL: Verifier checks resilience invariants for keypath instruction

Author: slavapestov

lib/SIL/SILVerifier.cpp

@@ -119,6 +119,7 @@ namespace {
 
 /// Verify invariants on a key path component.
 void verifyKeyPathComponent(SILModule &M,
+                            ResilienceExpansion expansion,
                             llvm::function_ref<void(bool, StringRef)> require,
                             CanType &baseTy,
                             CanType leafTy,
@@ -211,13 +212,21 @@ void verifyKeyPathComponent(SILModule &M,
   switch (auto kind = component.getKind()) {
   case KeyPathPatternComponent::Kind::StoredProperty: {
     auto property = component.getStoredPropertyDecl();
+    if (expansion == ResilienceExpansion::Minimal) {
+      require(property->getEffectiveAccess() >= AccessLevel::Public,
+              "Key path in serialized function cannot reference non-public "
+              "property");
+    }
+
     auto fieldTy = baseTy->getTypeOfMember(M.getSwiftModule(), property)
                          ->getReferenceStorageReferent()
                          ->getCanonicalType();
     require(fieldTy == componentTy,
             "property decl should be a member of the base with the same type "
             "as the component");
     require(property->hasStorage(), "property must be stored");
+    require(!property->isResilient(M.getSwiftModule(), expansion),
+            "cannot access storage of resilient property");
     auto propertyTy = loweredBaseTy.getFieldType(property, M);
     require(propertyTy.getObjectType()
               == loweredComponentTy.getObjectType(),
@@ -247,6 +256,12 @@ void verifyKeyPathComponent(SILModule &M,
     // Getter should be <Sig...> @convention(thin) (@in_guaranteed Base) -> @out Result
     {
       auto getter = component.getComputedPropertyGetter();
+      if (expansion == ResilienceExpansion::Minimal) {
+        require(getter->hasValidLinkageForFragileRef(),
+                "Key path in serialized function should not reference "
+                "less visible getters");
+      }
+
       auto substGetterType = getter->getLoweredFunctionType()
         ->substGenericArgs(M, patternSubs);
       require(substGetterType->getRepresentation() ==
@@ -286,6 +301,12 @@ void verifyKeyPathComponent(SILModule &M,
       // <Sig...> @convention(thin) (@in_guaranteed Result, @in Base) -> ()
 
       auto setter = component.getComputedPropertySetter();
+      if (expansion == ResilienceExpansion::Minimal) {
+        require(setter->hasValidLinkageForFragileRef(),
+                "Key path in serialized function should not reference "
+                "less visible setters");
+      }
+
       auto substSetterType = setter->getLoweredFunctionType()
         ->substGenericArgs(M, patternSubs);
 
@@ -4242,7 +4263,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
           break;
         }
 
-        verifyKeyPathComponent(F.getModule(),
+        verifyKeyPathComponent(F.getModule(), F.getResilienceExpansion(),
           [&](bool reqt, StringRef message) { _require(reqt, message); },
           baseTy,
           leafTy,
@@ -4879,15 +4900,16 @@ void SILProperty::verify(const SILModule &M) const {
 
   if (auto &component = getComponent()) {
     verifyKeyPathComponent(const_cast<SILModule&>(M),
-      require,
-      baseTy,
-      leafTy,
-      *component,
-      {},
-      canSig,
-      subs,
-      /*property descriptor*/true,
-      hasIndices);
+                           ResilienceExpansion::Maximal,
+                           require,
+                           baseTy,
+                           leafTy,
+                           *component,
+                           {},
+                           canSig,
+                           subs,
+                           /*property descriptor*/true,
+                           hasIndices);
     // verifyKeyPathComponent updates baseTy to be the projected type of the
     // component, which should be the same as the type of the declared storage
     require(baseTy == leafTy,

test/SIL/Serialization/keypath.sil

@@ -1,48 +1,48 @@
 
 // First parse this and then emit a *.sib. Then read in the *.sib, then recreate
 // RUN: %empty-directory(%t)
-// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name boxes
-// RUN: %target-sil-opt %t/tmp.sib -o %t/tmp.2.sib -module-name boxes
-// RUN: %target-sil-opt %t/tmp.2.sib -module-name boxes | %FileCheck %s
+// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name keypaths
+// RUN: %target-sil-opt %t/tmp.sib -emit-sib -o %t/tmp.2.sib -module-name keypaths
+// RUN: %target-sil-opt %t/tmp.2.sib -module-name keypaths | %FileCheck %s
 
 sil_stage canonical
 
 import Swift
 
-struct S: Hashable {
-  var x: Int
-  let y: String
-  var z: C
+public struct S: Hashable {
+  public var x: Int
+  public let y: String
+  public var z: C
 
-  func hash(into hasher: inout Hasher)
-  static func ==(x: S, y: S) -> Bool
+  public func hash(into hasher: inout Hasher)
+  public static func ==(x: S, y: S) -> Bool
 }
-class C: Hashable {
-  final var x: Int
-  final let y: String
-  final var z: S
+public class C: Hashable {
+  public final var x: Int
+  public final let y: String
+  public final var z: S
 
-  init()
-  var overridable: Int {
+  public init()
+  public var overridable: Int {
     get set
   }
 
-  func hash(into hasher: inout Hasher)
-  static func ==(x: C, y: C) -> Bool
+  public func hash(into hasher: inout Hasher)
+  public static func ==(x: C, y: C) -> Bool
 }
 
 protocol P {}
 protocol Q {}
 protocol R {}
 
-struct Gen<A: P, B: Q, C: R> {
-  var x: A
-  let y: B
-  var z: C
+public struct Gen<A: P, B: Q, C: R> {
+  public var x: A
+  public let y: B
+  public var z: C
 }
 
 public struct External<T> {
-  var ro: T
+  public var ro: T
 
   subscript<U: Hashable>(ro _: U) -> T { get }