SIL: Get addressor property names for display in move checker diagnostics.

Author: jckarter

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -91,7 +91,7 @@ static void getVariableNameForValue(SILValue value2,
   // operand.
   StackList<llvm::PointerUnion<SILInstruction *, SILValue>> variableNamePath(
       value2->getFunction());
-  while (true) {
+  while (searchValue) {
     if (auto *allocInst = dyn_cast<AllocationInst>(searchValue)) {
       // If the instruction itself doesn't carry any variable info, see whether
       // it's copied from another place that does.
@@ -130,18 +130,44 @@ static void getVariableNameForValue(SILValue value2,
       variableNamePath.push_back({fArg});
       break;
     }
-
-    if (auto bai = dyn_cast_or_null<BeginApplyInst>(searchValue->getDefiningInstruction())) {
+    
+    auto getNamePathComponentFromCallee = [&](FullApplySite call) -> llvm::Optional<SILValue> {
       // Use the name of the property being accessed if we can get to it.
-      if (isa<FunctionRefBaseInst>(bai->getCallee())
-          || isa<MethodInst>(bai->getCallee())) {
-        variableNamePath.push_back(bai->getCallee()->getDefiningInstruction());
+      if (isa<FunctionRefBaseInst>(call.getCallee())
+          || isa<MethodInst>(call.getCallee())) {
+        variableNamePath.push_back(call.getCallee()->getDefiningInstruction());
         // Try to name the base of the property if this is a method.
-        if (bai->getSubstCalleeType()->hasSelfParam()) {
-          searchValue = bai->getSelfArgument();
-          continue;
+        if (call.getSubstCalleeType()->hasSelfParam()) {
+          return call.getSelfArgument();
         } else {
-          break;
+          return SILValue();
+        }
+      }
+      return llvm::None;
+    };
+
+    // Read or modify accessor.
+    if (auto bai = dyn_cast_or_null<BeginApplyInst>(searchValue->getDefiningInstruction())) {
+      if (auto selfParam = getNamePathComponentFromCallee(bai)) {
+        searchValue = *selfParam;
+        continue;
+      }
+    }
+    
+    // Addressor accessor.
+    if (auto ptrToAddr = dyn_cast<PointerToAddressInst>(stripAccessMarkers(searchValue))) {
+      // The addressor can either produce the raw pointer itself or an `UnsafePointer` stdlib type wrapping it.
+      ApplyInst *addressorInvocation;
+      if (auto structExtract = dyn_cast<StructExtractInst>(ptrToAddr->getOperand())) {
+        addressorInvocation = dyn_cast<ApplyInst>(structExtract->getOperand());
+      } else {
+        addressorInvocation = dyn_cast<ApplyInst>(ptrToAddr->getOperand());
+      }
+      
+      if (addressorInvocation) {
+        if (auto selfParam = getNamePathComponentFromCallee(addressorInvocation)) {
+          searchValue = *selfParam;
+          continue;
         }
       }
     }

test/SILOptimizer/moveonly_addressors.swift

@@ -80,44 +80,43 @@ func borrow(_ nc: borrowing NC) {}
 func mod(_ nc: inout NC) {}
 func take(_ nc: consuming NC) {}
 
-// TODO: Resolve thing being consumed more precisely than 'unknown'.
 // TODO: Use more specific diagnostic than "reinitialization of inout parameter"
 
 func test(c: C) {
   borrow(c.data)
-  take(c.data) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(c.data) // expected-error{{'c.data' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 
   borrow(c.mutableData)
   mod(&c.mutableData)
-  take(c.mutableData) // expected-error{{missing reinitialization of inout parameter 'unknown' after consume}} expected-note{{consumed here}}
+  take(c.mutableData) // expected-error{{missing reinitialization of inout parameter 'c.mutableData' after consume}} expected-note{{consumed here}}
 }
 func test(s: S) {
   borrow(s.data)
-  take(s.data) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(s.data) // expected-error{{'s.data' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 
   borrow(s.mutableData)
-  take(s.mutableData) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(s.mutableData) // expected-error{{'s.mutableData' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 }
 func test(mut_s s: inout S) {
   borrow(s.data)
-  take(s.data) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(s.data) // expected-error{{'s.data' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 
   borrow(s.mutableData)
   mod(&s.mutableData)
-  take(s.mutableData) // expected-error{{missing reinitialization of inout parameter 'unknown' after consume}} expected-note{{consumed here}}
+  take(s.mutableData) // expected-error{{missing reinitialization of inout parameter 's.mutableData' after consume}} expected-note{{consumed here}}
 }
 func test(snc: borrowing SNC) {
   borrow(snc.data)
-  take(snc.data) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(snc.data) // expected-error{{'snc.data' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 
   borrow(snc.mutableData)
-  take(snc.mutableData) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(snc.mutableData) // expected-error{{'snc.mutableData' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 }
 func test(mut_snc snc: inout SNC) {
   borrow(snc.data)
-  take(snc.data) // expected-error{{'unknown' is borrowed and cannot be consumed}} expected-note{{consumed here}}
+  take(snc.data) // expected-error{{'snc.data' is borrowed and cannot be consumed}} expected-note{{consumed here}}
 
   borrow(snc.mutableData)
   mod(&snc.mutableData)
-  take(snc.mutableData) // expected-error{{missing reinitialization of inout parameter 'unknown' after consume}} expected-note{{consumed here}}
+  take(snc.mutableData) // expected-error{{missing reinitialization of inout parameter 'snc.mutableData' after consume}} expected-note{{consumed here}}
 }