---

yaml
---
r: 294651
b: refs/heads/tensorflow
c: 9681c3b
h: refs/heads/master
i:
  294649: 5d498ab
  294647: 73b5b94

Author: David Ungar

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: ef1ad0613cfcadb3aee212d66cd0721a2109646e
+refs/heads/tensorflow: 9681c3b0c8f6335394ce09d2cbf71284ae7b57f1
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/lib/IDE/REPLCodeCompletion.cpp

@@ -16,7 +16,6 @@
 
 #include "swift/IDE/REPLCodeCompletion.h"
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/DiagnosticSuppression.h"
 #include "swift/AST/Module.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceManager.h"
@@ -194,7 +193,7 @@ doCodeCompletion(SourceFile &SF, StringRef EnteredCode, unsigned *BufferID,
                  CodeCompletionCallbacksFactory *CompletionCallbacksFactory) {
   // Temporarily disable printing the diagnostics.
   ASTContext &Ctx = SF.getASTContext();
-  DiagnosticSuppression SuppressedDiags(Ctx.Diags);
+  DiagnosticTransaction DelayedDiags(Ctx.Diags);
 
   std::string AugmentedCode = EnteredCode.str();
   AugmentedCode += '\0';
@@ -223,10 +222,7 @@ doCodeCompletion(SourceFile &SF, StringRef EnteredCode, unsigned *BufferID,
   // Now we are done with code completion.  Remove the declarations we
   // temporarily inserted.
   SF.Decls.resize(OriginalDeclCount);
-
-  // Reset the error state because it's only relevant to the code that we just
-  // processed, which now gets thrown away.
-  Ctx.Diags.resetHadAnyError();
+  DelayedDiags.abort();
 }
 
 void REPLCompletions::populate(SourceFile &SF, StringRef EnteredCode) {

branches/tensorflow/lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -88,7 +88,8 @@ static void fixupReferenceCounts(
   DeadEndBlocks deadEndBlocks(pai->getFunction());
   SmallVector<SILBasicBlock *, 4> leakingBlocks;
 
-  auto errorBehavior = ownership::ErrorBehaviorKind::ReturnFalse;
+  auto errorBehavior =
+      ownership::ErrorBehaviorKind::ReturnFalseOnLeakAssertOtherwise;
 
   // Add a copy of each non-address type capture argument to lifetime extend the
   // captured argument over at least the inlined function and till the end of a
@@ -141,33 +142,21 @@ static void fixupReferenceCounts(
       auto error =
           valueHasLinearLifetime(copy, {applySite}, {}, visitedBlocks,
                                  deadEndBlocks, errorBehavior, &leakingBlocks);
-      if (error.getFoundLeak()) {
+      if (error.getFoundError()) {
         while (!leakingBlocks.empty()) {
           auto *leakingBlock = leakingBlocks.pop_back_val();
           auto loc = RegularLocation::getAutoGeneratedLocation();
           SILBuilderWithScope builder(leakingBlock->begin());
-          if (hasOwnership) {
-            builder.createEndBorrow(loc, argument);
-          }
           builder.emitDestroyValueOperation(loc, copy);
         }
       }
 
-      // If we found an over consume it means that our value is consumed within
-      // the loop. That means our leak code will have lifetime extended the
-      // value over the loop. So we should /not/ insert a destroy after the
-      // apply site. In contrast, if we do not have an over consume, we must
-      // have been compensating for uses in the top of a diamond and need to
-      // insert a destroy after the apply since the leak will just cover the
-      // other path.
-      if (!error.getFoundOverConsume()) {
-        insertAfterApply(applySite, [&](SILBasicBlock::iterator iter) {
-          if (hasOwnership) {
-            SILBuilderWithScope(iter).createEndBorrow(loc, argument);
-          }
-          SILBuilderWithScope(iter).emitDestroyValueOperation(loc, copy);
-        });
-      }
+      insertAfterApply(applySite, [&](SILBasicBlock::iterator iter) {
+        if (hasOwnership) {
+          SILBuilderWithScope(iter).createEndBorrow(loc, argument);
+        }
+        SILBuilderWithScope(iter).emitDestroyValueOperation(loc, copy);
+      });
       v = argument;
       break;
     }

branches/tensorflow/lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -113,7 +113,7 @@ APInt swift::constantFoldCast(APInt val, const BuiltinInfo &BI) {
   SrcTy->castTo<BuiltinIntegerType>()->getGreatestWidth();
   uint32_t DestBitWidth =
   DestTy->castTo<BuiltinIntegerType>()->getGreatestWidth();
-
+  
   APInt CastResV;
   if (SrcBitWidth == DestBitWidth) {
     return val;
@@ -1761,46 +1761,7 @@ ConstantFolder::processWorkList() {
               FoldedUsers.insert(TI);
           }
 
-          // We were able to fold, so all users should use the new folded
-          // value. If we don't have any such users, continue.
-          //
-          // NOTE: The reason why we check if our result has uses is that if
-          // User is a MultipleValueInstruction an infinite loop can result if
-          // User has a result different than the one at Index that we can not
-          // constant fold and if C's defining instruction is an aggregate that
-          // defines an operand of I.
-          //
-          // As an elucidating example, consider the following SIL:
-          //
-          //   %w = integer_literal $Builtin.Word, 1
-          //   %0 = struct $Int (%w : $Builtin.Word)                     (*)
-          //   %1 = apply %f() : $@convention(thin) () -> @owned Klass
-          //   %2 = tuple (%0 : $Int, %1 : $Klass)
-          //   (%3, %4) = destructure_tuple %2 : $(Int, Klass)
-          //   store %4 to [init] %mem2: %*Klass
-          //
-          // Without this check, we would infinite loop by processing our
-          // worklist as follows:
-          //
-          // 1. We visit %w and add %0 to the worklist unconditionally since it
-          //    is a StructInst.
-          //
-          // 2. We visit %0 and then since %2 is a tuple, we add %2 to the
-          //    worklist unconditionally.
-          //
-          // 3. We visit %2 and see that it has a destructure_tuple user. We see
-          //    that we can simplify %3 -> %0, but cannot simplify %4. This
-          //    means that if we just assume success if we can RAUW %3 without
-          //    checking if we will actually replace anything, we will add %0's
-          //    defining instruction (*) to the worklist. Q.E.D.
-          //
-          // In contrast, if we realize that RAUWing %3 does nothing and skip
-          // it, we exit the worklist as expected.
-          SILValue r = User->getResult(Index);
-          if (r->use_empty())
-            continue;
-
-          // Otherwise, do the RAUW.
+          // We were able to fold, so all users should use the new folded value.
           User->getResult(Index)->replaceAllUsesWith(C);
 
           // The new constant could be further folded now, add it to the

branches/tensorflow/lib/Sema/CSDiag.cpp

@@ -735,7 +735,7 @@ void FailureDiagnosis::diagnoseUnviableLookupResults(
 
   ValueDecl *member = nullptr;
   for (auto cand : result.UnviableCandidates) {
-    if (member == nullptr)
+    if (member == nullptr && cand.isDecl())
       member = cand.getDecl();
   }
 

branches/tensorflow/test/IDE/repl_complete_with_error.swift

@@ -4,10 +4,6 @@
 import Swift
 import Builtin
 
-//////////////////
-// Declarations //
-//////////////////
-
 struct UInt {
   var value: Builtin.Word
 }
@@ -24,15 +20,6 @@ struct UInt64 {
   var value: Builtin.Int64
 }
 
-class Klass {}
-
-sil @klass_allocator : $@convention(method) (@thick Klass.Type) -> @owned Klass
-sil @generic_user : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
-
-///////////
-// Tests //
-///////////
-
 sil [ossa] @count_leading_zeros_corner_case : $@convention(thin) () -> Builtin.Int64 {
 bb0:
  %zero64 = integer_literal $Builtin.Int64, 0
@@ -1145,39 +1132,3 @@ bb2(%8 : @owned $AnSubObject):
 bb3(%11 : $Builtin.Int1):
   return %11 : $Builtin.Int1
 }
-
-sil [ossa] @do_not_infinite_loop : $@convention(thin) () -> () {
-bb0:
-  %0 = integer_literal $Builtin.Word, 1
-  %1 = struct $Int (%0 : $Builtin.Word)
-  %2 = metatype $@thick Klass.Type
-  %3 = function_ref @klass_allocator : $@convention(method) (@thick Klass.Type) -> @owned Klass
-  %4 = apply %3(%2) : $@convention(method) (@thick Klass.Type) -> @owned Klass
-  // We can never in constant propagation forward %5 today since we would need
-  // to know that we are eliminting all of its uses. But the pass doesn't
-  // understand that today and so destroy_value %5 in bb2 stops our ability to
-  // optimize.
-  %5 = tuple (%1 : $Int, %4 : $Klass)
-  cond_br undef, bb1, bb2
-
-bb1:
-  %6 = alloc_stack $(Int, Klass)
-  %7 = tuple_element_addr %6 : $*(Int, Klass), 0
-  %8 = tuple_element_addr %6 : $*(Int, Klass), 1
-  (%9, %10) = destructure_tuple %5 : $(Int, Klass)
-  store %1 to [trivial] %7 : $*Int
-  store %10 to [init] %8 : $*Klass
-  %13 = function_ref @generic_user : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
-  %14 = apply %13<(Int, Klass)>(%6) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
-  destroy_addr %6 : $*(Int, Klass)
-  dealloc_stack %6 : $*(Int, Klass)
-  br bb3
-
-bb2:
-  destroy_value %5 : $(Int, Klass)
-  br bb3
-
-bb3:
-  %9999 = tuple()
-  return %9999 : $()
-}

branches/tensorflow/test/Interpreter/mandatory_inlining.swift

@@ -1200,143 +1200,3 @@ bb0(%0: $C):
   %tuple = tuple()
   return %tuple : $()
 }
-
-// CHECK-LABEL: sil @test_apply_pai_in_loop : $@convention(thin) (@guaranteed C) ->  () {
-// CHECK: bb0([[ARG:%.*]] : $C):
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   br bb1
-//
-// CHECK: bb1:
-// CHECK-NEXT:   cond_br undef, bb2, bb3
-//
-// CHECK: bb2:
-// CHECK-NEXT: function_ref use_c
-// CHECK-NEXT: [[FUNC:%.*]] = function_ref @use_c
-// CHECK-NEXT: apply [[FUNC]]([[ARG]])
-// CHECK-NEXT: tuple
-// CHECK-NEXT: br bb1
-//
-// CHECK: bb3:
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: tuple
-// CHECK-NEXT: return
-// CHECK-NEXT: } // end sil function 'test_apply_pai_in_loop'
-sil @test_apply_pai_in_loop : $@convention(thin) (@guaranteed C) ->  () {
-bb0(%0: $C):
-  strong_retain %0 : $C
-  %closure_fun = function_ref @guaranteed_closure_func : $@convention(thin) (@guaranteed C) -> ()
-  %closure = partial_apply [callee_guaranteed] %closure_fun(%0) : $@convention(thin) (@guaranteed C) -> ()
-  br bb1
-
-bb1:
-  cond_br undef, bb2, bb3
-
-bb2:
-  apply %closure() : $@callee_guaranteed () -> ()
-  br bb1
-
-bb3:
-  strong_release %0: $C
-  %tuple = tuple()
-  return %tuple : $()
-}
-
-// CHECK-LABEL: sil @test_apply_pai_in_loop_with_diamond : $@convention(thin) (@guaranteed C) ->  () {
-// CHECK: bb0([[ARG:%.*]] : $C):
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   cond_br undef, bb1, bb4
-//
-// CHECK: bb1:
-// CHECK-NEXT: function_ref use_c
-// CHECK-NEXT: [[FUNC:%.*]] = function_ref @use_c
-// CHECK-NEXT: apply [[FUNC]]([[ARG]])
-// CHECK-NEXT: tuple
-// CHECK-NEXT: cond_br undef, bb2, bb3
-//
-// CHECK: bb2:
-// CHECK-NEXT: function_ref use_c
-// CHECK-NEXT: [[FUNC:%.*]] = function_ref @use_c
-// CHECK-NEXT: apply [[FUNC]]([[ARG]])
-// CHECK-NEXT: tuple
-// CHECK-NEXT: br bb1
-//
-// CHECK: bb3:
-// CHECK-NEXT: br bb1
-//
-// CHECK: bb4:
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: tuple
-// CHECK-NEXT: return
-// CHECK-NEXT: } // end sil function 'test_apply_pai_in_loop_with_diamond'
-sil @test_apply_pai_in_loop_with_diamond : $@convention(thin) (@guaranteed C) ->  () {
-bb0(%0: $C):
-  strong_retain %0 : $C
-  %closure_fun = function_ref @guaranteed_closure_func : $@convention(thin) (@guaranteed C) -> ()
-  %closure = partial_apply [callee_guaranteed] %closure_fun(%0) : $@convention(thin) (@guaranteed C) -> ()
-  cond_br undef, bb2, bb5
-
-bb2:
-  apply %closure() : $@callee_guaranteed () -> ()
-  cond_br undef, bb3, bb4
-
-bb3:
-  apply %closure() : $@callee_guaranteed () -> ()
-  br bb2
-
-bb4:
-  br bb2
-
-bb5:
-  strong_release %0: $C
-  %tuple = tuple()
-  return %tuple : $()
-}
-
-// CHECK-LABEL: sil @test_apply_pai_in_diamond : $@convention(thin) (@guaranteed C) ->  () {
-// CHECK: bb0([[ARG:%.*]] : $C):
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   strong_retain [[ARG]]
-// CHECK-NEXT:   cond_br undef, bb1, bb2
-//
-// CHECK: bb1:
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: br bb3
-//
-// CHECK: bb2:
-// CHECK-NEXT: function_ref use_c
-// CHECK-NEXT: [[FUNC:%.*]] = function_ref @use_c
-// CHECK-NEXT: apply [[FUNC]]([[ARG]])
-// CHECK-NEXT: tuple
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: br bb3
-//
-// CHECK: bb3:
-// CHECK-NEXT: strong_release [[ARG]]
-// CHECK-NEXT: tuple
-// CHECK-NEXT: return
-// CHECK-NEXT: } // end sil function 'test_apply_pai_in_diamond'
-sil @test_apply_pai_in_diamond : $@convention(thin) (@guaranteed C) ->  () {
-bb0(%0: $C):
-  strong_retain %0 : $C
-  %closure_fun = function_ref @guaranteed_closure_func : $@convention(thin) (@guaranteed C) -> ()
-  %closure = partial_apply [callee_guaranteed] %closure_fun(%0) : $@convention(thin) (@guaranteed C) -> ()
-  cond_br undef, bb1, bb2
-
-bb1:
-  br bb3
-
-bb2:
-  apply %closure() : $@callee_guaranteed () -> ()
-  br bb3
-
-bb3:
-  strong_release %0: $C
-  %tuple = tuple()
-  return %tuple : $()
-}