---

yaml
---
r: 349204
b: refs/heads/master-next
c: 02b5e56
h: refs/heads/master

Author: jckarter

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 8c4df3b4c24f4d6f2ffec16f026fcec0605a5c2a
+refs/heads/master-next: 02b5e5632785f06c149850a9754474840bae1d0c
 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/ASTTypeIDs.h

@@ -21,6 +21,8 @@
 #include "swift/Basic/TypeID.h"
 namespace swift {
 
+class AbstractFunctionDecl;
+class BraceStmt;
 class CustomAttr;
 class Decl;
 class GenericParamList;

branches/master-next/include/swift/AST/Decl.h

@@ -6329,9 +6329,7 @@ class EnumElementDecl : public DeclContext, public ValueDecl {
 
   /// The raw value literal for the enum element, or null.
   LiteralExpr *RawValueExpr;
-  /// The type-checked raw value expression.
-  Expr *TypeCheckedRawValueExpr = nullptr;
-  
+
 public:
   EnumElementDecl(SourceLoc IdentifierLoc, DeclName Name,
                   ParameterList *Params,
@@ -6364,13 +6362,6 @@ class EnumElementDecl : public DeclContext, public ValueDecl {
   bool hasRawValueExpr() const { return RawValueExpr; }
   LiteralExpr *getRawValueExpr() const { return RawValueExpr; }
   void setRawValueExpr(LiteralExpr *e) { RawValueExpr = e; }
-  
-  Expr *getTypeCheckedRawValueExpr() const {
-    return TypeCheckedRawValueExpr;
-  }
-  void setTypeCheckedRawValueExpr(Expr *e) {
-    TypeCheckedRawValueExpr = e;
-  }
 
   /// Return the containing EnumDecl.
   EnumDecl *getParentEnum() const {

branches/master-next/include/swift/AST/DiagnosticEngine.h

@@ -18,15 +18,16 @@
 #ifndef SWIFT_BASIC_DIAGNOSTICENGINE_H
 #define SWIFT_BASIC_DIAGNOSTICENGINE_H
 
-#include "swift/AST/Attr.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/DeclNameLoc.h"
 #include "swift/AST/DiagnosticConsumer.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace swift {
   class Decl;
+  class DeclAttribute;
   class DiagnosticEngine;
   class SourceManager;
   class ValueDecl;

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/AST/Expr.h

@@ -19,13 +19,13 @@
 
 #include "swift/AST/CaptureInfo.h"
 #include "swift/AST/ConcreteDeclRef.h"
+#include "swift/AST/DeclContext.h"
 #include "swift/AST/DeclNameLoc.h"
 #include "swift/AST/FunctionRefKind.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/TrailingCallArguments.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeLoc.h"
-#include "swift/AST/TypeRepr.h"
 #include "swift/AST/Availability.h"
 #include "swift/Basic/InlineBitfield.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -40,7 +40,9 @@ namespace swift {
   class ArchetypeType;
   class ASTContext;
   class AvailabilitySpec;
+  class IdentTypeRepr;
   class Type;
+  class TypeRepr;
   class ValueDecl;
   class Decl;
   class DeclRefExpr;

branches/master-next/include/swift/Parse/ASTGen.h

@@ -21,6 +21,9 @@
 #include "llvm/ADT/DenseMap.h"
 
 namespace swift {
+class ComponentIdentTypeRepr;
+class TupleTypeRepr;
+
 /// Generates AST nodes from Syntax nodes.
 class Parser;
 class ASTGen {

branches/master-next/include/swift/Remote/MetadataReader.h

@@ -794,7 +794,7 @@ class MetadataReader {
       baseSize = sizeof(TargetAnonymousContextDescriptor<Runtime>);
       if (AnonymousContextDescriptorFlags(flags.getKindSpecificFlags())
             .hasMangledName()) {
-        baseSize += sizeof(TargetMangledContextName<Runtime>);
+        metadataInitSize = sizeof(TargetMangledContextName<Runtime>);
       }
       break;
     case ContextDescriptorKind::Class:

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/include/swift/SIL/Projection.h

@@ -22,11 +22,12 @@
 #ifndef SWIFT_SIL_PROJECTION_H
 #define SWIFT_SIL_PROJECTION_H
 
+#include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/NullablePtr.h"
 #include "swift/Basic/PointerIntEnum.h"
-#include "swift/AST/TypeAlignments.h"
-#include "swift/SIL/SILValue.h"
+#include "swift/Basic/STLExtras.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILValue.h"
 #include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
 #include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
 #include "llvm/ADT/Hashing.h"
@@ -751,15 +752,17 @@ class ProjectionTreeNode {
   ~ProjectionTreeNode() = default;
   ProjectionTreeNode(const ProjectionTreeNode &) = default;
 
-  llvm::ArrayRef<unsigned> getChildProjections() {
-     return llvm::makeArrayRef(ChildProjections);
+  bool isLeaf() const { return ChildProjections.empty(); }
+
+  ArrayRef<unsigned> getChildProjections() const {
+    return llvm::makeArrayRef(ChildProjections);
   }
 
-  llvm::Optional<Projection> &getProjection() { return Proj; }
+  Optional<Projection> &getProjection() { return Proj; }
 
-  llvm::SmallVector<Operand *, 4> getNonProjUsers() const {
-    return NonProjUsers;
-  };
+  const ArrayRef<Operand *> getNonProjUsers() const {
+    return llvm::makeArrayRef(NonProjUsers);
+  }
 
   SILType getType() const { return NodeType; }
 
@@ -914,6 +917,24 @@ class ProjectionTree {
     return false;
   }
 
+  void getAllLeafTypes(llvm::SmallVectorImpl<SILType> &outArray) const {
+    llvm::SmallVector<const ProjectionTreeNode *, 32> worklist;
+    worklist.push_back(getRoot());
+
+    while (!worklist.empty()) {
+      auto *node = worklist.pop_back_val();
+      // If we have a leaf node, add its type.
+      if (node->isLeaf()) {
+        outArray.push_back(node->getType());
+        continue;
+      }
+
+      // Otherwise, add the nodes children to the worklist.
+      transform(node->getChildProjections(), std::back_inserter(worklist),
+                [&](unsigned idx) { return getNode(idx); });
+    }
+  }
+
   void getLiveLeafTypes(llvm::SmallVectorImpl<SILType> &OutArray) const {
     for (unsigned LeafIndex : LiveLeafIndices) {
       const ProjectionTreeNode *Node = getNode(LeafIndex);
@@ -940,7 +961,9 @@ class ProjectionTree {
   void
   replaceValueUsesWithLeafUses(SILBuilder &B, SILLocation Loc,
                                llvm::SmallVectorImpl<SILValue> &Leafs);
- 
+
+  void getUsers(SmallPtrSetImpl<SILInstruction *> &users) const;
+
 private:
   void createRoot(SILType BaseTy) {
     assert(ProjectionTreeNodes.empty() &&