SILGen: Coordinate access strategy determination with actual codegen in findStorageReferenceExprForMoveOnly.

Looking at the AST-level `getReadImpl` doesn't always correspond to what
accessor SILGen prefers to use, due to resilience, ABI rules, and other
concerns. In findStorageReferenceExprForMoveOnly, when determining whether
a storage reference is borrowable, use the same logic as SILGenLValue actually
uses to determine what storage or accessor access strategy to use.

Fixes rdar://142509673

Author: jckarter

lib/SILGen/SILGenApply.cpp

@@ -3304,23 +3304,61 @@ Expr *SILGenFunction::findStorageReferenceExprForMoveOnly(Expr *argExpr,
   // referenced is a move-only type.
 
   AbstractStorageDecl *storage = nullptr;
+  AccessSemantics accessSemantics;
   Type type;
   if (auto dre = dyn_cast<DeclRefExpr>(result.getStorageRef())) {
     storage = dyn_cast<AbstractStorageDecl>(dre->getDecl());
     type = dre->getType();
+    accessSemantics = dre->getAccessSemantics();
   } else if (auto mre = dyn_cast<MemberRefExpr>(result.getStorageRef())) {
     storage = dyn_cast<AbstractStorageDecl>(mre->getDecl().getDecl());
     type = mre->getType();
+    accessSemantics = mre->getAccessSemantics();
   } else if (auto se = dyn_cast<SubscriptExpr>(result.getStorageRef())) {
     storage = dyn_cast<AbstractStorageDecl>(se->getDecl().getDecl());
     type = se->getType();
+    accessSemantics = se->getAccessSemantics();
   }
 
   if (!storage)
     return nullptr;
-  if (!storage->hasStorage() && storage->getReadImpl() != ReadImplKind::Read &&
-      storage->getReadImpl() != ReadImplKind::Read2 &&
-      storage->getReadImpl() != ReadImplKind::Address) {
+  // This should match the strategy computation used in
+  // SILGenLValue::visit{DeclRef,Member}RefExpr.
+  auto strategy = storage->getAccessStrategy(accessSemantics,
+         AccessKind::Read, SGM.M.getSwiftModule(), F.getResilienceExpansion(),
+         /* old abi*/ false);
+  
+  switch (strategy.getKind()) {
+  case AccessStrategy::Storage:
+    // Storage can benefit from direct borrowing/consumption.
+    break;
+  case AccessStrategy::DirectToAccessor:
+  case AccessStrategy::DispatchToAccessor:
+    // If the accessor naturally produces a borrow, then we benefit from
+    // directly borrowing it.
+    switch (strategy.getAccessor()) {
+    case AccessorKind::Address:
+    case AccessorKind::MutableAddress:
+    case AccessorKind::Read:
+    case AccessorKind::Read2:
+    case AccessorKind::Modify:
+    case AccessorKind::Modify2:
+      // Accessors that produce a borrow/inout value can be borrowed.
+      break;
+    
+    case AccessorKind::Get:
+    case AccessorKind::Set:
+    case AccessorKind::DistributedGet:
+    case AccessorKind::Init:
+    case AccessorKind::WillSet:
+    case AccessorKind::DidSet:
+      // Other accessors can't.
+      return nullptr;
+    }
+    break;
+  
+  case AccessStrategy::MaterializeToTemporary:
+  case AccessStrategy::DispatchToDistributedThunk:
     return nullptr;
   }
 

test/SILOptimizer/moveonly_checking_class_method.swift

@@ -0,0 +1,22 @@
+// RUN: %target-swift-frontend -emit-sil -verify %s
+
+// rdar://142509673
+
+struct Foo: ~Copyable {
+    var storage: UnsafeRawPointer
+}
+
+class Bar {
+    class var foo: Foo { fatalError() }
+}
+
+func test(foo: borrowing Foo) -> Bool {
+    fatalError()
+}
+
+func test2(bar: Bar.Type) -> Bool {
+    guard test(foo: bar.foo) else {
+        return false
+    }
+    return true
+}