---

yaml
---
r: 349094
b: refs/heads/master
c: d90117b
h: refs/heads/master

Author: xedin

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9a4abf47a450aeff6a3231225fd2cf18cc7a940a
+refs/heads/master: d90117bb8a7e953e080fbb3f6d22e5502e7aa51b
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/benchmark/scripts/run_smoke_bench

@@ -93,10 +93,6 @@ def main():
     argparser.add_argument(
         '-num-samples', type=int,
         help='The (minimum) number of samples to run', default=3)
-    argparser.add_argument(
-        '-num-reruns', type=int,
-        help="The number of re-runs until it's assumed to be a real change",
-        default=8)
     argparser.add_argument(
         '-platform', type=str,
         help='The benchmark build platform', default='macosx')
@@ -124,7 +120,7 @@ def test_opt_levels(args):
             if test_performance(opt_level, args.oldbuilddir[0],
                                 args.newbuilddir[0],
                                 float(args.threshold) / 100, args.num_samples,
-                                args.num_reruns, output_file):
+                                output_file):
                 changes = True
 
         # There is no point in reporting code size for Onone.
@@ -175,7 +171,7 @@ def merge(results, other_results):
 
 
 def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
-                     num_reruns, output_file):
+                     output_file):
     """Detect performance changes in benchmarks.
 
     Start fast with few samples per benchmark and gradually spend more time
@@ -189,7 +185,7 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
     tests = TestComparator(results[0], results[1], threshold)
     changed = tests.decreased + tests.increased
 
-    while len(changed) > 0 and unchanged_length_count < num_reruns:
+    while len(changed) > 0 and unchanged_length_count < 10:
         i += 1
         if VERBOSE:
             log('        test again: ' + str([test.name for test in changed]))

trunk/include/swift/SIL/MemoryLifetime.h

@@ -22,16 +22,6 @@
 
 namespace swift {
 
-void printBitsAsArray(llvm::raw_ostream &OS, const SmallBitVector &bits);
-
-inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
-                                     const SmallBitVector &bits) {
-  printBitsAsArray(OS, bits);
-  return OS;
-}
-
-void dumpBits(const SmallBitVector &bits);
-
 /// The MemoryLocations utility provides functions to analyze memory locations.
 ///
 /// Memory locations are limited to addresses which are guaranteed to

trunk/lib/IRGen/GenCast.cpp

@@ -638,12 +638,8 @@ void irgen::emitScalarExistentialDowncast(IRGenFunction &IGF,
   bool checkSuperclassConstraint = false;
   if (hasSuperclassConstraint) {
     Type srcSuperclassType = srcInstanceType;
-    if (srcSuperclassType->isExistentialType()) {
+    if (srcSuperclassType->isExistentialType())
       srcSuperclassType = srcSuperclassType->getSuperclass();
-      // Look for an AnyObject superclass (getSuperclass() returns nil).
-      if (!srcSuperclassType && srcInstanceType->isClassExistentialType())
-        checkSuperclassConstraint = true;
-    }
     if (srcSuperclassType) {
       checkSuperclassConstraint =
         !destInstanceType->getSuperclass()->isExactSuperclassOf(

trunk/lib/SIL/MemoryLifetime.cpp

@@ -28,28 +28,26 @@ llvm::cl::opt<bool> DontAbortOnMemoryLifetimeErrors(
     llvm::cl::desc("Don't abort compliation if the memory lifetime checker "
                    "detects an error."));
 
+namespace swift {
+namespace {
+
+//===----------------------------------------------------------------------===//
+//                            Utility functions
+//===----------------------------------------------------------------------===//
+
 /// Debug dump a location bit vector.
-void swift::printBitsAsArray(llvm::raw_ostream &OS, const SmallBitVector &bits) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                              const SmallBitVector &bits) {
   const char *separator = "";
   OS << '[';
   for (int idx = bits.find_first(); idx >= 0; idx = bits.find_next(idx)) {
     OS << separator << idx;
     separator = ",";
   }
   OS << ']';
+  return OS;
 }
 
-void swift::dumpBits(const SmallBitVector &bits) {
-  llvm::dbgs() << bits << '\n';
-}
-
-namespace swift {
-namespace {
-
-//===----------------------------------------------------------------------===//
-//                            Utility functions
-//===----------------------------------------------------------------------===//
-
 /// Enlarge the bitset if needed to set the bit with \p idx.
 static void setBitAndResize(SmallBitVector &bits, unsigned idx) {
   if (bits.size() <= idx)
@@ -242,6 +240,10 @@ void MemoryLocations::dump() const {
   }
 }
 
+void MemoryLocations::dumpBits(const Bits &bits) {
+  llvm::errs() << bits << '\n';
+}
+
 void MemoryLocations::clear() {
   locations.clear();
   addr2LocIdx.clear();

trunk/lib/SILOptimizer/Transforms/DeadStoreElimination.cpp

@@ -60,7 +60,6 @@
 #include "swift/SIL/Projection.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
-#include "swift/SIL/MemoryLifetime.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
@@ -270,8 +269,6 @@ class BlockState {
     init(LocationNum, Optimistic);
   }
 
-  void dump();
-
   /// Initialize the bitvectors for the current basic block.
   void init(unsigned LocationNum, bool Optimistic);
 
@@ -451,8 +448,6 @@ enum class ProcessKind {
              llvm::SpecificBumpPtrAllocator<BlockState> &BPA) 
     : Mod(M), F(F), PM(PM), AA(AA), TE(TE), EAFI(EAFI), BPA(BPA) {}
 
-  void dump();
-
   /// Entry point for dead store elimination.
   bool run();
 
@@ -486,12 +481,6 @@ enum class ProcessKind {
 
 } // end anonymous namespace
 
-void BlockState::dump() {
-  llvm::dbgs() << "  block " << BB->getDebugID() << ": in=" << BBWriteSetIn
-               << ", out=" << BBWriteSetOut << ", mid=" << BBWriteSetMid
-               << ", gen=" << BBGenSet << ", kill=" << BBKillSet << '\n';
-}
-
 void BlockState::init(unsigned LocationNum, bool Optimistic) {
   // For function that requires just 1 iteration of the data flow to converge
   // we set the initial state of BBWriteSetIn to 0.
@@ -524,21 +513,6 @@ void BlockState::init(unsigned LocationNum, bool Optimistic) {
   BBDeallocateLocation.resize(LocationNum, false);
 }
 
-#if __has_attribute(used)
-__attribute((used))
-#endif
-void DSEContext::dump() {
-  llvm::dbgs() << "Locations:\n";
-  unsigned idx = 0;
-  for (const LSLocation &loc : LocationVault) {
-    llvm::dbgs() << "  #" << idx << ": " << loc.getBase();
-    ++idx;
-  }
-  for (SILBasicBlock &BB : *F) {
-    getBlockState(&BB)->dump();
-  }
-}
-
 unsigned DSEContext::getLocationBit(const LSLocation &Loc) {
   // Return the bit position of the given Loc in the LocationVault. The bit
   // position is then used to set/reset the bitvector kept by each BlockState.
@@ -717,10 +691,6 @@ void DSEContext::mergeSuccessorLiveIns(SILBasicBlock *BB) {
   // dead for block with no successor.
   BlockState *C = getBlockState(BB);
   if (BB->succ_empty()) {
-    if (isa<UnreachableInst>(BB->getTerminator())) {
-      C->BBWriteSetOut.set();
-      return;
-    }
     C->BBWriteSetOut |= C->BBDeallocateLocation;
     return;
   }

trunk/lib/Sema/CSDiagnostics.cpp

@@ -542,26 +542,11 @@ void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
 
 bool MissingConformanceFailure::diagnoseAsError() {
   auto *anchor = getAnchor();
-  auto ownerType = getOwnerType();
   auto nonConformingType = getLHS();
   auto protocolType = getRHS();
 
-  auto getArgumentAt = [](const ApplyExpr *AE, unsigned index) -> Expr * {
-    assert(AE);
-
-    auto *arg = AE->getArg();
-    if (auto *TE = dyn_cast<TupleExpr>(arg))
-      return TE->getElement(index);
-
-    assert(index == 0);
-    if (auto *PE = dyn_cast<ParenExpr>(arg))
-      return PE->getSubExpr();
-
-    return arg;
-  };
-
   // If this is a requirement of a pattern-matching operator,
-  // let's see whether argument is already has a fix associated
+  // let's see whether argument already has a fix associated
   // with it and if so skip conformance error, otherwise we'd
   // produce an unrelated `<type> doesn't conform to Equatable protocol`
   // diagnostic.
@@ -588,43 +573,14 @@ bool MissingConformanceFailure::diagnoseAsError() {
   if (diagnoseAsAmbiguousOperatorRef())
     return true;
 
-  Optional<unsigned> atParameterPos;
-  // Sometimes fix is recorded by type-checking sub-expression
-  // during normal diagnostics, in such case call expression
-  // is unavailable.
-  if (Apply) {
-    if (auto *fnType = ownerType->getAs<AnyFunctionType>()) {
-      auto parameters = fnType->getParams();
-      for (auto index : indices(parameters)) {
-        if (parameters[index].getOldType()->isEqual(nonConformingType)) {
-          atParameterPos = index;
-          break;
-        }
-      }
-    }
-  }
-
   if (nonConformingType->isObjCExistentialType()) {
     emitDiagnostic(anchor->getLoc(), diag::protocol_does_not_conform_static,
                    nonConformingType, protocolType);
     return true;
   }
 
-  if (diagnoseTypeCannotConform((atParameterPos ?
-                                getArgumentAt(Apply, *atParameterPos) : anchor),
-                                nonConformingType, protocolType)) {
-      return true;
-  }
-
-  if (atParameterPos) {
-    // Requirement comes from one of the parameter types,
-    // let's try to point diagnostic to the argument expression.
-    auto *argExpr = getArgumentAt(Apply, *atParameterPos);
-    emitDiagnostic(argExpr->getLoc(),
-                   diag::cannot_convert_argument_value_protocol,
-                   nonConformingType, protocolType);
+  if (diagnoseTypeCannotConform(anchor, nonConformingType, protocolType))
     return true;
-  }
 
   // If none of the special cases could be diagnosed,
   // let's fallback to the most general diagnostic.

trunk/test/ClangImporter/newtype_conformance.swift

@@ -13,12 +13,15 @@ import MoreSwiftNewtypes
 
 func acceptEquatable<T: Equatable>(_: T) {}
 func acceptHashable<T: Hashable>(_: T) {}
+// expected-note@-1 {{where 'T' = 'WrappedRef'}}
+// expected-note@-2 {{where 'T' = 'WrappedValue'}}
 func acceptComparable<T: Comparable>(_: T) {}
+// expected-note@-1 {{where 'T' = 'NSNotification.Name'}}
 
 func testNewTypeWrapper(x: NSNotification.Name, y: NSNotification.Name) {
   acceptEquatable(x)
   acceptHashable(x)
-  acceptComparable(x) // expected-error {{does not conform to expected type 'Comparable'}}
+  acceptComparable(x) // expected-error {{global function 'acceptComparable' requires that 'NSNotification.Name' conform to 'Comparable'}}
 
   _ = x == y
   _ = x != y
@@ -30,6 +33,6 @@ func testNewTypeWrapper(x: NSNotification.Name, y: NSNotification.Name) {
 func testCustomWrappers(wrappedRef: WrappedRef, wrappedValue: WrappedValue) {
   acceptEquatable(wrappedRef)
   acceptEquatable(wrappedValue)
-  acceptHashable(wrappedRef) // expected-error {{does not conform to expected type 'Hashable'}}
-  acceptHashable(wrappedValue) // expected-error {{does not conform to expected type 'Hashable'}}
+  acceptHashable(wrappedRef) // expected-error {{global function 'acceptHashable' requires that 'WrappedRef' conform to 'Hashable'}}
+  acceptHashable(wrappedValue) // expected-error {{global function 'acceptHashable' requires that 'WrappedValue' conform to 'Hashable'}}
 }

trunk/test/Constraints/diagnostics.swift

@@ -31,6 +31,7 @@ func f5<T : P2>(_ : T) { }
 // expected-note@-1 {{required by global function 'f5' where 'T' = '(Int) -> Int'}}
 // expected-note@-2 {{required by global function 'f5' where 'T' = '(Int, String)'}}
 // expected-note@-3 {{required by global function 'f5' where 'T' = 'Int.Type'}}
+// expected-note@-4 {{where 'T' = 'Int'}}
 
 func f6<T : P, U : P>(_ t: T, _ u: U) where T.SomeType == U.SomeType {}
 
@@ -75,10 +76,10 @@ i.wobble() // expected-error{{value of type 'Int' has no member 'wobble'}}
 
 // Generic member does not conform.
 extension Int {
-  func wibble<T: P2>(_ x: T, _ y: T) -> T { return x }
+  func wibble<T: P2>(_ x: T, _ y: T) -> T { return x } // expected-note {{where 'T' = 'Int'}}
   func wubble<T>(_ x: (Int) -> T) -> T { return x(self) }
 }
-i.wibble(3, 4) // expected-error {{argument type 'Int' does not conform to expected type 'P2'}}
+i.wibble(3, 4) // expected-error {{instance method 'wibble' requires that 'Int' conform to 'P2'}}
 
 // Generic member args correct, but return type doesn't match.
 struct A : P2 {
@@ -98,9 +99,9 @@ func f7() -> (c: Int, v: A) {
   return f6(g) // expected-error {{cannot convert return expression of type '(c: Int, i: A)' to return type '(c: Int, v: A)'}}
 }
 
-func f8<T:P2>(_ n: T, _ f: @escaping (T) -> T) {}
+func f8<T:P2>(_ n: T, _ f: @escaping (T) -> T) {}  // expected-note {{where 'T' = 'Int'}}
 // expected-note@-1 {{required by global function 'f8' where 'T' = 'Tup' (aka '(Int, Double)')}}
-f8(3, f4) // expected-error {{argument type 'Int' does not conform to expected type 'P2'}}
+f8(3, f4) // expected-error {{global function 'f8' requires that 'Int' conform to 'P2'}}
 typealias Tup = (Int, Double)
 func f9(_ x: Tup) -> Tup { return x }
 f8((1,2.0), f9) // expected-error {{type 'Tup' (aka '(Int, Double)') cannot conform to 'P2'; only struct/enum/class types can conform to protocols}}
@@ -111,7 +112,7 @@ f8((1,2.0), f9) // expected-error {{type 'Tup' (aka '(Int, Double)') cannot conf
 "awfawf".doesntExist(0)   // expected-error {{value of type 'String' has no member 'doesntExist'}}
 
 // Does not conform to protocol.
-f5(i)  // expected-error {{argument type 'Int' does not conform to expected type 'P2'}}
+f5(i)  // expected-error {{global function 'f5' requires that 'Int' conform to 'P2'}}
 
 // Make sure we don't leave open existentials when diagnosing.
 // <rdar://problem/20598568>

trunk/test/Constraints/generics.swift

@@ -2,7 +2,7 @@
 
 infix operator +++
 
-protocol ConcatToAnything {
+protocol ConcatToAnything { // expected-note {{where 'Self' = 'U'}}
   static func +++ <T>(lhs: Self, other: T)
 }
 
@@ -14,7 +14,7 @@ func min<T : Comparable>(_ x: T, y: T) -> T {
 func weirdConcat<T : ConcatToAnything, U>(_ t: T, u: U) {
   t +++ u
   t +++ 1
-  u +++ t // expected-error{{argument type 'U' does not conform to expected type 'ConcatToAnything'}}
+  u +++ t // expected-error{{referencing operator function '+++' on 'ConcatToAnything' requires that 'U' conform to 'ConcatToAnything'}}
 }
 
 // Make sure that the protocol operators don't get in the way.
@@ -647,7 +647,7 @@ struct BottleLayout {
 }
 let arr = [BottleLayout]()
 let layout = BottleLayout(count:1)
-let ix = arr.firstIndex(of:layout) // expected-error {{argument type 'BottleLayout' does not conform to expected type 'Equatable'}}
+let ix = arr.firstIndex(of:layout) // expected-error {{referencing instance method 'firstIndex(of:)' on 'Collection' requires that 'BottleLayout' conform to 'Equatable'}}
 
 let _: () -> UInt8 = { .init("a" as Unicode.Scalar) } // expected-error {{missing argument label 'ascii:' in call}}
 

trunk/test/Constraints/protocols.swift

@@ -414,3 +414,10 @@ func rdar_50512161() {
     foo(item: item) // expected-error {{generic parameter 'I' could not be inferred}}
   }
 }
+
+// SR-11609: Compiler crash on missing conformance for default param
+func test_sr_11609() {
+  func foo<T : Initable>(_ x: T = .init()) -> T { x } // expected-note {{where 'T' = 'String'}}
+  let _: String = foo()
+  // expected-error@-1 {{local function 'foo' requires that 'String' conform to 'Initable'}}
+}

trunk/test/Constraints/rdar40002266.swift

@@ -6,6 +6,6 @@ import Foundation
 struct S {
   init<T: NSNumber>(_ num: T) { // expected-note {{where 'T' = 'Bool'}}
     self.init(num != 0) // expected-error {{initializer 'init(_:)' requires that 'Bool' inherit from 'NSNumber'}}
-    // expected-error@-1 {{argument type 'T' does not conform to expected type 'BinaryInteger'}}
+    // expected-error@-1 {{referencing operator function '!=' on 'BinaryInteger' requires that 'T' conform to 'BinaryInteger'}}
   }
 }

trunk/test/Constraints/tuple.swift

@@ -181,7 +181,7 @@ variadicWithTrailingClosure(fn: +)
 func gcd_23700031<T>(_ a: T, b: T) {
   var a = a
   var b = b
-  (a, b) = (b, a % b)  // expected-error {{argument type 'T' does not conform to expected type 'BinaryInteger'}}
+  (a, b) = (b, a % b)  // expected-error {{protocol 'BinaryInteger' requires that 'T' conform to 'BinaryInteger'}}
 }
 
 // <rdar://problem/24210190>