From f4e946c460b031923cbb24f3c3eb8ba709ed7979 Mon Sep 17 00:00:00 2001
From: Davide Italiano <dccitaliano@gmail.com>
Date: Mon, 7 Dec 2015 05:04:07 +0000
Subject: [PATCH 01/15] [Sema] Fix errors due to implicitly deleted copy
 constructor.

---
 include/swift/Sema/TypeCheckRequest.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/swift/Sema/TypeCheckRequest.h b/include/swift/Sema/TypeCheckRequest.h
index b5767e54cf93b..880d5da1b2c3b 100644
--- a/include/swift/Sema/TypeCheckRequest.h
+++ b/include/swift/Sema/TypeCheckRequest.h
@@ -70,6 +70,7 @@ class TypeCheckRequest {
   /// The payload of the request, which differs based on the request kind.
   union PayloadType {
     PayloadType() { }
+    PayloadType(const PayloadType &) {}
 
 #define TYPE_CHECK_REQUEST_PAYLOAD(PayloadName,...) \
     __VA_ARGS__ PayloadName;

From 9211c7c0d484e2ebe9435d7b1f2510c43644d1e5 Mon Sep 17 00:00:00 2001
From: gregomni <gregomni@gmail.com>
Date: Thu, 10 Dec 2015 23:26:18 -0800
Subject: [PATCH 02/15] Better diagnose error coming from unwrapping optional
 before initialized.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Added a check for whether the escape use is due to an
UncheckedTakeEnumDataAddrInst, which accesses the memory to grab the
.Some part of an Optional during “?.” or “!”. In that case, use the
generic used-before-initialized diagnostic, since it isn’t actually
because of closure capture.

Added test cases, including specifically testing that capturing in a
closure in order to unwrap the optional is still ok.
---
 lib/SILPasses/EarlySIL/DefiniteInitialization.cpp |  2 ++
 test/SILPasses/definite_init_diagnostics.swift    | 12 ++++++++++++
 2 files changed, 14 insertions(+)

diff --git a/lib/SILPasses/EarlySIL/DefiniteInitialization.cpp b/lib/SILPasses/EarlySIL/DefiniteInitialization.cpp
index f7e3dcd726ec2..8f8af66121c17 100644
--- a/lib/SILPasses/EarlySIL/DefiniteInitialization.cpp
+++ b/lib/SILPasses/EarlySIL/DefiniteInitialization.cpp
@@ -1094,6 +1094,8 @@ void LifetimeChecker::handleEscapeUse(const DIMemoryUse &Use) {
       DiagMessage = diag::variable_closure_use_uninit;
     else
       DiagMessage = diag::variable_function_use_uninit;
+  } else if (isa<UncheckedTakeEnumDataAddrInst>(Inst)) {
+    DiagMessage = diag::variable_used_before_initialized;
   } else {
     DiagMessage = diag::variable_closure_use_uninit;
   }
diff --git a/test/SILPasses/definite_init_diagnostics.swift b/test/SILPasses/definite_init_diagnostics.swift
index ad03ad2515952..96703d07ed66a 100644
--- a/test/SILPasses/definite_init_diagnostics.swift
+++ b/test/SILPasses/definite_init_diagnostics.swift
@@ -78,6 +78,12 @@ func test2() {
   takes_closure {     // ok.
     markUsed(b3)
   }
+    
+  var b4 : Int?
+  takes_closure {     // ok.
+    markUsed(b4!)
+  }
+  b4 = 7
 
   // Structs
   var s1 : SomeStruct
@@ -1184,3 +1190,9 @@ func test22436880() {
   x = 1
   bug22436880(&x) // expected-error {{immutable value 'x' may not be passed inout}}
 }
+
+// sr-184
+let x: String? // expected-note 2 {{constant defined here}}
+print(x?.characters.count) // expected-error {{constant 'x' used before being initialized}}
+print(x!) // expected-error {{constant 'x' used before being initialized}}
+

From e799d3e93e11f8971860f1a41c7d04e3511f4af8 Mon Sep 17 00:00:00 2001
From: Justas Brazauskas <brazauskasjustas@gmail.com>
Date: Fri, 11 Dec 2015 10:58:23 +0200
Subject: [PATCH 03/15] Fix typos

---
 CHANGELOG.md                       | 14 +++++++-------
 docs/doxygen.css                   |  4 ++--
 include/swift/SIL/SILInstruction.h |  2 +-
 lib/AST/ArchetypeBuilder.cpp       |  2 +-
 lib/AST/ConformanceLookupTable.cpp |  2 +-
 lib/AST/Verifier.cpp               |  2 +-
 utils/swift-bench.py               |  2 +-
 7 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c303495af990b..fc79f27731e14 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2891,7 +2891,7 @@ Latest
     @_silgen_name("foo") @objc
     ```
 
-  The `,` was vestigial when the attribute syntax consisted of bracked lists.
+  The `,` was vestigial when the attribute syntax consisted of bracket lists.
 
 * `switch` now always requires a statement after a `case` or `default`.
 
@@ -3106,7 +3106,7 @@ Latest
   inference (e.g. when passing a function argument).
 
 * Properties defined in classes are now dynamically dispatched and can be
-  overriden with `@override`.  Currently `@override` only works with computed properties
+  overridden with `@override`.  Currently `@override` only works with computed properties
   overriding other computed properties, but this will be enhanced in coming weeks.
 
 
@@ -3190,7 +3190,7 @@ Latest
     ```
 
 * The compiler now warns about cases where a variable is inferred to have
-  `AnyObject`, `AnyClass`, or `()` type, since type inferrence can turn a simple
+  `AnyObject`, `AnyClass`, or `()` type, since type inference can turn a simple
   mistake (e.g. failing to cast an `AnyObject` when you meant to) into something
   with ripple effects.  Here is a simple example:
 
@@ -3386,7 +3386,7 @@ Latest
   `#if` block.
 
   Target configurations are tested against their values via a pseudo-function
-  invocation expression, taking a single argument expressed as an identitifer.
+  invocation expression, taking a single argument expressed as an identifier.
   The argument represents certain static build-time information.
 
   There are currently two supported target configurations:
@@ -4708,7 +4708,7 @@ Latest
     ```
 
 * Attribute syntax has been redesigned (see **(rdar://10700853)** and
-  **(rdar://14462729)**) so that attributes now preceed the declaration and use
+  **(rdar://14462729)**) so that attributes now precede the declaration and use
   the `@` character to signify them.  Where before you might have written:
 
     ```swift
@@ -4830,7 +4830,7 @@ Latest
     ```
 
   checks whether `object` has a value and, if so, asks for the length of
-  its title.  `titleLength` wil have type `Int?`, and if `object` was
+  its title.  `titleLength` will have type `Int?`, and if `object` was
   missing, the variable will be initialized to None.
 
 * Objects with type `id` can now be used as the receiver of property
@@ -5293,5 +5293,5 @@ Latest
 
 * `POSIX.EnvironmentVariables` and `swift.CommandLineArguments` global variables
   were merged into a `swift.Process` variable.  Now you can access command line
-  arguments with `Process.arguments`.  In order to acces environment variables
+  arguments with `Process.arguments`.  In order to access environment variables
   add `import POSIX` and use `Process.environmentVariables`.
diff --git a/docs/doxygen.css b/docs/doxygen.css
index 83951f673db8d..d5691ed7e62d1 100644
--- a/docs/doxygen.css
+++ b/docs/doxygen.css
@@ -313,8 +313,8 @@ HR { height: 1px;
 
 /* 
  * LLVM Modifications.
- * Note: Everything above here is generated with "doxygen -w htlm" command. See
- * "doxygen --help" for details. What follows are CSS overrides for LLVM 
+ * Note: Everything above here is generated with "doxygen -w html" command. See
+ * "doxygen --help" for details. What follows are CSS overrides for LLVM
  * specific formatting. We want to keep the above so it can be replaced with
  * subsequent doxygen upgrades.
  */
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
index f5fff6a3514e6..505af2a7926a9 100644
--- a/include/swift/SIL/SILInstruction.h
+++ b/include/swift/SIL/SILInstruction.h
@@ -864,7 +864,7 @@ class ApplyInst : public ApplyInstBase<ApplyInst, SILInstruction> {
     return V->getKind() == ValueKind::ApplyInst;
   }
   
-  /// Returns true if the called function has an error result but is not actully
+  /// Returns true if the called function has an error result but is not actually
   /// throwing an error.
   bool isNonThrowing() const {
     return isNonThrowingApply();
diff --git a/lib/AST/ArchetypeBuilder.cpp b/lib/AST/ArchetypeBuilder.cpp
index fe7aafddc3f21..f3305d27e3c48 100644
--- a/lib/AST/ArchetypeBuilder.cpp
+++ b/lib/AST/ArchetypeBuilder.cpp
@@ -854,7 +854,7 @@ bool ArchetypeBuilder::addSameTypeRequirementBetweenArchetypes(
   T1 = T1->getRepresentative();
   T2 = T2->getRepresentative();
 
-  // If the representives are already the same, we're done.
+  // If the representatives are already the same, we're done.
   if (T1 == T2)
     return false;
 
diff --git a/lib/AST/ConformanceLookupTable.cpp b/lib/AST/ConformanceLookupTable.cpp
index e109506048cf4..a063ac5977c9a 100644
--- a/lib/AST/ConformanceLookupTable.cpp
+++ b/lib/AST/ConformanceLookupTable.cpp
@@ -543,7 +543,7 @@ ConformanceLookupTable::Ordering ConformanceLookupTable::compareConformances(
                                    bool &diagnoseSuperseded) {
   // If one entry is fixed and the other is not, we have our answer.
   if (lhs->isFixed() != rhs->isFixed()) {
-    // If the non-fixed conformance is not replacable, we have a failure to
+    // If the non-fixed conformance is not replaceable, we have a failure to
     // diagnose.
     diagnoseSuperseded = (lhs->isFixed() &&
                           !isReplaceable(rhs->getRankingKind())) ||
diff --git a/lib/AST/Verifier.cpp b/lib/AST/Verifier.cpp
index 937ecc1ac440d..3c8d0681f25e6 100644
--- a/lib/AST/Verifier.cpp
+++ b/lib/AST/Verifier.cpp
@@ -436,7 +436,7 @@ struct ASTNodeBase {};
             return false;
 
           // We should know about archetypes corresponding to opened
-          // existerntial archetypes.
+          // existential archetypes.
           if (archetype->getOpenedExistentialType()) {
             if (OpenedExistentialArchetypes.count(archetype) == 0) {
               Out << "Found opened existential archetype "
diff --git a/utils/swift-bench.py b/utils/swift-bench.py
index 893ddbca28354..f083f12816b2a 100644
--- a/utils/swift-bench.py
+++ b/utils/swift-bench.py
@@ -26,7 +26,7 @@
 #   o When all files are compiled, the harness begins to run the tests. The
 #     harness chooses a number of iterations for each tests to achieve the best
 #     accuracy in the given time limit (in order to do that, it performs several
-#     auxiliary test runs). When the iteration number is chosen, the measurent
+#     auxiliary test runs). When the iteration number is chosen, the measurement
 #     of execution time is actually performed.
 #   o At this point everything is ready, and the harness simply reports the
 #     results.

From 37840dbc4fe500bc39d77d779bf1afa9401f5b1b Mon Sep 17 00:00:00 2001
From: halfnelson <dpershouse@gmail.com>
Date: Fri, 11 Dec 2015 21:57:23 +1000
Subject: [PATCH 04/15] cmark c flags should derive from cmark build type

---
 utils/build-script-impl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/build-script-impl b/utils/build-script-impl
index 5c2ffb69fffee..6bc8a3df0d56c 100755
--- a/utils/build-script-impl
+++ b/utils/build-script-impl
@@ -1229,7 +1229,7 @@ function llvm_c_flags() {
 
 function cmark_c_flags() {
     echo -n " $(common_cross_c_flags $1)"
-    if [[ $(is_cmake_release_build_type "${LLVM_BUILD_TYPE}") ]] ; then
+    if [[ $(is_cmake_release_build_type "${CMARK_BUILD_TYPE}") ]] ; then
         echo -n " -fno-stack-protector"
     fi
 }

From 7730b4921edd3674459828d5263401c212b8ccaf Mon Sep 17 00:00:00 2001
From: Dylan Brown <djwbrown@gmail.com>
Date: Fri, 11 Dec 2015 17:19:50 +0200
Subject: [PATCH 05/15] Update README.md

Update the README.md instructions for utils/update-checkout option. Should read `--clone-with-ssh`.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b7e513dc5f16e..2979b70647574 100644
--- a/README.md
+++ b/README.md
@@ -77,7 +77,7 @@ uploading SSH keys to GitHub):
 
     git clone git@github.com:apple/swift.git
     cd swift
-    ./utils/update-checkout --clone-via-ssh
+    ./utils/update-checkout --clone-with-ssh
 
 [CMake](http://cmake.org) is the core infrastructure used to configure builds of
 Swift and its companion projects; at least version 2.8.12.2 is required. Your

From 4dad7c7d3e5c460e6e6c5ef0cdb385a1c449a0ab Mon Sep 17 00:00:00 2001
From: Vincent Garrigues <vincent.garrigues@gmail.com>
Date: Fri, 11 Dec 2015 16:50:19 +0100
Subject: [PATCH 06/15] Update getting started instructions

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b7e513dc5f16e..2979b70647574 100644
--- a/README.md
+++ b/README.md
@@ -77,7 +77,7 @@ uploading SSH keys to GitHub):
 
     git clone git@github.com:apple/swift.git
     cd swift
-    ./utils/update-checkout --clone-via-ssh
+    ./utils/update-checkout --clone-with-ssh
 
 [CMake](http://cmake.org) is the core infrastructure used to configure builds of
 Swift and its companion projects; at least version 2.8.12.2 is required. Your

From 2adabe500bdba7a528bfd16a5ecbb9b80b48bf05 Mon Sep 17 00:00:00 2001
From: Slava Pestov <spestov@apple.com>
Date: Fri, 11 Dec 2015 01:06:48 -0800
Subject: [PATCH 07/15] IRGen: Fix incorrect conditional in multi-payload
 destructiveInjectEnumTag() witness

We were checking if the tag was <= numPayloadCases, not <. Fix this
and swap the order of the basic blocks so that the no-tag case is
the fall through for consistency with getEnumTag().
---
 lib/IRGen/GenEnum.cpp               | 25 ++++++------
 test/IRGen/enum_value_semantics.sil | 60 ++++++++++++++---------------
 2 files changed, 43 insertions(+), 42 deletions(-)

diff --git a/lib/IRGen/GenEnum.cpp b/lib/IRGen/GenEnum.cpp
index 39d6ac0649348..472fac3f3ef76 100644
--- a/lib/IRGen/GenEnum.cpp
+++ b/lib/IRGen/GenEnum.cpp
@@ -4068,29 +4068,30 @@ namespace {
         return storeDynamicTag(IGF, enumAddr, tag, T);
       }
 
-      auto &C = IGF.IGM.getLLVMContext();
-      auto payloadBB = llvm::BasicBlock::Create(C);
-      auto noPayloadBB = llvm::BasicBlock::Create(C);
-      auto endBB = llvm::BasicBlock::Create(C);
-
+      // If there are no empty cases, don't need a conditional.
       if (ElementsWithNoPayload.empty()) {
         storePayloadTag(IGF, enumAddr, tag, T);
         return;
       }
 
+      auto &C = IGF.IGM.getLLVMContext();
+      auto noPayloadBB = llvm::BasicBlock::Create(C);
+      auto payloadBB = llvm::BasicBlock::Create(C);
+      auto endBB = llvm::BasicBlock::Create(C);
+
       llvm::Value *numPayloadCases =
           llvm::ConstantInt::get(IGF.IGM.Int32Ty,
                                  ElementsWithPayload.size());
-      llvm::Value *cond = IGF.Builder.CreateICmpULE(tag, numPayloadCases);
-      IGF.Builder.CreateCondBr(cond, payloadBB, noPayloadBB);
+      llvm::Value *cond = IGF.Builder.CreateICmpUGE(tag, numPayloadCases);
+      IGF.Builder.CreateCondBr(cond, noPayloadBB, payloadBB);
 
-      IGF.Builder.emitBlock(payloadBB);
-      storePayloadTag(IGF, enumAddr, tag, T);
+      IGF.Builder.emitBlock(noPayloadBB);
+      llvm::Value *noPayloadTag = IGF.Builder.CreateSub(tag, numPayloadCases);
+      storeNoPayloadTag(IGF, enumAddr, noPayloadTag, T);
       IGF.Builder.CreateBr(endBB);
       
-      IGF.Builder.emitBlock(noPayloadBB);
-      tag = IGF.Builder.CreateSub(tag, numPayloadCases);
-      storeNoPayloadTag(IGF, enumAddr, tag, T);
+      IGF.Builder.emitBlock(payloadBB);
+      storePayloadTag(IGF, enumAddr, tag, T);
       IGF.Builder.CreateBr(endBB);
       
       IGF.Builder.emitBlock(endBB);
diff --git a/test/IRGen/enum_value_semantics.sil b/test/IRGen/enum_value_semantics.sil
index 4bf74df07cd7f..d56de80e57e67 100644
--- a/test/IRGen/enum_value_semantics.sil
+++ b/test/IRGen/enum_value_semantics.sil
@@ -358,17 +358,8 @@ bb0(%0 : $SinglePayloadNontrivial):
 // -- MultiPayloadTrivial destructiveInjectEnumTag
 // CHECK-LABEL: define linkonce_odr hidden void @_TwuiO20enum_value_semantics19MultiPayloadTrivial
 // CHECK:      [[SELF:%.*]] = bitcast %swift.opaque* %value to %O20enum_value_semantics19MultiPayloadTrivial*
-// CHECK-NEXT: [[IS_PAYLOAD:%.*]] = icmp ule i32 %tag, 2
-// CHECK-NEXT: br i1 [[IS_PAYLOAD]], label %[[HAS_PAYLOAD:.*]], label %[[HAS_NO_PAYLOAD:.*]]
-
-// CHECK:      ; <label>:[[HAS_PAYLOAD]]
-
-//   -- Store the tag in the extra tag area
-// CHECK-NEXT: [[TAG:%.*]] = trunc i32 %tag to i2
-// CHECK-NEXT: [[EXTRA_TAG_ADDR_TMP:%.*]] = getelementptr inbounds %O20enum_value_semantics19MultiPayloadTrivial, %O20enum_value_semantics19MultiPayloadTrivial* [[SELF]], i32 0, i32 1
-// CHECK-NEXT: [[EXTRA_TAG_ADDR:%.*]] = bitcast [1 x i8]* [[EXTRA_TAG_ADDR_TMP]] to i2*
-// CHECK-NEXT: store i2 [[TAG]], i2* [[EXTRA_TAG_ADDR]], align 8
-// CHECK-NEXT: br label %[[DONE:.*]]
+// CHECK-NEXT: [[IS_PAYLOAD:%.*]] = icmp uge i32 %tag, 2
+// CHECK-NEXT: br i1 [[IS_PAYLOAD]], label %[[HAS_NO_PAYLOAD:.*]], label %[[HAS_PAYLOAD:.*]]
 
 // CHECK:      ; <label>:[[HAS_NO_PAYLOAD]]
 
@@ -384,6 +375,15 @@ bb0(%0 : $SinglePayloadNontrivial):
 // CHECK-NEXT: [[EXTRA_TAG_ADDR_TMP:%.*]] = getelementptr inbounds %O20enum_value_semantics19MultiPayloadTrivial, %O20enum_value_semantics19MultiPayloadTrivial* [[SELF]], i32 0, i32 1
 // CHECK-NEXT: [[EXTRA_TAG_ADDR:%.*]] = bitcast [1 x i8]* [[EXTRA_TAG_ADDR_TMP]] to i2*
 // CHECK-NEXT: store i2 -2, i2* [[EXTRA_TAG_ADDR]], align 8
+// CHECK-NEXT: br label %[[DONE:.*]]
+
+// CHECK:      ; <label>:[[HAS_PAYLOAD]]
+
+//   -- Store the tag in the extra tag area
+// CHECK-NEXT: [[TAG:%.*]] = trunc i32 %tag to i2
+// CHECK-NEXT: [[EXTRA_TAG_ADDR_TMP:%.*]] = getelementptr inbounds %O20enum_value_semantics19MultiPayloadTrivial, %O20enum_value_semantics19MultiPayloadTrivial* [[SELF]], i32 0, i32 1
+// CHECK-NEXT: [[EXTRA_TAG_ADDR:%.*]] = bitcast [1 x i8]* [[EXTRA_TAG_ADDR_TMP]] to i2*
+// CHECK-NEXT: store i2 [[TAG]], i2* [[EXTRA_TAG_ADDR]], align 8
 // CHECK-NEXT: br label %[[DONE]]
 
 // CHECK:      ; <label>:[[DONE]]
@@ -592,8 +592,25 @@ bb0(%0 : $SinglePayloadNontrivial):
 
 // CHECK-LABEL: define linkonce_odr hidden void @_TwuiO20enum_value_semantics31MultiPayloadNontrivialSpareBits
 // CHECK:      [[SELF:%.*]] = bitcast %swift.opaque* %value to %O20enum_value_semantics31MultiPayloadNontrivialSpareBits*
-// CHECK-NEXT: [[IS_PAYLOAD:%.*]] = icmp ule i32 %tag, 3
-// CHECK-NEXT: br i1 [[IS_PAYLOAD]], label %[[HAS_PAYLOAD:.*]], label %[[HAS_NO_PAYLOAD:.*]]
+// CHECK-NEXT: [[IS_PAYLOAD:%.*]] = icmp uge i32 %tag, 3
+// CHECK-NEXT: br i1 [[IS_PAYLOAD]], label %[[HAS_NO_PAYLOAD:.*]], label %[[HAS_PAYLOAD:.*]]
+
+// CHECK:      ; <label>:[[HAS_NO_PAYLOAD]]
+
+//   -- Turn the case index into a no-payload case index
+// CHECK-NEXT: [[NO_PAYLOAD_TAG_TMP:%.*]] = sub i32 %tag, 3
+// CHECK-NEXT: [[NO_PAYLOAD_TAG:%.*]] = zext i32 [[NO_PAYLOAD_TAG_TMP]] to i64
+
+//   -- Store the low bits of the tag into the payload
+// CHECK-NEXT: [[PAYLOAD:%.*]] = bitcast %O20enum_value_semantics31MultiPayloadNontrivialSpareBits* [[SELF]] to { i64, i64 }*
+// CHECK-NEXT: [[FIRST_ADDR:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[PAYLOAD]], i32 0, i32 0
+// CHECK-NEXT: store i64 [[NO_PAYLOAD_TAG]], i64* [[FIRST_ADDR]], align 8
+
+//   -- Store the high bits of the tag into the spare bits
+// CHECK-NEXT: [[SECOND_ADDR:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[PAYLOAD]], i32 0, i32 1
+//   -- 0xc000000000000000
+// CHECK-NEXT: store i64 -4611686018427387904, i64* [[SECOND_ADDR]], align 8
+// CHECK-NEXT: br label %[[END:.*]]
 
 // CHECK:      ; <label>:[[HAS_PAYLOAD]]
 
@@ -626,23 +643,6 @@ bb0(%0 : $SinglePayloadNontrivial):
 // CHECK-NEXT: store i64 [[FIRST]], i64* [[FIRST_ADDR]], align 8
 // CHECK-NEXT: [[SECOND_ADDR:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[PAYLOAD]], i32 0, i32 1
 // CHECK-NEXT: store i64 [[SECOND_NEW]], i64* [[SECOND_ADDR]], align 8
-// CHECK-NEXT: br label %[[END:.*]]
-
-// CHECK:      ; <label>:[[HAS_NO_PAYLOAD]]
-
-//   -- Turn the case index into a no-payload case index
-// CHECK-NEXT: [[NO_PAYLOAD_TAG_TMP:%.*]] = sub i32 %tag, 3
-// CHECK-NEXT: [[NO_PAYLOAD_TAG:%.*]] = zext i32 [[NO_PAYLOAD_TAG_TMP]] to i64
-
-//   -- Store the low bits of the tag into the payload
-// CHECK-NEXT: [[PAYLOAD:%.*]] = bitcast %O20enum_value_semantics31MultiPayloadNontrivialSpareBits* [[SELF]] to { i64, i64 }*
-// CHECK-NEXT: [[FIRST_ADDR:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[PAYLOAD]], i32 0, i32 0
-// CHECK-NEXT: store i64 [[NO_PAYLOAD_TAG]], i64* [[FIRST_ADDR]], align 8
-
-//   -- Store the high bits of the tag into the spare bits
-// CHECK-NEXT: [[SECOND_ADDR:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[PAYLOAD]], i32 0, i32 1
-//   -- 0xc000000000000000
-// CHECK-NEXT: store i64 -4611686018427387904, i64* [[SECOND_ADDR]], align 8
 // CHECK-NEXT: br label %[[END]]
 
 // CHECK:      ; <label>:[[END]]

From 0269e0291e88b8ee1fc48f66c082ae86a49260d1 Mon Sep 17 00:00:00 2001
From: Slava Pestov <spestov@apple.com>
Date: Fri, 11 Dec 2015 02:11:01 -0800
Subject: [PATCH 08/15] Sema: Fix assertion failure if EnumElementPattern is
 re-typechecked

We weren't actually successfully mutating ParentType,
so fix that, and also ensure we set ParentType together
with the rest of the state.

Discovered while writing resilient enum tests.
---
 include/swift/AST/Pattern.h     |  1 +
 lib/Sema/TypeCheckPattern.cpp   | 14 +++++-----
 test/Constraints/patterns.swift | 49 +++++++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/include/swift/AST/Pattern.h b/include/swift/AST/Pattern.h
index 694e0d54b64e0..393b8154936d2 100644
--- a/include/swift/AST/Pattern.h
+++ b/include/swift/AST/Pattern.h
@@ -674,6 +674,7 @@ class EnumElementPattern : public Pattern {
   }
   SourceRange getSourceRange() const { return {getStartLoc(), getEndLoc()}; }
   
+  TypeLoc &getParentType() { return ParentType; }
   TypeLoc getParentType() const { return ParentType; }
   
   static bool classof(const Pattern *P) {
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
index e212e119d444d..3ba60bcec6457 100644
--- a/lib/Sema/TypeCheckPattern.cpp
+++ b/lib/Sema/TypeCheckPattern.cpp
@@ -1280,17 +1280,17 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
     // type as `.Foo`), resolve it now that we have a type.
     Optional<CheckedCastKind> castKind;
     
+    EnumElementDecl *elt = EEP->getElementDecl();
+    
     Type enumTy;
-    if (!EEP->getElementDecl()) {
-      EnumElementDecl *element = nullptr;
+    if (!elt) {
       if (type->getAnyNominal())
-        element = lookupEnumMemberElement(*this, dc, type, EEP->getName());
-      if (!element) {
+        elt = lookupEnumMemberElement(*this, dc, type, EEP->getName());
+      if (!elt) {
         diagnose(EEP->getLoc(), diag::enum_element_pattern_member_not_found,
                  EEP->getName().str(), type);
         return true;
       }
-      EEP->setElementDecl(element);
       enumTy = type;
     } else {
       // Check if the explicitly-written enum type matches the type we're
@@ -1337,8 +1337,6 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
       }
     }
 
-    EnumElementDecl *elt = EEP->getElementDecl();
-    
     // If there is a subpattern, push the enum element type down onto it.
     if (EEP->hasSubPattern()) {
       Type elementType;
@@ -1355,6 +1353,8 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
         return true;
       EEP->setSubPattern(sub);
     }
+
+    EEP->setElementDecl(elt);
     EEP->setType(enumTy);
     
     // Ensure that the type of our TypeLoc is fully resolved. If an unbound
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
index 6b1b4b8df0041..6afa2e3600570 100644
--- a/test/Constraints/patterns.swift
+++ b/test/Constraints/patterns.swift
@@ -176,5 +176,54 @@ var (let y) = 42  // expected-error {{'let' cannot appear nested inside another
 let (var z) = 42  // expected-error {{'var' cannot appear nested inside another 'var' or 'let' pattern}}
 
 
+// Crash when re-typechecking EnumElementPattern.
+// FIXME: This should actually type-check -- the diagnostics are bogus. But
+// at least we don't crash anymore.
 
+protocol PP {
+  typealias E
+}
+
+struct A<T> : PP {
+  typealias E = T
+}
+
+extension PP {
+  func map<T>(f: Self.E -> T) -> T {}
+}
+
+enum EE {
+  case A
+  case B
+}
+
+func good(a: A<EE>) -> Int {
+  return a.map {
+    switch $0 {
+    case .A:
+      return 1
+    default:
+      return 2
+    }
+  }
+}
 
+func bad(a: A<EE>) {
+  a.map { // expected-error {{cannot invoke 'map' with an argument list of type '((EE) -> _)'}}
+  // expected-note@-1 {{expected an argument list of type '(EE -> T)'}}
+    let _: EE = $0
+    return 1 // expected-error {{cannot convert return expression of type 'Int' to return type 'T'}}
+  }
+}
+
+func ugly(a: A<EE>) {
+  a.map { // expected-error {{cannot invoke 'map' with an argument list of type '((EE) -> _)'}}
+  // expected-note@-1 {{expected an argument list of type '(EE -> T)'}}
+    switch $0 {
+    case .A:
+      return 1 // expected-error {{cannot convert return expression of type 'Int' to return type 'T'}}
+    default:
+      return 2 // expected-error {{cannot convert return expression of type 'Int' to return type 'T'}}
+    }
+  }
+}

From c31b209c81d113f9a0cea5d127df0cf08f3f4450 Mon Sep 17 00:00:00 2001
From: Slava Pestov <spestov@apple.com>
Date: Thu, 10 Dec 2015 22:06:28 -0800
Subject: [PATCH 09/15] Interpreter tests for resilient enums

---
 test/Inputs/resilient_enum.swift       | 118 ++++++++++
 test/Interpreter/enum_resilience.swift | 295 +++++++++++++++++++++++++
 2 files changed, 413 insertions(+)
 create mode 100644 test/Interpreter/enum_resilience.swift

diff --git a/test/Inputs/resilient_enum.swift b/test/Inputs/resilient_enum.swift
index 37fed4878fc31..ed4c6c3f6d3c7 100644
--- a/test/Inputs/resilient_enum.swift
+++ b/test/Inputs/resilient_enum.swift
@@ -29,3 +29,121 @@ public enum Medium {
 public indirect enum IndirectApproach {
   case Angle(Double)
 }
+
+// Specific enum implementations for executable tests
+public enum ResilientEmptyEnum {
+  case X
+}
+
+public enum ResilientSingletonEnum {
+  case X(AnyObject)
+}
+
+public enum ResilientSingletonGenericEnum<T> {
+  case X(T)
+}
+
+public enum ResilientNoPayloadEnum {
+  case A
+  case B
+  case C
+}
+
+public enum ResilientSinglePayloadEnum {
+  case A
+  case B
+  case C
+  case X(AnyObject)
+}
+
+public enum ResilientSinglePayloadGenericEnum<T> {
+  case A
+  case B
+  case C
+  case X(T)
+}
+
+public class ArtClass {
+  public init() {}
+}
+
+public enum ResilientMultiPayloadEnum {
+  case A
+  case B
+  case C
+  case X(Int)
+  case Y(Int)
+}
+
+public func makeResilientMultiPayloadEnum(n: Int, i: Int)
+    -> ResilientMultiPayloadEnum {
+  switch i {
+  case 0:
+    return .A
+  case 1:
+    return .B
+  case 2:
+    return .C
+  case 3:
+    return .X(n)
+  case 4:
+    return .Y(n)
+  default:
+    while true {}
+  }
+}
+
+public enum ResilientMultiPayloadEnumSpareBits {
+  case A
+  case B
+  case C
+  case X(ArtClass)
+  case Y(ArtClass)
+}
+
+public func makeResilientMultiPayloadEnumSpareBits(o: ArtClass, i: Int)
+    -> ResilientMultiPayloadEnumSpareBits {
+  switch i {
+  case 0:
+    return .A
+  case 1:
+    return .B
+  case 2:
+    return .C
+  case 3:
+    return .X(o)
+  case 4:
+    return .Y(o)
+  default:
+    while true {}
+  }
+}
+
+public typealias SevenSpareBits = (Bool, Int8, Int8, Int8, Int8, Int8, Int8, Int8)
+
+public enum ResilientMultiPayloadEnumSpareBitsAndExtraBits {
+  // On 64-bit little endian, 7 spare bits at the LSB end
+  case P1(SevenSpareBits)
+  // On 64-bit, 8 spare bits at the MSB end and 3 at the LSB end
+  case P2(ArtClass)
+  case P3(ArtClass)
+  case P4(ArtClass)
+  case P5(ArtClass)
+  case P6(ArtClass)
+  case P7(ArtClass)
+  case P8(ArtClass)
+}
+
+public enum ResilientMultiPayloadGenericEnum<T> {
+  case A
+  case B
+  case C
+  case X(T)
+  case Y(T)
+}
+
+public enum ResilientIndirectEnum {
+  case Base
+  indirect case A(ResilientIndirectEnum)
+  indirect case B(ResilientIndirectEnum, ResilientIndirectEnum)
+}
diff --git a/test/Interpreter/enum_resilience.swift b/test/Interpreter/enum_resilience.swift
new file mode 100644
index 0000000000000..774a88f40878e
--- /dev/null
+++ b/test/Interpreter/enum_resilience.swift
@@ -0,0 +1,295 @@
+// RUN: rm -rf %t && mkdir %t
+
+// RUN: %target-build-swift -emit-library -Xfrontend -enable-resilience -c %S/../Inputs/resilient_struct.swift -o %t/resilient_struct.o
+// RUN: %target-build-swift -emit-module -Xfrontend -enable-resilience -c %S/../Inputs/resilient_struct.swift -o %t/resilient_struct.o
+
+// RUN: %target-build-swift -emit-library -Xfrontend -enable-resilience -c %S/../Inputs/resilient_enum.swift -I %t/ -o %t/resilient_enum.o
+// RUN: %target-build-swift -emit-module -Xfrontend -enable-resilience -c %S/../Inputs/resilient_enum.swift -I %t/ -o %t/resilient_enum.o
+
+// RUN: %target-build-swift %s -Xlinker %t/resilient_struct.o -Xlinker %t/resilient_enum.o -I %t -L %t -o %t/main
+// RUN: %target-run %t/main
+
+import StdlibUnittest
+import resilient_enum
+import resilient_struct
+
+var ResilientEnumTestSuite = TestSuite("ResilientEnum")
+
+ResilientEnumTestSuite.test("ResilientEmptyEnum") {
+  let e = ResilientEmptyEnum.X
+  let n: Int
+  switch e {
+  case .X: n = 0
+  default: n = -1
+  }
+  expectEqual(n, 0)
+}
+
+ResilientEnumTestSuite.test("ResilientSingletonEnum") {
+  let o: AnyObject = ArtClass()
+  let e = ResilientSingletonEnum.X(o)
+  let n: Int
+  switch e {
+  case .X(let oo):
+    n = 0
+    expectTrue(o === oo)
+  default:
+    n = -1
+  }
+  expectEqual(n, 0)
+}
+
+ResilientEnumTestSuite.test("ResilientSingletonGenericEnum") {
+  let o = ArtClass()
+  let e = ResilientSingletonGenericEnum.X(o)
+  let n: Int
+  switch e {
+  case .X(let oo):
+    n = 0
+    expectEqual(o === oo, true)
+  default:
+    n = -1
+  }
+  expectEqual(n, 0)
+}
+
+ResilientEnumTestSuite.test("ResilientNoPayloadEnum") {
+  let a: [ResilientNoPayloadEnum] = [.A, .B, .C]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2])
+}
+
+ResilientEnumTestSuite.test("ResilientSinglePayloadEnum") {
+  let o = ArtClass()
+  let a: [ResilientSinglePayloadEnum] = [.A, .B, .C, .X(o)]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let oo):
+      expectTrue(o === oo)
+      return 3
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2, 3])
+}
+
+ResilientEnumTestSuite.test("ResilientSinglePayloadGenericEnum") {
+  let o = ArtClass()
+  let a: [ResilientSinglePayloadGenericEnum<ArtClass>] = [.A, .B, .C, .X(o)]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let oo):
+      expectTrue(o === oo)
+      return 3
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2, 3])
+}
+
+ResilientEnumTestSuite.test("ResilientMultiPayloadEnum") {
+  let a: [ResilientMultiPayloadEnum] =
+      [.A, .B, .C, .X(1), .Y(2)]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let x):
+      expectEqual(x, 1)
+      return 3
+    case .Y(let y):
+      expectEqual(y, 2)
+      return 4
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2, 3, 4])
+}
+
+ResilientEnumTestSuite.test("ResilientMultiPayloadEnumRoundTrip") {
+  let a = [0, 1, 2, 3, 4]
+  let b = a.map { makeResilientMultiPayloadEnum(1122, i: $0) }
+  let c: [Int] = b.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let x):
+      expectEqual(x, 1122)
+      return 3
+    case .Y(let y):
+      expectEqual(y, 1122)
+      return 4
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(c, a)
+}
+
+ResilientEnumTestSuite.test("ResilientMultiPayloadEnumSpareBits") {
+  let o1 = ArtClass()
+  let o2 = ArtClass()
+  let a: [ResilientMultiPayloadEnumSpareBits] =
+      [.A, .B, .C, .X(o1), .Y(o2)]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let oo1):
+      expectTrue(oo1 === o1)
+      return 3
+    case .Y(let oo2):
+      expectTrue(oo2 === o2)
+      return 4
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2, 3, 4])
+}
+
+ResilientEnumTestSuite.test("ResilientMultiPayloadEnumSpareBitsRoundTrip") {
+  let o = ArtClass()
+  let a = [0, 1, 2, 3, 4]
+  let b = a.map { makeResilientMultiPayloadEnumSpareBits(o, i: $0) }
+  let c: [Int] = b.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let oo):
+      expectTrue(oo === o)
+      return 3
+    case .Y(let oo):
+      expectTrue(oo === o)
+      return 4
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(c, a)
+}
+
+ResilientEnumTestSuite.test("ResilientMultiPayloadEnumSpareBitsAndExtraBits") {
+  let o = ArtClass()
+  let s: SevenSpareBits = (false, 1, 2, 3, 4, 5, 6, 7)
+  let a: [ResilientMultiPayloadEnumSpareBitsAndExtraBits]
+      = [.P1(s), .P2(o), .P3(o), .P4(o), .P5(o), .P6(o), .P7(o), .P8(o)]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .P1(let ss):
+      // FIXME: derive Equatable conformances for arbitrary tuples :-) 
+      expectEqual(ss.0, s.0)
+      expectEqual(ss.1, s.1)
+      expectEqual(ss.2, s.2)
+      expectEqual(ss.3, s.3)
+      expectEqual(ss.4, s.4)
+      expectEqual(ss.5, s.5)
+      expectEqual(ss.6, s.6)
+      expectEqual(ss.7, s.7)
+      return 0
+    case .P2(let oo):
+      expectTrue(oo === o)
+      return 1
+    case .P3(let oo):
+      expectTrue(oo === o)
+      return 2
+    case .P4(let oo):
+      expectTrue(oo === o)
+      return 3
+    case .P5(let oo):
+      expectTrue(oo === o)
+      return 4
+    case .P6(let oo):
+      expectTrue(oo === o)
+      return 5
+    case .P7(let oo):
+      expectTrue(oo === o)
+      return 6
+    case .P8(let oo):
+      expectTrue(oo === o)
+      return 7
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2, 3, 4, 5, 6, 7])
+}
+
+ResilientEnumTestSuite.test("ResilientMultiPayloadGenericEnum") {
+  let o1 = ArtClass()
+  let o2 = ArtClass()
+  let a: [ResilientMultiPayloadGenericEnum<ArtClass>] =
+      [.A, .B, .C, .X(o1), .Y(o2)]
+  let b: [Int] = a.map {
+    switch $0 {
+    case .A:
+      return 0
+    case .B:
+      return 1
+    case .C:
+      return 2
+    case .X(let oo1):
+      expectTrue(oo1 === o1)
+      return 3
+    case .Y(let oo2):
+      expectTrue(oo2 === o2)
+      return 4
+    default:
+      return -1
+    }
+  }
+
+  expectEqual(b, [0, 1, 2, 3, 4])
+}
+
+runAllTests()

From 832a637c0402beff7d886cac26a0898b22706034 Mon Sep 17 00:00:00 2001
From: Slava Pestov <spestov@apple.com>
Date: Thu, 10 Dec 2015 22:52:59 -0800
Subject: [PATCH 10/15] SIL: Start cleaning up getMethodDispatch() /
 requiresObjCDispatch()

Move these to SILDeclRef, maybe not the best place but a good home for now.
Factor out a new requiresForeignToNativeThunk() function, which cleans up
some code duplication introduced by the following patch:

https://github.com/apple/swift/commit/478e1c7513cef39548d0579979a68bf260b97975

This is a small step towards consolidating duplicated logic for figuring out
method dispatch semantics and emitting curry thunks.
---
 include/swift/SIL/SILDeclRef.h | 17 +++++++
 lib/SIL/SILDeclRef.cpp         | 87 +++++++++++++++++++++++++++++++---
 lib/SILGen/SILGen.h            |  7 ---
 lib/SILGen/SILGenApply.cpp     | 56 +++++-----------------
 lib/SILGen/SILGenFunction.cpp  | 10 +---
 lib/SILGen/SILGenFunction.h    | 11 -----
 lib/SILGen/SILGenType.cpp      | 41 ----------------
 7 files changed, 110 insertions(+), 119 deletions(-)

diff --git a/include/swift/SIL/SILDeclRef.h b/include/swift/SIL/SILDeclRef.h
index 7e965b5180e60..3bcf51cf1ab80 100644
--- a/include/swift/SIL/SILDeclRef.h
+++ b/include/swift/SIL/SILDeclRef.h
@@ -45,6 +45,23 @@ namespace swift {
   class SILLocation;
   class AnyFunctionRef;
 
+/// How a method is dispatched.
+enum class MethodDispatch {
+  // The method implementation can be referenced statically.
+  Static,
+  // The method implementation uses class_method dispatch.
+  Class,
+};
+
+/// Get the method dispatch mechanism for a method.
+MethodDispatch getMethodDispatch(AbstractFunctionDecl *method);
+
+/// True if calling the given method or property should use ObjC dispatch.
+bool requiresObjCDispatch(ValueDecl *vd);
+
+/// True if the entry point is natively foreign.
+bool requiresForeignToNativeThunk(ValueDecl *vd);
+
 enum ForDefinition_t : bool {
   NotForDefinition = false,
   ForDefinition = true
diff --git a/lib/SIL/SILDeclRef.cpp b/lib/SIL/SILDeclRef.cpp
index 59e53a7c75d33..45afe79015076 100644
--- a/lib/SIL/SILDeclRef.cpp
+++ b/lib/SIL/SILDeclRef.cpp
@@ -25,6 +25,85 @@
 #include "clang/AST/DeclObjC.h"
 using namespace swift;
 
+/// Get the method dispatch mechanism for a method.
+MethodDispatch
+swift::getMethodDispatch(AbstractFunctionDecl *method) {
+  // Final methods can be statically referenced.
+  if (method->isFinal())
+    return MethodDispatch::Static;
+  // Some methods are forced to be statically dispatched.
+  if (method->hasForcedStaticDispatch())
+    return MethodDispatch::Static;
+
+  // If this declaration is in a class but not marked final, then it is
+  // always dynamically dispatched.
+  auto dc = method->getDeclContext();
+  if (isa<ClassDecl>(dc))
+    return MethodDispatch::Class;
+
+  // Class extension methods are only dynamically dispatched if they're
+  // dispatched by objc_msgSend, which happens if they're foreign or dynamic.
+  if (dc->isClassOrClassExtensionContext()) {
+    if (method->hasClangNode())
+      return MethodDispatch::Class;
+    if (auto fd = dyn_cast<FuncDecl>(method)) {
+      if (fd->isAccessor() && fd->getAccessorStorageDecl()->hasClangNode())
+        return MethodDispatch::Class;
+    }
+    if (method->getAttrs().hasAttribute<DynamicAttr>())
+      return MethodDispatch::Class;
+  }
+
+  // Otherwise, it can be referenced statically.
+  return MethodDispatch::Static;
+}
+
+bool swift::requiresForeignToNativeThunk(ValueDecl *vd) {
+  // Functions imported from C, Objective-C methods imported from Objective-C,
+  // as well as methods in @objc protocols (even protocols defined in Swift)
+  // require a foreign to native thunk.
+  auto dc = vd->getDeclContext();
+  if (auto proto = dyn_cast<ProtocolDecl>(dc))
+    if (proto->isObjC())
+      return true;
+
+  if (auto fd = dyn_cast<FuncDecl>(vd))
+    return fd->hasClangNode();
+
+  return false;
+}
+
+/// FIXME: merge requiresObjCDispatch() into getMethodDispatch() and add
+/// an ObjectiveC case to the MethodDispatch enum.
+bool swift::requiresObjCDispatch(ValueDecl *vd) {
+  // Final functions never require ObjC dispatch.
+  if (vd->isFinal())
+    return false;
+
+  if (requiresForeignToNativeThunk(vd))
+    return true;
+
+  if (auto *fd = dyn_cast<FuncDecl>(vd)) {
+    // Property accessors should be generated alongside the property.
+    if (fd->isGetterOrSetter())
+      return requiresObjCDispatch(fd->getAccessorStorageDecl());
+
+    return fd->getAttrs().hasAttribute<DynamicAttr>();
+  }
+
+  if (auto *cd = dyn_cast<ConstructorDecl>(vd)) {
+    if (cd->hasClangNode())
+      return true;
+
+    return cd->getAttrs().hasAttribute<DynamicAttr>();
+  }
+
+  if (auto *asd = dyn_cast<AbstractStorageDecl>(vd))
+    return asd->requiresObjCGetterAndSetter();
+
+  return vd->getAttrs().hasAttribute<DynamicAttr>();
+}
+
 static unsigned getFuncNaturalUncurryLevel(AnyFunctionRef AFR) {
   assert(AFR.getBodyParamPatterns().size() >= 1 && "no arguments for func?!");
   unsigned Level = AFR.getBodyParamPatterns().size() - 1;
@@ -338,14 +417,8 @@ bool SILDeclRef::isForeignToNativeThunk() const {
   // have a foreign-to-native thunk.
   if (!hasDecl())
     return false;
-  // Otherwise, match whether we have a clang node with whether we're foreign.
-  if (isa<FuncDecl>(getDecl()) && getDecl()->hasClangNode())
+  if (requiresForeignToNativeThunk(getDecl()))
     return !isForeign;
-  // Objective-C protocol methods also require a foreign to native thunk.
-  auto dc = getDecl()->getDeclContext();
-  if (auto proto = dyn_cast<ProtocolDecl>(dc))
-    if (proto->isObjC())
-      return !isForeign;
   // ObjC initializing constructors and factories are foreign.
   // We emit a special native allocating constructor though.
   if (isa<ConstructorDecl>(getDecl())
diff --git a/lib/SILGen/SILGen.h b/lib/SILGen/SILGen.h
index fee1db006494b..f8f86de5138bd 100644
--- a/lib/SILGen/SILGen.h
+++ b/lib/SILGen/SILGen.h
@@ -323,13 +323,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// True if the given constructor requires an entry point for ObjC method
   /// dispatch.
   bool requiresObjCMethodEntryPoint(ConstructorDecl *constructor);
-  
-  /// True if calling the given method or property should use ObjC dispatch.
-  bool requiresObjCDispatch(ValueDecl *vd);
-  
-  /// True if super-calling the given method from a subclass should use ObjC
-  /// dispatch.
-  bool requiresObjCSuperDispatch(ValueDecl *vd);
 
   /// Emit a global initialization.
   void emitGlobalInitialization(PatternBindingDecl *initializer, unsigned elt);
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
index 857a754168057..1b6955b05e427 100644
--- a/lib/SILGen/SILGenApply.cpp
+++ b/lib/SILGen/SILGenApply.cpp
@@ -29,40 +29,6 @@
 using namespace swift;
 using namespace Lowering;
 
-/// Get the method dispatch mechanism for a method.
-MethodDispatch
-SILGenFunction::getMethodDispatch(AbstractFunctionDecl *method) {
-  // Final methods can be statically referenced.
-  if (method->isFinal())
-    return MethodDispatch::Static;
-  // Some methods are forced to be statically dispatched.
-  if (method->hasForcedStaticDispatch())
-    return MethodDispatch::Static;
-
-  // If this declaration is in a class but not marked final, then it is
-  // always dynamically dispatched.
-  auto dc = method->getDeclContext();
-  if (isa<ClassDecl>(dc))
-    return MethodDispatch::Class;
-
-  // Class extension methods are only dynamically dispatched if they're
-  // dispatched by objc_msgSend, which happens if they're foreign or dynamic.
-  if (auto declaredType = dc->getDeclaredTypeInContext())
-    if (declaredType->getClassOrBoundGenericClass()) {
-      if (method->hasClangNode())
-        return MethodDispatch::Class;
-      if (auto fd = dyn_cast<FuncDecl>(method)) {
-        if (fd->isAccessor() && fd->getAccessorStorageDecl()->hasClangNode())
-          return MethodDispatch::Class;
-      }
-      if (method->getAttrs().hasAttribute<DynamicAttr>())
-        return MethodDispatch::Class;
-    }
-
-  // Otherwise, it can be referenced statically.
-  return MethodDispatch::Static;
-}
-
 static SILDeclRef::Loc getLocForFunctionRef(AnyFunctionRef fn) {
   if (auto afd = fn.getAbstractFunctionDecl()) {
     return afd;
@@ -539,7 +505,7 @@ class Callee {
       // make sure we emit the right set of thunks.
       if (constant->isCurried && Constant.hasDecl())
         if (auto func = Constant.getAbstractFunctionDecl())
-          if (gen.getMethodDispatch(func) == MethodDispatch::Class)
+          if (getMethodDispatch(func) == MethodDispatch::Class)
             constant = constant->asDirectReference(true);
       
       constantInfo = gen.getConstantInfo(*constant);
@@ -1102,7 +1068,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       if (e->getAccessSemantics() != AccessSemantics::Ordinary) {
         isDynamicallyDispatched = false;
       } else {
-        switch (SGF.getMethodDispatch(afd)) {
+        switch (getMethodDispatch(afd)) {
         case MethodDispatch::Class:
           isDynamicallyDispatched = true;
           break;
@@ -1121,7 +1087,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         if (ctor->isRequired() &&
             thisCallSite->getArg()->getType()->is<AnyMetatypeType>() &&
             !thisCallSite->getArg()->isStaticallyDerivedMetatype()) {
-          if (SGF.SGM.requiresObjCDispatch(afd)) {
+          if (requiresObjCDispatch(afd)) {
             // When we're performing Objective-C dispatch, we don't have an
             // allocating constructor to call. So, perform an alloc_ref_dynamic
             // and pass that along to the initializer.
@@ -1171,7 +1137,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         SILDeclRef constant(afd, kind.getValue(),
                             SILDeclRef::ConstructAtBestResilienceExpansion,
                             SILDeclRef::ConstructAtNaturalUncurryLevel,
-                            SGF.SGM.requiresObjCDispatch(afd));
+                            requiresObjCDispatch(afd));
 
         setCallee(Callee::forClassMethod(SGF, selfValue,
                                          constant, getSubstFnType(), e));
@@ -1203,7 +1169,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     SILDeclRef constant(e->getDecl(),
                         SILDeclRef::ConstructAtBestResilienceExpansion,
                         SILDeclRef::ConstructAtNaturalUncurryLevel,
-                        SGF.SGM.requiresObjCDispatch(e->getDecl()));
+                        requiresObjCDispatch(e->getDecl()));
 
     // Otherwise, we have a statically-dispatched call.
     CanFunctionType substFnType = getSubstFnType();
@@ -1345,7 +1311,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       constant = SILDeclRef(ctorRef->getDecl(), SILDeclRef::Kind::Initializer,
                          SILDeclRef::ConstructAtBestResilienceExpansion,
                          SILDeclRef::ConstructAtNaturalUncurryLevel,
-                         SGF.SGM.requiresObjCSuperDispatch(ctorRef->getDecl()));
+                         requiresObjCDispatch(ctorRef->getDecl()));
 
       if (ctorRef->getDeclRef().isSpecialized())
         substitutions = ctorRef->getDeclRef().getSubstitutions();
@@ -1354,7 +1320,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       constant = SILDeclRef(declRef->getDecl(),
                          SILDeclRef::ConstructAtBestResilienceExpansion,
                          SILDeclRef::ConstructAtNaturalUncurryLevel,
-                         SGF.SGM.requiresObjCSuperDispatch(declRef->getDecl()));
+                         requiresObjCDispatch(declRef->getDecl()));
 
       if (declRef->getDeclRef().isSpecialized())
         substitutions = declRef->getDeclRef().getSubstitutions();
@@ -1536,12 +1502,12 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                                : SILDeclRef::Kind::Initializer,
                              SILDeclRef::ConstructAtBestResilienceExpansion,
                              SILDeclRef::ConstructAtNaturalUncurryLevel,
-                             SGF.SGM.requiresObjCDispatch(ctorRef->getDecl()));
+                             requiresObjCDispatch(ctorRef->getDecl()));
       setCallee(Callee::forArchetype(SGF, SILValue(),
                      self.getType().getSwiftRValueType(), constant,
                      cast<AnyFunctionType>(expr->getType()->getCanonicalType()),
                      expr));
-    } else if (SGF.getMethodDispatch(ctorRef->getDecl())
+    } else if (getMethodDispatch(ctorRef->getDecl())
                  == MethodDispatch::Class) {
       // Dynamic dispatch to the initializer.
       setCallee(Callee::forClassMethod(
@@ -1553,7 +1519,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                                : SILDeclRef::Kind::Initializer,
                              SILDeclRef::ConstructAtBestResilienceExpansion,
                              SILDeclRef::ConstructAtNaturalUncurryLevel,
-                             SGF.SGM.requiresObjCDispatch(ctorRef->getDecl())),
+                             requiresObjCDispatch(ctorRef->getDecl())),
                   getSubstFnType(), fn));
     } else {
       // Directly call the peer constructor.
@@ -3799,7 +3765,7 @@ static Callee getBaseAccessorFunctionRef(SILGenFunction &gen,
 
   bool isClassDispatch = false;
   if (!isDirectUse) {
-    switch (gen.getMethodDispatch(decl)) {
+    switch (getMethodDispatch(decl)) {
     case MethodDispatch::Class:
       isClassDispatch = true;
       break;
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
index a1ad3a965b8fd..66b46a1e001e1 100644
--- a/lib/SILGen/SILGenFunction.cpp
+++ b/lib/SILGen/SILGenFunction.cpp
@@ -147,14 +147,8 @@ SILValue SILGenFunction::emitGlobalFunctionRef(SILLocation loc,
       // If the function is fully uncurried and natively foreign, reference its
       // foreign entry point.
       if (!next.isCurried) {
-        if (vd->hasClangNode())
+        if (requiresForeignToNativeThunk(vd))
           next = next.asForeign();
-
-        // Objective-C protocol methods also require a foreign to native thunk.
-        auto dc = vd->getDeclContext();
-        if (auto proto = dyn_cast<ProtocolDecl>(dc))
-          if (proto->isObjC())
-            next = next.asForeign();
       }
       
       // Preserve whether the curry thunks lead to a direct reference to the
@@ -620,7 +614,7 @@ static SILValue getNextUncurryLevelRef(SILGenFunction &gen,
       thisArg = curriedArgs.back();
 
   if (isa<AbstractFunctionDecl>(next.getDecl()) &&
-      gen.getMethodDispatch(cast<AbstractFunctionDecl>(next.getDecl()))
+      getMethodDispatch(cast<AbstractFunctionDecl>(next.getDecl()))
         == MethodDispatch::Class) {
     SILValue thisArg = curriedArgs.back();
 
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
index 2692559bc6ad1..182e5b42ce801 100644
--- a/lib/SILGen/SILGenFunction.h
+++ b/lib/SILGen/SILGenFunction.h
@@ -31,14 +31,6 @@ class LValue;
 class ManagedValue;
 class RValue;
 class TemporaryInitialization;
-
-/// How a method is dispatched.
-enum class MethodDispatch {
-  // The method implementation can be referenced statically.
-  Static,
-  // The method implementation uses class_method dispatch.
-  Class,
-};
   
 /// Internal context information for the SILGenFunction visitor.
 ///
@@ -1540,9 +1532,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// intrinsic.
   Substitution getPointerSubstitution(Type pointerType,
                                       ArchetypeType *archetype);
-  
-  /// Get the method dispatch mechanism for a method.
-  MethodDispatch getMethodDispatch(AbstractFunctionDecl *method);
 };
 
 
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
index fc87a4f37db4c..9a4044bd97715 100644
--- a/lib/SILGen/SILGenType.cpp
+++ b/lib/SILGen/SILGenType.cpp
@@ -136,47 +136,6 @@ bool SILGenModule::requiresObjCMethodEntryPoint(ConstructorDecl *constructor) {
   return constructor->isObjC();
 }
 
-bool SILGenModule::requiresObjCDispatch(ValueDecl *vd) {
-  // Final functions never require ObjC dispatch.
-  if (vd->isFinal())
-    return false;
-
-  // If the decl is an @objc protocol requirement, then the only witness is
-  // objc.
-  if (auto *proto = dyn_cast<ProtocolDecl>(vd->getDeclContext()))
-    if (proto->isObjC())
-      return true;
-
-  if (auto *fd = dyn_cast<FuncDecl>(vd)) {
-    // If a function has an associated Clang node, it's foreign and only has
-    // an ObjC entry point.
-    if (vd->hasClangNode())
-      return true;
-
-    // Property accessors should be generated alongside the property.
-    if (fd->isGetterOrSetter())
-      return requiresObjCDispatch(fd->getAccessorStorageDecl());
-
-    return fd->getAttrs().hasAttribute<DynamicAttr>();
-  }
-  if (auto *cd = dyn_cast<ConstructorDecl>(vd)) {
-    // If a function has an associated Clang node, it's foreign and only has
-    // an ObjC entry point.
-    if (vd->hasClangNode())
-      return true;
-    
-    return cd->getAttrs().hasAttribute<DynamicAttr>();
-  }
-  if (auto *asd = dyn_cast<AbstractStorageDecl>(vd))
-    return asd->requiresObjCGetterAndSetter();
-
-  return vd->getAttrs().hasAttribute<DynamicAttr>();
-}
-
-bool SILGenModule::requiresObjCSuperDispatch(ValueDecl *vd) {
-  return requiresObjCDispatch(vd);
-}
-
 namespace {
 
 /// An ASTVisitor for populating SILVTable entries from ClassDecl members.

From f6e4355b698aaa36625d659a98ee1497a16d42ef Mon Sep 17 00:00:00 2001
From: Slava Pestov <spestov@apple.com>
Date: Fri, 11 Dec 2015 07:10:03 -0800
Subject: [PATCH 11/15] Sema: Fix monthly TypeNullifier bug

This time, the issue is that TypeNullifier skips bodies of
multi-statement closures. However, ExprRewriter will type
happily pass them on to typeCheckClosureBody(). This could
trigger assertions. Fix this by skipping type checking of
multi-statement closures when diagnosing.

There seems to be a minor QoI regression in some test cases
that already looked pretty dodgy and/or had FIXMEs. However
I think its worth fixing a crash.
---
 lib/Sema/CSApply.cpp                          | 27 ++++++++++++++-----
 lib/Sema/CSDiag.cpp                           |  4 +++
 lib/Sema/ConstraintSystem.h                   |  7 ++++-
 lib/Sema/TypeCheckConstraints.cpp             |  3 ++-
 lib/Sema/TypeChecker.h                        |  4 +++
 test/Constraints/closures.swift               | 11 ++++++++
 test/Constraints/diagnostics.swift            |  5 ++--
 test/Constraints/patterns.swift               |  6 ++---
 test/Constraints/subscript.swift              |  2 +-
 test/stmt/statements.swift                    |  2 +-
 .../26963-checkenumrawvalues.swift            |  2 +-
 ...typechecker-definedefaultconstructor.swift |  2 +-
 .../27019-swift-genericfunctiontype-get.swift |  2 +-
 ...ft-constraints-solution-simplifytype.swift |  2 +-
 .../27094-resolveidenttypecomponent.swift     |  2 +-
 .../27098-swift-type-transform.swift          |  2 +-
 .../27178-vtable.swift                        |  2 +-
 ...7291-swift-modulefile-getdeclcontext.swift |  2 +-
 .../27298-swift-modulefile-gettype.swift      |  2 +-
 ...tsystem-simplifyconformstoconstraint.swift |  2 +-
 ...addtypevariableconstraintstoworklist.swift |  2 +-
 .../27756-swift-modulefile-gettype.swift      |  2 +-
 ...27-swift-constraints-simplifylocator.swift |  2 +-
 ...constraintsystem-optimizeconstraints.swift |  2 +-
 .../27885-bool.swift                          |  2 +-
 ...7925-swift-modulefile-loadextensions.swift |  2 +-
 ...rter-implementation-importattributes.swift |  2 +-
 ...-swift-genericsignature-getcanonical.swift |  2 +-
 .../27980-matchcallarguments.swift            |  2 +-
 ...nts-constraintgraphnode-getadjacency.swift |  2 +-
 ...aintlocatorbuilder-trysimplifytoexpr.swift |  2 +-
 ...28087-swift-genericsignature-profile.swift |  2 +-
 ...typedecl-markinvalidgenericsignature.swift |  2 +-
 .../28097-swift-astprinter-printname.swift    |  2 +-
 ...-swift-constraints-constraint-create.swift |  2 +-
 .../28149-addcurriedselftype.swift            |  2 +-
 .../28154-swift-genericsignature-get.swift    |  2 +-
 37 files changed, 81 insertions(+), 44 deletions(-)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/26963-checkenumrawvalues.swift (79%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/26989-swift-typechecker-definedefaultconstructor.swift (81%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27019-swift-genericfunctiontype-get.swift (81%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27024-swift-constraints-solution-simplifytype.swift (81%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27094-resolveidenttypecomponent.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27098-swift-type-transform.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27178-vtable.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27291-swift-modulefile-getdeclcontext.swift (86%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27298-swift-modulefile-gettype.swift (97%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift (83%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27756-swift-modulefile-gettype.swift (79%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27827-swift-constraints-simplifylocator.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27870-swift-constraints-constraintsystem-optimizeconstraints.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27885-bool.swift (78%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27925-swift-modulefile-loadextensions.swift (82%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27930-swift-clangimporter-implementation-importattributes.swift (79%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27934-swift-genericsignature-getcanonical.swift (81%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/27980-matchcallarguments.swift (80%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28005-swift-constraints-constraintgraphnode-getadjacency.swift (82%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift (85%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28087-swift-genericsignature-profile.swift (97%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift (88%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28097-swift-astprinter-printname.swift (81%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28101-swift-constraints-constraint-create.swift (82%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28149-addcurriedselftype.swift (82%)
 rename validation-test/{compiler_crashers => compiler_crashers_fixed}/28154-swift-genericsignature-get.swift (85%)

diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
index 1fb4a3a89fc59..e60a149900478 100644
--- a/lib/Sema/CSApply.cpp
+++ b/lib/Sema/CSApply.cpp
@@ -295,6 +295,7 @@ namespace {
     DeclContext *dc;
     const Solution &solution;
     bool SuppressDiagnostics;
+    bool SkipClosures;
 
   private:
     /// \brief Coerce the given tuple to another tuple type.
@@ -1468,9 +1469,10 @@ namespace {
     
   public:
     ExprRewriter(ConstraintSystem &cs, const Solution &solution,
-                 bool suppressDiagnostics)
+                 bool suppressDiagnostics, bool skipClosures)
       : cs(cs), dc(cs.DC), solution(solution), 
-        SuppressDiagnostics(suppressDiagnostics) { }
+        SuppressDiagnostics(suppressDiagnostics),
+        SkipClosures(skipClosures) { }
 
     ConstraintSystem &getConstraintSystem() const { return cs; }
 
@@ -5646,6 +5648,11 @@ namespace {
     ExprWalker(ExprRewriter &Rewriter) : Rewriter(Rewriter) { }
 
     ~ExprWalker() {
+      // If we're re-typechecking an expression for diagnostics, don't
+      // visit closures that have non-single expression bodies.
+      if (Rewriter.SkipClosures)
+        return;
+
       auto &cs = Rewriter.getConstraintSystem();
       auto &tc = cs.getTypeChecker();
       for (auto *closure : closuresToTypeCheck)
@@ -6126,7 +6133,8 @@ bool ConstraintSystem::applySolutionFix(Expr *expr,
 Expr *ConstraintSystem::applySolution(Solution &solution, Expr *expr,
                                       Type convertType,
                                       bool discardedExpr,
-                                      bool suppressDiagnostics) {
+                                      bool suppressDiagnostics,
+                                      bool skipClosures) {
   // If any fixes needed to be applied to arrive at this solution, resolve
   // them to specific expressions.
   if (!solution.Fixes.empty()) {
@@ -6141,7 +6149,7 @@ Expr *ConstraintSystem::applySolution(Solution &solution, Expr *expr,
     return nullptr;
   }
 
-  ExprRewriter rewriter(*this, solution, suppressDiagnostics);
+  ExprRewriter rewriter(*this, solution, suppressDiagnostics, skipClosures);
   ExprWalker walker(rewriter);
 
   // Apply the solution to the expression.
@@ -6171,7 +6179,8 @@ Expr *ConstraintSystem::applySolution(Solution &solution, Expr *expr,
 Expr *ConstraintSystem::applySolutionShallow(const Solution &solution,
                                              Expr *expr,
                                              bool suppressDiagnostics) {
-  ExprRewriter rewriter(*this, solution, suppressDiagnostics);
+  ExprRewriter rewriter(*this, solution, suppressDiagnostics,
+                        /*skipClosures=*/false);
   rewriter.walkToExprPre(expr);
   Expr *result = rewriter.walkToExprPost(expr);
   if (result)
@@ -6183,7 +6192,9 @@ Expr *Solution::coerceToType(Expr *expr, Type toType,
                              ConstraintLocator *locator,
                              bool ignoreTopLevelInjection) const {
   auto &cs = getConstraintSystem();
-  ExprRewriter rewriter(cs, *this, /*suppressDiagnostics=*/false);
+  ExprRewriter rewriter(cs, *this,
+                        /*suppressDiagnostics=*/false,
+                        /*skipClosures=*/false);
   Expr *result = rewriter.coerceToType(expr, toType, locator);
   if (!result)
     return nullptr;
@@ -6309,7 +6320,9 @@ Expr *TypeChecker::callWitness(Expr *base, DeclContext *dc,
   }
 
   Solution &solution = solutions.front();
-  ExprRewriter rewriter(cs, solution, /*suppressDiagnostics=*/false);
+  ExprRewriter rewriter(cs, solution,
+                        /*suppressDiagnostics=*/false,
+                        /*skipClosures=*/false);
 
   auto memberRef = rewriter.buildMemberRef(base, openedFullType,
                                            base->getStartLoc(),
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
index 4cae243df7772..8a712af9c08eb 100644
--- a/lib/Sema/CSDiag.cpp
+++ b/lib/Sema/CSDiag.cpp
@@ -2897,6 +2897,10 @@ typeCheckChildIndependently(Expr *subExpr, Type convertType,
   // the context is missing).
   TypeCheckExprOptions TCEOptions = TypeCheckExprFlags::DisableStructuralChecks;
 
+  // Don't walk into non-single expression closure bodies, because
+  // ExprTypeSaver and TypeNullifier skip them too.
+  TCEOptions |= TypeCheckExprFlags::SkipMultiStmtClosures;
+
   // Claim that the result is discarded to preserve the lvalue type of
   // the expression.
   if (options.contains(TCC_AllowLValue))
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
index c416e400ef85e..9f0fdb7ad1172 100644
--- a/lib/Sema/ConstraintSystem.h
+++ b/lib/Sema/ConstraintSystem.h
@@ -2368,9 +2368,14 @@ class ConstraintSystem {
   ///
   /// \param convertType the contextual type to which the
   /// expression should be converted, if any.
+  /// \param discardedExpr if true, the result of the expression
+  /// is contextually ignored.
+  /// \param skipClosures if true, don't descend into bodies of
+  /// non-single expression closures.
   Expr *applySolution(Solution &solution, Expr *expr,
                       Type convertType, bool discardedExpr,
-                      bool suppressDiagnostics);
+                      bool suppressDiagnostics,
+                      bool skipClosures);
 
   /// \brief Apply a given solution to the expression to the top-level
   /// expression, producing a fully type-checked expression.
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
index fa365becc67db..7de87eb8b1abb 100644
--- a/lib/Sema/TypeCheckConstraints.cpp
+++ b/lib/Sema/TypeCheckConstraints.cpp
@@ -1188,8 +1188,9 @@ bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
   // Apply the solution to the expression.
   auto &solution = viable[0];
   bool isDiscarded = options.contains(TypeCheckExprFlags::IsDiscarded);
+  bool skipClosures = options.contains(TypeCheckExprFlags::SkipMultiStmtClosures);
   auto result = cs.applySolution(solution, expr, convertType, isDiscarded,
-                                 suppressDiagnostics);
+                                 suppressDiagnostics, skipClosures);
   if (!result) {
     // Failure already diagnosed, above, as part of applying the solution.
     return true;
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
index 131fae43db351..53d55d969d2b4 100644
--- a/lib/Sema/TypeChecker.h
+++ b/lib/Sema/TypeChecker.h
@@ -194,6 +194,10 @@ enum class TypeCheckExprFlags {
   /// statement. This should only be used for syntactic restrictions, and should
   /// not affect type checking itself.
   IsExprStmt = 0x20,
+  
+  /// If set, this expression is being re-type checked as part of diagnostics,
+  /// and so we should not visit bodies of non-single expression closures.
+  SkipMultiStmtClosures = 0x40,
 };
   
 typedef OptionSet<TypeCheckExprFlags> TypeCheckExprOptions;
diff --git a/test/Constraints/closures.swift b/test/Constraints/closures.swift
index b173e82783b7d..7d94e4f59b5d5 100644
--- a/test/Constraints/closures.swift
+++ b/test/Constraints/closures.swift
@@ -162,3 +162,14 @@ func r15998821() {
 var _: (Int,Int)-> Int = {$0+$1+$2}  // expected-error {{contextual closure type '(Int, Int) -> Int' expects 2 arguments, but 3 were used in closure body}}
 
 
+// Crash when re-typechecking bodies of non-single expression closures
+
+struct CC {}
+func callCC<U>(f: CC -> U) -> () {}
+
+func typeCheckMultiStmtClosureCrash() {
+  callCC { // expected-error {{cannot invoke 'callCC' with an argument list of type '((CC) -> _)'}}
+    _ = $0 // expected-note@-1 {{expected an argument list of type '(CC -> U)'}}
+    return 1
+  }
+}
diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift
index 696e869727d45..1a677cdb08734 100644
--- a/test/Constraints/diagnostics.swift
+++ b/test/Constraints/diagnostics.swift
@@ -117,7 +117,7 @@ func rdar20142523() {
   map(0..<10, { x in // expected-error{{cannot invoke 'map' with an argument list of type '(Range<Int>, (_) -> _)'}}
     // expected-note @-1 {{overloads for 'map' exist with these partially matching parameter lists: (C, (C.Generator.Element) -> T), (T?, @noescape (T) -> U)}}
     ()
-    return x  // expected-error {{type of expression is ambiguous without more context}}
+    return x
   })
 }
 
@@ -425,8 +425,7 @@ func f20371273() {
 // FIXME: Should complain about not having a return type annotation in the closure.
 [0].map { _ in let r =  (1,2).0;  return r }
 // expected-error @-1 {{cannot invoke 'map' with an argument list of type '(@noescape (Int) throws -> _)'}}
-// expected-error @-2 {{cannot convert return expression of type 'Int' to return type 'T'}}
-// expected-note @-3 {{expected an argument list of type '(@noescape Int throws -> T)'}}
+// expected-note @-2 {{expected an argument list of type '(@noescape Int throws -> T)'}}
 
 // <rdar://problem/21078316> Less than useful error message when using map on optional dictionary type
 func rdar21078316() {
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
index 6afa2e3600570..c7a0c3ef6f0ef 100644
--- a/test/Constraints/patterns.swift
+++ b/test/Constraints/patterns.swift
@@ -212,7 +212,7 @@ func bad(a: A<EE>) {
   a.map { // expected-error {{cannot invoke 'map' with an argument list of type '((EE) -> _)'}}
   // expected-note@-1 {{expected an argument list of type '(EE -> T)'}}
     let _: EE = $0
-    return 1 // expected-error {{cannot convert return expression of type 'Int' to return type 'T'}}
+    return 1
   }
 }
 
@@ -221,9 +221,9 @@ func ugly(a: A<EE>) {
   // expected-note@-1 {{expected an argument list of type '(EE -> T)'}}
     switch $0 {
     case .A:
-      return 1 // expected-error {{cannot convert return expression of type 'Int' to return type 'T'}}
+      return 1
     default:
-      return 2 // expected-error {{cannot convert return expression of type 'Int' to return type 'T'}}
+      return 2
     }
   }
 }
diff --git a/test/Constraints/subscript.swift b/test/Constraints/subscript.swift
index 21d015635ec65..0dd8afcc8af05 100644
--- a/test/Constraints/subscript.swift
+++ b/test/Constraints/subscript.swift
@@ -74,7 +74,7 @@ let _ = 1["1"]  // expected-error {{ambiguous use of 'subscript'}}
 // rdar://17687826 - QoI: error message when reducing to an untyped dictionary isn't helpful
 let squares = [ 1, 2, 3 ].reduce([:]) { (dict, n) in // expected-error {{cannot invoke 'reduce' with an argument list of type '([_ : _], @noescape (_, Int) throws -> _)'}}
   // expected-note @-1 {{expected an argument list of type '(T, combine: @noescape (T, Int) throws -> T)'}}
-  var dict = dict // expected-error {{type of expression is ambiguous without more context}}
+  var dict = dict
 
   dict[n] = n * n
   return dict
diff --git a/test/stmt/statements.swift b/test/stmt/statements.swift
index c3d9a04b2ceb3..87d73fba54cc7 100644
--- a/test/stmt/statements.swift
+++ b/test/stmt/statements.swift
@@ -403,7 +403,7 @@ func test_is_as_patterns() {
 func matching_pattern_recursion() {
   switch 42 {
   case {  // expected-error {{expression pattern of type '() -> ()' cannot match values of type 'Int'}}
-      for i in zs {  // expected-error {{use of unresolved identifier 'zs'}}
+      for i in zs {
       }
   }: break
   }
diff --git a/validation-test/compiler_crashers/26963-checkenumrawvalues.swift b/validation-test/compiler_crashers_fixed/26963-checkenumrawvalues.swift
similarity index 79%
rename from validation-test/compiler_crashers/26963-checkenumrawvalues.swift
rename to validation-test/compiler_crashers_fixed/26963-checkenumrawvalues.swift
index 0f703884ddd99..6f4217ee8ac14 100644
--- a/validation-test/compiler_crashers/26963-checkenumrawvalues.swift
+++ b/validation-test/compiler_crashers_fixed/26963-checkenumrawvalues.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/26989-swift-typechecker-definedefaultconstructor.swift b/validation-test/compiler_crashers_fixed/26989-swift-typechecker-definedefaultconstructor.swift
similarity index 81%
rename from validation-test/compiler_crashers/26989-swift-typechecker-definedefaultconstructor.swift
rename to validation-test/compiler_crashers_fixed/26989-swift-typechecker-definedefaultconstructor.swift
index 794133f0ea756..e88867aa60704 100644
--- a/validation-test/compiler_crashers/26989-swift-typechecker-definedefaultconstructor.swift
+++ b/validation-test/compiler_crashers_fixed/26989-swift-typechecker-definedefaultconstructor.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27019-swift-genericfunctiontype-get.swift b/validation-test/compiler_crashers_fixed/27019-swift-genericfunctiontype-get.swift
similarity index 81%
rename from validation-test/compiler_crashers/27019-swift-genericfunctiontype-get.swift
rename to validation-test/compiler_crashers_fixed/27019-swift-genericfunctiontype-get.swift
index 269977fe8fc65..50f6d21435371 100644
--- a/validation-test/compiler_crashers/27019-swift-genericfunctiontype-get.swift
+++ b/validation-test/compiler_crashers_fixed/27019-swift-genericfunctiontype-get.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27024-swift-constraints-solution-simplifytype.swift b/validation-test/compiler_crashers_fixed/27024-swift-constraints-solution-simplifytype.swift
similarity index 81%
rename from validation-test/compiler_crashers/27024-swift-constraints-solution-simplifytype.swift
rename to validation-test/compiler_crashers_fixed/27024-swift-constraints-solution-simplifytype.swift
index a739464db052e..3bc837819697d 100644
--- a/validation-test/compiler_crashers/27024-swift-constraints-solution-simplifytype.swift
+++ b/validation-test/compiler_crashers_fixed/27024-swift-constraints-solution-simplifytype.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27094-resolveidenttypecomponent.swift b/validation-test/compiler_crashers_fixed/27094-resolveidenttypecomponent.swift
similarity index 80%
rename from validation-test/compiler_crashers/27094-resolveidenttypecomponent.swift
rename to validation-test/compiler_crashers_fixed/27094-resolveidenttypecomponent.swift
index ae033733c3300..1a66235fad16b 100644
--- a/validation-test/compiler_crashers/27094-resolveidenttypecomponent.swift
+++ b/validation-test/compiler_crashers_fixed/27094-resolveidenttypecomponent.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27098-swift-type-transform.swift b/validation-test/compiler_crashers_fixed/27098-swift-type-transform.swift
similarity index 80%
rename from validation-test/compiler_crashers/27098-swift-type-transform.swift
rename to validation-test/compiler_crashers_fixed/27098-swift-type-transform.swift
index 5c080e95521ad..561245b28460f 100644
--- a/validation-test/compiler_crashers/27098-swift-type-transform.swift
+++ b/validation-test/compiler_crashers_fixed/27098-swift-type-transform.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27178-vtable.swift b/validation-test/compiler_crashers_fixed/27178-vtable.swift
similarity index 80%
rename from validation-test/compiler_crashers/27178-vtable.swift
rename to validation-test/compiler_crashers_fixed/27178-vtable.swift
index a73c3d7966c2c..0b8d53ed52d11 100644
--- a/validation-test/compiler_crashers/27178-vtable.swift
+++ b/validation-test/compiler_crashers_fixed/27178-vtable.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27291-swift-modulefile-getdeclcontext.swift b/validation-test/compiler_crashers_fixed/27291-swift-modulefile-getdeclcontext.swift
similarity index 86%
rename from validation-test/compiler_crashers/27291-swift-modulefile-getdeclcontext.swift
rename to validation-test/compiler_crashers_fixed/27291-swift-modulefile-getdeclcontext.swift
index 54c5e192e9cf9..7a9fea12e2e5d 100644
--- a/validation-test/compiler_crashers/27291-swift-modulefile-getdeclcontext.swift
+++ b/validation-test/compiler_crashers_fixed/27291-swift-modulefile-getdeclcontext.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27298-swift-modulefile-gettype.swift b/validation-test/compiler_crashers_fixed/27298-swift-modulefile-gettype.swift
similarity index 97%
rename from validation-test/compiler_crashers/27298-swift-modulefile-gettype.swift
rename to validation-test/compiler_crashers_fixed/27298-swift-modulefile-gettype.swift
index 6edede4dde96a..412354d9eda0e 100644
--- a/validation-test/compiler_crashers/27298-swift-modulefile-gettype.swift
+++ b/validation-test/compiler_crashers_fixed/27298-swift-modulefile-gettype.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift b/validation-test/compiler_crashers_fixed/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift
similarity index 80%
rename from validation-test/compiler_crashers/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift
rename to validation-test/compiler_crashers_fixed/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift
index 5393202de9aaa..c57acd6fa30d9 100644
--- a/validation-test/compiler_crashers/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift
+++ b/validation-test/compiler_crashers_fixed/27417-swift-constraints-constraintsystem-simplifyconformstoconstraint.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift b/validation-test/compiler_crashers_fixed/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift
similarity index 83%
rename from validation-test/compiler_crashers/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift
rename to validation-test/compiler_crashers_fixed/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift
index 8b3b3c8684028..b531afa558b07 100644
--- a/validation-test/compiler_crashers/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift
+++ b/validation-test/compiler_crashers_fixed/27465-swift-constraints-constraintsystem-addtypevariableconstraintstoworklist.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27756-swift-modulefile-gettype.swift b/validation-test/compiler_crashers_fixed/27756-swift-modulefile-gettype.swift
similarity index 79%
rename from validation-test/compiler_crashers/27756-swift-modulefile-gettype.swift
rename to validation-test/compiler_crashers_fixed/27756-swift-modulefile-gettype.swift
index 778871fe1e161..fa76f403becbd 100644
--- a/validation-test/compiler_crashers/27756-swift-modulefile-gettype.swift
+++ b/validation-test/compiler_crashers_fixed/27756-swift-modulefile-gettype.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27827-swift-constraints-simplifylocator.swift b/validation-test/compiler_crashers_fixed/27827-swift-constraints-simplifylocator.swift
similarity index 80%
rename from validation-test/compiler_crashers/27827-swift-constraints-simplifylocator.swift
rename to validation-test/compiler_crashers_fixed/27827-swift-constraints-simplifylocator.swift
index 72f654b74a4b5..2f8ea45d229c1 100644
--- a/validation-test/compiler_crashers/27827-swift-constraints-simplifylocator.swift
+++ b/validation-test/compiler_crashers_fixed/27827-swift-constraints-simplifylocator.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27870-swift-constraints-constraintsystem-optimizeconstraints.swift b/validation-test/compiler_crashers_fixed/27870-swift-constraints-constraintsystem-optimizeconstraints.swift
similarity index 80%
rename from validation-test/compiler_crashers/27870-swift-constraints-constraintsystem-optimizeconstraints.swift
rename to validation-test/compiler_crashers_fixed/27870-swift-constraints-constraintsystem-optimizeconstraints.swift
index f9f9435c3c2d1..ff2a1ad48ce7a 100644
--- a/validation-test/compiler_crashers/27870-swift-constraints-constraintsystem-optimizeconstraints.swift
+++ b/validation-test/compiler_crashers_fixed/27870-swift-constraints-constraintsystem-optimizeconstraints.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27885-bool.swift b/validation-test/compiler_crashers_fixed/27885-bool.swift
similarity index 78%
rename from validation-test/compiler_crashers/27885-bool.swift
rename to validation-test/compiler_crashers_fixed/27885-bool.swift
index 1fadbd0b79b25..0cb994c901292 100644
--- a/validation-test/compiler_crashers/27885-bool.swift
+++ b/validation-test/compiler_crashers_fixed/27885-bool.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27925-swift-modulefile-loadextensions.swift b/validation-test/compiler_crashers_fixed/27925-swift-modulefile-loadextensions.swift
similarity index 82%
rename from validation-test/compiler_crashers/27925-swift-modulefile-loadextensions.swift
rename to validation-test/compiler_crashers_fixed/27925-swift-modulefile-loadextensions.swift
index 1b168b03b9c07..48c9c92f1830e 100644
--- a/validation-test/compiler_crashers/27925-swift-modulefile-loadextensions.swift
+++ b/validation-test/compiler_crashers_fixed/27925-swift-modulefile-loadextensions.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27930-swift-clangimporter-implementation-importattributes.swift b/validation-test/compiler_crashers_fixed/27930-swift-clangimporter-implementation-importattributes.swift
similarity index 79%
rename from validation-test/compiler_crashers/27930-swift-clangimporter-implementation-importattributes.swift
rename to validation-test/compiler_crashers_fixed/27930-swift-clangimporter-implementation-importattributes.swift
index bb022f71c0dd8..ee228502e505b 100644
--- a/validation-test/compiler_crashers/27930-swift-clangimporter-implementation-importattributes.swift
+++ b/validation-test/compiler_crashers_fixed/27930-swift-clangimporter-implementation-importattributes.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27934-swift-genericsignature-getcanonical.swift b/validation-test/compiler_crashers_fixed/27934-swift-genericsignature-getcanonical.swift
similarity index 81%
rename from validation-test/compiler_crashers/27934-swift-genericsignature-getcanonical.swift
rename to validation-test/compiler_crashers_fixed/27934-swift-genericsignature-getcanonical.swift
index 5f27922447ed5..b5eaf8fd24dd4 100644
--- a/validation-test/compiler_crashers/27934-swift-genericsignature-getcanonical.swift
+++ b/validation-test/compiler_crashers_fixed/27934-swift-genericsignature-getcanonical.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/27980-matchcallarguments.swift b/validation-test/compiler_crashers_fixed/27980-matchcallarguments.swift
similarity index 80%
rename from validation-test/compiler_crashers/27980-matchcallarguments.swift
rename to validation-test/compiler_crashers_fixed/27980-matchcallarguments.swift
index df3837a5a278c..68d9eb325fb7f 100644
--- a/validation-test/compiler_crashers/27980-matchcallarguments.swift
+++ b/validation-test/compiler_crashers_fixed/27980-matchcallarguments.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28005-swift-constraints-constraintgraphnode-getadjacency.swift b/validation-test/compiler_crashers_fixed/28005-swift-constraints-constraintgraphnode-getadjacency.swift
similarity index 82%
rename from validation-test/compiler_crashers/28005-swift-constraints-constraintgraphnode-getadjacency.swift
rename to validation-test/compiler_crashers_fixed/28005-swift-constraints-constraintgraphnode-getadjacency.swift
index a026a24cff1b6..a84bd0f0d7dfe 100644
--- a/validation-test/compiler_crashers/28005-swift-constraints-constraintgraphnode-getadjacency.swift
+++ b/validation-test/compiler_crashers_fixed/28005-swift-constraints-constraintgraphnode-getadjacency.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift b/validation-test/compiler_crashers_fixed/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift
similarity index 85%
rename from validation-test/compiler_crashers/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift
rename to validation-test/compiler_crashers_fixed/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift
index f9b5af9117002..23471a72552ae 100644
--- a/validation-test/compiler_crashers/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift
+++ b/validation-test/compiler_crashers_fixed/28024-swift-constraints-constraintlocatorbuilder-trysimplifytoexpr.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28087-swift-genericsignature-profile.swift b/validation-test/compiler_crashers_fixed/28087-swift-genericsignature-profile.swift
similarity index 97%
rename from validation-test/compiler_crashers/28087-swift-genericsignature-profile.swift
rename to validation-test/compiler_crashers_fixed/28087-swift-genericsignature-profile.swift
index da6776e8a2c36..f907cbd722ffd 100644
--- a/validation-test/compiler_crashers/28087-swift-genericsignature-profile.swift
+++ b/validation-test/compiler_crashers_fixed/28087-swift-genericsignature-profile.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift b/validation-test/compiler_crashers_fixed/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift
similarity index 88%
rename from validation-test/compiler_crashers/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift
rename to validation-test/compiler_crashers_fixed/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift
index e26d28e190e92..b37ef7d422021 100644
--- a/validation-test/compiler_crashers/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift
+++ b/validation-test/compiler_crashers_fixed/28088-swift-nominaltypedecl-markinvalidgenericsignature.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28097-swift-astprinter-printname.swift b/validation-test/compiler_crashers_fixed/28097-swift-astprinter-printname.swift
similarity index 81%
rename from validation-test/compiler_crashers/28097-swift-astprinter-printname.swift
rename to validation-test/compiler_crashers_fixed/28097-swift-astprinter-printname.swift
index 3ee2742d90287..6820448ff132f 100644
--- a/validation-test/compiler_crashers/28097-swift-astprinter-printname.swift
+++ b/validation-test/compiler_crashers_fixed/28097-swift-astprinter-printname.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28101-swift-constraints-constraint-create.swift b/validation-test/compiler_crashers_fixed/28101-swift-constraints-constraint-create.swift
similarity index 82%
rename from validation-test/compiler_crashers/28101-swift-constraints-constraint-create.swift
rename to validation-test/compiler_crashers_fixed/28101-swift-constraints-constraint-create.swift
index 1a83c063df957..eeef991c5294a 100644
--- a/validation-test/compiler_crashers/28101-swift-constraints-constraint-create.swift
+++ b/validation-test/compiler_crashers_fixed/28101-swift-constraints-constraint-create.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28149-addcurriedselftype.swift b/validation-test/compiler_crashers_fixed/28149-addcurriedselftype.swift
similarity index 82%
rename from validation-test/compiler_crashers/28149-addcurriedselftype.swift
rename to validation-test/compiler_crashers_fixed/28149-addcurriedselftype.swift
index c70af27d13ffa..25409520c0faa 100644
--- a/validation-test/compiler_crashers/28149-addcurriedselftype.swift
+++ b/validation-test/compiler_crashers_fixed/28149-addcurriedselftype.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
diff --git a/validation-test/compiler_crashers/28154-swift-genericsignature-get.swift b/validation-test/compiler_crashers_fixed/28154-swift-genericsignature-get.swift
similarity index 85%
rename from validation-test/compiler_crashers/28154-swift-genericsignature-get.swift
rename to validation-test/compiler_crashers_fixed/28154-swift-genericsignature-get.swift
index 996600fe78b3d..611b0d7d3b1f9 100644
--- a/validation-test/compiler_crashers/28154-swift-genericsignature-get.swift
+++ b/validation-test/compiler_crashers_fixed/28154-swift-genericsignature-get.swift
@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)

From 2a34a62ce13f230a1625f65989e3b9278ca2897f Mon Sep 17 00:00:00 2001
From: Slava Pestov <spestov@apple.com>
Date: Fri, 11 Dec 2015 09:46:10 -0800
Subject: [PATCH 12/15] Fix some compiler_crashers that regressed recently

---
 lib/Sema/CSDiag.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
index 8a712af9c08eb..3f0fb751239ec 100644
--- a/lib/Sema/CSDiag.cpp
+++ b/lib/Sema/CSDiag.cpp
@@ -1702,7 +1702,11 @@ bool CalleeCandidateInfo::diagnoseAnyStructuralArgumentError(Expr *fnExpr,
   
   
   auto args = decomposeArgParamType(argExpr->getType());
-  auto params = decomposeArgParamType(candidates[0].getArgumentType());
+
+  auto argTy = candidates[0].getArgumentType();
+  if (!argTy) return false;
+
+  auto params = decomposeArgParamType(argTy);
 
   // It is a somewhat common error to try to access an instance method as a
   // curried member on the type, instead of using an instance, e.g. the user

From fb9f5647ddd3a1de134893d0d864f607e82ea6da Mon Sep 17 00:00:00 2001
From: Erik Eckstein <eeckstein@apple.com>
Date: Fri, 11 Dec 2015 09:20:45 -0800
Subject: [PATCH 13/15] [StackPromotion] fix the declaration of
 swift_buffer[De]AllocateOnStack.

This caused a linker failure on linux for some stdlib unit tests.
rdar://problem/23849414
---
 lib/SILPasses/Scalar/StackPromotion.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/SILPasses/Scalar/StackPromotion.cpp b/lib/SILPasses/Scalar/StackPromotion.cpp
index d17ec071b3fda..73752b08e17f5 100644
--- a/lib/SILPasses/Scalar/StackPromotion.cpp
+++ b/lib/SILPasses/Scalar/StackPromotion.cpp
@@ -251,7 +251,8 @@ SILFunction *StackPromoter::getBufferAllocFunc(SILFunction *OrigFunc,
                           "swift_bufferAllocateOnStack",
                           OrigFunc->getLinkage(),
                           OrigFunc->getLoweredFunctionType(),
-                          OrigFunc->isBare(), IsNotTransparent, IsNotFragile);
+                          OrigFunc->isBare(), IsNotTransparent,
+                          OrigFunc->isFragile());
   }
   return BufferAllocFunc;
 }
@@ -279,7 +280,7 @@ SILFunction *StackPromoter::getBufferDeallocFunc(SILFunction *OrigFunc,
       "swift_bufferDeallocateFromStack",
       OrigFunc->getLinkage(),
       FunTy,
-      OrigFunc->isBare(), IsNotTransparent, IsNotFragile);
+      OrigFunc->isBare(), IsNotTransparent, OrigFunc->isFragile());
   }
   return BufferDeallocFunc;
 }

From 94d2c2fcd0ab8e7a188cdf9ec237443c936cd9fb Mon Sep 17 00:00:00 2001
From: Erik Eckstein <eeckstein@apple.com>
Date: Fri, 11 Dec 2015 09:30:26 -0800
Subject: [PATCH 14/15] Remove a wrong TODO comment.

---
 lib/Serialization/SerializeSIL.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
index 0a6deac3158f9..65bfd2a3539a8 100644
--- a/lib/Serialization/SerializeSIL.cpp
+++ b/lib/Serialization/SerializeSIL.cpp
@@ -167,7 +167,6 @@ namespace {
                          << " for layout " << Layout::Code << "\n");
     }
 
-    // TODO: this is not required anymore. Remove it.
     bool ShouldSerializeAll;
 
     /// Helper function to update ListOfValues for MethodInst. Format:

From 689db1780060302e962cbe4735171fbea0fa6271 Mon Sep 17 00:00:00 2001
From: Erik Eckstein <eeckstein@apple.com>
Date: Fri, 11 Dec 2015 10:40:53 -0800
Subject: [PATCH 15/15] Resurrect call-graph dot viewing.

It's useful for debugging.
---
 include/swift/SILPasses/PassManager.h     |   5 +
 lib/SILPasses/PassManager/PassManager.cpp | 192 ++++++++++++++++++++++
 2 files changed, 197 insertions(+)

diff --git a/include/swift/SILPasses/PassManager.h b/include/swift/SILPasses/PassManager.h
index 6bbb04dc762f3..21082f20f163c 100644
--- a/include/swift/SILPasses/PassManager.h
+++ b/include/swift/SILPasses/PassManager.h
@@ -160,6 +160,11 @@ class SILPassManager {
   /// if the pass manager requested to stop the execution
   /// of the optimization cycle (this is a debug feature).
   bool runFunctionPasses(PassList FuncTransforms);
+
+  /// Displays the call graph in an external dot-viewer.
+  /// This function is meant for use from the debugger.
+  /// When asserts are disabled, this is a NoOp.
+  void viewCallGraph();
 };
 
 } // end namespace swift
diff --git a/lib/SILPasses/PassManager/PassManager.cpp b/lib/SILPasses/PassManager/PassManager.cpp
index a5cfc575401b4..2ca03b7e2bb2e 100644
--- a/lib/SILPasses/PassManager/PassManager.cpp
+++ b/lib/SILPasses/PassManager/PassManager.cpp
@@ -12,6 +12,7 @@
 
 #define DEBUG_TYPE "sil-passmanager"
 
+#include "swift/Basic/DemangleWrappers.h"
 #include "swift/SILPasses/PassManager.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILModule.h"
@@ -20,9 +21,11 @@
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "swift/SILAnalysis/FunctionOrder.h"
+#include "swift/SILAnalysis/BasicCalleeAnalysis.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TimeValue.h"
+#include "llvm/Support/GraphWriter.h"
 
 using namespace swift;
 
@@ -445,4 +448,193 @@ void SILPassManager::addPassForName(StringRef Name) {
   addPass(P);
 }
 
+//===----------------------------------------------------------------------===//
+//                          View Call-Graph Implementation
+//===----------------------------------------------------------------------===//
+
+#ifndef NDEBUG
+
+namespace {
+
+  /// An explicit graph data structure for the call graph.
+  /// Used for viewing the callgraph as dot file with llvm::ViewGraph.
+  struct CallGraph {
+
+    struct Node;
+
+    struct Edge {
+      FullApplySite FAS;
+      Node *Child;
+      bool Incomplete;
+    };
+
+    struct Node {
+      SILFunction *F;
+      CallGraph *CG;
+      int NumCallSites = 0;
+      SmallVector<Edge, 8> Children;
+    };
+
+    struct child_iterator : public std::iterator<std::random_access_iterator_tag,
+    Node *, ptrdiff_t> {
+      SmallVectorImpl<Edge>::iterator baseIter;
+
+      child_iterator(SmallVectorImpl<Edge>::iterator baseIter) :
+      baseIter(baseIter)
+      { }
+
+      child_iterator &operator++() { baseIter++; return *this; }
+      child_iterator operator++(int) { auto tmp = *this; baseIter++; return tmp; }
+      Node *operator*() const { return baseIter->Child; }
+      bool operator==(const child_iterator &RHS) const {
+        return baseIter == RHS.baseIter;
+      }
+      bool operator!=(const child_iterator &RHS) const {
+        return baseIter != RHS.baseIter;
+      }
+      difference_type operator-(const child_iterator &RHS) const {
+        return baseIter - RHS.baseIter;
+      }
+    };
+
+    CallGraph(SILModule *M, BasicCalleeAnalysis *BCA);
+
+    std::vector<Node> Nodes;
+
+    /// The SILValue IDs which are printed as edge source labels.
+    llvm::DenseMap<const ValueBase *, unsigned> InstToIDMap;
+
+    typedef std::vector<Node>::iterator iterator;
+  };
+
+  CallGraph::CallGraph(SILModule *M, BasicCalleeAnalysis *BCA) {
+    Nodes.resize(M->getFunctionList().size());
+    llvm::DenseMap<SILFunction *, Node *> NodeMap;
+    int idx = 0;
+    for (SILFunction &F : *M) {
+      Node &Nd = Nodes[idx++];
+      Nd.F = &F;
+      Nd.CG = this;
+      NodeMap[&F] = &Nd;
+
+      F.numberValues(InstToIDMap);
+    }
+
+    for (Node &Nd : Nodes) {
+      for (SILBasicBlock &BB : *Nd.F) {
+        for (SILInstruction &I : BB) {
+          if (FullApplySite FAS = FullApplySite::isa(&I)) {
+            auto CList = BCA->getCalleeList(FAS);
+            for (SILFunction *Callee : CList) {
+              Node *CalleeNode = NodeMap[Callee];
+              Nd.Children.push_back({FAS, CalleeNode,CList.isIncomplete()});
+            }
+          }
+        }
+      }
+    }
+  }
+
+} // end swift namespace
+
+namespace llvm {
+
+  /// Wraps a dot node label string to multiple lines. The \p NumEdgeLabels
+  /// gives an estimate on the minimum width of the node shape.
+  static void wrap(std::string &Str, int NumEdgeLabels) {
+    unsigned ColNum = 0;
+    unsigned LastSpace = 0;
+    unsigned MaxColumns = std::max(60, NumEdgeLabels * 8);
+    for (unsigned i = 0; i != Str.length(); ++i) {
+      if (ColNum == MaxColumns) {
+        if (!LastSpace)
+          LastSpace = i;
+        Str.insert(LastSpace + 1, "\\l");
+        ColNum = i - LastSpace - 1;
+        LastSpace = 0;
+      } else
+        ++ColNum;
+      if (Str[i] == ' ' || Str[i] == '.')
+        LastSpace = i;
+    }
+  }
 
+  /// CallGraph GraphTraits specialization so the CallGraph can be
+  /// iterable by generic graph iterators.
+  template <> struct GraphTraits<CallGraph::Node *> {
+    typedef CallGraph::Node NodeType;
+    typedef CallGraph::child_iterator ChildIteratorType;
+
+    static NodeType *getEntryNode(NodeType *N) { return N; }
+    static inline ChildIteratorType child_begin(NodeType *N) {
+      return N->Children.begin();
+    }
+    static inline ChildIteratorType child_end(NodeType *N) {
+      return N->Children.end();
+    }
+  };
+
+  template <> struct GraphTraits<CallGraph *>
+  : public GraphTraits<CallGraph::Node *> {
+    typedef CallGraph *GraphType;
+
+    static NodeType *getEntryNode(GraphType F) { return nullptr; }
+
+    typedef CallGraph::iterator nodes_iterator;
+    static nodes_iterator nodes_begin(GraphType CG) {
+      return CG->Nodes.begin();
+    }
+    static nodes_iterator nodes_end(GraphType CG) { return CG->Nodes.end(); }
+    static unsigned size(GraphType CG) { return CG->Nodes.size(); }
+  };
+
+  /// This is everything the llvm::GraphWriter needs to write the call graph in
+  /// a dot file.
+  template <>
+  struct DOTGraphTraits<CallGraph *> : public DefaultDOTGraphTraits {
+
+    DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
+
+    std::string getNodeLabel(const CallGraph::Node *Node,
+                             const CallGraph *Graph) {
+      std::string Label = Node->F->getName();
+      wrap(Label, Node->NumCallSites);
+      return Label;
+    }
+
+    std::string getNodeDescription(const CallGraph::Node *Node,
+                                   const CallGraph *Graph) {
+      std::string Label = demangle_wrappers::
+      demangleSymbolAsString(Node->F->getName());
+      wrap(Label, Node->NumCallSites);
+      return Label;
+    }
+
+    static std::string getEdgeSourceLabel(const CallGraph::Node *Node,
+                                          CallGraph::child_iterator I) {
+      std::string Label;
+      raw_string_ostream O(Label);
+      SILInstruction *Inst = I.baseIter->FAS.getInstruction();
+      O << '%' << Node->CG->InstToIDMap[Inst];
+      return Label;
+    }
+
+    static std::string getEdgeAttributes(const CallGraph::Node *Node,
+                                         CallGraph::child_iterator I,
+                                         const CallGraph *Graph) {
+      CallGraph::Edge *Edge = I.baseIter;
+      if (Edge->Incomplete)
+        return "color=\"red\"";
+      return "";
+    }
+  };
+} // end llvm namespace
+#endif
+
+void SILPassManager::viewCallGraph() {
+  /// When asserts are disabled, this should be a NoOp.
+#ifndef NDEBUG
+  CallGraph OCG(getModule(), getAnalysis<BasicCalleeAnalysis>());
+  llvm::ViewGraph(&OCG, "callgraph");
+#endif
+}