---

yaml
---
r: 349190
b: refs/heads/master-next
c: c0a57b6
h: refs/heads/master

Author: slavapestov

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 44827bbde4d856199c528b9743b4c6b86fb4e6f7
+refs/heads/master-next: c0a57b6e17831e2c4e399c4a61b342f5b077245c
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/AST/DiagnosticsSema.def

@@ -1116,6 +1116,8 @@ ERROR(missing_argument_named,none,
       "missing argument for parameter %0 in call", (Identifier))
 ERROR(missing_argument_positional,none,
       "missing argument for parameter #%0 in call", (unsigned))
+ERROR(missing_arguments_in_call,none,
+      "missing arguments for parameters %0 in call", (StringRef))
 ERROR(extra_argument_named,none,
       "extra argument %0 in call", (Identifier))
 ERROR(extra_argument_positional,none,
@@ -3493,6 +3495,10 @@ ERROR(single_tuple_parameter_mismatch_normal,none,
       (DescriptiveDeclKind, DeclBaseName, Type, StringRef))
 ERROR(unknown_single_tuple_parameter_mismatch,none,
       "single parameter of type %0 is expected in call", (Type))
+ERROR(cannot_convert_single_tuple_into_multiple_arguments,none,
+      "%0 %select{%1 |}2expects %3 separate arguments"
+      "%select{|; remove extra parentheses to change tuple into separate arguments}4",
+      (DescriptiveDeclKind, DeclName, bool, unsigned, bool))
 
 ERROR(enum_element_pattern_assoc_values_mismatch,none,
       "pattern with associated values does not match enum case %0",

branches/master-next/include/swift/SIL/OwnershipUtils.h

@@ -200,7 +200,86 @@ bool isOwnershipForwardingInst(SILInstruction *i);
 
 bool isGuaranteedForwardingInst(SILInstruction *i);
 
-struct BorrowScopeIntroducerKind {
+struct BorrowScopeOperandKind {
+  using UnderlyingKindTy = std::underlying_type<SILInstructionKind>::type;
+
+  enum Kind : UnderlyingKindTy {
+    BeginBorrow = UnderlyingKindTy(SILInstructionKind::BeginBorrowInst),
+    BeginApply = UnderlyingKindTy(SILInstructionKind::BeginApplyInst),
+  };
+
+  Kind value;
+
+  BorrowScopeOperandKind(Kind newValue) : value(newValue) {}
+  BorrowScopeOperandKind(const BorrowScopeOperandKind &other)
+      : value(other.value) {}
+  operator Kind() const { return value; }
+
+  static Optional<BorrowScopeOperandKind> get(SILInstructionKind kind) {
+    switch (kind) {
+    default:
+      return None;
+    case SILInstructionKind::BeginBorrowInst:
+      return BorrowScopeOperandKind(BeginBorrow);
+    case SILInstructionKind::BeginApplyInst:
+      return BorrowScopeOperandKind(BeginApply);
+    }
+  }
+
+  void print(llvm::raw_ostream &os) const;
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const, "only for use in the debugger");
+};
+
+/// An operand whose user instruction introduces a new borrow scope for the
+/// operand's value. The value of the operand must be considered as implicitly
+/// borrowed until the user's corresponding end scope instruction.
+struct BorrowScopeOperand {
+  BorrowScopeOperandKind kind;
+  Operand *op;
+
+  BorrowScopeOperand(Operand *op)
+      : kind(*BorrowScopeOperandKind::get(op->getUser()->getKind())), op(op) {}
+
+  /// If value is a borrow introducer return it after doing some checks.
+  static Optional<BorrowScopeOperand> get(Operand *op) {
+    auto *user = op->getUser();
+    auto kind = BorrowScopeOperandKind::get(user->getKind());
+    if (!kind)
+      return None;
+    return BorrowScopeOperand(*kind, op);
+  }
+
+  void visitEndScopeInstructions(function_ref<void(Operand *)> func) const {
+    switch (kind) {
+    case BorrowScopeOperandKind::BeginBorrow:
+      for (auto *use : cast<BeginBorrowInst>(op->getUser())->getUses()) {
+        if (isa<EndBorrowInst>(use->getUser())) {
+          func(use);
+        }
+      }
+      return;
+    case BorrowScopeOperandKind::BeginApply: {
+      auto *user = cast<BeginApplyInst>(op->getUser());
+      for (auto *use : user->getTokenResult()->getUses()) {
+        func(use);
+      }
+      return;
+    }
+    }
+    llvm_unreachable("Covered switch isn't covered");
+  }
+
+private:
+  /// Internal constructor for failable static constructor. Please do not expand
+  /// its usage since it assumes the code passed in is well formed.
+  BorrowScopeOperand(BorrowScopeOperandKind kind, Operand *op)
+      : kind(kind), op(op) {}
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              BorrowScopeOperandKind kind);
+
+struct BorrowScopeIntroducingValueKind {
   using UnderlyingKindTy = std::underlying_type<ValueKind>::type;
 
   /// Enum we use for exhaustive pattern matching over borrow scope introducers.
@@ -210,23 +289,23 @@ struct BorrowScopeIntroducerKind {
     SILFunctionArgument = UnderlyingKindTy(ValueKind::SILFunctionArgument),
   };
 
-  static Optional<BorrowScopeIntroducerKind> get(ValueKind kind) {
+  static Optional<BorrowScopeIntroducingValueKind> get(ValueKind kind) {
     switch (kind) {
     default:
       return None;
     case ValueKind::LoadBorrowInst:
-      return BorrowScopeIntroducerKind(LoadBorrow);
+      return BorrowScopeIntroducingValueKind(LoadBorrow);
     case ValueKind::BeginBorrowInst:
-      return BorrowScopeIntroducerKind(BeginBorrow);
+      return BorrowScopeIntroducingValueKind(BeginBorrow);
     case ValueKind::SILFunctionArgument:
-      return BorrowScopeIntroducerKind(SILFunctionArgument);
+      return BorrowScopeIntroducingValueKind(SILFunctionArgument);
     }
   }
 
   Kind value;
 
-  BorrowScopeIntroducerKind(Kind newValue) : value(newValue) {}
-  BorrowScopeIntroducerKind(const BorrowScopeIntroducerKind &other)
+  BorrowScopeIntroducingValueKind(Kind newValue) : value(newValue) {}
+  BorrowScopeIntroducingValueKind(const BorrowScopeIntroducingValueKind &other)
       : value(other.value) {}
   operator Kind() const { return value; }
 
@@ -238,10 +317,10 @@ struct BorrowScopeIntroducerKind {
   /// of the scope.
   bool isLocalScope() const {
     switch (value) {
-    case BorrowScopeIntroducerKind::BeginBorrow:
-    case BorrowScopeIntroducerKind::LoadBorrow:
+    case BorrowScopeIntroducingValueKind::BeginBorrow:
+    case BorrowScopeIntroducingValueKind::LoadBorrow:
       return true;
-    case BorrowScopeIntroducerKind::SILFunctionArgument:
+    case BorrowScopeIntroducingValueKind::SILFunctionArgument:
       return false;
     }
     llvm_unreachable("Covered switch isnt covered?!");
@@ -252,7 +331,7 @@ struct BorrowScopeIntroducerKind {
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
-                              BorrowScopeIntroducerKind kind);
+                              BorrowScopeIntroducingValueKind kind);
 
 /// A higher level construct for working with values that represent the
 /// introduction of a new borrow scope.
@@ -271,26 +350,26 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
 /// borrow introducers can not have guaranteed results that are not creating a
 /// new borrow scope. No such instructions exist today.
 struct BorrowScopeIntroducingValue {
-  BorrowScopeIntroducerKind kind;
+  BorrowScopeIntroducingValueKind kind;
   SILValue value;
 
   BorrowScopeIntroducingValue(LoadBorrowInst *lbi)
-      : kind(BorrowScopeIntroducerKind::LoadBorrow), value(lbi) {}
+      : kind(BorrowScopeIntroducingValueKind::LoadBorrow), value(lbi) {}
   BorrowScopeIntroducingValue(BeginBorrowInst *bbi)
-      : kind(BorrowScopeIntroducerKind::BeginBorrow), value(bbi) {}
+      : kind(BorrowScopeIntroducingValueKind::BeginBorrow), value(bbi) {}
   BorrowScopeIntroducingValue(SILFunctionArgument *arg)
-      : kind(BorrowScopeIntroducerKind::SILFunctionArgument), value(arg) {
+      : kind(BorrowScopeIntroducingValueKind::SILFunctionArgument), value(arg) {
     assert(arg->getOwnershipKind() == ValueOwnershipKind::Guaranteed);
   }
 
   BorrowScopeIntroducingValue(SILValue v)
-      : kind(*BorrowScopeIntroducerKind::get(v->getKind())), value(v) {
+      : kind(*BorrowScopeIntroducingValueKind::get(v->getKind())), value(v) {
     assert(v.getOwnershipKind() == ValueOwnershipKind::Guaranteed);
   }
 
   /// If value is a borrow introducer return it after doing some checks.
   static Optional<BorrowScopeIntroducingValue> get(SILValue value) {
-    auto kind = BorrowScopeIntroducerKind::get(value->getKind());
+    auto kind = BorrowScopeIntroducingValueKind::get(value->getKind());
     if (!kind || value.getOwnershipKind() != ValueOwnershipKind::Guaranteed)
       return None;
     return BorrowScopeIntroducingValue(*kind, value);
@@ -334,7 +413,8 @@ struct BorrowScopeIntroducingValue {
 private:
   /// Internal constructor for failable static constructor. Please do not expand
   /// its usage since it assumes the code passed in is well formed.
-  BorrowScopeIntroducingValue(BorrowScopeIntroducerKind kind, SILValue value)
+  BorrowScopeIntroducingValue(BorrowScopeIntroducingValueKind kind,
+                              SILValue value)
       : kind(kind), value(value) {}
 };
 

branches/master-next/lib/SIL/OwnershipUtils.cpp

@@ -81,22 +81,22 @@ bool swift::isOwnershipForwardingInst(SILInstruction *i) {
 //                             Borrow Introducers
 //===----------------------------------------------------------------------===//
 
-void BorrowScopeIntroducerKind::print(llvm::raw_ostream &os) const {
+void BorrowScopeIntroducingValueKind::print(llvm::raw_ostream &os) const {
   switch (value) {
-  case BorrowScopeIntroducerKind::SILFunctionArgument:
+  case BorrowScopeIntroducingValueKind::SILFunctionArgument:
     os << "SILFunctionArgument";
     return;
-  case BorrowScopeIntroducerKind::BeginBorrow:
+  case BorrowScopeIntroducingValueKind::BeginBorrow:
     os << "BeginBorrowInst";
     return;
-  case BorrowScopeIntroducerKind::LoadBorrow:
+  case BorrowScopeIntroducingValueKind::LoadBorrow:
     os << "LoadBorrowInst";
     return;
   }
   llvm_unreachable("Covered switch isn't covered?!");
 }
 
-void BorrowScopeIntroducerKind::dump() const {
+void BorrowScopeIntroducingValueKind::dump() const {
 #ifndef NDEBUG
   print(llvm::dbgs());
 #endif
@@ -107,13 +107,13 @@ void BorrowScopeIntroducingValue::getLocalScopeEndingInstructions(
   assert(isLocalScope() && "Should only call this given a local scope");
 
   switch (kind) {
-  case BorrowScopeIntroducerKind::SILFunctionArgument:
+  case BorrowScopeIntroducingValueKind::SILFunctionArgument:
     llvm_unreachable("Should only call this with a local scope");
-  case BorrowScopeIntroducerKind::BeginBorrow:
+  case BorrowScopeIntroducingValueKind::BeginBorrow:
     llvm::copy(cast<BeginBorrowInst>(value)->getEndBorrows(),
                std::back_inserter(scopeEndingInsts));
     return;
-  case BorrowScopeIntroducerKind::LoadBorrow:
+  case BorrowScopeIntroducingValueKind::LoadBorrow:
     llvm::copy(cast<LoadBorrowInst>(value)->getEndBorrows(),
                std::back_inserter(scopeEndingInsts));
     return;
@@ -125,17 +125,17 @@ void BorrowScopeIntroducingValue::visitLocalScopeEndingUses(
     function_ref<void(Operand *)> visitor) const {
   assert(isLocalScope() && "Should only call this given a local scope");
   switch (kind) {
-  case BorrowScopeIntroducerKind::SILFunctionArgument:
+  case BorrowScopeIntroducingValueKind::SILFunctionArgument:
     llvm_unreachable("Should only call this with a local scope");
-  case BorrowScopeIntroducerKind::BeginBorrow:
-    for (auto *use : cast<BeginBorrowInst>(value)->getUses()) {
+  case BorrowScopeIntroducingValueKind::BeginBorrow:
+    for (auto *use : value->getUses()) {
       if (isa<EndBorrowInst>(use->getUser())) {
         visitor(use);
       }
     }
     return;
-  case BorrowScopeIntroducerKind::LoadBorrow:
-    for (auto *use : cast<LoadBorrowInst>(value)->getUses()) {
+  case BorrowScopeIntroducingValueKind::LoadBorrow:
+    for (auto *use : value->getUses()) {
       if (isa<EndBorrowInst>(use->getUser())) {
         visitor(use);
       }
@@ -182,7 +182,7 @@ bool swift::getUnderlyingBorrowIntroducingValues(
 }
 
 llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
-                                     BorrowScopeIntroducerKind kind) {
+                                     BorrowScopeIntroducingValueKind kind) {
   kind.print(os);
   return os;
 }

branches/master-next/lib/SIL/SILOwnershipVerifier.cpp

@@ -278,14 +278,10 @@ bool SILValueOwnershipChecker::gatherUsers(
         // For correctness reasons we use indices to make sure that we can
         // append to NonLifetimeEndingUsers without needing to deal with
         // iterator invalidation.
-        for (unsigned i : indices(nonLifetimeEndingUsers)) {
-          if (auto *bbi = dyn_cast<BeginBorrowInst>(
-                  nonLifetimeEndingUsers[i]->getUser())) {
-            for (auto *use : bbi->getUses()) {
-              if (isa<EndBorrowInst>(use->getUser())) {
-                implicitRegularUsers.push_back(use);
-              }
-            }
+        for (auto *op : nonLifetimeEndingUsers) {
+          if (auto scopedOperand = BorrowScopeOperand::get(op)) {
+            scopedOperand->visitEndScopeInstructions(
+                [&](Operand *op) { implicitRegularUsers.push_back(op); });
           }
         }
       }