Merge pull request #18319 from slavapestov/di-try-apply

DI: Don't forget to check inout uses for try_apply too

Author: slavapestov

lib/SILOptimizer/Mandatory/DIMemoryUseCollectorOwnership.cpp

@@ -819,8 +819,9 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
     //
     // Note that partial_apply instructions always close over their argument.
     //
-    if (auto *Apply = dyn_cast<ApplyInst>(User)) {
-      auto substConv = Apply->getSubstCalleeConv();
+    auto Apply = FullApplySite::isa(User);
+    if (Apply) {
+      auto substConv = Apply.getSubstCalleeConv();
       unsigned ArgumentNumber = Op->getOperandNumber() - 1;
 
       // If this is an out-parameter, it is like a store.

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1087,14 +1087,15 @@ void LifetimeChecker::handleInOutUse(const DIMemoryUse &Use) {
     // Otherwise, we produce a generic error.
     FuncDecl *FD = nullptr;
     bool isAssignment = false;
-    
-    if (auto *Apply = dyn_cast<ApplyInst>(Use.Inst)) {
+
+    auto Apply = FullApplySite::isa(Use.Inst);
+    if (Apply) {
       // If this is a method application, produce a nice, specific, error.
-      if (auto *WMI = dyn_cast<MethodInst>(Apply->getOperand(0)))
+      if (auto *WMI = dyn_cast<MethodInst>(Apply.getCallee()))
         FD = dyn_cast<FuncDecl>(WMI->getMember().getDecl());
 
       // If this is a direct/devirt method application, check the location info.
-      if (auto *Fn = Apply->getReferencedFunction()) {
+      if (auto *Fn = Apply.getReferencedFunction()) {
         if (Fn->hasLocation()) {
           auto SILLoc = Fn->getLocation();
           FD = SILLoc.getAsASTNode<FuncDecl>();
@@ -1104,9 +1105,9 @@ void LifetimeChecker::handleInOutUse(const DIMemoryUse &Use) {
       // If we failed to find the decl a clean and principled way, try hacks:
       // map back to the AST and look for some common patterns.
       if (!FD) {
-        if (Apply->getLoc().getAsASTNode<AssignExpr>())
+        if (Apply.getLoc().getAsASTNode<AssignExpr>())
           isAssignment = true;
-        else if (auto *CE = Apply->getLoc().getAsASTNode<ApplyExpr>()) {
+        else if (auto *CE = Apply.getLoc().getAsASTNode<ApplyExpr>()) {
           if (auto *DSCE = dyn_cast<SelfApplyExpr>(CE->getFn()))
             // Normal method calls are curried, so they are:
             // (call_expr (dot_syntax_call_expr (decl_ref_expr METHOD)))

test/SILOptimizer/definite_init_diagnostics.swift

@@ -758,6 +758,8 @@ extension Int {
 }
 
 
+func throwingSwap<T>(_ a: inout T, _ b: inout T) throws {}
+
 // <rdar://problem/19035287> let properties should only be initializable, not reassignable
 struct LetProperties {
   // expected-note @+1 {{change 'let' to 'var' to make it mutable}} {{3-6=var}}
@@ -771,6 +773,9 @@ struct LetProperties {
   let y : Int
   let z : Int?  // expected-note{{'self.z' not initialized}}
 
+  func methodTakesInOut(_ x: inout Int) {}
+  func throwingMethodTakesInOut(_ x: inout Int) throws {}
+
   // Let properties can be initialized naturally exactly once along any given
   // path through an initializer.
   init(cond : Bool) {
@@ -810,19 +815,23 @@ struct LetProperties {
   }  // expected-error {{return from initializer without initializing all stored properties}}
 
   // inout uses of let properties are an error.
-  init() {
+  init() throws {
     u = 1; v = 13; w = (1,2); y = 1 ; z = u
 
     var variable = 42
     swap(&u, &variable)  // expected-error {{immutable value 'self.u' must not be passed inout}}
-    
+    try throwingSwap(&u, &variable)  // expected-error {{immutable value 'self.u' must not be passed inout}}
+
     u.inspect()  // ok, non mutating.
     u.mutate()  // expected-error {{mutating method 'mutate' may not be used on immutable value 'self.u'}}
 
     arr = []
     arr += []      // expected-error {{mutating operator '+=' may not be used on immutable value 'self.arr'}}
     arr.append(4)  // expected-error {{mutating method 'append' may not be used on immutable value 'self.arr'}}
     arr[12] = 17   // expected-error {{mutating subscript 'subscript' may not be used on immutable value 'self.arr'}}
+
+    methodTakesInOut(&u)  // expected-error {{mutating method 'methodTakesInOut' may not be used on immutable value 'self.u'}}
+    try throwingMethodTakesInOut(&u)  // expected-error {{mutating method 'throwingMethodTakesInOut' may not be used on immutable value 'self.u'}}
   }
 }