diff --git a/.pep8 b/.pep8
index 8d2e668..8d7296d 100644
--- a/.pep8
+++ b/.pep8
@@ -1,2 +1,2 @@
 [flake8]
-filename = *.py,80+-check,backtrace-check,Benchmark_Driver,Benchmark_DTrace.in,Benchmark_GuardMalloc.in,Benchmark_RuntimeLeaksRunner.in,build-script,check-incremental,clang++,coverage-build-db,coverage-generate-data,coverage-query-db,coverage-touch-tests,gyb,ld,line-directive,mock-distcc,ns-html2rst,PathSanitizingFileCheck,recursive-lipo,rth,run-test,scale-test,submit-benchmark-results,update-checkout,viewcfg,symbolicate-linux-fatal
+filename = *.py,80+-check,backtrace-check,Benchmark_Driver,Benchmark_DTrace.in,Benchmark_GuardMalloc.in,Benchmark_RuntimeLeaksRunner.in,build-script,check-incremental,clang++,coverage-build-db,coverage-generate-data,coverage-query-db,coverage-touch-tests,gyb,ld,line-directive,mock-distcc,ns-html2rst,PathSanitizingFileCheck,python-lint,recursive-lipo,round-trip-syntax-test,rth,run-test,scale-test,submit-benchmark-results,update-checkout,viewcfg,symbolicate-linux-fatal
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 196afd7..f91a13f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@
 
 | Contents               |
 | :--------------------- |
+| [Swift 4.0](#swift-40) |
 | [Swift 3.1](#swift-31) |
 | [Swift 3.0](#swift-30) |
 | [Swift 2.2](#swift-22) |
@@ -17,6 +18,28 @@
 
 </details>
 
+Swift 4.0
+---------
+
+* [SE-0148][]:
+
+  Subscript declarations can now be defined to have generic parameter lists.
+  Example:
+
+  ```
+  extension JSON {
+    subscript<T>(key: String) -> T?
+        where T : JSONConvertible {
+      // ...
+    }
+  }
+  ```
+
+* [SE-0110][]:
+
+  In Swift 4 mode, Swift's type system properly distinguishes between functions that
+  take one tuple argument, and functions that take multiple arguments.
+
 * More types of C macros which define integer constants are supported by the
   importer. Specifically the `+, -, *, /, ^, >>, ==, <, <=, >, >=` operators
   are now recognized, and the previously-supported `<<, &&, ||, &, |`
@@ -6408,3 +6431,11 @@
 [SE-0145]: <https://github.com/apple/swift-evolution/blob/master/proposals/0145-package-manager-version-pinning.md>
 [SE-0146]: <https://github.com/apple/swift-evolution/blob/master/proposals/0146-package-manager-product-definitions.md>
 [SE-0147]: <https://github.com/apple/swift-evolution/blob/master/proposals/0147-move-unsafe-initialize-from.md>
+[SE-0148]: <https://github.com/apple/swift-evolution/blob/master/proposals/0148-generic-subscripts.md>
+[SE-0149]: <https://github.com/apple/swift-evolution/blob/master/proposals/0149-package-manager-top-of-tree.md>
+[SE-0150]: <https://github.com/apple/swift-evolution/blob/master/proposals/0150-package-manager-branch-support.md>
+[SE-0151]: <https://github.com/apple/swift-evolution/blob/master/proposals/0151-package-manager-swift-language-compatibility-version.md>
+[SE-0152]: <https://github.com/apple/swift-evolution/blob/master/proposals/0152-package-manager-tools-version.md>
+[SE-0153]: <https://github.com/apple/swift-evolution/blob/master/proposals/0153-compensate-for-the-inconsistency-of-nscopyings-behaviour.md>
+[SE-0154]: <https://github.com/apple/swift-evolution/blob/master/proposals/0154-dictionary-key-and-value-collections.md>
+[SE-0155]: <https://github.com/apple/swift-evolution/blob/master/proposals/0155-normalize-enum-case-representation.md>
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b47c464..cacf882 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -270,6 +270,10 @@
     "Build the standard libraries and overlays with resilience enabled; see docs/LibraryEvolution.rst"
     FALSE)
 
+option(SWIFT_STDLIB_USE_NONATOMIC_RC
+    "Build the standard libraries and overlays with nonatomic reference count operations enabled"
+    FALSE)
+
 option(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP
   "Build the standard libraries and overlays with sil ownership enabled."
   FALSE)
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 82b7755..6d87720 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -48,6 +48,7 @@
     single-source/GlobalClass
     single-source/Hanoi
     single-source/Hash
+    single-source/HashQuadratic
     single-source/Histogram
     single-source/Integrate
     single-source/IterateData
diff --git a/benchmark/scripts/generate_harness/CMakeLists.txt_template b/benchmark/scripts/generate_harness/CMakeLists.txt_template
index 79eba3b..d4f0abb 100644
--- a/benchmark/scripts/generate_harness/CMakeLists.txt_template
+++ b/benchmark/scripts/generate_harness/CMakeLists.txt_template
@@ -67,9 +67,18 @@
   set(SWIFT_LIBRARY_PATH "${tmp_dir}/lib/swift")
 endif()
 
-runcmd(COMMAND "xcrun" "-toolchain" "${SWIFT_DARWIN_XCRUN_TOOLCHAIN}" "-f" "clang"
-       VARIABLE CLANG_EXEC
-       ERROR "Unable to find Clang driver")
+# If the CMAKE_C_COMPILER is already clang, don't find it again,
+# thus allowing the --host-cc build-script argument to work here.
+get_filename_component(c_compiler ${CMAKE_C_COMPILER} NAME)
+
+if(${c_compiler} STREQUAL "clang")
+  set(CLANG_EXEC ${CMAKE_C_COMPILER})
+else()
+  runcmd(COMMAND "xcrun" "-toolchain" "${SWIFT_DARWIN_XCRUN_TOOLCHAIN}" "-f" "clang"
+         VARIABLE CLANG_EXEC
+         ERROR "Unable to find Clang driver")
+endif()
+
 
 # You have to delete CMakeCache.txt in the swift build to force a
 # reconfiguration.
diff --git a/benchmark/single-source/HashQuadratic.swift b/benchmark/single-source/HashQuadratic.swift
new file mode 100644
index 0000000..0895aad
--- /dev/null
+++ b/benchmark/single-source/HashQuadratic.swift
@@ -0,0 +1,33 @@
+//===--- HashQuadratic.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+let size = 3_000_000
+
+@inline(never)
+public func run_HashQuadratic(_ N: Int) {
+    for _ in 1...N {
+        var dict1: [Int: Int] = [:]
+        for i in 0..<size {
+            dict1[i] = i * 2
+        }
+
+        var dict2: [Int: Int] = [:]
+        for (k, v) in dict1 {
+            dict2[k] = v
+        }
+    
+        CheckResults(dict1[size/2] == dict2[size/2],
+            "Incorrect results in HashQuadratic")
+    }
+}
diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift
index a716acd..d21cb0c 100644
--- a/benchmark/utils/main.swift
+++ b/benchmark/utils/main.swift
@@ -53,6 +53,7 @@
 import GlobalClass
 import Hanoi
 import Hash
+import HashQuadratic
 import Histogram
 import Integrate
 import IterateData
@@ -113,21 +114,19 @@
   "Array2D": run_Array2D,
   "ArrayAppend": run_ArrayAppend,
   "ArrayAppendArrayOfInt": run_ArrayAppendArrayOfInt,
+  "ArrayAppendAscii": run_ArrayAppendAscii,
   "ArrayAppendFromGeneric": run_ArrayAppendFromGeneric,
   "ArrayAppendGenericStructs": run_ArrayAppendGenericStructs,
+  "ArrayAppendLatin1": run_ArrayAppendLatin1,
   "ArrayAppendLazyMap": run_ArrayAppendLazyMap,
   "ArrayAppendOptionals": run_ArrayAppendOptionals,
   "ArrayAppendRepeatCol": run_ArrayAppendRepeatCol,
   "ArrayAppendReserved": run_ArrayAppendReserved,
   "ArrayAppendSequence": run_ArrayAppendSequence,
   "ArrayAppendStrings": run_ArrayAppendStrings,
-  "ArrayAppendASCII": run_ArrayAppendAscii,  
-  "ArrayAppendLatin1": run_ArrayAppendLatin1,  
-  "ArrayAppendUTF16": run_ArrayAppendUTF16,  
   "ArrayAppendToFromGeneric": run_ArrayAppendToFromGeneric,
   "ArrayAppendToGeneric": run_ArrayAppendToGeneric,
-  "ArrayPlusEqualSingleElementCollection": run_ArrayPlusEqualSingleElementCollection,
-  "ArrayPlusEqualFiveElementCollection": run_ArrayPlusEqualFiveElementCollection,
+  "ArrayAppendUTF16": run_ArrayAppendUTF16,
   "ArrayInClass": run_ArrayInClass,
   "ArrayLiteral": run_ArrayLiteral,
   "ArrayOfGenericPOD": run_ArrayOfGenericPOD,
@@ -135,6 +134,8 @@
   "ArrayOfPOD": run_ArrayOfPOD,
   "ArrayOfRef": run_ArrayOfRef,
   "ArrayPlusEqualArrayOfInt": run_ArrayPlusEqualArrayOfInt,
+  "ArrayPlusEqualFiveElementCollection": run_ArrayPlusEqualFiveElementCollection,
+  "ArrayPlusEqualSingleElementCollection": run_ArrayPlusEqualSingleElementCollection,
   "ArraySubscript": run_ArraySubscript,
   "ArrayValueProp": run_ArrayValueProp,
   "ArrayValueProp2": run_ArrayValueProp2,
@@ -164,6 +165,7 @@
   "ErrorHandling": run_ErrorHandling,
   "GlobalClass": run_GlobalClass,
   "Hanoi": run_Hanoi,
+  "HashQuadratic": run_HashQuadratic,
   "HashTest": run_HashTest,
   "Histogram": run_Histogram,
   "Integrate": run_Integrate,
@@ -172,15 +174,16 @@
   "LinkedList": run_LinkedList,
   "MapReduce": run_MapReduce,
   "MapReduceAnyCollection": run_MapReduceAnyCollection,
-  "MapReduceShort": run_MapReduceShort,
-  "MapReduceSequence": run_MapReduceSequence,
-  "MapReduceLazySequence": run_MapReduceLazySequence,
-  "MapReduceLazyCollection": run_MapReduceLazyCollection,
-  "MapReduceLazyCollectionShort": run_MapReduceLazyCollectionShort,
-  "MapReduceString": run_MapReduceString,
-  "MapReduceShortString": run_MapReduceShortString,
+  "MapReduceAnyCollectionShort": run_MapReduceAnyCollectionShort,
   "MapReduceClass": run_MapReduceClass,
   "MapReduceClassShort": run_MapReduceClassShort,
+  "MapReduceLazyCollection": run_MapReduceLazyCollection,
+  "MapReduceLazyCollectionShort": run_MapReduceLazyCollectionShort,
+  "MapReduceLazySequence": run_MapReduceLazySequence,
+  "MapReduceSequence": run_MapReduceSequence,
+  "MapReduceShort": run_MapReduceShort,
+  "MapReduceShortString": run_MapReduceShortString,
+  "MapReduceString": run_MapReduceString,
   "Memset": run_Memset,
   "MonteCarloE": run_MonteCarloE,
   "MonteCarloPi": run_MonteCarloPi,
diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index 993c156..0acbd41 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -241,6 +241,8 @@
     list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
     # TODO(compnerd) handle /MT
     list(APPEND result "-D_DLL")
+    # NOTE: We assume that we are using VS 2015 U2+
+    list(APPEND result "-D_ENABLE_ATOMIC_ALIGNMENT_FIX")
   endif()
 
   if(CFLAGS_ENABLE_ASSERTIONS)
diff --git a/cmake/modules/SwiftConfigureSDK.cmake b/cmake/modules/SwiftConfigureSDK.cmake
index a4b4ff1..39b0d2b 100644
--- a/cmake/modules/SwiftConfigureSDK.cmake
+++ b/cmake/modules/SwiftConfigureSDK.cmake
@@ -22,6 +22,13 @@
   message(STATUS "  Triple name: ${SWIFT_SDK_${prefix}_TRIPLE_NAME}")
   message(STATUS "  Architectures: ${SWIFT_SDK_${prefix}_ARCHITECTURES}")
   message(STATUS "  Object Format: ${SWIFT_SDK_${prefix}_OBJECT_FORMAT}")
+  foreach(arch ${SWIFT_SDK_${prefix}_ARCHITECTURES})
+    if(${SWIFT_SDK_${prefix}_ARCH_${arch}_LINKER})
+      message(STATUS "  Linker (${arch}): ${SWIFT_SDK_${prefix}_ARCH_${arch}_LINKER}")
+    else()
+      message(STATUS "  Linker (${arch}): ${CMAKE_LINKER}")
+    endif()
+  endforeach()
 
   foreach(arch ${SWIFT_SDK_${prefix}_ARCHITECTURES})
     message(STATUS
diff --git a/cmake/modules/SwiftSource.cmake b/cmake/modules/SwiftSource.cmake
index a9bb87e..bb20246 100644
--- a/cmake/modules/SwiftSource.cmake
+++ b/cmake/modules/SwiftSource.cmake
@@ -239,6 +239,10 @@
     list(APPEND swift_flags "-Xfrontend" "-enable-resilience")
   endif()
 
+  if(SWIFT_STDLIB_USE_NONATOMIC_RC)
+    list(APPEND swift_flags "-Xfrontend" "-assume-single-threaded")
+  endif()
+
   if(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP AND SWIFTFILE_IS_STDLIB)
     list(APPEND swift_flags "-Xfrontend" "-enable-sil-ownership")
   endif()
diff --git a/docs/HighLevelSILOptimizations.rst b/docs/HighLevelSILOptimizations.rst
index 7cb9e45..3178b4c 100644
--- a/docs/HighLevelSILOptimizations.rst
+++ b/docs/HighLevelSILOptimizations.rst
@@ -349,6 +349,11 @@
   @_semantics("optimize.sil.never")
   func miscompile() { ... }
 
+sil.specialize.generic.never
+
+   The sil optimizer should never create generic specializations of this function. 
+
+
 Availability checks
 ~~~~~~~~~~~~~~~~~~~
 
diff --git a/docs/SIL.rst b/docs/SIL.rst
index 0ee207f..6e45602 100644
--- a/docs/SIL.rst
+++ b/docs/SIL.rst
@@ -3743,6 +3743,7 @@
   
   * `init_existential_opaque`_
   * `open_existential_opaque`_
+  * `deinit_existential_opaque`_
 
 - **Class existential containers**: If a protocol type is constrained by one or
   more class protocols, then the existential container for that type is
@@ -3847,6 +3848,22 @@
 ``init_existential_addr`` but haven't had their contained value initialized.
 A fully initialized existential must be destroyed with ``destroy_addr``.
 
+deinit_existential_opaque
+`````````````````````````
+::
+
+  sil-instruction ::= 'deinit_existential_opaque' sil-operand
+
+  deinit_existential_opaque %0 : $P
+  // %0 must be of a $P opaque type for non-class protocol or protocol
+  // composition type P
+
+Undoes the partial initialization performed by
+``init_existential_opaque``.  ``deinit_existential_opaque`` is only valid for
+existential containers that have been partially initialized by
+``init_existential_opaque`` but haven't had their contained value initialized.
+A fully initialized existential must be destroyed with ``destroy_value``.
+
 open_existential_addr
 `````````````````````
 ::
diff --git a/docs/Testing.rst b/docs/Testing.rst
index ffc1183..b7fd2a5 100644
--- a/docs/Testing.rst
+++ b/docs/Testing.rst
@@ -431,7 +431,7 @@
 * ``swift_ast_verifier``: present if the AST verifier is enabled in this build.
 
 * When writing a test specific to x86, if possible, prefer ``REQUIRES:
-  CPU=i386 || CPU=x86_64`` over ``REQUIRES: CPU=x86_64``.
+  CPU=i386_or_x86_64`` to ``REQUIRES: CPU=x86_64``.
 
 * ``swift_test_mode_optimize[_unchecked|none]`` and
   ``swift_test_mode_optimize[_unchecked|none]_<CPUNAME>``: specify a test mode
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
index 1fddf63..fc285c4 100644
--- a/include/swift/AST/Decl.h
+++ b/include/swift/AST/Decl.h
@@ -24,9 +24,11 @@
 #include "swift/AST/DefaultArgumentKind.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/GenericParamKey.h"
+#include "swift/AST/IfConfigClause.h"
 #include "swift/AST/LayoutConstraint.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/TypeAlignments.h"
+#include "swift/AST/TypeWalker.h"
 #include "swift/AST/Witness.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/OptionalEnum.h"
@@ -238,11 +240,15 @@
     /// \brief Whether this declaration is currently being validated.
     unsigned BeingValidated : 1;
 
+    /// \brief Whether we have started validating the declaration; this *isn't*
+    /// reset after finishing it.
+    unsigned ValidationStarted : 1;
+
     /// \brief Whether this declaration was added to the surrounding
     /// DeclContext of an active #if config clause.
     unsigned EscapedFromIfConfig : 1;
   };
-  enum { NumDeclBits = 12 };
+  enum { NumDeclBits = 13 };
   static_assert(NumDeclBits <= 32, "fits in an unsigned");
 
   class PatternBindingDeclBitfields {
@@ -423,13 +429,8 @@
   class TypeAliasDeclBitfields {
     friend class TypeAliasDecl;
     unsigned : NumGenericTypeDeclBits;
-
-    /// Whether we have completed validation of the typealias.
-    /// This is necessary because unlike other declarations, a
-    /// typealias will not get an interface type right away.
-    unsigned HasCompletedValidation : 1;
   };
-  enum { NumTypeAliasDeclBits = NumGenericTypeDeclBits + 1 };
+  enum { NumTypeAliasDeclBits = NumGenericTypeDeclBits };
   static_assert(NumTypeAliasDeclBits <= 32, "fits in an unsigned");
 
   class NominalTypeDeclBitFields {
@@ -577,9 +578,6 @@
     /// FIXME: Is this too fine-grained?
     unsigned CheckedInheritanceClause : 1;
 
-    /// Whether this extension has already been validated.
-    unsigned Validated : 1;
-
     /// An encoding of the default and maximum access level for this extension.
     ///
     /// This is encoded as (1 << (maxAccess-1)) | (1 << (defaultAccess-1)),
@@ -590,7 +588,7 @@
     /// Whether there is are lazily-loaded conformances for this extension.
     unsigned HasLazyConformances : 1;
   };
-  enum { NumExtensionDeclBits = NumDeclBits + 6 };
+  enum { NumExtensionDeclBits = NumDeclBits + 5 };
   static_assert(NumExtensionDeclBits <= 32, "fits in an unsigned");
 
   class IfConfigDeclBitfields {
@@ -659,6 +657,7 @@
     DeclBits.FromClang = false;
     DeclBits.EarlyAttrValidation = false;
     DeclBits.BeingValidated = false;
+    DeclBits.ValidationStarted = false;
     DeclBits.EscapedFromIfConfig = false;
   }
 
@@ -815,8 +814,19 @@
   void setIsBeingValidated(bool ibv = true) {
     assert(DeclBits.BeingValidated != ibv);
     DeclBits.BeingValidated = ibv;
+    if (ibv) {
+      DeclBits.ValidationStarted = true;
+    }
   }
 
+  bool hasValidationStarted() const { return DeclBits.ValidationStarted; }
+
+  /// Manually indicate that validation has started for the declaration.
+  ///
+  /// This is implied by setIsBeingValidated(true) (i.e. starting validation)
+  /// and so rarely needs to be called directly.
+  void setValidationStarted() { DeclBits.ValidationStarted = true; }
+
   bool escapedFromIfConfig() const {
     return DeclBits.EscapedFromIfConfig;
   }
@@ -1644,19 +1654,9 @@
 
   void setInherited(MutableArrayRef<TypeLoc> i) { Inherited = i; }
 
-  /// Whether we started validating this extension.
-  bool validated() const {
-    return ExtensionDeclBits.Validated;
-  }
-
-  /// Set whether we have validated this extension.
-  void setValidated(bool validated = true) {
-    ExtensionDeclBits.Validated = validated;
-  }
-
   /// Whether we have fully checked the extension.
   bool hasValidSignature() const {
-    return validated() && !isBeingValidated();
+    return hasValidationStarted() && !isBeingValidated();
   }
 
   /// Whether we already type-checked the inheritance clause.
@@ -2017,28 +2017,6 @@
   }
 };
 
-/// This represents one part of a #if block.  If the condition field is
-/// non-null, then this represents a #if or a #elseif, otherwise it represents
-/// an #else block.
-struct IfConfigDeclClause {
-  /// The location of the #if, #elseif, or #else keyword.
-  SourceLoc Loc;
-  
-  /// The condition guarding this #if or #elseif block.  If this is null, this
-  /// is a #else clause.
-  Expr *Cond;
-
-  ArrayRef<Decl*> Members;
-
-  /// True if this is the active clause of the #if block.
-  bool isActive;
-
-  IfConfigDeclClause(SourceLoc Loc, Expr *Cond, ArrayRef<Decl*> Members,
-                     bool isActive)
-    : Loc(Loc), Cond(Cond), Members(Members), isActive(isActive) {}
-};
-  
-  
 /// IfConfigDecl - This class represents the declaration-side representation of
 /// #if/#else/#endif blocks. Active and inactive block members are stored
 /// separately, with the intention being that active members will be handed
@@ -2046,21 +2024,21 @@
 class IfConfigDecl : public Decl {
   /// An array of clauses controlling each of the #if/#elseif/#else conditions.
   /// The array is ASTContext allocated.
-  ArrayRef<IfConfigDeclClause> Clauses;
+  ArrayRef<IfConfigClause<Decl *>> Clauses;
   SourceLoc EndLoc;
 public:
   
-  IfConfigDecl(DeclContext *Parent, ArrayRef<IfConfigDeclClause> Clauses,
+  IfConfigDecl(DeclContext *Parent, ArrayRef<IfConfigClause<Decl *>> Clauses,
                SourceLoc EndLoc, bool HadMissingEnd)
     : Decl(DeclKind::IfConfig, Parent), Clauses(Clauses), EndLoc(EndLoc)
   {
     IfConfigDeclBits.HadMissingEnd = HadMissingEnd;
   }
 
-  ArrayRef<IfConfigDeclClause> getClauses() const { return Clauses; }
+  ArrayRef<IfConfigClause<Decl *>> getClauses() const { return Clauses; }
 
   /// Return the active clause, or null if there is no active one.
-  const IfConfigDeclClause *getActiveClause() const {
+  const IfConfigClause<Decl *> *getActiveClause() const {
     for (auto &Clause : Clauses)
       if (Clause.isActive) return &Clause;
     return nullptr;
@@ -2068,7 +2046,7 @@
 
   const ArrayRef<Decl*> getActiveMembers() const {
     if (auto *Clause = getActiveClause())
-      return Clause->Members;
+      return Clause->Elements;
     return {};
   }
   
@@ -2442,14 +2420,6 @@
   /// aliases.
   void setUnderlyingType(Type type);
 
-  bool hasCompletedValidation() const {
-    return TypeAliasDeclBits.HasCompletedValidation;
-  }
-
-  void setHasCompletedValidation() {
-    TypeAliasDeclBits.HasCompletedValidation = 1;
-  }
-
   /// For generic typealiases, return the unbound generic type.
   UnboundGenericType *getUnboundGenericType() const;
 
@@ -2583,14 +2553,19 @@
   /// The default definition.
   TypeLoc DefaultDefinition;
 
+  /// The where clause attached to the associated type.
+  TrailingWhereClause *TrailingWhere;
+
   LazyMemberLoader *Resolver = nullptr;
   uint64_t ResolverContextData;
 
 public:
   AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc, Identifier name,
-                     SourceLoc nameLoc, TypeLoc defaultDefinition);
+                     SourceLoc nameLoc, TypeLoc defaultDefinition,
+                     TrailingWhereClause *trailingWhere);
   AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc, Identifier name,
-                     SourceLoc nameLoc, LazyMemberLoader *definitionResolver,
+                     SourceLoc nameLoc, TrailingWhereClause *trailingWhere,
+                     LazyMemberLoader *definitionResolver,
                      uint64_t resolverData);
 
   /// Get the protocol in which this associated type is declared.
@@ -2608,6 +2583,14 @@
     return const_cast<AssociatedTypeDecl *>(this)->getDefaultDefinitionLoc();
   }
 
+  /// Retrieve the trailing where clause for this associated type, if any.
+  TrailingWhereClause *getTrailingWhereClause() const { return TrailingWhere; }
+
+  /// Set the trailing where clause for this associated type.
+  void setTrailingWhereClause(TrailingWhereClause *trailingWhereClause) {
+    TrailingWhere = trailingWhereClause;
+  }
+
   /// computeType - Compute the type (and declared type) of this associated
   /// type; can only be called after the alias type has been resolved.
   void computeType();
@@ -3413,6 +3396,19 @@
   /// Retrieve the set of protocols inherited from this protocol.
   llvm::TinyPtrVector<ProtocolDecl *> getInheritedProtocols() const;
 
+  /// Walk all of the protocols inherited by this protocol, transitively,
+  /// invoking the callback function for each protocol.
+  ///
+  /// \param fn The callback function that will be invoked for each inherited
+  /// protocol. It can return \c Continue to continue the traversal,
+  /// \c SkipChildren to avoid visiting the children of the given protocol
+  /// but continue the search, and \c Stop to halt the search.
+  ///
+  /// \returns \c true if \c fn returned \c Stop for any protocol, \c false
+  /// otherwise.
+  bool walkInheritedProtocols(
+               llvm::function_ref<TypeWalker::Action(ProtocolDecl *)> fn) const;
+
   /// \brief Determine whether this protocol inherits from the given ("super")
   /// protocol.
   bool inheritsFrom(const ProtocolDecl *Super) const;
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
index a1dd113..c5e2979 100644
--- a/include/swift/AST/DiagnosticsParse.def
+++ b/include/swift/AST/DiagnosticsParse.def
@@ -208,6 +208,9 @@
 ERROR(enum_case_dot_prefix,none,
       "extraneous '.' in enum 'case' declaration", ())
 
+ERROR(associatedtype_where_swift_3,none,
+      "where clauses on associated types are fragile; use '-swift-version 4' to experiment.", ())
+
 
 // Variable getters/setters
 ERROR(static_var_decl_global_scope,none,
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
index 377c8b6..42e442f 100644
--- a/include/swift/AST/DiagnosticsSema.def
+++ b/include/swift/AST/DiagnosticsSema.def
@@ -164,6 +164,9 @@
 ERROR(cannot_match_expr_pattern_with_value,none,
       "expression pattern of type %0 cannot match values of type %1",
       (Type, Type))
+ERROR(cannot_match_unresolved_expr_pattern_with_value,none,
+      "pattern cannot match values of type %0",
+      (Type))
 
 ERROR(cannot_reference_compare_types,none,
       "cannot check reference equality of functions; operands here have types "
@@ -1562,9 +1565,6 @@
 ERROR(requires_generic_param_made_equal_to_concrete,none,
       "same-type requirement makes generic parameter %0 non-generic",
       (Type))
-ERROR(requires_superclass_conflict,none,
-      "%select{generic parameter |protocol |}0%1 cannot be a subclass of both "
-      "%2 and %3", (unsigned, Type, Type, Type))
 ERROR(recursive_type_reference,none,
       "%0 %1 references itself", (DescriptiveDeclKind, Identifier))
 ERROR(recursive_requirement_reference,none,
@@ -1586,9 +1586,17 @@
       (Identifier, Type, Type))
 WARNING(redundant_same_type_to_concrete,none,
         "redundant same-type constraint %0 == %1", (Type, Type))
-NOTE(redundancy_here,none,
+NOTE(same_type_redundancy_here,none,
      "same-type constraint %1 == %2 %select{written here|implied here}0",
      (bool, Type, Type))
+ERROR(requires_superclass_conflict,none,
+      "%select{generic parameter |protocol |}0%1 cannot be a subclass of both "
+      "%2 and %3", (unsigned, Type, Type, Type))
+WARNING(redundant_superclass_constraint,none,
+        "redundant superclass constraint %0 : %1", (Type, Type))
+NOTE(superclass_redundancy_here,none,
+     "superclass constraint %1 : %2 %select{written here|implied here}0",
+     (bool, Type, Type))
 
 ERROR(mutiple_layout_constraints,none,
       "multiple layout constraints cannot be used at the same time: %0 and %1",
diff --git a/include/swift/AST/GenericSignature.h b/include/swift/AST/GenericSignature.h
index 8c7721d..a859f92 100644
--- a/include/swift/AST/GenericSignature.h
+++ b/include/swift/AST/GenericSignature.h
@@ -114,8 +114,9 @@
   /// \param substitutions The generic parameter -> generic argument
   /// substitutions that will have been applied to these types.
   /// These are used to produce the "parameter = argument" bindings in the test.
-  std::string gatherGenericParamBindingsText(
-      ArrayRef<Type> types, const TypeSubstitutionMap &substitutions) const;
+  std::string
+  gatherGenericParamBindingsText(ArrayRef<Type> types,
+                                 TypeSubstitutionFn substitutions) const;
 
   /// Retrieve the requirements.
   ArrayRef<Requirement> getRequirements() const {
diff --git a/include/swift/AST/GenericSignatureBuilder.h b/include/swift/AST/GenericSignatureBuilder.h
index d6aef4f..ed575c4 100644
--- a/include/swift/AST/GenericSignatureBuilder.h
+++ b/include/swift/AST/GenericSignatureBuilder.h
@@ -21,6 +21,7 @@
 #define SWIFT_GENERICSIGNATUREBUILDER_H
 
 #include "swift/AST/Decl.h"
+#include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/TypeLoc.h"
@@ -31,6 +32,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/TrailingObjects.h"
 #include <functional>
 #include <memory>
 
@@ -50,17 +52,428 @@
 class RequirementRepr;
 class SILModule;
 class SourceLoc;
+class SubstitutionMap;
 class Type;
 class TypeRepr;
 class ASTContext;
 class DiagnosticEngine;
 
+/// \brief Collects a set of requirements of generic parameters, both explicitly
+/// stated and inferred, and determines the set of archetypes for each of
+/// the generic parameters.
+class GenericSignatureBuilder {
+public:
+  /// Describes a potential archetype, which stands in for a generic parameter
+  /// type or some type derived from it.
+  class PotentialArchetype;
+
+  using UnresolvedType = llvm::PointerUnion<PotentialArchetype *, Type>;
+  struct ResolvedType;
+
+  using RequirementRHS =
+      llvm::PointerUnion3<Type, PotentialArchetype *, LayoutConstraint>;
+
+  class RequirementSource;
+
+  class FloatingRequirementSource;
+
+  /// Describes a constraint that is bounded on one side by a concrete type.
+  struct ConcreteConstraint {
+    PotentialArchetype *archetype;
+    Type concreteType;
+    const RequirementSource *source;
+  };
+
+  /// Describes an equivalence class of potential archetypes.
+  struct EquivalenceClass {
+    /// Concrete type to which this equivalence class is equal.
+    ///
+    /// This is the semantic concrete type; the constraints as written
+    /// (or implied) are stored in \c concreteTypeConstraints;
+    Type concreteType;
+
+    /// The same-type-to-concrete constraints written within this
+    /// equivalence class.
+    std::vector<ConcreteConstraint> concreteTypeConstraints;
+
+    /// Superclass constraint, which requires that the type fulfilling the
+    /// requirements of this equivalence class to be the same as or a subtype
+    /// of this superclass.
+    Type superclass;
+
+    /// Superclass constraints written within this equivalence class.
+    std::vector<ConcreteConstraint> superclassConstraints;
+
+    /// The members of the equivalence class.
+    TinyPtrVector<PotentialArchetype *> members;
+
+    /// Construct a new equivalence class containing only the given
+    /// potential archetype (which represents itself).
+    EquivalenceClass(PotentialArchetype *representative);
+
+    /// Find a source of the same-type constraint that maps a potential
+    /// archetype in this equivalence class to a concrete type along with
+    /// that concrete type as written.
+    Optional<ConcreteConstraint>
+    findAnyConcreteConstraintAsWritten(
+                              PotentialArchetype *preferredPA = nullptr) const;
+
+    /// Find a source of the superclass constraint in this equivalence class
+    /// that has a type equivalence to \c superclass, along with that
+    /// superclass type as written.
+    Optional<ConcreteConstraint>
+    findAnySuperclassConstraintAsWritten(
+                              PotentialArchetype *preferredPA = nullptr) const;
+};
+
+  friend class RequirementSource;
+
+private:
+  class InferRequirementsWalker;
+  friend class InferRequirementsWalker;
+  friend class GenericSignature;
+
+  ASTContext &Context;
+  DiagnosticEngine &Diags;
+  struct Implementation;
+  std::unique_ptr<Implementation> Impl;
+
+  GenericSignatureBuilder(const GenericSignatureBuilder &) = delete;
+  GenericSignatureBuilder &operator=(const GenericSignatureBuilder &) = delete;
+
+  /// Update an existing constraint source reference when another constraint
+  /// source was found to produce the same constraint. Only the better
+  /// constraint source will be kept.
+  ///
+  /// \returns true if the new constraint source was better, false otherwise.
+  bool updateRequirementSource(const RequirementSource *&existingSource,
+                               const RequirementSource *newSource);
+
+  /// Retrieve the constraint source conformance for the superclass constraint
+  /// of the given potential archetype (if present) to the given protocol.
+  ///
+  /// \param pa The potential archetype whose superclass constraint is being
+  /// queried.
+  ///
+  /// \param proto The protocol to which we are establishing conformance.
+  ///
+  /// \param protoSource The requirement source for the conformance to the
+  /// given protocol.
+  const RequirementSource *resolveSuperConformance(
+                            GenericSignatureBuilder::PotentialArchetype *pa,
+                            ProtocolDecl *proto,
+                            const RequirementSource *&protoSource);
+
+  /// \brief Add a new conformance requirement specifying that the given
+  /// potential archetype conforms to the given protocol.
+  bool addConformanceRequirement(PotentialArchetype *T,
+                                 ProtocolDecl *Proto,
+                                 const RequirementSource *Source);
+
+  bool addConformanceRequirement(PotentialArchetype *T,
+                                 ProtocolDecl *Proto,
+                                 const RequirementSource *Source,
+                                llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited);
+
+public:
+  /// \brief Add a new same-type requirement between two fully resolved types
+  /// (output of \c GenericSignatureBuilder::resolve).
+  ///
+  /// If the types refer to two concrete types that are fundamentally
+  /// incompatible (e.g. \c Foo<Bar<T>> and \c Foo<Baz>), \c diagnoseMismatch is
+  /// called with the two types that don't match (\c Bar<T> and \c Baz for the
+  /// previous example).
+  bool
+  addSameTypeRequirement(ResolvedType paOrT1, ResolvedType paOrT2,
+                         FloatingRequirementSource Source,
+                         llvm::function_ref<void(Type, Type)> diagnoseMismatch);
+
+  /// \brief Add a new same-type requirement between two fully resolved types
+  /// (output of GenericSignatureBuilder::resolve).
+  ///
+  /// The two types must not be incompatible concrete types.
+  bool addSameTypeRequirement(ResolvedType paOrT1, ResolvedType paOrT2,
+                              FloatingRequirementSource Source);
+
+  /// \brief Add a new same-type requirement between two unresolved types.
+  ///
+  /// The types are resolved with \c GenericSignatureBuilder::resolve, and must
+  /// not be incompatible concrete types.
+  bool addSameTypeRequirement(UnresolvedType paOrT1, UnresolvedType paOrT2,
+                              FloatingRequirementSource Source);
+
+  /// \brief Add a new same-type requirement between two unresolved types.
+  ///
+  /// The types are resolved with \c GenericSignatureBuilder::resolve. \c
+  /// diagnoseMismatch is called if the two types refer to incompatible concrete
+  /// types.
+  bool
+  addSameTypeRequirement(UnresolvedType paOrT1, UnresolvedType paOrT2,
+                         FloatingRequirementSource Source,
+                         llvm::function_ref<void(Type, Type)> diagnoseMismatch);
+
+  /// Update the superclass for the equivalence class of \c T.
+  ///
+  /// This assumes that the constraint has already been recorded
+  bool updateSuperclass(PotentialArchetype *T,
+                        Type superclass,
+                        const RequirementSource *source);
+
+private:
+  /// \brief Add a new superclass requirement specifying that the given
+  /// potential archetype has the given type as an ancestor.
+  bool addSuperclassRequirement(PotentialArchetype *T,
+                                Type Superclass,
+                                const RequirementSource *Source);
+
+  /// \brief Add a new conformance requirement specifying that the given
+  /// potential archetypes are equivalent.
+  bool addSameTypeRequirementBetweenArchetypes(PotentialArchetype *T1,
+                                               PotentialArchetype *T2,
+                                               const RequirementSource *Source);
+  
+  /// \brief Add a new conformance requirement specifying that the given
+  /// potential archetype is bound to a concrete type.
+  bool addSameTypeRequirementToConcrete(PotentialArchetype *T,
+                                        Type Concrete,
+                                        const RequirementSource *Source);
+
+  /// \brief Add a new same-type requirement specifying that the given two
+  /// types should be the same.
+  ///
+  /// \param diagnoseMismatch Callback invoked when the types in the same-type
+  /// requirement mismatch.
+  bool addSameTypeRequirementBetweenConcrete(
+      Type T1, Type T2, FloatingRequirementSource Source,
+      llvm::function_ref<void(Type, Type)> diagnoseMismatch);
+
+  /// Add the requirements placed on the given type parameter
+  /// to the given potential archetype.
+  bool addInheritedRequirements(TypeDecl *decl, PotentialArchetype *pa,
+                                const RequirementSource *parentSource,
+                                llvm::SmallPtrSetImpl<ProtocolDecl *> &visited);
+
+  /// Visit all of the potential archetypes.
+  template<typename F>
+  void visitPotentialArchetypes(F f);
+
+  void markPotentialArchetypeRecursive(PotentialArchetype *pa,
+                                       ProtocolDecl *proto,
+                                       const RequirementSource *source);
+
+public:
+  /// Construct a new generic signature builder.
+  ///
+  /// \param lookupConformance Conformance-lookup routine that will be used
+  /// to satisfy conformance requirements for concrete types.
+  explicit GenericSignatureBuilder(ASTContext &ctx,
+                            std::function<GenericFunction> lookupConformance);
+
+  GenericSignatureBuilder(GenericSignatureBuilder &&);
+  ~GenericSignatureBuilder();
+
+  /// Retrieve the AST context.
+  ASTContext &getASTContext() const { return Context; }
+
+  /// Retrieve the conformance-lookup function used by this generic signature builder.
+  std::function<GenericFunction> getLookupConformanceFn() const;
+
+  /// Retrieve the lazy resolver, if there is one.
+  LazyResolver *getLazyResolver() const;
+
+  /// Enumerate the requirements that describe the signature of this
+  /// generic signature builder.
+  ///
+  /// \param f A function object that will be passed each requirement
+  /// and requirement source.
+  void enumerateRequirements(llvm::function_ref<
+                      void (RequirementKind kind,
+                            PotentialArchetype *archetype,
+                            RequirementRHS constraint,
+                            const RequirementSource *source)> f);
+
+public:
+  /// \brief Add a new generic parameter for which there may be requirements.
+  void addGenericParameter(GenericTypeParamDecl *GenericParam);
+
+  /// Add the requirements placed on the given abstract type parameter
+  /// to the given potential archetype.
+  ///
+  /// \returns true if an error occurred, false otherwise.
+  bool addGenericParameterRequirements(GenericTypeParamDecl *GenericParam);
+
+  /// \brief Add a new generic parameter for which there may be requirements.
+  void addGenericParameter(GenericTypeParamType *GenericParam);
+  
+  /// \brief Add a new requirement.
+  ///
+  /// \returns true if this requirement makes the set of requirements
+  /// inconsistent, in which case a diagnostic will have been issued.
+  bool addRequirement(const RequirementRepr *Req,
+                      const RequirementSource *source = nullptr,
+                      const SubstitutionMap *subMap = nullptr);
+
+  /// \brief Add an already-checked requirement.
+  ///
+  /// Adding an already-checked requirement cannot fail. This is used to
+  /// re-inject requirements from outer contexts.
+  ///
+  /// \returns true if this requirement makes the set of requirements
+  /// inconsistent, in which case a diagnostic will have been issued.
+  bool addRequirement(const Requirement &req, FloatingRequirementSource source);
+
+  bool addRequirement(const Requirement &req, FloatingRequirementSource source,
+                      llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited);
+
+  /// \brief Add a new requirement.
+  ///
+  /// \returns true if this requirement makes the set of requirements
+  /// inconsistent, in which case a diagnostic will have been issued.
+
+  bool addLayoutRequirement(PotentialArchetype *PAT,
+                            LayoutConstraint Layout,
+                            const RequirementSource *Source);
+
+  /// \brief Add all of a generic signature's parameters and requirements.
+  void addGenericSignature(GenericSignature *sig);
+
+  /// \brief Build the generic signature.
+  GenericSignature *getGenericSignature();
+
+  /// Infer requirements from the given type, recursively.
+  ///
+  /// This routine infers requirements from a type that occurs within the
+  /// signature of a generic function. For example, given:
+  ///
+  /// \code
+  /// func f<K, V>(dict : Dictionary<K, V>) { ... }
+  /// \endcode
+  ///
+  /// where \c Dictionary requires that its key type be \c Hashable,
+  /// the requirement \c K : Hashable is inferred from the parameter type,
+  /// because the type \c Dictionary<K,V> cannot be formed without it.
+  void inferRequirements(TypeLoc type);
+
+  /// Infer requirements from the given pattern, recursively.
+  ///
+  /// This routine infers requirements from a type that occurs within the
+  /// signature of a generic function. For example, given:
+  ///
+  /// \code
+  /// func f<K, V>(dict : Dictionary<K, V>) { ... }
+  /// \endcode
+  ///
+  /// where \c Dictionary requires that its key type be \c Hashable,
+  /// the requirement \c K : Hashable is inferred from the parameter type,
+  /// because the type \c Dictionary<K,V> cannot be formed without it.
+  void inferRequirements(ParameterList *params,GenericParamList *genericParams);
+
+  /// Finalize the set of requirements, performing any remaining checking
+  /// required before generating archetypes.
+  ///
+  /// \param allowConcreteGenericParams If true, allow generic parameters to
+  /// be made concrete.
+  void finalize(SourceLoc loc,
+                ArrayRef<GenericTypeParamType *> genericParams,
+                bool allowConcreteGenericParams=false);
+
+  /// Diagnose any remaining renames.
+  ///
+  /// \returns \c true if there were any remaining renames to diagnose.
+  bool diagnoseRemainingRenames(SourceLoc loc,
+                                ArrayRef<GenericTypeParamType *> genericParams);
+
+private:
+  /// Describes the relationship between a given constraint and
+  /// the canonical constraint of the equivalence class.
+  enum class ConstraintRelation {
+    /// The constraint is unrelated.
+    ///
+    /// This is a conservative result that can be used when, for example,
+    /// we have incomplete information to make a determination.
+    Unrelated,
+    /// The constraint is redundant and can be removed without affecting the
+    /// semantics.
+    Redundant,
+    /// The constraint conflicts, meaning that the signature is erroneous.
+    Conflicting,
+  };
+
+  /// Check a list of concrete constraints, removing self-derived constraints
+  /// and diagnosing redundant constraints.
+  ///
+  /// \param isSuitableRepresentative Determines whether the given constraint
+  /// is a suitable representative.
+  ///
+  /// \param checkConstraint Checks the given constraint against the
+  /// canonical constraint to determine which diagnostics (if any) should be
+  /// emitted.
+  ///
+  /// \returns the representative constraint.
+  ConcreteConstraint checkConstraintList(
+                           ArrayRef<GenericTypeParamType *> genericParams,
+                           std::vector<ConcreteConstraint> &constraints,
+                           llvm::function_ref<bool(const ConcreteConstraint &)>
+                             isSuitableRepresentative,
+                           llvm::function_ref<ConstraintRelation(Type)>
+                             checkConstraint,
+                           Optional<Diag<unsigned, Type, Type, Type>>
+                             conflictingDiag,
+                           Diag<Type, Type> redundancyDiag,
+                           Diag<bool, Type, Type> otherNoteDiag);
+
+  /// Check for redundant concrete type constraints within the equivalence
+  /// class of the given potential archetype.
+  void checkRedundantConcreteTypeConstraints(
+                            ArrayRef<GenericTypeParamType *> genericParams,
+                            PotentialArchetype *pa);
+
+  /// Check for redundant superclass constraints within the equivalence
+  /// class of the given potential archetype.
+  void checkRedundantSuperclassConstraints(
+                            ArrayRef<GenericTypeParamType *> genericParams,
+                            PotentialArchetype *pa);
+
+public:
+  /// \brief Resolve the given type to the potential archetype it names.
+  ///
+  /// This routine will synthesize nested types as required to refer to a
+  /// potential archetype, even in cases where no requirement specifies the
+  /// requirement for such an archetype. FIXME: The failure to include such a
+  /// requirement will be diagnosed at some point later (when the types in the
+  /// signature are fully resolved).
+  ///
+  /// For any type that cannot refer to an archetype, this routine returns null.
+  PotentialArchetype *resolveArchetype(Type type);
+
+  /// \brief Resolve the given type as far as this Builder knows how.
+  ///
+  /// This returns either a non-typealias potential archetype or a Type, if \c
+  /// type is concrete.
+  // FIXME: the hackTypeFromGenericTypeAlias is just temporarily patching over
+  // problems with generic typealiases (see the comment on the ResolvedType
+  // function)
+  ResolvedType resolve(UnresolvedType type,
+                       bool hackTypeFromGenericTypeAlias = false);
+
+  /// \brief Dump all of the requirements, both specified and inferred.
+  LLVM_ATTRIBUTE_DEPRECATED(
+      void dump(),
+      "only for use within the debugger");
+
+  /// Dump all of the requirements to the given output stream.
+  void dump(llvm::raw_ostream &out);
+};
+
 /// Describes how a generic signature determines a requirement, from its origin
 /// in some requirement written in the source, inferred through a path of
 /// other implications (e.g., introduced by a particular protocol).
 ///
 /// Requirement sources are uniqued within a generic signature builder.
-class RequirementSource : public llvm::FoldingSetNode {
+class GenericSignatureBuilder::RequirementSource final
+  : public llvm::FoldingSetNode,
+    private llvm::TrailingObjects<RequirementSource, PotentialArchetype *> {
+
 public:
   enum Kind : uint8_t {
     /// A requirement stated explicitly, e.g., in a where clause or type
@@ -126,11 +539,12 @@
 private:
   /// The kind of storage we have.
   enum class StorageKind : uint8_t {
-    None,
+    RootArchetype,
     TypeRepr,
     RequirementRepr,
     ProtocolDecl,
     ProtocolConformance,
+    AssociatedTypeDecl,
   };
 
   /// The kind of storage we have.
@@ -138,6 +552,9 @@
 
   /// The actual storage, described by \c storageKind.
   union {
+    /// The root archetype.
+    PotentialArchetype *rootArchetype;
+
     /// The type representation describing where the requirement came from.
     const TypeRepr *typeRepr;
 
@@ -149,8 +566,32 @@
 
     /// A protocol conformance used to satisfy the requirement.
     ProtocolConformance *conformance;
+
+    /// An associated type to which a requirement is being applied.
+    AssociatedTypeDecl *assocType;
   } storage;
 
+  friend TrailingObjects;
+
+  /// The trailing potential archetype, for
+  size_t numTrailingObjects(OverloadToken<PotentialArchetype *>) const {
+    switch (kind) {
+    case RequirementSignatureSelf:
+      return 1;
+
+    case Explicit:
+    case Inferred:
+      return storageKind == StorageKind::RootArchetype ? 0 : 1;
+
+    case NestedTypeNameMatch:
+    case ProtocolRequirement:
+    case Superclass:
+    case Parent:
+    case Concrete:
+      return 0;
+    }
+  }
+
   /// Determines whether we have been provided with an acceptable storage kind
   /// for the given requirement source kind.
   static bool isAcceptableStorageKind(Kind kind, StorageKind storageKind);
@@ -158,6 +599,10 @@
   /// Retrieve the opaque storage as a single pointer, for use in uniquing.
   const void *getOpaqueStorage() const;
 
+  /// Retrieve the extra opaque storage as a single pointer, for use in
+  /// uniquing.
+  const void *getExtraOpaqueStorage() const;
+
   /// Whether this kind of requirement source is a root.
   static bool isRootKind(Kind kind) {
     switch (kind) {
@@ -182,15 +627,15 @@
   /// requirement source with one of the "root" kinds.
   const RequirementSource * const parent;
 
-  RequirementSource(Kind kind, const RequirementSource *parent)
-    : kind(kind), storageKind(StorageKind::None), parent(parent) {
+  RequirementSource(Kind kind, const RequirementSource *parent,
+                    PotentialArchetype *rootArchetype)
+    : kind(kind), storageKind(StorageKind::RootArchetype), parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
     assert(isAcceptableStorageKind(kind, storageKind) &&
            "RequirementSource kind/storageKind mismatch");
 
-    // Prevent uninitialized memory.
-    storage.typeRepr = nullptr;
+    storage.rootArchetype = rootArchetype;
   }
 
   RequirementSource(Kind kind, const RequirementSource *parent,
@@ -216,7 +661,7 @@
   }
 
   RequirementSource(Kind kind, const RequirementSource *parent,
-                   ProtocolDecl *protocol)
+                    ProtocolDecl *protocol)
     : kind(kind), storageKind(StorageKind::ProtocolDecl), parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
@@ -227,7 +672,7 @@
   }
 
   RequirementSource(Kind kind, const RequirementSource *parent,
-                   ProtocolConformance *conformance)
+                    ProtocolConformance *conformance)
     : kind(kind), storageKind(StorageKind::ProtocolConformance),
       parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
@@ -238,35 +683,48 @@
     storage.conformance = conformance;
   }
 
+  RequirementSource(Kind kind, const RequirementSource *parent,
+                    AssociatedTypeDecl *assocType)
+    : kind(kind), storageKind(StorageKind::AssociatedTypeDecl),
+      parent(parent) {
+    assert((static_cast<bool>(parent) != isRootKind(kind)) &&
+           "Root RequirementSource should not have parent (or vice versa)");
+    assert(isAcceptableStorageKind(kind, storageKind) &&
+           "RequirementSource kind/storageKind mismatch");
+
+    storage.assocType = assocType;
+  }
+
 public:
   /// Retrieve an abstract requirement source.
-  static const RequirementSource *forAbstract(GenericSignatureBuilder &builder);
+  static const RequirementSource *forAbstract(PotentialArchetype *root);
 
   /// Retrieve a requirement source representing an explicit requirement
   /// stated in an 'inheritance' clause.
-  static const RequirementSource *forExplicit(GenericSignatureBuilder &builder,
+  static const RequirementSource *forExplicit(PotentialArchetype *root,
                                               const TypeRepr *typeRepr);
 
   /// Retrieve a requirement source representing an explicit requirement
   /// stated in an 'where' clause.
-  static const RequirementSource *forExplicit(GenericSignatureBuilder &builder,
+  static const RequirementSource *forExplicit(
+                                        PotentialArchetype *root,
                                         const RequirementRepr *requirementRepr);
 
   /// Retrieve a requirement source representing a requirement that is
   /// inferred from some part of a generic declaration's signature, e.g., the
   /// parameter or result type of a generic function.
-  static const RequirementSource *forInferred(GenericSignatureBuilder &builder,
+  static const RequirementSource *forInferred(PotentialArchetype *root,
                                               const TypeRepr *typeRepr);
 
   /// Retrieve a requirement source representing the requirement signature
   /// computation for a protocol.
   static const RequirementSource *forRequirementSignature(
-                                              GenericSignatureBuilder &builder,
-                                              ProtocolDecl *protocol);
+                                                      PotentialArchetype *root,
+                                                      ProtocolDecl *protocol);
 
-  /// Retrieve an requirement source for nested type name matches.
+  /// Retrieve a requirement source for nested type name matches.
   static const RequirementSource *forNestedTypeNameMatch(
-                                              GenericSignatureBuilder &builder);
+                                     PotentialArchetype *root);
 
   /// A requirement source that describes that a requirement comes from a
   /// requirement of the given protocol described by the parent.
@@ -287,7 +745,13 @@
 
   /// A constraint source that describes that a constraint that is resolved
   /// for a nested type via a constraint on its parent.
-  const RequirementSource *viaParent(GenericSignatureBuilder &builder) const;
+  ///
+  /// \param assocType the associated type that
+  const RequirementSource *viaParent(GenericSignatureBuilder &builder,
+                                     AssociatedTypeDecl *assocType) const;
+
+  /// Retrieve the potential archetype at the root.
+  PotentialArchetype *getRootPotentialArchetype() const;
 
   /// Whether the requirement can be derived from something in its path.
   ///
@@ -301,6 +765,13 @@
   /// to a protocol.
   bool isDerivedViaConcreteConformance() const;
 
+  /// Determine whether the given derived requirement \c source, when rooted at
+  /// the potential archetype \c pa, is actually derived from the same
+  /// requirement. Such "self-derived" requirements do not make the original
+  /// requirement redundant, because without said original requirement, the
+  /// derived requirement ceases to hold.
+  bool isSelfDerivedSource(PotentialArchetype *pa) const;
+
   /// Retrieve a source location that corresponds to the requirement.
   SourceLoc getLoc() const;
 
@@ -333,17 +804,26 @@
     return storage.conformance;
   }
 
+  /// Retrieve the associated type declaration for this requirement, if there
+  /// is one.
+  AssociatedTypeDecl *getAssociatedType() const {
+    if (storageKind != StorageKind::AssociatedTypeDecl) return nullptr;
+    return storage.assocType;
+  }
+
   /// Profiling support for \c FoldingSet.
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, kind, parent, getOpaqueStorage());
+    Profile(ID, kind, parent, getOpaqueStorage(), getExtraOpaqueStorage());
   }
 
   /// Profiling support for \c FoldingSet.
   static void Profile(llvm::FoldingSetNodeID &ID, Kind kind,
-                      const RequirementSource *parent, const void *storage) {
+                      const RequirementSource *parent, const void *storage,
+                      const void *extraStorage) {
     ID.AddInteger(kind);
     ID.AddPointer(parent);
     ID.AddPointer(storage);
+    ID.AddPointer(extraStorage);
   }
 
   LLVM_ATTRIBUTE_DEPRECATED(
@@ -362,313 +842,56 @@
   void print(llvm::raw_ostream &out, SourceManager *SrcMgr) const;
 };
 
-/// \brief Collects a set of requirements of generic parameters, both explicitly
-/// stated and inferred, and determines the set of archetypes for each of
-/// the generic parameters.
-class GenericSignatureBuilder {
-public:
-  /// Describes a potential archetype, which stands in for a generic parameter
-  /// type or some type derived from it.
-  class PotentialArchetype;
+/// A requirement source that potentially lacks a root \c PotentialArchetype.
+/// The root will be supplied as soon as the appropriate dependent type is
+/// resolved.
+class GenericSignatureBuilder::FloatingRequirementSource {
+  enum Kind {
+    /// A fully-resolved requirement source, which does not need a root.
+    Resolved,
+    /// An explicit requirement source lacking a root.
+    Explicit,
+    /// An inferred requirement source lacking a root.
+    Inferred
+  } kind;
 
-  using UnresolvedType = llvm::PointerUnion<PotentialArchetype *, Type>;
-  struct ResolvedType;
+  using Storage =
+    llvm::PointerUnion3<const RequirementSource *, const TypeRepr *,
+                        const RequirementRepr *>;
 
-  using RequirementRHS =
-      llvm::PointerUnion3<Type, PotentialArchetype *, LayoutConstraint>;
+  Storage storage;
 
-  /// Describes an equivalence class of potential archetypes.
-  struct EquivalenceClass {
-    /// Concrete type to which this equivalence class is equal.
-    Type concreteType;
-
-    /// The members of the equivalence class.
-    TinyPtrVector<PotentialArchetype *> members;
-
-    /// Construct a new equivalence class containing only the given
-    /// potential archetype (which represents itself).
-    EquivalenceClass(PotentialArchetype *representative);
-  };
-
-  friend class RequirementSource;
-
-private:
-  class InferRequirementsWalker;
-  friend class InferRequirementsWalker;
-  friend class GenericSignature;
-
-  ASTContext &Context;
-  DiagnosticEngine &Diags;
-  struct Implementation;
-  std::unique_ptr<Implementation> Impl;
-
-  GenericSignatureBuilder(const GenericSignatureBuilder &) = delete;
-  GenericSignatureBuilder &operator=(const GenericSignatureBuilder &) = delete;
-
-  /// Update an existing constraint source reference when another constraint
-  /// source was found to produce the same constraint. Only the better
-  /// constraint source will be kept.
-  ///
-  /// \returns true if the new constraint source was better, false otherwise.
-  bool updateRequirementSource(const RequirementSource *&existingSource,
-                               const RequirementSource *newSource);
-
-  /// Retrieve the constraint source conformance for the superclass constraint
-  /// of the given potential archetype (if present) to the given protocol.
-  ///
-  /// \param pa The potential archetype whose superclass constraint is being
-  /// queried.
-  ///
-  /// \param proto The protocol to which we are establishing conformance.
-  ///
-  /// \param protoSource The requirement source for the conformance to the
-  /// given protocol.
-  const RequirementSource *resolveSuperConformance(
-                            GenericSignatureBuilder::PotentialArchetype *pa,
-                            ProtocolDecl *proto,
-                            const RequirementSource *&protoSource);
-
-  /// \brief Add a new conformance requirement specifying that the given
-  /// potential archetype conforms to the given protocol.
-  bool addConformanceRequirement(PotentialArchetype *T,
-                                 ProtocolDecl *Proto,
-                                 const RequirementSource *Source);
-
-  bool addConformanceRequirement(PotentialArchetype *T,
-                                 ProtocolDecl *Proto,
-                                 const RequirementSource *Source,
-                                llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited);
+  FloatingRequirementSource(Kind kind, Storage storage)
+    : kind(kind), storage(storage) { }
 
 public:
-  /// \brief Add a new same-type requirement between two fully resolved types
-  /// (output of \c GenericSignatureBuilder::resolve).
-  ///
-  /// If the types refer to two concrete types that are fundamentally
-  /// incompatible (e.g. \c Foo<Bar<T>> and \c Foo<Baz>), \c diagnoseMismatch is
-  /// called with the two types that don't match (\c Bar<T> and \c Baz for the
-  /// previous example).
-  bool
-  addSameTypeRequirement(ResolvedType paOrT1, ResolvedType paOrT2,
-                         const RequirementSource *Source,
-                         llvm::function_ref<void(Type, Type)> diagnoseMismatch);
+  /// Implicit conversion from a resolved requirement source.
+  FloatingRequirementSource(const RequirementSource *source)
+    : FloatingRequirementSource(Resolved, source) { }
 
-  /// \brief Add a new same-type requirement between two fully resolved types
-  /// (output of GenericSignatureBuilder::resolve).
-  ///
-  /// The two types must not be incompatible concrete types.
-  bool addSameTypeRequirement(ResolvedType paOrT1, ResolvedType paOrT2,
-                              const RequirementSource *Source);
+  static FloatingRequirementSource forAbstract() {
+    return { Explicit, Storage() };
+  }
 
-  /// \brief Add a new same-type requirement between two unresolved types.
-  ///
-  /// The types are resolved with \c GenericSignatureBuilder::resolve, and must
-  /// not be incompatible concrete types.
-  bool addSameTypeRequirement(UnresolvedType paOrT1, UnresolvedType paOrT2,
-                              const RequirementSource *Source);
+  static FloatingRequirementSource forExplicit(const TypeRepr *typeRepr) {
+    return { Explicit, typeRepr };
+  }
 
-  /// \brief Add a new same-type requirement between two unresolved types.
-  ///
-  /// The types are resolved with \c GenericSignatureBuilder::resolve. \c
-  /// diagnoseMismatch is called if the two types refer to incompatible concrete
-  /// types.
-  bool
-  addSameTypeRequirement(UnresolvedType paOrT1, UnresolvedType paOrT2,
-                         const RequirementSource *Source,
-                         llvm::function_ref<void(Type, Type)> diagnoseMismatch);
+  static FloatingRequirementSource forExplicit(
+                                     const RequirementRepr *requirementRepr) {
+    return { Explicit, requirementRepr };
+  }
 
-private:
-  /// \brief Add a new superclass requirement specifying that the given
-  /// potential archetype has the given type as an ancestor.
-  bool addSuperclassRequirement(PotentialArchetype *T,
-                                Type Superclass,
-                                const RequirementSource *Source);
+  static FloatingRequirementSource forInferred(const TypeRepr *typeRepr) {
+    return { Inferred, typeRepr };
+  }
 
-  /// \brief Add a new conformance requirement specifying that the given
-  /// potential archetypes are equivalent.
-  bool addSameTypeRequirementBetweenArchetypes(PotentialArchetype *T1,
-                                               PotentialArchetype *T2,
-                                               const RequirementSource *Source);
-  
-  /// \brief Add a new conformance requirement specifying that the given
-  /// potential archetype is bound to a concrete type.
-  bool addSameTypeRequirementToConcrete(PotentialArchetype *T,
-                                        Type Concrete,
-                                        const RequirementSource *Source);
+  /// Retrieve the complete requirement source rooted at the given potential
+  /// archetype.
+  const RequirementSource *getSource(PotentialArchetype *pa) const;
 
-  /// \brief Add a new same-type requirement specifying that the given two
-  /// types should be the same.
-  ///
-  /// \param diagnoseMismatch Callback invoked when the types in the same-type
-  /// requirement mismatch.
-  bool addSameTypeRequirementBetweenConcrete(
-      Type T1, Type T2, const RequirementSource *Source,
-      llvm::function_ref<void(Type, Type)> diagnoseMismatch);
-
-  /// Add the requirements placed on the given type parameter
-  /// to the given potential archetype.
-  bool addInheritedRequirements(TypeDecl *decl, PotentialArchetype *pa,
-                                const RequirementSource *parentSource,
-                                llvm::SmallPtrSetImpl<ProtocolDecl *> &visited);
-
-  /// Visit all of the potential archetypes.
-  template<typename F>
-  void visitPotentialArchetypes(F f);
-
-  void markPotentialArchetypeRecursive(PotentialArchetype *pa,
-                                       ProtocolDecl *proto,
-                                       const RequirementSource *source);
-
-public:
-  /// Construct a new generic signature builder.
-  ///
-  /// \param lookupConformance Conformance-lookup routine that will be used
-  /// to satisfy conformance requirements for concrete types.
-  explicit GenericSignatureBuilder(ASTContext &ctx,
-                            std::function<GenericFunction> lookupConformance);
-
-  GenericSignatureBuilder(GenericSignatureBuilder &&);
-  ~GenericSignatureBuilder();
-
-  /// Retrieve the AST context.
-  ASTContext &getASTContext() const { return Context; }
-
-  /// Retrieve the conformance-lookup function used by this generic signature builder.
-  std::function<GenericFunction> getLookupConformanceFn() const;
-
-  /// Retrieve the lazy resolver, if there is one.
-  LazyResolver *getLazyResolver() const;
-
-  /// Enumerate the requirements that describe the signature of this
-  /// generic signature builder.
-  ///
-  /// \param f A function object that will be passed each requirement
-  /// and requirement source.
-  void enumerateRequirements(llvm::function_ref<
-                      void (RequirementKind kind,
-                            PotentialArchetype *archetype,
-                            RequirementRHS constraint,
-                            const RequirementSource *source)> f);
-
-public:
-  /// \brief Add a new generic parameter for which there may be requirements.
-  void addGenericParameter(GenericTypeParamDecl *GenericParam);
-
-  /// Add the requirements placed on the given abstract type parameter
-  /// to the given potential archetype.
-  ///
-  /// \returns true if an error occurred, false otherwise.
-  bool addGenericParameterRequirements(GenericTypeParamDecl *GenericParam);
-
-  /// \brief Add a new generic parameter for which there may be requirements.
-  void addGenericParameter(GenericTypeParamType *GenericParam);
-  
-  /// \brief Add a new requirement.
-  ///
-  /// \returns true if this requirement makes the set of requirements
-  /// inconsistent, in which case a diagnostic will have been issued.
-  bool addRequirement(const RequirementRepr *Req);
-
-  /// \brief Add an already-checked requirement.
-  ///
-  /// Adding an already-checked requirement cannot fail. This is used to
-  /// re-inject requirements from outer contexts.
-  ///
-  /// \returns true if this requirement makes the set of requirements
-  /// inconsistent, in which case a diagnostic will have been issued.
-  bool addRequirement(const Requirement &req, const RequirementSource *source);
-
-  bool addRequirement(const Requirement &req, const RequirementSource *source,
-                      llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited);
-
-  bool addLayoutRequirement(PotentialArchetype *PAT,
-                            LayoutConstraint Layout,
-                            const RequirementSource *Source);
-
-  /// \brief Add all of a generic signature's parameters and requirements.
-  void addGenericSignature(GenericSignature *sig);
-
-  /// \brief Build the generic signature.
-  GenericSignature *getGenericSignature();
-
-  /// Infer requirements from the given type, recursively.
-  ///
-  /// This routine infers requirements from a type that occurs within the
-  /// signature of a generic function. For example, given:
-  ///
-  /// \code
-  /// func f<K, V>(dict : Dictionary<K, V>) { ... }
-  /// \endcode
-  ///
-  /// where \c Dictionary requires that its key type be \c Hashable,
-  /// the requirement \c K : Hashable is inferred from the parameter type,
-  /// because the type \c Dictionary<K,V> cannot be formed without it.
-  void inferRequirements(TypeLoc type, unsigned minDepth, unsigned maxDepth);
-
-  /// Infer requirements from the given pattern, recursively.
-  ///
-  /// This routine infers requirements from a type that occurs within the
-  /// signature of a generic function. For example, given:
-  ///
-  /// \code
-  /// func f<K, V>(dict : Dictionary<K, V>) { ... }
-  /// \endcode
-  ///
-  /// where \c Dictionary requires that its key type be \c Hashable,
-  /// the requirement \c K : Hashable is inferred from the parameter type,
-  /// because the type \c Dictionary<K,V> cannot be formed without it.
-  void inferRequirements(ParameterList *params,GenericParamList *genericParams);
-
-  /// Finalize the set of requirements, performing any remaining checking
-  /// required before generating archetypes.
-  ///
-  /// \param allowConcreteGenericParams If true, allow generic parameters to
-  /// be made concrete.
-  void finalize(SourceLoc loc,
-                ArrayRef<GenericTypeParamType *> genericParams,
-                bool allowConcreteGenericParams=false);
-
-  /// Diagnose any remaining renames.
-  ///
-  /// \returns \c true if there were any remaining renames to diagnose.
-  bool diagnoseRemainingRenames(SourceLoc loc,
-                                ArrayRef<GenericTypeParamType *> genericParams);
-
-private:
-  /// Check for redundant concrete type constraints within the equivalence
-  /// class of the given potential archetype.
-  void checkRedundantConcreteTypeConstraints(
-                            ArrayRef<GenericTypeParamType *> genericParams,
-                            PotentialArchetype *pa);
-
-public:
-  /// \brief Resolve the given type to the potential archetype it names.
-  ///
-  /// This routine will synthesize nested types as required to refer to a
-  /// potential archetype, even in cases where no requirement specifies the
-  /// requirement for such an archetype. FIXME: The failure to include such a
-  /// requirement will be diagnosed at some point later (when the types in the
-  /// signature are fully resolved).
-  ///
-  /// For any type that cannot refer to an archetype, this routine returns null.
-  PotentialArchetype *resolveArchetype(Type type);
-
-  /// \brief Resolve the given type as far as this Builder knows how.
-  ///
-  /// This returns either a non-typealias potential archetype or a Type, if \c
-  /// type is concrete.
-  // FIXME: the hackTypeFromGenericTypeAlias is just temporarily patching over
-  // problems with generic typealiases (see the comment on the ResolvedType
-  // function)
-  ResolvedType resolve(UnresolvedType type,
-                       bool hackTypeFromGenericTypeAlias = false);
-
-  /// \brief Dump all of the requirements, both specified and inferred.
-  LLVM_ATTRIBUTE_DEPRECATED(
-      void dump(),
-      "only for use within the debugger");
-
-  /// Dump all of the requirements to the given output stream.
-  void dump(llvm::raw_ostream &out);
+  /// Retrieve the source location for this requirement.
+  SourceLoc getLoc() const;
 };
 
 class GenericSignatureBuilder::PotentialArchetype {
@@ -713,12 +936,6 @@
   llvm::MapVector<PotentialArchetype *, const RequirementSource *>
     SameTypeConstraints;
 
-  /// \brief The superclass of this archetype, if specified.
-  Type Superclass;
-
-  /// The source of the superclass requirement.
-  const RequirementSource *SuperclassSource = nullptr;
-
   /// \brief The list of protocols to which this archetype will conform.
   llvm::MapVector<ProtocolDecl *, const RequirementSource *> ConformsTo;
 
@@ -736,16 +953,6 @@
   llvm::MapVector<Identifier, llvm::TinyPtrVector<PotentialArchetype *>>
     NestedTypes;
 
-  /// The concrete types to which this potential archetype has been
-  /// constrained.
-  ///
-  /// This vector runs parallel to ConcreteTypeSources.
-  llvm::TinyPtrVector<Type> concreteTypes;
-
-  /// The source of the concrete type requirements that were written on
-  /// this potential archetype.
-  llvm::TinyPtrVector<const RequirementSource *> concreteTypeSources;
-
   /// Whether this is an unresolved nested type.
   unsigned isUnresolvedNestedType : 1;
 
@@ -910,12 +1117,12 @@
                       GenericSignatureBuilder &builder);
 
   /// Retrieve the superclass of this archetype.
-  Type getSuperclass() const { return Superclass; }
-
-  /// Retrieve the requirement source for the superclass requirement.
-  const RequirementSource *getSuperclassSource() const {
-    return SuperclassSource;
-  } 
+  Type getSuperclass() const {
+    if (auto equiv = getEquivalenceClassIfPresent())
+      return equiv->superclass;
+    
+    return nullptr;
+  }
 
   /// Retrieve the layout constraint of this archetype.
   LayoutConstraint getLayout() const { return Layout; }
@@ -973,22 +1180,6 @@
                             SameTypeConstraints.end());
   }
 
-  /// Retrieve the concrete types as written on this potential archetype.
-  const llvm::TinyPtrVector<Type>& getConcreteTypesAsWritten() const {
-    return concreteTypes;
-  }
-
-  /// Retrieve the concrete type sources as written on this potential archetype.
-  ArrayRef<const RequirementSource *> getConcreteTypeSourcesAsWritten() const {
-    return concreteTypeSources;
-  }
-
-  /// Find a source of the same-type constraint that maps this potential
-  /// archetype to a concrete type somewhere in the equivalence class of this
-  /// type along with the concrete type that was written there.
-  Optional<std::pair<Type, const RequirementSource *>>
-  findAnyConcreteTypeSourceAsWritten() const;
-
   /// \brief Retrieve (or create) a nested type with the given name.
   PotentialArchetype *getNestedType(Identifier Name,
                                     GenericSignatureBuilder &builder);
diff --git a/include/swift/AST/IfConfigClause.h b/include/swift/AST/IfConfigClause.h
new file mode 100644
index 0000000..7c8c1cf
--- /dev/null
+++ b/include/swift/AST/IfConfigClause.h
@@ -0,0 +1,52 @@
+//===--- IfConfigClause.h ---------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the IfConfigClause.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_IFCONFIGCLAUSE_H
+#define SWIFT_AST_IFCONFIGCLAUSE_H
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace swift {
+  class Expr;
+  class SourceLoc;
+
+/// This represents one part of a #if block.  If the condition field is
+/// non-null, then this represents a #if or a #elseif, otherwise it represents
+/// an #else block.
+template <typename ElemTy>
+struct IfConfigClause {
+  /// The location of the #if, #elseif, or #else keyword.
+  SourceLoc Loc;
+  
+  /// The condition guarding this #if or #elseif block.  If this is null, this
+  /// is a #else clause.
+  Expr *Cond;
+  
+  /// Elements inside the clause
+  ArrayRef<ElemTy> Elements;
+
+  /// True if this is the active clause of the #if block.
+  bool isActive;
+
+  IfConfigClause<ElemTy>(SourceLoc Loc, Expr *Cond,
+                         ArrayRef<ElemTy> Elements, bool isActive)
+    : Loc(Loc), Cond(Cond), Elements(Elements), isActive(isActive) {
+  }
+};
+
+} // end namespace swift
+
+#endif
diff --git a/include/swift/AST/Pattern.h b/include/swift/AST/Pattern.h
index 3c561ce..5100365 100644
--- a/include/swift/AST/Pattern.h
+++ b/include/swift/AST/Pattern.h
@@ -492,7 +492,7 @@
   SourceLoc DotLoc;
   SourceLoc NameLoc;
   Identifier Name;
-  EnumElementDecl *ElementDecl;
+  PointerUnion<EnumElementDecl *, Expr*> ElementDeclOrUnresolvedOriginalExpr;
   Pattern /*nullable*/ *SubPattern;
   
 public:
@@ -501,10 +501,25 @@
                      Pattern *SubPattern, Optional<bool> Implicit = None)
     : Pattern(PatternKind::EnumElement),
       ParentType(ParentType), DotLoc(DotLoc), NameLoc(NameLoc), Name(Name),
-      ElementDecl(Element), SubPattern(SubPattern) {
+      ElementDeclOrUnresolvedOriginalExpr(Element),
+      SubPattern(SubPattern) {
     if (Implicit.hasValue() && *Implicit)
       setImplicit();
   }
+  
+  /// Create an unresolved EnumElementPattern for a `.foo` pattern relying on
+  /// contextual type.
+  EnumElementPattern(SourceLoc DotLoc,
+                     SourceLoc NameLoc,
+                     Identifier Name,
+                     Pattern *SubPattern,
+                     Expr *UnresolvedOriginalExpr)
+    : Pattern(PatternKind::EnumElement),
+      ParentType(), DotLoc(DotLoc), NameLoc(NameLoc), Name(Name),
+      ElementDeclOrUnresolvedOriginalExpr(UnresolvedOriginalExpr),
+      SubPattern(SubPattern) {
+    
+  }
 
   bool hasSubPattern() const { return SubPattern; }
   
@@ -524,8 +539,19 @@
   
   Identifier getName() const { return Name; }
   
-  EnumElementDecl *getElementDecl() const { return ElementDecl; }
-  void setElementDecl(EnumElementDecl *d) { ElementDecl = d; }
+  EnumElementDecl *getElementDecl() const {
+    return ElementDeclOrUnresolvedOriginalExpr.dyn_cast<EnumElementDecl*>();
+  }
+  void setElementDecl(EnumElementDecl *d) {
+    ElementDeclOrUnresolvedOriginalExpr = d;
+  }
+  
+  Expr *getUnresolvedOriginalExpr() const {
+    return ElementDeclOrUnresolvedOriginalExpr.get<Expr*>();
+  }
+  bool hasUnresolvedOriginalExpr() const {
+    return ElementDeclOrUnresolvedOriginalExpr.is<Expr*>();
+  }
   
   SourceLoc getNameLoc() const { return NameLoc; }
   SourceLoc getLoc() const { return NameLoc; }
diff --git a/include/swift/AST/Stmt.h b/include/swift/AST/Stmt.h
index 928da0f..9a6adf5 100644
--- a/include/swift/AST/Stmt.h
+++ b/include/swift/AST/Stmt.h
@@ -20,6 +20,7 @@
 #include "swift/AST/Availability.h"
 #include "swift/AST/AvailabilitySpec.h"
 #include "swift/AST/ASTNode.h"
+#include "swift/AST/IfConfigClause.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/NullablePtr.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -653,41 +654,17 @@
   static bool classof(const Stmt *S) { return S->getKind() == StmtKind::Guard; }
 };
 
-  
-/// This represents one part of a #if block.  If the condition field is
-/// non-null, then this represents a #if or a #elseif, otherwise it represents
-/// an #else block.
-struct IfConfigStmtClause {
-  /// The location of the #if, #elseif, or #else keyword.
-  SourceLoc Loc;
-  
-  /// The condition guarding this #if or #elseif block.  If this is null, this
-  /// is a #else clause.
-  Expr *Cond;
-  
-  /// Elements inside the clause
-  ArrayRef<ASTNode> Elements;
-
-  /// True if this is the active clause of the #if block.
-  bool isActive;
-
-  IfConfigStmtClause(SourceLoc Loc, Expr *Cond,
-                     ArrayRef<ASTNode> Elements, bool isActive)
-    : Loc(Loc), Cond(Cond), Elements(Elements), isActive(isActive) {
-  }
-};
-
 /// IfConfigStmt - This class models the statement-side representation of
 /// #if/#else/#endif blocks.
 class IfConfigStmt : public Stmt {
   /// An array of clauses controlling each of the #if/#elseif/#else conditions.
   /// The array is ASTContext allocated.
-  ArrayRef<IfConfigStmtClause> Clauses;
+  ArrayRef<IfConfigClause<ASTNode>> Clauses;
   SourceLoc EndLoc;
   bool HadMissingEnd;
 
 public:
-  IfConfigStmt(ArrayRef<IfConfigStmtClause> Clauses, SourceLoc EndLoc,
+  IfConfigStmt(ArrayRef<IfConfigClause<ASTNode>> Clauses, SourceLoc EndLoc,
                bool HadMissingEnd)
   : Stmt(StmtKind::IfConfig, /*implicit=*/false),
     Clauses(Clauses), EndLoc(EndLoc), HadMissingEnd(HadMissingEnd) {}
@@ -699,7 +676,9 @@
 
   bool hadMissingEnd() const { return HadMissingEnd; }
   
-  const ArrayRef<IfConfigStmtClause> &getClauses() const { return Clauses; }
+  const ArrayRef<IfConfigClause<ASTNode>> &getClauses() const {
+    return Clauses;
+  }
 
   ArrayRef<ASTNode> getActiveClauseElements() const {
     for (auto &Clause : Clauses)
diff --git a/include/swift/AST/Type.h b/include/swift/AST/Type.h
index 26fdde0..5d3fb2a 100644
--- a/include/swift/AST/Type.h
+++ b/include/swift/AST/Type.h
@@ -361,7 +361,6 @@
                                               OptionalTypeKind &kind);
   static CanType getReferenceStorageReferentImpl(CanType type);
   static CanType getLValueOrInOutObjectTypeImpl(CanType type);
-  static ClassDecl *getClassBoundImpl(CanType type);
 
 public:
   explicit CanType(TypeBase *P = 0) : Type(P) {
@@ -438,15 +437,6 @@
   /// it returns an empty LayoutConstraint.
   LayoutConstraint getLayoutConstraint() const;
 
-  /// \brief Retrieve the most-specific class bound of this type,
-  /// which is either a class, a bound-generic class, or a class-bounded
-  /// archetype.
-  ///
-  /// Returns nil if this is an archetype with a non-specific class bound.
-  ClassDecl *getClassBound() const {
-    return getClassBoundImpl(*this);
-  }
-
   CanType getAnyOptionalObjectType() const {
     OptionalTypeKind kind;
     return getAnyOptionalObjectTypeImpl(*this, kind);
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
index 5bdebfd..166bc0e 100644
--- a/include/swift/AST/TypeRepr.h
+++ b/include/swift/AST/TypeRepr.h
@@ -283,6 +283,9 @@
   SimpleIdentTypeRepr(SourceLoc Loc, Identifier Id)
     : ComponentIdentTypeRepr(TypeReprKind::SimpleIdent, Loc, Id) {}
 
+  SimpleIdentTypeRepr(const SimpleIdentTypeRepr &repr)
+    : SimpleIdentTypeRepr(repr.getLoc(), repr.getIdentifier()) {}
+
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::SimpleIdent;
   }
@@ -846,6 +849,9 @@
   FixedTypeRepr(Type Ty, SourceLoc Loc)
     : TypeRepr(TypeReprKind::Fixed), Ty(Ty), Loc(Loc) {}
 
+  FixedTypeRepr(const FixedTypeRepr& repr)
+    : FixedTypeRepr(repr.Ty, repr.Loc) {}
+
   /// Retrieve the location.
   SourceLoc getLoc() const { return Loc; }
 
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
index 77f492e..743761b 100644
--- a/include/swift/AST/Types.h
+++ b/include/swift/AST/Types.h
@@ -606,13 +606,6 @@
                            LazyResolver *resolver,
                            DeclContext *gpContext = nullptr);
 
-  /// \brief Determine whether the given type is "generic", meaning that
-  /// it involves generic types for which generic arguments have not been
-  /// provided.
-  /// For example, the type Vector and Vector<Int>.InnerGeneric are both
-  /// unspecialized generic, but the type Vector<Int> is not.
-  bool isUnspecializedGeneric();
-
   /// \brief Determine whether this type is a legal, lowered SIL type.
   ///
   /// A type is SIL-illegal if it is:
@@ -882,13 +875,15 @@
   /// Get the substitutions to apply to the type of the given member as seen
   /// from this base type.
   ///
-  /// If the member has its own generic parameters, they will remain unchanged
-  /// by the substitution.
+  /// \param genericEnv If non-null, generic parameters of the member are
+  /// mapped to context archetypes of this generic environment.
   SubstitutionMap getMemberSubstitutionMap(ModuleDecl *module,
-                                           const ValueDecl *member);
+                                           const ValueDecl *member,
+                                           GenericEnvironment *genericEnv=nullptr);
 
   /// Deprecated version of the above.
-  TypeSubstitutionMap getMemberSubstitutions(const ValueDecl *member);
+  TypeSubstitutionMap getMemberSubstitutions(const ValueDecl *member,
+                                             GenericEnvironment *genericEnv=nullptr);
 
   /// Retrieve the type of the given member as seen through the given base
   /// type, substituting generic arguments where necessary.
@@ -4471,6 +4466,8 @@
 inline Type TypeBase::getNominalParent() {
   if (auto classType = getAs<NominalType>()) {
     return classType->getParent();
+  } else if (auto unboundType = getAs<UnboundGenericType>()) {
+    return unboundType->getParent();
   } else {
     return castTo<BoundGenericType>()->getParent();
   }
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
index cd5f872..82a1cee 100644
--- a/include/swift/Basic/LangOptions.h
+++ b/include/swift/Basic/LangOptions.h
@@ -29,6 +29,20 @@
 #include <vector>
 
 namespace swift {
+
+  /// Kind of implicit platform conditions.
+  enum class PlatformConditionKind {
+    /// The active os target (OSX, iOS, Linux, etc.)
+    OS,
+    /// The active arch target (x86_64, i386, arm, arm64, etc.)
+    Arch,
+    /// The active endianness target (big or little)
+    Endianness,
+    /// Runtime support (_ObjC or _Native)
+    Runtime,
+  };
+  enum { NumPlatformConditionKind = 4 };
+
   /// \brief A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions {
@@ -114,6 +128,10 @@
     /// solver should be debugged.
     unsigned DebugConstraintSolverAttempt = 0;
 
+    /// \brief Enable the experimental constraint propagation in the
+    /// type checker.
+    bool EnableConstraintPropagation = false;
+
     /// \brief Enable the iterative type checker.
     bool IterativeTypeChecker = false;
 
@@ -198,14 +216,9 @@
     }
 
     /// Sets an implicit platform condition.
-    ///
-    /// There are currently three supported platform conditions:
-    /// - os: The active os target (OSX or iOS)
-    /// - arch: The active arch target (x86_64, i386, arm, arm64)
-    /// - _runtime: Runtime support (_ObjC or _Native)
-    void addPlatformConditionValue(StringRef Name, StringRef Value) {
-      assert(!Name.empty() && !Value.empty());
-      PlatformConditionValues.emplace_back(Name, Value);
+    void addPlatformConditionValue(PlatformConditionKind Kind, StringRef Value) {
+      assert(!Value.empty());
+      PlatformConditionValues.emplace_back(Kind, Value);
     }
 
     /// Removes all values added with addPlatformConditionValue.
@@ -214,7 +227,7 @@
     }
     
     /// Returns the value for the given platform condition or an empty string.
-    StringRef getPlatformConditionValue(StringRef Name) const;
+    StringRef getPlatformConditionValue(PlatformConditionKind Kind) const;
 
     /// Explicit conditional compilation flags, initialized via the '-D'
     /// compiler flag.
@@ -226,7 +239,7 @@
     /// Determines if a given conditional compilation flag has been set.
     bool isCustomConditionalCompilationFlagSet(StringRef Name) const;
 
-    ArrayRef<std::pair<std::string, std::string>>
+    ArrayRef<std::pair<PlatformConditionKind, std::string>>
     getPlatformConditionValues() const {
       return PlatformConditionValues;
     }
@@ -240,35 +253,18 @@
       return EffectiveLanguageVersion.isVersion3();
     }
 
-    /// Returns true if the 'os' platform condition argument represents
+    /// Returns true if the given platform condition argument represents
     /// a supported target operating system.
     ///
-    /// Note that this also canonicalizes the OS name if the check returns
-    /// true.
-    ///
     /// \param suggestions Populated with suggested replacements
     /// if a match is not found.
-    static bool checkPlatformConditionOS(
-      StringRef &OSName, std::vector<StringRef> &suggestions);
-
-    /// Returns true if the 'arch' platform condition argument represents
-    /// a supported target architecture.
-    ///
-    /// \param suggestions Populated with suggested replacements
-    /// if a match is not found.
-    static bool isPlatformConditionArchSupported(
-      StringRef ArchName, std::vector<StringRef> &suggestions);
-
-    /// Returns true if the 'endian' platform condition argument represents
-    /// a supported target endianness.
-    ///
-    /// \param suggestions Populated with suggested replacements
-    /// if a match is not found.
-    static bool isPlatformConditionEndiannessSupported(
-      StringRef endianness, std::vector<StringRef> &suggestions);
+    static bool checkPlatformConditionSupported(
+      PlatformConditionKind Kind, StringRef Value,
+      std::vector<StringRef> &suggestions);
 
   private:
-    llvm::SmallVector<std::pair<std::string, std::string>, 3>
+    llvm::SmallVector<std::pair<PlatformConditionKind, std::string>,
+                      NumPlatformConditionKind>
         PlatformConditionValues;
     llvm::SmallVector<std::string, 2> CustomConditionalCompilationFlags;
   };
diff --git a/include/swift/Basic/OwnedString.h b/include/swift/Basic/OwnedString.h
index f4240b2..8745de6 100644
--- a/include/swift/Basic/OwnedString.h
+++ b/include/swift/Basic/OwnedString.h
@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
diff --git a/include/swift/Basic/Timer.h b/include/swift/Basic/Timer.h
index 8558cd2..20f199c 100644
--- a/include/swift/Basic/Timer.h
+++ b/include/swift/Basic/Timer.h
@@ -33,8 +33,7 @@
   public:
     explicit SharedTimer(StringRef name) {
       if (CompilationTimersEnabled == State::Enabled)
-        Timer.emplace(name, StringRef("Swift compilation"), StringRef("swift"),
-                      StringRef("swift related timers"));
+        Timer.emplace(name, name, "swift", "Swift compilation");
       else
         CompilationTimersEnabled = State::Skipped;
     }
diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h
index 242f075..c0881c9 100644
--- a/include/swift/ClangImporter/ClangImporter.h
+++ b/include/swift/ClangImporter/ClangImporter.h
@@ -260,8 +260,7 @@
   /// The return value may be an empty identifier, in which case the enum would
   /// not be imported.
   ///
-  /// This is mostly an implementation detail of the importer, but is also
-  /// used by the debugger.
+  /// This is not used by the importer itself, but is used by the debugger.
   Identifier getEnumConstantName(const clang::EnumConstantDecl *enumConstant);
 
   /// Writes the mangled name of \p clangDecl to \p os.
diff --git a/include/swift/ClangImporter/ClangModule.h b/include/swift/ClangImporter/ClangModule.h
index a3ed69b..11d3a38 100644
--- a/include/swift/ClangImporter/ClangModule.h
+++ b/include/swift/ClangImporter/ClangModule.h
@@ -17,6 +17,7 @@
 #define SWIFT_CLANGIMPORTER_CLANGMODULE_H
 
 #include "swift/AST/Module.h"
+#include "swift/ClangImporter/ClangImporter.h"
 
 namespace clang {
   class ASTContext;
@@ -26,12 +27,11 @@
 namespace swift {
 
 class ASTContext;
-class ClangImporter;
 class ModuleLoader;
 
 /// \brief Represents a Clang module that has been imported into Swift.
 class ClangModuleUnit final : public LoadedFile {
-  ClangImporter &owner;
+  ClangImporter::Implementation &owner;
   const clang::Module *clangModule;
   llvm::PointerIntPair<ModuleDecl *, 1, bool> adapterModule;
   mutable ArrayRef<ModuleDecl::ImportedModule> importedModulesForLookup;
@@ -42,7 +42,7 @@
   /// True if the given Module contains an imported Clang module unit.
   static bool hasClangModule(ModuleDecl *M);
 
-  ClangModuleUnit(ModuleDecl &M, ClangImporter &owner,
+  ClangModuleUnit(ModuleDecl &M, ClangImporter::Implementation &owner,
                   const clang::Module *clangModule);
 
   /// \brief Retrieve the underlying Clang module.
diff --git a/include/swift/IDE/Utils.h b/include/swift/IDE/Utils.h
index c472f12..633e77f 100644
--- a/include/swift/IDE/Utils.h
+++ b/include/swift/IDE/Utils.h
@@ -307,7 +307,7 @@
   unsigned commonPartsCount(DeclNameViewer &Other) const;
 };
 
-/// This provide a utility for writing to a underlying string buffer multiple
+/// This provide a utility for writing to an underlying string buffer mulitiple
 /// string pieces and retrieve them later when the underlying buffer is stable.
 class DelayedStringRetriever : public raw_ostream {
     SmallVectorImpl<char> &OS;
diff --git a/include/swift/Option/FrontendOptions.td b/include/swift/Option/FrontendOptions.td
index cd1111b..260b898 100644
--- a/include/swift/Option/FrontendOptions.td
+++ b/include/swift/Option/FrontendOptions.td
@@ -139,6 +139,9 @@
 def debug_constraints_attempt : Separate<["-"], "debug-constraints-attempt">,
   HelpText<"Debug the constraint solver at a given attempt">;
 
+def propagate_constraints : Flag<["-"], "propagate-constraints">,
+  HelpText<"Enable constraint propagation in the type checker">;
+
 def iterative_type_checker : Flag<["-"], "iterative-type-checker">,
   HelpText<"Enable the iterative type checker">;
 
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
index 5496801..ea69199 100644
--- a/include/swift/Parse/Parser.h
+++ b/include/swift/Parse/Parser.h
@@ -750,6 +750,9 @@
                                            DeclAttributes &Attributes);
   ParserStatus parseInheritance(SmallVectorImpl<TypeLoc> &Inherited,
                                 SourceLoc *classRequirementLoc);
+  ParserStatus parseDeclItem(bool &PreviousHadSemi,
+                             Parser::ParseDeclOptions Options,
+                             llvm::function_ref<void(Decl*)> handler);
   bool parseDeclList(SourceLoc LBLoc, SourceLoc &RBLoc,
                      Diag<> ErrorDiag, ParseDeclOptions Options,
                      llvm::function_ref<void(Decl*)> handler);
diff --git a/include/swift/Remote/MetadataReader.h b/include/swift/Remote/MetadataReader.h
index 8097ab5..a2fcbcd 100644
--- a/include/swift/Remote/MetadataReader.h
+++ b/include/swift/Remote/MetadataReader.h
@@ -869,6 +869,8 @@
       return {true, metadataPointer};
     }
     }
+
+    swift_runtime_unreachable("Unhandled IsaEncodingKind in switch.");
   }
 
   /// Read the parent type metadata from a nested nominal type metadata.
diff --git a/include/swift/Runtime/HeapObject.h b/include/swift/Runtime/HeapObject.h
index e21d417..cfb6fba 100644
--- a/include/swift/Runtime/HeapObject.h
+++ b/include/swift/Runtime/HeapObject.h
@@ -510,6 +510,16 @@
 void swift_unownedRelease(HeapObject *value)
     SWIFT_CC(RegisterPreservingCC);
 
+/// Increment the unowned retain count.
+SWIFT_RT_ENTRY_VISIBILITY
+void swift_nonatomic_unownedRetain(HeapObject *value)
+    SWIFT_CC(RegisterPreservingCC);
+
+/// Decrement the unowned retain count.
+SWIFT_RT_ENTRY_VISIBILITY
+void swift_nonatomic_unownedRelease(HeapObject *value)
+    SWIFT_CC(RegisterPreservingCC);
+
 /// Increment the unowned retain count by n.
 SWIFT_RT_ENTRY_VISIBILITY
 void swift_unownedRetain_n(HeapObject *value, int n)
@@ -520,12 +530,28 @@
 void swift_unownedRelease_n(HeapObject *value, int n)
     SWIFT_CC(RegisterPreservingCC);
 
+/// Increment the unowned retain count by n.
+SWIFT_RT_ENTRY_VISIBILITY
+void swift_nonatomic_unownedRetain_n(HeapObject *value, int n)
+    SWIFT_CC(RegisterPreservingCC);
+
+/// Decrement the unowned retain count by n.
+SWIFT_RT_ENTRY_VISIBILITY
+void swift_nonatomic_unownedRelease_n(HeapObject *value, int n)
+    SWIFT_CC(RegisterPreservingCC);
+
 /// Increment the strong retain count of an object, aborting if it has
 /// been deallocated.
 SWIFT_RT_ENTRY_VISIBILITY
 void swift_unownedRetainStrong(HeapObject *value)
     SWIFT_CC(RegisterPreservingCC);
 
+/// Increment the strong retain count of an object, aborting if it has
+/// been deallocated.
+SWIFT_RT_ENTRY_VISIBILITY
+void swift_nonatomic_unownedRetainStrong(HeapObject *value)
+    SWIFT_CC(RegisterPreservingCC);
+
 /// Increment the strong retain count of an object which may have been
 /// deallocated, aborting if it has been deallocated, and decrement its
 /// unowned reference count.
@@ -533,6 +559,13 @@
 void swift_unownedRetainStrongAndRelease(HeapObject *value)
     SWIFT_CC(RegisterPreservingCC);
 
+/// Increment the strong retain count of an object which may have been
+/// deallocated, aborting if it has been deallocated, and decrement its
+/// unowned reference count.
+SWIFT_RT_ENTRY_VISIBILITY
+void swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *value)
+    SWIFT_CC(RegisterPreservingCC);
+
 /// Aborts if the object has been deallocated.
 SWIFT_RUNTIME_EXPORT
 void swift_unownedCheck(HeapObject *value);
diff --git a/include/swift/Runtime/Metadata.h b/include/swift/Runtime/Metadata.h
index 555a2b0..4a8ceb0 100644
--- a/include/swift/Runtime/Metadata.h
+++ b/include/swift/Runtime/Metadata.h
@@ -769,6 +769,8 @@
   value_witness_types::storeExtraInhabitant *storeExtraInhabitant;
   value_witness_types::getExtraInhabitantIndex *getExtraInhabitantIndex;
 
+#define SET_WITNESS(NAME) base.NAME,
+
   constexpr ExtraInhabitantsValueWitnessTable()
     : ValueWitnessTable{}, extraInhabitantFlags(),
       storeExtraInhabitant(nullptr),
@@ -778,9 +780,15 @@
                             value_witness_types::extraInhabitantFlags eif,
                             value_witness_types::storeExtraInhabitant *sei,
                             value_witness_types::getExtraInhabitantIndex *geii)
-    : ValueWitnessTable(base), extraInhabitantFlags(eif),
+    : ValueWitnessTable{
+      FOR_ALL_FUNCTION_VALUE_WITNESSES(SET_WITNESS)
+      base.size,
+      base.flags,
+      base.stride
+    }, extraInhabitantFlags(eif),
       storeExtraInhabitant(sei),
       getExtraInhabitantIndex(geii) {}
+#undef SET_WITNESS
 
   static bool classof(const ValueWitnessTable *table) {
     return table->flags.hasExtraInhabitants();
diff --git a/include/swift/Runtime/RuntimeFunctions.def b/include/swift/Runtime/RuntimeFunctions.def
index 9c82868..2be2880 100644
--- a/include/swift/Runtime/RuntimeFunctions.def
+++ b/include/swift/Runtime/RuntimeFunctions.def
@@ -369,6 +369,20 @@
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind))
 
+// void swift_nonatomic_unownedRetain(void *ptr);
+FUNCTION(NonAtomicNativeUnownedRetain, swift_nonatomic_unownedRetain,
+         RegisterPreservingCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
+// void swift_nonatomic_unownedRelease(void *ptr);
+FUNCTION(NonAtomicNativeUnownedRelease, swift_nonatomic_unownedRelease,
+         RegisterPreservingCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
 // void swift_unownedRetain_n(void *ptr, int32_t n);
 FUNCTION(UnownedRetainN, swift_unownedRetain_n,
          RegisterPreservingCC,
@@ -383,12 +397,33 @@
          ARGS(RefCountedPtrTy, Int32Ty),
          ATTRS(NoUnwind))
 
+// void swift_nonatomic_unownedRetain_n(void *ptr, int32_t n);
+FUNCTION(NonAtomicUnownedRetainN, swift_nonatomic_unownedRetain_n,
+         RegisterPreservingCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy, Int32Ty),
+         ATTRS(NoUnwind))
+
+// void swift_nonatomic_unownedRelease_n(void *ptr, int32_t n);
+FUNCTION(NonAtomicUnownedReleaseN, swift_nonatomic_unownedRelease_n,
+         RegisterPreservingCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy, Int32Ty),
+         ATTRS(NoUnwind))
+
 // void swift_unownedRetainStrong(void *ptr);
 FUNCTION(NativeStrongRetainUnowned, swift_unownedRetainStrong, RegisterPreservingCC,
          RETURNS(VoidTy),
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind))
 
+// void swift_nonatomic_unownedRetainStrong(void *ptr);
+FUNCTION(NonAtomicNativeStrongRetainUnowned, swift_nonatomic_unownedRetainStrong,
+         RegisterPreservingCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
 // void swift_unownedRetainStrongAndRelease(void *ptr);
 FUNCTION(NativeStrongRetainAndUnownedRelease,
          swift_unownedRetainStrongAndRelease, RegisterPreservingCC,
@@ -396,6 +431,13 @@
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind))
 
+// void swift_nonatomic_unownedRetainStrongAndRelease(void *ptr);
+FUNCTION(NonAtomicNativeStrongRetainAndUnownedRelease,
+         swift_nonatomic_unownedRetainStrongAndRelease, RegisterPreservingCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
 // void swift_weakDestroy(WeakReference *object);
 FUNCTION(NativeWeakDestroy, swift_weakDestroy, DefaultCC,
          RETURNS(VoidTy),
diff --git a/include/swift/SIL/PatternMatch.h b/include/swift/SIL/PatternMatch.h
index 831abb1..b50ac0f 100644
--- a/include/swift/SIL/PatternMatch.h
+++ b/include/swift/SIL/PatternMatch.h
@@ -369,6 +369,7 @@
 UNARY_OP_MATCH_WITH_ARG_MATCHER(InitExistentialOpaqueInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(InitExistentialRefInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(DeinitExistentialAddrInst)
+UNARY_OP_MATCH_WITH_ARG_MATCHER(DeinitExistentialOpaqueInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ProjectBlockStorageInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(StrongRetainInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(StrongReleaseInst)
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
index 79821fb..1088268 100644
--- a/include/swift/SIL/SILBuilder.h
+++ b/include/swift/SIL/SILBuilder.h
@@ -479,7 +479,8 @@
   /// non-address values.
   SILValue emitLoadValueOperation(SILLocation Loc, SILValue LV,
                                   LoadOwnershipQualifier Qualifier) {
-    assert(LV->getType().isLoadable(F.getModule()));
+    assert(!SILModuleConventions(F.getModule()).useLoweredAddresses()
+           || LV->getType().isLoadable(F.getModule()));
     const auto &lowering = getTypeLowering(LV->getType());
     return lowering.emitLoad(*this, Loc, LV, Qualifier);
   }
@@ -819,17 +820,19 @@
   }
 
   UnmanagedRetainValueInst *createUnmanagedRetainValue(SILLocation Loc,
-                                                       SILValue operand) {
+                                                       SILValue operand,
+                                                       Atomicity atomicity) {
     assert(F.hasQualifiedOwnership());
     return insert(new (F.getModule()) UnmanagedRetainValueInst(
-        getSILDebugLocation(Loc), operand));
+        getSILDebugLocation(Loc), operand, atomicity));
   }
 
   UnmanagedReleaseValueInst *createUnmanagedReleaseValue(SILLocation Loc,
-                                                         SILValue operand) {
+                                                         SILValue operand,
+                                                         Atomicity atomicity) {
     assert(F.hasQualifiedOwnership());
     return insert(new (F.getModule()) UnmanagedReleaseValueInst(
-        getSILDebugLocation(Loc), operand));
+        getSILDebugLocation(Loc), operand, atomicity));
   }
 
   CopyValueInst *createCopyValue(SILLocation Loc, SILValue operand) {
@@ -856,9 +859,10 @@
   }
 
   UnmanagedAutoreleaseValueInst *
-  createUnmanagedAutoreleaseValue(SILLocation Loc, SILValue operand) {
+  createUnmanagedAutoreleaseValue(SILLocation Loc, SILValue operand,
+                                  Atomicity atomicity) {
     return insert(new (F.getModule()) UnmanagedAutoreleaseValueInst(
-                      getSILDebugLocation(Loc), operand));
+                      getSILDebugLocation(Loc), operand, atomicity));
   }
 
   SetDeallocatingInst *createSetDeallocating(SILLocation Loc,
@@ -1175,6 +1179,12 @@
         getSILDebugLocation(Loc), Existential));
   }
 
+  DeinitExistentialOpaqueInst *
+  createDeinitExistentialOpaque(SILLocation Loc, SILValue Existential) {
+    return insert(new (F.getModule()) DeinitExistentialOpaqueInst(
+        getSILDebugLocation(Loc), Existential));
+  }
+
   ProjectBlockStorageInst *createProjectBlockStorage(SILLocation Loc,
                                                      SILValue Storage) {
     auto CaptureTy = Storage->getType()
@@ -1529,6 +1539,11 @@
   // Memory management helpers
   //===--------------------------------------------------------------------===//
 
+  /// Returns the default atomicity of the module.
+  Atomicity getDefaultAtomicity() {
+    return getModule().isDefaultAtomic() ? Atomicity::Atomic : Atomicity::NonAtomic;
+  }
+
   /// Try to fold a destroy_addr operation into the previous instructions, or
   /// generate an explicit one if that fails.  If this inserts a new
   /// instruction, it returns it, otherwise it returns null.
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
index 1308eba..9184783 100644
--- a/include/swift/SIL/SILCloner.h
+++ b/include/swift/SIL/SILCloner.h
@@ -143,28 +143,43 @@
   
   SILType getTypeInClonedContext(SILType Ty) {
     // Substitute opened existential types, if we have any.
-    if (!OpenedExistentialSubs.empty()) {
-      auto &F = getBuilder().getFunction();
-      Ty = Ty.subst(F.getModule(),
-                    QueryTypeSubstitutionMap{OpenedExistentialSubs},
-                    MakeAbstractConformanceForGenericType());
-    }
-
-    return Ty;
+    return SILType::getPrimitiveObjectType(
+      getASTTypeInClonedContext(Ty.getSwiftRValueType()))
+      .copyCategory(Ty);
   }
   SILType getOpType(SILType Ty) {
     Ty = getTypeInClonedContext(Ty);
     return asImpl().remapType(Ty);
   }
-  
+
   CanType getASTTypeInClonedContext(CanType ty) {
-    // Substitute opened existential types, if we have any.
-    if (!OpenedExistentialSubs.empty()) {
-      ty = ty.subst(QueryTypeSubstitutionMap{OpenedExistentialSubs},
-                    MakeAbstractConformanceForGenericType())
-          ->getCanonicalType();
-    }
-    return ty;
+    // Do not substitute opened existential types, if we do not have any.
+    if (!ty->hasOpenedExistential())
+      return ty;
+    // Do not substitute opened existential types, if it is not required.
+    // This is often the case when cloning basic blocks inside the same
+    // function.
+    if (OpenedExistentialSubs.empty())
+      return ty;
+
+    return ty.transform(
+      [&](Type t) -> Type {
+        if (t->isOpenedExistential()) {
+          auto found = OpenedExistentialSubs.find(
+            t->castTo<ArchetypeType>());
+          // If an opened existential is supposed to be
+          // remapped, it is guaranteed by construction
+          // to be in the OpenedExistentialSubs, because
+          // a cloner always processes definitions of
+          // opened existentials before their uses and
+          // adds found opened existentials definitions
+          // to the map.
+          if (found != OpenedExistentialSubs.end())
+            return found->second;
+          return t;
+        }
+        return t;
+      })->getCanonicalType();
   }
   CanType getOpASTType(CanType ty) {
     ty = getASTTypeInClonedContext(ty);
@@ -1176,7 +1191,8 @@
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   doPostProcess(
       Inst, getBuilder().createUnmanagedRetainValue(
-                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
+                  Inst->getAtomicity()));
 }
 
 template <typename ImplClass>
@@ -1211,7 +1227,8 @@
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   doPostProcess(
       Inst, getBuilder().createUnmanagedReleaseValue(
-                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
+                  Inst->getAtomicity()));
 }
 
 template <typename ImplClass>
@@ -1238,7 +1255,8 @@
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   doPostProcess(
       Inst, getBuilder().createUnmanagedAutoreleaseValue(
-                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
+                  Inst->getAtomicity()));
 }
 
 template<typename ImplClass>
@@ -1645,6 +1663,15 @@
                                          getOpValue(Inst->getOperand())));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitDeinitExistentialOpaqueInst(
+    DeinitExistentialOpaqueInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(
+      Inst, getBuilder().createDeinitExistentialOpaque(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitCopyBlockInst(CopyBlockInst *Inst) {
diff --git a/include/swift/SIL/SILFunctionConventions.h b/include/swift/SIL/SILFunctionConventions.h
index 182db02..615fc12 100644
--- a/include/swift/SIL/SILFunctionConventions.h
+++ b/include/swift/SIL/SILFunctionConventions.h
@@ -148,6 +148,12 @@
   /// Get the error result type.
   SILType getSILErrorType() { return getSILType(funcTy->getErrorResult()); }
 
+  /// Returns an array of result info.
+  /// Provides convenient access to the underlying SILFunctionType.
+  ArrayRef<SILResultInfo> getResults() const {
+    return funcTy->getResults();
+  }
+
   /// Get the number of SIL results passed as address-typed arguments.
   unsigned getNumIndirectSILResults() const {
     return silConv.loweredAddresses ? funcTy->getNumIndirectFormalResults() : 0;
@@ -243,7 +249,7 @@
   /// SILFunctionType.
   unsigned getNumParameters() const { return funcTy->getNumParameters(); }
 
-  /// Returns an array if parameter info, not including indirect
+  /// Returns an array of parameter info, not including indirect
   /// results. Provides convenient access to the underlying SILFunctionType.
   ArrayRef<SILParameterInfo> getParameters() const {
     return funcTy->getParameters();
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
index d8c47ec..77766a7 100644
--- a/include/swift/SIL/SILInstruction.h
+++ b/include/swift/SIL/SILInstruction.h
@@ -3021,8 +3021,11 @@
                                   /*HasValue*/ false> {
   friend SILBuilder;
 
-  UnmanagedRetainValueInst(SILDebugLocation DebugLoc, SILValue operand)
-      : UnaryInstructionBase(DebugLoc, operand) {}
+  UnmanagedRetainValueInst(SILDebugLocation DebugLoc, SILValue operand,
+                           Atomicity atomicity)
+      : UnaryInstructionBase(DebugLoc, operand) {
+    setAtomicity(atomicity);
+  }
 };
 
 /// Destroys a loadable value in an unmanaged, unbalanced way. Only meant for
@@ -3034,8 +3037,11 @@
                                   /*HasValue*/ false> {
   friend SILBuilder;
 
-  UnmanagedReleaseValueInst(SILDebugLocation DebugLoc, SILValue operand)
-      : UnaryInstructionBase(DebugLoc, operand) {}
+  UnmanagedReleaseValueInst(SILDebugLocation DebugLoc, SILValue operand,
+                            Atomicity atomicity)
+      : UnaryInstructionBase(DebugLoc, operand) {
+    setAtomicity(atomicity);
+  }
 };
 
 /// Transfers ownership of a loadable value to the current autorelease
@@ -3046,8 +3052,11 @@
                                                 /*HasValue*/ false> {
   friend SILBuilder;
 
-  UnmanagedAutoreleaseValueInst(SILDebugLocation DebugLoc, SILValue operand)
-      : UnaryInstructionBase(DebugLoc, operand) {}
+  UnmanagedAutoreleaseValueInst(SILDebugLocation DebugLoc, SILValue operand,
+                                Atomicity atomicity)
+      : UnaryInstructionBase(DebugLoc, operand) {
+    setAtomicity(atomicity);
+  }
 };
 
 /// Transfers ownership of a loadable value to the current autorelease pool.
@@ -4167,6 +4176,15 @@
       : UnaryInstructionBase(DebugLoc, Existential) {}
 };
 
+class DeinitExistentialOpaqueInst
+    : public UnaryInstructionBase<ValueKind::DeinitExistentialOpaqueInst,
+                                  SILInstruction, /*HAS_RESULT*/ false> {
+  friend SILBuilder;
+
+  DeinitExistentialOpaqueInst(SILDebugLocation DebugLoc, SILValue Existential)
+      : UnaryInstructionBase(DebugLoc, Existential) {}
+};
+
 /// Projects the capture storage address from a @block_storage address.
 class ProjectBlockStorageInst
   : public UnaryInstructionBase<ValueKind::ProjectBlockStorageInst,
diff --git a/include/swift/SIL/SILModule.h b/include/swift/SIL/SILModule.h
index f4ed80f..f184c9b 100644
--- a/include/swift/SIL/SILModule.h
+++ b/include/swift/SIL/SILModule.h
@@ -642,6 +642,11 @@
 
   /// Returns true if the builtin or intrinsic is no-return.
   bool isNoReturnBuiltinOrIntrinsic(Identifier Name);
+
+  /// Returns true if the default atomicity of the module is Atomic.
+  bool isDefaultAtomic() const {
+    return ! getOptions().AssumeSingleThreaded;
+  }
 };
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SILModule &M){
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
index 63e796d..770fec1 100644
--- a/include/swift/SIL/SILNodes.def
+++ b/include/swift/SIL/SILNodes.def
@@ -227,6 +227,8 @@
   INST(InitExistentialOpaqueInst, SILInstruction, init_existential_opaque, MayWrite, DoesNotRelease)
   INST(DeinitExistentialAddrInst, SILInstruction, deinit_existential_addr, MayHaveSideEffects,
        DoesNotRelease)
+  INST(DeinitExistentialOpaqueInst, SILInstruction, deinit_existential_opaque, MayHaveSideEffects,
+       DoesNotRelease)
   INST(OpenExistentialAddrInst, SILInstruction, open_existential_addr, MayRead, DoesNotRelease)
   INST(InitExistentialRefInst, SILInstruction, init_existential_ref, None, DoesNotRelease)
   INST(OpenExistentialRefInst, SILInstruction, open_existential_ref, None, DoesNotRelease)
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
index 1bdd049..cb46848 100644
--- a/include/swift/SIL/SILType.h
+++ b/include/swift/SIL/SILType.h
@@ -127,12 +127,6 @@
     return SILType(T, SILValueCategory::Address);
   }
 
-  ///  Apply a substitution to the function type.
-  static CanSILFunctionType substFuncType(SILModule &silModule,
-                                          const SubstitutionMap &subs,
-                                          CanSILFunctionType SrcTy,
-                                          bool dropGenerics);
-
   bool isNull() const { return value.getPointer() == nullptr; }
   explicit operator bool() const { return bool(value.getPointer()); }
 
@@ -166,15 +160,6 @@
   CanType getSwiftRValueType() const {
     return CanType(value.getPointer());
   }
-
-  /// Returns the Swift type equivalent to this SIL type. If the SIL type is
-  /// an address type, returns an InOutType.
-  CanType getSwiftType() const {
-    CanType rvalueTy = getSwiftRValueType();
-    if (isAddress())
-      return CanInOutType::get(rvalueTy);
-    return rvalueTy;
-  }
   
   /// Returns the AbstractCC of a function type.
   /// The SILType must refer to a function type.
@@ -436,9 +421,14 @@
   SILType substGenericArgs(SILModule &M,
                            SubstitutionList Subs) const;
 
+  /// If the original type is generic, pass the signature as genericSig.
+  ///
+  /// If the replacement types are generic, you must push a generic context
+  /// first.
   SILType subst(SILModule &silModule,
                 TypeSubstitutionFn subs,
-                LookupConformanceFn conformances) const;
+                LookupConformanceFn conformances,
+                CanGenericSignature genericSig=CanGenericSignature()) const;
 
   SILType subst(SILModule &silModule, const SubstitutionMap &subs) const;
 
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
index 6c2f784..dd42035 100644
--- a/include/swift/SIL/TypeLowering.h
+++ b/include/swift/SIL/TypeLowering.h
@@ -622,7 +622,8 @@
   CanSILFunctionType
   getMaterializeForSetCallbackType(AbstractStorageDecl *storage,
                                    CanGenericSignature genericSig,
-                                   Type selfType);
+                                   Type selfType,
+                                   SILFunctionTypeRepresentation rep);
 
   /// Return the SILFunctionType for a native function value of the
   /// given type.
@@ -675,13 +676,6 @@
   SILConstantInfo getConstantOverrideInfo(SILDeclRef constant,
                                           SILDeclRef base);
 
-  /// Substitute the given function type so that it implements the
-  /// given substituted type.
-  CanSILFunctionType substFunctionType(CanSILFunctionType origFnType,
-                                 CanAnyFunctionType origLoweredType,
-                                 CanAnyFunctionType substLoweredInterfaceType,
-                         const Optional<ForeignErrorConvention> &foreignError);
-  
   /// Get the empty tuple type as a SILType.
   SILType getEmptyTupleType() {
     return getLoweredType(TupleType::getEmpty(Context));
diff --git a/include/swift/SIL/TypeSubstCloner.h b/include/swift/SIL/TypeSubstCloner.h
index e8ff184..234016d 100644
--- a/include/swift/SIL/TypeSubstCloner.h
+++ b/include/swift/SIL/TypeSubstCloner.h
@@ -97,12 +97,12 @@
   }
 
   Substitution remapSubstitution(Substitution sub) {
-    sub = sub.subst(SwiftMod, SubsMap);
-
     // Remap opened archetypes into the cloned context.
-    return Substitution(getASTTypeInClonedContext(sub.getReplacement()
-                                                    ->getCanonicalType()),
-                        sub.getConformances());
+    sub = Substitution(
+        getASTTypeInClonedContext(sub.getReplacement()->getCanonicalType()),
+        sub.getConformances());
+    // Now remap the substitution. 
+    return sub.subst(SwiftMod, SubsMap);
   }
 
   ProtocolConformanceRef remapConformance(CanType type,
diff --git a/include/swift/SILOptimizer/Utils/Devirtualize.h b/include/swift/SILOptimizer/Utils/Devirtualize.h
index dfcfe5e..44bede7 100644
--- a/include/swift/SILOptimizer/Utils/Devirtualize.h
+++ b/include/swift/SILOptimizer/Utils/Devirtualize.h
@@ -54,9 +54,7 @@
                                                SILValue ClassInstance);
 DevirtualizationResult tryDevirtualizeClassMethod(FullApplySite AI,
                                                   SILValue ClassInstance);
-DevirtualizationResult tryDevirtualizeWitnessMethod(ApplySite AI); 
-/// Check if an upcast is legal.
-bool isLegalUpcast(SILType FromTy, SILType ToTy);
+DevirtualizationResult tryDevirtualizeWitnessMethod(ApplySite AI);
 }
 
 #endif
diff --git a/include/swift/SILOptimizer/Utils/Local.h b/include/swift/SILOptimizer/Utils/Local.h
index caf0480..6ca651c 100644
--- a/include/swift/SILOptimizer/Utils/Local.h
+++ b/include/swift/SILOptimizer/Utils/Local.h
@@ -110,22 +110,10 @@
 /// - a type of the return value is a subclass of the expected return type.
 /// - actual return type and expected return type differ in optionality.
 /// - both types are tuple-types and some of the elements need to be casted.
-///
-/// If CheckOnly flag is set, then this function only checks if the
-/// required casting is possible. If it is not possible, then None
-/// is returned.
-/// If CheckOnly is not set, then a casting code is generated and the final
-/// casted value is returned.
-Optional<SILValue> castValueToABICompatibleType(SILBuilder *B, SILLocation Loc,
-                                                SILValue Value,
-                                                SILType SrcTy,
-                                                SILType DestTy,
-                                                bool CheckOnly = false);
-
-/// Check if the optimizer can cast a value into the expected,
-/// ABI compatible type if necessary.
-bool canCastValueToABICompatibleType(SILModule &M,
-                                     SILType SrcTy, SILType DestTy);
+SILValue castValueToABICompatibleType(SILBuilder *B, SILLocation Loc,
+                                      SILValue Value,
+                                      SILType SrcTy,
+                                      SILType DestTy);
 
 /// Returns a project_box if it is the next instruction after \p ABI and
 /// and has \p ABI as operand. Otherwise it creates a new project_box right
diff --git a/include/swift/Sema/Semantics.h b/include/swift/Sema/Semantics.h
index c399df2..524a2b5 100644
--- a/include/swift/Sema/Semantics.h
+++ b/include/swift/Sema/Semantics.h
@@ -1,4 +1,4 @@
-//===--- Semantics.h - Swift Container for Semantic Info ----*- C++ -*-===//
+//===--- Semantics.h - Swift Container for Semantic Info --------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/include/swift/Serialization/ModuleFormat.h b/include/swift/Serialization/ModuleFormat.h
index fd084f9..e790e71 100644
--- a/include/swift/Serialization/ModuleFormat.h
+++ b/include/swift/Serialization/ModuleFormat.h
@@ -54,7 +54,7 @@
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 320; // Last change: inherited protocols
+const uint16_t VERSION_MINOR = 321; // Last change: restrict to extension
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;
@@ -1181,7 +1181,7 @@
   using XRefTypePathPieceLayout = BCRecordLayout<
     XREF_TYPE_PATH_PIECE,
     IdentifierIDField, // name
-    BCFixed<1>         // only in nominal
+    BCFixed<1>         // restrict to protocol extension
   >;
 
   using XRefValuePathPieceLayout = BCRecordLayout<
diff --git a/include/swift/Syntax/DeclSyntax.h b/include/swift/Syntax/DeclSyntax.h
index f826ed4..eb936fa 100644
--- a/include/swift/Syntax/DeclSyntax.h
+++ b/include/swift/Syntax/DeclSyntax.h
@@ -1,4 +1,4 @@
-//===--- DeclSyntax.cpp - Declaration Syntax Interface ----------*- C++ -*-===//
+//===--- DeclSyntax.h - Declaration Syntax Interface ------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -25,6 +25,7 @@
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
 #include "swift/Syntax/TypeSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 #include "llvm/ADT/BitVector.h"
 
@@ -56,7 +57,7 @@
 
 #pragma mark - unknown-declaration Data
 
-class UnknownDeclSyntaxData : public DeclSyntaxData {
+class UnknownDeclSyntaxData : public UnknownSyntaxData {
   UnknownDeclSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
                         CursorIndex IndexInParent = 0);
 public:
@@ -71,7 +72,7 @@
 
 #pragma mark - unknown-declaration API
 
-class UnknownDeclSyntax : public DeclSyntax {
+class UnknownDeclSyntax : public UnknownSyntax {
   friend class SyntaxData;
   friend class UnknownStmtSyntaxData;
   friend class LegacyASTTransformer;
diff --git a/include/swift/Syntax/ExprSyntax.h b/include/swift/Syntax/ExprSyntax.h
index 2873c65..5dbebda 100644
--- a/include/swift/Syntax/ExprSyntax.h
+++ b/include/swift/Syntax/ExprSyntax.h
@@ -1,4 +1,4 @@
-//===--- ExprSyntax.h - Swift Expression Syntax Interface --------*- C++ -*-===//
+//===--- ExprSyntax.h - Swift Expression Syntax Interface -------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -23,12 +23,16 @@
 #include "swift/Syntax/Syntax.h"
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using llvm::Optional;
 
 namespace swift {
 namespace syntax {
 
+class GenericArgumentClauseSyntax;
+class GenericArgumentClauseSyntaxData;
+
 class ExprSyntaxData : public SyntaxData {
 protected:
   ExprSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
@@ -58,7 +62,7 @@
 
 #pragma mark - unknown-expression Data
 
-class UnknownExprSyntaxData : public ExprSyntaxData {
+class UnknownExprSyntaxData : public UnknownSyntaxData {
   UnknownExprSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
                         CursorIndex IndexInParent = 0);
 public:
@@ -73,17 +77,17 @@
 
 #pragma mark - unknown-expression API
 
-class UnknownExprSyntax : public ExprSyntax {
+class UnknownExprSyntax : public UnknownSyntax {
   friend class SyntaxData;
   friend class UnknownExprSyntaxData;
   friend class LegacyASTTransformer;
 
   using DataType = UnknownExprSyntaxData;
 
+public:
   UnknownExprSyntax(const RC<SyntaxData> Root,
                     const UnknownExprSyntaxData *Data);
 
-public:
   static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::UnknownExpr;
   }
@@ -144,6 +148,329 @@
   }
 };
 
+#pragma mark - symbolic-reference Data
+
+class SymbolicReferenceExprSyntaxData : public ExprSyntaxData {
+  friend class SymbolicReferenceExprSyntax;
+  friend class SyntaxData;
+  friend struct SyntaxFactory;
+
+  RC<GenericArgumentClauseSyntaxData> CachedGenericArgClause;
+
+  SymbolicReferenceExprSyntaxData(RC<RawSyntax> Raw,
+                                  const SyntaxData *Parent = nullptr,
+                                  CursorIndex IndexInParent = 0);
+
+  static RC<SymbolicReferenceExprSyntaxData>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0);
+
+  static RC<SymbolicReferenceExprSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::SymbolicReferenceExpr;
+  }
+};
+
+#pragma mark - symbolic-reference API
+
+/// symbolic-reference-expression -> identifier generic-argument-clause?
+///
+/// This is shown as primary-expression -> identifier generic-argument-clause?
+/// in the grammar. It can be just an identifier referring to some
+/// declaration, or it could perhaps be a constructor call to `Array<Int>`.
+class SymbolicReferenceExprSyntax : public ExprSyntax {
+
+  using DataType = SymbolicReferenceExprSyntaxData;
+
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class Syntax;
+  friend class SymbolicReferenceExprSyntaxData;
+
+  enum class Cursor : CursorIndex {
+    Identifier,
+    GenericArgumentClause
+  };
+
+  SymbolicReferenceExprSyntax(const RC<SyntaxData> Root,
+                              const DataType *Data);
+
+public:
+
+  /// Get the identifier for the symbol to which this expression refers.
+  RC<TokenSyntax> getIdentifier() const;
+
+  /// Return a new `SymbolicReferenceExprSyntax` with the given identifier.
+  SymbolicReferenceExprSyntax
+  withIdentifier(RC<TokenSyntax> NewIdentifier) const;
+
+  /// Return the generic arguments this symbolic reference has, if it has one.
+  llvm::Optional<GenericArgumentClauseSyntax> getGenericArgumentClause() const;
+
+  /// Return a new `SymbolicReferenceExprSyntax` with the given generic
+  /// arguments.
+  SymbolicReferenceExprSyntax
+  withGenericArgumentClause(GenericArgumentClauseSyntax NewGenericArgs) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::SymbolicReferenceExpr;
+  }
+};
+
+#pragma mark - function-call-argument Data
+
+class FunctionCallArgumentSyntaxData : public SyntaxData {
+  friend struct SyntaxFactory;
+  friend class FunctionCallArgumentSyntax;
+  friend class SyntaxData;
+
+  RC<ExprSyntaxData> CachedExpression;
+
+  FunctionCallArgumentSyntaxData(RC<RawSyntax> Raw,
+                           const SyntaxData *Parent = nullptr,
+                           CursorIndex IndexInParent = 0);
+
+  static RC<FunctionCallArgumentSyntaxData>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0);
+
+  static RC<FunctionCallArgumentSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::FunctionCallArgument;
+  }
+};
+
+#pragma mark - function-call-argument API
+
+/// function-call-argument -> label? ':'? (expression | operator) ','?
+class FunctionCallArgumentSyntax : public Syntax {
+
+  using DataType = FunctionCallArgumentSyntaxData;
+
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class Syntax;
+  friend class FunctionCallArgumentSyntaxData;
+  friend class FunctionCallArgumentListSyntax;
+
+  enum class Cursor {
+    Label,
+    Colon,
+    Expression,
+    Comma,
+  };
+
+  FunctionCallArgumentSyntax(const RC<SyntaxData> Root,
+                             const DataType *Data);
+
+public:
+
+  /// Return the label identifier for this argument, if it has one.
+  RC<TokenSyntax> getLabel() const;
+
+  /// Return a new `FunctionCallArgumentSyntax` with the given label.
+  FunctionCallArgumentSyntax withLabel(RC<TokenSyntax> NewLabel) const;
+
+  /// Get the colon ':' token in between the label and argument,
+  /// if there is one.
+  RC<TokenSyntax> getColonToken() const;
+
+  /// Return a new `FunctionCallArgumentSyntax` with the given colon ':' token.
+  FunctionCallArgumentSyntax withColonToken(RC<TokenSyntax> NewColon) const;
+
+  /// Returns the expression of the argument.
+  llvm::Optional<ExprSyntax> getExpression() const;
+
+  /// Return a new `FunctionCallArgumentSyntax` with the given expression
+  /// argument.
+  FunctionCallArgumentSyntax withExpression(ExprSyntax NewExpression) const;
+
+  /// Get the comma ',' token immediately following this argument, if there
+  /// is one.
+  RC<TokenSyntax> getTrailingComma() const;
+
+  /// Return a new `FunctionCallArgumentSyntax` with the given comma attached
+  /// to the end of the argument.
+  FunctionCallArgumentSyntax
+  withTrailingComma(RC<TokenSyntax> NewTrailingComma) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionCallArgument;
+  }
+};
+
+#pragma mark - function-call-argument-list Data
+
+class FunctionCallArgumentListSyntaxData : public SyntaxData {
+  friend struct SyntaxFactory;
+  friend class FunctionCallArgumentListSyntax;
+  friend class FunctionCallExprSyntaxBuilder;
+  friend class SyntaxData;
+
+  std::vector<RC<FunctionCallArgumentSyntaxData>> CachedArguments;
+
+  FunctionCallArgumentListSyntaxData(const RC<RawSyntax> Raw,
+                                     const SyntaxData *Parent = nullptr,
+                                     CursorIndex IndexInParent = 0);
+
+  static RC<FunctionCallArgumentListSyntaxData>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0);
+
+  static RC<FunctionCallArgumentListSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::FunctionCallArgumentList;
+  }
+};
+
+#pragma mark - function-call-argument-list API
+
+/// function-call-argument-list -> function-call-argument
+///                                function-call-argument-list?
+class FunctionCallArgumentListSyntax : public Syntax {
+  friend struct SyntaxFactory;
+  friend class FunctionCallArgumentListSyntaxData;
+  friend class FunctionCallExprSyntax;
+  friend class Syntax;
+  friend class SyntaxData;
+
+  using DataType = FunctionCallArgumentListSyntaxData;
+
+  FunctionCallArgumentListSyntax(const RC<SyntaxData> Root,
+                                 const DataType *Data);
+
+public:
+  /// Return the number of arguments in this list.
+  size_t getNumArguments() const;
+
+  /// Get the argument at the given Index.
+  FunctionCallArgumentSyntax getArgument(size_t n) const;
+
+  /// Returns a new `FunctionCallArgumentListSyntax` with the given
+  /// argument added to the end.
+  FunctionCallArgumentListSyntax
+  withAdditionalArgument(FunctionCallArgumentSyntax AdditionalArgument) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionCallArgumentList;
+  }
+};
+
+#pragma mark - function-call-expression Data
+
+class FunctionCallExprSyntaxData : public ExprSyntaxData {
+  friend struct SyntaxFactory;
+  friend class FunctionCallExprSyntax;
+  friend class FunctionCallExprSyntaxBuilder;
+  friend class SyntaxData;
+
+  RC<ExprSyntaxData> CachedCalledExpression;
+  RC<FunctionCallArgumentListSyntaxData> CachedArgumentList;
+
+  FunctionCallExprSyntaxData(RC<RawSyntax> Raw,
+                                 const SyntaxData *Parent = nullptr,
+                                 CursorIndex IndexInParent = 0);
+
+  static RC<FunctionCallExprSyntaxData>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0);
+
+  static RC<FunctionCallExprSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::FunctionCallExpr;
+  }
+};
+
+#pragma mark - function-call-expression API
+
+class FunctionCallExprSyntax : public ExprSyntax {
+  using DataType = FunctionCallExprSyntaxData;
+  friend struct SyntaxFactory;
+  friend class FunctionCallExprSyntaxData;
+  friend class FunctionCallExprSyntaxBuilder;
+  friend class Syntax;
+  friend class SyntaxData;
+
+  enum class Cursor: CursorIndex {
+    CalledExpression,
+    LeftParen,
+    ArgumentList,
+    RightParen,
+  };
+
+  FunctionCallExprSyntax(const RC<SyntaxData> Root, const DataType *Data);
+
+public:
+
+  /// Get the base expression getting called.
+  ExprSyntax getCalledExpression() const;
+
+  /// Return a new `FunctionCallExprSyntax` with the given base expression
+  /// to be called.
+  FunctionCallExprSyntax
+  withCalledExpression(ExprSyntax NewBaseExpression) const;
+
+  /// Return the left parenthesis '(' token in this call.
+  RC<TokenSyntax> getLeftParen() const;
+
+  /// Return a new `FunctionCallExprSyntax` with the given left parenthesis '('
+  /// token.
+  FunctionCallExprSyntax withLeftParen(RC<TokenSyntax> NewLeftParen) const;
+
+  /// Get the list of arguments in this call expression.
+  FunctionCallArgumentListSyntax getArgumentList() const;
+
+  /// Return a new `FunctionCallExprSyntax` with the given argument list.
+  FunctionCallExprSyntax
+  withArgumentList(FunctionCallArgumentListSyntax NewArgumentList) const;
+
+  /// Return the right parenthesis ')' token in this call.
+  RC<TokenSyntax> getRightParen() const;
+
+  /// Return a new `FunctionCallExprSyntax` with the given right parenthesis ')'
+  /// token.
+  FunctionCallExprSyntax withRightParen(RC<TokenSyntax> NewLeftParen) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionCallExpr;
+  }
+};
+
+#pragma mark - function-call-argument-list-builder
+class FunctionCallExprSyntaxBuilder {
+  RawSyntax::LayoutList CallLayout;
+  RawSyntax::LayoutList ListLayout;
+public:
+
+  /// Start the builder with all elements marked as missing or empty.
+  FunctionCallExprSyntaxBuilder();
+
+  /// Use the given expression as the call target.
+  FunctionCallExprSyntaxBuilder &
+  useCalledExpression(ExprSyntax CalledExpression);
+
+  /// Use the given left parenthesis '(' token in the function call.
+  FunctionCallExprSyntaxBuilder &useLeftParen(RC<TokenSyntax> LeftParen);
+
+  /// Add an additional argument to the layout.
+  FunctionCallExprSyntaxBuilder &
+  appendArgument(FunctionCallArgumentSyntax AdditionalArgument);
+
+  /// Use the given right parenthesis ')' token in the function call.
+  FunctionCallExprSyntaxBuilder &useRightParen(RC<TokenSyntax> RightParen);
+
+  /// Return a `FunctionCallExprSyntax` with the arguments added so far.
+  FunctionCallExprSyntax build() const;
+};
+
 } // end namespace syntax
 } // end namespace swift
 
diff --git a/include/swift/Syntax/Format.h b/include/swift/Syntax/Format.h
index ca89034..b6cd188 100644
--- a/include/swift/Syntax/Format.h
+++ b/include/swift/Syntax/Format.h
@@ -1,4 +1,4 @@
-//===--- Format.cpp - Declaration Syntax Formatting Interface ---*- C++ -*-===//
+//===--- Format.h - Declaration Syntax Formatting Interface -----*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/include/swift/Syntax/GenericSyntax.h b/include/swift/Syntax/GenericSyntax.h
index e31eec9..753018e 100644
--- a/include/swift/Syntax/GenericSyntax.h
+++ b/include/swift/Syntax/GenericSyntax.h
@@ -1,4 +1,4 @@
-//===--- GenericSyntax.cpp - Swift Generic Syntax Interface -----*- C++ -*-===//
+//===--- GenericSyntax.h - Swift Generic Syntax Interface -------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -433,7 +433,9 @@
 class GenericArgumentClauseSyntax : public Syntax {
   friend struct SyntaxFactory;
   friend class GenericArgumentClauseBuilder;
+  friend class SymbolicReferenceExprSyntax;
   friend class SyntaxData;
+  friend class Syntax;
 
   using DataType = GenericArgumentClauseSyntaxData;
 
diff --git a/include/swift/Syntax/RawSyntax.h b/include/swift/Syntax/RawSyntax.h
index 1b58de0..40a53c3 100644
--- a/include/swift/Syntax/RawSyntax.h
+++ b/include/swift/Syntax/RawSyntax.h
@@ -235,6 +235,18 @@
     return Kind >= SyntaxKind::First_Expr && Kind <= SyntaxKind::Last_Expr;
   }
 
+  /// Return true if this raw syntax node is a token.
+  bool isToken() const {
+    return Kind == SyntaxKind::Token;
+  }
+
+  bool isUnknown() const {
+    return Kind == SyntaxKind::Unknown ||
+           Kind == SyntaxKind::UnknownDecl ||
+           Kind == SyntaxKind::UnknownExpr ||
+           Kind == SyntaxKind::UnknownStmt;
+  }
+
   /// Get the absolute position of this raw syntax: its offset, line,
   /// and column.
   AbsolutePosition getAbsolutePosition(RC<RawSyntax> Root) const;
diff --git a/include/swift/Syntax/Rewriter.h b/include/swift/Syntax/Rewriter.h
index bdebab2..224373d 100644
--- a/include/swift/Syntax/Rewriter.h
+++ b/include/swift/Syntax/Rewriter.h
@@ -27,6 +27,7 @@
 #include "swift/Syntax/ExprSyntax.h"
 #include "swift/Syntax/StmtSyntax.h"
 #include "swift/Syntax/Syntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 namespace swift {
 namespace syntax {
diff --git a/include/swift/Syntax/StmtSyntax.h b/include/swift/Syntax/StmtSyntax.h
index 523133f..d4c93a5 100644
--- a/include/swift/Syntax/StmtSyntax.h
+++ b/include/swift/Syntax/StmtSyntax.h
@@ -22,6 +22,7 @@
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/Syntax.h"
 #include "swift/Syntax/SyntaxData.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using llvm::Optional;
 
@@ -66,7 +67,7 @@
 
 #pragma mark - unknown-statement Data
 
-class UnknownStmtSyntaxData : public StmtSyntaxData {
+class UnknownStmtSyntaxData : public UnknownSyntaxData {
   UnknownStmtSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
                         CursorIndex IndexInParent = 0);
 public:
@@ -81,12 +82,12 @@
 
 #pragma mark - unknown-statement API
 
-class UnknownStmtSyntax : public StmtSyntax {
+class UnknownStmtSyntax : public UnknownSyntax {
   friend class SyntaxData;
   friend class UnknownStmtSyntaxData;
   friend class LegacyASTTransformer;
 
-  using DataType = UnknownExprSyntaxData;
+  using DataType = UnknownStmtSyntaxData;
 
   UnknownStmtSyntax(const RC<SyntaxData> Root,
                     const UnknownStmtSyntaxData *Data);
diff --git a/include/swift/Syntax/Syntax.h b/include/swift/Syntax/Syntax.h
index 3528fb2..7be6fd9 100644
--- a/include/swift/Syntax/Syntax.h
+++ b/include/swift/Syntax/Syntax.h
@@ -39,7 +39,6 @@
 const auto NoParent = llvm::None;
 
 class SyntaxData;
-class UnknownSyntaxData;
 
 /// The main handle for syntax nodes - subclasses contain all public
 /// structured editing APIs.
@@ -138,6 +137,9 @@
   /// Returns true if this syntax node represents a type.
   bool isType() const;
 
+  /// Returns true if this syntax is of some "unknown" kind.
+  bool isUnknown() const;
+
   /// Print the syntax node with full fidelity to the given output stream.
   void print(llvm::raw_ostream &OS) const;
 
@@ -155,19 +157,6 @@
   // TODO: hasSameStructureAs ?
 };
 
-/// A chunk of "unknown" syntax - effectively a sequence of tokens.
-class UnknownSyntax final : public Syntax {
-  friend struct SyntaxFactory;
-
-  UnknownSyntax(const RC<SyntaxData> Root, UnknownSyntaxData *Data);
-  static UnknownSyntax make(RC<RawSyntax> Raw);
-
-public:
-  static bool classof(const Syntax *S) {
-    return S->getKind() == SyntaxKind::Unknown;
-  }
-};
-
 } // end namespace syntax
 } // end namespace swift
 
diff --git a/include/swift/Syntax/SyntaxData.h b/include/swift/Syntax/SyntaxData.h
index c048dcc..f27e59e 100644
--- a/include/swift/Syntax/SyntaxData.h
+++ b/include/swift/Syntax/SyntaxData.h
@@ -242,28 +242,14 @@
   /// Returns true if the data node represents expression syntax.
   bool isExpr() const;
 
+  /// Returns true if this syntax is of some "unknown" kind.
+  bool isUnknown() const;
+
   /// Dump a debug description of the syntax data for debugging to
   /// standard error.
   void dump(llvm::raw_ostream &OS) const;
 };
 
-class UnknownSyntaxData final : public SyntaxData {
-  friend class SyntaxData;
-  friend class UnknownSyntax;
-  friend struct SyntaxFactory;
-  friend class LegacyASTTransformer;
-
-  UnknownSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
-                    CursorIndex IndexInParent = 0)
-    : SyntaxData(Raw, Parent, IndexInParent) {}
-
-  static RC<UnknownSyntaxData> make(RC<RawSyntax> Raw,
-                                    const SyntaxData *Parent = nullptr,
-                                    CursorIndex IndexInParent = 0);
-public:
-  static bool classof(const SyntaxData *SD);
-};
-
 } // end namespace syntax
 } // end namespace swift
 
diff --git a/include/swift/Syntax/SyntaxFactory.h b/include/swift/Syntax/SyntaxFactory.h
index 4f09467..d1d74c8 100644
--- a/include/swift/Syntax/SyntaxFactory.h
+++ b/include/swift/Syntax/SyntaxFactory.h
@@ -129,6 +129,43 @@
   /// as missing.
   static IntegerLiteralExprSyntax makeBlankIntegerLiteralExpr();
 
+  /// Make a symbolic reference with the given identifier and optionally a
+  /// generic argument clause.
+  static SymbolicReferenceExprSyntax
+  makeSymbolicReferenceExpr(RC<TokenSyntax> Identifier,
+    llvm::Optional<GenericArgumentClauseSyntax> GenericArgs);
+
+  /// Make a symbolic reference expression with the identifier and
+  /// generic argument clause marked as missing.
+  static SymbolicReferenceExprSyntax makeBlankSymbolicReferenceExpr();
+
+  /// Make a function call argument with all elements marked as missing.
+  static FunctionCallArgumentSyntax makeBlankFunctionCallArgument();
+
+  /// Make a function call argument based on an expression with the
+  /// given elements.
+  static FunctionCallArgumentSyntax
+  makeFunctionCallArgument(RC<TokenSyntax> Label, RC<TokenSyntax> Colon,
+                           ExprSyntax ExpressionArgument,
+                           RC<TokenSyntax> TrailingComma);
+
+  /// Make a function call argument list with the given arguments.
+  static FunctionCallArgumentListSyntax
+  makeFunctionCallArgumentList(
+    std::vector<FunctionCallArgumentSyntax> Arguments);
+
+  /// Make a function call argument list with no arguments.
+  static FunctionCallArgumentListSyntax makeBlankFunctionCallArgumentList();
+
+  /// Make a function call expression with the given elements.
+  static FunctionCallExprSyntax
+  makeFunctionCallExpr(ExprSyntax CalledExpr, RC<TokenSyntax> LeftParen,
+                       FunctionCallArgumentListSyntax Arguments,
+                       RC<TokenSyntax> RightParen);
+
+  /// Make a function call expression with all elements marked as missing.
+  static FunctionCallExprSyntax makeBlankFunctionCallExpr();
+
 #pragma mark - Tokens
 
   /// Make a 'fallthrough' keyword with the specified leading and
@@ -353,7 +390,7 @@
   /// Make a metatype type with all elements marked as missing.
   static MetatypeTypeSyntax makeBlankMetatypeType();
 
-  /// Make an sugared Array type, as in `[MyType]`.
+  /// Make a sugared Array type, as in `[MyType]`.
   static ArrayTypeSyntax makeArrayType(RC<TokenSyntax> LeftSquareBracket,
                                        TypeSyntax ElementType,
                                        RC<TokenSyntax> RightSquareBracket);
diff --git a/include/swift/Syntax/SyntaxKinds.def b/include/swift/Syntax/SyntaxKinds.def
index e5b0c70..941d50d 100644
--- a/include/swift/Syntax/SyntaxKinds.def
+++ b/include/swift/Syntax/SyntaxKinds.def
@@ -1,4 +1,4 @@
-//===--- SyntaxKinds.def - Swift Syntax Node Metaprogramming -------------===//
+//===--- SyntaxKinds.def - Swift Syntax Node Metaprogramming --------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -86,13 +86,18 @@
   MISSING_SYNTAX(MissingExpr, ExprSyntax)
   SYNTAX(UnknownExpr, ExprSyntax)
   SYNTAX(IntegerLiteralExpr, ExprSyntax)
-SYNTAX_RANGE(Expr, MissingExpr, IntegerLiteralExpr)
+  SYNTAX(FunctionCallExpr, ExprSyntax)
+  SYNTAX(SymbolicReferenceExpr, ExprSyntax)
+SYNTAX_RANGE(Expr, MissingExpr, SymbolicReferenceExpr)
 
+// Other stuff
 SYNTAX(BalancedTokens, Syntax)
 SYNTAX(TypeAttribute, Syntax)
 SYNTAX(TypeAttributes, Syntax)
 SYNTAX(TupleTypeElement, Syntax)
 SYNTAX(FunctionTypeArgument, Syntax)
+SYNTAX(FunctionCallArgumentList, Syntax)
+SYNTAX(FunctionCallArgument, Syntax)
 
 #undef ABSTRACT_SYNTAX
 #undef DECL
diff --git a/include/swift/Syntax/TypeSyntax.h b/include/swift/Syntax/TypeSyntax.h
index 5afb0ed..07bf362 100644
--- a/include/swift/Syntax/TypeSyntax.h
+++ b/include/swift/Syntax/TypeSyntax.h
@@ -32,8 +32,7 @@
 class GenericParameterClauseSyntax;
 class GenericParameterClauseSyntaxData;
 
-#pragma mark -
-#pragma mark balanced-tokens Data
+#pragma mark - balanced-tokens Data
 
 class BalancedTokensSyntaxData final : public SyntaxData {
   friend class SyntaxData;
@@ -52,8 +51,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark balanced-tokens API
+#pragma mark - balanced-tokens API
 
 /// balanced-tokens -> Any identifier, keyword, literal, or operator
 ///                  | Any punctuation except (, ), [, ], {, or }
@@ -77,8 +75,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-attribute Data
+#pragma mark - type-attribute Data
 
 class TypeAttributeSyntaxData final : public SyntaxData {
   friend class SyntaxData;
@@ -99,8 +96,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-attribute API
+#pragma mark - type-attribute API
 
 /// type-attribute -> '@' identifier attribute-argument-clause?
 /// attribute-argument-clause -> '(' balanced-tokens ')'
@@ -162,8 +158,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-attributes Data
+#pragma mark - type-attributes Data
 
 class TypeAttributesSyntaxData final : public SyntaxData {
   friend class SyntaxData;
@@ -183,8 +178,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-attributes API
+#pragma mark - type-attributes API
 
 /// type-attributes -> type-attribute
 ///                  | type-attribute type-attributes
@@ -208,8 +202,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-syntax Data
+#pragma mark - type-syntax Data
 
 class TypeSyntaxData : public SyntaxData {
   friend class SyntaxData;
@@ -226,8 +219,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-syntax API
+#pragma mark - type-syntax API
 
 /// type -> array-type
 ///       | dictionary-type
@@ -251,8 +243,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-identifier Data
+#pragma mark - type-identifier Data
 
 class TypeIdentifierSyntaxData final : public TypeSyntaxData {
   friend struct SyntaxFactory;
@@ -276,8 +267,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-identifier API
+#pragma mark - type-identifier API
 
 /// type-identifier -> type-name generic-argument-clause?
 ///                  | type-name generic-argument-clause '.' type-identifier
@@ -320,8 +310,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark type-argument-list Data
+#pragma mark - type-argument-list Data
 
 class TypeArgumentListSyntaxData final : public SyntaxData {
   friend class SyntaxData;
@@ -342,8 +331,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark tuple-type-element Data
+#pragma mark - tuple-type-element Data
 
 class TupleTypeElementSyntaxData final : public SyntaxData {
   friend class SyntaxData;
@@ -362,8 +350,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark tuple-type-element API
+#pragma mark - tuple-type-element API
 
 /// tuple-type-element -> (identifier ':')? type-attributes? 'inout'? type
 ///
@@ -425,8 +412,7 @@
 };
 
 
-#pragma mark -
-#pragma mark type-argument-list API
+#pragma mark - type-argument-list API
 
 /// type-argument-list
 ///   -> function-type-argument
@@ -451,8 +437,8 @@
   }
 };
 
-#pragma mark -
-#pragma mark tuple-type Data
+#pragma mark - tuple-type Data
+
 class TupleTypeSyntaxData final : public TypeSyntaxData {
   friend class SyntaxData;
   friend struct SyntaxFactory;
@@ -472,8 +458,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark tuple-type API
+#pragma mark - tuple-type API
 
 /// tuple-type -> '(' tuple-type-element-list ')'
 class TupleTypeSyntax final : public TypeSyntax {
@@ -513,8 +498,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark tuple-type Builder
+#pragma mark - tuple-type Builder
 
 /// Incrementally builds tuple type syntax.
 class TupleTypeSyntaxBuilder final {
@@ -543,8 +527,7 @@
   TupleTypeSyntax build() const;
 };
 
-#pragma mark -
-#pragma mark metatype-type Data
+#pragma mark - metatype-type Data
 
 class MetatypeTypeSyntaxData final : public TypeSyntaxData {
   friend struct SyntaxFactory;
@@ -562,8 +545,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark metatype-type API
+#pragma mark - metatype-type API
 
 /// metatype-type -> type '.' 'Type'
 ///                | type '.' 'Protocol'
@@ -605,8 +587,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark optional-type Data
+#pragma mark - optional-type Data
 
 class OptionalTypeSyntaxData final : public TypeSyntaxData {
   friend class SyntaxData;
@@ -624,8 +605,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark optional-type API
+#pragma mark - optional-type API
 
 /// optional-type -> type '?'
 class OptionalTypeSyntax final : public TypeSyntax {
@@ -661,8 +641,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark implicitly-unwrapped-optional-type Data
+#pragma mark - implicitly-unwrapped-optional-type Data
 
 class ImplicitlyUnwrappedOptionalTypeSyntaxData final : public TypeSyntaxData {
   friend struct SyntaxFactory;
@@ -682,8 +661,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark implicitly-unwrapped-optional-type API
+#pragma mark - implicitly-unwrapped-optional-type API
 
 /// implicitly-unwrapped-optional-type -> type '!'
 class ImplicitlyUnwrappedOptionalTypeSyntax final : public TypeSyntax {
@@ -722,8 +700,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark array-type Data
+#pragma mark - array-type Data
 
 class ArrayTypeSyntaxData final : public TypeSyntaxData {
   friend class SyntaxData;
@@ -744,8 +721,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark array-type API
+#pragma mark - array-type API
 
 // array-type -> '[' type ']'
 class ArrayTypeSyntax final : public TypeSyntax {
@@ -788,8 +764,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark dictionary-type Data
+#pragma mark - dictionary-type Data
 
 class DictionaryTypeSyntaxData final : public TypeSyntaxData {
   friend class SyntaxData;
@@ -813,8 +788,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark dictionary-type API
+#pragma mark - dictionary-type API
 
 // dictionary-type -> '[' type ':' type ']'
 class DictionaryTypeSyntax final : public TypeSyntax {
@@ -875,8 +849,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark function-type-argument Data
+#pragma mark - function-type-argument Data
 
 class FunctionTypeArgumentSyntaxData final : public SyntaxData {
   friend class SyntaxData;
@@ -897,8 +870,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark function-type-argument API
+#pragma mark - function-type-argument API
 
 class FunctionTypeArgumentSyntax final : public Syntax {
   friend struct SyntaxFactory;
@@ -925,8 +897,7 @@
 };
 
 
-#pragma mark -
-#pragma mark function-type Data
+#pragma mark - function-type Data
 
 class FunctionTypeSyntaxData final : public TypeSyntaxData {
   friend class SyntaxData;
@@ -947,8 +918,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark function-type API
+#pragma mark - function-type API
 
 /// function-type ->
 ///   type-attributes? function-type-argument-clause 'throws'? '->' type
@@ -1045,8 +1015,7 @@
   }
 };
 
-#pragma mark -
-#pragma mark function-type Builder
+#pragma mark - function-type Builder
 
 /// Incrementally builds function type syntax.
 class FunctionTypeSyntaxBuilder final {
diff --git a/include/swift/Syntax/UnknownSyntax.h b/include/swift/Syntax/UnknownSyntax.h
new file mode 100644
index 0000000..7158e03
--- /dev/null
+++ b/include/swift/Syntax/UnknownSyntax.h
@@ -0,0 +1,89 @@
+//===--- UnknownSyntax.h - Swift Unknown Syntax Interface -----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SYNTAX_UNKNOWNSYNTAX_H
+#define SWIFT_SYNTAX_UNKNOWNSYNTAX_H
+
+#include "swift/Syntax/SyntaxData.h"
+#include "swift/Syntax/Syntax.h"
+
+#include <vector>
+
+namespace swift {
+namespace syntax {
+
+#pragma mark unknown-syntax Data
+
+class UnknownSyntaxData : public SyntaxData {
+  friend class SyntaxData;
+  friend class UnknownSyntax;
+  friend struct SyntaxFactory;
+  friend class LegacyASTTransformer;
+
+protected:
+  std::vector<RC<SyntaxData>> CachedChildren;
+
+  UnknownSyntaxData(const RC<RawSyntax> Raw,
+                    const SyntaxData *Parent = nullptr,
+                    const CursorIndex IndexInParent = 0);
+public:
+
+  static RC<UnknownSyntaxData> make(RC<RawSyntax> Raw,
+                                    const SyntaxData *Parent = nullptr,
+                                    CursorIndex IndexInParent = 0);
+
+  size_t getNumChildren() const {
+    return CachedChildren.size();
+  }
+
+  /// Get the child at the given Index.
+  ///
+  /// Precondition: Index <= getNumChildren();
+  Syntax getChild(size_t Index) const;
+
+  static bool classof(const SyntaxData *SD) {
+    return SD->isUnknown();
+  }
+};
+
+#pragma mark unknown-syntax API
+
+/// A chunk of "unknown" syntax.
+///
+/// Effectively wraps a tree of RawSyntax.
+///
+/// This should not be vended by SyntaxFactory.
+class UnknownSyntax : public Syntax {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+
+  using DataType = UnknownSyntaxData;
+
+public:
+  UnknownSyntax(const RC<SyntaxData> Root, const UnknownSyntaxData *Data);
+
+  /// Get the number of child nodes in this piece of syntax, not including
+  /// tokens.
+  size_t getNumChildren() const;
+
+  /// Get the Nth child of this piece of syntax.
+  Syntax getChild(const size_t N) const;
+
+  static bool classof(const Syntax *S) {
+    return S->isUnknown();
+  }
+};
+
+} // end namespace syntax
+} // end namespace swift
+
+#endif // SWIFT_SYNTAX_UNKNOWNSYNTAX_H
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
index 0f7e463..7be8ea7 100644
--- a/lib/AST/ASTDumper.cpp
+++ b/lib/AST/ASTDumper.cpp
@@ -365,11 +365,11 @@
 //===----------------------------------------------------------------------===//
 
 // Print a name.
-static void printName(raw_ostream &os, Identifier name) {
-  if (name.empty())
+static void printName(raw_ostream &os, DeclName name) {
+  if (!name)
     os << "<anonymous>";
   else
-    os << name.str();
+    os << name;
 }
 
 namespace {
@@ -1004,7 +1004,7 @@
           OS << "#else:\n";
         }
 
-        for (auto D : Clause.Members) {
+        for (auto D : Clause.Elements) {
           OS << '\n';
           printRec(D);
         }
@@ -1148,7 +1148,7 @@
         break;
       }
     }
-    os << "extension";
+    os << " extension";
     break;
 
   case DeclContextKind::Initializer:
@@ -1166,18 +1166,12 @@
     os << "top-level code";
     break;
 
-  case DeclContextKind::AbstractFunctionDecl: {
-    auto *AFD = cast<AbstractFunctionDecl>(dc);
-    if (isa<FuncDecl>(AFD))
-      os << "func decl";
-    if (isa<ConstructorDecl>(AFD))
-      os << "init";
-    if (isa<DestructorDecl>(AFD))
-      os << "deinit";
+  case DeclContextKind::AbstractFunctionDecl:
+    printName(os, cast<AbstractFunctionDecl>(dc)->getFullName());
     break;
-  }
+
   case DeclContextKind::SubscriptDecl:
-    os << "subscript decl";
+    printName(os, cast<SubscriptDecl>(dc)->getFullName());
     break;
   }
 }
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index b6eeb2b..c57b4cf 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -622,6 +622,20 @@
   if (auto genericSig = GenericSigOrEnv.dyn_cast<GenericSignature *>())
     return genericSig;
 
+  // The signature of a Protocol is trivial (Self: TheProtocol) so let's compute
+  // it.
+  if (auto PD = dyn_cast<ProtocolDecl>(this)) {
+    auto self = PD->getSelfInterfaceType()->castTo<GenericTypeParamType>();
+    auto req =
+        Requirement(RequirementKind::Conformance, self, PD->getDeclaredType());
+    GenericTypeParamType *params[] = {self};
+    Requirement reqs[] = {req};
+
+    auto &ctx = getASTContext();
+    return GenericSignature::get(ctx.AllocateCopy(params),
+                                 ctx.AllocateCopy(reqs));
+  }
+
   return nullptr;
 }
 
@@ -808,7 +822,6 @@
     ExtendedType(extendedType),
     Inherited(inherited)
 {
-  ExtensionDeclBits.Validated = false;
   ExtensionDeclBits.CheckedInheritanceClause = false;
   ExtensionDeclBits.DefaultAndMaxAccessLevel = 0;
   ExtensionDeclBits.HasLazyConformances = false;
@@ -2006,7 +2019,7 @@
         selfTy, const_cast<AssociatedTypeDecl *>(ATD));
   }
 
-  Type interfaceType = getInterfaceType();
+  Type interfaceType = hasInterfaceType() ? getInterfaceType() : nullptr;
   if (interfaceType.isNull() || interfaceType->is<ErrorType>())
     return interfaceType;
 
@@ -2261,10 +2274,7 @@
                              Identifier Name, SourceLoc NameLoc,
                              GenericParamList *GenericParams, DeclContext *DC)
   : GenericTypeDecl(DeclKind::TypeAlias, DC, Name, NameLoc, {}, GenericParams),
-    TypeAliasLoc(TypeAliasLoc),
-    EqualLoc(EqualLoc) {
-  TypeAliasDeclBits.HasCompletedValidation = false;
-}
+    TypeAliasLoc(TypeAliasLoc), EqualLoc(EqualLoc) {}
 
 SourceRange TypeAliasDecl::getSourceRange() const {
   if (UnderlyingTy.hasLocation())
@@ -2273,7 +2283,7 @@
 }
 
 void TypeAliasDecl::setUnderlyingType(Type underlying) {
-  setHasCompletedValidation();
+  setValidationStarted();
 
   // lldb creates global typealiases containing archetypes
   // sometimes...
@@ -2342,19 +2352,20 @@
 
 AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
                                        Identifier name, SourceLoc nameLoc,
-                                       TypeLoc defaultDefinition)
-  : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
-    KeywordLoc(keywordLoc), DefaultDefinition(defaultDefinition)
-{ }
+                                       TypeLoc defaultDefinition,
+                                       TrailingWhereClause *trailingWhere)
+    : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
+      KeywordLoc(keywordLoc), DefaultDefinition(defaultDefinition),
+      TrailingWhere(trailingWhere) {}
 
 AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
                                        Identifier name, SourceLoc nameLoc,
+                                       TrailingWhereClause *trailingWhere,
                                        LazyMemberLoader *definitionResolver,
                                        uint64_t resolverData)
-  : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
-    KeywordLoc(keywordLoc), Resolver(definitionResolver),
-    ResolverContextData(resolverData)
-{
+    : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
+      KeywordLoc(keywordLoc), TrailingWhere(trailingWhere),
+      Resolver(definitionResolver), ResolverContextData(resolverData) {
   assert(Resolver && "missing resolver");
 }
 
@@ -2725,6 +2736,41 @@
   return result;
 }
 
+bool ProtocolDecl::walkInheritedProtocols(
+              llvm::function_ref<TypeWalker::Action(ProtocolDecl *)> fn) const {
+  auto self = const_cast<ProtocolDecl *>(this);
+
+  // Visit all of the inherited protocols.
+  SmallPtrSet<ProtocolDecl *, 8> visited;
+  SmallVector<ProtocolDecl *, 4> stack;
+  stack.push_back(self);
+  visited.insert(self);
+  while (!stack.empty()) {
+    // Pull the next protocol off the stack.
+    auto proto = stack.back();
+    stack.pop_back();
+
+    switch (fn(proto)) {
+    case TypeWalker::Action::Stop:
+      return true;
+
+    case TypeWalker::Action::Continue:
+      // Add inherited protocols to the stack.
+      for (auto inherited : proto->getInheritedProtocols()) {
+        if (visited.insert(inherited).second)
+          stack.push_back(inherited);
+      }
+      break;
+
+    case TypeWalker::Action::SkipChildren:
+      break;
+    }
+  }
+
+  return false;
+
+}
+
 bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
   if (this == super)
     return false;
@@ -2735,26 +2781,27 @@
 }
 
 bool ProtocolDecl::requiresClassSlow() {
-  if (!isRequirementSignatureComputed()) return false;
+  ProtocolDeclBits.RequiresClass =
+    walkInheritedProtocols([&](ProtocolDecl *proto) {
+      // If the 'requires class' bit is valid, we don't need to search any
+      // further.
+      if (proto->ProtocolDeclBits.RequiresClassValid) {
+        // If this protocol has a class requirement, we're done.
+        if (proto->ProtocolDeclBits.RequiresClass)
+          return TypeWalker::Action::Stop;
 
-  ProtocolDeclBits.RequiresClass = false;
+        return TypeWalker::Action::SkipChildren;
+      }
 
-  // Ensure that the result cannot change in future.
+      // Quick check: @objc indicates that it requires a class.
+      if (proto->getAttrs().hasAttribute<ObjCAttr>() || proto->isObjC())
+        return TypeWalker::Action::Stop;
 
-  if (getAttrs().hasAttribute<ObjCAttr>() || isObjC()) {
-    ProtocolDeclBits.RequiresClass = true;
-    return true;
-  }
+      // Keep looking.
+      return TypeWalker::Action::Continue;
+    });
 
-  // Check inherited protocols for class-ness.
-  for (auto *proto : getInheritedProtocols()) {
-    if (proto->requiresClass()) {
-      ProtocolDeclBits.RequiresClass = true;
-      return true;
-    }
-  }
-
-  return false;
+  return ProtocolDeclBits.RequiresClass;
 }
 
 bool ProtocolDecl::existentialConformsToSelfSlow() {
@@ -2787,7 +2834,6 @@
 
   // Check whether any of the inherited protocols fail to conform to
   // themselves.
-  // FIXME: does this need a resolver?
   for (auto proto : getInheritedProtocols()) {
     if (!proto->existentialConformsToSelf()) {
       ProtocolDeclBits.ExistentialConformsToSelf = false;
@@ -3058,9 +3104,10 @@
   GenericSignatureBuilder builder(getASTContext(),
                                   LookUpConformanceInModule(module));
   builder.addGenericParameter(selfType);
-  builder.addRequirement(requirement,
-                         RequirementSource::forRequirementSignature(builder,
-                                                                    this));
+  builder.addRequirement(
+         requirement,
+         GenericSignatureBuilder::RequirementSource
+          ::forRequirementSignature(builder.resolveArchetype(selfType), this));
   builder.finalize(SourceLoc(), { selfType });
   
   RequirementSignature = builder.getGenericSignature();
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
index 0a3bebe..56747a6 100644
--- a/lib/AST/GenericSignature.cpp
+++ b/lib/AST/GenericSignature.cpp
@@ -79,7 +79,7 @@
 }
 
 std::string GenericSignature::gatherGenericParamBindingsText(
-    ArrayRef<Type> types, const TypeSubstitutionMap &substitutions) const {
+    ArrayRef<Type> types, TypeSubstitutionFn substitutions) const {
   llvm::SmallPtrSet<GenericTypeParamType *, 2> knownGenericParams;
   for (auto type : types) {
     type.visit([&](Type type) {
@@ -106,11 +106,11 @@
     result += gp->getName().str();
     result += " = ";
 
-    auto found = substitutions.find(canonGP);
-    if (found == substitutions.end())
+    auto type = substitutions(canonGP);
+    if (!type)
       return "";
 
-    result += found->second.getString();
+    result += type.getString();
   }
 
   result += "]";
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
index c039407..b3f69c4 100644
--- a/lib/AST/GenericSignatureBuilder.cpp
+++ b/lib/AST/GenericSignatureBuilder.cpp
@@ -39,7 +39,11 @@
 using llvm::DenseMap;
 
 namespace {
+  typedef GenericSignatureBuilder::RequirementSource RequirementSource;
+  typedef GenericSignatureBuilder::FloatingRequirementSource
+    FloatingRequirementSource;
   typedef GenericSignatureBuilder::PotentialArchetype PotentialArchetype;
+  typedef GenericSignatureBuilder::ConcreteConstraint ConcreteConstraint;
   typedef GenericSignatureBuilder::EquivalenceClass EquivalenceClass;
 
 } // end anonymous namespace
@@ -78,38 +82,53 @@
   switch (kind) {
   case Explicit:
     switch (storageKind) {
-    case StorageKind::None:
+    case StorageKind::RootArchetype:
     case StorageKind::TypeRepr:
     case StorageKind::RequirementRepr:
       return true;
 
     case StorageKind::ProtocolDecl:
     case StorageKind::ProtocolConformance:
+    case StorageKind::AssociatedTypeDecl:
       return false;
     }
 
   case Inferred:
     switch (storageKind) {
-    case StorageKind::None:
+    case StorageKind::RootArchetype:
     case StorageKind::TypeRepr:
       return true;
 
     case StorageKind::ProtocolDecl:
     case StorageKind::ProtocolConformance:
     case StorageKind::RequirementRepr:
+    case StorageKind::AssociatedTypeDecl:
       return false;
     }
 
   case NestedTypeNameMatch:
-  case Parent:
     switch (storageKind) {
-    case StorageKind::None:
+    case StorageKind::RootArchetype:
         return true;
 
     case StorageKind::TypeRepr:
     case StorageKind::ProtocolDecl:
     case StorageKind::ProtocolConformance:
     case StorageKind::RequirementRepr:
+    case StorageKind::AssociatedTypeDecl:
+      return false;
+    }
+
+  case Parent:
+    switch (storageKind) {
+    case StorageKind::AssociatedTypeDecl:
+        return true;
+
+    case StorageKind::RootArchetype:
+    case StorageKind::TypeRepr:
+    case StorageKind::ProtocolDecl:
+    case StorageKind::ProtocolConformance:
+    case StorageKind::RequirementRepr:
       return false;
     }
 
@@ -119,10 +138,11 @@
     case StorageKind::ProtocolDecl:
       return true;
 
-    case StorageKind::None:
+    case StorageKind::RootArchetype:
     case StorageKind::TypeRepr:
     case StorageKind::ProtocolConformance:
     case StorageKind::RequirementRepr:
+    case StorageKind::AssociatedTypeDecl:
       return false;
     }
 
@@ -132,10 +152,11 @@
     case StorageKind::ProtocolConformance:
       return true;
 
-    case StorageKind::None:
+    case StorageKind::RootArchetype:
     case StorageKind::ProtocolDecl:
     case StorageKind::TypeRepr:
     case StorageKind::RequirementRepr:
+    case StorageKind::AssociatedTypeDecl:
       return false;
     }
   }
@@ -143,9 +164,8 @@
 
 const void *RequirementSource::getOpaqueStorage() const {
   switch (storageKind) {
-  case StorageKind::None:
-    // Note: always null.
-    return storage.typeRepr;
+  case StorageKind::RootArchetype:
+    return storage.rootArchetype;
 
   case StorageKind::TypeRepr:
     return storage.typeRepr;
@@ -158,9 +178,19 @@
 
   case StorageKind::ProtocolDecl:
     return storage.protocol;
+
+  case StorageKind::AssociatedTypeDecl:
+    return storage.assocType;
   }
 }
 
+const void *RequirementSource::getExtraOpaqueStorage() const {
+  if (numTrailingObjects(OverloadToken<PotentialArchetype *>()) == 1)
+    return getTrailingObjects<PotentialArchetype *>()[0];
+
+  return nullptr;
+}
+
 bool RequirementSource::isDerivedRequirement() const {
   switch (kind) {
   case Explicit:
@@ -204,23 +234,60 @@
   return false;
 }
 
-#define REQUIREMENT_SOURCE_FACTORY_BODY(SourceKind, Parent, Storage)       \
-  llvm::FoldingSetNodeID nodeID;                                           \
-  Profile(nodeID, Kind::SourceKind, Parent, Storage);                      \
-                                                                           \
-  void *insertPos = nullptr;                                               \
-  if (auto known =                                                         \
-        builder.Impl->RequirementSources.FindNodeOrInsertPos(nodeID,       \
-                                                            insertPos))    \
-    return known;                                                          \
-                                                                           \
-  auto result = new RequirementSource(Kind::SourceKind, Parent, Storage);  \
-  builder.Impl->RequirementSources.InsertNode(result, insertPos);          \
-  return result
+bool RequirementSource::isSelfDerivedSource(PotentialArchetype *pa) const {
+  // If it's not a derived requirement, it's not self-derived.
+  if (!isDerivedRequirement()) return false;
 
-#define REQUIREMENT_SOURCE_FACTORY_BODY_NOSTORAGE(SourceKind, Parent)      \
+  // Collect the path of associated types from the root pa.
+  SmallVector<AssociatedTypeDecl *, 4> assocTypes;
+  PotentialArchetype *currentPA = nullptr;
+  for (auto source = this; source; source = source->parent) {
+    switch (source->kind) {
+    case RequirementSource::Parent:
+      assocTypes.push_back(source->getAssociatedType());
+      break;
+
+    case RequirementSource::NestedTypeNameMatch:
+      return false;
+
+    case RequirementSource::Explicit:
+    case RequirementSource::Inferred:
+    case RequirementSource::RequirementSignatureSelf:
+      currentPA = source->getRootPotentialArchetype();
+      break;
+
+    case RequirementSource::Concrete:
+    case RequirementSource::ProtocolRequirement:
+    case RequirementSource::Superclass:
+      break;
+    }
+  }
+
+  assert(currentPA && "Missing root potential archetype");
+
+  // Check whether anything of the potential archetypes in the path are
+  // equivalent to the end of the path.
+  auto rep = pa->getRepresentative();
+  for (auto assocType : reversed(assocTypes)) {
+    // Check whether this potential archetype is in the same equivalence class.
+    if (currentPA->getRepresentative() == rep) return true;
+
+    // Get the next nested type, but only if we've seen it before.
+    // FIXME: Feels hacky.
+    auto knownNested = currentPA->NestedTypes.find(assocType->getName());
+    if (knownNested == currentPA->NestedTypes.end()) return false;
+    currentPA = knownNested->second.front();
+  }
+
+  // FIXME: currentPA == pa?
+  return false;
+}
+
+#define REQUIREMENT_SOURCE_FACTORY_BODY(                                   \
+          SourceKind, Parent, Storage, ExtraStorage,                       \
+          NumPotentialArchetypes)                                          \
   llvm::FoldingSetNodeID nodeID;                                           \
-  Profile(nodeID, Kind::SourceKind, Parent, nullptr);                      \
+  Profile(nodeID, Kind::SourceKind, Parent, Storage, ExtraStorage);        \
                                                                            \
   void *insertPos = nullptr;                                               \
   if (auto known =                                                         \
@@ -228,73 +295,113 @@
                                                             insertPos))    \
     return known;                                                          \
                                                                            \
-  auto result = new RequirementSource(Kind::SourceKind, Parent);           \
+  unsigned size =                                                          \
+    totalSizeToAlloc<PotentialArchetype *>(NumPotentialArchetypes);        \
+  void *mem = malloc(size);                                                \
+  auto result = new (mem) RequirementSource(Kind::SourceKind, Parent,      \
+                                            Storage);                      \
+  if (NumPotentialArchetypes > 0)                                          \
+    result->getTrailingObjects<PotentialArchetype *>()[0] = ExtraStorage;  \
   builder.Impl->RequirementSources.InsertNode(result, insertPos);          \
   return result
 
 const RequirementSource *RequirementSource::forAbstract(
-                                             GenericSignatureBuilder &builder) {
-  REQUIREMENT_SOURCE_FACTORY_BODY_NOSTORAGE(Explicit, nullptr);
+                                                    PotentialArchetype *root) {
+  auto &builder = *root->getBuilder();
+  REQUIREMENT_SOURCE_FACTORY_BODY(Explicit, nullptr, root, nullptr, 0);
 }
 
 const RequirementSource *RequirementSource::forExplicit(
-                                             GenericSignatureBuilder &builder,
+                                             PotentialArchetype *root,
                                              const TypeRepr *typeRepr) {
-  REQUIREMENT_SOURCE_FACTORY_BODY(Explicit, nullptr, typeRepr);
+  // If the type representation is NULL, we have an abstract requirement
+  // source.
+  if (!typeRepr)
+    return forAbstract(root);
+
+  auto &builder = *root->getBuilder();
+  REQUIREMENT_SOURCE_FACTORY_BODY(Explicit, nullptr, typeRepr, root, 1);
 }
 
 const RequirementSource *RequirementSource::forExplicit(
-                                      GenericSignatureBuilder &builder,
+                                      PotentialArchetype *root,
                                       const RequirementRepr *requirementRepr) {
-  REQUIREMENT_SOURCE_FACTORY_BODY(Explicit, nullptr, requirementRepr);
+  // If the requirement representation is NULL, we have an abstract requirement
+  // source.
+  if (!requirementRepr)
+    return forAbstract(root);
+
+  auto &builder = *root->getBuilder();
+  REQUIREMENT_SOURCE_FACTORY_BODY(Explicit, nullptr, requirementRepr, root, 1);
 }
 
 const RequirementSource *RequirementSource::forInferred(
-                                              GenericSignatureBuilder &builder,
+                                              PotentialArchetype *root,
                                               const TypeRepr *typeRepr) {
-  REQUIREMENT_SOURCE_FACTORY_BODY(Inferred, nullptr, typeRepr);
+  auto &builder = *root->getBuilder();
+  REQUIREMENT_SOURCE_FACTORY_BODY(Inferred, nullptr, typeRepr, root, 1);
 }
 
 const RequirementSource *RequirementSource::forRequirementSignature(
-                                              GenericSignatureBuilder &builder,
+                                              PotentialArchetype *root,
                                               ProtocolDecl *protocol) {
-  REQUIREMENT_SOURCE_FACTORY_BODY(RequirementSignatureSelf, nullptr, protocol);
+  auto &builder = *root->getBuilder();
+  REQUIREMENT_SOURCE_FACTORY_BODY(RequirementSignatureSelf, nullptr, protocol,
+                                  root, 1);
 }
 
 const RequirementSource *RequirementSource::forNestedTypeNameMatch(
-                                             GenericSignatureBuilder &builder) {
-  REQUIREMENT_SOURCE_FACTORY_BODY_NOSTORAGE(NestedTypeNameMatch, nullptr);
+                                             PotentialArchetype *root) {
+  auto &builder = *root->getBuilder();
+  REQUIREMENT_SOURCE_FACTORY_BODY(NestedTypeNameMatch, nullptr, root, nullptr,
+                                  0);
 }
 
 const RequirementSource *RequirementSource::viaAbstractProtocolRequirement(
                                                GenericSignatureBuilder &builder,
                                                ProtocolDecl *protocol) const {
-  REQUIREMENT_SOURCE_FACTORY_BODY(ProtocolRequirement, this, protocol);
+  REQUIREMENT_SOURCE_FACTORY_BODY(ProtocolRequirement, this, protocol,
+                                  nullptr, 0);
 }
 
 const RequirementSource *RequirementSource::viaSuperclass(
                                       GenericSignatureBuilder &builder,
                                       ProtocolConformance *conformance) const {
-  REQUIREMENT_SOURCE_FACTORY_BODY(Superclass, this, conformance);
+  REQUIREMENT_SOURCE_FACTORY_BODY(Superclass, this, conformance, nullptr, 0);
 }
 
 const RequirementSource *RequirementSource::viaConcrete(
                                       GenericSignatureBuilder &builder,
                                       ProtocolConformance *conformance) const {
-  REQUIREMENT_SOURCE_FACTORY_BODY(Concrete, this, conformance);
+  REQUIREMENT_SOURCE_FACTORY_BODY(Concrete, this, conformance, nullptr, 0);
 }
 
 const RequirementSource *RequirementSource::viaParent(
-                                      GenericSignatureBuilder &builder) const {
-  REQUIREMENT_SOURCE_FACTORY_BODY_NOSTORAGE(Parent, this);
+                                      GenericSignatureBuilder &builder,
+                                      AssociatedTypeDecl *assocType) const {
+  REQUIREMENT_SOURCE_FACTORY_BODY(Parent, this, assocType, nullptr, 0);
 }
 
-#undef REQUIREMENT_SOURCE_FACTORY_BODY_NOSTORAGE
 #undef REQUIREMENT_SOURCE_FACTORY_BODY
 
+PotentialArchetype *RequirementSource::getRootPotentialArchetype() const {
+  /// Find the root.
+  auto root = this;
+  while (auto parent = root->parent)
+    root = parent;
+
+  // If the root archetype is in extra storage, grab it from there.
+  if (root->numTrailingObjects(OverloadToken<PotentialArchetype *>()) == 1)
+    return root->getTrailingObjects<PotentialArchetype *>()[0];
+
+  // Otherwise, it's in inline storage.
+  assert(storageKind == StorageKind::RootArchetype);
+  return storage.rootArchetype;
+}
+
 ProtocolDecl *RequirementSource::getProtocolDecl() const {
   switch (storageKind) {
-  case StorageKind::None:
+  case StorageKind::RootArchetype:
   case StorageKind::TypeRepr:
   case StorageKind::RequirementRepr:
     return nullptr;
@@ -307,6 +414,9 @@
       return storage.conformance->getProtocol();
 
     return nullptr;
+
+  case StorageKind::AssociatedTypeDecl:
+    return storage.assocType->getProtocol();
   }
 }
 
@@ -365,6 +475,9 @@
   if (parent) {
     parent->print(out, srcMgr);
     out << " -> ";
+  } else {
+    auto pa = getRootPotentialArchetype();
+    out << pa->getDebugName() << ": ";
   }
 
   switch (kind) {
@@ -413,7 +526,7 @@
   };
 
   switch (storageKind) {
-  case StorageKind::None:
+  case StorageKind::RootArchetype:
     break;
 
   case StorageKind::TypeRepr:
@@ -432,9 +545,53 @@
           << storage.conformance->getProtocol()->getName() << ")";
     }
     break;
+
+  case StorageKind::AssociatedTypeDecl:
+    out << " (" << storage.assocType->getProtocol()->getName()
+        << "::" << storage.assocType->getName() << ")";
+    break;
   }
 }
 
+const RequirementSource *FloatingRequirementSource::getSource(
+                                                PotentialArchetype *pa) const {
+  switch (kind) {
+  case Resolved:
+      return storage.get<const RequirementSource *>();
+
+  case Explicit:
+    if (auto requirementRepr = storage.dyn_cast<const RequirementRepr *>())
+      return RequirementSource::forExplicit(pa, requirementRepr);
+    if (auto typeRepr = storage.dyn_cast<const TypeRepr *>())
+      return RequirementSource::forExplicit(pa, typeRepr);
+    return RequirementSource::forAbstract(pa);
+
+  case Inferred:
+    return RequirementSource::forInferred(pa, storage.get<const TypeRepr *>());
+  }
+}
+
+SourceLoc FloatingRequirementSource::getLoc() const {
+  if (auto source = storage.dyn_cast<const RequirementSource *>())
+    return source->getLoc();
+
+  if (auto typeRepr = storage.dyn_cast<const TypeRepr *>())
+    return typeRepr->getLoc();
+
+  if (auto requirementRepr = storage.dyn_cast<const RequirementRepr *>()) {
+    switch (requirementRepr->getKind()) {
+    case RequirementReprKind::LayoutConstraint:
+    case RequirementReprKind::TypeConstraint:
+      return requirementRepr->getColonLoc();
+
+    case RequirementReprKind::SameType:
+      return requirementRepr->getEqualLoc();
+    }
+  }
+
+  return SourceLoc();
+}
+
 GenericSignatureBuilder::PotentialArchetype::~PotentialArchetype() {
   for (const auto &nested : NestedTypes) {
     for (auto pa : nested.second) {
@@ -501,38 +658,44 @@
   --builder.Impl->NumUnresolvedNestedTypes;
 }
 
-Optional<std::pair<Type, const RequirementSource *>>
-PotentialArchetype::findAnyConcreteTypeSourceAsWritten() const {
-  using Result = std::pair<Type, const RequirementSource *>;
-
-  // Local function to look for a source in the given potential archetype.
-  auto lookInPA = [](const PotentialArchetype *pa) -> Optional<Result> {
-    for (unsigned i : indices(pa->concreteTypeSources)) {
-      auto source = pa->concreteTypeSources[i];
-      if (source->getLoc().isValid())
-        return Result(pa->concreteTypes[i], source);
-    }
-
-    return None;
-  };
-
-  // If we have a concrete type source with location information, use that.
-  if (auto result = lookInPA(this))
-    return result;
-
+Optional<ConcreteConstraint>
+EquivalenceClass::findAnyConcreteConstraintAsWritten(
+                                      PotentialArchetype *preferredPA) const {
   // If we don't have a concrete type, there's no source.
-  auto rep = getRepresentative();
-  if (!rep->isConcreteType()) return None;
+  if (!concreteType) return None;
 
-  // Otherwise, go look for the source.
-  for (auto pa : rep->getEquivalenceClassMembers()) {
-    if (pa != this) {
-      if (auto result = lookInPA(pa))
+  // Go look for a source with source-location information.
+  Optional<ConcreteConstraint> result;
+  for (const auto &constraint : concreteTypeConstraints) {
+    if (constraint.source->getLoc().isValid()) {
+      result = constraint;
+      if (!preferredPA || constraint.archetype == preferredPA)
         return result;
     }
   }
 
-  return None;
+  return result;
+}
+
+Optional<ConcreteConstraint>
+EquivalenceClass::findAnySuperclassConstraintAsWritten(
+                                      PotentialArchetype *preferredPA) const {
+  // If we don't have a superclass, there's no source.
+  if (!superclass) return None;
+
+  // Go look for a source with source-location information.
+  Optional<ConcreteConstraint> result;
+  for (const auto &constraint : superclassConstraints) {
+    if (constraint.source->getLoc().isValid() &&
+        constraint.concreteType->isEqual(superclass)) {
+      result = constraint;
+
+      if (!preferredPA || constraint.archetype == preferredPA)
+        return result;
+    }
+  }
+
+  return result;
 }
 
 bool GenericSignatureBuilder::updateRequirementSource(
@@ -570,8 +733,16 @@
 
   // Conformance to this protocol is redundant; update the requirement source
   // appropriately.
-  auto superclassSource =
-    pa->getSuperclassSource()->viaSuperclass(*this, conformance->getConcrete());
+  auto paEquivClass = pa->getOrCreateEquivalenceClass();
+  const RequirementSource *superclassSource;
+  if (auto writtenSource =
+        paEquivClass->findAnySuperclassConstraintAsWritten(pa))
+    superclassSource = writtenSource->source;
+  else
+    superclassSource = paEquivClass->superclassConstraints.front().source;
+
+  superclassSource =
+    superclassSource->viaSuperclass(*this, conformance->getConcrete());
   updateRequirementSource(protoSource, superclassSource);
   return superclassSource;
 }
@@ -603,7 +774,6 @@
 
   static ResolvedType forNewTypeAlias(PotentialArchetype *pa) {
     assert(pa->getParent() && pa->getTypeAliasDecl() &&
-           pa->concreteTypes.empty() &&
            pa->getEquivalenceClassMembers().size() == 1 &&
            "not a new typealias");
     return ResolvedType(pa);
@@ -635,7 +805,7 @@
   if (!concreteType) return;
 
   // Add the same-type constraint.
-  auto nestedSource = superSource->viaParent(builder);
+  auto nestedSource = superSource->viaParent(builder, assocType);
   concreteType = superConformance->getDeclContext()
       ->mapTypeOutOfContext(concreteType);
 
@@ -709,7 +879,8 @@
     // and make it equivalent to the first potential archetype we encountered.
     auto otherPA = new PotentialArchetype(this, assocType);
     known->second.push_back(otherPA);
-    auto sameNamedSource = RequirementSource::forNestedTypeNameMatch(builder);
+    auto sameNamedSource = RequirementSource::forNestedTypeNameMatch(
+                                                        known->second.front());
     builder.addSameTypeRequirement(known->second.front(), otherPA,
                                    sameNamedSource);
 
@@ -921,11 +1092,12 @@
 
   // These requirements are all implied based on the parent's concrete
   // conformance.
-  auto source = parentConcreteSource->viaConcrete(builder, /*FIXME: */nullptr)
-    ->viaParent(builder);
   auto assocType = nestedPA->getResolvedAssociatedType();
   if (!assocType) return;
 
+  auto source = parentConcreteSource->viaConcrete(builder, /*FIXME: */nullptr)
+    ->viaParent(builder, assocType);
+
   // FIXME: Get the conformance from the parent.
   auto conformance = lookupConformance(assocType->getProtocol());
 
@@ -964,9 +1136,6 @@
   if (rep != this)
     repNested = rep->getNestedType(nestedName, builder);
 
-  auto sameNestedTypeSource =
-    RequirementSource::forNestedTypeNameMatch(builder);
-
   // Attempt to resolve this nested type to an associated type
   // of one of the protocols to which the parent potential
   // archetype conforms.
@@ -1032,9 +1201,11 @@
           ProtocolConformanceRef(proto));
         type = type.subst(subMap, SubstFlags::UseErrorType);
 
-        builder.addSameTypeRequirement(ResolvedType::forNewTypeAlias(pa),
-                                       builder.resolve(type),
-                                       sameNestedTypeSource, diagnoseMismatch);
+        builder.addSameTypeRequirement(
+                                 ResolvedType::forNewTypeAlias(pa),
+                                 builder.resolve(type),
+                                 RequirementSource::forNestedTypeNameMatch(pa),
+                                 diagnoseMismatch);
       } else
         continue;
 
@@ -1047,14 +1218,18 @@
 
         // Produce a same-type constraint between the two same-named
         // potential archetypes.
-        builder.addSameTypeRequirement(pa, nested.front(), sameNestedTypeSource,
-                                       diagnoseMismatch);
+        builder.addSameTypeRequirement(
+                                 pa, nested.front(),
+                                 RequirementSource::forNestedTypeNameMatch(pa),
+                                 diagnoseMismatch);
       } else {
         nested.push_back(pa);
 
         if (repNested) {
-          builder.addSameTypeRequirement(pa, repNested, sameNestedTypeSource,
-                                         diagnoseMismatch);
+          builder.addSameTypeRequirement(
+                                 pa, repNested,
+                                 RequirementSource::forNestedTypeNameMatch(pa),
+                                 diagnoseMismatch);
         }
       }
 
@@ -1081,7 +1256,8 @@
   if (isConcreteType()) {
     for (auto equivT : rep->getEquivalenceClassMembers()) {
       concretizeNestedTypeFromConcreteParent(
-          equivT, sameNestedTypeSource, nestedPA, builder,
+          equivT, RequirementSource::forNestedTypeNameMatch(nestedPA),
+          nestedPA, builder,
           [&](ProtocolDecl *proto) -> ProtocolConformanceRef {
             auto depTy = nestedPA->getDependentType({},
                                                     /*allowUnresolved=*/true)
@@ -1109,7 +1285,7 @@
   // somewhere else.
   bool failed = builder.addConformanceRequirement(
                   this, assocType->getProtocol(),
-                  RequirementSource::forInferred(builder, nullptr));
+                  RequirementSource::forInferred(this, nullptr));
   (void)failed;
 
   // Trigger the construction of nested types with this name.
@@ -1341,31 +1517,40 @@
   else
     Out.indent(Indent) << getNestedName();
 
+  auto equivClass = getEquivalenceClassIfPresent();
+
   // Print superclass.
-  if (Superclass) {
-    Out << " : ";
-    Superclass.print(Out);
-    Out << " ";
-    if (!SuperclassSource->isDerivedRequirement())
-      Out << "*";
-    Out << "[";
-    SuperclassSource->print(Out, SrcMgr);
-    Out << "]";
+  if (equivClass && equivClass->superclass) {
+    for (const auto &constraint : equivClass->superclassConstraints) {
+      if (constraint.archetype != this) continue;
+
+      Out << " : ";
+      constraint.concreteType.print(Out);
+
+      Out << " ";
+      if (!constraint.source->isDerivedRequirement())
+        Out << "*";
+      Out << "[";
+      constraint.source->print(Out, SrcMgr);
+      Out << "]";
+    }
   }
 
   // Print concrete type.
-  for (unsigned i : indices(concreteTypes)) {
-    auto concreteType = concreteTypes[i];
-    Out << " == ";
-    concreteType.print(Out);
+  if (equivClass && equivClass->concreteType) {
+    for (const auto &constraint : equivClass->concreteTypeConstraints) {
+      if (constraint.archetype != this) continue;
 
-    auto concreteTypeSource = concreteTypeSources[i];
-    Out << " ";
-    if (!concreteTypeSource->isDerivedRequirement())
-      Out << "*";
-    Out << "[";
-    concreteTypeSource->print(Out, SrcMgr);
-    Out << "]";
+      Out << " == ";
+      constraint.concreteType.print(Out);
+
+      Out << " ";
+      if (!constraint.source->isDerivedRequirement())
+        Out << "*";
+      Out << "[";
+      constraint.source->print(Out, SrcMgr);
+      Out << "]";
+    }
   }
 
   // Print requirements.
@@ -1595,19 +1780,19 @@
     Visited.erase(Proto);
   };
 
+  auto concreteSelf = T->getDependentType({}, /*allowUnresolved=*/true);
+  auto protocolSubMap = SubstitutionMap::getProtocolSubstitutions(
+      Proto, concreteSelf, ProtocolConformanceRef(Proto));
+
   // Use the requirement signature to avoid rewalking the entire protocol.  This
   // cannot compute the requirement signature directly, because that may be
   // infinitely recursive: this code is also used to construct it.
   if (Proto->isRequirementSignatureComputed()) {
     auto reqSig = Proto->getRequirementSignature();
 
-    auto concreteSelf = T->getDependentType({}, /*allowUnresolved=*/true);
-    auto subMap = SubstitutionMap::getProtocolSubstitutions(
-        Proto, concreteSelf, ProtocolConformanceRef(Proto));
-
     auto innerSource = Source->viaAbstractProtocolRequirement(*this, Proto);
     for (auto rawReq : reqSig->getRequirements()) {
-      auto req = rawReq.subst(subMap);
+      auto req = rawReq.subst(protocolSubMap);
       assert(req && "substituting Self in requirement shouldn't fail");
       if (addRequirement(*req, innerSource, Visited))
         return true;
@@ -1633,6 +1818,12 @@
         if (addInheritedRequirements(AssocType, AssocPA, Source, Visited))
           return true;
       }
+      if (auto WhereClause = AssocType->getTrailingWhereClause()) {
+        auto innerSource = Source->viaAbstractProtocolRequirement(*this, Proto);
+        for (auto &req : WhereClause->getRequirements()) {
+          addRequirement(&req, innerSource, &protocolSubMap);
+        }
+      }
     } else if (auto TypeAlias = dyn_cast<TypeAliasDecl>(Member)) {
         // FIXME: this should check that the typealias is makes sense (e.g. has
         // the same/compatible type as typealiases in parent protocols) and
@@ -1642,8 +1833,6 @@
         // unresolved PA that prints an error later.
       (void)TypeAlias;
     }
-
-    // FIXME: Requirement declarations.
   }
 
   return false;
@@ -1677,28 +1866,11 @@
   return false;
 }
 
-bool GenericSignatureBuilder::addSuperclassRequirement(PotentialArchetype *T,
-                                                Type Superclass,
-                                                const RequirementSource *Source) {
-  T = T->getRepresentative();
-
-  // Make sure the concrete type fulfills the superclass requirement
-  // of the archetype.
-  if (T->isConcreteType()) {
-    Type concrete = T->getConcreteType();
-    if (!Superclass->isExactSuperclassOf(concrete, getLazyResolver())) {
-      if (auto source = T->findAnyConcreteTypeSourceAsWritten()) {
-        Diags.diagnose(source->second->getLoc(), diag::type_does_not_inherit,
-                       T->getDependentType(/*FIXME:*/{ },
-                                           /*allowUnresolved=*/true),
-                       source->first, Superclass)
-          .highlight(Source->getLoc());
-      }
-      return true;
-    }
-
-    return false;
-  }
+bool GenericSignatureBuilder::updateSuperclass(
+                                           PotentialArchetype *T,
+                                           Type superclass,
+                                           const RequirementSource *source) {
+  auto equivClass = T->getOrCreateEquivalenceClass();
 
   // Local function to handle the update of superclass conformances
   // when the superclass constraint changes.
@@ -1724,73 +1896,49 @@
     }
   };
 
-  // If T already has a superclass, make sure it's related.
-  if (T->Superclass) {
-    // TODO: In principle, this could be isBindableToSuperclassOf instead of
-    // isExactSubclassOf. If you had:
-    //
-    //   class Foo<T>
-    //   class Bar: Foo<Int>
-    //
-    //   func foo<T, U where U: Foo<T>, U: Bar>(...) { ... }
-    //
-    // then the second constraint should be allowed, constraining U to Bar
-    // and secondarily imposing a T == Int constraint.
-    if (T->Superclass->isExactSuperclassOf(Superclass, nullptr)) {
-      T->Superclass = Superclass;
-
-      // We've strengthened the bound, so update superclass conformances.
-      updateSuperclassConformances();
-    // TODO: Similar to the above, a more general isBindableToSuperclassOf
-    // base class constraint could potentially introduce secondary constraints.
-    // If you had:
-    //
-    //   class Foo<T>
-    //   class Bar: Foo<Int>
-    //
-    //   func foo<T, U where U: Bar, U: Foo<T>>(...) { ... }
-    //
-    // then the second `U: Foo<T>` constraint introduces a `T == Int`
-    // constraint.
-    } else if (!Superclass->isExactSuperclassOf(T->Superclass, nullptr)) {
-      if (Source->getLoc().isValid()) {
-        // Figure out what kind of subject we have; it will affect the
-        // diagnostic.
-        auto subjectType = T->getDependentType(/*FIXME: */{ }, true);
-        unsigned kind;
-        if (auto gp = subjectType->getAs<GenericTypeParamType>()) {
-          if (gp->getDecl() &&
-              isa<ProtocolDecl>(gp->getDecl()->getDeclContext())) {
-            kind = 1;
-            subjectType = cast<ProtocolDecl>(gp->getDecl()->getDeclContext())
-                            ->getDeclaredInterfaceType();
-          } else {
-            kind = 0;
-          }
-        } else {
-          kind = 2;
-        }
-
-        Diags.diagnose(Source->getLoc(), diag::requires_superclass_conflict,
-                       kind, subjectType, T->Superclass, Superclass)
-          .highlight(T->SuperclassSource->getLoc());
-      }
-      return true;
-    }
-
-    updateRequirementSource(T->SuperclassSource, Source);
+  // If we haven't yet recorded a superclass constraint for this equivalence
+  // class, do so now.
+  if (!equivClass->superclass) {
+    equivClass->superclass = superclass;
+    updateSuperclassConformances();
     return false;
   }
 
-  // Set the superclass.
-  T->Superclass = Superclass;
-  T->SuperclassSource = Source;
+  // T already has a superclass; make sure it's related.
+  auto existingSuperclass = equivClass->superclass;
+  // TODO: In principle, this could be isBindableToSuperclassOf instead of
+  // isExactSubclassOf. If you had:
+  //
+  //   class Foo<T>
+  //   class Bar: Foo<Int>
+  //
+  //   func foo<T, U where U: Foo<T>, U: Bar>(...) { ... }
+  //
+  // then the second constraint should be allowed, constraining U to Bar
+  // and secondarily imposing a T == Int constraint.
+  if (existingSuperclass->isExactSuperclassOf(superclass, nullptr)) {
+    equivClass->superclass = superclass;
 
-  // Update based on these conformances.
-  updateSuperclassConformances();
+    // We've strengthened the bound, so update superclass conformances.
+    updateSuperclassConformances();
+    return false;
+  }
+
   return false;
 }
 
+bool GenericSignatureBuilder::addSuperclassRequirement(
+                                            PotentialArchetype *T,
+                                            Type superclass,
+                                            const RequirementSource *source) {
+  // Record the constraint.
+  T->getOrCreateEquivalenceClass()->superclassConstraints
+    .push_back(ConcreteConstraint{T, superclass, source});
+
+  // Update the equivalence class with the constraint.
+  return updateSuperclass(T, superclass, source);
+}
+
 void GenericSignatureBuilder::PotentialArchetype::addSameTypeConstraint(
                                              PotentialArchetype *otherPA,
                                              const RequirementSource *source) {
@@ -1831,8 +1979,10 @@
   // Decide which potential archetype is to be considered the representative.
   // It doesn't specifically matter which we use, but it's a minor optimization
   // to prefer the canonical type.
-  if (compareDependentTypes(&T2, &T1) < 0)
+  if (compareDependentTypes(&T2, &T1) < 0) {
     std::swap(T1, T2);
+    std::swap(OrigT1, OrigT2);
+  }
 
   // Merge any concrete constraints.
   Type concrete1 = T1->getConcreteType();
@@ -1882,17 +2032,35 @@
     delete equivClass2;
   };
 
+  // Same-type-to-concrete requirements.
+  if (equivClass2 && equivClass2->concreteType) {
+    if (!equivClass->concreteType)
+      equivClass->concreteType = equivClass2->concreteType;
+
+    equivClass->concreteTypeConstraints.insert(
+                                 equivClass->concreteTypeConstraints.end(),
+                                 equivClass2->concreteTypeConstraints.begin(),
+                                 equivClass2->concreteTypeConstraints.end());
+  }
+
   // Make T1 the representative of T2, merging the equivalence classes.
   T2->representativeOrEquivClass = T1;
 
-  // Same-type-to-concrete requirement.
-  if (equivClass2 && equivClass2->concreteType && !equivClass->concreteType)
-    equivClass->concreteType = equivClass2->concreteType;
-
   // Superclass requirements.
-  if (T2->Superclass) {
-    addSuperclassRequirement(T1, T2->getSuperclass(),
-                             T2->getSuperclassSource());
+  if (equivClass2 && equivClass2->superclass) {
+    const RequirementSource *source2;
+    if (auto existingSource2 =
+          equivClass2->findAnySuperclassConstraintAsWritten(OrigT2))
+      source2 = existingSource2->source;
+    else
+      source2 = equivClass2->superclassConstraints.front().source;
+
+    (void)updateSuperclass(T1, equivClass2->superclass, source2);
+
+    equivClass->superclassConstraints.insert(
+                                   equivClass->concreteTypeConstraints.end(),
+                                   equivClass2->superclassConstraints.begin(),
+                                   equivClass2->superclassConstraints.end());
   }
 
   // Add all of the protocol conformance requirements of T2 to T1.
@@ -1902,13 +2070,13 @@
   }
 
   // Recursively merge the associated types of T2 into T1.
-  auto sameNestedTypeSource = RequirementSource::forNestedTypeNameMatch(*this);
   for (auto equivT2 : equivClass2Members) {
     for (auto T2Nested : equivT2->NestedTypes) {
       auto T1Nested = T1->getNestedType(T2Nested.first, *this);
-      if (addSameTypeRequirement(T1Nested, T2Nested.second.front(),
-                                 sameNestedTypeSource,
-                                 [&](Type type1, Type type2) {
+      if (addSameTypeRequirement(
+                           T1Nested, T2Nested.second.front(),
+                           RequirementSource::forNestedTypeNameMatch(T1Nested),
+                           [&](Type type1, Type type2) {
             Diags.diagnose(Source->getLoc(),
                            diag::requires_same_type_conflict,
                            T1Nested->isGenericParam(),
@@ -1926,21 +2094,25 @@
        PotentialArchetype *T,
        Type Concrete,
        const RequirementSource *Source) {
+  auto rep = T->getRepresentative();
+  auto equivClass = rep->getOrCreateEquivalenceClass();
+
   // Record the concrete type and its source.
-  T->concreteTypes.push_back(Concrete);
-  T->concreteTypeSources.push_back(Source);
+  equivClass->concreteTypeConstraints.push_back(
+                                      ConcreteConstraint{T, Concrete, Source});
 
   // If we've already been bound to a type, match that type.
-  if (auto oldConcrete = T->getConcreteType()) {
+  if (equivClass->concreteType) {
     bool mismatch = addSameTypeRequirement(
-        oldConcrete, Concrete, Source, [&](Type type1, Type type2) {
-          Diags.diagnose(Source->getLoc(),
-                         diag::requires_same_type_conflict,
-                         T->isGenericParam(),
-                         T->getDependentType(/*FIXME: */{ }, true), type1,
-                         type2);
+            equivClass->concreteType, Concrete, Source,
+            [&](Type type1, Type type2) {
+            Diags.diagnose(Source->getLoc(),
+                           diag::requires_same_type_conflict,
+                           T->isGenericParam(),
+                           T->getDependentType(/*FIXME: */{ }, true), type1,
+                           type2);
 
-        });
+          });
 
     if (mismatch) return true;
 
@@ -1949,10 +2121,7 @@
   }
 
   // Record the requirement.
-  auto rep = T->getRepresentative();
-  auto equivClass = rep->getOrCreateEquivalenceClass();
-  if (!equivClass->concreteType)
-    equivClass->concreteType = Concrete;
+  equivClass->concreteType = Concrete;
 
   // Make sure the concrete type fulfills the requirements on the archetype.
   // FIXME: Move later...
@@ -1986,24 +2155,6 @@
     updateRequirementSource(conforms.second, concreteSource);
   }
 
-  // Make sure the concrete type fulfills the superclass requirement
-  // of the archetype.
-  if (rep->Superclass) {
-    if (!rep->Superclass->isExactSuperclassOf(Concrete, getLazyResolver())) {
-      Diags.diagnose(Source->getLoc(), diag::type_does_not_inherit,
-                     rep->getDependentType(/*FIXME: */{ },
-                                         /*allowUnresolved=*/true),
-                     Concrete, rep->Superclass)
-        .highlight(rep->SuperclassSource->getLoc());
-      return true;
-    }
-
-    // The superclass requirement is made redundant by the concrete type
-    // assignment.
-    auto concreteSource = Source->viaConcrete(*this, nullptr);
-    updateRequirementSource(rep->SuperclassSource, concreteSource);
-  }
-
   // Eagerly resolve any existing nested types to their concrete forms (others
   // will be "concretized" as they are constructed, in getNestedType).
   for (auto equivT : rep->getEquivalenceClassMembers()) {
@@ -2020,17 +2171,18 @@
 }
 
 bool GenericSignatureBuilder::addSameTypeRequirementBetweenConcrete(
-    Type type1, Type type2, const RequirementSource *source,
+    Type type1, Type type2, FloatingRequirementSource source,
     llvm::function_ref<void(Type, Type)> diagnoseMismatch) {
   // Local class to handle matching the two sides of the same-type constraint.
   class ReqTypeMatcher : public TypeMatcher<ReqTypeMatcher> {
     GenericSignatureBuilder &builder;
-    const RequirementSource *source;
+    FloatingRequirementSource source;
     Type outerType1, outerType2;
     llvm::function_ref<void(Type, Type)> diagnoseMismatch;
 
   public:
-    ReqTypeMatcher(GenericSignatureBuilder &builder, const RequirementSource *source,
+    ReqTypeMatcher(GenericSignatureBuilder &builder,
+                   FloatingRequirementSource source,
                    Type outerType1, Type outerType2,
                    llvm::function_ref<void(Type, Type)> diagnoseMismatch)
         : builder(builder), source(source), outerType1(outerType1),
@@ -2056,29 +2208,31 @@
   return !matcher.match(type1, type2);
 }
 
-bool GenericSignatureBuilder::addSameTypeRequirement(UnresolvedType paOrT1,
-                                                     UnresolvedType paOrT2,
-                                                     const RequirementSource *source) {
+bool GenericSignatureBuilder::addSameTypeRequirement(
+                                             UnresolvedType paOrT1,
+                                             UnresolvedType paOrT2,
+                                             FloatingRequirementSource source) {
   return addSameTypeRequirement(resolve(paOrT1), resolve(paOrT2), source);
 }
 bool GenericSignatureBuilder::addSameTypeRequirement(
-    UnresolvedType paOrT1, UnresolvedType paOrT2, const RequirementSource *source,
+    UnresolvedType paOrT1, UnresolvedType paOrT2,
+    FloatingRequirementSource source,
     llvm::function_ref<void(Type, Type)> diagnoseMismatch) {
   return addSameTypeRequirement(resolve(paOrT1), resolve(paOrT2), source,
                                 diagnoseMismatch);
 }
 bool GenericSignatureBuilder::addSameTypeRequirement(ResolvedType paOrT1,
                                                      ResolvedType paOrT2,
-                                                     const RequirementSource *source) {
+                                                     FloatingRequirementSource source) {
   return addSameTypeRequirement(paOrT1, paOrT2, source,
                                 [&](Type type1, Type type2) {
-    Diags.diagnose(source->getLoc(), diag::requires_same_concrete_type,
+    Diags.diagnose(source.getLoc(), diag::requires_same_concrete_type,
                    type1, type2);
   });
 }
 
 bool GenericSignatureBuilder::addSameTypeRequirement(
-    ResolvedType paOrT1, ResolvedType paOrT2, const RequirementSource *source,
+    ResolvedType paOrT1, ResolvedType paOrT2, FloatingRequirementSource source,
     llvm::function_ref<void(Type, Type)> diagnoseMismatch) {
   auto pa1 = paOrT1.getPotentialArchetype();
   auto pa2 = paOrT2.getPotentialArchetype();
@@ -2087,12 +2241,13 @@
 
   // If both sides of the requirement are type parameters, equate them.
   if (pa1 && pa2) {
-    return addSameTypeRequirementBetweenArchetypes(pa1, pa2, source);
+    return addSameTypeRequirementBetweenArchetypes(pa1, pa2,
+                                                   source.getSource(pa1));
     // If just one side is a type parameter, map it to a concrete type.
   } else if (pa1) {
-    return addSameTypeRequirementToConcrete(pa1, t2, source);
+    return addSameTypeRequirementToConcrete(pa1, t2, source.getSource(pa1));
   } else if (pa2) {
-    return addSameTypeRequirementToConcrete(pa2, t1, source);
+    return addSameTypeRequirementToConcrete(pa2, t1, source.getSource(pa2));
   } else {
     return addSameTypeRequirementBetweenConcrete(t1, t2, source,
                                                  diagnoseMismatch);
@@ -2155,10 +2310,10 @@
 
       // Explicit requirement.
       if (typeRepr)
-        return RequirementSource::forExplicit(*this, typeRepr);
+        return RequirementSource::forExplicit(pa, typeRepr);
 
       // An abstract explicit requirement.
-      return RequirementSource::forAbstract(*this);
+      return RequirementSource::forAbstract(pa);
     };
 
     // Protocol requirement.
@@ -2184,13 +2339,23 @@
   });
 }
 
-bool GenericSignatureBuilder::addRequirement(const RequirementRepr *Req) {
-  auto source = RequirementSource::forExplicit(*this, Req);
+bool GenericSignatureBuilder::addRequirement(const RequirementRepr *Req,
+                                             const RequirementSource *source,
+                                             const SubstitutionMap *subMap) {
+  auto localSource = source ? FloatingRequirementSource(source)
+                            : FloatingRequirementSource::forExplicit(Req);
+
+  auto subst = [&](Type t) {
+    if (subMap)
+      return t.subst(*subMap);
+
+    return t;
+  };
 
   switch (Req->getKind()) {
   case RequirementReprKind::LayoutConstraint: {
     // FIXME: Need to do something here.
-    PotentialArchetype *PA = resolveArchetype(Req->getSubject());
+    PotentialArchetype *PA = resolveArchetype(subst(Req->getSubject()));
     if (!PA) {
       // FIXME: Poor location information.
       // FIXME: Delay diagnostic until after type validation?
@@ -2199,14 +2364,15 @@
       return true;
     }
 
-    if (addLayoutRequirement(PA, Req->getLayoutConstraint(), source))
+    if (addLayoutRequirement(PA, Req->getLayoutConstraint(),
+                             localSource.getSource(PA)))
       return true;
 
     return false;
   }
 
   case RequirementReprKind::TypeConstraint: {
-    PotentialArchetype *PA = resolveArchetype(Req->getSubject());
+    PotentialArchetype *PA = resolveArchetype(subst(Req->getSubject()));
     if (!PA) {
       // FIXME: Poor location information.
       // FIXME: Delay diagnostic until after type validation?
@@ -2217,7 +2383,8 @@
 
     // Check whether this is a supertype requirement.
     if (Req->getConstraint()->getClassOrBoundGenericClass()) {
-      return addSuperclassRequirement(PA, Req->getConstraint(), source);
+      return addSuperclassRequirement(PA, Req->getConstraint(),
+                                      localSource.getSource(PA));
     }
 
     SmallVector<ProtocolDecl *, 4> ConformsTo;
@@ -2228,7 +2395,7 @@
 
     // Add each of the protocols.
     for (auto Proto : ConformsTo)
-      if (addConformanceRequirement(PA, Proto, source))
+      if (addConformanceRequirement(PA, Proto, localSource.getSource(PA)))
         return true;
 
     return false;
@@ -2246,22 +2413,22 @@
     }
 
     return addRequirement(Requirement(RequirementKind::SameType,
-                                      Req->getFirstType(),
-                                      Req->getSecondType()),
-                          source);
+                                      subst(Req->getFirstType()),
+                                      subst(Req->getSecondType())),
+                          localSource);
   }
 
   llvm_unreachable("Unhandled requirement?");
 }
 
 bool GenericSignatureBuilder::addRequirement(const Requirement &req,
-                                      const RequirementSource *source) {
+                                             FloatingRequirementSource source) {
   llvm::SmallPtrSet<ProtocolDecl *, 8> Visited;
   return addRequirement(req, source, Visited);
 }
 
 bool GenericSignatureBuilder::addRequirement(
-    const Requirement &req, const RequirementSource *source,
+    const Requirement &req, FloatingRequirementSource source,
     llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited) {
   switch (req.getKind()) {
   case RequirementKind::Superclass: {
@@ -2270,7 +2437,8 @@
     if (!pa) return false;
 
     assert(req.getSecondType()->getClassOrBoundGenericClass());
-    return addSuperclassRequirement(pa, req.getSecondType(), source);
+    return addSuperclassRequirement(pa, req.getSecondType(),
+                                    source.getSource(pa));
   }
 
   case RequirementKind::Layout: {
@@ -2278,7 +2446,8 @@
     PotentialArchetype *pa = resolveArchetype(req.getFirstType());
     if (!pa) return false;
 
-    return addLayoutRequirement(pa, req.getLayoutConstraint(), source);
+    return addLayoutRequirement(pa, req.getLayoutConstraint(),
+                                source.getSource(pa));
   }
 
   case RequirementKind::Conformance: {
@@ -2292,10 +2461,11 @@
     // Add each of the protocols.
     for (auto proto : conformsTo) {
       if (Visited.count(proto)) {
-        markPotentialArchetypeRecursive(pa, proto, source);
+        markPotentialArchetypeRecursive(pa, proto, source.getSource(pa));
         continue;
       }
-      if (addConformanceRequirement(pa, proto, source, Visited)) return true;
+      if (addConformanceRequirement(pa, proto, source.getSource(pa), Visited))
+        return true;
     }
 
     return false;
@@ -2305,8 +2475,8 @@
     return addSameTypeRequirement(
         req.getFirstType(), req.getSecondType(), source,
         [&](Type type1, Type type2) {
-          if (source->getLoc().isValid())
-            Diags.diagnose(source->getLoc(), diag::requires_same_concrete_type,
+          if (source.getLoc().isValid())
+            Diags.diagnose(source.getLoc(), diag::requires_same_concrete_type,
                            type1, type2);
         });
   }
@@ -2318,25 +2488,11 @@
 class GenericSignatureBuilder::InferRequirementsWalker : public TypeWalker {
   GenericSignatureBuilder &Builder;
   TypeRepr *typeRepr;
-  unsigned MinDepth;
-  unsigned MaxDepth;
-
-  /// We cannot add requirements to archetypes from outer generic parameter
-  /// lists.
-  bool isOuterArchetype(PotentialArchetype *PA) {
-    unsigned ParamDepth = PA->getRootGenericParamKey().Depth;
-    assert(ParamDepth <= MaxDepth);
-    (void) MaxDepth;
-    return ParamDepth < MinDepth;
-  }
 
 public:
   InferRequirementsWalker(GenericSignatureBuilder &builder,
-                          TypeRepr *typeRepr,
-                          unsigned MinDepth,
-                          unsigned MaxDepth)
-    : Builder(builder), typeRepr(typeRepr), MinDepth(MinDepth),
-      MaxDepth(MaxDepth) { }
+                          TypeRepr *typeRepr)
+    : Builder(builder), typeRepr(typeRepr) { }
 
   Action walkToTypePost(Type ty) override {
     auto boundGeneric = ty->getAs<BoundGenericType>();
@@ -2364,7 +2520,7 @@
 
     // Handle the requirements.
     // FIXME: Inaccurate TypeReprs.
-    auto source = RequirementSource::forInferred(Builder, typeRepr);
+    auto source = FloatingRequirementSource::forInferred(typeRepr);
     for (const auto &rawReq : genericSig->getRequirements()) {
       if (auto req = rawReq.subst(getTypeSubstitution,
                                   Builder.getLookupConformanceFn()))
@@ -2375,14 +2531,11 @@
   }
 };
 
-void GenericSignatureBuilder::inferRequirements(TypeLoc type,
-                                         unsigned minDepth,
-                                         unsigned maxDepth) {
+void GenericSignatureBuilder::inferRequirements(TypeLoc type) {
   if (!type.getType())
     return;
   // FIXME: Crummy source-location information.
-  InferRequirementsWalker walker(*this, type.getTypeRepr(),
-                                 minDepth, maxDepth);
+  InferRequirementsWalker walker(*this, type.getTypeRepr());
   type.getType().walk(walker);
 }
 
@@ -2391,11 +2544,8 @@
   if (genericParams == nullptr)
     return;
 
-  unsigned depth = genericParams->getDepth();
   for (auto P : *params)
-    inferRequirements(P->getTypeLoc(),
-                      /*minDepth=*/depth,
-                      /*maxDepth=*/depth);
+    inferRequirements(P->getTypeLoc());
 }
 
 /// Perform typo correction on the given nested type, producing the
@@ -2548,15 +2698,17 @@
   visitPotentialArchetypes([&](PotentialArchetype *archetype) {
     if (archetype != archetype->getRepresentative()) return;
 
-    if (archetype->isConcreteType()) {
+    auto equivClass = archetype->getOrCreateEquivalenceClass();
+    if (equivClass->concreteType) {
       // Check for recursive same-type bindings.
       if (isRecursiveConcreteType(archetype, /*isSuperclass=*/false)) {
-        if (auto source = archetype->findAnyConcreteTypeSourceAsWritten()) {
-          Diags.diagnose(source->second->getLoc(),
+        if (auto constraint =
+              equivClass->findAnyConcreteConstraintAsWritten()) {
+          Diags.diagnose(constraint->source->getLoc(),
                          diag::recursive_same_type_constraint,
                          archetype->getDependentType(genericParams,
                                                      /*allowUnresolved=*/true),
-                         source->first);
+                         constraint->concreteType);
         }
 
         archetype->RecursiveConcreteType = true;
@@ -2566,25 +2718,29 @@
     }
 
     // Check for recursive superclass bindings.
-    if (archetype->getSuperclass()) {
+    if (equivClass->superclass) {
       if (isRecursiveConcreteType(archetype, /*isSuperclass=*/true)) {
-        if (archetype->SuperclassSource->getLoc().isValid())
-          Diags.diagnose(archetype->SuperclassSource->getLoc(),
+        if (auto source = equivClass->findAnySuperclassConstraintAsWritten()) {
+          Diags.diagnose(source->source->getLoc(),
                          diag::recursive_superclass_constraint,
-                         archetype->getDependentType(genericParams,
+                         source->archetype->getDependentType(
+                                                     genericParams,
                                                      /*allowUnresolved=*/true),
-                         archetype->getSuperclass());
+                         equivClass->superclass);
+        }
 
         archetype->RecursiveSuperclassType = true;
+      } else {
+        checkRedundantSuperclassConstraints(genericParams, archetype);
       }
     }
   });
 
-  SmallPtrSet<PotentialArchetype *, 4> visited;
-
   // Check for generic parameters which have been made concrete or equated
   // with each other.
   if (!allowConcreteGenericParams) {
+    SmallPtrSet<PotentialArchetype *, 4> visited;
+    
     unsigned depth = 0;
     for (const auto &gp : Impl->GenericParams)
       depth = std::max(depth, gp->getDepth());
@@ -2600,9 +2756,10 @@
 
       // Don't allow a generic parameter to be equivalent to a concrete type,
       // because then we don't actually have a parameter.
-      if (rep->getConcreteType()) {
-        if (auto source = rep->findAnyConcreteTypeSourceAsWritten())
-          Diags.diagnose(source->second->getLoc(),
+      auto equivClass = rep->getOrCreateEquivalenceClass();
+      if (equivClass->concreteType) {
+        if (auto constraint = equivClass->findAnyConcreteConstraintAsWritten())
+          Diags.diagnose(constraint->source->getLoc(),
                          diag::requires_generic_param_made_equal_to_concrete,
                          rep->getDependentType(genericParams,
                                                /*allowUnresolved=*/true));
@@ -2667,7 +2824,7 @@
                                 *this);
       addSameTypeRequirement(
           pa, replacement,
-          RequirementSource::forNestedTypeNameMatch(*this));
+          RequirementSource::forNestedTypeNameMatch(pa));
     });
   }
 }
@@ -2690,101 +2847,97 @@
   return invalid;
 }
 
-namespace {
-  /// Describes a concrete constraint on a potential archetype.
-  struct ConcreteConstraint {
-    PotentialArchetype *archetype;
-    Type concreteType;
-    const RequirementSource *source;
+namespace swift {
+  bool operator<(const ConcreteConstraint &lhs, const ConcreteConstraint &rhs) {
+    auto lhsPA = lhs.archetype;
+    auto rhsPA = rhs.archetype;
+    if (int result = compareDependentTypes(&lhsPA, &rhsPA))
+      return result < 0;
 
-    friend bool operator<(const ConcreteConstraint &lhs,
-                          const ConcreteConstraint &rhs) {
-      auto lhsPA = lhs.archetype;
-      auto rhsPA = rhs.archetype;
-      if (int result = compareDependentTypes(&lhsPA, &rhsPA))
-        return result < 0;
+    if (int result = lhs.source->compare(rhs.source))
+      return result < 0;
 
-      if (int result = lhs.source->compare(rhs.source))
-        return result < 0;
-
-      return false;
-    }
-
-    friend bool operator==(const ConcreteConstraint &lhs,
-                           const ConcreteConstraint &rhs) {
-      return lhs.archetype == rhs.archetype &&
-             lhs.concreteType->isEqual(rhs.concreteType) &&
-             lhs.source == rhs.source;
-    }
-  };
-}
-
-void GenericSignatureBuilder::checkRedundantConcreteTypeConstraints(
-                                 ArrayRef<GenericTypeParamType *> genericParams,
-                                 PotentialArchetype *representative) {
-  Type concreteType = representative->getConcreteType();
-  assert(concreteType && "No concrete type to check");
-
-  Optional<ConcreteConstraint> representativeConstraint;
-
-  // Gather the concrete constraints within this equivalence class.
-  SmallVector<ConcreteConstraint, 4> concreteConstraints;
-  for (auto pa : representative->getEquivalenceClassMembers()) {
-    auto types = pa->getConcreteTypesAsWritten();
-    auto sources = pa->getConcreteTypeSourcesAsWritten();
-    for (unsigned i : indices(types)) {
-      auto source = sources[i];
-
-      // Save this constraint.
-      auto constraint = ConcreteConstraint{pa, types[i], source};
-      concreteConstraints.push_back(constraint);
-
-      // Check whether this constraint is better than the best we've seen so far
-      // at being the representative constraint against which others will be
-      // compared.
-      if (!representativeConstraint) {
-        representativeConstraint = constraint;
-        continue;
-      }
-
-      // We prefer derived constraints to non-derived constraints.
-      bool thisIsDerived = source->isDerivedRequirement();
-      bool representativeIsDerived =
-        representativeConstraint->source->isDerivedRequirement();
-      if (thisIsDerived != representativeIsDerived) {
-        if (thisIsDerived)
-          representativeConstraint = constraint;
-
-        continue;
-      }
-
-      // We prefer constraints with locations to constraints without locations.
-      bool thisHasValidSourceLoc = source->getLoc().isValid();
-      bool representativeHasValidSourceLoc =
-        representativeConstraint->source->getLoc().isValid();
-      if (thisHasValidSourceLoc != representativeHasValidSourceLoc) {
-        if (thisHasValidSourceLoc)
-          representativeConstraint = constraint;
-
-        continue;
-      }
-
-      // Otherwise, order via the constraint itself.
-      if (constraint < *representativeConstraint)
-        representativeConstraint = constraint;
-    }
+    return false;
   }
 
-  // Sort the concrete constraints, so we get deterministic ordering of
-  // diagnostics.
-  llvm::array_pod_sort(concreteConstraints.begin(), concreteConstraints.end());
+  bool operator==(const ConcreteConstraint &lhs, const ConcreteConstraint &rhs){
+    return lhs.archetype == rhs.archetype &&
+           lhs.concreteType->isEqual(rhs.concreteType) &&
+           lhs.source == rhs.source;
+  }
+}
 
-  // Local function to provide a note desribing the representative constraint.
+ConcreteConstraint GenericSignatureBuilder::checkConstraintList(
+                           ArrayRef<GenericTypeParamType *> genericParams,
+                           std::vector<ConcreteConstraint> &constraints,
+                           llvm::function_ref<bool(const ConcreteConstraint &)>
+                             isSuitableRepresentative,
+                           llvm::function_ref<ConstraintRelation(Type)>
+                             checkConstraint,
+                           Optional<Diag<unsigned, Type, Type, Type>>
+                             conflictingDiag,
+                           Diag<Type, Type> redundancyDiag,
+                           Diag<bool, Type, Type> otherNoteDiag) {
+  // Remove self-derived constraints.
+  constraints.erase(
+    std::remove_if(constraints.begin(), constraints.end(),
+                   [&](const ConcreteConstraint &constraint) {
+                     return constraint.source->isSelfDerivedSource(
+                              constraint.archetype);
+                   }),
+    constraints.end());
+
+  // Sort the constraints, so we get a deterministic ordering of diagnostics.
+  llvm::array_pod_sort(constraints.begin(), constraints.end());
+
+  // Find a representative constraint.
+  Optional<ConcreteConstraint> representativeConstraint;
+  for (const auto &constraint : constraints) {
+    // If this isn't a suitable representative constraint, ignore it.
+    if (!isSuitableRepresentative(constraint))
+      continue;
+
+    // Check whether this constraint is better than the best we've seen so far
+    // at being the representative constraint against which others will be
+    // compared.
+    if (!representativeConstraint) {
+      representativeConstraint = constraint;
+      continue;
+    }
+
+    // We prefer derived constraints to non-derived constraints.
+    bool thisIsDerived = constraint.source->isDerivedRequirement();
+    bool representativeIsDerived =
+      representativeConstraint->source->isDerivedRequirement();
+    if (thisIsDerived != representativeIsDerived) {
+      if (thisIsDerived)
+        representativeConstraint = constraint;
+
+      continue;
+    }
+
+    // We prefer constraints with locations to constraints without locations.
+    bool thisHasValidSourceLoc = constraint.source->getLoc().isValid();
+    bool representativeHasValidSourceLoc =
+      representativeConstraint->source->getLoc().isValid();
+    if (thisHasValidSourceLoc != representativeHasValidSourceLoc) {
+      if (thisHasValidSourceLoc)
+        representativeConstraint = constraint;
+
+      continue;
+    }
+
+    // Otherwise, order via the constraint itself.
+    if (constraint < *representativeConstraint)
+      representativeConstraint = constraint;
+  }
+
+  // Local function to provide a note describing the representative constraint.
   auto noteRepresentativeConstraint = [&] {
     if (representativeConstraint->source->getLoc().isInvalid()) return;
 
     Diags.diagnose(representativeConstraint->source->getLoc(),
-                   diag::redundancy_here,
+                   otherNoteDiag,
                    representativeConstraint->source->isDerivedRequirement(),
                    representativeConstraint->archetype->
                      getDependentType(genericParams, /*allowUnresolved=*/true),
@@ -2792,26 +2945,193 @@
   };
 
   // Go through the concrete constraints looking for redundancies.
-  for (const auto &constraint : concreteConstraints) {
+  bool diagnosedConflictingRepresentative = false;
+  for (const auto &constraint : constraints) {
     // Leave the representative alone.
     if (constraint == *representativeConstraint) continue;
 
-    // Note: this is conservative. There might be redundant constraints that
-    // don't get diagnosed here.
-    if (!concreteType->isEqual(constraint.concreteType)) continue;
+    switch (checkConstraint(constraint.concreteType)) {
+    case ConstraintRelation::Unrelated:
+      continue;
 
-    // If this requirement is not derived (but has a useful location),
-    // complain that it is redundant.
-    if (!constraint.source->isDerivedRequirement() &&
-        constraint.source->getLoc().isValid()) {
-      Diags.diagnose(constraint.source->getLoc(),
-                     diag::redundant_same_type_to_concrete,
-                     constraint.archetype->getDependentType(
-                                                  /*FIXME:*/{ },
+    case ConstraintRelation::Conflicting: {
+      // Figure out what kind of subject we have; it will affect the
+      // diagnostic.
+      auto getSubjectType =
+        [&](PotentialArchetype *T) -> std::pair<unsigned, Type> {
+          auto subjectType = T->getDependentType(genericParams, true);
+          unsigned kind;
+          if (auto gp = subjectType->getAs<GenericTypeParamType>()) {
+            if (gp->getDecl() &&
+                isa<ProtocolDecl>(gp->getDecl()->getDeclContext())) {
+              kind = 1;
+              subjectType = cast<ProtocolDecl>(gp->getDecl()->getDeclContext())
+                              ->getDeclaredInterfaceType();
+            } else {
+              kind = 0;
+            }
+          } else {
+            kind = 2;
+          }
+
+          return std::make_pair(kind, subjectType);
+        };
+
+
+      // The requirement conflicts. If this constraint has a location, complain
+      // about it.
+      if (constraint.source->getLoc().isValid()) {
+        auto subject = getSubjectType(constraint.archetype);
+        Diags.diagnose(constraint.source->getLoc(), *conflictingDiag,
+                       subject.first, subject.second,
+                       constraint.concreteType,
+                       representativeConstraint->concreteType);
+
+        noteRepresentativeConstraint();
+        break;
+      }
+
+      // If the representative itself conflicts and we haven't diagnosed it yet,
+      // do so now.
+      if (!diagnosedConflictingRepresentative &&
+          representativeConstraint->source->getLoc().isValid()) {
+        auto subject = getSubjectType(representativeConstraint->archetype);
+        Diags.diagnose(representativeConstraint->source->getLoc(),
+                       *conflictingDiag,
+                       subject.first, subject.second,
+                       representativeConstraint->concreteType,
+                       constraint.concreteType);
+
+        diagnosedConflictingRepresentative = true;
+        break;
+      }
+      break;
+    }
+
+    case ConstraintRelation::Redundant:
+      // If this requirement is not derived (but has a useful location),
+      // complain that it is redundant.
+      if (!constraint.source->isDerivedRequirement() &&
+          constraint.source->getLoc().isValid()) {
+        Diags.diagnose(constraint.source->getLoc(),
+                       redundancyDiag,
+                       constraint.archetype->getDependentType(
+                         genericParams, /*allowUnresolved=*/true),
+                       constraint.concreteType);
+
+        noteRepresentativeConstraint();
+      }
+      break;
+    }
+  }
+
+  return *representativeConstraint;
+}
+
+void GenericSignatureBuilder::checkRedundantConcreteTypeConstraints(
+                                 ArrayRef<GenericTypeParamType *> genericParams,
+                                 PotentialArchetype *representative) {
+  auto equivClass = representative->getOrCreateEquivalenceClass();
+  assert(equivClass->concreteType && "No concrete type to check");
+
+  checkConstraintList(
+    genericParams, equivClass->concreteTypeConstraints,
+    [](const ConcreteConstraint &constraint) {
+      return true;
+    },
+    [&](Type concreteType) {
+      // If the concrete type is equivalent, the constraint is redundant.
+      // FIXME: Should check this constraint after substituting in the
+      // archetype anchors for each dependent type.
+      if (concreteType->isEqual(equivClass->concreteType))
+        return ConstraintRelation::Redundant;
+
+      // Call this unrelated.
+      return ConstraintRelation::Unrelated;
+    },
+    None,
+    diag::redundant_same_type_to_concrete,
+    diag::same_type_redundancy_here);
+}
+
+void GenericSignatureBuilder::checkRedundantSuperclassConstraints(
+                                 ArrayRef<GenericTypeParamType *> genericParams,
+                                 PotentialArchetype *representative) {
+  auto equivClass = representative->getOrCreateEquivalenceClass();
+  assert(equivClass->superclass && "No superclass constraint?");
+
+  // FIXME: We should be substituting in the canonical type in context so
+  // we can resolve superclass requirements, e.g., if you had:
+  //
+  //   class Foo<T>
+  //   class Bar: Foo<Int>
+  //
+  //   func foo<T, U where U: Bar, U: Foo<T>>(...) { ... }
+  //
+  // then the second `U: Foo<T>` constraint introduces a `T == Int`
+  // constraint, and we will need to perform that substitution for this final
+  // check.
+
+  auto representativeConstraint =
+    checkConstraintList(
+      genericParams, equivClass->superclassConstraints,
+      [&](const ConcreteConstraint &constraint) {
+        return constraint.concreteType->isEqual(equivClass->superclass);
+      },
+      [&](Type superclass) {
+        // If this class is a superclass of the "best"
+        if (superclass->isExactSuperclassOf(equivClass->superclass, nullptr))
+          return ConstraintRelation::Redundant;
+
+        // Otherwise, it conflicts.
+        return ConstraintRelation::Conflicting;
+      },
+      diag::requires_superclass_conflict,
+      diag::redundant_superclass_constraint,
+      diag::superclass_redundancy_here);
+
+  // If we have a concrete type, check it.
+  // FIXME: Substitute into the concrete type.
+  if (equivClass->concreteType) {
+    // Make sure the concrete type fulfills the superclass requirement.
+    if (!equivClass->superclass->isExactSuperclassOf(equivClass->concreteType,
+                                                     nullptr)) {
+      if (auto existing = equivClass->findAnyConcreteConstraintAsWritten(
+                            representativeConstraint.archetype)) {
+        Diags.diagnose(existing->source->getLoc(), diag::type_does_not_inherit,
+                       existing->archetype->getDependentType(
+                                                   genericParams,
+                                                   /*allowUnresolved=*/true),
+                       existing->concreteType, equivClass->superclass);
+
+        // FIXME: Note the representative constraint.
+      } else if (representativeConstraint.source->getLoc().isValid()) {
+        Diags.diagnose(representativeConstraint.source->getLoc(),
+                       diag::type_does_not_inherit,
+                       representativeConstraint.archetype->getDependentType(
+                                                    genericParams,
+                                                    /*allowUnresolved=*/true),
+                       equivClass->concreteType, equivClass->superclass);
+      }
+    } else if (representativeConstraint.source->getLoc().isValid()) {
+      // It does fulfill the requirement; diagnose the redundancy.
+      Diags.diagnose(representativeConstraint.source->getLoc(),
+                     diag::redundant_superclass_constraint,
+                     representativeConstraint.archetype->getDependentType(
+                                                  genericParams,
                                                   /*allowUnresolved=*/true),
-                     constraint.concreteType);
+                     representativeConstraint.concreteType);
 
-      noteRepresentativeConstraint();
+      if (auto existing = equivClass->findAnyConcreteConstraintAsWritten(
+                            representativeConstraint.archetype)) {
+        Diags.diagnose(existing->source->getLoc(),
+                       diag::same_type_redundancy_here,
+                       existing->source->isDerivedRequirement(),
+                       existing->archetype->getDependentType(
+                                                   genericParams,
+                                                   /*allowUnresolved=*/true),
+                       existing->concreteType);
+      }
     }
   }
 }
@@ -2849,17 +3169,19 @@
 /// the *implicit* same-type constraints.
 ///
 /// \param pa The potential archetype to visit.
-/// \param visited The set of potential archetypes that have already been
-/// seen.
-/// \param found Used to record each potential archetype visited
-static void sameTypeDFS(PotentialArchetype *pa,
-                        SmallPtrSetImpl<PotentialArchetype *> &visited,
-                        SmallVectorImpl<PotentialArchetype *> &found) {
-  // If we've already visited this potential archetype, we're done.
-  if (!visited.insert(pa).second) return;
+/// \param paToComponent A mapping from each potential archetype to its
+/// component number.
+/// \param component The component number we're currently visiting.
+///
+/// \returns the best archetype anchor seen so far.
+static PotentialArchetype *sameTypeDFS(PotentialArchetype *pa,
+                        unsigned component,
+                        llvm::SmallDenseMap<PotentialArchetype *, unsigned>
+                          &paToComponent) {
+  PotentialArchetype *anchor = pa;
 
-  // Note that we've found this potential archetype.
-  found.push_back(pa);
+  // If we've already visited this potential archetype, we're done.
+  if (!paToComponent.insert({pa, component}).second) return anchor;
 
   // Visit its adjacent potential archetypes.
   for (const auto &sameType : pa->getSameTypeConstraints()) {
@@ -2878,19 +3200,29 @@
       break;
     }
 
-    sameTypeDFS(sameType.first, visited, found);
+    sameTypeDFS(sameType.first, component, paToComponent);
+
+    // If this type is better than the anchor, use it for the anchor.
+    if (compareDependentTypes(&sameType.first, &anchor) < 0)
+      anchor = sameType.first;
   }
+
+  return anchor;
 }
 
 namespace {
   /// Describes a component in the (implied) same-type constraint graph.
   struct SameTypeComponent {
     /// The potential archetype that acts as the anchor for this component.
-    PotentialArchetype * anchor;
+    PotentialArchetype *anchor;
 
     /// The (best) requirement source within the component that makes the
     /// potential archetypes in this component equivalent to the concrete type.
-    const RequirementSource * concreteTypeSource;
+    const RequirementSource *concreteTypeSource;
+
+    /// The (best) requirement source within the component that introduces
+    /// the superclass constraint.
+    const RequirementSource *superclassSource;
 
     friend bool operator<(const SameTypeComponent &lhs,
                           const SameTypeComponent &rhs) {
@@ -2937,44 +3269,54 @@
 /// canonical edges connects vertex i to vertex i+1 for i in 0..<size-1.
 static SmallVector<SameTypeComponent, 2> getSameTypeComponents(
                                                      PotentialArchetype *rep) {
-  SmallPtrSet<PotentialArchetype *, 8> visited;
+  llvm::SmallDenseMap<PotentialArchetype *, unsigned> paToComponent;
   SmallVector<SameTypeComponent, 2> components;
   for (auto pa : rep->getEquivalenceClassMembers()) {
     // If we've already seen this potential archetype, there's nothing else to
     // do.
-    if (visited.count(pa) != 0) continue;
+    if (paToComponent.count(pa) != 0) continue;
 
     // Find all of the potential archetypes within this connected component.
-    SmallVector<PotentialArchetype *, 2> component;
-    sameTypeDFS(pa, visited, component);
-
-    // Find the best anchor and concrete type source for this component.
-    PotentialArchetype *anchor = component[0];
-    const RequirementSource *bestConcreteTypeSource = nullptr;
-    auto considerNewSource = [&](const RequirementSource *source) {
-      if (!bestConcreteTypeSource ||
-          source->compare(bestConcreteTypeSource) < 0)
-        bestConcreteTypeSource = source;
-    };
-
-    if (!anchor->getConcreteTypeSourcesAsWritten().empty())
-      bestConcreteTypeSource = anchor->getConcreteTypeSourcesAsWritten()[0];
-
-    for (auto componentPA : ArrayRef<PotentialArchetype *>(component)) {
-      // Update the anchor.
-      if (compareDependentTypes(&componentPA, &anchor) < 0)
-        anchor = componentPA;
-
-      // If this potential archetype has a better concrete type source than
-      // the best we've seen, take it.
-      for (auto source: componentPA->getConcreteTypeSourcesAsWritten())
-        considerNewSource(source);
-    }
+    auto anchor = sameTypeDFS(pa, components.size(), paToComponent);
 
     // Record the anchor.
-    components.push_back({anchor, bestConcreteTypeSource});
+    components.push_back({anchor, nullptr, nullptr});
   }
 
+  // If there is a concrete type, figure out the best concrete type anchor
+  // per component.
+  auto equivClass = rep->getOrCreateEquivalenceClass();
+  for (const auto &concrete : equivClass->concreteTypeConstraints) {
+    // Dig out the component associated with constraint.
+    assert(paToComponent.count(concrete.archetype) > 0);
+    auto &component = components[paToComponent[concrete.archetype]];
+
+    // If it has a better source than we'd seen before for this component,
+    // keep it.
+    auto &bestConcreteTypeSource = component.concreteTypeSource;
+    if (!bestConcreteTypeSource ||
+        concrete.source->compare(bestConcreteTypeSource) < 0)
+      bestConcreteTypeSource = concrete.source;
+  }
+
+  // If there is a superclass and no concrete type, figure out the best
+  // superclass source per component.
+  if (equivClass->superclass && !equivClass->concreteType) {
+    for (const auto &superclass : equivClass->superclassConstraints) {
+    // Dig out the component associated with constraint.
+    assert(paToComponent.count(superclass.archetype) > 0);
+    auto &component = components[paToComponent[superclass.archetype]];
+
+    // If it has a better source than we'd seen before for this component,
+    // keep it.
+    auto &bestSuperclassSource = component.superclassSource;
+    if (!bestSuperclassSource ||
+        superclass.source->compare(bestSuperclassSource) < 0)
+      bestSuperclassSource = superclass.source;
+    }
+  }
+
+  // Sort the components.
   llvm::array_pod_sort(components.begin(), components.end());
 
   return components;
@@ -3047,12 +3389,20 @@
         auto source =
           knownAnchor->concreteTypeSource
             ? knownAnchor->concreteTypeSource
-            : RequirementSource::forAbstract(*this);
+            : RequirementSource::forAbstract(archetype);
 
         f(RequirementKind::SameType, archetype, concreteType, source);
         continue;
       }
 
+      // If we have a superclass, produce a superclass requirement
+      if (Type superclass = rep->getSuperclass()) {
+        f(RequirementKind::Superclass, archetype, superclass,
+          knownAnchor->superclassSource
+            ? knownAnchor->superclassSource
+            : RequirementSource::forAbstract(archetype));
+      }
+
       // If we're at the last anchor in the component, do nothing;
       auto nextAnchor = knownAnchor;
       ++nextAnchor;
@@ -3063,7 +3413,7 @@
         auto otherPA = nextAnchor->anchor;
         deferredSameTypeRequirement = [&f, archetype, otherPA, this] {
           f(RequirementKind::SameType, archetype, otherPA,
-            RequirementSource::forAbstract(*this));
+            RequirementSource::forAbstract(archetype));
         };
       }
     }
@@ -3075,12 +3425,6 @@
     if (archetype != archetype->getArchetypeAnchor(*this))
       continue;
 
-    // If we have a superclass, produce a superclass requirement
-    if (Type superclass = rep->getSuperclass()) {
-      f(RequirementKind::Superclass, archetype, superclass,
-        rep->getSuperclassSource());
-    }
-
     // If we have a layout constraint, produce a layout requirement.
     if (LayoutConstraint Layout = archetype->getLayout()) {
       f(RequirementKind::Layout, archetype, Layout,
@@ -3166,9 +3510,8 @@
   for (auto param : sig->getGenericParams())
     addGenericParameter(param);
 
-  auto source = RequirementSource::forAbstract(*this);
   for (auto &reqt : sig->getRequirements()) {
-    addRequirement(reqt, source);
+    addRequirement(reqt, FloatingRequirementSource::forAbstract());
   }
 }
 
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 521fcb2..659ad44 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -20,6 +20,7 @@
 #include "swift/AST/TypeWalker.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/AST.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/SubstitutionMap.h"
@@ -52,7 +53,7 @@
 
 bool TypeLoc::isError() const {
   assert(wasValidated() && "Type not yet validated");
-  return getType()->hasError() || getType()->getCanonicalType()->hasError();
+  return getType()->hasError();
 }
 
 SourceRange TypeLoc::getSourceRange() const {
@@ -282,111 +283,17 @@
 }
 
 bool TypeBase::isSpecialized() {
-  CanType CT = getCanonicalType();
-  if (CT.getPointer() != this)
-    return CT->isSpecialized();
+  Type t = getCanonicalType();
 
-  return CT.findIf([](Type type) -> bool {
-    return isa<BoundGenericType>(type.getPointer());
-  });
-}
-
-bool TypeBase::isUnspecializedGeneric() {
-  CanType CT = getCanonicalType();
-  if (CT.getPointer() != this)
-    return CT->isUnspecializedGeneric();
-
-  switch (getKind()) {
-#define SUGARED_TYPE(id, parent) case TypeKind::id:
-#define TYPE(id, parent)
-#include "swift/AST/TypeNodes.def"
-    llvm_unreachable("we're only working with CanType's here");
-
-  case TypeKind::Error:
-  case TypeKind::Unresolved:
-  case TypeKind::TypeVariable:
-    llvm_unreachable("querying invalid type");
-
-  case TypeKind::UnboundGeneric:
-    return true;
-
-  case TypeKind::BoundGenericClass:
-  case TypeKind::BoundGenericEnum:
-  case TypeKind::BoundGenericStruct:
-    return true;
-
-  case TypeKind::Function: {
-    auto funcTy = cast<AnyFunctionType>(this);
-    return funcTy->getInput()->isUnspecializedGeneric() ||
-           funcTy->getResult()->isUnspecializedGeneric();
+  for (;;) {
+    if (!t || !t->getAnyNominal())
+      return false;
+    if (t->is<BoundGenericType>())
+      return true;
+    t = t->getNominalParent();
   }
 
-  case TypeKind::GenericFunction:
-    return true;
-
-  case TypeKind::Class:
-  case TypeKind::Struct:
-  case TypeKind::Enum:
-    if (auto parentTy = cast<NominalType>(this)->getParent())
-      return parentTy->isUnspecializedGeneric();
-    return false;
-
-  case TypeKind::ExistentialMetatype:
-  case TypeKind::Metatype:
-    return cast<AnyMetatypeType>(this)->getInstanceType()
-             ->isUnspecializedGeneric();
-
-  case TypeKind::UnownedStorage:
-  case TypeKind::UnmanagedStorage:
-  case TypeKind::WeakStorage:
-    return cast<ReferenceStorageType>(this)->getReferentType()
-             ->isUnspecializedGeneric();
-
-  case TypeKind::LValue:
-    return cast<LValueType>(this)->getObjectType()->isUnspecializedGeneric();
-  case TypeKind::InOut:
-    return cast<InOutType>(this)->getObjectType()->isUnspecializedGeneric();
-
-  case TypeKind::Tuple: {
-    auto tupleTy = cast<TupleType>(this);
-    for (auto &Elt : tupleTy->getElements())
-      if (Elt.getType()->isUnspecializedGeneric())
-        return true;
-
-    return false;
-  }
-
-  case TypeKind::Archetype:
-  case TypeKind::BuiltinFloat:
-  case TypeKind::BuiltinInteger:
-  case TypeKind::BuiltinUnknownObject:
-  case TypeKind::BuiltinNativeObject:
-  case TypeKind::BuiltinBridgeObject:
-  case TypeKind::BuiltinRawPointer:
-  case TypeKind::BuiltinUnsafeValueBuffer:
-  case TypeKind::BuiltinVector:
-  case TypeKind::Module:
-  case TypeKind::DynamicSelf:
-  case TypeKind::Protocol:
-  case TypeKind::ProtocolComposition:
-  case TypeKind::SILFunction:
-    return false;
-
-  case TypeKind::GenericTypeParam:
-  case TypeKind::DependentMember:
-    return false;
-      
-  case TypeKind::SILBlockStorage:
-    return cast<SILBlockStorageType>(this)->getCaptureType()
-        ->isUnspecializedGeneric();
-  case TypeKind::SILBox:
-    for (auto &arg : cast<SILBoxType>(this)->getGenericArgs()) {
-      if (arg.getReplacement()->isUnspecializedGeneric())
-        return true;
-    }
-    return false;
-  }
-  llvm_unreachable("bad TypeKind");
+  return false;
 }
 
 bool TypeBase::hasOpenedExistential(ArchetypeType *opened) {
@@ -543,44 +450,16 @@
   return false;
 }
 
-namespace {
-class GetRValueTypeVisitor : public TypeVisitor<GetRValueTypeVisitor, Type> {
-public:
-  Type visitLValueType(LValueType *lvt) {
-    // Look through lvalue types.
-    assert(!lvt->getObjectType()->isLValueType()
-           && "unexpected nested lvalue");
-    return lvt->getObjectType();
-  }
-  
-  Type visitTupleType(TupleType *tt) {
-    // Look through lvalues in tuples.
-    SmallVector<TupleTypeElt, 4> elts;
-    for (auto &elt : tt->getElements()) {
-      elts.push_back(elt.getWithType(visit(elt.getType())));
-    }
-    return TupleType::get(elts, tt->getASTContext());
-  }
-  
-  Type visitParenType(ParenType *pt) {
-    return ParenType::get(pt->getASTContext(), visit(pt->getUnderlyingType()));
-  }
-
-  Type visitType(TypeBase *t) {
-    // Other types should not structurally contain lvalues.
-    assert(!t->isLValueType()
-           && "unexpected structural lvalue");
-    return t;
-  }
-};
-} // end anonymous namespace
-
 Type TypeBase::getRValueType() {
   // If the type is not an lvalue, this is a no-op.
   if (!isLValueType())
     return this;
-  
-  return GetRValueTypeVisitor().visit(this);
+
+  return Type(this).transform([](Type t) -> Type {
+      if (auto *lvalueTy = dyn_cast<LValueType>(t.getPointer()))
+        return lvalueTy->getObjectType();
+      return t;
+    });
 }
 
 Type TypeBase::getOptionalObjectType() {
@@ -661,24 +540,6 @@
   return type;
 }
 
-ClassDecl *CanType::getClassBoundImpl(CanType type) {
-  if (auto classTy = dyn_cast<ClassType>(type))
-    return classTy->getDecl();
-
-  if (auto boundTy = dyn_cast<BoundGenericClassType>(type))
-    return boundTy->getDecl();
-
-  if (auto archetypeTy = dyn_cast<ArchetypeType>(type)) {
-    assert(archetypeTy->requiresClass());
-    if (Type supertype = archetypeTy->getSuperclass()) {
-      return supertype->getClassOrBoundGenericClass();
-    }
-    return nullptr;
-  }
-
-  llvm_unreachable("class has no class bound!");
-}
-
 LayoutConstraint CanType::getLayoutConstraint() const {
   if (auto archetypeTy = dyn_cast<ArchetypeType>(*this)) {
     return archetypeTy->getLayoutConstraint();
@@ -3240,7 +3101,7 @@
 }
 
 SubstitutionMap TypeBase::getContextSubstitutionMap(
-  ModuleDecl *module, const DeclContext *dc) {
+    ModuleDecl *module, const DeclContext *dc) {
   auto *genericSig = dc->getGenericSignatureOfContext();
   if (genericSig == nullptr)
     return SubstitutionMap();
@@ -3249,7 +3110,9 @@
       LookUpConformanceInModule(module));
 }
 
-TypeSubstitutionMap TypeBase::getMemberSubstitutions(const ValueDecl *member) {
+TypeSubstitutionMap TypeBase::getMemberSubstitutions(
+    const ValueDecl *member,
+    GenericEnvironment *genericEnv) {
   auto *memberDC = member->getDeclContext();
 
   TypeSubstitutionMap substitutions;
@@ -3262,14 +3125,18 @@
   // We need this since code completion and diagnostics want to be able
   // to call getTypeOfMember() with functions and nested types.
   if (isa<AbstractFunctionDecl>(member) ||
-      isa<GenericTypeDecl>(member)) {
+      isa<GenericTypeDecl>(member) ||
+      isa<SubscriptDecl>(member)) {
     auto *innerDC = member->getInnermostDeclContext();
     if (innerDC->isInnermostContextGeneric()) {
       auto *sig = innerDC->getGenericSignatureOfContext();
       for (auto param : sig->getInnermostGenericParams()) {
         auto *genericParam = param->getCanonicalType()
             ->castTo<GenericTypeParamType>();
-        substitutions[genericParam] = param;
+        substitutions[genericParam] =
+          (genericEnv
+           ? genericEnv->mapTypeIntoContext(param)
+           : param);
       }
     }
   }
@@ -3278,13 +3145,15 @@
 }
 
 SubstitutionMap TypeBase::getMemberSubstitutionMap(
-  ModuleDecl *module, const ValueDecl *member) {
+    ModuleDecl *module, const ValueDecl *member,
+    GenericEnvironment *genericEnv) {
   auto *genericSig = member->getInnermostDeclContext()
       ->getGenericSignatureOfContext();
   if (genericSig == nullptr)
     return SubstitutionMap();
+  auto subs = getMemberSubstitutions(member, genericEnv);
   return genericSig->getSubstitutionMap(
-      QueryTypeSubstitutionMap{getMemberSubstitutions(member)},
+      QueryTypeSubstitutionMap{subs},
       LookUpConformanceInModule(module));
 }
 
diff --git a/lib/AST/USRGeneration.cpp b/lib/AST/USRGeneration.cpp
index d568648..70cb225 100644
--- a/lib/AST/USRGeneration.cpp
+++ b/lib/AST/USRGeneration.cpp
@@ -57,6 +57,10 @@
     clang::index::generateUSRForObjCProtocol(ObjCName, OS);
   } else if (isa<VarDecl>(D)) {
     clang::index::generateUSRForObjCProperty(ObjCName, D->isStatic(), OS);
+  } else if (isa<ConstructorDecl>(D)) {
+    // init() is a class member in Swift, but an instance method in ObjC.
+    clang::index::generateUSRForObjCMethod(ObjCName, /*isInstanceMember=*/true,
+                                           OS);
   } else if (isa<AbstractFunctionDecl>(D)) {
     clang::index::generateUSRForObjCMethod(ObjCName, D->isInstanceMember(), OS);
   } else if (isa<EnumDecl>(D)) {
diff --git a/lib/Basic/Demangle.cpp b/lib/Basic/Demangle.cpp
index a4c71a9..281883f 100644
--- a/lib/Basic/Demangle.cpp
+++ b/lib/Basic/Demangle.cpp
@@ -628,11 +628,13 @@
 
 /// TODO: This is an atrocity. Come up with a shorter name.
 #define FUNCSIGSPEC_CREATE_PARAM_KIND(kind)                                    \
-  Factory.createNode(Node::Kind::FunctionSignatureSpecializationParamKind,    \
-                      unsigned(FunctionSigSpecializationParamKind::kind))
+  Factory.createNode(                                                          \
+      Node::Kind::FunctionSignatureSpecializationParamKind,                    \
+      Node::IndexType(FunctionSigSpecializationParamKind::kind))
+
 #define FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(payload)                              \
-  Factory.createNode(Node::Kind::FunctionSignatureSpecializationParamPayload, \
-                      payload)
+  Factory.createNode(Node::Kind::FunctionSignatureSpecializationParamPayload,  \
+                     payload)
 
   bool demangleFuncSigSpecializationConstantProp(NodePointer parent) {
     // Then figure out what was actually constant propagated. First check if
@@ -3413,7 +3415,8 @@
   case Node::Kind::ReabstractionThunk:
   case Node::Kind::ReabstractionThunkHelper: {
     if (Options.ShortenThunk) {
-      Printer << "thunk";
+      Printer << "thunk for ";
+      print(pointer->getChild(pointer->getNumChildren() - 2));
       return;
     }
     Printer << "reabstraction thunk ";
diff --git a/lib/Basic/Demangler.cpp b/lib/Basic/Demangler.cpp
index 734af69..70ded11 100644
--- a/lib/Basic/Demangler.cpp
+++ b/lib/Basic/Demangler.cpp
@@ -1412,19 +1412,24 @@
       // The parameters will be added later.
       return addChild(Param, createNode(
         Node::Kind::FunctionSignatureSpecializationParamKind,
-        unsigned(FunctionSigSpecializationParamKind::ClosureProp)));
+        uint64_t(FunctionSigSpecializationParamKind::ClosureProp)));
     case 'p': {
       switch (nextChar()) {
         case 'f':
           // Consumes an identifier parameter, which will be added later.
-          return addChild(Param, createNode(
-            Node::Kind::FunctionSignatureSpecializationParamKind,
-            unsigned(FunctionSigSpecializationParamKind::ConstantPropFunction)));
+          return addChild(
+              Param,
+              createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                         Node::IndexType(FunctionSigSpecializationParamKind::
+                                             ConstantPropFunction)));
         case 'g':
           // Consumes an identifier parameter, which will be added later.
-          return addChild(Param, createNode(
-            Node::Kind::FunctionSignatureSpecializationParamKind,
-            unsigned(FunctionSigSpecializationParamKind::ConstantPropGlobal)));
+          return addChild(
+              Param,
+              createNode(
+                  Node::Kind::FunctionSignatureSpecializationParamKind,
+                  Node::IndexType(
+                      FunctionSigSpecializationParamKind::ConstantPropGlobal)));
         case 'i':
           return addFuncSpecParamNumber(Param,
                     FunctionSigSpecializationParamKind::ConstantPropInteger);
@@ -1441,10 +1446,12 @@
             case 'c': Encoding = "objc"; break;
             default: return nullptr;
           }
-          addChild(Param, createNode(
-                  Node::Kind::FunctionSignatureSpecializationParamKind,
-                  unsigned(swift::Demangle::FunctionSigSpecializationParamKind::
-                           ConstantPropString)));
+          addChild(Param,
+                   createNode(
+                       Node::Kind::FunctionSignatureSpecializationParamKind,
+                       Node::IndexType(
+                           swift::Demangle::FunctionSigSpecializationParamKind::
+                               ConstantPropString)));
           return addChild(Param, createNode(
                   Node::Kind::FunctionSignatureSpecializationParamPayload,
                   Encoding));
diff --git a/lib/Basic/LangOptions.cpp b/lib/Basic/LangOptions.cpp
index 19efc63..93ec8a9 100644
--- a/lib/Basic/LangOptions.cpp
+++ b/lib/Basic/LangOptions.cpp
@@ -52,6 +52,11 @@
   "big"
 };
 
+static const StringRef SupportedConditionalCompilationRuntimes[] = {
+  "_ObjC",
+  "_Native",
+};
+
 template <size_t N>
 bool contains(const StringRef (&Array)[N], const StringRef &V,
               std::vector<StringRef> &suggestions) {
@@ -75,36 +80,31 @@
   return false;
 }
 
-bool LangOptions::checkPlatformConditionOS(
-  StringRef &OSName, std::vector<StringRef> &suggestions) {
-  if (OSName == "macOS")
-    OSName = "OSX";
-  return contains(SupportedConditionalCompilationOSs,
-                  OSName,
-                  suggestions);
-}
-
-bool
-LangOptions::isPlatformConditionArchSupported(
-  StringRef ArchName, std::vector<StringRef> &suggestions) {
-  return contains(SupportedConditionalCompilationArches,
-                  ArchName,
-                  suggestions);
-}
-
-bool
-LangOptions::isPlatformConditionEndiannessSupported(
-  StringRef Endianness, std::vector<StringRef> &suggestions) {
-  return contains(SupportedConditionalCompilationEndianness,
-                  Endianness,
-                  suggestions);
+bool LangOptions::
+checkPlatformConditionSupported(PlatformConditionKind Kind, StringRef Value,
+                                std::vector<StringRef> &suggestions) {
+  switch (Kind) {
+  case PlatformConditionKind::OS:
+    return contains(SupportedConditionalCompilationOSs, Value,
+                    suggestions);
+  case PlatformConditionKind::Arch:
+    return contains(SupportedConditionalCompilationArches, Value,
+                    suggestions);
+  case PlatformConditionKind::Endianness:
+    return contains(SupportedConditionalCompilationEndianness, Value,
+                    suggestions);
+  case PlatformConditionKind::Runtime:
+    return contains(SupportedConditionalCompilationRuntimes, Value,
+                    suggestions);
+  }
+  llvm_unreachable("Unhandled enum value");
 }
 
 StringRef
-LangOptions::getPlatformConditionValue(StringRef Name) const {
+LangOptions::getPlatformConditionValue(PlatformConditionKind Kind) const {
   // Last one wins.
   for (auto &Opt : reversed(PlatformConditionValues)) {
-    if (Opt.first == Name)
+    if (Opt.first == Kind)
       return Opt.second;
   }
   return StringRef();
@@ -141,23 +141,23 @@
 
   // Set the "os" platform condition.
   if (Target.isMacOSX())
-    addPlatformConditionValue("os", "OSX");
+    addPlatformConditionValue(PlatformConditionKind::OS, "OSX");
   else if (triple.isTvOS())
-    addPlatformConditionValue("os", "tvOS");
+    addPlatformConditionValue(PlatformConditionKind::OS, "tvOS");
   else if (triple.isWatchOS())
-    addPlatformConditionValue("os", "watchOS");
+    addPlatformConditionValue(PlatformConditionKind::OS, "watchOS");
   else if (triple.isiOS())
-    addPlatformConditionValue("os", "iOS");
+    addPlatformConditionValue(PlatformConditionKind::OS, "iOS");
   else if (triple.isAndroid())
-    addPlatformConditionValue("os", "Android");
+    addPlatformConditionValue(PlatformConditionKind::OS, "Android");
   else if (triple.isOSLinux())
-    addPlatformConditionValue("os", "Linux");
+    addPlatformConditionValue(PlatformConditionKind::OS, "Linux");
   else if (triple.isOSFreeBSD())
-    addPlatformConditionValue("os", "FreeBSD");
+    addPlatformConditionValue(PlatformConditionKind::OS, "FreeBSD");
   else if (triple.isOSWindows())
-    addPlatformConditionValue("os", "Windows");
+    addPlatformConditionValue(PlatformConditionKind::OS, "Windows");
   else if (triple.isPS4())
-    addPlatformConditionValue("os", "PS4");
+    addPlatformConditionValue(PlatformConditionKind::OS, "PS4");
   else
     UnsupportedOS = true;
 
@@ -167,25 +167,25 @@
   switch (Target.getArch()) {
   case llvm::Triple::ArchType::arm:
   case llvm::Triple::ArchType::thumb:
-    addPlatformConditionValue("arch", "arm");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "arm");
     break;
   case llvm::Triple::ArchType::aarch64:
-    addPlatformConditionValue("arch", "arm64");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "arm64");
     break;
   case llvm::Triple::ArchType::ppc64:
-    addPlatformConditionValue("arch", "powerpc64");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "powerpc64");
     break;
   case llvm::Triple::ArchType::ppc64le:
-    addPlatformConditionValue("arch", "powerpc64le");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "powerpc64le");
     break;
   case llvm::Triple::ArchType::x86:
-    addPlatformConditionValue("arch", "i386");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "i386");
     break;
   case llvm::Triple::ArchType::x86_64:
-    addPlatformConditionValue("arch", "x86_64");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "x86_64");
     break;
   case llvm::Triple::ArchType::systemz:
-    addPlatformConditionValue("arch", "s390x");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "s390x");
     break;
   default:
     UnsupportedArch = true;
@@ -198,25 +198,25 @@
   switch (Target.getArch()) {
   case llvm::Triple::ArchType::arm:
   case llvm::Triple::ArchType::thumb:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::aarch64:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::ppc64:
-    addPlatformConditionValue("_endian", "big");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "big");
     break;
   case llvm::Triple::ArchType::ppc64le:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::x86:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::x86_64:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::systemz:
-    addPlatformConditionValue("_endian", "big");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "big");
     break;
   default:
     llvm_unreachable("undefined architecture endianness");
@@ -224,9 +224,9 @@
 
   // Set the "runtime" platform condition.
   if (EnableObjCInterop)
-    addPlatformConditionValue("_runtime", "_ObjC");
+    addPlatformConditionValue(PlatformConditionKind::Runtime, "_ObjC");
   else
-    addPlatformConditionValue("_runtime", "_Native");
+    addPlatformConditionValue(PlatformConditionKind::Runtime, "_Native");
 
   // If you add anything to this list, change the default size of
   // PlatformConditionValues to not require an extra allocation
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
index 09b43dc..29b7d10 100644
--- a/lib/ClangImporter/ClangImporter.cpp
+++ b/lib/ClangImporter/ClangImporter.cpp
@@ -83,9 +83,7 @@
     void handleImport(const clang::Module *imported) {
       if (!imported)
         return;
-      ModuleDecl *nativeImported = Impl.finishLoadingClangModule(Importer, imported,
-        /*preferAdapter=*/true);
-      Impl.ImportedHeaderExports.push_back({ /*filter=*/{}, nativeImported });
+      Impl.DeferredHeaderImports.push_back(imported);
     }
 
     void InclusionDirective(clang::SourceLocation HashLoc,
@@ -835,7 +833,7 @@
   // Set up the imported header module.
   auto *importedHeaderModule = ModuleDecl::create(ctx.getIdentifier("__ObjC"), ctx);
   importer->Impl.ImportedHeaderUnit =
-    new (ctx) ClangModuleUnit(*importedHeaderModule, *importer, nullptr);
+    new (ctx) ClangModuleUnit(*importedHeaderModule, importer->Impl, nullptr);
   importedHeaderModule->addFile(*importer->Impl.ImportedHeaderUnit);
 
   importer->Impl.IsReadingBridgingPCH = false;
@@ -963,6 +961,9 @@
   // Add any defined macros to the bridging header lookup table.
   addMacrosToLookupTable(*BridgingHeaderLookupTable, getNameImporter());
 
+  // Finish loading any extra modules that were (transitively) imported.
+  handleDeferredImports();
+
   // Wrap all Clang imports under a Swift import decl.
   for (auto &Import : BridgeHeaderTopLevelImports) {
     if (auto *ClangImport = Import.dyn_cast<clang::ImportDecl*>()) {
@@ -1008,16 +1009,11 @@
                                          bool trackParsedSymbols,
                                          bool implicitImport) {
   if (llvm::sys::path::extension(header).endswith(PCH_EXTENSION)) {
-    // We already imported this with -include-pch above, so we should have
-    // collected a bunch of PCH-encoded module imports that we need to
-    // replay to the HeaderImportCallbacks for processing.
     Impl.ImportedHeaderOwners.push_back(adapter);
-    clang::ASTReader &R = *Impl.Instance->getModuleManager();
-    HeaderImportCallbacks CB(*this, Impl);
-    for (auto ID : Impl.PCHImportedSubmodules) {
-      CB.handleImport(R.getSubmodule(ID));
-    }
-    Impl.PCHImportedSubmodules.clear();
+    // We already imported this with -include-pch above, so we should have
+    // collected a bunch of PCH-encoded module imports that we just need to
+    // replay in handleDeferredImports.
+    Impl.handleDeferredImports();
     return false;
   }
   clang::FileManager &fileManager = Impl.Instance->getFileManager();
@@ -1037,7 +1033,6 @@
     llvm::MemoryBuffer::getMemBufferCopy(
       importLine, Implementation::bridgingHeaderBufferName)
   };
-
   return Impl.importHeader(adapter, header, diagLoc, trackParsedSymbols,
                            std::move(sourceBuffer), implicitImport);
 }
@@ -1234,12 +1229,11 @@
   if (!clangModule)
     return nullptr;
 
-  return Impl.finishLoadingClangModule(*this, clangModule,
+  return Impl.finishLoadingClangModule(clangModule,
                                        /*preferAdapter=*/false);
 }
 
 ModuleDecl *ClangImporter::Implementation::finishLoadingClangModule(
-    ClangImporter &owner,
     const clang::Module *clangModule,
     bool findAdapter) {
   assert(clangModule);
@@ -1269,7 +1263,7 @@
     result->setTestingEnabled();
 
     wrapperUnit =
-      new (SwiftContext) ClangModuleUnit(*result, owner, clangModule);
+      new (SwiftContext) ClangModuleUnit(*result, *this, clangModule);
     result->addFile(*wrapperUnit);
     cacheEntry.setPointerAndInt(wrapperUnit, true);
 
@@ -1280,7 +1274,7 @@
   }
 
   if (clangModule->isSubModule()) {
-    finishLoadingClangModule(owner, clangModule->getTopLevelModule(), true);
+    finishLoadingClangModule(clangModule->getTopLevelModule(), true);
   } else {
     ModuleDecl *&loaded = SwiftContext.LoadedModules[result->getName()];
     if (!loaded)
@@ -1294,6 +1288,25 @@
   return result;
 }
 
+// Run through the set of deferred imports -- either those referenced by
+// submodule ID from a bridging PCH, or those already loaded as clang::Modules
+// in response to an import directive in a bridging header -- and call
+// finishLoadingClangModule on each.
+void ClangImporter::Implementation::handleDeferredImports()
+{
+  clang::ASTReader &R = *Instance->getModuleManager();
+  for (clang::serialization::SubmoduleID ID : PCHImportedSubmodules) {
+    DeferredHeaderImports.push_back(R.getSubmodule(ID));
+  }
+  PCHImportedSubmodules.clear();
+  for (const clang::Module *M : DeferredHeaderImports) {
+    ModuleDecl *nativeImported =
+      finishLoadingClangModule(M, /*preferAdapter=*/true);
+    ImportedHeaderExports.push_back({ /*filter=*/{}, nativeImported });
+  }
+  DeferredHeaderImports.clear();
+}
+
 ModuleDecl *ClangImporter::getImportedHeaderModule() const {
   return Impl.ImportedHeaderUnit->getParentModule();
 }
@@ -1381,7 +1394,6 @@
 }
 
 ClangModuleUnit *ClangImporter::Implementation::getWrapperForModule(
-    ClangImporter &importer,
     const clang::Module *underlying) {
   auto &cacheEntry = ModuleWrappers[underlying];
   if (ClangModuleUnit *cached = cacheEntry.getPointer())
@@ -1393,7 +1405,7 @@
   // Silence error messages about testably importing a Clang module.
   wrapper->setTestingEnabled();
 
-  auto file = new (SwiftContext) ClangModuleUnit(*wrapper, importer,
+  auto file = new (SwiftContext) ClangModuleUnit(*wrapper, *this,
                                                  underlying);
   wrapper->addFile(*file);
   cacheEntry.setPointer(file);
@@ -1414,9 +1426,7 @@
   // ClangModuleUnit.
   auto *M = maybeModule.getValue()->getTopLevelModule();
 
-  auto &importer =
-    static_cast<ClangImporter &>(*SwiftContext.getClangModuleLoader());
-  return getWrapperForModule(importer, M);
+  return getWrapperForModule(M);
 }
 
 #pragma mark Source locations
@@ -1988,9 +1998,9 @@
   }
 
   // Find the corresponding lookup table.
-  if (auto lookupTable = owner.Impl.findLookupTable(clangModule)) {
+  if (auto lookupTable = owner.findLookupTable(clangModule)) {
     // Search it.
-    owner.Impl.lookupVisibleDecls(*lookupTable, *actualConsumer);
+    owner.lookupVisibleDecls(*lookupTable, *actualConsumer);
   }
 }
 
@@ -2021,14 +2031,14 @@
     actualConsumer = &blacklistConsumer;
 
   // Find the corresponding lookup table.
-  if (auto lookupTable = owner.Impl.findLookupTable(topLevelModule)) {
+  if (auto lookupTable = owner.findLookupTable(topLevelModule)) {
     // Search it.
-    owner.Impl.lookupVisibleDecls(*lookupTable, *actualConsumer);
+    owner.lookupVisibleDecls(*lookupTable, *actualConsumer);
 
     // Add the extensions produced by importing categories.
     for (auto category : lookupTable->categories()) {
       if (auto extension = cast_or_null<ExtensionDecl>(
-              owner.Impl.importDecl(category, owner.Impl.CurrentVersion)))
+              owner.importDecl(category, owner.CurrentVersion)))
         results.push_back(extension);
     }
 
@@ -2040,7 +2050,7 @@
     for (auto entry : lookupTable->allGlobalsAsMembers()) {
       auto decl = entry.get<clang::NamedDecl *>();
       auto importedDecl =
-          owner.Impl.importDecl(decl, owner.Impl.CurrentVersion);
+          owner.importDecl(decl, owner.CurrentVersion);
       if (!importedDecl) continue;
 
       auto ext = dyn_cast<ExtensionDecl>(importedDecl->getDeclContext());
@@ -2125,9 +2135,9 @@
   }
 
   // Find the corresponding lookup table.
-  if (auto lookupTable = owner.Impl.findLookupTable(clangModule)) {
+  if (auto lookupTable = owner.findLookupTable(clangModule)) {
     // Search it.
-    owner.Impl.lookupValue(*lookupTable, name, *consumer);
+    owner.lookupValue(*lookupTable, name, *consumer);
   }
 }
 
@@ -2265,9 +2275,9 @@
   VectorDeclConsumer consumer(results);
 
   // Find the corresponding lookup table.
-  if (auto lookupTable = owner.Impl.findLookupTable(clangModule)) {
+  if (auto lookupTable = owner.findLookupTable(clangModule)) {
     // Search it.
-    owner.Impl.lookupObjCMembers(*lookupTable, name, consumer);
+    owner.lookupObjCMembers(*lookupTable, name, consumer);
   }
 }
 
@@ -2278,9 +2288,9 @@
     return;
 
   // Find the corresponding lookup table.
-  if (auto lookupTable = owner.Impl.findLookupTable(clangModule)) {
+  if (auto lookupTable = owner.findLookupTable(clangModule)) {
     // Search it.
-    owner.Impl.lookupAllObjCMembers(*lookupTable, consumer);
+    owner.lookupAllObjCMembers(*lookupTable, consumer);
   }
 }
 
@@ -2292,12 +2302,12 @@
     return;
 
   // Map the selector into a Clang selector.
-  auto clangSelector = owner.Impl.exportSelector(selector);
+  auto clangSelector = owner.exportSelector(selector);
   if (clangSelector.isNull()) return;
 
   // Collect all of the Objective-C methods with this selector.
   SmallVector<clang::ObjCMethodDecl *, 8> objcMethods;
-  auto &clangSema = owner.Impl.getClangSema();
+  auto &clangSema = owner.getClangSema();
   clangSema.CollectMultipleMethodsInGlobalPool(clangSelector,
                                                objcMethods,
                                                /*InstanceFirst=*/true,
@@ -2319,23 +2329,23 @@
 
     // If we found a property accessor, import the property.
     if (objcMethod->isPropertyAccessor())
-      (void)owner.Impl.importDecl(objcMethod->findPropertyDecl(true),
-                                  owner.Impl.CurrentVersion);
+      (void)owner.importDecl(objcMethod->findPropertyDecl(true),
+                             owner.CurrentVersion);
 
     // Import it.
     // FIXME: Retrying a failed import works around recursion bugs in the Clang
     // importer.
     auto imported =
-        owner.Impl.importDecl(objcMethod, owner.Impl.CurrentVersion);
+        owner.importDecl(objcMethod, owner.CurrentVersion);
     if (!imported)
-      imported = owner.Impl.importDecl(objcMethod, owner.Impl.CurrentVersion);
+      imported = owner.importDecl(objcMethod, owner.CurrentVersion);
     if (!imported) continue;
 
     if (auto func = dyn_cast<AbstractFunctionDecl>(imported))
       results.push_back(func);
 
     // If there is an alternate declaration, also look at it.
-    for (auto alternate : owner.Impl.getAlternateDecls(imported)) {
+    for (auto alternate : owner.getAlternateDecls(imported)) {
       if (auto func = dyn_cast<AbstractFunctionDecl>(alternate))
         results.push_back(func);
     }
@@ -2435,7 +2445,8 @@
 // ClangModule Implementation
 //===----------------------------------------------------------------------===//
 
-ClangModuleUnit::ClangModuleUnit(ModuleDecl &M, ClangImporter &owner,
+ClangModuleUnit::ClangModuleUnit(ModuleDecl &M,
+                                 ClangImporter::Implementation &owner,
                                  const clang::Module *clangModule)
   : LoadedFile(FileUnitKind::ClangModule, M), owner(owner),
     clangModule(clangModule) {
@@ -2468,7 +2479,7 @@
   if (!isTopLevel()) {
     // FIXME: Is this correct for submodules?
     auto topLevel = clangModule->getTopLevelModule();
-    auto wrapper = owner.Impl.getWrapperForModule(owner, topLevel);
+    auto wrapper = owner.getWrapperForModule(topLevel);
     return wrapper->getAdapterModule();
   }
 
@@ -2504,8 +2515,8 @@
   if (!clangModule) {
     // This is the special "imported headers" module.
     if (filter != ModuleDecl::ImportFilter::Private) {
-      imports.append(owner.Impl.ImportedHeaderExports.begin(),
-                     owner.Impl.ImportedHeaderExports.end());
+      imports.append(owner.ImportedHeaderExports.begin(),
+                     owner.ImportedHeaderExports.end());
     }
     return;
   }
@@ -2541,7 +2552,7 @@
   }
 
   for (auto importMod : imported) {
-    auto wrapper = owner.Impl.getWrapperForModule(owner, importMod);
+    auto wrapper = owner.getWrapperForModule(importMod);
 
     auto actualMod = wrapper->getAdapterModule();
     if (!actualMod) {
@@ -2550,8 +2561,7 @@
       auto importTopLevel = importMod->getTopLevelModule();
       if (importTopLevel != importMod &&
           importTopLevel != clangModule->getTopLevelModule()) {
-        auto topLevelWrapper = owner.Impl.getWrapperForModule(owner,
-                                                              importTopLevel);
+        auto topLevelWrapper = owner.getWrapperForModule(importTopLevel);
         imports.push_back({ ModuleDecl::AccessPathTy(),
                             topLevelWrapper->getParentModule() });
       }
@@ -2570,8 +2580,8 @@
 
   if (!clangModule) {
     // This is the special "imported headers" module.
-    imports.append(owner.Impl.ImportedHeaderExports.begin(),
-                   owner.Impl.ImportedHeaderExports.end());
+    imports.append(owner.ImportedHeaderExports.begin(),
+                   owner.ImportedHeaderExports.end());
     return;
   }
 
@@ -2608,7 +2618,7 @@
 
       // Don't continue looking through submodules of modules that have
       // overlays. The overlay might shadow things.
-      auto wrapper = owner.Impl.getWrapperForModule(owner, nextTopLevel);
+      auto wrapper = owner.getWrapperForModule(nextTopLevel);
       if (wrapper->getAdapterModule())
         continue;
     }
@@ -2626,7 +2636,7 @@
   }
 
   for (auto importMod : topLevelImported) {
-    auto wrapper = owner.Impl.getWrapperForModule(owner, importMod);
+    auto wrapper = owner.getWrapperForModule(importMod);
 
     auto actualMod = wrapper->getAdapterModule();
     if (!actualMod || actualMod == topLevelAdapter)
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
index bcacb55..6fcdebc 100644
--- a/lib/ClangImporter/ImportDecl.cpp
+++ b/lib/ClangImporter/ImportDecl.cpp
@@ -2041,10 +2041,11 @@
       decl->setImplicit();
     }
 
-    /// Create a typealias for the Swift 2 name of a Clang type declaration.
-    Decl *importSwift2TypeAlias(const clang::NamedDecl *decl,
-                                ImportedName swift2Name,
-                                ImportedName correctSwiftName);
+    /// Create a typealias for the name of a Clang type declaration in an
+    /// alternate version of Swift.
+    Decl *importCompatibilityTypeAlias(const clang::NamedDecl *decl,
+                                       ImportedName compatibilityName,
+                                       ImportedName correctSwiftName);
 
     /// Create a swift_newtype struct corresponding to a typedef. Returns
     /// nullptr if unable.
@@ -2062,7 +2063,8 @@
       // If we've been asked to produce a Swift 2 stub, handle it via a
       // typealias.
       if (correctSwiftName)
-        return importSwift2TypeAlias(Decl, importedName, *correctSwiftName);
+        return importCompatibilityTypeAlias(Decl, importedName,
+                                            *correctSwiftName);
 
       Type SwiftType;
       if (Decl->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
@@ -2277,7 +2279,8 @@
       // If we've been asked to produce a Swift 2 stub, handle it via a
       // typealias.
       if (correctSwiftName)
-        return importSwift2TypeAlias(decl, importedName, *correctSwiftName);
+        return importCompatibilityTypeAlias(decl, importedName,
+                                            *correctSwiftName);
 
       auto dc =
           Impl.importDeclContextOf(decl, importedName.getEffectiveContext());
@@ -2693,7 +2696,8 @@
       // If we've been asked to produce a Swift 2 stub, handle it via a
       // typealias.
       if (correctSwiftName)
-        return importSwift2TypeAlias(decl, importedName, *correctSwiftName);
+        return importCompatibilityTypeAlias(decl, importedName,
+                                            *correctSwiftName);
 
       auto dc =
           Impl.importDeclContextOf(decl, importedName.getEffectiveContext());
@@ -3873,7 +3877,7 @@
       SmallVector<TypeLoc, 4> inheritedTypes;
       importObjCProtocols(result, decl->getReferencedProtocols(),
                           inheritedTypes);
-      result->setValidated();
+      result->setValidationStarted();
       result->setInherited(Impl.SwiftContext.AllocateCopy(inheritedTypes));
       result->setCheckedInheritanceClause();
       result->setMemberLoader(&Impl, 0);
@@ -3957,7 +3961,8 @@
       // If we've been asked to produce a Swift 2 stub, handle it via a
       // typealias.
       if (correctSwiftName)
-        return importSwift2TypeAlias(decl, importedName, *correctSwiftName);
+        return importCompatibilityTypeAlias(decl, importedName,
+                                            *correctSwiftName);
 
       Identifier name = importedName.getDeclName().getBaseName();
 
@@ -4092,7 +4097,8 @@
       // If we've been asked to produce a Swift 2 stub, handle it via a
       // typealias.
       if (correctSwiftName)
-        return importSwift2TypeAlias(decl, importedName, *correctSwiftName);
+        return importCompatibilityTypeAlias(decl, importedName,
+                                            *correctSwiftName);
 
       auto name = importedName.getDeclName().getBaseName();
 
@@ -4630,9 +4636,10 @@
   return theClass;
 }
 
-Decl *SwiftDeclConverter::importSwift2TypeAlias(const clang::NamedDecl *decl,
-                                                ImportedName swift2Name,
-                                                ImportedName correctSwiftName) {
+Decl *SwiftDeclConverter::importCompatibilityTypeAlias(
+    const clang::NamedDecl *decl,
+    ImportedName compatibilityName,
+    ImportedName correctSwiftName) {
   // Import the referenced declaration. If it doesn't come in as a type,
   // we don't care.
   auto importedDecl = Impl.importDecl(decl, getActiveSwiftVersion());
@@ -4665,19 +4672,14 @@
 
   // Create the type alias.
   auto alias = Impl.createDeclWithClangNode<TypeAliasDecl>(
-      decl,
-      Accessibility::Public, Impl.importSourceLoc(decl->getLocStart()),
-      SourceLoc(), swift2Name.getDeclName().getBaseName(),
-      Impl.importSourceLoc(decl->getLocation()),
-      genericParams, dc);
+      decl, Accessibility::Public, Impl.importSourceLoc(decl->getLocStart()),
+      SourceLoc(), compatibilityName.getDeclName().getBaseName(),
+      Impl.importSourceLoc(decl->getLocation()), genericParams, dc);
   alias->setUnderlyingType(underlyingType);
   alias->setGenericEnvironment(genericEnv);
 
-  // Record that this is the Swift 2 version of this declaration.
-  Impl.ImportedDecls[{decl->getCanonicalDecl(), ImportNameVersion::Swift2}] =
-      alias;
-
-  // Mark it as the Swift 2 variant.
+  // Record that this is the official version of this declaration.
+  Impl.ImportedDecls[{decl->getCanonicalDecl(), getVersion()}] = alias;
   markAsVariant(alias, correctSwiftName);
   return alias;
 }
@@ -6516,7 +6518,7 @@
   if (!clangDecl)
     return "";
 
-  auto importedName = importFullName(clangDecl, ImportNameVersion::Swift3);
+  auto importedName = importFullName(clangDecl, CurrentVersion);
   if (!importedName)
     return "";
 
@@ -6758,7 +6760,7 @@
     Result = converter.Visit(ClangDecl);
     HadForwardDeclaration = converter.hadForwardDeclaration();
   }
-  if (!Result && version > ImportNameVersion::Swift2) {
+  if (!Result && version == CurrentVersion) {
     // If we couldn't import this Objective-C entity, determine
     // whether it was a required member of a protocol.
     bool hasMissingRequiredMember = false;
@@ -7202,7 +7204,7 @@
   auto swiftTyLoc = TypeLoc::withoutLoc(nominal->getDeclaredType());
   auto ext = ExtensionDecl::create(SwiftContext, SourceLoc(), swiftTyLoc, {},
                                    getClangModuleForDecl(decl), nullptr);
-  ext->setValidated();
+  ext->setValidationStarted();
   ext->setCheckedInheritanceClause();
   ext->setMemberLoader(this, reinterpret_cast<uintptr_t>(declSubmodule));
 
@@ -7568,7 +7570,7 @@
 
 Identifier
 ClangImporter::getEnumConstantName(const clang::EnumConstantDecl *enumConstant){
-  return Impl.importFullName(enumConstant, ImportNameVersion::Swift3)
+  return Impl.importFullName(enumConstant, Impl.CurrentVersion)
       .getDeclName()
       .getBaseName();
 }
diff --git a/lib/ClangImporter/ImportMacro.cpp b/lib/ClangImporter/ImportMacro.cpp
index 60812f1..25966a1 100644
--- a/lib/ClangImporter/ImportMacro.cpp
+++ b/lib/ClangImporter/ImportMacro.cpp
@@ -51,9 +51,7 @@
   // ClangModule.
   auto *M = maybeModule.getValue()->getTopLevelModule();
 
-  auto &importer =
-    static_cast<ClangImporter &>(*SwiftContext.getClangModuleLoader());
-  return getWrapperForModule(importer, M);
+  return getWrapperForModule(M);
 }
 
 template <typename T = clang::Expr>
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
index 841c171..36e4dfa 100644
--- a/lib/ClangImporter/ImportType.cpp
+++ b/lib/ClangImporter/ImportType.cpp
@@ -1626,7 +1626,7 @@
     }
 
     // Figure out the name for this parameter.
-    Identifier bodyName = importFullName(param, ImportNameVersion::Swift3)
+    Identifier bodyName = importFullName(param, CurrentVersion)
                               .getDeclName()
                               .getBaseName();
 
@@ -2037,7 +2037,7 @@
     }
 
     // Figure out the name for this parameter.
-    Identifier bodyName = importFullName(param, ImportNameVersion::Swift3)
+    Identifier bodyName = importFullName(param, CurrentVersion)
                               .getDeclName()
                               .getBaseName();
 
@@ -2194,7 +2194,7 @@
 
   } else {
     const clang::ParmVarDecl *param = clangDecl->parameters().front();
-    ImportedName fullBodyName = importFullName(param,ImportNameVersion::Swift3);
+    ImportedName fullBodyName = importFullName(param, CurrentVersion);
     Identifier bodyName = fullBodyName.getDeclName().getBaseName();
     SourceLoc nameLoc = importSourceLoc(param->getLocation());
     Identifier argLabel = functionName.getDeclName().getArgumentNames().front();
diff --git a/lib/ClangImporter/ImporterImpl.h b/lib/ClangImporter/ImporterImpl.h
index 5447bd4..72b3fc6 100644
--- a/lib/ClangImporter/ImporterImpl.h
+++ b/lib/ClangImporter/ImporterImpl.h
@@ -275,6 +275,7 @@
 
   bool IsReadingBridgingPCH;
   llvm::SmallVector<clang::serialization::SubmoduleID, 2> PCHImportedSubmodules;
+  llvm::SmallVector<const clang::Module*, 2> DeferredHeaderImports;
 
   const Version CurrentVersion;
 
@@ -815,13 +816,15 @@
 
   /// \brief Retrieves the Swift wrapper for the given Clang module, creating
   /// it if necessary.
-  ClangModuleUnit *getWrapperForModule(ClangImporter &importer,
-                                       const clang::Module *underlying);
+  ClangModuleUnit *getWrapperForModule(const clang::Module *underlying);
 
   /// \brief Constructs a Swift module for the given Clang module.
-  ModuleDecl *finishLoadingClangModule(ClangImporter &importer,
-                                   const clang::Module *clangModule,
-                                   bool preferAdapter);
+  ModuleDecl *finishLoadingClangModule(const clang::Module *clangModule,
+                                       bool preferAdapter);
+
+  /// \brief Call finishLoadingClangModule on each deferred import collected
+  /// while scanning a bridging header or PCH.
+  void handleDeferredImports();
 
   /// \brief Retrieve the named Swift type, e.g., Int32.
   ///
@@ -1105,6 +1108,8 @@
     D->setAccessibility(access);
     if (auto ASD = dyn_cast<AbstractStorageDecl>(D))
       ASD->setSetterAccessibility(access);
+    // All imported decls are constructed fully validated.
+    D->setValidationStarted();
     return D;
   }
 
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
index 98af405..6fbb2a2 100644
--- a/lib/Frontend/CompilerInvocation.cpp
+++ b/lib/Frontend/CompilerInvocation.cpp
@@ -864,6 +864,7 @@
   
   Opts.EnableASTScopeLookup |= Args.hasArg(OPT_enable_astscope_lookup);
   Opts.DebugConstraintSolver |= Args.hasArg(OPT_debug_constraints);
+  Opts.EnableConstraintPropagation |= Args.hasArg(OPT_propagate_constraints);
   Opts.IterativeTypeChecker |= Args.hasArg(OPT_iterative_type_checker);
   Opts.DebugGenericSignatures |= Args.hasArg(OPT_debug_generic_signatures);
 
diff --git a/lib/IDE/SyntaxModel.cpp b/lib/IDE/SyntaxModel.cpp
index e19700c..05936b5 100644
--- a/lib/IDE/SyntaxModel.cpp
+++ b/lib/IDE/SyntaxModel.cpp
@@ -916,7 +916,7 @@
       if (Clause.Cond && !annotateIfConfigConditionIdentifiers(Clause.Cond))
         return false;
 
-      for (auto *D : Clause.Members)
+      for (auto *D : Clause.Elements)
         if (D->walk(*this))
           return false;
     }
diff --git a/lib/IRGen/DebugTypeInfo.cpp b/lib/IRGen/DebugTypeInfo.cpp
index 47d4de1..551ea82 100644
--- a/lib/IRGen/DebugTypeInfo.cpp
+++ b/lib/IRGen/DebugTypeInfo.cpp
@@ -90,7 +90,7 @@
                                        Alignment align) {
   // Prefer the original, potentially sugared version of the type if
   // the type hasn't been mucked with by an optimization pass.
-  auto LowTy = GV->getLoweredType().getSwiftType();
+  auto LowTy = GV->getLoweredType().getSwiftRValueType();
   auto *Type = LowTy.getPointer();
   if (auto *Decl = GV->getDecl()) {
     auto DeclType =
diff --git a/lib/IRGen/GenCast.cpp b/lib/IRGen/GenCast.cpp
index b48f544..472f258 100644
--- a/lib/IRGen/GenCast.cpp
+++ b/lib/IRGen/GenCast.cpp
@@ -145,8 +145,14 @@
   llvm::Constant *castFn;
 
   // Get the best known type information about the destination type.
-  auto destClass = toType.getSwiftRValueType().getClassBound();
-  assert(destClass || toType.is<ArchetypeType>());
+  ClassDecl *destClass = nullptr;
+  if (auto archetypeTy = toType.getAs<ArchetypeType>()) {
+    if (auto superclassTy = archetypeTy->getSuperclass())
+      destClass = superclassTy->getClassOrBoundGenericClass();
+  } else {
+    destClass = toType.getClassOrBoundGenericClass();
+    assert(destClass != nullptr);
+  }
 
   // If the destination type is known to have a Swift-compatible
   // implementation, use the most specific entrypoint.
diff --git a/lib/IRGen/GenClass.cpp b/lib/IRGen/GenClass.cpp
index 2d5d794..64cacf3 100644
--- a/lib/IRGen/GenClass.cpp
+++ b/lib/IRGen/GenClass.cpp
@@ -795,7 +795,7 @@
 
   // Retain 'self' if necessary.
   if (fnType->getParameters()[0].isConsumed()) {
-    IGF.emitNativeStrongRetain(selfValue);
+    IGF.emitNativeStrongRetain(selfValue, IGF.getDefaultAtomicity());
   }
 
   // Adjust down to the defining subclass type if necessary.
diff --git a/lib/IRGen/GenEnum.cpp b/lib/IRGen/GenEnum.cpp
index 14732d8..f925bcc 100644
--- a/lib/IRGen/GenEnum.cpp
+++ b/lib/IRGen/GenEnum.cpp
@@ -1281,7 +1281,7 @@
       assert(TIK >= Loadable);
       Explosion tmp;
       loadAsTake(IGF, addr, tmp);
-      copy(IGF, tmp, e, Atomicity::Atomic);
+      copy(IGF, tmp, e, IGF.getDefaultAtomicity());
     }
 
     void assign(IRGenFunction &IGF, Explosion &e, Address addr) const override {
@@ -1291,7 +1291,7 @@
         loadAsTake(IGF, addr, old);
       initialize(IGF, e, addr);
       if (!isPOD(ResilienceExpansion::Maximal))
-        consume(IGF, old, Atomicity::Atomic);
+        consume(IGF, old, IGF.getDefaultAtomicity());
     }
 
     void initialize(IRGenFunction &IGF, Explosion &e, Address addr)
@@ -1503,7 +1503,7 @@
         Explosion payloadCopy;
         auto &loadableTI = getLoadablePayloadTypeInfo();
         loadableTI.unpackFromEnumPayload(IGF, payload, payloadValue, 0);
-        loadableTI.copy(IGF, payloadValue, payloadCopy, Atomicity::Atomic);
+        loadableTI.copy(IGF, payloadValue, payloadCopy, IGF.getDefaultAtomicity());
         (void)payloadCopy.claimAll(); // FIXME: repack if not bit-identical
       }
 
@@ -1536,7 +1536,7 @@
         Explosion payloadValue;
         auto &loadableTI = getLoadablePayloadTypeInfo();
         loadableTI.unpackFromEnumPayload(IGF, payload, payloadValue, 0);
-        loadableTI.consume(IGF, payloadValue, Atomicity::Atomic);
+        loadableTI.consume(IGF, payloadValue, IGF.getDefaultAtomicity());
       }
 
       IGF.Builder.CreateBr(endBB);
@@ -2208,7 +2208,7 @@
                                  llvm::Value *ptr) const {
       switch (CopyDestroyKind) {
       case NullableRefcounted:
-        IGF.emitStrongRetain(ptr, Refcounting, Atomicity::Atomic);
+        IGF.emitStrongRetain(ptr, Refcounting, IGF.getDefaultAtomicity());
         return;
       case POD:
       case Normal:
@@ -2232,7 +2232,7 @@
                                   llvm::Value *ptr) const {
       switch (CopyDestroyKind) {
       case NullableRefcounted:
-        IGF.emitStrongRelease(ptr, Refcounting, Atomicity::Atomic);
+        IGF.emitStrongRelease(ptr, Refcounting, IGF.getDefaultAtomicity());
         return;
       case POD:
       case Normal:
@@ -2917,7 +2917,7 @@
         projectPayloadValue(IGF, parts.payload, tagIndex, lti, value);
 
         Explosion tmp;
-        lti.copy(IGF, value, tmp, Atomicity::Atomic);
+        lti.copy(IGF, value, tmp, IGF.getDefaultAtomicity());
         (void)tmp.claimAll(); // FIXME: repack if not bit-identical
       });
 
@@ -2942,7 +2942,7 @@
         Explosion value;
         projectPayloadValue(IGF, parts.payload, tagIndex, lti, value);
 
-        lti.consume(IGF, value, Atomicity::Atomic);
+        lti.consume(IGF, value, IGF.getDefaultAtomicity());
       });
 
       IGF.Builder.CreateRetVoid();
@@ -3119,7 +3119,7 @@
                                  llvm::Value *ptr) const {
       switch (CopyDestroyKind) {
       case TaggedRefcounted:
-        IGF.emitStrongRetain(ptr, Refcounting, Atomicity::Atomic);
+        IGF.emitStrongRetain(ptr, Refcounting, IGF.getDefaultAtomicity());
         return;
       case POD:
       case BitwiseTakable:
@@ -3145,7 +3145,7 @@
                                   llvm::Value *ptr) const {
       switch (CopyDestroyKind) {
       case TaggedRefcounted:
-        IGF.emitStrongRelease(ptr, Refcounting, Atomicity::Atomic);
+        IGF.emitStrongRelease(ptr, Refcounting, IGF.getDefaultAtomicity());
         return;
       case POD:
       case BitwiseTakable:
@@ -4060,7 +4060,7 @@
 
           loadAsTake(IGF, dest, tmpOld);
           initialize(IGF, tmpSrc, dest);
-          consume(IGF, tmpOld, Atomicity::Atomic);
+          consume(IGF, tmpOld, IGF.getDefaultAtomicity());
           return;
         }
 
@@ -4254,7 +4254,7 @@
         if (TI->isLoadable()) {
           Explosion tmp;
           loadAsTake(IGF, addr, tmp);
-          consume(IGF, tmp, Atomicity::Atomic);
+          consume(IGF, tmp, IGF.getDefaultAtomicity());
           return;
         }
 
diff --git a/lib/IRGen/GenExistential.cpp b/lib/IRGen/GenExistential.cpp
index cc16f51..b51b45e 100644
--- a/lib/IRGen/GenExistential.cpp
+++ b/lib/IRGen/GenExistential.cpp
@@ -750,7 +750,7 @@
                   Explosion &out) const override {
     // Load the instance pointer, which is unknown-refcounted.
     llvm::Value *instance = asDerived().loadValue(IGF, address);
-    asDerived().emitValueRetain(IGF, instance, Atomicity::Atomic);
+    asDerived().emitValueRetain(IGF, instance, IGF.getDefaultAtomicity());
     out.add(instance);
 
     // Load the witness table pointers.
@@ -772,7 +772,7 @@
     Address instanceAddr = asDerived().projectValue(IGF, address);
     llvm::Value *old = IGF.Builder.CreateLoad(instanceAddr);
     IGF.Builder.CreateStore(e.claimNext(), instanceAddr);
-    asDerived().emitValueRelease(IGF, old, Atomicity::Atomic);
+    asDerived().emitValueRelease(IGF, old, IGF.getDefaultAtomicity());
 
     // Store the witness table pointers.
     asDerived().emitStoreOfTables(IGF, e, address);
@@ -821,7 +821,7 @@
 
   void destroy(IRGenFunction &IGF, Address addr, SILType T) const override {
     llvm::Value *value = asDerived().loadValue(IGF, addr);
-    asDerived().emitValueRelease(IGF, value, Atomicity::Atomic);
+    asDerived().emitValueRelease(IGF, value, IGF.getDefaultAtomicity());
   }
 
   void packIntoEnumPayload(IRGenFunction &IGF,
@@ -937,12 +937,12 @@
 
   void emitValueRetain(IRGenFunction &IGF, llvm::Value *value,
                        Atomicity atomicity) const {
-    IGF.emitUnownedRetain(value, Refcounting);
+    IGF.emitUnownedRetain(value, Refcounting, atomicity);
   }
 
   void emitValueRelease(IRGenFunction &IGF, llvm::Value *value,
                         Atomicity atomicity) const {
-    IGF.emitUnownedRelease(value, Refcounting);
+    IGF.emitUnownedRelease(value, Refcounting, atomicity);
   }
 
   void emitValueFixLifetime(IRGenFunction &IGF, llvm::Value *value) const {
@@ -1077,24 +1077,29 @@
     (void)e.claim(getNumStoredProtocols());
   }
 
-  void strongRetainUnowned(IRGenFunction &IGF, Explosion &e) const override {
-    IGF.emitStrongRetainUnowned(e.claimNext(), Refcounting);
+  void strongRetainUnowned(IRGenFunction &IGF, Explosion &e,
+                           Atomicity atomicity) const override {
+    IGF.emitStrongRetainUnowned(e.claimNext(), Refcounting, atomicity);
     (void)e.claim(getNumStoredProtocols());
   }
 
   void strongRetainUnownedRelease(IRGenFunction &IGF,
-                                  Explosion &e) const override {
-    IGF.emitStrongRetainAndUnownedRelease(e.claimNext(), Refcounting);
+                                  Explosion &e,
+                                  Atomicity atomicity) const override {
+    IGF.emitStrongRetainAndUnownedRelease(e.claimNext(), Refcounting,
+                                          atomicity);
     (void)e.claim(getNumStoredProtocols());
   }
 
-  void unownedRetain(IRGenFunction &IGF, Explosion &e) const override {
-    IGF.emitUnownedRetain(e.claimNext(), Refcounting);
+  void unownedRetain(IRGenFunction &IGF, Explosion &e,
+                     Atomicity atomicity) const override {
+    IGF.emitUnownedRetain(e.claimNext(), Refcounting, atomicity);
     (void)e.claim(getNumStoredProtocols());
   }
 
-  void unownedRelease(IRGenFunction &IGF, Explosion &e) const override {
-    IGF.emitUnownedRelease(e.claimNext(), Refcounting);
+  void unownedRelease(IRGenFunction &IGF, Explosion &e,
+                      Atomicity atomicity) const override {
+    IGF.emitUnownedRelease(e.claimNext(), Refcounting, atomicity);
     (void)e.claim(getNumStoredProtocols());
   }
 
diff --git a/lib/IRGen/GenFunc.cpp b/lib/IRGen/GenFunc.cpp
index ae977bc..e3b66ff 100644
--- a/lib/IRGen/GenFunc.cpp
+++ b/lib/IRGen/GenFunc.cpp
@@ -252,7 +252,7 @@
       Address dataAddr = projectData(IGF, address);
       auto data = IGF.Builder.CreateLoad(dataAddr);
       if (!isPOD(ResilienceExpansion::Maximal))
-        IGF.emitNativeStrongRetain(data);
+        IGF.emitNativeStrongRetain(data, IGF.getDefaultAtomicity());
       e.add(data);
     }
 
@@ -333,20 +333,24 @@
         IGF.emitNativeStrongRelease(context, atomicity);
     }
 
-    void strongRetainUnowned(IRGenFunction &IGF, Explosion &e) const override {
+    void strongRetainUnowned(IRGenFunction &IGF, Explosion &e,
+                             Atomicity atomicity) const override {
       llvm_unreachable("unowned references to functions are not supported");
     }
 
     void strongRetainUnownedRelease(IRGenFunction &IGF,
-                                    Explosion &e) const override {
-      llvm_unreachable("unowned references to functions are not supported");
-    }
-    
-    void unownedRetain(IRGenFunction &IGF, Explosion &e) const override {
+                                    Explosion &e,
+                                    Atomicity atomicity) const override {
       llvm_unreachable("unowned references to functions are not supported");
     }
 
-    void unownedRelease(IRGenFunction &IGF, Explosion &e) const override {
+    void unownedRetain(IRGenFunction &IGF, Explosion &e,
+                       Atomicity atomicity) const override {
+      llvm_unreachable("unowned references to functions are not supported");
+    }
+
+    void unownedRelease(IRGenFunction &IGF, Explosion &e,
+                        Atomicity atomicity) const override {
       llvm_unreachable("unowned references to functions are not supported");
     }
 
@@ -373,7 +377,7 @@
     void destroy(IRGenFunction &IGF, Address addr, SILType T) const override {
       auto data = IGF.Builder.CreateLoad(projectData(IGF, addr));
       if (!isPOD(ResilienceExpansion::Maximal))
-        IGF.emitNativeStrongRelease(data);
+        IGF.emitNativeStrongRelease(data, IGF.getDefaultAtomicity());
     }
 
     void packIntoEnumPayload(IRGenFunction &IGF,
@@ -555,6 +559,7 @@
       
   case SILFunctionType::Representation::Thin:
   case SILFunctionType::Representation::Method:
+  case SILFunctionType::Representation::WitnessMethod:
   case SILFunctionType::Representation::ObjCMethod:
   case SILFunctionType::Representation::CFunctionPointer:
   case SILFunctionType::Representation::Closure:
@@ -576,19 +581,6 @@
                                 std::move(spareBits),
                                 IsNotPOD);
   }
-  // Witness method values carry a reference to their originating witness table
-  // as context.
-  case SILFunctionType::Representation::WitnessMethod: {
-    SpareBitVector spareBits;
-    spareBits.append(IGM.getFunctionPointerSpareBits());
-    spareBits.append(IGM.getWitnessTablePtrSpareBits());
-    return FuncTypeInfo::create(CanSILFunctionType(T),
-                                IGM.WitnessFunctionPairTy,
-                                IGM.getPointerSize() * 2,
-                                IGM.getPointerAlignment(),
-                                std::move(spareBits),
-                                IsPOD);
-  }
   }
   llvm_unreachable("bad function type representation");
 }
@@ -911,7 +903,7 @@
     switch (argConvention) {
     case ParameterConvention::Indirect_In:
     case ParameterConvention::Direct_Owned:
-      if (!consumesContext) subIGF.emitNativeStrongRetain(rawData);
+      if (!consumesContext) subIGF.emitNativeStrongRetain(rawData, subIGF.getDefaultAtomicity());
       break;
 
     case ParameterConvention::Indirect_In_Guaranteed:
@@ -919,7 +911,7 @@
       dependsOnContextLifetime = true;
       if (outType->getCalleeConvention() ==
             ParameterConvention::Direct_Unowned) {
-        subIGF.emitNativeStrongRetain(rawData);
+        subIGF.emitNativeStrongRetain(rawData, subIGF.getDefaultAtomicity());
         consumesContext = true;
       }
       break;
@@ -1060,7 +1052,7 @@
     // so we can tail call. The safety of this assumes that neither this release
     // nor any of the loads can throw.
     if (consumesContext && !dependsOnContextLifetime && rawData)
-      subIGF.emitNativeStrongRelease(rawData);
+      subIGF.emitNativeStrongRelease(rawData, subIGF.getDefaultAtomicity());
   }
 
   // Derive the callee function pointer.  If we found a function
@@ -1157,7 +1149,7 @@
   
   // If the parameters depended on the context, consume the context now.
   if (rawData && consumesContext && dependsOnContextLifetime)
-    subIGF.emitNativeStrongRelease(rawData);
+    subIGF.emitNativeStrongRelease(rawData, subIGF.getDefaultAtomicity());
   
   // FIXME: Reabstract the result value as substituted.
 
@@ -1224,24 +1216,20 @@
     argValTypes.push_back(argType);
     argConventions.push_back(param.getConvention());
     
-    CanType argLoweringTy;
+    auto argLoweringTy = argType.getSwiftRValueType();
     switch (param.getConvention()) {
     // Capture value parameters by value, consuming them.
     case ParameterConvention::Direct_Owned:
     case ParameterConvention::Direct_Unowned:
     case ParameterConvention::Direct_Guaranteed:
-      argLoweringTy = argType.getSwiftRValueType();
-      break;
-      
     case ParameterConvention::Indirect_In:
     case ParameterConvention::Indirect_In_Guaranteed:
-      argLoweringTy = argType.getSwiftRValueType();
       break;
       
     // Capture inout parameters by pointer.
     case ParameterConvention::Indirect_Inout:
     case ParameterConvention::Indirect_InoutAliasable:
-      argLoweringTy = argType.getSwiftType();
+      argLoweringTy = CanInOutType::get(argLoweringTy);
       break;
     }
     
diff --git a/lib/IRGen/GenHeap.cpp b/lib/IRGen/GenHeap.cpp
index 0e6f309..7f36897 100644
--- a/lib/IRGen/GenHeap.cpp
+++ b/lib/IRGen/GenHeap.cpp
@@ -426,12 +426,12 @@
 
     void emitScalarRetain(IRGenFunction &IGF, llvm::Value *value,
                           Atomicity atomicity) const {
-      IGF.emitNativeUnownedRetain(value);
+      IGF.emitNativeUnownedRetain(value, atomicity);
     }
 
     void emitScalarRelease(IRGenFunction &IGF, llvm::Value *value,
                            Atomicity atomicity) const {
-      IGF.emitNativeUnownedRelease(value);
+      IGF.emitNativeUnownedRelease(value, atomicity);
     }
 
     void emitScalarFixLifetime(IRGenFunction &IGF, llvm::Value *value) const {
@@ -975,7 +975,7 @@
   Builder.CreateStore(newValue, address);
 
   // Release the old value.
-  emitNativeStrongRelease(oldValue);
+  emitNativeStrongRelease(oldValue, getDefaultAtomicity());
 }
 
 /// Emit an initialize of a live value to the given retaining variable.
@@ -1106,31 +1106,35 @@
 #undef DEFINE_BINARY_OPERATION
 
 void IRGenFunction::emitUnownedRetain(llvm::Value *value,
-                                      ReferenceCounting style) {
+                                      ReferenceCounting style,
+                                      Atomicity atomicity) {
   assert(style == ReferenceCounting::Native &&
          "only native references support scalar unowned reference-counting");
-  emitNativeUnownedRetain(value);
+  emitNativeUnownedRetain(value, atomicity);
 }
 
 void IRGenFunction::emitUnownedRelease(llvm::Value *value,
-                                       ReferenceCounting style) {
+                                       ReferenceCounting style,
+                                       Atomicity atomicity) {
   assert(style == ReferenceCounting::Native &&
          "only native references support scalar unowned reference-counting");
-  emitNativeUnownedRelease(value);
+  emitNativeUnownedRelease(value, atomicity);
 }
 
 void IRGenFunction::emitStrongRetainUnowned(llvm::Value *value,
-                                            ReferenceCounting style) {
+                                            ReferenceCounting style,
+                                            Atomicity atomicity) {
   assert(style == ReferenceCounting::Native &&
          "only native references support scalar unowned reference-counting");
-  emitNativeStrongRetainUnowned(value);
+  emitNativeStrongRetainUnowned(value, atomicity);
 }
 
 void IRGenFunction::emitStrongRetainAndUnownedRelease(llvm::Value *value,
-                                                      ReferenceCounting style) {
+                                                      ReferenceCounting style,
+                                                      Atomicity atomicity) {
   assert(style == ReferenceCounting::Native &&
          "only native references support scalar unowned reference-counting");
-  emitNativeStrongRetainAndUnownedRelease(value);
+  emitNativeStrongRetainAndUnownedRelease(value, atomicity);
 }
 
 /// Emit a release of a live value.
@@ -1154,7 +1158,7 @@
   value = Builder.CreateBitCast(value, IGM.RefCountedPtrTy);
   dest = Builder.CreateStructGEP(dest, 0, Size(0));
   Builder.CreateStore(value, dest);
-  emitNativeUnownedRetain(value);
+  emitNativeUnownedRetain(value, getDefaultAtomicity());
 }
 
 void IRGenFunction::emitNativeUnownedAssign(llvm::Value *value,
@@ -1163,8 +1167,8 @@
   dest = Builder.CreateStructGEP(dest, 0, Size(0));
   auto oldValue = Builder.CreateLoad(dest);
   Builder.CreateStore(value, dest);
-  emitNativeUnownedRetain(value);
-  emitNativeUnownedRelease(oldValue);
+  emitNativeUnownedRetain(value, getDefaultAtomicity());
+  emitNativeUnownedRelease(oldValue, getDefaultAtomicity());
 }
 
 llvm::Value *IRGenFunction::emitNativeUnownedLoadStrong(Address src,
@@ -1172,7 +1176,7 @@
   src = Builder.CreateStructGEP(src, 0, Size(0));
   llvm::Value *value = Builder.CreateLoad(src);
   value = Builder.CreateBitCast(value, type);
-  emitNativeStrongRetainUnowned(value);
+  emitNativeStrongRetainUnowned(value, getDefaultAtomicity());
   return value;
 }
 
@@ -1181,14 +1185,14 @@
   src = Builder.CreateStructGEP(src, 0, Size(0));
   llvm::Value *value = Builder.CreateLoad(src);
   value = Builder.CreateBitCast(value, type);
-  emitNativeStrongRetainAndUnownedRelease(value);
+  emitNativeStrongRetainAndUnownedRelease(value, getDefaultAtomicity());
   return value;
 }
 
 void IRGenFunction::emitNativeUnownedDestroy(Address ref) {
   ref = Builder.CreateStructGEP(ref, 0, Size(0));
   llvm::Value *value = Builder.CreateLoad(ref);
-  emitNativeUnownedRelease(value);
+  emitNativeUnownedRelease(value, getDefaultAtomicity());
 }
 
 void IRGenFunction::emitNativeUnownedCopyInit(Address dest, Address src) {
@@ -1196,7 +1200,7 @@
   dest = Builder.CreateStructGEP(dest, 0, Size(0));
   llvm::Value *newValue = Builder.CreateLoad(src);
   Builder.CreateStore(newValue, dest);
-  emitNativeUnownedRetain(newValue);
+  emitNativeUnownedRetain(newValue, getDefaultAtomicity());
 }
 
 void IRGenFunction::emitNativeUnownedTakeInit(Address dest, Address src) {
@@ -1212,8 +1216,8 @@
   llvm::Value *newValue = Builder.CreateLoad(src);
   llvm::Value *oldValue = Builder.CreateLoad(dest);
   Builder.CreateStore(newValue, dest);
-  emitNativeUnownedRetain(newValue);
-  emitNativeUnownedRelease(oldValue);
+  emitNativeUnownedRetain(newValue, getDefaultAtomicity());
+  emitNativeUnownedRelease(oldValue, getDefaultAtomicity());
 }
 
 void IRGenFunction::emitNativeUnownedTakeAssign(Address dest, Address src) {
@@ -1222,7 +1226,7 @@
   llvm::Value *newValue = Builder.CreateLoad(src);
   llvm::Value *oldValue = Builder.CreateLoad(dest);
   Builder.CreateStore(newValue, dest);
-  emitNativeUnownedRelease(oldValue);
+  emitNativeUnownedRelease(oldValue, getDefaultAtomicity());
 }
 
 llvm::Constant *IRGenModule::getFixLifetimeFn() {
@@ -1646,9 +1650,11 @@
 }
 
 #define DEFINE_VALUE_OP(ID)                                           \
-void IRGenFunction::emit##ID(llvm::Value *value) {                    \
+void IRGenFunction::emit##ID(llvm::Value *value, Atomicity atomicity) { \
   if (doesNotRequireRefCounting(value)) return;                       \
-  emitUnaryRefCountCall(*this, IGM.get##ID##Fn(), value);             \
+  emitUnaryRefCountCall(*this, (atomicity == Atomicity::Atomic)       \
+                        ? IGM.get##ID##Fn() : IGM.getNonAtomic##ID##Fn(), \
+                        value);                                       \
 }
 #define DEFINE_ADDR_OP(ID)                                            \
 void IRGenFunction::emit##ID(Address addr) {                          \
diff --git a/lib/IRGen/GenObjC.cpp b/lib/IRGen/GenObjC.cpp
index e16bbad..bb659fc 100644
--- a/lib/IRGen/GenObjC.cpp
+++ b/lib/IRGen/GenObjC.cpp
@@ -909,7 +909,7 @@
       subIGF.emitObjCAutoreleaseCall(self);
     }
     // Release the context.
-    subIGF.emitNativeStrongRelease(context);
+    subIGF.emitNativeStrongRelease(context, subIGF.getDefaultAtomicity());
   };
   
    // Emit the call and produce the return value.
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
index b559b52..1102627 100644
--- a/lib/IRGen/GenProto.cpp
+++ b/lib/IRGen/GenProto.cpp
@@ -2259,10 +2259,23 @@
   if (concreteConformance->getProtocol() != proto) {
     concreteConformance = concreteConformance->getInheritedConformance(proto);
   }
+
+  // Check immediately for an existing cache entry.
+  auto wtable = IGF.tryGetLocalTypeData(
+    srcType,
+    LocalTypeDataKind::forConcreteProtocolWitnessTable(concreteConformance));
+  if (wtable) return wtable;
+
   auto &protoI = IGF.IGM.getProtocolInfo(proto);
   auto &conformanceI =
     protoI.getConformance(IGF.IGM, proto, concreteConformance);
-  return conformanceI.getTable(IGF, srcType, srcMetadataCache);
+  wtable = conformanceI.getTable(IGF, srcType, srcMetadataCache);
+
+  IGF.setScopedLocalTypeData(
+    srcType,
+    LocalTypeDataKind::forConcreteProtocolWitnessTable(concreteConformance),
+    wtable);
+  return wtable;
 }
 
 /// Emit the witness table references required for the given type
@@ -2747,7 +2760,6 @@
   
   // Build the value.
   out.add(witness);
-  out.add(wtable);
 }
 
 llvm::FunctionType *IRGenModule::getAssociatedTypeMetadataAccessFunctionTy() {
diff --git a/lib/IRGen/GenRecord.h b/lib/IRGen/GenRecord.h
index ba1efd6..2b7a803 100644
--- a/lib/IRGen/GenRecord.h
+++ b/lib/IRGen/GenRecord.h
@@ -489,14 +489,14 @@
             Explosion &dest, Atomicity atomicity) const override {
     for (auto &field : getFields())
       cast<LoadableTypeInfo>(field.getTypeInfo())
-          .copy(IGF, src, dest, Atomicity::Atomic);
+          .copy(IGF, src, dest, atomicity);
   }
 
   void consume(IRGenFunction &IGF, Explosion &src,
                Atomicity atomicity) const override {
     for (auto &field : getFields())
       cast<LoadableTypeInfo>(field.getTypeInfo())
-          .consume(IGF, src, Atomicity::Atomic);
+          .consume(IGF, src, atomicity);
   }
 
   void fixLifetime(IRGenFunction &IGF, Explosion &src) const override {
diff --git a/lib/IRGen/GenValueWitness.cpp b/lib/IRGen/GenValueWitness.cpp
index d66e20a..33cafb2 100644
--- a/lib/IRGen/GenValueWitness.cpp
+++ b/lib/IRGen/GenValueWitness.cpp
@@ -899,10 +899,10 @@
     Address src(&*(it++), IGM.getPointerAlignment());
 
     llvm::Value *newValue = IGF.Builder.CreateLoad(src, "new");
-    IGF.emitNativeStrongRetain(newValue);
+    IGF.emitNativeStrongRetain(newValue, IGF.getDefaultAtomicity());
     llvm::Value *oldValue = IGF.Builder.CreateLoad(dest, "old");
     IGF.Builder.CreateStore(newValue, dest);
-    IGF.emitNativeStrongRelease(oldValue);
+    IGF.emitNativeStrongRelease(oldValue, IGF.getDefaultAtomicity());
 
     IGF.Builder.CreateRet(dest.getAddress());
   });
@@ -925,7 +925,7 @@
     llvm::Value *newValue = IGF.Builder.CreateLoad(src, "new");
     llvm::Value *oldValue = IGF.Builder.CreateLoad(dest, "old");
     IGF.Builder.CreateStore(newValue, dest);
-    IGF.emitNativeStrongRelease(oldValue);
+    IGF.emitNativeStrongRelease(oldValue, IGF.getDefaultAtomicity());
 
     IGF.Builder.CreateRet(dest.getAddress());
   });
@@ -945,7 +945,7 @@
     Address src(&*(it++), IGM.getPointerAlignment());
 
     llvm::Value *newValue = IGF.Builder.CreateLoad(src, "new");
-    IGF.emitNativeStrongRetain(newValue);
+    IGF.emitNativeStrongRetain(newValue, IGF.getDefaultAtomicity());
     IGF.Builder.CreateStore(newValue, dest);
 
     IGF.Builder.CreateRet(dest.getAddress());
@@ -960,7 +960,7 @@
                                        IGM.VoidTy, argTys,
                                        [&](IRGenFunction &IGF) {
     Address arg(&*IGF.CurFn->arg_begin(), IGM.getPointerAlignment());
-    IGF.emitNativeStrongRelease(IGF.Builder.CreateLoad(arg));
+    IGF.emitNativeStrongRelease(IGF.Builder.CreateLoad(arg), IGF.getDefaultAtomicity());
     IGF.Builder.CreateRetVoid();
   });
 }
diff --git a/lib/IRGen/HeapTypeInfo.h b/lib/IRGen/HeapTypeInfo.h
index a21dc1e..15021eb 100644
--- a/lib/IRGen/HeapTypeInfo.h
+++ b/lib/IRGen/HeapTypeInfo.h
@@ -116,26 +116,32 @@
     asDerived().emitScalarRelease(IGF, value, atomicity);
   }
 
-  void strongRetainUnowned(IRGenFunction &IGF, Explosion &e) const override {
+  void strongRetainUnowned(IRGenFunction &IGF, Explosion &e,
+                           Atomicity atomicity) const override {
     llvm::Value *value = e.claimNext();
-    IGF.emitStrongRetainUnowned(value, asDerived().getReferenceCounting());
+    IGF.emitStrongRetainUnowned(value, asDerived().getReferenceCounting(),
+                                atomicity);
   }
 
   void strongRetainUnownedRelease(IRGenFunction &IGF,
-                                  Explosion &e) const override {
+                                  Explosion &e,
+                                  Atomicity atomicity) const override {
     llvm::Value *value = e.claimNext();
     IGF.emitStrongRetainAndUnownedRelease(value,
-                                          asDerived().getReferenceCounting());
+                                          asDerived().getReferenceCounting(),
+                                          atomicity);
   }
 
-  void unownedRetain(IRGenFunction &IGF, Explosion &e) const override {
+  void unownedRetain(IRGenFunction &IGF, Explosion &e,
+                     Atomicity atomicity) const override {
     llvm::Value *value = e.claimNext();
-    IGF.emitUnownedRetain(value, asDerived().getReferenceCounting());
+    IGF.emitUnownedRetain(value, asDerived().getReferenceCounting(), atomicity);
   }
 
-  void unownedRelease(IRGenFunction &IGF, Explosion &e) const override {
+  void unownedRelease(IRGenFunction &IGF, Explosion &e,
+                      Atomicity atomicity) const override {
     llvm::Value *value = e.claimNext();
-    IGF.emitUnownedRelease(value, asDerived().getReferenceCounting());
+    IGF.emitUnownedRelease(value, asDerived().getReferenceCounting(), atomicity);
   }
 
   void unownedLoadStrong(IRGenFunction &IGF, Address src,
diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp
index 47b118a..0018616 100644
--- a/lib/IRGen/IRGenDebugInfo.cpp
+++ b/lib/IRGen/IRGenDebugInfo.cpp
@@ -569,8 +569,10 @@
 void IRGenDebugInfo::createParameterType(
     llvm::SmallVectorImpl<llvm::Metadata *> &Parameters, SILType type,
     DeclContext *DeclCtx) {
-  // FIXME: This use of getSwiftType() is extremely suspect.
-  auto DbgTy = DebugTypeInfo::getFromTypeInfo(DeclCtx, type.getSwiftType(),
+  auto RealType = type.getSwiftRValueType();
+  if (type.isAddress())
+    RealType = CanInOutType::get(RealType);
+  auto DbgTy = DebugTypeInfo::getFromTypeInfo(DeclCtx, RealType,
                                               IGM.getTypeInfo(type));
   Parameters.push_back(getOrCreateType(DbgTy));
 }
@@ -1590,7 +1592,7 @@
       auto DT = getOrCreateDesugaredType(ObjectTy, DbgTy);
       return createPointerSizedStruct(
           Scope, MangledName, DT, File, 0, Flags,
-          BaseTy->isUnspecializedGeneric() ? StringRef() : MangledName);
+          MangledName);
     } else
       return createOpaqueStruct(Scope, MangledName, File, 0, SizeInBits,
                                 AlignInBits, Flags, MangledName);
diff --git a/lib/IRGen/IRGenFunction.cpp b/lib/IRGen/IRGenFunction.cpp
index 686d442..e25c89e 100644
--- a/lib/IRGen/IRGenFunction.cpp
+++ b/lib/IRGen/IRGenFunction.cpp
@@ -72,6 +72,11 @@
   return IGM.getSILTypes();
 }
 
+// Returns the default atomicity of the module.
+Atomicity IRGenFunction::getDefaultAtomicity() {
+  return getSILModule().isDefaultAtomic() ? Atomicity::Atomic : Atomicity::NonAtomic;
+}
+
 /// Call the llvm.memcpy intrinsic.  The arguments need not already
 /// be of i8* type.
 void IRGenFunction::emitMemCpy(llvm::Value *dest, llvm::Value *src,
diff --git a/lib/IRGen/IRGenFunction.h b/lib/IRGen/IRGenFunction.h
index b23d42d..4782647 100644
--- a/lib/IRGen/IRGenFunction.h
+++ b/lib/IRGen/IRGenFunction.h
@@ -231,6 +231,9 @@
 
 //--- Reference-counting methods -----------------------------------------------
 public:
+  // Returns the default atomicity of the module.
+  Atomicity getDefaultAtomicity();
+
   llvm::Value *emitUnmanagedAlloc(const HeapLayout &layout,
                                   const llvm::Twine &name,
                                   llvm::Constant *captureDescriptor,
@@ -248,11 +251,15 @@
   llvm::Value *emitLoadRefcountedPtr(Address addr, ReferenceCounting style);
 
   //   - unowned references
-  void emitUnownedRetain(llvm::Value *value, ReferenceCounting style);
-  void emitUnownedRelease(llvm::Value *value, ReferenceCounting style);
-  void emitStrongRetainUnowned(llvm::Value *value, ReferenceCounting style);
+  void emitUnownedRetain(llvm::Value *value, ReferenceCounting style,
+                         Atomicity atomicity);
+  void emitUnownedRelease(llvm::Value *value, ReferenceCounting style,
+                          Atomicity atomicity);
+  void emitStrongRetainUnowned(llvm::Value *value, ReferenceCounting style,
+                               Atomicity atomicity);
   void emitStrongRetainAndUnownedRelease(llvm::Value *value,
-                                         ReferenceCounting style);
+                                         ReferenceCounting style,
+                                         Atomicity atomicity);
   void emitUnownedInit(llvm::Value *val, Address dest, ReferenceCounting style);
   void emitUnownedAssign(llvm::Value *value, Address dest,
                          ReferenceCounting style);
@@ -295,16 +302,15 @@
   //   - strong references
   void emitNativeStrongAssign(llvm::Value *value, Address addr);
   void emitNativeStrongInit(llvm::Value *value, Address addr);
-  void emitNativeStrongRetain(llvm::Value *value,
-                              Atomicity atomicity = Atomicity::Atomic);
-  void emitNativeStrongRelease(llvm::Value *value,
-                               Atomicity atomicity = Atomicity::Atomic);
+  void emitNativeStrongRetain(llvm::Value *value, Atomicity atomicity);
+  void emitNativeStrongRelease(llvm::Value *value, Atomicity atomicity);
   void emitNativeSetDeallocating(llvm::Value *value);
   //   - unowned references
-  void emitNativeUnownedRetain(llvm::Value *value);
-  void emitNativeUnownedRelease(llvm::Value *value);
-  void emitNativeStrongRetainUnowned(llvm::Value *value);
-  void emitNativeStrongRetainAndUnownedRelease(llvm::Value *value);
+  void emitNativeUnownedRetain(llvm::Value *value, Atomicity atomicity);
+  void emitNativeUnownedRelease(llvm::Value *value, Atomicity atomicity);
+  void emitNativeStrongRetainUnowned(llvm::Value *value, Atomicity atomicity);
+  void emitNativeStrongRetainAndUnownedRelease(llvm::Value *value,
+                                               Atomicity atomicity);
   void emitNativeUnownedInit(llvm::Value *val, Address dest);
   void emitNativeUnownedAssign(llvm::Value *value, Address dest);
   void emitNativeUnownedCopyInit(Address destAddr, Address srcAddr);
@@ -341,10 +347,8 @@
   // Routines for an unknown reference-counting style (meaning,
   // dynamically something compatible with either the ObjC or Swift styles).
   //   - strong references
-  void emitUnknownStrongRetain(llvm::Value *value,
-                               Atomicity atomicity = Atomicity::Atomic);
-  void emitUnknownStrongRelease(llvm::Value *valuei,
-                                Atomicity atomicity = Atomicity::Atomic);
+  void emitUnknownStrongRetain(llvm::Value *value, Atomicity atomicity);
+  void emitUnknownStrongRelease(llvm::Value *value, Atomicity atomicity);
   //   - unowned references
   void emitUnknownUnownedInit(llvm::Value *val, Address dest);
   void emitUnknownUnownedAssign(llvm::Value *value, Address dest);
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
index d3359ba..e70a62c 100644
--- a/lib/IRGen/IRGenModule.cpp
+++ b/lib/IRGen/IRGenModule.cpp
@@ -273,10 +273,6 @@
     FunctionPtrTy,
     RefCountedPtrTy,
   });
-  WitnessFunctionPairTy = createStructType(*this, "swift.function", {
-    FunctionPtrTy,
-    WitnessTablePtrTy,
-  });
   
   OpaquePtrTy = llvm::StructType::create(LLVMContext, "swift.opaque")
                   ->getPointerTo(DefaultAS);
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
index 2468b79..e5282b1 100644
--- a/lib/IRGen/IRGenModule.h
+++ b/lib/IRGen/IRGenModule.h
@@ -430,7 +430,6 @@
   llvm::PointerType *UnownedReferencePtrTy;/// %swift.unowned_reference*
   llvm::Constant *RefCountedNull;      /// %swift.refcounted* null
   llvm::StructType *FunctionPairTy;    /// { i8*, %swift.refcounted* }
-  llvm::StructType *WitnessFunctionPairTy;    /// { i8*, %witness.table* }
   llvm::FunctionType *DeallocatingDtorTy; /// void (%swift.refcounted*)
   llvm::StructType *TypeMetadataStructTy; /// %swift.type = type { ... }
   llvm::PointerType *TypeMetadataPtrTy;/// %swift.type*
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
index dfff469..97e61fb 100644
--- a/lib/IRGen/IRGenSIL.cpp
+++ b/lib/IRGen/IRGenSIL.cpp
@@ -887,7 +887,8 @@
   void visitInitExistentialMetatypeInst(InitExistentialMetatypeInst *i);
   void visitInitExistentialRefInst(InitExistentialRefInst *i);
   void visitDeinitExistentialAddrInst(DeinitExistentialAddrInst *i);
-  
+  void visitDeinitExistentialOpaqueInst(DeinitExistentialOpaqueInst *i);
+
   void visitAllocExistentialBoxInst(AllocExistentialBoxInst *i);
   void visitOpenExistentialBoxInst(OpenExistentialBoxInst *i);
   void visitProjectExistentialBoxInst(ProjectExistentialBoxInst *i);
@@ -1887,14 +1888,11 @@
     //
     // We recover the witness table from the substitution that was used to
     // produce the substituted callee type.
-    //
-    // There can be multiple substitutions, but the first one is the Self type.
-    assert(subs.size() >= 1);
-    assert(subs[0].getConformances().size() == 1);
-
-    auto conformance = subs[0].getConformances()[0];
-    assert(conformance.getRequirement() == proto); (void) proto;
-    auto substSelfType = subs[0].getReplacement()->getCanonicalType();
+    auto subMap = origCalleeType->getGenericSignature()
+      ->getSubstitutionMap(subs);
+    auto origSelfType = proto->getSelfInterfaceType()->getCanonicalType();
+    auto substSelfType = origSelfType.subst(subMap)->getCanonicalType();
+    auto conformance = *subMap.lookupConformance(origSelfType, proto);
 
     llvm::Value *argMetadata = IGF.emitTypeMetadataRef(substSelfType);
     wtable = emitWitnessTableRef(IGF, substSelfType, &argMetadata,
@@ -1992,12 +1990,8 @@
 
       if (origCalleeType->getRepresentation()
             == SILFunctionType::Representation::WitnessMethod) {
-        // @convention(witness_method) callees are exploded as a
-        // triple consisting of the function, Self metadata, and
-        // the Self witness table.
-        witnessMetadata->SelfWitnessTable = calleeValues.claimNext();
-        assert(witnessMetadata->SelfWitnessTable->getType() ==
-               IGF.IGM.WitnessTablePtrTy);
+        witnessMetadata->SelfWitnessTable = emitWitnessTableForLoweredCallee(
+          IGF, origCalleeType, substitutions);
       }
 
       if (origCalleeType->getRepresentation()
@@ -2221,12 +2215,9 @@
     case SILFunctionType::Representation::Closure:
     case SILFunctionType::Representation::ObjCMethod:
       break;
-    case SILFunctionType::Representation::WitnessMethod: {
-      llvm::Value *wtable = ex.claimNext();
-      assert(wtable->getType() == IGF.IGM.WitnessTablePtrTy);
-      context = wtable;
+    case SILFunctionType::Representation::WitnessMethod:
+      context = emitWitnessTableForLoweredCallee(IGF, fnType, subs);
       break;
-    }
     case SILFunctionType::Representation::CFunctionPointer:
       break;
     case SILFunctionType::Representation::Thick:
@@ -2434,7 +2425,7 @@
     defaultDest = llvm::BasicBlock::Create(IGF.IGM.getLLVMContext());
   }
 
-  if (ty.getAs<BuiltinIntegerType>()) {
+  if (ty.is<BuiltinIntegerType>()) {
     auto *discriminator = value.claimNext();
     auto *i = IGF.Builder.CreateSwitch(discriminator, defaultDest,
                                      dests.size());
@@ -2444,7 +2435,7 @@
     // Get the value we're testing, which is a function.
     llvm::Value *val;
     llvm::BasicBlock *nextTest = nullptr;
-    if (ty.getSwiftType()->is<SILFunctionType>()) {
+    if (ty.is<SILFunctionType>()) {
       val = value.claimNext();   // Function pointer.
       //values.claimNext();         // Ignore the data pointer.
     } else {
@@ -2455,7 +2446,7 @@
       auto casePair = dests[i];
       llvm::Value *caseval;
       auto casevalue = IGF.getLoweredExplosion(casePair.first);
-      if (casePair.first->getType().getSwiftType()->is<SILFunctionType>()) {
+      if (casePair.first->getType().is<SILFunctionType>()) {
         caseval = casevalue.claimNext();   // Function pointer.
         //values.claimNext();         // Ignore the data pointer.
       } else {
@@ -3013,7 +3004,7 @@
   Explosion in = getLoweredExplosion(i->getOperand());
   Explosion out;
   cast<LoadableTypeInfo>(getTypeInfo(i->getOperand()->getType()))
-      .copy(*this, in, out, irgen::Atomicity::Atomic);
+      .copy(*this, in, out, getDefaultAtomicity());
   setLoweredExplosion(i, out);
 }
 
@@ -3071,7 +3062,7 @@
 void IRGenSILFunction::visitDestroyValueInst(swift::DestroyValueInst *i) {
   Explosion in = getLoweredExplosion(i->getOperand());
   cast<LoadableTypeInfo>(getTypeInfo(i->getOperand()->getType()))
-      .consume(*this, in, irgen::Atomicity::Atomic);
+      .consume(*this, in, getDefaultAtomicity());
 }
 
 void IRGenSILFunction::visitStructInst(swift::StructInst *i) {
@@ -3276,21 +3267,16 @@
   StringRef Name = getVarName(i);
   DebugTypeInfo DbgTy;
   SILType SILTy = SILVal->getType();
-  // An inout/lvalue type that is described by a debug value has been
-  // promoted by an optimization pass. Unwrap the type.
-  bool Unwrap = true;
-  auto RealTy = SILVal->getType().getSwiftType();
+  auto RealTy = SILVal->getType().getSwiftRValueType();
   if (VarDecl *Decl = i->getDecl()) {
     DbgTy = DebugTypeInfo::getLocalVariable(
         CurSILFn->getDeclContext(), Decl, RealTy,
-        getTypeInfo(SILVal->getType()), Unwrap);
+        getTypeInfo(SILVal->getType()), /*Unwrap=*/false);
   } else if (i->getFunction()->isBare() &&
-             !SILTy.getSwiftType()->hasArchetype() && !Name.empty()) {
+             !SILTy.hasArchetype() && !Name.empty()) {
     // Preliminary support for .sil debug information.
     DbgTy = DebugTypeInfo::getFromTypeInfo(CurSILFn->getDeclContext(), RealTy,
                                            getTypeInfo(SILTy));
-    if (Unwrap)
-      DbgTy.unwrapLValueOrInOutType();
   } else
     return;
 
@@ -3317,7 +3303,9 @@
   StringRef Name = getVarName(i);
   auto Addr = getLoweredAddress(SILVal).getAddress();
   SILType SILTy = SILVal->getType();
-  auto RealType = SILTy.getSwiftType();
+  auto RealType = SILTy.getSwiftRValueType();
+  if (SILTy.isAddress())
+    RealType = CanInOutType::get(RealType);
   // Unwrap implicitly indirect types and types that are passed by
   // reference only at the SIL level and below.
   //
@@ -3326,7 +3314,7 @@
   // 'Unwrap' set to false.
   bool Unwrap =
       i->getVarInfo().Constant ||
-      RealType->getLValueOrInOutObjectType()->is<ArchetypeType>();
+      SILTy.is<ArchetypeType>();
   auto DbgTy = DebugTypeInfo::getLocalVariable(
       CurSILFn->getDeclContext(), Decl, RealType,
       getTypeInfo(SILVal->getType()), Unwrap);
@@ -3445,19 +3433,22 @@
 visitStrongRetainUnownedInst(swift::StrongRetainUnownedInst *i) {
   Explosion lowered = getLoweredExplosion(i->getOperand());
   auto &ti = getReferentTypeInfo(*this, i->getOperand()->getType());
-  ti.strongRetainUnowned(*this, lowered);
+  ti.strongRetainUnowned(*this, lowered, i->isAtomic() ? irgen::Atomicity::Atomic
+                                                       : irgen::Atomicity::NonAtomic);
 }
 
 void IRGenSILFunction::visitUnownedRetainInst(swift::UnownedRetainInst *i) {
   Explosion lowered = getLoweredExplosion(i->getOperand());
   auto &ti = getReferentTypeInfo(*this, i->getOperand()->getType());
-  ti.unownedRetain(*this, lowered);
+  ti.unownedRetain(*this, lowered, i->isAtomic() ? irgen::Atomicity::Atomic
+                                                 : irgen::Atomicity::NonAtomic);
 }
 
 void IRGenSILFunction::visitUnownedReleaseInst(swift::UnownedReleaseInst *i) {
   Explosion lowered = getLoweredExplosion(i->getOperand());
   auto &ti = getReferentTypeInfo(*this, i->getOperand()->getType());
-  ti.unownedRelease(*this, lowered);
+  ti.unownedRelease(*this, lowered, i->isAtomic() ? irgen::Atomicity::Atomic
+                                                  : irgen::Atomicity::NonAtomic);
 }
 
 void IRGenSILFunction::visitLoadUnownedInst(swift::LoadUnownedInst *i) {
@@ -3597,14 +3588,10 @@
           Pattern->getKind() != PatternKind::OptionalSome)
         return;
 
-    // Discard any inout or lvalue qualifiers. Since the object itself
-    // is stored in the alloca, emitting it as a reference type would
-    // be wrong.
-    bool Unwrap = true;
     SILType SILTy = i->getType();
-    auto RealType = SILTy.getSwiftType().getLValueOrInOutObjectType();
+    auto RealType = SILTy.getSwiftRValueType();
     auto DbgTy = DebugTypeInfo::getLocalVariable(CurSILFn->getDeclContext(),
-                                                 Decl, RealType, type, Unwrap);
+                                                 Decl, RealType, type, false);
     StringRef Name = getVarName(i);
     if (auto DS = i->getDebugScope())
       emitDebugVariableDeclaration(addr, DbgTy, SILTy, DS, Decl, Name,
@@ -3785,10 +3772,13 @@
 
     assert(i->getBoxType()->getLayout()->getFields().size() == 1
            && "box for a local variable should only have one field");
+    auto SILTy = i->getBoxType()->getFieldType(IGM.getSILModule(), 0);
+    auto RealType = SILTy.getSwiftRValueType();
+    if (SILTy.isAddress())
+      RealType = CanInOutType::get(RealType);
     auto DbgTy = DebugTypeInfo::getLocalVariable(
         CurSILFn->getDeclContext(), Decl,
-        i->getBoxType()->getFieldType(IGM.getSILModule(), 0).getSwiftType(),
-          type, /*Unwrap=*/false);
+        RealType, type, /*Unwrap=*/false);
 
     if (isInlinedGeneric(Decl, i->getDebugScope()))
       return;
@@ -4343,7 +4333,7 @@
   llvm::Value *val;
   const LoweredValue &lv = getLoweredValue(i->getOperand());
   
-  if (i->getOperand()->getType().getSwiftType()->is<SILFunctionType>()) {
+  if (i->getOperand()->getType().is<SILFunctionType>()) {
     Explosion values = lv.getExplosion(*this);
     val = values.claimNext();   // Function pointer.
     values.claimNext();         // Ignore the data pointer.
@@ -4511,6 +4501,11 @@
                                        i->getOperand()->getType());
 }
 
+void IRGenSILFunction::visitDeinitExistentialOpaqueInst(
+    swift::DeinitExistentialOpaqueInst *i) {
+  llvm_unreachable("unsupported instruction during IRGen");
+}
+
 void IRGenSILFunction::visitOpenExistentialAddrInst(OpenExistentialAddrInst *i) {
   SILType baseTy = i->getOperand()->getType();
   Address base = getLoweredAddress(i->getOperand());
diff --git a/lib/IRGen/ReferenceTypeInfo.h b/lib/IRGen/ReferenceTypeInfo.h
index 56e3c33..816a240 100644
--- a/lib/IRGen/ReferenceTypeInfo.h
+++ b/lib/IRGen/ReferenceTypeInfo.h
@@ -49,20 +49,24 @@
 
   /// Strongly retains a value that has come from a safe [unowned] reference.
   /// This operation is not supported for all reference types.
-  virtual void strongRetainUnowned(IRGenFunction &IGF, Explosion &in) const = 0;
+  virtual void strongRetainUnowned(IRGenFunction &IGF, Explosion &in,
+                                   Atomicity atomicity) const = 0;
 
   /// Strongly retains a value that has come from a safe [unowned] reference.
   /// This operation is not supported for all reference types.
   virtual void strongRetainUnownedRelease(IRGenFunction &IGF,
-                                          Explosion &in) const = 0;
+                                          Explosion &in,
+                                          Atomicity atomicity) const = 0;
 
   /// Weakly retains a value in the manner of a safe [unowned] reference.
   /// This operation is not supported for all reference types.
-  virtual void unownedRetain(IRGenFunction &IGF, Explosion &in) const = 0;
+  virtual void unownedRetain(IRGenFunction &IGF, Explosion &in,
+                             Atomicity atomicity) const = 0;
 
   /// Weakly releases a value in the manner of a safe [unowned] reference.
   /// This operation is not supported for all reference types.
-  virtual void unownedRelease(IRGenFunction &IGF, Explosion &in) const = 0;
+  virtual void unownedRelease(IRGenFunction &IGF, Explosion &in,
+                              Atomicity atomicity) const = 0;
 
   /// Load a reference from a safe [unowned] reference in memory and
   /// destroy the [unowned] location.
diff --git a/lib/IRGen/ScalarTypeInfo.h b/lib/IRGen/ScalarTypeInfo.h
index d2471e6..dd7dbc9 100644
--- a/lib/IRGen/ScalarTypeInfo.h
+++ b/lib/IRGen/ScalarTypeInfo.h
@@ -127,7 +127,7 @@
                   Explosion &out) const override {
     addr = asDerived().projectScalar(IGF, addr);
     llvm::Value *value = IGF.Builder.CreateLoad(addr);
-    asDerived().emitScalarRetain(IGF, value, Atomicity::Atomic);
+    asDerived().emitScalarRetain(IGF, value, IGF.getDefaultAtomicity());
     out.add(value);
   }
 
@@ -153,7 +153,7 @@
 
     // Release the old value if we need to.
     if (!Derived::IsScalarPOD) {
-      asDerived().emitScalarRelease(IGF, oldValue, Atomicity::Atomic);
+      asDerived().emitScalarRelease(IGF, oldValue, IGF.getDefaultAtomicity());
     }
   }
 
@@ -179,7 +179,7 @@
     if (!Derived::IsScalarPOD) {
       addr = asDerived().projectScalar(IGF, addr);
       llvm::Value *value = IGF.Builder.CreateLoad(addr, "toDestroy");
-      asDerived().emitScalarRelease(IGF, value, Atomicity::Atomic);
+      asDerived().emitScalarRelease(IGF, value, IGF.getDefaultAtomicity());
     }
   }
   
diff --git a/lib/IRGen/SwiftTargetInfo.cpp b/lib/IRGen/SwiftTargetInfo.cpp
index ea5464e..1c68338 100644
--- a/lib/IRGen/SwiftTargetInfo.cpp
+++ b/lib/IRGen/SwiftTargetInfo.cpp
@@ -158,6 +158,7 @@
     break;
 
   case llvm::Triple::arm:
+  case llvm::Triple::thumb:
     configureARM(IGM, triple, target);
     break;
 
diff --git a/lib/Index/Index.cpp b/lib/Index/Index.cpp
index 0464ab1..52bf53c 100644
--- a/lib/Index/Index.cpp
+++ b/lib/Index/Index.cpp
@@ -191,6 +191,14 @@
 
   bool addRelation(IndexSymbol &Info, SymbolRoleSet RelationRoles, Decl *D) {
     assert(D);
+    auto Match = std::find_if(Info.Relations.begin(), Info.Relations.end(),
+                              [D](IndexRelation R) { return R.decl == D; });
+    if (Match != Info.Relations.end()) {
+      Match->roles |= RelationRoles;
+      Info.roles |= RelationRoles;
+      return false;
+    }
+
     StringRef Name, USR;
     SymbolInfo SymInfo = getSymbolInfoForDecl(D);
 
@@ -400,7 +408,8 @@
   }
 
   bool isLocal(ValueDecl *D) const {
-    return D->getDeclContext()->getLocalContext();
+    return D->getDeclContext()->getLocalContext() &&
+      (!isa<ParamDecl>(D) || cast<ParamDecl>(D)->getArgumentNameLoc().isValid());
   }
 
   void getModuleHash(SourceFileOrModule SFOrMod, llvm::raw_ostream &OS);
@@ -605,7 +614,7 @@
         return false;
 
     } else if (auto ParentED = dyn_cast<ExtensionDecl>(Parent)) {
-      if (NominalTypeDecl *NTD = ParentED->getExtendedType()->getAnyNominal()) {
+      if (ParentED->getExtendedType()->getAnyNominal()) {
         if (addRelation(Info, (SymbolRoleSet) SymbolRole::RelationChildOf, ParentED))
           return false;
       }
@@ -866,10 +875,14 @@
 
   // Cannot be extension, which is not a ValueDecl.
 
-  if (IsRef)
+  if (IsRef) {
     Info.roles |= (unsigned)SymbolRole::Reference;
-  else
+    auto Parent = getParentDecl();
+    if (Parent && isa<AbstractFunctionDecl>(Parent))
+      addRelation(Info, (unsigned)SymbolRole::RelationContainedBy, Parent);
+  } else {
     Info.roles |= (unsigned)SymbolRole::Definition;
+  }
 
   if (getNameAndUSR(D, /*ExtD=*/nullptr, Info.name, Info.USR))
     return true;
diff --git a/lib/Index/IndexSymbol.cpp b/lib/Index/IndexSymbol.cpp
index 1537c91..d59d1ba 100644
--- a/lib/Index/IndexSymbol.cpp
+++ b/lib/Index/IndexSymbol.cpp
@@ -112,10 +112,10 @@
       info.SubKind = SymbolSubKind::SwiftSubscript;
       break;
     case DeclKind::Constructor:      info.Kind = SymbolKind::Constructor; break;
-    case DeclKind::Destructor:       info.Kind = SymbolKind::Destructor; break;;
+    case DeclKind::Destructor:       info.Kind = SymbolKind::Destructor; break;
     case DeclKind::Param:
-      llvm_unreachable("unexpected parameter seen while indexing");
-
+      info.Kind = SymbolKind::Parameter;
+      break;
     case DeclKind::Func:
       setFuncSymbolInfo(cast<FuncDecl>(D), info);
       break;
diff --git a/lib/Parse/CMakeLists.txt b/lib/Parse/CMakeLists.txt
index 870e1be..c0b384d 100644
--- a/lib/Parse/CMakeLists.txt
+++ b/lib/Parse/CMakeLists.txt
@@ -3,6 +3,7 @@
   ParseDecl.cpp
   ParseExpr.cpp
   ParseGeneric.cpp
+  ParseIfConfig.cpp
   ParsePattern.cpp
   Parser.cpp
   ParseSIL.cpp
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 0b449e6..c61e690 100644
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -2727,32 +2727,31 @@
 }
 
 /// Parse a Decl item in decl list.
-static ParserStatus parseDeclItem(Parser &P,
-                                  bool &PreviousHadSemi,
-                                  Parser::ParseDeclOptions Options,
-                                  llvm::function_ref<void(Decl*)> handler) {
-  if (P.Tok.is(tok::semi)) {
+ParserStatus Parser::parseDeclItem(bool &PreviousHadSemi,
+                                   Parser::ParseDeclOptions Options,
+                                   llvm::function_ref<void(Decl*)> handler) {
+  if (Tok.is(tok::semi)) {
     // Consume ';' without preceding decl.
-    P.diagnose(P.Tok, diag::unexpected_separator, ";")
-      .fixItRemove(P.Tok.getLoc());
-    P.consumeToken();
+    diagnose(Tok, diag::unexpected_separator, ";")
+      .fixItRemove(Tok.getLoc());
+    consumeToken();
     // Return success because we already recovered.
     return makeParserSuccess();
   }
 
   // If the previous declaration didn't have a semicolon and this new
   // declaration doesn't start a line, complain.
-  if (!PreviousHadSemi && !P.Tok.isAtStartOfLine() && !P.Tok.is(tok::unknown)) {
-    auto endOfPrevious = P.getEndOfPreviousLoc();
-    P.diagnose(endOfPrevious, diag::declaration_same_line_without_semi)
+  if (!PreviousHadSemi && !Tok.isAtStartOfLine() && !Tok.is(tok::unknown)) {
+    auto endOfPrevious = getEndOfPreviousLoc();
+    diagnose(endOfPrevious, diag::declaration_same_line_without_semi)
       .fixItInsert(endOfPrevious, ";");
   }
 
-  auto Result = P.parseDecl(Options, handler);
+  auto Result = parseDecl(Options, handler);
   if (Result.isParseError())
-    P.skipUntilDeclRBrace(tok::semi, tok::pound_endif);
+    skipUntilDeclRBrace(tok::semi, tok::pound_endif);
   SourceLoc SemiLoc;
-  PreviousHadSemi = P.consumeIf(tok::semi, SemiLoc);
+  PreviousHadSemi = consumeIf(tok::semi, SemiLoc);
   if (PreviousHadSemi && Result.isNonNull())
     Result.get()->TrailingSemiLoc = SemiLoc;
   return Result;
@@ -2769,7 +2768,7 @@
   ParserStatus Status;
   bool PreviousHadSemi = true;
   while (Tok.isNot(tok::r_brace)) {
-    Status |= parseDeclItem(*this, PreviousHadSemi, Options, handler);
+    Status |= parseDeclItem(PreviousHadSemi, Options, handler);
     if (Tok.isAny(tok::eof, tok::pound_endif, tok::pound_else,
                   tok::pound_elseif)) {
       IsInputIncomplete = true;
@@ -2999,94 +2998,6 @@
   return makeParserSuccess();
 }
 
-ParserResult<IfConfigDecl> Parser::parseDeclIfConfig(ParseDeclOptions Flags) {
-  StructureMarkerRAII ParsingDecl(*this, Tok.getLoc(),
-                                  StructureMarkerKind::IfConfig);
-
-  SmallVector<IfConfigDeclClause, 4> Clauses;
-
-  bool foundActive = false;
-  ConditionalCompilationExprState ConfigState;
-  while (1) {
-    bool isElse = Tok.is(tok::pound_else);
-    SourceLoc ClauseLoc = consumeToken();
-    Expr *Condition = nullptr;
-
-    if (isElse) {
-      ConfigState.setConditionActive(!foundActive);
-    } else {
-      // Evaluate the condition.
-      llvm::SaveAndRestore<bool> S(InPoundIfEnvironment, true);
-      ParserResult<Expr> Result = parseExprSequence(diag::expected_expr,
-                                                    /*isBasic*/true,
-                                                    /*isForDirective*/true);
-      if (Result.isNull())
-        return makeParserError();
-
-      Condition = Result.get();
-
-      // Evaluate the condition, to validate it.
-      ConfigState = classifyConditionalCompilationExpr(Condition, Context,
-                                                       Diags);
-      if (foundActive)
-        ConfigState.setConditionActive(false);
-    }
-
-    foundActive |= ConfigState.isConditionActive();
-
-    if (!Tok.isAtStartOfLine() && Tok.isNot(tok::eof)) {
-      diagnose(Tok.getLoc(),
-               diag::extra_tokens_conditional_compilation_directive);
-    }
-
-    Optional<Scope> scope;
-    if (!ConfigState.isConditionActive())
-      scope.emplace(this, getScopeInfo().getCurrentScope()->getKind(),
-                    /*inactiveConfigBlock=*/true);
-
-    SmallVector<Decl*, 8> Decls;
-    if (ConfigState.shouldParse()) {
-      ParserStatus Status;
-      bool PreviousHadSemi = true;
-      while (Tok.isNot(tok::pound_else, tok::pound_endif, tok::pound_elseif,
-                       tok::eof)) {
-        if (Tok.is(tok::r_brace)) {
-          diagnose(Tok.getLoc(),
-                   diag::unexpected_rbrace_in_conditional_compilation_block);
-          // If we see '}', following declarations don't look like belong to
-          // the current decl context; skip them.
-          skipUntilConditionalBlockClose();
-          break;
-        }
-        Status |= parseDeclItem(*this, PreviousHadSemi, Flags,
-                                [&](Decl *D) {Decls.push_back(D);});
-      }
-    } else {
-      DiagnosticTransaction DT(Diags);
-      skipUntilConditionalBlockClose();
-      DT.abort();
-    }
-
-    Clauses.push_back(IfConfigDeclClause(ClauseLoc, Condition,
-                                         Context.AllocateCopy(Decls),
-                                         ConfigState.isConditionActive()));
-
-    if (Tok.isNot(tok::pound_elseif) && Tok.isNot(tok::pound_else))
-      break;
-
-    if (isElse)
-      diagnose(Tok, diag::expected_close_after_else_directive);
-  }
-
-  SourceLoc EndLoc;
-  bool HadMissingEnd = parseEndIfDirective(EndLoc);
-
-  IfConfigDecl *ICD = new (Context) IfConfigDecl(CurDeclContext,
-                                                 Context.AllocateCopy(Clauses),
-                                                 EndLoc, HadMissingEnd);
-  return makeParserResult(ICD);
-}
-
 /// \brief Parse a typealias decl.
 ///
 /// \verbatim
@@ -3185,7 +3096,7 @@
 ///
 /// \verbatim
 ///   decl-associatedtype:
-///     'associatedtype' identifier inheritance? ('=' type)?
+///     'associatedtype' identifier inheritance? ('=' type)? where-clause?
 /// \endverbatim
 
 ParserResult<TypeDecl> Parser::parseDeclAssociatedType(Parser::ParseDeclOptions Flags,
@@ -3239,15 +3150,32 @@
     if (UnderlyingTy.isNull())
       return Status;
   }
-  
-  // Parse a 'where' clause if present. These are not supported, but we will
-  // get better QoI this way.
+
+  TrailingWhereClause *TrailingWhere = nullptr;
+  // Parse a 'where' clause if present.
   if (Tok.is(tok::kw_where)) {
-    GenericParamList *unused = nullptr;
-    auto whereStatus = parseFreestandingGenericWhereClause(
-        unused, WhereClauseKind::AssociatedType);
-    if (whereStatus.shouldStopParsing())
-      return whereStatus;
+    SourceLoc whereLoc;
+    SmallVector<RequirementRepr, 4> requirements;
+    bool firstTypeInComplete;
+    auto whereStatus =
+        parseGenericWhereClause(whereLoc, requirements, firstTypeInComplete);
+    if (whereStatus.isSuccess()) {
+      TrailingWhere =
+          TrailingWhereClause::create(Context, whereLoc, requirements);
+    } else if (whereStatus.hasCodeCompletion()) {
+      // FIXME: this is completely (hah) cargo culted.
+      if (CodeCompletion && firstTypeInComplete) {
+        CodeCompletion->completeGenericParams(nullptr);
+      } else {
+        return makeParserCodeCompletionResult<AssociatedTypeDecl>();
+      }
+    }
+
+    if (Context.isSwiftVersion3()) {
+      diagnose(whereLoc, diag::associatedtype_where_swift_3);
+      // There's nothing to see here, move along.
+      TrailingWhere = nullptr;
+    }
   }
 
   if (!Flags.contains(PD_InProtocol)) {
@@ -3256,10 +3184,10 @@
     Status.setIsParseError();
     return Status;
   }
-  
-  auto assocType = new (Context) AssociatedTypeDecl(CurDeclContext,
-                                                    AssociatedTypeLoc, Id, IdLoc,
-                                                    UnderlyingTy.getPtrOrNull());
+
+  auto assocType = new (Context)
+      AssociatedTypeDecl(CurDeclContext, AssociatedTypeLoc, Id, IdLoc,
+                         UnderlyingTy.getPtrOrNull(), TrailingWhere);
   assocType->getAttrs() = Attributes;
   if (!Inherited.empty())
     assocType->setInherited(Context.AllocateCopy(Inherited));
diff --git a/lib/Parse/ParseIfConfig.cpp b/lib/Parse/ParseIfConfig.cpp
new file mode 100644
index 0000000..f6c064d
--- /dev/null
+++ b/lib/Parse/ParseIfConfig.cpp
@@ -0,0 +1,427 @@
+//===--- ParseDecl.cpp - Swift Language Parser for #if directives -- ------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Conditional Compilation Block Parsing and AST Building
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Parse/Parser.h"
+#include "swift/Basic/Defer.h"
+#include "swift/Basic/LangOptions.h"
+#include "swift/Basic/Version.h"
+#include "swift/Parse/Lexer.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/SaveAndRestore.h"
+
+using namespace swift;
+
+/// Parse and populate a list of #if/#elseif/#else/#endif clauses.
+/// Delegate callback function to parse elements in the blocks.
+template <typename ElemTy, unsigned N>
+static ParserStatus parseIfConfig(
+    Parser &P, SmallVectorImpl<IfConfigClause<ElemTy>> &Clauses,
+    SourceLoc &EndLoc, bool HadMissingEnd,
+    llvm::function_ref<void(SmallVectorImpl<ElemTy> &, bool)> parseElements) {
+  Parser::StructureMarkerRAII ParsingDecl(
+      P, P.Tok.getLoc(), Parser::StructureMarkerKind::IfConfig);
+
+  bool foundActive = false;
+  ConditionalCompilationExprState ConfigState;
+  while (1) {
+    bool isElse = P.Tok.is(tok::pound_else);
+    SourceLoc ClauseLoc = P.consumeToken();
+    Expr *Condition = nullptr;
+
+    // Parse and evaluate the directive.
+    if (isElse) {
+      ConfigState.setConditionActive(!foundActive);
+    } else {
+      llvm::SaveAndRestore<bool> S(P.InPoundIfEnvironment, true);
+      ParserResult<Expr> Result = P.parseExprSequence(diag::expected_expr,
+                                                      /*isBasic*/true,
+                                                      /*isForDirective*/true);
+      if (Result.isNull())
+        return makeParserError();
+
+      Condition = Result.get();
+
+      // Evaluate the condition, to validate it.
+      ConfigState = P.classifyConditionalCompilationExpr(Condition, P.Context,
+                                                         P.Diags);
+      if (foundActive)
+        ConfigState.setConditionActive(false);
+    }
+
+    foundActive |= ConfigState.isConditionActive();
+
+    if (!P.Tok.isAtStartOfLine() && P.Tok.isNot(tok::eof)) {
+      P.diagnose(P.Tok.getLoc(),
+                 diag::extra_tokens_conditional_compilation_directive);
+    }
+
+    // Parse elements
+    SmallVector<ElemTy, N> Elements;
+    if (ConfigState.shouldParse()) {
+      parseElements(Elements, ConfigState.isConditionActive());
+    } else {
+      DiagnosticTransaction DT(P.Diags);
+      P.skipUntilConditionalBlockClose();
+      DT.abort();
+    }
+
+    Clauses.push_back(IfConfigClause<ElemTy>(ClauseLoc, Condition,
+                                             P.Context.AllocateCopy(Elements),
+                                             ConfigState.isConditionActive()));
+
+    if (P.Tok.isNot(tok::pound_elseif, tok::pound_else))
+      break;
+
+    if (isElse)
+      P.diagnose(P.Tok, diag::expected_close_after_else_directive);
+  }
+
+  HadMissingEnd = P.parseEndIfDirective(EndLoc);
+  return makeParserSuccess();
+}
+
+ParserResult<IfConfigDecl> Parser::parseDeclIfConfig(ParseDeclOptions Flags) {
+  SmallVector<IfConfigClause<Decl *>, 4> Clauses;
+  SourceLoc EndLoc;
+  bool HadMissingEnd = false;
+  auto Status = parseIfConfig<Decl *, 8>(
+      *this, Clauses, EndLoc, HadMissingEnd,
+      [&](SmallVectorImpl<Decl *> &Decls, bool IsActive) {
+    Optional<Scope> scope;
+    if (!IsActive)
+      scope.emplace(this, getScopeInfo().getCurrentScope()->getKind(),
+                    /*inactiveConfigBlock=*/true);
+
+    ParserStatus Status;
+    bool PreviousHadSemi = true;
+    while (Tok.isNot(tok::pound_else, tok::pound_endif, tok::pound_elseif,
+                      tok::eof)) {
+      if (Tok.is(tok::r_brace)) {
+        diagnose(Tok.getLoc(),
+                  diag::unexpected_rbrace_in_conditional_compilation_block);
+        // If we see '}', following declarations don't look like belong to
+        // the current decl context; skip them.
+        skipUntilConditionalBlockClose();
+        break;
+      }
+      Status |= parseDeclItem(PreviousHadSemi, Flags,
+                              [&](Decl *D) {Decls.push_back(D);});
+    }
+  });
+  if (Status.isError())
+    return makeParserErrorResult<IfConfigDecl>();
+
+  IfConfigDecl *ICD = new (Context) IfConfigDecl(CurDeclContext,
+                                                 Context.AllocateCopy(Clauses),
+                                                 EndLoc, HadMissingEnd);
+  return makeParserResult(ICD);
+}
+
+ParserResult<Stmt> Parser::parseStmtIfConfig(BraceItemListKind Kind) {
+  SmallVector<IfConfigClause<ASTNode>, 4> Clauses;
+  SourceLoc EndLoc;
+  bool HadMissingEnd = false;
+  auto Status = parseIfConfig<ASTNode, 16>(
+      *this, Clauses, EndLoc, HadMissingEnd,
+      [&](SmallVectorImpl<ASTNode> &Elements, bool IsActive) {
+    parseBraceItems(Elements, Kind, IsActive
+                      ? BraceItemListKind::ActiveConditionalBlock
+                      : BraceItemListKind::InactiveConditionalBlock);
+  });
+  if (Status.isError())
+    return makeParserErrorResult<Stmt>();
+
+  auto *ICS = new (Context) IfConfigStmt(Context.AllocateCopy(Clauses),
+                                         EndLoc, HadMissingEnd);
+  return makeParserResult(ICS);
+}
+
+// Evaluate a subset of expression types suitable for build configuration
+// conditional expressions.  The accepted expression types are:
+//  - The magic constants "true" and "false".
+//  - Named decl ref expressions ("FOO")
+//  - Parenthesized expressions ("(FOO)")
+//  - Binary "&&" or "||" operations applied to other build configuration
+//    conditional expressions
+//  - Unary "!" expressions applied to other build configuration conditional
+//    expressions
+//  - Single-argument call expressions, where the function being invoked is a
+//    supported target configuration (currently "os", "arch", and
+//    "_compiler_version"), and whose argument is a named decl ref expression
+ConditionalCompilationExprState
+Parser::classifyConditionalCompilationExpr(Expr *condition,
+                                           ASTContext &Context,
+                                           DiagnosticEngine &D) {
+  assert(condition && "Cannot classify a NULL condition expression!");
+
+  // Evaluate a ParenExpr.
+  if (auto *PE = dyn_cast<ParenExpr>(condition))
+    return classifyConditionalCompilationExpr(PE->getSubExpr(), Context, D);
+
+  // Evaluate a "&&" or "||" expression.
+  if (auto *SE = dyn_cast<SequenceExpr>(condition)) {
+    // Check for '&&' or '||' as the expression type.
+    if (SE->getNumElements() < 3) {
+      D.diagnose(SE->getLoc(),
+                 diag::unsupported_conditional_compilation_binary_expression);
+      return ConditionalCompilationExprState::error();
+    }
+    // Before type checking, chains of binary expressions will not be fully
+    // parsed, so associativity has not yet been encoded in the subtree.
+    auto elements = SE->getElements();
+    auto numElements = SE->getNumElements();
+    size_t iOperator = 1;
+    size_t iOperand = 2;
+
+    auto result = classifyConditionalCompilationExpr(elements[0], Context, D);
+
+    while (iOperand < numElements) {
+
+      if (auto *UDREOp = dyn_cast<UnresolvedDeclRefExpr>(elements[iOperator])) {
+        auto name = UDREOp->getName().getBaseName().str();
+
+        if (name.equals("||") || name.equals("&&")) {
+          auto rhs = classifyConditionalCompilationExpr(elements[iOperand],
+                                                        Context, D);
+
+          if (name.equals("||")) {
+            result = result || rhs;
+            if (result.isConditionActive())
+              break;
+          }
+
+          if (name.equals("&&")) {
+            result = result && rhs;
+            if (!result.isConditionActive())
+              break;
+          }
+        } else {
+          D.diagnose(
+              SE->getLoc(),
+              diag::unsupported_conditional_compilation_binary_expression);
+          return ConditionalCompilationExprState::error();
+        }
+      } else {
+        // Swift3 didn't have this branch. the operator and the RHS are
+        // silently ignored.
+        if (!Context.isSwiftVersion3()) {
+          D.diagnose(
+              elements[iOperator]->getLoc(),
+              diag::unsupported_conditional_compilation_expression_type);
+          return ConditionalCompilationExprState::error();
+        } else {
+          SourceRange ignoredRange(elements[iOperator]->getLoc(),
+                                   elements[iOperand]->getEndLoc());
+          D.diagnose(
+              elements[iOperator]->getLoc(),
+              diag::swift3_unsupported_conditional_compilation_expression_type)
+            .highlight(ignoredRange);
+        }
+      }
+
+      iOperator += 2;
+      iOperand += 2;
+    }
+
+    return result;
+  }
+
+  // Evaluate a named reference expression.
+  if (auto *UDRE = dyn_cast<UnresolvedDeclRefExpr>(condition)) {
+    auto name = UDRE->getName().getBaseName().str();
+    return {Context.LangOpts.isCustomConditionalCompilationFlagSet(name),
+      ConditionalCompilationExprKind::DeclRef};
+  }
+
+  // Evaluate a Boolean literal.
+  if (auto *boolLit = dyn_cast<BooleanLiteralExpr>(condition)) {
+    return {boolLit->getValue(), ConditionalCompilationExprKind::Boolean};
+  }
+
+  // Evaluate a negation (unary "!") expression.
+  if (auto *PUE = dyn_cast<PrefixUnaryExpr>(condition)) {
+    // If the PUE is not a negation expression, return false
+    auto name =
+    cast<UnresolvedDeclRefExpr>(PUE->getFn())->getName().getBaseName().str();
+    if (name != "!") {
+      D.diagnose(PUE->getLoc(),
+                 diag::unsupported_conditional_compilation_unary_expression);
+      return ConditionalCompilationExprState::error();
+    }
+
+    return !classifyConditionalCompilationExpr(PUE->getArg(), Context, D);
+  }
+
+  // Evaluate a target config call expression.
+  if (auto *CE = dyn_cast<CallExpr>(condition)) {
+    // look up target config, and compare value
+    auto fnNameExpr = dyn_cast<UnresolvedDeclRefExpr>(CE->getFn());
+
+    // Get the arg, which should be in a paren expression.
+    if (!fnNameExpr) {
+      D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_expression);
+      return ConditionalCompilationExprState::error();
+    }
+
+    auto fnName = fnNameExpr->getName().getBaseName().str();
+
+    auto *PE = dyn_cast<ParenExpr>(CE->getArg());
+    if (!PE) {
+      auto diag = D.diagnose(CE->getLoc(),
+                             diag::platform_condition_expected_one_argument);
+      return ConditionalCompilationExprState::error();
+    }
+
+    if (!fnName.equals("arch") && !fnName.equals("os") &&
+        !fnName.equals("_endian") &&
+        !fnName.equals("_runtime") &&
+        !fnName.equals("swift") &&
+        !fnName.equals("_compiler_version")) {
+      D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_expression);
+      return ConditionalCompilationExprState::error();
+    }
+
+    if (fnName.equals("_compiler_version")) {
+      if (auto SLE = dyn_cast<StringLiteralExpr>(PE->getSubExpr())) {
+        if (SLE->getValue().empty()) {
+          D.diagnose(CE->getLoc(), diag::empty_version_string);
+          return ConditionalCompilationExprState::error();
+        }
+        auto versionRequirement =
+        version::Version::parseCompilerVersionString(SLE->getValue(),
+                                                     SLE->getLoc(),
+                                                     &D);
+        auto thisVersion = version::Version::getCurrentCompilerVersion();
+        auto VersionNewEnough = thisVersion >= versionRequirement;
+        return {VersionNewEnough,
+          ConditionalCompilationExprKind::CompilerVersion};
+      } else {
+        D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_argument,
+                 "string literal");
+        return ConditionalCompilationExprState::error();
+      }
+    } else if (fnName.equals("swift")) {
+      auto PUE = dyn_cast<PrefixUnaryExpr>(PE->getSubExpr());
+      if (!PUE) {
+        D.diagnose(PE->getSubExpr()->getLoc(),
+                   diag::unsupported_platform_condition_argument,
+                   "a unary comparison, such as '>=2.2'");
+        return ConditionalCompilationExprState::error();
+      }
+
+      auto prefix = dyn_cast<UnresolvedDeclRefExpr>(PUE->getFn());
+      auto versionArg = PUE->getArg();
+      auto versionStartLoc = versionArg->getStartLoc();
+      auto endLoc = Lexer::getLocForEndOfToken(Context.SourceMgr,
+                                               versionArg->getSourceRange().End);
+      CharSourceRange versionCharRange(Context.SourceMgr, versionStartLoc,
+                                       endLoc);
+      auto versionString = Context.SourceMgr.extractText(versionCharRange);
+
+      auto versionRequirement =
+        version::Version::parseVersionString(versionString,
+                                             versionStartLoc,
+                                             &D);
+
+      if (!versionRequirement.hasValue())
+        return ConditionalCompilationExprState::error();
+
+      auto thisVersion = Context.LangOpts.EffectiveLanguageVersion;
+
+      if (!prefix->getName().getBaseName().str().equals(">=")) {
+        D.diagnose(PUE->getFn()->getLoc(),
+                   diag::unexpected_version_comparison_operator)
+          .fixItReplace(PUE->getFn()->getLoc(), ">=");
+        return ConditionalCompilationExprState::error();
+      }
+
+      auto VersionNewEnough = thisVersion >= versionRequirement.getValue();
+      return {VersionNewEnough,
+        ConditionalCompilationExprKind::LanguageVersion};
+    } else {
+      if (auto UDRE = dyn_cast<UnresolvedDeclRefExpr>(PE->getSubExpr())) {
+        // The sub expression should be an UnresolvedDeclRefExpr (we won't
+        // tolerate extra parens).
+        auto argumentIdent = UDRE->getName().getBaseName();
+        auto argument = argumentIdent.str();
+        PlatformConditionKind Kind =
+          llvm::StringSwitch<PlatformConditionKind>(fnName)
+          .Case("os", PlatformConditionKind::OS)
+          .Case("arch", PlatformConditionKind::Arch)
+          .Case("_endian", PlatformConditionKind::Endianness)
+          .Case("_runtime", PlatformConditionKind::Runtime);
+
+        // FIXME: Perform the replacement macOS -> OSX elsewhere.
+        if (Kind == PlatformConditionKind::OS && argument == "macOS")
+          argument = "OSX";
+
+        std::vector<StringRef> suggestions;
+        if (!LangOptions::checkPlatformConditionSupported(Kind, argument,
+                                                          suggestions)) {
+          if (Kind == PlatformConditionKind::Runtime) {
+            // Error for _runtime()
+            D.diagnose(UDRE->getLoc(),
+                       diag::unsupported_platform_runtime_condition_argument);
+            return ConditionalCompilationExprState::error();
+          }
+          StringRef DiagName;
+          switch (Kind) {
+          case PlatformConditionKind::OS:
+            DiagName = "operating system"; break;
+          case PlatformConditionKind::Arch:
+            DiagName = "architecture"; break;
+          case PlatformConditionKind::Endianness:
+            DiagName = "endianness"; break;
+          case PlatformConditionKind::Runtime:
+            llvm_unreachable("handled above");
+          }
+          D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
+                     DiagName, fnName);
+          for (const StringRef &suggestion : suggestions) {
+            D.diagnose(UDRE->getLoc(), diag::note_typo_candidate, suggestion)
+              .fixItReplace(UDRE->getSourceRange(), suggestion);
+          }
+        }
+
+        auto target = Context.LangOpts.getPlatformConditionValue(Kind);
+        return {target == argument, ConditionalCompilationExprKind::DeclRef};
+      } else {
+        D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_argument,
+                   "identifier");
+        return ConditionalCompilationExprState::error();
+      }
+    }
+  }
+
+  // "#if 0" isn't valid, but it is common, so recognize it and handle it
+  // with a fixit elegantly.
+  if (auto *IL = dyn_cast<IntegerLiteralExpr>(condition))
+    if (IL->getDigitsText() == "0" || IL->getDigitsText() == "1") {
+      StringRef replacement = IL->getDigitsText() == "0" ? "false" :"true";
+      D.diagnose(IL->getLoc(), diag::unsupported_conditional_compilation_integer,
+                 IL->getDigitsText(), replacement)
+       .fixItReplace(IL->getLoc(), replacement);
+      return {IL->getDigitsText() == "1",
+        ConditionalCompilationExprKind::Integer};
+    }
+
+
+  // If we've gotten here, it's an unsupported expression type.
+  D.diagnose(condition->getLoc(),
+             diag::unsupported_conditional_compilation_expression_type);
+  return ConditionalCompilationExprState::error();
+}
diff --git a/lib/Parse/ParseSIL.cpp b/lib/Parse/ParseSIL.cpp
index 771cdda..dedf8c8 100644
--- a/lib/Parse/ParseSIL.cpp
+++ b/lib/Parse/ParseSIL.cpp
@@ -2133,9 +2133,9 @@
     UNARY_INSTRUCTION(DestroyValue)
     UNARY_INSTRUCTION(CondFail)
     UNARY_INSTRUCTION(EndBorrowArgument)
-    UNARY_INSTRUCTION(UnmanagedReleaseValue)
-    UNARY_INSTRUCTION(UnmanagedRetainValue)
-    UNARY_INSTRUCTION(UnmanagedAutoreleaseValue)
+    REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
+    REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
+    REFCOUNTING_INSTRUCTION(UnmanagedAutoreleaseValue)
     REFCOUNTING_INSTRUCTION(StrongPin)
     REFCOUNTING_INSTRUCTION(StrongRetain)
     REFCOUNTING_INSTRUCTION(StrongRelease)
@@ -3724,6 +3724,12 @@
     ResultVal = B.createDeinitExistentialAddr(InstLoc, Val);
     break;
   }
+  case ValueKind::DeinitExistentialOpaqueInst: {
+    if (parseTypedValueRef(Val, B) || parseSILDebugLocation(InstLoc, B))
+      return true;
+    ResultVal = B.createDeinitExistentialOpaque(InstLoc, Val);
+    break;
+  }
   case ValueKind::InitExistentialAddrInst: {
     CanType Ty;
     SourceLoc TyLoc;
@@ -3758,7 +3764,7 @@
     SourceLoc TyLoc;
 
     if (parseTypedValueRef(Val, B) ||
-        P.parseToken(tok::colon, diag::expected_tok_in_sil_instr, ":") ||
+        P.parseToken(tok::comma, diag::expected_tok_in_sil_instr, ",") ||
         P.parseToken(tok::sil_dollar, diag::expected_tok_in_sil_instr, "$") ||
         parseASTType(FormalConcreteTy, TyLoc) ||
         P.parseToken(tok::comma, diag::expected_tok_in_sil_instr, ",") ||
diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp
index ed621fd..f670b8b 100644
--- a/lib/Parse/ParseStmt.cpp
+++ b/lib/Parse/ParseStmt.cpp
@@ -1486,358 +1486,6 @@
               new (Context) GuardStmt(GuardLoc, Condition, Body.get()));
 }
 
-
-// Evaluate a subset of expression types suitable for build configuration
-// conditional expressions.  The accepted expression types are:
-//  - The magic constants "true" and "false".
-//  - Named decl ref expressions ("FOO")
-//  - Parenthesized expressions ("(FOO)")
-//  - Binary "&&" or "||" operations applied to other build configuration
-//    conditional expressions
-//  - Unary "!" expressions applied to other build configuration conditional
-//    expressions
-//  - Single-argument call expressions, where the function being invoked is a
-//    supported target configuration (currently "os", "arch", and
-//    "_compiler_version"), and whose argument is a named decl ref expression
-ConditionalCompilationExprState
-Parser::classifyConditionalCompilationExpr(Expr *condition,
-                                           ASTContext &Context,
-                                           DiagnosticEngine &D) {
-  assert(condition && "Cannot classify a NULL condition expression!");
-
-  // Evaluate a ParenExpr.
-  if (auto *PE = dyn_cast<ParenExpr>(condition))
-    return classifyConditionalCompilationExpr(PE->getSubExpr(), Context, D);
-
-  // Evaluate a "&&" or "||" expression.
-  if (auto *SE = dyn_cast<SequenceExpr>(condition)) {
-    // Check for '&&' or '||' as the expression type.
-    if (SE->getNumElements() < 3) {
-      D.diagnose(SE->getLoc(),
-                 diag::unsupported_conditional_compilation_binary_expression);
-      return ConditionalCompilationExprState::error();
-    }
-    // Before type checking, chains of binary expressions will not be fully
-    // parsed, so associativity has not yet been encoded in the subtree.
-    auto elements = SE->getElements();
-    auto numElements = SE->getNumElements();
-    size_t iOperator = 1;
-    size_t iOperand = 2;
-
-    auto result = classifyConditionalCompilationExpr(elements[0], Context, D);
-
-    while (iOperand < numElements) {
-
-      if (auto *UDREOp = dyn_cast<UnresolvedDeclRefExpr>(elements[iOperator])) {
-        auto name = UDREOp->getName().getBaseName().str();
-
-        if (name.equals("||") || name.equals("&&")) {
-          auto rhs = classifyConditionalCompilationExpr(elements[iOperand],
-                                                        Context, D);
-
-          if (name.equals("||")) {
-            result = result || rhs;
-            if (result.isConditionActive())
-              break;
-          }
-
-          if (name.equals("&&")) {
-            result = result && rhs;
-            if (!result.isConditionActive())
-              break;
-          }
-        } else {
-          D.diagnose(
-              SE->getLoc(),
-              diag::unsupported_conditional_compilation_binary_expression);
-          return ConditionalCompilationExprState::error();
-        }
-      } else {
-        // Swift3 didn't have this branch. the operator and the RHS are
-        // silently ignored.
-        if (!Context.isSwiftVersion3()) {
-          D.diagnose(
-              elements[iOperator]->getLoc(),
-              diag::unsupported_conditional_compilation_expression_type);
-          return ConditionalCompilationExprState::error();
-        } else {
-          SourceRange ignoredRange(elements[iOperator]->getLoc(),
-                                   elements[iOperand]->getEndLoc());
-          D.diagnose(
-              elements[iOperator]->getLoc(),
-              diag::swift3_unsupported_conditional_compilation_expression_type)
-            .highlight(ignoredRange);
-        }
-      }
-
-      iOperator += 2;
-      iOperand += 2;
-    }
-
-    return result;
-  }
-
-  // Evaluate a named reference expression.
-  if (auto *UDRE = dyn_cast<UnresolvedDeclRefExpr>(condition)) {
-    auto name = UDRE->getName().getBaseName().str();
-    return {Context.LangOpts.isCustomConditionalCompilationFlagSet(name),
-      ConditionalCompilationExprKind::DeclRef};
-  }
-
-  // Evaluate a Boolean literal.
-  if (auto *boolLit = dyn_cast<BooleanLiteralExpr>(condition)) {
-    return {boolLit->getValue(), ConditionalCompilationExprKind::Boolean};
-  }
-
-  // Evaluate a negation (unary "!") expression.
-  if (auto *PUE = dyn_cast<PrefixUnaryExpr>(condition)) {
-    // If the PUE is not a negation expression, return false
-    auto name =
-    cast<UnresolvedDeclRefExpr>(PUE->getFn())->getName().getBaseName().str();
-    if (name != "!") {
-      D.diagnose(PUE->getLoc(),
-                 diag::unsupported_conditional_compilation_unary_expression);
-      return ConditionalCompilationExprState::error();
-    }
-
-    return !classifyConditionalCompilationExpr(PUE->getArg(), Context, D);
-  }
-
-  // Evaluate a target config call expression.
-  if (auto *CE = dyn_cast<CallExpr>(condition)) {
-    // look up target config, and compare value
-    auto fnNameExpr = dyn_cast<UnresolvedDeclRefExpr>(CE->getFn());
-
-    // Get the arg, which should be in a paren expression.
-    if (!fnNameExpr) {
-      D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_expression);
-      return ConditionalCompilationExprState::error();
-    }
-
-    auto fnName = fnNameExpr->getName().getBaseName().str();
-
-    auto *PE = dyn_cast<ParenExpr>(CE->getArg());
-    if (!PE) {
-      auto diag = D.diagnose(CE->getLoc(),
-                             diag::platform_condition_expected_one_argument);
-      return ConditionalCompilationExprState::error();
-    }
-
-    if (!fnName.equals("arch") && !fnName.equals("os") &&
-        !fnName.equals("_endian") &&
-        !fnName.equals("_runtime") &&
-        !fnName.equals("swift") &&
-        !fnName.equals("_compiler_version")) {
-      D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_expression);
-      return ConditionalCompilationExprState::error();
-    }
-
-    if (fnName.equals("_compiler_version")) {
-      if (auto SLE = dyn_cast<StringLiteralExpr>(PE->getSubExpr())) {
-        if (SLE->getValue().empty()) {
-          D.diagnose(CE->getLoc(), diag::empty_version_string);
-          return ConditionalCompilationExprState::error();
-        }
-        auto versionRequirement =
-        version::Version::parseCompilerVersionString(SLE->getValue(),
-                                                     SLE->getLoc(),
-                                                     &D);
-        auto thisVersion = version::Version::getCurrentCompilerVersion();
-        auto VersionNewEnough = thisVersion >= versionRequirement;
-        return {VersionNewEnough,
-          ConditionalCompilationExprKind::CompilerVersion};
-      } else {
-        D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_argument,
-                 "string literal");
-        return ConditionalCompilationExprState::error();
-      }
-    } else if (fnName.equals("swift")) {
-      auto PUE = dyn_cast<PrefixUnaryExpr>(PE->getSubExpr());
-      if (!PUE) {
-        D.diagnose(PE->getSubExpr()->getLoc(),
-                   diag::unsupported_platform_condition_argument,
-                   "a unary comparison, such as '>=2.2'");
-        return ConditionalCompilationExprState::error();
-      }
-
-      auto prefix = dyn_cast<UnresolvedDeclRefExpr>(PUE->getFn());
-      auto versionArg = PUE->getArg();
-      auto versionStartLoc = versionArg->getStartLoc();
-      auto endLoc = Lexer::getLocForEndOfToken(Context.SourceMgr,
-                                               versionArg->getSourceRange().End);
-      CharSourceRange versionCharRange(Context.SourceMgr, versionStartLoc,
-                                       endLoc);
-      auto versionString = Context.SourceMgr.extractText(versionCharRange);
-
-      auto versionRequirement =
-        version::Version::parseVersionString(versionString,
-                                             versionStartLoc,
-                                             &D);
-
-      if (!versionRequirement.hasValue())
-        return ConditionalCompilationExprState::error();
-
-      auto thisVersion = Context.LangOpts.EffectiveLanguageVersion;
-
-      if (!prefix->getName().getBaseName().str().equals(">=")) {
-        D.diagnose(PUE->getFn()->getLoc(),
-                   diag::unexpected_version_comparison_operator)
-          .fixItReplace(PUE->getFn()->getLoc(), ">=");
-        return ConditionalCompilationExprState::error();
-      }
-
-      auto VersionNewEnough = thisVersion >= versionRequirement.getValue();
-      return {VersionNewEnough,
-        ConditionalCompilationExprKind::LanguageVersion};
-    } else {
-      if (auto UDRE = dyn_cast<UnresolvedDeclRefExpr>(PE->getSubExpr())) {
-        // The sub expression should be an UnresolvedDeclRefExpr (we won't
-        // tolerate extra parens).
-        auto argumentIdent = UDRE->getName().getBaseName();
-        auto argument = argumentIdent.str();
-
-        // Error for values that don't make sense if there's a clear definition
-        // of the possible values (as there is for _runtime).
-        if (fnName.equals("_runtime") &&
-            !argument.equals("_ObjC") && !argument.equals("_Native")) {
-          D.diagnose(CE->getLoc(),
-                     diag::unsupported_platform_runtime_condition_argument);
-          return ConditionalCompilationExprState::error();
-        }
-
-        std::vector<StringRef> suggestions;
-        SWIFT_DEFER {
-          for (const StringRef& suggestion : suggestions) {
-            D.diagnose(UDRE->getLoc(), diag::note_typo_candidate,
-                       suggestion)
-            .fixItReplace(UDRE->getSourceRange(), suggestion);
-          }
-        };
-        if (fnName == "os") {
-          if (!LangOptions::checkPlatformConditionOS(argument,
-                                                     suggestions)) {
-            D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
-                       "operating system", fnName);
-            return ConditionalCompilationExprState::error();
-          }
-        } else if (fnName == "arch") {
-          if (!LangOptions::isPlatformConditionArchSupported(argument,
-                                                             suggestions)) {
-            D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
-                       "architecture", fnName);
-            return ConditionalCompilationExprState::error();
-          }
-        } else if (fnName == "_endian") {
-          if (!LangOptions::isPlatformConditionEndiannessSupported(argument,
-                                                                   suggestions)) {
-            D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
-                       "endianness", fnName);
-          }
-        }
-
-        // FIXME: Perform the replacement macOS -> OSX elsewhere.
-        if (fnName == "os" && argument == "macOS")
-          argument = "OSX";
-
-        auto target = Context.LangOpts.getPlatformConditionValue(fnName);
-        return {target == argument, ConditionalCompilationExprKind::DeclRef};
-      } else {
-        D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_argument,
-                   "identifier");
-        return ConditionalCompilationExprState::error();
-      }
-    }
-  }
-
-  // "#if 0" isn't valid, but it is common, so recognize it and handle it
-  // with a fixit elegantly.
-  if (auto *IL = dyn_cast<IntegerLiteralExpr>(condition))
-    if (IL->getDigitsText() == "0" || IL->getDigitsText() == "1") {
-      StringRef replacement = IL->getDigitsText() == "0" ? "false" :"true";
-      D.diagnose(IL->getLoc(), diag::unsupported_conditional_compilation_integer,
-                 IL->getDigitsText(), replacement)
-       .fixItReplace(IL->getLoc(), replacement);
-      return {IL->getDigitsText() == "1",
-        ConditionalCompilationExprKind::Integer};
-    }
-
-
-  // If we've gotten here, it's an unsupported expression type.
-  D.diagnose(condition->getLoc(),
-             diag::unsupported_conditional_compilation_expression_type);
-  return ConditionalCompilationExprState::error();
-}
-
-ParserResult<Stmt> Parser::parseStmtIfConfig(BraceItemListKind Kind) {
-  StructureMarkerRAII ParsingDecl(*this, Tok.getLoc(),
-                                  StructureMarkerKind::IfConfig);
-  SmallVector<IfConfigStmtClause, 4> Clauses;
-
-  bool foundActive = false;
-  ConditionalCompilationExprState ConfigState;
-  while (1) {
-    bool isElse = Tok.is(tok::pound_else);
-    SourceLoc ClauseLoc = consumeToken();
-    Expr *Condition = nullptr;
-
-    if (isElse) {
-      ConfigState.setConditionActive(!foundActive);
-    } else {
-      // Evaluate the condition.
-      llvm::SaveAndRestore<bool> S(InPoundIfEnvironment, true);
-      ParserResult<Expr> Result = parseExprSequence(diag::expected_expr,
-                                                    /*basic*/true,
-                                                    /*isForDirective*/true);
-      if (Result.isNull())
-        return makeParserError();
-
-      Condition = Result.get();
-
-      // Evaluate the condition, to validate it.
-      ConfigState = classifyConditionalCompilationExpr(Condition, Context,
-                                                       Diags);
-      if (foundActive)
-        ConfigState.setConditionActive(false);
-    }
-
-    foundActive |= ConfigState.isConditionActive();
-
-    if (!Tok.isAtStartOfLine() && Tok.isNot(tok::eof)) {
-      diagnose(Tok.getLoc(),
-               diag::extra_tokens_conditional_compilation_directive);
-    }
-
-    SmallVector<ASTNode, 16> Elements;
-    if (ConfigState.shouldParse()) {
-      parseBraceItems(Elements, Kind,
-                      ConfigState.isConditionActive()
-                        ? BraceItemListKind::ActiveConditionalBlock
-                        : BraceItemListKind::InactiveConditionalBlock);
-    } else {
-      DiagnosticTransaction DT(Diags);
-      skipUntilConditionalBlockClose();
-      DT.abort();
-    }
-
-    Clauses.push_back(IfConfigStmtClause(ClauseLoc, Condition,
-                                         Context.AllocateCopy(Elements),
-                                         ConfigState.isConditionActive()));
-
-    if (Tok.isNot(tok::pound_elseif) && Tok.isNot(tok::pound_else))
-      break;
-
-    if (isElse)
-      diagnose(Tok, diag::expected_close_after_else_directive);
-  }
-
-  SourceLoc EndLoc;
-  bool HadMissingEnd = parseEndIfDirective(EndLoc);
-
-  auto *ICS = new (Context) IfConfigStmt(Context.AllocateCopy(Clauses),
-                                         EndLoc, HadMissingEnd);
-  return makeParserResult(ICS);
-}
-
 /// 
 ///   stmt-while:
 ///     (identifier ':')? 'while' expr-basic stmt-brace
diff --git a/lib/PrintAsObjC/PrintAsObjC.cpp b/lib/PrintAsObjC/PrintAsObjC.cpp
index 66e142d..32521d1 100644
--- a/lib/PrintAsObjC/PrintAsObjC.cpp
+++ b/lib/PrintAsObjC/PrintAsObjC.cpp
@@ -15,6 +15,7 @@
 #include "swift/AST/AST.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ForeignErrorConvention.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/ProtocolConformance.h"
@@ -172,6 +173,23 @@
     ASTVisitor::visit(const_cast<Decl *>(D));
   }
 
+  void maybePrintObjCGenericParameters(const ClassDecl *importedClass) {
+    auto *clangDecl = importedClass->getClangDecl();
+    auto *objcClass = dyn_cast_or_null<clang::ObjCInterfaceDecl>(clangDecl);
+    if (!objcClass)
+      return;
+    if (!objcClass->getTypeParamList())
+      return;
+    assert(objcClass->getTypeParamList()->size() != 0);
+    os << "<";
+    interleave(*objcClass->getTypeParamList(),
+               [this](const clang::ObjCTypeParamDecl *param) {
+                 os << param->getName();
+               },
+               [this] { os << ", "; });
+    os << ">";
+  }
+
   void printAdHocCategory(iterator_range<const ValueDecl * const *> members) {
     assert(members.begin() != members.end());
 
@@ -182,8 +200,10 @@
       baseClass = extendedTy->getClassOrBoundGenericClass();
     }
 
-    os << "@interface " << getNameForObjC(baseClass)
-    << " (SWIFT_EXTENSION(" << origDC->getParentModule()->getName() << "))\n";
+    os << "@interface " << getNameForObjC(baseClass);
+    maybePrintObjCGenericParameters(baseClass);
+    os << " (SWIFT_EXTENSION(" << origDC->getParentModule()->getName()
+       << "))\n";
     printMembers</*allowDelayed*/true>(members);
     os << "@end\n\n";
   }
@@ -312,8 +332,9 @@
   void visitExtensionDecl(ExtensionDecl *ED) {
     auto baseClass = ED->getExtendedType()->getClassOrBoundGenericClass();
 
-    os << "@interface " << getNameForObjC(baseClass)
-       << " (SWIFT_EXTENSION(" << ED->getModuleContext()->getName() << "))";
+    os << "@interface " << getNameForObjC(baseClass);
+    maybePrintObjCGenericParameters(baseClass);
+    os << " (SWIFT_EXTENSION(" << ED->getModuleContext()->getName() << "))";
     printProtocols(ED->getLocalProtocols(ConformanceLookupKind::OnlyExplicit));
     os << "\n";
     printMembers(ED->getMembers());
@@ -1574,6 +1595,30 @@
       visitType(MT, optionalKind);
     }
   }
+
+  void visitGenericTypeParamType(GenericTypeParamType *type,
+                                 Optional<OptionalTypeKind> optionalKind) {
+    const GenericTypeParamDecl *decl = type->getDecl();
+    assert(decl && "can't print canonicalized GenericTypeParamType");
+
+    if (auto *extension = dyn_cast<ExtensionDecl>(decl->getDeclContext())) {
+      const ClassDecl *extendedClass =
+          extension->getAsClassOrClassExtensionContext();
+      assert(extendedClass->isGeneric());
+      assert(extension->getGenericParams()->size() ==
+             extendedClass->getGenericParams()->size() &&
+             "extensions with custom generic parameters?");
+      assert(extension->getGenericSignature()->getCanonicalSignature() ==
+             extendedClass->getGenericSignature()->getCanonicalSignature() &&
+             "constrained extensions or custom generic parameters?");
+      type = extendedClass->getGenericEnvironment()->getSugaredType(type);
+      decl = type->getDecl();
+    }
+
+    assert(decl->getClangDecl() && "can only handle imported ObjC generics");
+    os << cast<clang::ObjCTypeParamDecl>(decl->getClangDecl())->getName();
+    printNullability(optionalKind);
+  }
                       
   void printFunctionType(FunctionType *FT, char pointerSigil,
                          Optional<OptionalTypeKind> optionalKind) {
diff --git a/lib/SIL/DynamicCasts.cpp b/lib/SIL/DynamicCasts.cpp
index e528d87..eedca48 100644
--- a/lib/SIL/DynamicCasts.cpp
+++ b/lib/SIL/DynamicCasts.cpp
@@ -1139,23 +1139,30 @@
   // non-NSError superclass constraint. Casts to archetypes thus must always be
   // indirect.
   if (auto archetype = targetType->getAs<ArchetypeType>()) {
-    auto super = archetype->getSuperclass();
-    if (super.isNull())
-      return false;
-
     // Only ever permit this if the source type is a reference type.
     if (!objectType.isAnyClassReferenceType())
       return false;
+    
+    if (M.getASTContext().LangOpts.EnableObjCInterop) {
+      auto super = archetype->getSuperclass();
+      if (super.isNull())
+        return false;
 
-    // A base class constraint that isn't NSError rules out the archetype being
-    // bound to NSError.
-    if (auto nserror = M.Types.getNSErrorType())
-      return !super->isEqual(nserror);
-    // If NSError wasn't loaded, any base class constraint must not be NSError.
-    return true;
+      // A base class constraint that isn't NSError rules out the archetype being
+      // bound to NSError.
+        if (auto nserror = M.Types.getNSErrorType())
+          return !super->isEqual(nserror);
+      // If NSError wasn't loaded, any base class constraint must not be NSError.
+      return true;
+    } else {
+      // If ObjC bridging isn't enabled, we can do a scalar cast from any
+      // reference type to any class-constrained archetype.
+      return archetype->requiresClass();
+    }
   }
   
-  if (targetType == M.Types.getNSErrorType()) {
+  if (M.getASTContext().LangOpts.EnableObjCInterop
+      && targetType == M.Types.getNSErrorType()) {
     // If we statically know the source is an NSError subclass, then the cast
     // can go through the scalar path (and it's trivially true so can be
     // killed).
diff --git a/lib/SIL/SILBuilder.cpp b/lib/SIL/SILBuilder.cpp
index 8961f2d..e0dee29 100644
--- a/lib/SIL/SILBuilder.cpp
+++ b/lib/SIL/SILBuilder.cpp
@@ -245,7 +245,7 @@
   }
 
   // If we didn't find a retain to fold this into, emit the release.
-  return createStrongRelease(Loc, Operand, Atomicity::Atomic);
+  return createStrongRelease(Loc, Operand, getDefaultAtomicity());
 }
 
 /// Emit a release_value instruction at the current location, attempting to
@@ -272,7 +272,7 @@
   }
 
   // If we didn't find a retain to fold this into, emit the release.
-  return createReleaseValue(Loc, Operand, Atomicity::Atomic);
+  return createReleaseValue(Loc, Operand, getDefaultAtomicity());
 }
 
 PointerUnion<CopyValueInst *, DestroyValueInst *>
diff --git a/lib/SIL/SILFunction.cpp b/lib/SIL/SILFunction.cpp
index d1b799d..e6573ea 100644
--- a/lib/SIL/SILFunction.cpp
+++ b/lib/SIL/SILFunction.cpp
@@ -163,109 +163,24 @@
       getGenericEnvironment(), type);
 }
 
-namespace {
-template<typename SubstFn>
-struct SubstDependentSILType
-  : CanTypeVisitor<SubstDependentSILType<SubstFn>, CanType>
-{
-  SILModule &M;
-  SubstFn Subst;
-  
-  SubstDependentSILType(SILModule &M, SubstFn Subst)
-    : M(M), Subst(std::move(Subst))
-  {}
-  
-  using super = CanTypeVisitor<SubstDependentSILType<SubstFn>, CanType>;
-  using super::visit;
-  
-  CanType visitDependentMemberType(CanDependentMemberType t) {
-    // If a dependent member type appears in lowered position, we need to lower
-    // its context substitution against the associated type's abstraction
-    // pattern.
-    CanType astTy = Subst(t);
-    auto origTy = AbstractionPattern::getOpaque();
-    
-    return M.Types.getLoweredType(origTy, astTy)
-      .getSwiftRValueType();
-  }
-  
-  CanType visitTupleType(CanTupleType t) {
-    // Dependent members can appear in lowered position inside tuples.
-    
-    SmallVector<TupleTypeElt, 4> elements;
-    
-    for (auto &elt : t->getElements())
-      elements.push_back(elt.getWithType(visit(CanType(elt.getType()))));
-    
-    return TupleType::get(elements, t->getASTContext())
-      ->getCanonicalType();
-  }
-  
-  CanType visitSILFunctionType(CanSILFunctionType t) {
-    // Dependent members can appear in lowered position inside SIL functions.
-    
-    SmallVector<SILParameterInfo, 4> params;
-    for (auto &param : t->getParameters())
-      params.push_back(param.map([&](CanType pt) -> CanType {
-        return visit(pt);
-      }));
-
-    SmallVector<SILResultInfo, 4> results;
-    for (auto &result : t->getResults())
-      results.push_back(result.map([&](CanType pt) -> CanType {
-        return visit(pt);
-      }));
-    
-    Optional<SILResultInfo> errorResult;
-    if (t->hasErrorResult()) {
-      errorResult = t->getErrorResult().map([&](CanType elt) -> CanType {
-          return visit(elt);
-      });
-    }
-    
-    return SILFunctionType::get(t->getGenericSignature(),
-                                t->getExtInfo(),
-                                t->getCalleeConvention(),
-                                params, results, errorResult,
-                                t->getASTContext());
-  }
-  
-  CanType visitType(CanType t) {
-    // Other types get substituted into context normally.
-    return Subst(t);
-  }
-};
-
-template<typename SubstFn>
-SILType doSubstDependentSILType(SILModule &M,
-                                SubstFn Subst,
-                                SILType t) {
-  CanType result = SubstDependentSILType<SubstFn>(M, std::move(Subst))
-    .visit(t.getSwiftRValueType());
-  return SILType::getPrimitiveType(result, t.getCategory());
-}
-  
-} // end anonymous namespace
-
 SILType SILFunction::mapTypeIntoContext(SILType type) const {
-  return doSubstDependentSILType(getModule(),
-    [&](CanType t) { return mapTypeIntoContext(t)->getCanonicalType(); },
-    type);
+  if (auto *genericEnv = getGenericEnvironment())
+    return genericEnv->mapTypeIntoContext(getModule(), type);
+  return type;
 }
 
 SILType GenericEnvironment::mapTypeIntoContext(SILModule &M,
                                                SILType type) const {
-  return doSubstDependentSILType(M,
-    [&](CanType t) {
-      return mapTypeIntoContext(t)->getCanonicalType();
-    },
-    type);
+  auto genericSig = getGenericSignature()->getCanonicalSignature();
+  return type.subst(M,
+                    QueryInterfaceTypeSubstitutions(this),
+                    LookUpConformanceInSignature(*genericSig),
+                    genericSig);
 }
 
 Type SILFunction::mapTypeOutOfContext(Type type) const {
   return GenericEnvironment::mapTypeOutOfContext(
-      getGenericEnvironment(),
-      type);
+      getGenericEnvironment(), type);
 }
 
 bool SILFunction::isNoReturnFunction() const {
diff --git a/lib/SIL/SILFunctionType.cpp b/lib/SIL/SILFunctionType.cpp
index 09cd8f2..3246a39 100644
--- a/lib/SIL/SILFunctionType.cpp
+++ b/lib/SIL/SILFunctionType.cpp
@@ -1760,268 +1760,6 @@
   return result;
 }
 
-namespace {
-  class SILFunctionTypeSubstituter {
-    TypeConverter &TC;
-    CanSILFunctionType OrigFnType;
-    ArrayRef<SILParameterInfo> OrigParams;
-    ArrayRef<SILResultInfo> OrigResults;
-    unsigned NextOrigParamIndex = 0;
-    unsigned NextOrigResultIndex = 0;
-    SmallVector<SILParameterInfo, 8> SubstParams;
-    SmallVector<SILResultInfo, 8> SubstResults;
-    const Optional<ForeignErrorConvention> &ForeignError;
-
-  public:
-    SILFunctionTypeSubstituter(
-        TypeConverter &TC, CanSILFunctionType origFnType,
-        const Optional<ForeignErrorConvention> &foreignError)
-        : TC(TC), OrigFnType(origFnType),
-          OrigParams(origFnType->getParameters()),
-          OrigResults(origFnType->getResults()), ForeignError(foreignError) {}
-
-    ArrayRef<SILResultInfo> getSubstResults() const {
-      assert(NextOrigResultIndex == OrigResults.size() &&
-             "didn't claim all results?!");
-      return SubstResults;
-    }
-
-    void substResults(AbstractionPattern origType, CanType substType);
-
-    ArrayRef<SILParameterInfo> getSubstParams() const {
-      assert(NextOrigParamIndex == OrigParams.size() &&
-             "didn't claim all parameters?!");
-      return SubstParams;
-    }
-
-    void substInputs(AbstractionPattern origType, CanType substType) {
-      maybeSkipForeignErrorParameter();
-
-      // Decompose tuples.
-      if (origType.isTuple()) {
-        auto substTuple = cast<TupleType>(substType);
-        assert(origType.getNumTupleElements() == substTuple->getNumElements());
-        for (auto i : indices(substTuple.getElementTypes())) {
-          substInputs(origType.getTupleElementType(i),
-                      substTuple.getElementType(i));
-        }
-        return;
-      }
-
-      // Every other type corresponds to a single parameter in the
-      // original signature, since we're dealing with like-uncurried
-      // types and thus don't have to worry about expanding archetypes
-      // to unmaterializable parameter clauses in result function types.
-      auto origParam = claimNextOrigParam();
-
-      // If the type hasn't changed and doesn't rely on context, just use the
-      // original parameter.
-      if (origType.isExactType(substType) &&
-          !origParam.getType()->hasTypeParameter()) {
-        SubstParams.push_back(origParam);
-        return;
-      }
-
-      // Otherwise, lower the substituted type using the abstraction
-      // patterns of the original.
-      auto &substTL = TC.getTypeLowering(origType, substType);
-      auto substConvention = getSubstConvention(origParam.getConvention(),
-                                                substTL.isTrivial());
-      assert(isIndirectFormalParameter(substConvention)
-             || !substTL.isAddressOnly());
-      addSubstParam(substTL.getLoweredType().getSwiftRValueType(),
-                    substConvention);
-    }
-
-  private:
-    void decomposeResult(AbstractionPattern origType, CanType substType);
-
-    SILParameterInfo claimNextOrigParam() {
-      maybeSkipForeignErrorParameter();
-      return OrigParams[NextOrigParamIndex++];
-    }
-
-    SILResultInfo claimNextOrigResult() {
-      return OrigResults[NextOrigResultIndex++];
-    }
-
-    void maybeSkipForeignErrorParameter() {
-      if (!ForeignError ||
-          NextOrigParamIndex != ForeignError->getErrorParameterIndex())
-        return;
-      SubstParams.push_back(OrigParams[NextOrigParamIndex++]);
-    }
-
-    void addSubstParam(CanType type, ParameterConvention conv) {
-      SubstParams.push_back(SILParameterInfo(type, conv));
-    }
-
-    ParameterConvention getSubstConvention(ParameterConvention orig,
-                                           bool isTrivial) {
-      // We use the original convention, except that we have an
-      // invariant that direct trivial parameters are always unowned.
-      switch (orig) {
-      case ParameterConvention::Direct_Owned:
-      case ParameterConvention::Direct_Guaranteed:
-        if (isTrivial) return ParameterConvention::Direct_Unowned;
-        LLVM_FALLTHROUGH;
-      case ParameterConvention::Direct_Unowned:
-      case ParameterConvention::Indirect_Inout:
-      case ParameterConvention::Indirect_InoutAliasable:
-      case ParameterConvention::Indirect_In:
-      case ParameterConvention::Indirect_In_Guaranteed:
-        return orig;
-      }
-      llvm_unreachable("bad parameter convention");
-    }
-
-    ResultConvention getSubstConvention(ResultConvention orig,
-                                        bool isTrivial) {
-      // We use the original convention, except that we have an
-      // invariant that direct trivial results are always unowned.
-      switch (orig) {
-      case ResultConvention::Owned:
-      case ResultConvention::Autoreleased:
-        if (isTrivial) return ResultConvention::Unowned;
-        LLVM_FALLTHROUGH;
-      case ResultConvention::Indirect:
-      case ResultConvention::Unowned:
-      case ResultConvention::UnownedInnerPointer:
-        return orig;
-      }
-      llvm_unreachable("bad parameter convention");
-    }
-  };
-} // end anonymous namespace
-
-void SILFunctionTypeSubstituter::substResults(AbstractionPattern origResultType,
-                                              CanType substResultType) {
-  // Fast path: if the results of the original type are not type-dependent,
-  // we can just copy them over.
-  auto allResults = OrigFnType->getResults();
-  if (std::find_if(allResults.begin(), allResults.end(),
-                   [&](SILResultInfo result) { 
-                     return result.getType()->hasTypeParameter();
-                   }) == allResults.end()) {
-    SubstResults.append(allResults.begin(), allResults.end());
-    return;
-  }
-
-  // Okay, we need to walk the types and re-lower.
-
-  // If we have a foreign-error convention that strips result
-  // optionality, we need to wrap both the original and
-  // substituted types in a level of optionality.
-  if (ForeignError && ForeignError->stripsResultOptionality()) {
-    origResultType =
-      AbstractionPattern::getOptional(origResultType, OTK_Optional);
-    substResultType =
-      OptionalType::get(substResultType)->getCanonicalType();
-  }
-
-  decomposeResult(origResultType, substResultType);
-}
-
-void
-SILFunctionTypeSubstituter::decomposeResult(AbstractionPattern origResultType,
-                                            CanType substResultType) {
-  // If the result is a tuple, we need to expand it.
-  if (origResultType.isTuple()) {
-    auto substResultTupleType = cast<TupleType>(substResultType);
-    for (auto eltIndex : indices(substResultTupleType.getElementTypes())) {
-      auto origEltType = origResultType.getTupleElementType(eltIndex);
-      auto substEltType = substResultTupleType.getElementType(eltIndex);
-      decomposeResult(origEltType, substEltType);
-    }
-    return;
-  }
-
-  // Okay, the result is a single value, which will either be an
-  // indirect result or not.
-
-  // Grab the next result.
-  SILResultInfo origResult = claimNextOrigResult();
-
-  // If substitution is trivial, fast path.
-  if (!origResult.getType()->hasTypeParameter()) {
-    SubstResults.push_back(origResult);
-    return;
-  }
-
-  // Lower the substituted result using the abstraction patterns
-  // of the original result.
-  auto &substResultTL = TC.getTypeLowering(origResultType, substResultType);
-  auto loweredResultTy = substResultTL.getLoweredType().getSwiftRValueType();
-
-  // Return the new type with the old convention.
-  SILResultInfo substResult(loweredResultTy,
-                            getSubstConvention(origResult.getConvention(),
-                                               substResultTL.isTrivial()));
-  SubstResults.push_back(substResult);
-}
-
-/// Apply a substitution to the given SILFunctionType so that it has
-/// the form of the normal SILFunctionType for the substituted type,
-/// except using the original conventions.
-///
-/// This is equivalent to
-///    getLoweredType(origLoweredType,
-///                   substLoweredType).castTo<SILFunctionType>()
-/// except that origFnType's conventions may not correspond to the
-/// standard conventions of the lowered type.
-CanSILFunctionType
-TypeConverter::substFunctionType(CanSILFunctionType origFnType,
-                                 CanAnyFunctionType origLoweredType,
-                                 CanAnyFunctionType substLoweredInterfaceType,
-                         const Optional<ForeignErrorConvention> &foreignError) {
-  // FIXME: is this inefficient now?
-  if (origLoweredType == substLoweredInterfaceType)
-    return origFnType;
-
-  // Use the generic parameters from the substituted type.
-  CanGenericSignature genericSig;
-  if (auto genSubstFn = dyn_cast<GenericFunctionType>(substLoweredInterfaceType))
-    genericSig = genSubstFn.getGenericSignature();
-
-  GenericContextScope scope(*this, genericSig);
-  SILFunctionTypeSubstituter substituter(*this, origFnType, foreignError);
-
-  AbstractionPattern origLoweredPattern(origLoweredType);
-
-  // Map the results.
-  substituter.substResults(origLoweredPattern.getFunctionResultType(),
-                           substLoweredInterfaceType.getResult());
-
-  // Map the error result.  Currently this is never dependent.
-  Optional<SILResultInfo> substErrorResult
-    = origFnType->getOptionalErrorResult();
-  assert(!substErrorResult ||
-         (!substErrorResult->getType()->hasTypeParameter() &&
-          !substErrorResult->getType()->hasArchetype()));
-
-  // Map the inputs.
-  substituter.substInputs(origLoweredPattern.getFunctionInputType(),
-                          substLoweredInterfaceType.getInput());
-
-  // Allow the substituted type to add thick-ness, but not remove it.
-  assert(!origFnType->getExtInfo().hasContext()
-           || substLoweredInterfaceType->getExtInfo().hasContext());
-  assert(substLoweredInterfaceType->getExtInfo().getSILRepresentation()
-           == substLoweredInterfaceType->getExtInfo().getSILRepresentation());
-
-  auto rep = substLoweredInterfaceType->getExtInfo().getSILRepresentation();
-  auto extInfo = origFnType->getExtInfo().withRepresentation(rep);
-
-  // FIXME: Map into archetype context.
-  return SILFunctionType::get(genericSig,
-                              extInfo,
-                              origFnType->getCalleeConvention(),
-                              substituter.getSubstParams(),
-                              substituter.getSubstResults(),
-                              substErrorResult,
-                              Context);
-}
-
 /// Returns the SILParameterInfo for the given declaration's `self` parameter.
 /// `constant` must refer to a method.
 SILParameterInfo TypeConverter::getConstantSelfParameter(SILDeclRef constant) {
@@ -2129,27 +1867,38 @@
     SILModule &TheSILModule;
     TypeSubstitutionFn Subst;
     LookupConformanceFn Conformances;
+    // The signature for the original type.
+    //
+    // Replacement types are lowered with respect to the current
+    // context signature.
+    CanGenericSignature Sig;
 
     ASTContext &getASTContext() { return TheSILModule.getASTContext(); }
 
   public:
     SILTypeSubstituter(SILModule &silModule,
                        TypeSubstitutionFn Subst,
-                       LookupConformanceFn Conformances)
+                       LookupConformanceFn Conformances,
+                       CanGenericSignature Sig)
       : TheSILModule(silModule),
         Subst(Subst),
-        Conformances(Conformances)
+        Conformances(Conformances),
+        Sig(Sig)
     {}
 
     // SIL type lowering only does special things to tuples and functions.
 
-    /// Functions need to preserve their abstraction structure.
-    CanSILFunctionType visitSILFunctionType(CanSILFunctionType origType,
-                                            bool dropGenerics = false)
-    {
-      GenericContextScope scope(TheSILModule.Types,
-                                origType->getGenericSignature());
+    // When a function appears inside of another type, we only perform
+    // substitutions if it does not have a generic signature.
+    CanSILFunctionType visitSILFunctionType(CanSILFunctionType origType) {
+      if (origType->getGenericSignature())
+        return origType;
 
+      return substSILFunctionType(origType);
+    }
+
+    // Entry point for use by SILType::substGenericArgs().
+    CanSILFunctionType substSILFunctionType(CanSILFunctionType origType) {
       SmallVector<SILResultInfo, 8> substResults;
       substResults.reserve(origType->getNumResults());
       for (auto origResult : origType->getResults()) {
@@ -2167,10 +1916,7 @@
         substParams.push_back(subst(origParam));
       }
 
-      auto genericSig
-        = (dropGenerics ? nullptr : origType->getGenericSignature());
-
-      return SILFunctionType::get(genericSig,
+      return SILFunctionType::get(nullptr,
                                   origType->getExtInfo(),
                                   origType->getCalleeConvention(),
                                   substParams, substResults,
@@ -2230,16 +1976,7 @@
     CanType visitType(CanType origType) {
       assert(!isa<AnyFunctionType>(origType));
       assert(!isa<LValueType>(origType) && !isa<InOutType>(origType));
-
-      CanGenericSignature genericSig =
-          TheSILModule.Types.getCurGenericContext();
-      AbstractionPattern abstraction(genericSig, origType);
-
-      assert(TheSILModule.Types.getLoweredType(abstraction, origType)
-               .getSwiftRValueType() == origType);
-
-      CanType substType =
-        origType.subst(Subst, Conformances, None)->getCanonicalType();
+      auto substType = origType.subst(Subst, Conformances)->getCanonicalType();
 
       // If the substitution didn't change anything, we know that the
       // original type was a lowered type, so we're good.
@@ -2247,6 +1984,7 @@
         return origType;
       }
 
+      AbstractionPattern abstraction(Sig, origType);
       return TheSILModule.Types.getLoweredType(abstraction, substType)
                .getSwiftRValueType();
     }
@@ -2255,8 +1993,15 @@
 
 SILType SILType::subst(SILModule &silModule,
                        TypeSubstitutionFn subs,
-                       LookupConformanceFn conformances) const {
-  SILTypeSubstituter STST(silModule, subs, conformances);
+                       LookupConformanceFn conformances,
+                       CanGenericSignature genericSig) const {
+  if (!hasArchetype() && !hasTypeParameter())
+    return *this;
+
+  if (!genericSig)
+    genericSig = silModule.Types.getCurGenericContext();
+  SILTypeSubstituter STST(silModule, subs, conformances,
+                          genericSig);
   return STST.subst(*this);
 }
 
@@ -2266,16 +2011,6 @@
                LookUpConformanceInSubstitutionMap(subs));
 }
 
-CanSILFunctionType SILType::substFuncType(SILModule &silModule,
-                                          const SubstitutionMap &subs,
-                                          CanSILFunctionType SrcTy,
-                                          bool dropGenerics) {
-  auto subFn = QuerySubstitutionMap{subs};
-  auto lookupFn = LookUpConformanceInSubstitutionMap(subs);
-  SILTypeSubstituter STST(silModule, subFn, lookupFn);
-  return STST.visitSILFunctionType(SrcTy, dropGenerics);
-}
-
 /// Apply a substitution to this polymorphic SILFunctionType so that
 /// it has the form of the normal SILFunctionType for the substituted
 /// type, except using the original conventions.
@@ -2313,9 +2048,9 @@
                                   TypeSubstitutionFn subs,
                                   LookupConformanceFn conformances) {
   if (!isPolymorphic()) return CanSILFunctionType(this);
-  SILTypeSubstituter substituter(silModule, subs, conformances);
-  return substituter.visitSILFunctionType(CanSILFunctionType(this),
-                                          /*dropGenerics*/ true);
+  SILTypeSubstituter substituter(silModule, subs, conformances,
+                                 getGenericSignature());
+  return substituter.substSILFunctionType(CanSILFunctionType(this));
 }
 
 /// Fast path for bridging types in a function type without uncurrying.
diff --git a/lib/SIL/SILOwnershipVerifier.cpp b/lib/SIL/SILOwnershipVerifier.cpp
index b8c1344..70da549 100644
--- a/lib/SIL/SILOwnershipVerifier.cpp
+++ b/lib/SIL/SILOwnershipVerifier.cpp
@@ -457,6 +457,7 @@
 CONSTANT_OR_TRIVIAL_OWNERSHIP_INST(Owned, true, CheckedCastBranch)
 CONSTANT_OR_TRIVIAL_OWNERSHIP_INST(Owned, true, SwitchEnum)
 CONSTANT_OR_TRIVIAL_OWNERSHIP_INST(Owned, true, InitExistentialOpaque)
+CONSTANT_OR_TRIVIAL_OWNERSHIP_INST(Owned, true, DeinitExistentialOpaque)
 #undef CONSTANT_OR_TRIVIAL_OWNERSHIP_INST
 
 #define ACCEPTS_ANY_OWNERSHIP_INST(INST)                                       \
@@ -1785,6 +1786,12 @@
   // If SILOwnership is not enabled, do not perform verification.
   if (!getModule().getOptions().EnableSILOwnership)
     return;
+
+  // If the given function has unqualified ownership, there is nothing to
+  // verify.
+  if (getFunction()->hasUnqualifiedOwnership())
+    return;
+
   // If we are testing the verifier, bail so we only print errors once when
   // performing a full verification, instead of additionally in the SILBuilder.
   if (IsSILOwnershipVerifierTestingEnabled)
@@ -1808,6 +1815,21 @@
 void SILValue::verifyOwnership(SILModule &Mod,
                                TransitivelyUnreachableBlocksInfo *TUB) const {
 #ifndef NDEBUG
+  // If we are SILUndef, just bail. SILUndef can pair with anything. Any uses of
+  // the SILUndef will make sure that the matching checks out.
+  if (isa<SILUndef>(*this))
+    return;
+
+  // Since we do not have SILUndef, we now know that getFunction() should return
+  // a real function. Assert in case this assumption is no longer true.
+  SILFunction *F = (*this)->getFunction();
+  assert(F && "Instructions and arguments should have a function");
+
+  // If the given function has unqualified ownership, there is nothing further
+  // to verify.
+  if (F->hasUnqualifiedOwnership())
+    return;
+
   if (TUB) {
     SILValueOwnershipChecker(Mod, *TUB, *this).check();
   } else {
diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
index a9f2d52..654a13a 100644
--- a/lib/SIL/SILPrinter.cpp
+++ b/lib/SIL/SILPrinter.cpp
@@ -1522,6 +1522,9 @@
   void visitDeinitExistentialAddrInst(DeinitExistentialAddrInst *DEI) {
     *this << getIDAndType(DEI->getOperand());
   }
+  void visitDeinitExistentialOpaqueInst(DeinitExistentialOpaqueInst *DEI) {
+    *this << getIDAndType(DEI->getOperand());
+  }
   void visitDeallocExistentialBoxInst(DeallocExistentialBoxInst *DEI) {
     *this << getIDAndType(DEI->getOperand()) << ", $" << DEI->getConcreteType();
   }
diff --git a/lib/SIL/SILType.cpp b/lib/SIL/SILType.cpp
index 95f249b..1a154c7 100644
--- a/lib/SIL/SILType.cpp
+++ b/lib/SIL/SILType.cpp
@@ -460,6 +460,10 @@
 /// Error existentials.
 static bool isBridgedErrorClass(SILModule &M,
                                 Type t) {
+  // There's no bridging if ObjC interop is disabled.
+  if (!M.getASTContext().LangOpts.EnableObjCInterop)
+    return false;
+
   if (!t)
     return false;
 
@@ -565,21 +569,13 @@
   
   // Apply generic arguments if the layout is generic.
   if (!getGenericArgs().empty()) {
-    // FIXME: Map the field type into the layout's generic context because
-    // SIL TypeLowering currently expects to lower abstract generic parameters
-    // with a generic context pushed, but nested generic contexts are not
-    // supported by TypeLowering. If TypeLowering were properly
-    // de-contextualized and plumbed through the generic signature, this could
-    // be avoided.
-    auto *env = getLayout()->getGenericSignature()
-      .getGenericEnvironment(*M.getSwiftModule());
-    auto substMap =
-      env->getSubstitutionMap(getGenericArgs());
-    fieldTy = env->mapTypeIntoContext(fieldTy)
-      ->getCanonicalType();
-    
-    fieldTy = SILType::getPrimitiveObjectType(fieldTy)
-      .subst(M, substMap)
+    auto sig = getLayout()->getGenericSignature();
+    auto subs = sig->getSubstitutionMap(getGenericArgs());
+    return SILType::getPrimitiveObjectType(fieldTy)
+      .subst(M,
+             QuerySubstitutionMap{subs},
+             LookUpConformanceInSubstitutionMap(subs),
+             sig)
       .getSwiftRValueType();
   }
   return fieldTy;
diff --git a/lib/SIL/SILValue.cpp b/lib/SIL/SILValue.cpp
index 7de3009..f9bf589 100644
--- a/lib/SIL/SILValue.cpp
+++ b/lib/SIL/SILValue.cpp
@@ -331,6 +331,7 @@
 NO_RESULT_OWNERSHIP_INST(AllocGlobal)
 NO_RESULT_OWNERSHIP_INST(InjectEnumAddr)
 NO_RESULT_OWNERSHIP_INST(DeinitExistentialAddr)
+NO_RESULT_OWNERSHIP_INST(DeinitExistentialOpaque)
 NO_RESULT_OWNERSHIP_INST(CondFail)
 
 // Terminators. These do not produce SILValue, so they do not have a
diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
index dfd06f9..541709a 100644
--- a/lib/SIL/SILVerifier.cpp
+++ b/lib/SIL/SILVerifier.cpp
@@ -1288,7 +1288,7 @@
             PointerRVType->is<UnownedStorageType>(),
             "load_unowned operand must be an unowned address");
     require(PointerRVType->getReferenceStorageReferent()->getCanonicalType() ==
-            LUI->getType().getSwiftType(),
+            LUI->getType().getSwiftRValueType(),
             "Load operand type and result type mismatch");
   }
 
@@ -1301,13 +1301,13 @@
             PointerRVType->is<UnownedStorageType>(),
             "store_unowned address operand must be an unowned address");
     require(PointerRVType->getReferenceStorageReferent()->getCanonicalType() ==
-            SUI->getSrc()->getType().getSwiftType(),
+            SUI->getSrc()->getType().getSwiftRValueType(),
             "Store operand type and dest type mismatch");
   }
 
   void checkLoadWeakInst(LoadWeakInst *LWI) {
     require(LWI->getType().isObject(), "Result of load must be an object");
-    require(LWI->getType().getSwiftType()->getAnyOptionalObjectType(),
+    require(LWI->getType().getAnyOptionalObjectType(),
             "Result of weak load must be an optional");
     auto PointerType = LWI->getOperand()->getType();
     auto PointerRVType = PointerType.getSwiftRValueType();
@@ -1315,14 +1315,14 @@
             PointerRVType->is<WeakStorageType>(),
             "load_weak operand must be a weak address");
     require(PointerRVType->getReferenceStorageReferent()->getCanonicalType() ==
-            LWI->getType().getSwiftType(),
+            LWI->getType().getSwiftRValueType(),
             "Load operand type and result type mismatch");
   }
 
   void checkStoreWeakInst(StoreWeakInst *SWI) {
     require(SWI->getSrc()->getType().isObject(),
             "Can't store from an address source");
-    require(SWI->getSrc()->getType().getSwiftType()->getAnyOptionalObjectType(),
+    require(SWI->getSrc()->getType().getAnyOptionalObjectType(),
             "store_weak must be of an optional value");
     auto PointerType = SWI->getDest()->getType();
     auto PointerRVType = PointerType.getSwiftRValueType();
@@ -1330,7 +1330,7 @@
             PointerRVType->is<WeakStorageType>(),
             "store_weak address operand must be a weak address");
     require(PointerRVType->getReferenceStorageReferent()->getCanonicalType() ==
-            SWI->getSrc()->getType().getSwiftType(),
+            SWI->getSrc()->getType().getSwiftRValueType(),
             "Store operand type and dest type mismatch");
   }
 
@@ -1642,8 +1642,8 @@
             "Tuple field count mismatch!");
 
     for (size_t i = 0, size = TI->getElements().size(); i < size; ++i) {
-      require(TI->getElement(i)->getType().getSwiftType()
-               ->isEqual(ResTy.getElementType(i)),
+      require(TI->getElement(i)->getType().getSwiftRValueType()
+              == ResTy.getElementType(i),
               "Tuple element arguments do not match tuple type!");
     }
   }
@@ -2080,9 +2080,9 @@
 
     require(EMI->getMember().getDecl()->isObjC(), "method must be @objc");
     if (!EMI->getMember().getDecl()->isInstanceMember()) {
-      require(operandType.getSwiftType()->is<MetatypeType>(),
+      require(operandType.is<MetatypeType>(),
               "operand must have metatype type");
-      require(operandType.getSwiftType()->castTo<MetatypeType>()
+      require(operandType.castTo<MetatypeType>()
                 ->getInstanceType()->mayHaveSuperclass(),
               "operand must have metatype of class or class-bounded type");
     }
@@ -2153,7 +2153,7 @@
 
     require(methodClass->getClassOrBoundGenericClass(),
             "super_method must look up a class method");
-    require(!methodClass->isEqual(operandType.getSwiftType()),
+    require(!methodClass->isEqual(operandType.getSwiftRValueType()),
             "super_method operand should be a subtype of the "
             "lookup class type");
   }
@@ -2210,7 +2210,7 @@
 
     CanType resultInstanceTy = OEI->getType().getSwiftRValueType();
 
-    require(OEI->getType().isAddress(),
+    require(OEI->getType().isAddress() || !fnConv.useLoweredAddresses(),
             "open_existential_box result must be an address");
 
     auto archetype = getOpenedArchetypeOf(resultInstanceTy);
@@ -2358,7 +2358,7 @@
 
   void checkInitExistentialRefInst(InitExistentialRefInst *IEI) {
     SILType concreteType = IEI->getOperand()->getType();
-    require(concreteType.getSwiftType()->isBridgeableObjectType(),
+    require(concreteType.getSwiftRValueType()->isBridgeableObjectType(),
             "init_existential_ref operand must be a class instance");
     require(IEI->getType().canUseExistentialRepresentation(F.getModule(),
                                      ExistentialRepresentation::Class,
@@ -2390,10 +2390,19 @@
     SILType exType = DEI->getOperand()->getType();
     require(exType.isAddress(),
             "deinit_existential_addr must be applied to an address");
-    require(exType.canUseExistentialRepresentation(F.getModule(),
-                                       ExistentialRepresentation::Opaque),
-            "deinit_existential_addr must be applied to an opaque "
-            "existential");
+    require(exType.canUseExistentialRepresentation(
+                F.getModule(), ExistentialRepresentation::Opaque),
+            "deinit_existential_addr must be applied to an opaque existential");
+  }
+
+  void checkDeinitExistentialOpaqueInst(DeinitExistentialOpaqueInst *DEI) {
+    SILType exType = DEI->getOperand()->getType();
+    require(!exType.isAddress(),
+            "deinit_existential_opaque must not be applied to an address");
+    require(
+        exType.canUseExistentialRepresentation(
+            F.getModule(), ExistentialRepresentation::Opaque),
+        "deinit_existential_opaque must be applied to an opaque existential");
   }
   
   void checkDeallocExistentialBoxInst(DeallocExistentialBoxInst *DEBI) {
@@ -2555,8 +2564,20 @@
                 CBI->getCastType(),
             "success dest block argument of checked_cast_br must match type of "
             "cast");
-    require(CBI->getFailureBB()->args_empty(),
-            "failure dest of checked_cast_br must take no arguments");
+    require(F.hasQualifiedOwnership() || CBI->getFailureBB()->args_empty(),
+            "failure dest of checked_cast_br in unqualified ownership sil must "
+            "take no arguments");
+#if 0
+    require(F.hasUnqualifiedOwnership() ||
+                CBI->getFailureBB()->args_size() == 1,
+            "failure dest of checked_cast_br must take one argument in "
+            "ownership qualified sil");
+    require(F.hasUnqualifiedOwnership() ||
+                CBI->getFailureBB()->args_begin()[0]->getType() ==
+                    CBI->getOperand()->getType(),
+            "failure dest block argument must match type of original type in "
+            "ownership qualified sil");
+#endif
   }
 
   void checkCheckedCastAddrBranchInst(CheckedCastAddrBranchInst *CCABI) {
@@ -2738,7 +2759,7 @@
 
   void checkIsNonnullInst(IsNonnullInst *II) {
     // The operand must be a function type or a class type.
-    auto OpTy = II->getOperand()->getType().getSwiftType();
+    auto OpTy = II->getOperand()->getType().getSwiftRValueType();
     require(OpTy->mayHaveSuperclass() || OpTy->is<SILFunctionType>(),
             "is_nonnull operand must be a class or function type");
   }
@@ -2746,7 +2767,7 @@
   void checkAddressToPointerInst(AddressToPointerInst *AI) {
     require(AI->getOperand()->getType().isAddress(),
             "address-to-pointer operand must be an address");
-    require(AI->getType().getSwiftType()->isEqual(
+    require(AI->getType().getSwiftRValueType()->isEqual(
                               AI->getType().getASTContext().TheRawPointerType),
             "address-to-pointer result type must be RawPointer");
   }
@@ -2803,11 +2824,11 @@
   }
 
   void checkRefToRawPointerInst(RefToRawPointerInst *AI) {
-    require(AI->getOperand()->getType().getSwiftType()
+    require(AI->getOperand()->getType().getSwiftRValueType()
               ->isAnyClassReferenceType(),
             "ref-to-raw-pointer operand must be a class reference or"
             " NativeObject");
-    require(AI->getType().getSwiftType()->isEqual(
+    require(AI->getType().getSwiftRValueType()->isEqual(
                             AI->getType().getASTContext().TheRawPointerType),
             "ref-to-raw-pointer result must be RawPointer");
   }
@@ -2815,13 +2836,13 @@
   void checkRawPointerToRefInst(RawPointerToRefInst *AI) {
     verifyOpenedArchetype(AI, AI->getType().getSwiftRValueType());
     require(AI->getType()
-              .getSwiftType()->isBridgeableObjectType()
-            || AI->getType().getSwiftType()->isEqual(
+              .getSwiftRValueType()->isBridgeableObjectType()
+            || AI->getType().getSwiftRValueType()->isEqual(
                              AI->getType().getASTContext().TheNativeObjectType)
-            || AI->getType().getSwiftType()->isEqual(
+            || AI->getType().getSwiftRValueType()->isEqual(
                             AI->getType().getASTContext().TheUnknownObjectType),
         "raw-pointer-to-ref result must be a class reference or NativeObject");
-    require(AI->getOperand()->getType().getSwiftType()->isEqual(
+    require(AI->getOperand()->getType().getSwiftRValueType()->isEqual(
                             AI->getType().getASTContext().TheRawPointerType),
             "raw-pointer-to-ref operand must be NativeObject");
   }
@@ -2876,8 +2897,12 @@
     requireObjectType(BuiltinRawPointerType, CI,
                       "thin_function_to_pointer result");
 
-    require(opTI->getRepresentation() == SILFunctionType::Representation::Thin,
-            "thin_function_to_pointer only works on thin functions");
+    auto rep = opTI->getRepresentation();
+    require(rep == SILFunctionTypeRepresentation::Thin ||
+            rep == SILFunctionTypeRepresentation::Method ||
+            rep == SILFunctionTypeRepresentation::WitnessMethod,
+            "thin_function_to_pointer only works on thin, method or "
+            "witness_method functions");
   }
 
   void checkPointerToThinFunctionInst(PointerToThinFunctionInst *CI) {
@@ -2886,8 +2911,12 @@
     requireObjectType(BuiltinRawPointerType, CI->getOperand(),
                       "pointer_to_thin_function operand");
 
-    require(resultTI->getRepresentation() == SILFunctionType::Representation::Thin,
-            "pointer_to_thin_function only works on thin functions");
+    auto rep = resultTI->getRepresentation();
+    require(rep == SILFunctionTypeRepresentation::Thin ||
+            rep == SILFunctionTypeRepresentation::Method ||
+            rep == SILFunctionTypeRepresentation::WitnessMethod,
+            "pointer_to_thin_function only works on thin, method or "
+            "witness_method functions");
   }
 
   void checkCondFailInst(CondFailInst *CFI) {
@@ -3225,9 +3254,9 @@
 
     require(DMBI->getMember().getDecl()->isObjC(), "method must be @objc");
     if (!DMBI->getMember().getDecl()->isInstanceMember()) {
-      require(operandType.getSwiftType()->is<MetatypeType>(),
+      require(operandType.getSwiftRValueType()->is<MetatypeType>(),
               "operand must have metatype type");
-      require(operandType.getSwiftType()->castTo<MetatypeType>()
+      require(operandType.getSwiftRValueType()->castTo<MetatypeType>()
                 ->getInstanceType()->mayHaveSuperclass(),
               "operand must have metatype of class or class-bound type");
     }
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
index 01dd21b..ea66f37 100644
--- a/lib/SIL/TypeLowering.cpp
+++ b/lib/SIL/TypeLowering.cpp
@@ -758,7 +758,7 @@
                            SILValue value) const override {
       if (B.getFunction().hasQualifiedOwnership())
         return B.createCopyValue(loc, value);
-      B.createRetainValue(loc, value, Atomicity::Atomic);
+      B.createRetainValue(loc, value, B.getDefaultAtomicity());
       return value;
     }
 
@@ -891,7 +891,7 @@
                            SILValue value) const override {
       if (B.getFunction().hasQualifiedOwnership())
         return B.createCopyValue(loc, value);
-      B.createRetainValue(loc, value, Atomicity::Atomic);
+      B.createRetainValue(loc, value, B.getDefaultAtomicity());
       return value;
     }
 
@@ -900,7 +900,7 @@
                                   LoweringStyle style) const override {
       if (B.getFunction().hasQualifiedOwnership())
         return B.createCopyValue(loc, value);
-      B.createRetainValue(loc, value, Atomicity::Atomic);
+      B.createRetainValue(loc, value, B.getDefaultAtomicity());
       return value;
     }
 
@@ -960,7 +960,7 @@
       if (B.getFunction().hasQualifiedOwnership())
         return B.createCopyValue(loc, value);
 
-      B.createStrongRetain(loc, value, Atomicity::Atomic);
+      B.createStrongRetain(loc, value, B.getDefaultAtomicity());
       return value;
     }
 
@@ -985,7 +985,7 @@
       if (B.getFunction().hasQualifiedOwnership())
         return B.createCopyValue(loc, value);
 
-      B.createUnownedRetain(loc, value, Atomicity::Atomic);
+      B.createUnownedRetain(loc, value, B.getDefaultAtomicity());
       return value;
     }
 
@@ -995,7 +995,7 @@
         B.createDestroyValue(loc, value);
         return;
       }
-      B.createUnownedRelease(loc, value, Atomicity::Atomic);
+      B.createUnownedRelease(loc, value, B.getDefaultAtomicity());
     }
   };
 
@@ -1105,25 +1105,12 @@
       llvm_unreachable("destroy address");
     }
 
-    void emitDestroyRValue(SILBuilder &B, SILLocation loc,
-                           SILValue value) const override {
-      llvm_unreachable("destroy value");
-    }
-
     void emitCopyInto(SILBuilder &B, SILLocation loc,
                       SILValue src, SILValue dest, IsTake_t isTake,
                       IsInitialization_t isInit) const override {
       llvm_unreachable("copy into");
     }
 
-    // --- Same as NonTrivialLoadableTypeLowering
-
-    void emitStoreOfCopy(SILBuilder &B, SILLocation loc,
-                         SILValue newValue, SILValue addr,
-                         IsInitialization_t isInit) const override {
-      llvm_unreachable("store copy");
-    }
-
     // --- Same as LeafLoadableTypeLowering.
 
     SILValue emitLoweredCopyValue(SILBuilder &B, SILLocation loc,
@@ -2130,7 +2117,8 @@
 CanSILFunctionType TypeConverter::
 getMaterializeForSetCallbackType(AbstractStorageDecl *storage,
                                  CanGenericSignature genericSig,
-                                 Type selfType) {
+                                 Type selfType,
+                                 SILFunctionTypeRepresentation rep) {
   auto &ctx = M.getASTContext();
 
   // Get lowered formal types for callback parameters.
@@ -2168,9 +2156,8 @@
     { canSelfMetatypeType, ParameterConvention::Direct_Unowned },
   };
   ArrayRef<SILResultInfo> results = {};
-  auto extInfo = 
-    SILFunctionType::ExtInfo()
-      .withRepresentation(SILFunctionTypeRepresentation::Thin);
+
+  auto extInfo = SILFunctionType::ExtInfo().withRepresentation(rep);
 
   if (genericSig && genericSig->areAllParamsConcrete())
     genericSig = nullptr;
diff --git a/lib/SILGen/ManagedValue.cpp b/lib/SILGen/ManagedValue.cpp
index 14dd691..3268c90 100644
--- a/lib/SILGen/ManagedValue.cpp
+++ b/lib/SILGen/ManagedValue.cpp
@@ -60,7 +60,7 @@
 void ManagedValue::copyInto(SILGenFunction &gen, SILValue dest,
                             SILLocation loc) {
   auto &lowering = gen.getTypeLowering(getType());
-  if (lowering.isAddressOnly()) {
+  if (lowering.isAddressOnly() && gen.silConv.useLoweredAddresses()) {
     gen.B.createCopyAddr(loc, getValue(), dest, IsNotTake, IsInitialization);
     return;
   }
diff --git a/lib/SILGen/ManagedValue.h b/lib/SILGen/ManagedValue.h
index b3330b6..8c02138 100644
--- a/lib/SILGen/ManagedValue.h
+++ b/lib/SILGen/ManagedValue.h
@@ -230,12 +230,6 @@
     return M;
   }
 
-  CanType getSwiftType() const {
-    return isLValue()
-      ? getType().getSwiftType()
-      : getType().getSwiftRValueType();
-  }
-  
   /// Emit a copy of this value with independent ownership.
   ManagedValue copy(SILGenFunction &gen, SILLocation loc);
 
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
index f2b4b55..dbc9b5d 100644
--- a/lib/SILGen/SILGenApply.cpp
+++ b/lib/SILGen/SILGenApply.cpp
@@ -42,7 +42,7 @@
   if (member->isInstanceMember()) {
     selfTy = ctx.TheUnknownObjectType;
   } else {
-    selfTy = proto->getType().getSwiftType();
+    selfTy = proto->getType().getSwiftRValueType();
   }
   auto extInfo = FunctionType::ExtInfo()
                    .withRepresentation(FunctionType::Representation::Thin);
@@ -99,7 +99,7 @@
     selfTy = proto->getType().getSwiftRValueType();
     assert(selfTy->is<ArchetypeType>() && "Dynamic lookup needs an archetype");
   } else {
-    selfTy = proto->getType().getSwiftType();
+    selfTy = proto->getType().getSwiftRValueType();
   }
 
   // Replace the 'self' parameter type in the method type with it.
@@ -1367,8 +1367,7 @@
 
         // If the 'self' value is a metatype, update the target type
         // accordingly.
-        if (auto selfMetaTy
-                    = selfValue.getSwiftType()->getAs<AnyMetatypeType>()) {
+        if (auto selfMetaTy = selfValue.getType().getAs<AnyMetatypeType>()) {
           resultTy = CanMetatypeType::get(resultTy,
                                           selfMetaTy->getRepresentation());
         }
@@ -1809,9 +1808,9 @@
   };
 
   TupleTypeElt TypeEltsArray[] = {
-    EltsArray[0].getSwiftType(),
-    EltsArray[1].getSwiftType(),
-    EltsArray[2].getSwiftType()
+    EltsArray[0].getType().getSwiftRValueType(),
+    EltsArray[1].getType().getSwiftRValueType(),
+    EltsArray[2].getType().getSwiftRValueType()
   };
 
   ArrayRef<ManagedValue> Elts;
@@ -2486,7 +2485,7 @@
       assert(lifetimeExtendedSelf
              && "did not save lifetime-extended self param");
       if (!hasAlreadyLifetimeExtendedSelf) {
-        B.createAutoreleaseValue(loc, lifetimeExtendedSelf, Atomicity::Atomic);
+        B.createAutoreleaseValue(loc, lifetimeExtendedSelf, B.getDefaultAtomicity());
         hasAlreadyLifetimeExtendedSelf = true;
       }
       LLVM_FALLTHROUGH;
@@ -3453,7 +3452,7 @@
           emittedArg = ManagedValue(erased, emittedArg.getCleanup());
         }
         
-        assert(isAnyObjectType(emittedArg.getSwiftType()));
+        assert(isAnyObjectType(emittedArg.getType().getSwiftRValueType()));
         return emittedArg;
       };
       
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
index 3ced3d4..e89eab2 100644
--- a/lib/SILGen/SILGenBridging.cpp
+++ b/lib/SILGen/SILGenBridging.cpp
@@ -35,7 +35,7 @@
                              ManagedValue swiftValue,
                              ProtocolConformance *conformance) {
   // Dig out the nominal type we're bridging from.
-  Type swiftValueType = swiftValue.getSwiftType()->getRValueType();
+  Type swiftValueType = swiftValue.getType().getSwiftRValueType();
 
   // Find the _bridgeToObjectiveC requirement.
   auto requirement = gen.SGM.getBridgeToObjectiveCRequirement(loc);
@@ -988,7 +988,7 @@
       gen.emitBridgedToNativeValue(loc,
                                    bridgedArgs[i],
                                    SILFunctionTypeRepresentation::ObjCMethod,
-                                   argTy.getSwiftType());
+                                   argTy.getSwiftRValueType());
     SILValue argValue;
 
     if (nativeInputs[i].isConsumed()) {
diff --git a/lib/SILGen/SILGenBuilder.cpp b/lib/SILGen/SILGenBuilder.cpp
index baad164..b791ed3 100644
--- a/lib/SILGen/SILGenBuilder.cpp
+++ b/lib/SILGen/SILGenBuilder.cpp
@@ -209,7 +209,7 @@
   SILValue result = SILBuilder::createUnmanagedToRef(
       loc, originalValue.getValue(),
       SILType::getPrimitiveObjectType(unmanagedType.getReferentType()));
-  SILBuilder::createUnmanagedRetainValue(loc, result);
+  SILBuilder::createUnmanagedRetainValue(loc, result, getDefaultAtomicity());
   return gen.emitManagedRValueWithCleanup(result);
 }
 
@@ -489,3 +489,25 @@
   return gen.emitManagedRValueWithCleanup(result);
 }
 
+ManagedValue SILGenBuilder::createUnconditionalCheckedCastOpaque(
+    SILLocation loc, ManagedValue operand, SILType type) {
+  SILValue result = SILBuilder::createUnconditionalCheckedCastOpaque(
+      loc, operand.forward(gen), type);
+  return gen.emitManagedRValueWithCleanup(result);
+}
+
+ManagedValue SILGenBuilder::createUnconditionalCheckedCast(SILLocation loc,
+                                                           ManagedValue operand,
+                                                           SILType type) {
+  SILValue result = SILBuilder::createUnconditionalCheckedCast(
+      loc, operand.forward(gen), type);
+  return gen.emitManagedRValueWithCleanup(result);
+}
+
+void SILGenBuilder::createCheckedCastBranch(SILLocation loc, bool isExact,
+                                            ManagedValue operand, SILType type,
+                                            SILBasicBlock *trueBlock,
+                                            SILBasicBlock *falseBlock) {
+  SILBuilder::createCheckedCastBranch(loc, isExact, operand.forward(gen), type,
+                                      trueBlock, falseBlock);
+}
diff --git a/lib/SILGen/SILGenBuilder.h b/lib/SILGen/SILGenBuilder.h
index f5bd0ab..3e4701c 100644
--- a/lib/SILGen/SILGenBuilder.h
+++ b/lib/SILGen/SILGenBuilder.h
@@ -211,6 +211,21 @@
   ManagedValue formalAccessBufferForExpr(
       SILLocation loc, SILType ty, const TypeLowering &lowering,
       SGFContext context, std::function<void(SILValue)> rvalueEmitter);
+
+  using SILBuilder::createUnconditionalCheckedCastOpaque;
+  ManagedValue createUnconditionalCheckedCastOpaque(SILLocation loc,
+                                                    ManagedValue operand,
+                                                    SILType type);
+  using SILBuilder::createUnconditionalCheckedCast;
+  ManagedValue createUnconditionalCheckedCast(SILLocation loc,
+                                              ManagedValue operand,
+                                              SILType type);
+
+  using SILBuilder::createCheckedCastBranch;
+  void createCheckedCastBranch(SILLocation loc, bool isExact,
+                               ManagedValue operand, SILType type,
+                               SILBasicBlock *trueBlock,
+                               SILBasicBlock *falseBlock);
 };
 
 } // namespace Lowering
diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
index 93e449a..10fa3b4 100644
--- a/lib/SILGen/SILGenBuiltin.cpp
+++ b/lib/SILGen/SILGenBuiltin.cpp
@@ -72,7 +72,8 @@
   // The value was produced at +1; we can produce an unbalanced retain simply by
   // disabling the cleanup. But this would violate ownership semantics. Instead,
   // we must allow for the cleanup and emit a new unmanaged retain value.
-  gen.B.createUnmanagedRetainValue(loc, args[0].getValue());
+  gen.B.createUnmanagedRetainValue(loc, args[0].getValue(),
+                                   gen.B.getDefaultAtomicity());
   return ManagedValue::forUnmanaged(gen.emitEmptyTuple(loc));    
 }
 
@@ -85,7 +86,8 @@
   // The value was produced at +1, so to produce an unbalanced
   // release we need to leave the cleanup intact and then do a *second*
   // release.
-  gen.B.createUnmanagedReleaseValue(loc, args[0].getValue());
+  gen.B.createUnmanagedReleaseValue(loc, args[0].getValue(),
+                                    gen.B.getDefaultAtomicity());
   return ManagedValue::forUnmanaged(gen.emitEmptyTuple(loc));    
 }
 
@@ -95,7 +97,8 @@
                                            ArrayRef<ManagedValue> args,
                                            CanFunctionType formalApplyType,
                                            SGFContext C) {
-  gen.B.createUnmanagedAutoreleaseValue(loc, args[0].getValue());
+  gen.B.createUnmanagedAutoreleaseValue(loc, args[0].getValue(),
+                                        gen.B.getDefaultAtomicity());
   return ManagedValue::forUnmanaged(gen.emitEmptyTuple(loc));    
 }
 
@@ -127,7 +130,7 @@
   // retain, so we have to leave the cleanup in place.  TODO: try to
   // emit the argument at +0.
   SILValue result =
-      gen.B.createStrongPin(loc, args[0].getValue(), Atomicity::Atomic);
+      gen.B.createStrongPin(loc, args[0].getValue(), gen.B.getDefaultAtomicity());
 
   // The handle, if non-null, is effectively +1.
   return gen.emitManagedRValueWithCleanup(result);
@@ -143,7 +146,7 @@
 
   if (requireIsOptionalNativeObject(gen, loc, subs[0].getReplacement())) {
     // Unpinning takes responsibility for the +1 handle.
-    gen.B.createStrongUnpin(loc, args[0].forward(gen), Atomicity::Atomic);
+    gen.B.createStrongUnpin(loc, args[0].forward(gen), gen.B.getDefaultAtomicity());
   }
 
   return ManagedValue::forUnmanaged(gen.emitEmptyTuple(loc));
diff --git a/lib/SILGen/SILGenConvert.cpp b/lib/SILGen/SILGenConvert.cpp
index 9438e8d..c160037 100644
--- a/lib/SILGen/SILGenConvert.cpp
+++ b/lib/SILGen/SILGenConvert.cpp
@@ -781,26 +781,25 @@
   SILType existentialType = existentialValue.getType();
   switch (existentialType.getPreferredExistentialRepresentation(SGM.M)) {
   case ExistentialRepresentation::Opaque: {
+    SILValue archetypeValue;
     if (existentialType.isAddress()) {
       OpenedExistentialAccess allowedAccess =
           getOpenedExistentialAccessFor(accessKind);
-      SILValue archetypeValue = B.createOpenExistentialAddr(
-          loc, existentialValue.forward(*this), loweredOpenedType,
-          allowedAccess);
-      if (existentialValue.hasCleanup()) {
-        canConsume = true;
-        // Leave a cleanup to deinit the existential container.
-        enterDeinitExistentialCleanup(existentialValue.getValue(), CanType(),
-                                      ExistentialRepresentation::Opaque);
-        archetypeMV = emitManagedBufferWithCleanup(archetypeValue);
-      } else {
-        canConsume = false;
-        archetypeMV = ManagedValue::forUnmanaged(archetypeValue);
-      }
+      archetypeValue =
+          B.createOpenExistentialAddr(loc, existentialValue.forward(*this),
+                                      loweredOpenedType, allowedAccess);
     } else {
-      SILValue archetypeValue = B.createOpenExistentialOpaque(
+      archetypeValue = B.createOpenExistentialOpaque(
           loc, existentialValue.forward(*this), loweredOpenedType);
-      assert(!existentialValue.hasCleanup());
+    }
+
+    if (existentialValue.hasCleanup()) {
+      canConsume = true;
+      // Leave a cleanup to deinit the existential container.
+      enterDeinitExistentialCleanup(existentialValue.getValue(), CanType(),
+                                    ExistentialRepresentation::Opaque);
+      archetypeMV = emitManagedBufferWithCleanup(archetypeValue);
+    } else {
       canConsume = false;
       archetypeMV = ManagedValue::forUnmanaged(archetypeValue);
     }
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
index e4a5168..cbe0448 100644
--- a/lib/SILGen/SILGenDecl.cpp
+++ b/lib/SILGen/SILGenDecl.cpp
@@ -83,7 +83,7 @@
   // A scalar value is being copied into the tuple, break it into elements
   // and assign/init each element in turn.
   SILValue value = valueMV.forward(SGF);
-  auto sourceType = cast<TupleType>(valueMV.getSwiftType());
+  auto sourceType = valueMV.getType().castTo<TupleType>();
   auto sourceSILType = value->getType();
   for (unsigned i = 0, e = sourceType->getNumElements(); i != e; ++i) {
     SILType fieldTy = sourceSILType.getTupleElementType(i);
@@ -813,9 +813,10 @@
   
   // Reabstract to the substituted type, if needed.
   CanType substEltTy =
-    value.getSwiftType()->getTypeOfMember(SGF.SGM.M.getSwiftModule(),
-                                      ElementDecl,
-                                      ElementDecl->getArgumentInterfaceType())
+    value.getType().getSwiftRValueType()
+      ->getTypeOfMember(SGF.SGM.M.getSwiftModule(),
+                        ElementDecl,
+                        ElementDecl->getArgumentInterfaceType())
       ->getCanonicalType();
 
   AbstractionPattern origEltTy =
@@ -1233,7 +1234,11 @@
       case ExistentialRepresentation::Metatype:
         llvm_unreachable("cannot cleanup existential");
       case ExistentialRepresentation::Opaque:
-        gen.B.createDeinitExistentialAddr(l, existentialAddr);
+        if (gen.silConv.useLoweredAddresses()) {
+          gen.B.createDeinitExistentialAddr(l, existentialAddr);
+        } else {
+          gen.B.createDeinitExistentialOpaque(l, existentialAddr);
+        }
         break;
       case ExistentialRepresentation::Boxed:
         gen.B.createDeallocExistentialBox(l, concreteFormalType,
diff --git a/lib/SILGen/SILGenDynamicCast.cpp b/lib/SILGen/SILGenDynamicCast.cpp
index 1b717f2..da67262 100644
--- a/lib/SILGen/SILGenDynamicCast.cpp
+++ b/lib/SILGen/SILGenDynamicCast.cpp
@@ -100,6 +100,285 @@
                                              abstraction, origTargetTL, ctx));
       }
 
+      ManagedValue result;
+      if (Strategy == CastStrategy::Address) {
+        result = SGF.B.createUnconditionalCheckedCastOpaque(
+            Loc, operand, origTargetTL.getLoweredType());
+      } else {
+        result = SGF.B.createUnconditionalCheckedCast(
+            Loc, operand, origTargetTL.getLoweredType());
+      }
+
+      return RValue(SGF, Loc, TargetType,
+                    finishFromResultScalar(hasAbstraction, result,
+                                           CastConsumptionKind::TakeAlways,
+                                           abstraction, origTargetTL, ctx));
+    }
+
+    /// Emit a conditional cast.
+    void emitConditional(
+        ManagedValue operand, CastConsumptionKind consumption, SGFContext ctx,
+        const std::function<void(ManagedValue)> &handleTrue,
+        const std::function<void(Optional<ManagedValue>)> &handleFalse) {
+      // The cast instructions don't know how to work with anything
+      // but the most general possible abstraction level.
+      AbstractionPattern abstraction =
+          SGF.SGM.Types.getMostGeneralAbstraction();
+      auto &origTargetTL = SGF.getTypeLowering(abstraction, TargetType);
+      auto &substTargetTL = SGF.getTypeLowering(TargetType);
+      bool hasAbstraction =
+          (origTargetTL.getLoweredType() != substTargetTL.getLoweredType());
+
+      SILBasicBlock *falseBB = SGF.B.splitBlockForFallthrough();
+      SILBasicBlock *trueBB = SGF.B.splitBlockForFallthrough();
+
+      // Emit the branch.
+      ManagedValue scalarOperandValue;
+      SILValue resultBuffer;
+      if (Strategy == CastStrategy::Address) {
+        assert(operand.getType().isAddress());
+        resultBuffer =
+            createAbstractResultBuffer(hasAbstraction, origTargetTL, ctx);
+        SGF.B.createCheckedCastAddrBranch(
+            Loc, consumption, operand.forward(SGF), SourceType, resultBuffer,
+            TargetType, trueBB, falseBB);
+      } else {
+        // Tolerate being passed an address here.  It comes up during switch
+        // emission.
+        scalarOperandValue = std::move(operand);
+        if (scalarOperandValue.getType().isAddress()) {
+          scalarOperandValue = SGF.B.createLoadTake(Loc, scalarOperandValue);
+        }
+        SGF.B.createCheckedCastBranch(Loc, /*exact*/ false, scalarOperandValue,
+                                      origTargetTL.getLoweredType(), trueBB,
+                                      falseBB);
+      }
+
+      // Emit the success block.
+      SGF.B.setInsertionPoint(trueBB);
+      {
+        FullExpr scope(SGF.Cleanups, CleanupLocation::get(Loc));
+
+        ManagedValue result;
+        if (Strategy == CastStrategy::Address) {
+          result = finishFromResultBuffer(hasAbstraction, resultBuffer,
+                                          abstraction, origTargetTL, ctx);
+        } else {
+          ManagedValue argument =
+              SGF.B.createOwnedPHIArgument(origTargetTL.getLoweredType());
+          result = finishFromResultScalar(hasAbstraction, argument, consumption,
+                                          abstraction, origTargetTL, ctx);
+        }
+
+        handleTrue(result);
+        assert(!SGF.B.hasValidInsertionPoint() && "handler did not end block");
+      }
+
+      // Emit the failure block.
+      SGF.B.setInsertionPoint(falseBB);
+      {
+        FullExpr scope(SGF.Cleanups, CleanupLocation::get(Loc));
+
+        // If we have an address only type, do not handle the consumption
+        // rules. These are handled for us by the user.
+        if (Strategy == CastStrategy::Address) {
+          handleFalse(None);
+          assert(!SGF.B.hasValidInsertionPoint() &&
+                 "handler did not end block");
+          return;
+        }
+
+        // Otherwise, we use the following strategy:
+        //
+        // 1. If we have a take_always, we create a phi node argument for the
+        // failure case and a scope for that so that it is immediately
+        // destroyed.
+        //
+        // 2. If we have a take_on_success or copy_on_success, then on failure,
+        // we propagate through the default argument, but do not clean it up. On
+        // the false case, our user must treat the taken value as a new value.
+        if (shouldDestroyOnFailure(consumption)) {
+          {
+            FullExpr argScope(SGF.Cleanups, CleanupLocation::get(Loc));
+            SGF.B.createOwnedPHIArgument(scalarOperandValue.getType());
+          }
+          handleFalse(None);
+          assert(!SGF.B.hasValidInsertionPoint() &&
+                 "handler did not end block");
+          return;
+        }
+
+        handleFalse(SGF.B.createOwnedPHIArgument(scalarOperandValue.getType()));
+        assert(!SGF.B.hasValidInsertionPoint() && "handler did not end block");
+      }
+    }
+
+    SILValue createAbstractResultBuffer(bool hasAbstraction,
+                                        const TypeLowering &origTargetTL,
+                                        SGFContext ctx) {
+      if (!hasAbstraction) {
+        if (auto emitInto = ctx.getEmitInto()) {
+          if (SILValue addr = emitInto->getAddressOrNull()) {
+            return addr;
+          }
+        }
+      }
+
+      return SGF.emitTemporaryAllocation(Loc, origTargetTL.getLoweredType());
+    }
+
+    ManagedValue finishFromResultBuffer(bool hasAbstraction, SILValue buffer,
+                                        AbstractionPattern abstraction,
+                                        const TypeLowering &origTargetTL,
+                                        SGFContext ctx) {
+      if (!hasAbstraction) {
+        if (auto emitInto = ctx.getEmitInto()) {
+          if (emitInto->getAddressOrNull()) {
+            emitInto->finishInitialization(SGF);
+            return ManagedValue::forInContext();
+          }
+        }
+      }
+
+      ManagedValue result;
+      if (!origTargetTL.isAddressOnly()) {
+        result = SGF.emitLoad(Loc, buffer, origTargetTL, ctx, IsTake);
+      } else {
+        result = SGF.emitManagedBufferWithCleanup(buffer, origTargetTL);
+      }
+
+      if (hasAbstraction) {
+        result =
+            SGF.emitOrigToSubstValue(Loc, result, abstraction, TargetType, ctx);
+      }
+      return result;
+    }
+
+    /// Our cast succeeded and gave us this abstracted value.
+    ManagedValue finishFromResultScalar(bool hasAbstraction, ManagedValue value,
+                                        CastConsumptionKind consumption,
+                                        AbstractionPattern abstraction,
+                                        const TypeLowering &origTargetTL,
+                                        SGFContext ctx) {
+      ManagedValue result = value;
+      // Copy the result if this is copy-on-success.
+      if (!shouldTakeOnSuccess(consumption))
+        result = result.copy(SGF, Loc);
+
+      // Re-abstract if necessary.
+      if (hasAbstraction) {
+        result =
+            SGF.emitOrigToSubstValue(Loc, result, abstraction, TargetType, ctx);
+      }
+
+      return result;
+    }
+
+  private:
+    CastStrategy computeStrategy() const {
+      if (canUseScalarCheckedCastInstructions(SGF.SGM.M, SourceType,
+                                              TargetType))
+        return CastStrategy::Scalar;
+      return CastStrategy::Address;
+    }
+  };
+} // end anonymous namespace
+
+void SILGenFunction::emitCheckedCastBranch(
+    SILLocation loc, Expr *source, Type targetType, SGFContext ctx,
+    std::function<void(ManagedValue)> handleTrue,
+    std::function<void(Optional<ManagedValue>)> handleFalse) {
+  CheckedCastEmitter emitter(*this, loc, source->getType(), targetType);
+  ManagedValue operand = emitter.emitOperand(source);
+  emitter.emitConditional(operand, CastConsumptionKind::TakeAlways, ctx,
+                          handleTrue, handleFalse);
+}
+
+void SILGenFunction::emitCheckedCastBranch(
+    SILLocation loc, ConsumableManagedValue src, Type sourceType,
+    CanType targetType, SGFContext ctx,
+    std::function<void(ManagedValue)> handleTrue,
+    std::function<void(Optional<ManagedValue>)> handleFalse) {
+  CheckedCastEmitter emitter(*this, loc, sourceType, targetType);
+  emitter.emitConditional(src.getFinalManagedValue(),
+                          src.getFinalConsumption(), ctx, handleTrue,
+                          handleFalse);
+}
+
+namespace {
+  class CheckedCastEmitterOld {
+    SILGenFunction &SGF;
+    SILLocation Loc;
+    CanType SourceType;
+    CanType TargetType;
+
+    enum class CastStrategy : uint8_t {
+      Address,
+      Scalar,
+    };
+    CastStrategy Strategy;
+
+  public:
+    CheckedCastEmitterOld(SILGenFunction &SGF, SILLocation loc, Type sourceType,
+                          Type targetType)
+        : SGF(SGF), Loc(loc), SourceType(sourceType->getCanonicalType()),
+          TargetType(targetType->getCanonicalType()),
+          Strategy(computeStrategy()) {}
+
+    bool isOperandIndirect() const { return Strategy == CastStrategy::Address; }
+
+    ManagedValue emitOperand(Expr *operand) {
+      AbstractionPattern mostGeneral =
+          SGF.SGM.Types.getMostGeneralAbstraction();
+      auto &origSourceTL = SGF.getTypeLowering(mostGeneral, SourceType);
+
+      SGFContext ctx;
+
+      std::unique_ptr<TemporaryInitialization> temporary;
+      if (isOperandIndirect() && SGF.silConv.useLoweredAddresses()) {
+        temporary = SGF.emitTemporary(Loc, origSourceTL);
+        ctx = SGFContext(temporary.get());
+      }
+
+      auto result =
+          SGF.emitRValueAsOrig(operand, mostGeneral, origSourceTL, ctx);
+
+      if (isOperandIndirect() && SGF.silConv.useLoweredAddresses()) {
+        // Force the result into the temporary if it's not already there.
+        if (!result.isInContext()) {
+          result.forwardInto(SGF, Loc, temporary->getAddress());
+          temporary->finishInitialization(SGF);
+        }
+        return temporary->getManagedAddress();
+      }
+
+      return result;
+    }
+
+    RValue emitUnconditionalCast(ManagedValue operand, SGFContext ctx) {
+      // The cast functions don't know how to work with anything but
+      // the most general possible abstraction level.
+      AbstractionPattern abstraction =
+          SGF.SGM.Types.getMostGeneralAbstraction();
+      auto &origTargetTL = SGF.getTypeLowering(abstraction, TargetType);
+      auto &substTargetTL = SGF.getTypeLowering(TargetType);
+      bool hasAbstraction =
+          (origTargetTL.getLoweredType() != substTargetTL.getLoweredType());
+
+      // If we're using checked_cast_addr, take the operand (which
+      // should be an address) and build into the destination buffer.
+      if (Strategy == CastStrategy::Address &&
+          SGF.silConv.useLoweredAddresses()) {
+        SILValue resultBuffer =
+            createAbstractResultBuffer(hasAbstraction, origTargetTL, ctx);
+        SGF.B.createUnconditionalCheckedCastAddr(
+            Loc, CastConsumptionKind::TakeAlways, operand.forward(SGF),
+            SourceType, resultBuffer, TargetType);
+        return RValue(SGF, Loc, TargetType,
+                      finishFromResultBuffer(hasAbstraction, resultBuffer,
+                                             abstraction, origTargetTL, ctx));
+      }
+
       SILValue resultScalar;
       if (Strategy == CastStrategy::Address) {
         resultScalar = SGF.B.createUnconditionalCheckedCastOpaque(
@@ -265,25 +544,22 @@
   };
 } // end anonymous namespace
 
-void SILGenFunction::emitCheckedCastBranch(SILLocation loc, Expr *source,
-                                           Type targetType,
-                                           SGFContext ctx,
-                                std::function<void(ManagedValue)> handleTrue,
-                                           std::function<void()> handleFalse) {
-  CheckedCastEmitter emitter(*this, loc, source->getType(), targetType);
+void SILGenFunction::emitCheckedCastBranchOld(
+    SILLocation loc, Expr *source, Type targetType, SGFContext ctx,
+    std::function<void(ManagedValue)> handleTrue,
+    std::function<void()> handleFalse) {
+  CheckedCastEmitterOld emitter(*this, loc, source->getType(), targetType);
   ManagedValue operand = emitter.emitOperand(source);
   emitter.emitConditional(operand, CastConsumptionKind::TakeAlways, ctx,
                           handleTrue, handleFalse);
 }
 
-void SILGenFunction::emitCheckedCastBranch(SILLocation loc,
-                                           ConsumableManagedValue src,
-                                           Type sourceType,
-                                           CanType targetType,
-                                           SGFContext ctx,
-                                std::function<void(ManagedValue)> handleTrue,
-                                           std::function<void()> handleFalse) {
-  CheckedCastEmitter emitter(*this, loc, sourceType, targetType);
+void SILGenFunction::emitCheckedCastBranchOld(
+    SILLocation loc, ConsumableManagedValue src, Type sourceType,
+    CanType targetType, SGFContext ctx,
+    std::function<void(ManagedValue)> handleTrue,
+    std::function<void()> handleFalse) {
+  CheckedCastEmitterOld emitter(*this, loc, sourceType, targetType);
   emitter.emitConditional(src.getFinalManagedValue(), src.getFinalConsumption(),
                           ctx, handleTrue, handleFalse);
 }
@@ -459,53 +735,59 @@
   ExitableFullExpr scope(SGF, CleanupLocation::get(loc));
 
   auto operandCMV = ConsumableManagedValue::forOwned(operand);
-  SGF.emitCheckedCastBranch(loc, operandCMV, operandType,
-                            resultObjectType, resultObjectCtx,
-    // The success path.
-    [&](ManagedValue objectValue) {
-      // If we're not emitting into a temporary, just wrap up the result
-      // in Some and go to the continuation block.
-      if (!resultObjectTemp) {
-        auto some = SGF.B.createEnum(loc, objectValue.forward(SGF),
-                                     someDecl, resultTL.getLoweredType());
-        SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, { some });
-        return;
-      }
+  assert(operandCMV.getFinalConsumption() == CastConsumptionKind::TakeAlways);
 
-      // Otherwise, make sure the value is in the context.
-      if (!objectValue.isInContext()) {
-        objectValue.forwardInto(SGF, loc, resultObjectBuffer);
-      }
-      SGF.B.createInjectEnumAddr(loc, resultBuffer, someDecl);
-      SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc);
-    },
-    // The failure path.
-    [&] {
-      auto noneDecl = SGF.getASTContext().getOptionalNoneDecl();
+  SGF.emitCheckedCastBranch(
+      loc, operandCMV, operandType, resultObjectType, resultObjectCtx,
+      // The success path.
+      [&](ManagedValue objectValue) {
+        // If we're not emitting into a temporary, just wrap up the result
+        // in Some and go to the continuation block.
+        if (!resultObjectTemp) {
+          auto some = SGF.B.createEnum(loc, objectValue.forward(SGF), someDecl,
+                                       resultTL.getLoweredType());
+          SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, {some});
+          return;
+        }
 
-      // If we're not emitting into a temporary, just wrap up the result
-      // in None and go to the continuation block.
-      if (!resultObjectTemp) {
-        auto none =
-          SGF.B.createEnum(loc, nullptr, noneDecl, resultTL.getLoweredType());
-        SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, { none });
-
-      // Just construct the enum directly in the context.
-      } else {
-        SGF.B.createInjectEnumAddr(loc, resultBuffer, noneDecl);
+        // Otherwise, make sure the value is in the context.
+        if (!objectValue.isInContext()) {
+          objectValue.forwardInto(SGF, loc, resultObjectBuffer);
+        }
+        SGF.B.createInjectEnumAddr(loc, resultBuffer, someDecl);
         SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc);
-      }
-    });
+      },
+      // The failure path.
+      [&](Optional<ManagedValue> Value) {
+        // We always are performing a take here, so Value should be None since
+        // the
+        // object should have been destroyed immediately in the fail block.
+        assert(!Value.hasValue() && "Expected a take_always consumption kind");
+        auto noneDecl = SGF.getASTContext().getOptionalNoneDecl();
+
+        // If we're not emitting into a temporary, just wrap up the result
+        // in None and go to the continuation block.
+        if (!resultObjectTemp) {
+          auto none = SGF.B.createEnum(loc, nullptr, noneDecl,
+                                       resultTL.getLoweredType());
+          SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, {none});
+
+          // Just construct the enum directly in the context.
+        } else {
+          SGF.B.createInjectEnumAddr(loc, resultBuffer, noneDecl);
+          SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc);
+        }
+      });
 
   // Enter the continuation block.
-  auto contBB = scope.exit();
+  SILBasicBlock *contBlock = scope.exit();
 
   ManagedValue result;
   if (resultObjectTemp) {
     result = SGF.manageBufferForExprResult(resultBuffer, resultTL, C);
   } else {
-    auto argument = contBB->createPHIArgument(resultTL.getLoweredType(),
-                                              ValueOwnershipKind::Owned);
+    auto argument = contBlock->createPHIArgument(resultTL.getLoweredType(),
+                                                 ValueOwnershipKind::Owned);
     result = SGF.emitManagedRValueWithCleanup(argument, resultTL);
   }
 
@@ -543,15 +825,18 @@
 
   auto i1Ty = SILType::getBuiltinIntegerType(1, SGF.getASTContext());
 
-  SGF.emitCheckedCastBranch(loc, operand, targetType, SGFContext(),
-    [&](ManagedValue value) {
-      SILValue yes = SGF.B.createIntegerLiteral(loc, i1Ty, 1);
-      SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, yes);
-    },
-    [&] {
-      SILValue no = SGF.B.createIntegerLiteral(loc, i1Ty, 0);
-      SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, no);
-    });
+  // When we pass in an expr, we perform a take_always cast.
+  SGF.emitCheckedCastBranch(
+      loc, operand, targetType, SGFContext(),
+      [&](ManagedValue value) {
+        SILValue yes = SGF.B.createIntegerLiteral(loc, i1Ty, 1);
+        SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, yes);
+      },
+      [&](Optional<ManagedValue> Value) {
+        assert(!Value.hasValue() && "Expected take_always semantics");
+        SILValue no = SGF.B.createIntegerLiteral(loc, i1Ty, 0);
+        SGF.Cleanups.emitBranchAndCleanups(scope.getExitDest(), loc, no);
+      });
 
   auto contBB = scope.exit();
   auto isa = contBB->createPHIArgument(i1Ty, ValueOwnershipKind::Trivial);
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
index 4580307..7407c7a 100644
--- a/lib/SILGen/SILGenExpr.cpp
+++ b/lib/SILGen/SILGenExpr.cpp
@@ -290,7 +290,8 @@
 
 ManagedValue SILGenFunction::emitManagedBufferWithCleanup(SILValue v,
                                                const TypeLowering &lowering) {
-  assert(lowering.getLoweredType().getAddressType() == v->getType());
+  assert(lowering.getLoweredType().getAddressType() == v->getType() ||
+         !silConv.useLoweredAddresses());
   if (lowering.isTrivial())
     return ManagedValue::forUnmanaged(v);
 
@@ -856,7 +857,7 @@
   case AddressorKind::NativePinning:
     // Emit the unpin immediately.
     SGF.B.createStrongUnpin(loc, addressorResult.second.forward(SGF),
-                            Atomicity::Atomic);
+                            SGF.B.getDefaultAtomicity());
     break;
   }
   
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
index 563f171..a11b63e 100644
--- a/lib/SILGen/SILGenFunction.h
+++ b/lib/SILGen/SILGenFunction.h
@@ -1408,11 +1408,22 @@
   ///                     terminated.
   /// \param handleFalse  A callback to invoke in the failure path.  The
   ///                     current BB should be terminated.
-  void emitCheckedCastBranch(SILLocation loc, ConsumableManagedValue src,
-                             Type sourceType, CanType targetType,
-                             SGFContext C,
-                             std::function<void(ManagedValue)> handleTrue,
-                             std::function<void()> handleFalse);
+  void emitCheckedCastBranch(
+      SILLocation loc, ConsumableManagedValue src, Type sourceType,
+      CanType targetType, SGFContext C,
+      std::function<void(ManagedValue)> handleTrue,
+      std::function<void(Optional<ManagedValue>)> handleFalse);
+
+  /// A form of checked cast branch that uses the old non-ownership preserving
+  /// semantics.
+  ///
+  /// The main difference is that this code does not pass the old argument as a
+  /// block argument in the failure case. This causes values to be double
+  /// consumed.
+  void emitCheckedCastBranchOld(SILLocation loc, Expr *source, Type targetType,
+                                SGFContext ctx,
+                                std::function<void(ManagedValue)> handleTrue,
+                                std::function<void()> handleFalse);
 
   /// \brief Emit a conditional checked cast branch, starting from an
   /// expression.  Terminates the current BB.
@@ -1426,10 +1437,22 @@
   ///                     terminated.
   /// \param handleFalse  A callback to invoke in the failure path.  The
   ///                     current BB should be terminated.
-  void emitCheckedCastBranch(SILLocation loc, Expr *src,
-                             Type targetType, SGFContext C,
-                             std::function<void(ManagedValue)> handleTrue,
-                             std::function<void()> handleFalse);
+  void emitCheckedCastBranch(
+      SILLocation loc, Expr *src, Type targetType, SGFContext C,
+      std::function<void(ManagedValue)> handleTrue,
+      std::function<void(Optional<ManagedValue>)> handleFalse);
+
+  /// A form of checked cast branch that uses the old non-ownership preserving
+  /// semantics.
+  ///
+  /// The main difference is that this code does not pass the old argument as a
+  /// block argument in the failure case. This causes values to be double
+  /// consumed.
+  void emitCheckedCastBranchOld(SILLocation loc, ConsumableManagedValue src,
+                                Type sourceType, CanType targetType,
+                                SGFContext ctx,
+                                std::function<void(ManagedValue)> handleTrue,
+                                std::function<void()> handleFalse);
 
   /// Emit the control flow for an optional 'bind' operation, branching to the
   /// active failure destination if the optional value addressed by optionalAddr
diff --git a/lib/SILGen/SILGenLValue.cpp b/lib/SILGen/SILGenLValue.cpp
index 8c3e03f..ccdaf53 100644
--- a/lib/SILGen/SILGenLValue.cpp
+++ b/lib/SILGen/SILGenLValue.cpp
@@ -227,7 +227,8 @@
 
   assert(temporary.getType().isAddress());
   auto &tempTL = gen.getTypeLowering(temporary.getType());
-  if (!tempTL.isAddressOnly() || !isFinal) {
+  if (!tempTL.isAddressOnly() || !isFinal ||
+      !gen.silConv.useLoweredAddresses()) {
     if (isFinal) temporary.forward(gen);
     temporary = gen.emitLoad(loc, temporary.getValue(), tempTL,
                              SGFContext(), IsTake_t(isFinal));
@@ -879,8 +880,14 @@
             rawPointerTy, ValueOwnershipKind::Trivial);
 
         // Cast the callback to the correct polymorphic function type.
+        SILFunctionTypeRepresentation rep;
+        if (isa<ProtocolDecl>(decl->getDeclContext()))
+          rep = SILFunctionTypeRepresentation::WitnessMethod;
+        else
+          rep = SILFunctionTypeRepresentation::Method;
+
         auto origCallbackFnType = gen.SGM.Types.getMaterializeForSetCallbackType(
-            decl, materialized.genericSig, materialized.origSelfType);
+          decl, materialized.genericSig, materialized.origSelfType, rep);
         auto origCallbackType = SILType::getPrimitiveObjectType(origCallbackFnType);
         callback = gen.B.createPointerToThinFunction(loc, callback, origCallbackType);
 
@@ -1094,7 +1101,7 @@
       if (!isFinal)
         baseValue = gen.B.createCopyValue(loc, baseValue);
 
-      gen.B.createStrongUnpin(loc, baseValue, Atomicity::Atomic);
+      gen.B.createStrongUnpin(loc, baseValue, gen.B.getDefaultAtomicity());
     }
 
     void print(raw_ostream &OS) const override {
@@ -2138,7 +2145,7 @@
     assert(unownedType->isLoadable(ResilienceExpansion::Maximal));
     (void) unownedType;
 
-    B.createStrongRetainUnowned(loc, src, Atomicity::Atomic);
+    B.createStrongRetainUnowned(loc, src, B.getDefaultAtomicity());
     return B.createUnownedToRef(loc, src,
                 SILType::getPrimitiveObjectType(unownedType.getReferentType()));
   }
@@ -2199,9 +2206,9 @@
 
     auto unownedValue =
         gen.B.emitLoadValueOperation(loc, src, LoadOwnershipQualifier::Take);
-    gen.B.createStrongRetainUnowned(loc, unownedValue, Atomicity::Atomic);
+    gen.B.createStrongRetainUnowned(loc, unownedValue, gen.B.getDefaultAtomicity());
     if (isTake)
-      gen.B.createUnownedRelease(loc, unownedValue, Atomicity::Atomic);
+      gen.B.createUnownedRelease(loc, unownedValue, gen.B.getDefaultAtomicity());
     return gen.B.createUnownedToRef(
         loc, unownedValue,
         SILType::getPrimitiveObjectType(unownedType.getReferentType()));
@@ -2264,7 +2271,7 @@
 
     auto unownedValue =
       gen.B.createRefToUnowned(loc, value, storageType.getObjectType());
-    gen.B.createUnownedRetain(loc, unownedValue, Atomicity::Atomic);
+    gen.B.createUnownedRetain(loc, unownedValue, gen.B.getDefaultAtomicity());
     emitUnloweredStoreOfCopy(gen.B, loc, unownedValue, dest, isInit);
     gen.B.emitDestroyValueOperation(loc, value);
     return;
@@ -2366,7 +2373,7 @@
     (void) unownedType;
 
     SILValue unowned = B.createRefToUnowned(loc, semanticValue, storageType);
-    B.createUnownedRetain(loc, unowned, Atomicity::Atomic);
+    B.createUnownedRetain(loc, unowned, B.getDefaultAtomicity());
     B.emitDestroyValueOperation(loc, semanticValue);
     return unowned;
   }
diff --git a/lib/SILGen/SILGenMaterializeForSet.cpp b/lib/SILGen/SILGenMaterializeForSet.cpp
index 52aaa46..53326de 100644
--- a/lib/SILGen/SILGenMaterializeForSet.cpp
+++ b/lib/SILGen/SILGenMaterializeForSet.cpp
@@ -12,6 +12,147 @@
 //
 // Emission of materializeForSet.
 //
+// There are two cases where materializeForSet is used for inout access:
+//
+// === Storage is virtually dispatched on a base class ===
+//
+// For example, suppose we have this setup, where a computed property in a
+// base class is overridden with a computed property in the derived class:
+//
+//   class Base<T> { var x: T }
+//   class Derived : Base<Int> { override var x: Int { ... } }
+//   func operate(b: Base<Int>) {
+//     b.x += 1
+//   }
+//
+// As far as caller is concerned, the callback is invoked with the following
+// SIL type:
+//
+// @convention(method)
+// <T> (RawPointer, @inout UnsafeValueBuffer, @inout Base<T>, @thick Base<T>.Type) -> ()
+//
+// The caller will pass the first four formal parameters, followed by the
+// type metadata for 'T'.
+//
+// However if the dynamic type of the parameter 'b' is actually 'Derived',
+// then the actual callback has this SIL type:
+//
+// @convention(method)
+// (RawPointer, @inout UnsafeValueBuffer, @inout Derived, @thick Derived.Type) -> ()
+//
+// This is a fully concrete function type, with no additional generic metadata.
+//
+// These two callbacks are be ABI-compatible though, because IRGen makes three
+// guarantees:
+//
+// 1) Passing extra arguments (in this case, the type metadata for 'T') is a
+//    no-op.
+//
+// 2) IRGen knows to recover the type metadata for 'T' from the
+//    '@thick Base<T>.Type' parameter, instead of passing it separately.
+//
+// 3) The metatype for 'Derived' must be layout-compatible with 'Base<T>';
+//    since the generic parameter 'T' is made concrete, we expect to find the
+//    type metadata for 'Int' at the same offset within 'Derived.Type' as the
+//    generic parameter 'T' in 'Base<T>.Type'.
+//
+// === Storage is virtually dispatched on a protocol ===
+//
+// For example,
+//
+//   protocol BoxLike { associatedtype Element; var x: Element { get set } }
+//   func operate<B : BoxLike>(b: B) where B.Element == Int {
+//     b.x += 1
+//   }
+//
+// As far as the caller is concerned, the callback is invoked with following
+// SIL type:
+//
+// <Self : BoxLike> (RawPointer, @inout UnsafeValueBuffer, @inout Self, @thick Self.Type) -> ()
+//
+// At the IRGen level, a call of a SIL function with the above type will pass
+// the four formal parameters, followed by the type metadata for 'Self', and
+// then followed by the protocol witness table for 'Self : BoxLike'.
+//
+// As in the class case, the callback won't have the same identical SIL type,
+// because it might have a different representation of 'Self'.
+//
+// So we must consider two separate cases:
+//
+// 1) The witness is a method of the concrete conforming type, eg,
+//
+//      struct Box<T> : BoxLike { var x: T }
+//
+//    Here, the actual callback will have the following type:
+//
+//    @convention(method)
+//    <T> (RawPointer, @inout UnsafeValueBuffer, @inout Box<T>, @thick Box<T>.Type) -> ()
+//
+//    As with the class case, IRGen can already do the right thing -- the type
+//    metadata for 'T' is recovered from the '@thick Box<T>.Type' parameter,
+//    and the type metadata for 'Self' as well as the conformance
+//    'Self : BoxLike' are ignored.
+//
+// 2) The witness is a protocol extension method, possibly of some other protocol, eg,
+//
+//      protocol SomeOtherProtocol { }
+//      extension SomeOtherProtocol { var x: Element { ... } }
+//      struct FunnyBox<T> : BoxLike, SomeOtherProtocol { typealias Element = T }
+//
+//    Here, the actual callback will have the following type:
+//
+//    @convention(method)
+//    <Self : SomeOtherProtocol> (RawPointer, @inout UnsafeValueBuffer, @inout Self, @thick Self.Type) -> ()
+//
+//    Here, the actual callback expects to receive the four formal parameters,
+//    followed by the type metadata for 'Self', followed by the witness table
+//    for the conformance 'Self : SomeOtherProtocol'. Note that the
+//    conformance cannot be recovered from the thick metatype.
+//
+//    This is *not* ABI-compatible with the type used at the call site,
+//    because the caller is passing in the conformance of 'Self : BoxLike'
+//    (the requirement's signature) but the callee is expecting
+//    'Self : SomeOtherProtocol' (the witness signature).
+//
+//    For this reason the materializeForSet method in the protocol extension
+//    of 'SomeOtherProtocol' cannot witness the materializeForSet requirement
+//    of 'BoxLike'. So instead, the protocol witness thunk for
+//    materializeForSet cannot delegate to the materializeForSet witness at
+//    all; it's entirely open-coded, with its own callback that has the right
+//    calling convention.
+//
+// === Storage has its own generic parameters ===
+//
+// One final special case is where the storage has its own generic parameters;
+// that is, a generic subscript.
+//
+// Suppose we have the following protocol:
+//
+//   protocol GenericSubscript { subscript<T, U>(t: T) -> U { get set } }
+//
+// At the call site, the callback is invoked with the following signature:
+//
+// @convention(witness_method)
+// <Self : GenericSubscript, T, U> (RawPointer, @inout UnsafeValueBuffer, @inout Self, @thick Self.Type) -> ()
+//
+// If the witness is a member of a concrete type 'AnyDictionary', the actual
+// callback will have the following signature:
+//
+// @convention(method)
+// <T, U> (RawPointer, @inout UnsafeValueBuffer, @inout AnyDictionary, @thick SelfAnyDictionary.Type) -> ()
+//
+// These are ABI-compatible; the key is that witness_method passes the Self
+// metadata and conformance at the end, after the type metadata for innermost
+// generic parameters, and so everything lines up.
+//
+// === Summary ===
+//
+// To recap, we assume the following types are ABI-compatible:
+//
+// @convention(method) <T, U, V> (..., Foo<T, U>.Type)
+// @convention(witness_method) <T, U, V> (..., Foo<T, U>.Type)
+// @convention(witness_method) <Self : P, V> (..., Self.Type)
+//
 //===----------------------------------------------------------------------===//
 
 #include "SILGen.h"
@@ -21,10 +162,9 @@
 #include "Scope.h"
 #include "Initialization.h"
 #include "swift/AST/AST.h"
-#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Types.h"
-#include "swift/AST/DiagnosticsCommon.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Mangle.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/ProtocolConformance.h"
@@ -125,11 +265,15 @@
 
   SILType WitnessStorageType;
 
+  SILFunctionTypeRepresentation CallbackRepresentation;
+
 private:
 
   MaterializeForSetEmitter(SILGenModule &SGM, SILLinkage linkage,
                            FuncDecl *witness, SubstitutionList subs,
-                           Type selfInterfaceType, Type selfType)
+                           GenericEnvironment *genericEnv,
+                           Type selfInterfaceType, Type selfType,
+                           SILFunctionTypeRepresentation callbackRepresentation)
     : SGM(SGM),
       Linkage(linkage),
       RequirementStorage(nullptr),
@@ -138,11 +282,12 @@
       WitnessStorage(witness->getAccessorStorageDecl()),
       WitnessStoragePattern(AbstractionPattern::getInvalid()),
       WitnessSubs(subs),
-      GenericEnv(nullptr),
+      GenericEnv(genericEnv),
       SelfInterfaceType(selfInterfaceType->getCanonicalType()),
       SubstSelfType(selfType->getCanonicalType()),
       TheAccessSemantics(AccessSemantics::Ordinary),
-      IsSuper(false) {
+      IsSuper(false),
+      CallbackRepresentation(callbackRepresentation) {
 
     // Determine the formal type of the 'self' parameter.
     if (WitnessStorage->isStatic()) {
@@ -164,6 +309,9 @@
     WitnessStorageType =
       SGM.Types.getLoweredType(WitnessStoragePattern, SubstStorageType)
                .getObjectType();
+
+    if (genericEnv)
+      GenericSig = genericEnv->getGenericSignature()->getCanonicalSignature();
   }
 
 public:
@@ -176,18 +324,8 @@
                   FuncDecl *requirement, FuncDecl *witness,
                   SubstitutionList witnessSubs) {
     MaterializeForSetEmitter emitter(SGM, linkage, witness, witnessSubs,
-                                     selfInterfaceType, selfType);
-
-    if (conformance) {
-      if (auto signature = conformance->getGenericSignature())
-        emitter.GenericSig = signature->getCanonicalSignature();
-      emitter.GenericEnv = genericEnv;
-    } else {
-      auto signature = requirement->getGenericSignatureOfContext();
-      emitter.GenericSig = signature->getCanonicalSignature();
-      emitter.GenericEnv = genericEnv;
-    }
-
+                                     genericEnv, selfInterfaceType, selfType,
+                                     SILFunctionTypeRepresentation::WitnessMethod);
     emitter.RequirementStorage = requirement->getAccessorStorageDecl();
 
     // Determine the desired abstraction pattern of the storage type
@@ -214,15 +352,11 @@
     Type selfType = witness->mapTypeIntoContext(selfInterfaceType);
 
     SILDeclRef constant(witness);
-    auto constantInfo = SGM.Types.getConstantInfo(constant);
-
     MaterializeForSetEmitter emitter(SGM, constant.getLinkage(ForDefinition),
                                      witness, witnessSubs,
-                                     selfInterfaceType, selfType);
-
-    if (auto signature = witness->getGenericSignatureOfContext())
-      emitter.GenericSig = signature->getCanonicalSignature();
-    emitter.GenericEnv = constantInfo.GenericEnv;
+                                     witness->getGenericEnvironment(),
+                                     selfInterfaceType, selfType,
+                                     SILFunctionTypeRepresentation::Method);
 
     emitter.RequirementStorage = emitter.WitnessStorage;
     emitter.RequirementStoragePattern = emitter.WitnessStoragePattern;
@@ -317,11 +451,8 @@
     CanType witnessSelfType =
       Witness->computeInterfaceSelfType()->getCanonicalType();
     witnessSelfType = getSubstWitnessInterfaceType(witnessSelfType);
-    if (auto selfTuple = dyn_cast<TupleType>(witnessSelfType)) {
-      assert(selfTuple->getNumElements() == 1);
-      witnessSelfType = selfTuple.getElementType(0);
-    }
-    witnessSelfType = witnessSelfType.getLValueOrInOutObjectType();
+    witnessSelfType = witnessSelfType->getInOutObjectType()
+      ->getCanonicalType();
 
     // Eagerly loading here could cause an unnecessary
     // load+materialize in some cases, but it's not really important.
@@ -387,9 +518,12 @@
   /// Given part of the witness's interface type, produce its
   /// substitution according to the witness substitutions.
   CanType getSubstWitnessInterfaceType(CanType type) {
-    auto subs = SubstSelfType->getRValueInstanceType()
-        ->getMemberSubstitutionMap(SGM.SwiftModule, WitnessStorage);
-    return type.subst(subs)->getCanonicalType();
+    if (auto *witnessSig = Witness->getGenericSignature()) {
+      auto subMap = witnessSig->getSubstitutionMap(WitnessSubs);
+      return type.subst(subMap, SubstFlags::UseErrorType)->getCanonicalType();
+    }
+
+    return type;
   }
 
 };
@@ -550,14 +684,23 @@
   auto callbackType =
       SGM.Types.getMaterializeForSetCallbackType(WitnessStorage,
                                                  GenericSig,
-                                                 SelfInterfaceType);
-  auto callback =
-      SGM.M.getOrCreateFunction(Witness, CallbackName, Linkage,
-                                callbackType, IsBare,
-                                F.isTransparent(),
-                                F.isFragile());
+                                                 SelfInterfaceType,
+                                                 CallbackRepresentation);
 
-  callback->setGenericEnvironment(GenericEnv);
+  auto *genericEnv = GenericEnv;
+  if (GenericEnv && GenericEnv->getGenericSignature()->areAllParamsConcrete())
+    genericEnv = nullptr;
+
+  auto callback =
+    SGM.M.createFunction(Linkage, CallbackName, callbackType,
+                         genericEnv, SILLocation(Witness),
+                         IsBare, F.isTransparent(), F.isFragile(),
+                         IsNotThunk,
+                         /*ClassVisibility=*/SILFunction::NotRelevant,
+                         /*InlineStrategy=*/InlineDefault,
+                         /*EffectsKind=*/EffectsKind::Unspecified,
+                         /*InsertBefore=*/&F);
+
   callback->setDebugScope(new (SGM.M) SILDebugScope(Witness, callback));
 
   PrettyStackTraceSILFunction X("silgen materializeForSet callback", callback);
@@ -680,7 +823,7 @@
       break;
 
     case AddressorKind::NativePinning:
-      gen.B.createStrongUnpin(loc, owner, Atomicity::Atomic);
+      gen.B.createStrongUnpin(loc, owner, gen.B.getDefaultAtomicity());
       break;
     }
 
@@ -784,7 +927,7 @@
       // ownership of it.
       SILValue indicesV =
         gen.B.createProjectValueBuffer(loc, indicesTy, callbackBuffer);
-      if (indicesTL->isLoadable())
+      if (indicesTL->isLoadable() || !gen.silConv.useLoweredAddresses())
         indicesV = indicesTL->emitLoad(gen.B, loc, indicesV,
                                        LoadOwnershipQualifier::Take);
       ManagedValue mIndices =
@@ -805,7 +948,7 @@
     auto &valueTL = gen.getTypeLowering(lvalue.getTypeOfRValue());
     value = gen.B.createPointerToAddress(
       loc, value, valueTL.getLoweredType().getAddressType(), /*isStrict*/ true);
-    if (valueTL.isLoadable())
+    if (valueTL.isLoadable() || !gen.silConv.useLoweredAddresses())
       value = valueTL.emitLoad(gen.B, loc, value, LoadOwnershipQualifier::Take);
     ManagedValue mValue = gen.emitManagedRValueWithCleanup(value, valueTL);
     RValue rvalue(gen, loc, lvalue.getSubstFormalType(), mValue);
diff --git a/lib/SILGen/SILGenPattern.cpp b/lib/SILGen/SILGenPattern.cpp
index a2b74b6..c53f642 100644
--- a/lib/SILGen/SILGenPattern.cpp
+++ b/lib/SILGen/SILGenPattern.cpp
@@ -1527,16 +1527,16 @@
     innerFailure = &specializedFailure;
   
   // Perform a conditional cast branch.
-  SGF.emitCheckedCastBranch(loc, castOperand,
-                            sourceType, targetType, SGFContext(),
-    // Success block: recurse.
-    [&](ManagedValue castValue) {
-      handleCase(ConsumableManagedValue::forOwned(castValue),
-                 specializedRows, *innerFailure);
-      assert(!SGF.B.hasValidInsertionPoint() && "did not end block");
-    },
-    // Failure block: branch out to the continuation block.
-    [&] { (*innerFailure)(loc); });
+  SGF.emitCheckedCastBranchOld(
+      loc, castOperand, sourceType, targetType, SGFContext(),
+      // Success block: recurse.
+      [&](ManagedValue castValue) {
+        handleCase(ConsumableManagedValue::forOwned(castValue), specializedRows,
+                   *innerFailure);
+        assert(!SGF.B.hasValidInsertionPoint() && "did not end block");
+      },
+      // Failure block: branch out to the continuation block.
+      [&] { (*innerFailure)(loc); });
 }
 
 /// Perform specialized dispatch for a sequence of EnumElementPattern or an
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
index fb6d960..8092c04 100644
--- a/lib/SILGen/SILGenPoly.cpp
+++ b/lib/SILGen/SILGenPoly.cpp
@@ -1097,7 +1097,7 @@
         SGF.B.createInitExistentialAddr(Loc, existentialBuf,
                                         inputTupleType,
                                         concreteTL.getLoweredType(),
-                                        /*Conformances=*/{});
+                                        /*conformances=*/{});
 
       auto tupleTemp = SGF.useBufferAsTemporary(tupleBuf, concreteTL);
       translateAndImplodeInto(inputOrigType, inputTupleType,
@@ -1911,7 +1911,7 @@
     SILValue outerConcreteResultAddr
       = Gen.B.createInitExistentialAddr(Loc, outerResultAddr, innerSubstType,
                                         Gen.getLoweredType(opaque, innerSubstType),
-                                        /*Conformances=*/{});
+                                        /*conformances=*/{});
 
     // Emit into that address.
     planTupleIntoIndirectResult(innerOrigType, innerSubstType,
@@ -2517,7 +2517,8 @@
   builder.addGenericParameter(newGenericParam);
   Requirement newRequirement(RequirementKind::Conformance, newGenericParam,
                              openedExistential->getOpenedExistentialType());
-  auto source = RequirementSource::forAbstract(builder);
+  auto source =
+    GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
   builder.addRequirement(newRequirement, source);
 
   builder.finalize(SourceLoc(), {newGenericParam},
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
index fb7a624..971662d 100644
--- a/lib/SILGen/SILGenType.cpp
+++ b/lib/SILGen/SILGenType.cpp
@@ -494,8 +494,6 @@
       SGM.emitPropertyBehavior(vd);
     if (vd->hasStorage()) {
       assert(vd->isStatic() && "stored property in extension?!");
-      ExtensionDecl *ext = cast<ExtensionDecl>(vd->getDeclContext());
-      NominalTypeDecl *theType = ext->getExtendedType()->getAnyNominal();
       return emitTypeMemberGlobalVariable(SGM, vd);
     }
     visitAbstractStorageDecl(vd);
diff --git a/lib/SILOptimizer/Analysis/ArraySemantic.cpp b/lib/SILOptimizer/Analysis/ArraySemantic.cpp
index 064b980..aa2d3f1 100644
--- a/lib/SILOptimizer/Analysis/ArraySemantic.cpp
+++ b/lib/SILOptimizer/Analysis/ArraySemantic.cpp
@@ -374,17 +374,19 @@
   bool IsOwnedSelf = SelfConvention == ParameterConvention::Direct_Owned;
 
   // Emit matching release for owned self if we are moving the original call.
-  if (!LeaveOriginal && IsOwnedSelf)
-    SILBuilderWithScope(SemanticsCall)
-        .createReleaseValue(SemanticsCall->getLoc(), Self, Atomicity::Atomic);
+  if (!LeaveOriginal && IsOwnedSelf) {
+    SILBuilderWithScope Builder(SemanticsCall);
+    Builder.createReleaseValue(SemanticsCall->getLoc(), Self, Builder.getDefaultAtomicity());
+  }
 
   auto NewArrayStructValue = copyArrayLoad(Self, InsertBefore, DT);
 
   // Retain the array.
-  if (IsOwnedSelf)
-    SILBuilderWithScope(InsertBefore, SemanticsCall)
-        .createRetainValue(SemanticsCall->getLoc(), NewArrayStructValue,
-                           Atomicity::Atomic);
+  if (IsOwnedSelf) {
+    SILBuilderWithScope Builder(InsertBefore, SemanticsCall);
+    Builder.createRetainValue(SemanticsCall->getLoc(), NewArrayStructValue,
+                              Builder.getDefaultAtomicity());
+  }
 
   return NewArrayStructValue;
 }
@@ -477,10 +479,11 @@
 
 void swift::ArraySemanticsCall::removeCall() {
   if (getSelfParameterConvention(SemanticsCall) ==
-      ParameterConvention::Direct_Owned)
-    SILBuilderWithScope(SemanticsCall)
-        .createReleaseValue(SemanticsCall->getLoc(), getSelf(),
-                            Atomicity::Atomic);
+      ParameterConvention::Direct_Owned) {
+    SILBuilderWithScope Builder(SemanticsCall);
+    Builder.createReleaseValue(SemanticsCall->getLoc(), getSelf(),
+                               Builder.getDefaultAtomicity());
+  }
 
   switch (getKind()) {
   default: break;
diff --git a/lib/SILOptimizer/Analysis/EscapeAnalysis.cpp b/lib/SILOptimizer/Analysis/EscapeAnalysis.cpp
index 8c0637f..44a04c6 100644
--- a/lib/SILOptimizer/Analysis/EscapeAnalysis.cpp
+++ b/lib/SILOptimizer/Analysis/EscapeAnalysis.cpp
@@ -1004,7 +1004,7 @@
   if (Ty.hasReferenceSemantics())
     return true;
 
-  if (Ty.getSwiftType() == Mod->getASTContext().TheRawPointerType)
+  if (Ty.getSwiftRValueType() == Mod->getASTContext().TheRawPointerType)
     return true;
 
   if (auto *Str = Ty.getStructOrBoundGenericStruct()) {
diff --git a/lib/SILOptimizer/IPO/CapturePromotion.cpp b/lib/SILOptimizer/IPO/CapturePromotion.cpp
index b53c482..9a6ed88 100644
--- a/lib/SILOptimizer/IPO/CapturePromotion.cpp
+++ b/lib/SILOptimizer/IPO/CapturePromotion.cpp
@@ -192,36 +192,22 @@
 namespace {
 /// \brief A SILCloner subclass which clones a closure function while converting
 /// one or more captures from 'inout' (by-reference) to by-value.
-class ClosureCloner : public TypeSubstCloner<ClosureCloner> {
+class ClosureCloner : public SILClonerWithScopes<ClosureCloner> {
 public:
   friend class SILVisitor<ClosureCloner>;
   friend class SILCloner<ClosureCloner>;
 
   ClosureCloner(SILFunction *Orig, IsFragile_t Fragile,
                 StringRef ClonedName,
-                SubstitutionMap &InterfaceSubs,
-                SubstitutionList ApplySubs,
                 IndicesSet &PromotableIndices);
 
   void populateCloned();
 
   SILFunction *getCloned() { return &getBuilder().getFunction(); }
 
-protected:
-  // FIXME: We intentionally call SILClonerWithScopes here to ensure
-  //        the debug scopes are set correctly for cloned
-  //        functions. TypeSubstCloner, SILClonerWithScopes, and
-  //        SILCloner desperately need refactoring and/or combining so
-  //        that the obviously right things are happening for cloning
-  //        vs. inlining.
-  void postProcess(SILInstruction *Orig, SILInstruction *Cloned) {
-    SILClonerWithScopes<ClosureCloner>::postProcess(Orig, Cloned);
-  }
-
 private:
   static SILFunction *initCloned(SILFunction *Orig, IsFragile_t Fragile,
                                  StringRef ClonedName,
-                                 SubstitutionMap &InterfaceSubs,
                                  IndicesSet &PromotableIndices);
 
   void visitDebugValueAddrInst(DebugValueAddrInst *Inst);
@@ -316,13 +302,9 @@
 
 ClosureCloner::ClosureCloner(SILFunction *Orig, IsFragile_t Fragile,
                              StringRef ClonedName,
-                             SubstitutionMap &InterfaceSubs,
-                             SubstitutionList ApplySubs,
                              IndicesSet &PromotableIndices)
-  : TypeSubstCloner<ClosureCloner>(
-                           *initCloned(Orig, Fragile, ClonedName, InterfaceSubs,
-                                       PromotableIndices),
-                           *Orig, ApplySubs),
+  : SILClonerWithScopes<ClosureCloner>(
+                           *initCloned(Orig, Fragile, ClonedName, PromotableIndices)),
     Orig(Orig), PromotableIndices(PromotableIndices) {
   assert(Orig->getDebugScope()->Parent != getCloned()->getDebugScope()->Parent);
 }
@@ -419,7 +401,6 @@
 SILFunction*
 ClosureCloner::initCloned(SILFunction *Orig, IsFragile_t Fragile,
                           StringRef ClonedName,
-                          SubstitutionMap &InterfaceSubs,
                           IndicesSet &PromotableIndices) {
   SILModule &M = Orig->getModule();
 
@@ -436,9 +417,6 @@
       OrigFTI->getResults(), OrigFTI->getOptionalErrorResult(),
       M.getASTContext());
 
-  auto SubstTy = SILType::substFuncType(M, InterfaceSubs, ClonedTy,
-                                        /* dropGenerics = */ false);
-  
   assert((Orig->isTransparent() || Orig->isBare() || Orig->getLocation())
          && "SILFunction missing location");
   assert((Orig->isTransparent() || Orig->isBare() || Orig->getDebugScope())
@@ -446,7 +424,7 @@
   assert(!Orig->isGlobalInit() && "Global initializer cannot be cloned");
 
   auto *Fn = M.createFunction(
-      Orig->getLinkage(), ClonedName, SubstTy, Orig->getGenericEnvironment(),
+      Orig->getLinkage(), ClonedName, ClonedTy, Orig->getGenericEnvironment(),
       Orig->getLocation(), Orig->isBare(), IsNotTransparent, Fragile,
       Orig->isThunk(), Orig->getClassVisibility(), Orig->getInlineStrategy(),
       Orig->getEffectsKind(), Orig, Orig->getDebugScope());
@@ -726,18 +704,6 @@
   return false;
 }
 
-static bool signatureHasDependentTypes(SILFunction *Callee) {
-  SILFunctionConventions conventions = Callee->getConventions();
-  if (conventions.getSILResultType().hasTypeParameter())
-    return true;
-
-  for (auto Param : conventions.funcTy->getParameters())
-    if (conventions.getSILType(Param).hasTypeParameter())
-      return true;
-
-  return false;
-}
-
 /// \brief Examine an alloc_box instruction, returning true if at least one
 /// capture of the boxed variable is promotable.  If so, then the pair of the
 /// partial_apply instruction and the index of the box argument in the closure's
@@ -759,11 +725,6 @@
       if (IM.count(PAI))
         return false;
 
-      // Bail if the signature has any dependent types as we do not
-      // currently support these.
-      if (signatureHasDependentTypes(PAI->getCalleeFunction()))
-        return false;
-
       SILModule &M = PAI->getModule();
       auto closureType = PAI->getType().castTo<SILFunctionType>();
       SILFunctionConventions closureConv(closureType, M);
@@ -864,13 +825,6 @@
                         IndicesSet &PromotableIndices) {
   SILFunction *F = PAI->getFunction();
 
-  // Create the substitution maps.
-  auto ApplySubs = PAI->getSubstitutions();
-
-  SubstitutionMap InterfaceSubs;
-  if (auto genericSig = PAI->getOrigCalleeType()->getGenericSignature())
-    InterfaceSubs = genericSig->getSubstitutionMap(ApplySubs);
-
   // Create the Cloned Name for the function.
   SILFunction *Orig = FRI->getReferencedFunction();
 
@@ -887,8 +841,7 @@
   }
 
   // Otherwise, create a new clone.
-  ClosureCloner cloner(Orig, Fragile, ClonedName, InterfaceSubs,
-                       ApplySubs, PromotableIndices);
+  ClosureCloner cloner(Orig, Fragile, ClonedName, PromotableIndices);
   cloner.populateCloned();
   return cloner.getCloned();
 }
diff --git a/lib/SILOptimizer/IPO/ClosureSpecializer.cpp b/lib/SILOptimizer/IPO/ClosureSpecializer.cpp
index 24c9fe0..860c4fc 100644
--- a/lib/SILOptimizer/IPO/ClosureSpecializer.cpp
+++ b/lib/SILOptimizer/IPO/ClosureSpecializer.cpp
@@ -343,9 +343,9 @@
       // Emit the retain that matches the captured argument by the partial_apply
       // in the callee that is consumed by the partial_apply.
       Builder.setInsertionPoint(AI.getInstruction());
-      Builder.createRetainValue(Closure->getLoc(), Arg, Atomicity::Atomic);
+      Builder.createRetainValue(Closure->getLoc(), Arg, Builder.getDefaultAtomicity());
     } else {
-      Builder.createRetainValue(Closure->getLoc(), Arg, Atomicity::Atomic);
+      Builder.createRetainValue(Closure->getLoc(), Arg, Builder.getDefaultAtomicity());
     }
   }
 
@@ -364,9 +364,9 @@
     // argument to AI.
     if (CSDesc.isClosureConsumed() && CSDesc.closureHasRefSemanticContext()) {
       Builder.setInsertionPoint(TAI->getNormalBB()->begin());
-      Builder.createReleaseValue(Closure->getLoc(), Closure, Atomicity::Atomic);
+      Builder.createReleaseValue(Closure->getLoc(), Closure, Builder.getDefaultAtomicity());
       Builder.setInsertionPoint(TAI->getErrorBB()->begin());
-      Builder.createReleaseValue(Closure->getLoc(), Closure, Atomicity::Atomic);
+      Builder.createReleaseValue(Closure->getLoc(), Closure, Builder.getDefaultAtomicity());
       Builder.setInsertionPoint(AI.getInstruction());
     }
   } else {
@@ -377,7 +377,7 @@
     // right after NewAI. This is to balance the +1 from being an @owned
     // argument to AI.
     if (CSDesc.isClosureConsumed() && CSDesc.closureHasRefSemanticContext())
-      Builder.createReleaseValue(Closure->getLoc(), Closure, Atomicity::Atomic);
+      Builder.createReleaseValue(Closure->getLoc(), Closure, Builder.getDefaultAtomicity());
   }
 
   // Replace all uses of the old apply with the new apply.
@@ -425,10 +425,10 @@
 
   // Extend the lifetime of a captured argument to cover the callee.
   SILBuilderWithScope Builder(getClosure());
-  Builder.createRetainValue(getClosure()->getLoc(), Arg, Atomicity::Atomic);
+  Builder.createRetainValue(getClosure()->getLoc(), Arg, Builder.getDefaultAtomicity());
   for (auto *I : CInfo->LifetimeFrontier) {
     Builder.setInsertionPoint(I);
-    Builder.createReleaseValue(getClosure()->getLoc(), Arg, Atomicity::Atomic);
+    Builder.createReleaseValue(getClosure()->getLoc(), Arg, Builder.getDefaultAtomicity());
   }
 }
 
@@ -647,7 +647,7 @@
       if (isa<ReturnInst>(TI)) {
         Builder.setInsertionPoint(TI);
         Builder.createReleaseValue(Loc, SILValue(NewClosure),
-                                   Atomicity::Atomic);
+                                   Builder.getDefaultAtomicity());
         continue;
       }
 
@@ -663,7 +663,7 @@
       // value, we will retain the partial apply before we release it and
       // potentially eliminate it.
       Builder.setInsertionPoint(NoReturnApply.getInstruction());
-      Builder.createReleaseValue(Loc, SILValue(NewClosure), Atomicity::Atomic);
+      Builder.createReleaseValue(Loc, SILValue(NewClosure), Builder.getDefaultAtomicity());
     }
   }
 }
diff --git a/lib/SILOptimizer/Mandatory/AddressLowering.cpp b/lib/SILOptimizer/Mandatory/AddressLowering.cpp
index 6bf6614..4731fe0 100644
--- a/lib/SILOptimizer/Mandatory/AddressLowering.cpp
+++ b/lib/SILOptimizer/Mandatory/AddressLowering.cpp
@@ -77,6 +77,12 @@
     return valueHashMap.find(value) != valueHashMap.end();
   }
 
+  ValueStorage &getStorage(SILValue value) {
+    auto hashIter = valueHashMap.find(value);
+    assert(hashIter != valueHashMap.end() && "Missing SILValue");
+    return valueVector[hashIter->second].second;
+  }
+
   ValueStorage &insertValue(SILValue value) {
     auto hashResult =
         valueHashMap.insert(std::make_pair(value, valueVector.size()));
@@ -87,10 +93,18 @@
     return valueVector.back().second;
   }
 
-  ValueStorage &getStorage(SILValue value) {
-    auto hashIter = valueHashMap.find(value);
+  // Replace entry for `oldValue` with an entry for `newValue` preserving the
+  // the mapped ValueStorage.
+  void replaceValue(SILValue oldValue, SILValue newValue) {
+    auto hashIter = valueHashMap.find(oldValue);
     assert(hashIter != valueHashMap.end() && "Missing SILValue");
-    return valueVector[hashIter->second].second;
+    unsigned idx = hashIter->second;
+    valueHashMap.erase(hashIter);
+
+    valueVector[idx].first = newValue;
+    
+    auto hashResult = valueHashMap.insert(std::make_pair(newValue, idx));
+    assert(hashResult.second && "SILValue already mapped");
   }
 };
 } // end anonymous namespace
@@ -117,7 +131,10 @@
   AddressLoweringState(SILFunction *F) : F(F) {}
 
   void markDeadInst(SILInstruction *inst) {
-    assert(onlyHaveDebugUses(inst));
+#ifndef NDEBUG
+    for (Operand *use : inst->getUses())
+      assert(instsToDelete.count(use->getUser()));
+#endif
     instsToDelete.insert(inst);
   }
 };
@@ -128,7 +145,7 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-/// Collect all Opaque/Resilient values, inserting them in a ValueStorageMap in
+/// Collect all opaque/resilient values, inserting them in `valueStorageMap` in
 /// RPO order.
 ///
 /// Collect all call arguments with formally indirect SIL argument convention in
@@ -152,7 +169,10 @@
 };
 } // end anonymous namespace
 
-/// Populate valueStorageMap. Find all Opaque/Resilient SILValues and add them
+/// Top-level entry: Populate `valueStorageMap`, `indirectResults`, and
+/// `indirectOperands`.
+///
+/// Find all Opaque/Resilient SILValues and add them
 /// to valueStorageMap in RPO.
 void OpaqueValueVisitor::mapValueStorage() {
   for (auto *BB : postorderInfo.getReversePostOrder()) {
@@ -176,8 +196,12 @@
   }
 }
 
-/// Populate indirectOperands. Add an operand for each call argument with a
-/// formally indirect convention.
+/// Populate `indirectResults` and `indirectOperands`.
+///
+/// If this call has indirect formal results, add it to `indirectResults`.
+/// 
+/// Add each call operand with a formally indirect convention to
+/// `indirectOperands`.
 void OpaqueValueVisitor::visitApply(ApplySite applySite) {
   if (applySite.getSubstCalleeType()->hasIndirectFormalResults())
     pass.indirectResults.push_back(applySite.getInstruction());
@@ -195,11 +219,14 @@
   }
 }
 
+/// If `value` is address-only add it to the `valueStorageMap`.
+/// 
 /// TODO: Set ValueStorage.projectionFrom whenever there is a single
 /// isComposingOperand() use and the aggregate's storage can be hoisted to a
 /// dominating point.
 void OpaqueValueVisitor::visitValue(SILValue value) {
-  if (value->getType().isAddressOnly(pass.F->getModule())) {
+  if (value->getType().isObject()
+      && value->getType().isAddressOnly(pass.F->getModule())) {
     if (pass.valueStorageMap.contains(value)) {
       assert(isa<SILFunctionArgument>(
           pass.valueStorageMap.getStorage(value).storageAddress));
@@ -241,6 +268,11 @@
   unsigned insertIndirectResultParameters(unsigned argIdx, SILType resultType);
   void allocateForValue(SILValue value, ValueStorage &storage);
   void allocateForOperand(Operand *operand);
+  void canonicalizeResults(
+    ApplyInst *applyInst,
+    SmallVectorImpl<SILInstruction*> &directResultValues,
+    ArrayRef<Operand*> nonCanonicalUses);
+  void canonicalizeResults(ApplyInst *applyInst);
   void allocateForResults(SILInstruction *origInst);
 };
 } // end anonymous namespace
@@ -280,14 +312,17 @@
   // Create an AllocStack for every formally indirect argument.
   for (Operand *operand : pass.indirectOperands)
     allocateForOperand(operand);
+  pass.indirectOperands.clear();
 
   // Create an AllocStack for every formally indirect result.
+  // This rewrites and potentially erases the original call.
   for (SILInstruction *callInst : pass.indirectResults)
     allocateForResults(callInst);
+  pass.indirectResults.clear();
 }
 
-/// Replace each value-typed argument with an address-typed argument by
-/// inserting a temprorary load instruction.
+/// Replace each value-typed argument to the current function with an
+/// address-typed argument by inserting a temporary load instruction.
 void OpaqueStorageAllocation::replaceFunctionArgs() {
   // Insert temporary argument loads at the top of the function.
   SILBuilder argBuilder(pass.F->getEntryBlock()->begin());
@@ -297,7 +332,7 @@
   for (SILParameterInfo param :
        pass.F->getLoweredFunctionType()->getParameters()) {
 
-    if (param.isFormalIndirect()) {
+    if (param.isFormalIndirect() && !fnConv.isSILIndirect(param)) {
       SILArgument *arg = pass.F->getArgument(argIdx);
       SILType addrType = arg->getType().getAddressType();
 
@@ -326,7 +361,8 @@
 /// Recursively insert function arguments for any @out result type at the
 /// specified index. Return the index after the last inserted result argument.
 ///
-/// This is effectively moved from the old SILGen emitIndirectResultParameters.
+/// Note: This is effectively moved from the old SILGen
+/// emitIndirectResultParameters.
 ///
 /// TODO: It might be faster to generate args directly from
 /// SILFunctionConventions without drilling through the result SILType. But one
@@ -362,6 +398,7 @@
 }
 
 /// Utility to derive SILLocation.
+/// 
 /// TODO: This should be a common utility.
 static SILLocation getLocForValue(SILValue value) {
   if (auto *instr = dyn_cast<SILInstruction>(value)) {
@@ -384,6 +421,11 @@
   if (isa<TupleInst>(value))
     return;
 
+  // Don't bother allocating storage for result tuples. Each element has its own
+  // storage.
+  if (isa<FullApplySite>(value))
+    return;
+
   // Argument loads already have a storage address.
   if (storage.storageAddress) {
     assert(isa<SILFunctionArgument>(storage.storageAddress));
@@ -404,11 +446,16 @@
 }
 
 /// Deallocate temporary call-site stack storage.
+///
+/// `argLoad` is non-null for @out args that are loaded.
 static void insertStackDeallocationAtCall(AllocStackInst *allocInst,
-                                          SILInstruction *applyInst) {
+                                          SILInstruction *applyInst,
+                                          SILInstruction *argLoad) {
+  SILInstruction *lastUse = argLoad ? argLoad : applyInst;
+
   switch (applyInst->getKind()) {
   case ValueKind::ApplyInst: {
-    SILBuilder deallocBuilder(&*std::next(applyInst->getIterator()));
+    SILBuilder deallocBuilder(&*std::next(lastUse->getIterator()));
     deallocBuilder.createDeallocStack(allocInst->getLoc(), allocInst);
     break;
   }
@@ -425,6 +472,9 @@
 /// Allocate storage for formally indirect arguments.
 /// Update the operand to this address.
 /// After this, the SIL argument types no longer match SIL function conventions.
+///
+/// Note: The temporary argument storage does not own its value. If the argument
+/// is owner, the stored value should already have been copied.
 void OpaqueStorageAllocation::allocateForOperand(Operand *operand) {
   SILInstruction *apply = operand->getUser();
   SILValue argValue = operand->get();
@@ -433,77 +483,174 @@
   AllocStackInst *allocInstr =
       callBuilder.createAllocStack(apply->getLoc(), argValue->getType());
 
-  // This is a store [init], but qualifications aren't allowed.
   callBuilder.createStore(apply->getLoc(), argValue, allocInstr,
                           StoreOwnershipQualifier::Unqualified);
 
   operand->set(allocInstr);
 
-  insertStackDeallocationAtCall(allocInstr, apply);
+  insertStackDeallocationAtCall(allocInstr, apply, /*argLoad=*/nullptr);
+}
+
+// Canonicalize call result uses. Treat each result of a multi-result call as
+// independent values. Currently, SILGen may generate tuple_extract for each
+// result but generate a single destroy_value for the entire tuple of
+// results. This makes it impossible to reason about each call result as an
+// independent value according to the callee's function type.
+//
+// directResultValues has an entry for each tuple extract corresponding to
+// that result if one exists. This function will add an entry to
+// directResultValues whenever it needs to materialize a TupleExtractInst.
+void OpaqueStorageAllocation::canonicalizeResults(
+  ApplyInst *applyInst,
+  SmallVectorImpl<SILInstruction*> &directResultValues,
+  ArrayRef<Operand*> nonCanonicalUses) {
+
+  for (Operand *operand : nonCanonicalUses) {
+    auto *destroyInst = dyn_cast<DestroyValueInst>(operand->getUser());
+    if (!destroyInst)
+      llvm::report_fatal_error("Simultaneous use of multiple call results.");
+
+    for (unsigned resultIdx = 0, endIdx = directResultValues.size();
+         resultIdx < endIdx; ++resultIdx) {
+      SILInstruction *result = directResultValues[resultIdx];
+      if (!result) {
+        SILBuilder resultBuilder(std::next(SILBasicBlock::iterator(applyInst)));
+        result = resultBuilder.createTupleExtract(applyInst->getLoc(),
+                                                  applyInst, resultIdx);
+        directResultValues[resultIdx] = result;
+      }
+      SILBuilder B(destroyInst);
+      auto &TL = pass.F->getModule().getTypeLowering(result->getType());
+      TL.emitDestroyValue(B, destroyInst->getLoc(), result);
+    }
+    destroyInst->eraseFromParent();
+  }
 }
 
 /// Allocate storage for formally indirect results at the given call site.
 /// Create a new call instruction with indirect SIL arguments.
-void OpaqueStorageAllocation::allocateForResults(SILInstruction *origInst) {
-  ApplySite apply(origInst);
+void OpaqueStorageAllocation::allocateForResults(SILInstruction *origCallInst) {
+  ApplySite apply(origCallInst);
+
+  SILFunctionConventions origFnConv = apply.getSubstCalleeConv();
+
+  // Gather the original direct return values.
+  // Canonicalize results so no user uses more than one result.
+  SmallVector<SILInstruction *, 8> origDirectResultValues(
+    origFnConv.getNumDirectSILResults());
+  SmallVector<Operand *, 4> nonCanonicalUses;
+  if (origCallInst->getType().is<TupleType>()) {
+    for (Operand *operand : origCallInst->getUses()) {
+      if (auto *extract = dyn_cast<TupleExtractInst>(operand->getUser()))
+        origDirectResultValues[extract->getFieldNo()] = extract;
+      else
+        nonCanonicalUses.push_back(operand);
+    }
+    if (!nonCanonicalUses.empty()) {
+      auto *applyInst = cast<ApplyInst>(origCallInst);
+      canonicalizeResults(applyInst, origDirectResultValues, nonCanonicalUses);
+    }
+  } else {
+    // A call with no indirect results should not have been added to
+    // pass.indirectResults.
+    assert(origDirectResultValues.size() == 1);
+    if (!origCallInst->use_empty()) {
+      origDirectResultValues[0] = origCallInst;
+      // Tuple extract values were already mapped. The call itself was not.
+      pass.valueStorageMap.insertValue(origCallInst);
+    }
+  }
+
+  // Prepare to emit a new call instruction.
+  SILLocation loc = origCallInst->getLoc();
+  SILBuilder callBuilder(origCallInst);
+
+  // Lambda to allocate and map storage for an indirect result.
+  // Note: origDirectResultValues contains null for unused results.
+  auto mapIndirectArg = [&](SILInstruction *origDirectResultVal,
+                            SILType argTy) {
+    if (origDirectResultVal
+        && pass.valueStorageMap.contains(origDirectResultVal)) {
+      // Pass the local storage address as the indirect result address.
+      return
+        pass.valueStorageMap.getStorage(origDirectResultVal).storageAddress;
+    }
+    // Allocate temporary call-site storage for an unused or loadable result.
+    auto *allocInst =
+    callBuilder.createAllocStack(loc, argTy);
+    LoadInst *loadInst = nullptr;
+    if (origDirectResultVal) {
+      // TODO: Find the try_apply's result block.
+      // Build results outside-in to next stack allocations.
+      SILBuilder resultBuilder(
+        std::next(SILBasicBlock::iterator(origCallInst)));
+      // This is a formally indirect argument, but is loadable.
+      loadInst = resultBuilder.createLoad(loc, allocInst,
+                                          LoadOwnershipQualifier::Unqualified);
+      origDirectResultVal->replaceAllUsesWith(loadInst);
+      pass.markDeadInst(origDirectResultVal);
+    }
+    insertStackDeallocationAtCall(allocInst, origCallInst, loadInst);
+    return SILValue(allocInst);
+  };
+
+  // The new call instruction's SIL calling convention.
   SILFunctionConventions loweredFnConv(
       apply.getSubstCalleeType(),
       SILModuleConventions::getLoweredAddressConventions());
 
-  SILLocation loc = origInst->getLoc();
-  SILBuilder callBuilder(origInst);
+  // The new call instruction's SIL argument list.
+  SmallVector<SILValue, 8> newCallArgs(loweredFnConv.getNumSILArguments());
 
-  SmallVector<SILValue, 8> args(loweredFnConv.getNumSILArguments());
-  unsigned firstResultIdx = loweredFnConv.getSILArgIndexOfFirstIndirectResult();
+  // Map the original result indices to new result indices.
+  SmallVector<unsigned, 8> newDirectResultIndices(
+    origFnConv.getNumDirectSILResults());
+  // Indices used to populate newDirectResultIndices.
+  unsigned oldDirectResultIdx = 0, newDirectResultIdx = 0;
 
-  // Find the storage location of each indirect result and populate the SIL
-  // argument vector.
-  SmallVector<TupleExtractInst *, 4> concreteResults;
-  if (origInst->getType().is<TupleType>()) {
-    for (Operand *operand : origInst->getUses()) {
-      if (auto *extract = dyn_cast<TupleExtractInst>(operand->getUser())) {
-        unsigned argIdx = firstResultIdx + extract->getFieldNo();
-        assert(argIdx < loweredFnConv.getSILArgIndexOfFirstParam());
-        if (!extract->getType().isAddressOnly(pass.F->getModule())) {
-          concreteResults.push_back(extract);
-          continue;
-        }
-        auto addr = pass.valueStorageMap.getStorage(extract).storageAddress;
-        assert(addr);
-        args[argIdx] = addr;
+  // The index of the next indirect result argument.
+  unsigned newResultArgIdx =
+    loweredFnConv.getSILArgIndexOfFirstIndirectResult();
+
+  // Visit each result. Redirect results that are now indirect.
+  // Result that remain direct will be redirected later.
+  // Populate newCallArgs and newDirectResultIndices.
+  for_each(
+    apply.getSubstCalleeType()->getResults(),
+    origDirectResultValues, 
+    [&](SILResultInfo resultInfo, SILInstruction *origDirectResultVal) {
+      // Assume that all original results are direct in SIL.
+      assert(!origFnConv.isSILIndirect(resultInfo));
+
+      if (loweredFnConv.isSILIndirect(resultInfo)) {
+        newCallArgs[newResultArgIdx++] =
+          mapIndirectArg(origDirectResultVal,
+                         loweredFnConv.getSILType(resultInfo));;
+        newDirectResultIndices[oldDirectResultIdx++] = newDirectResultIdx;
+      } else {
+        newDirectResultIndices[oldDirectResultIdx++] = newDirectResultIdx++;
       }
-    }
-  } else {
-    auto addr = pass.valueStorageMap.getStorage(origInst).storageAddress;
-    assert(addr);
-    args[firstResultIdx] = addr;
-  }
-  // Allocate storage for any unused or concrete results. One for each missing
-  // entry in the SIL arguments list.
-  unsigned argIdx = firstResultIdx;
-  for (SILType resultTy : loweredFnConv.getIndirectSILResultTypes()) {
-    if (!args[argIdx]) {
-      AllocStackInst *allocInstr = callBuilder.createAllocStack(loc, resultTy);
-      args[argIdx] = allocInstr;
-      insertStackDeallocationAtCall(allocInstr, origInst);
-    }
-    ++argIdx;
-  }
+      // replaceAllUses will be called later to handle direct results that
+      // remain direct results of the new call instruction.
+    });
+
   // Append the existing call arguments to the SIL argument list. They were
   // already lowered to addresses by allocateForOperand.
-  assert(argIdx == loweredFnConv.getSILArgIndexOfFirstParam());
+  assert(newResultArgIdx == loweredFnConv.getSILArgIndexOfFirstParam());
   unsigned origArgIdx = apply.getSubstCalleeConv().getSILArgIndexOfFirstParam();
-  for (unsigned endIdx = args.size(); argIdx < endIdx; ++argIdx, ++origArgIdx) {
-    args[argIdx] = apply.getArgument(origArgIdx);
+  for (unsigned endIdx = newCallArgs.size(); newResultArgIdx < endIdx;
+       ++newResultArgIdx, ++origArgIdx) {
+    newCallArgs[newResultArgIdx] = apply.getArgument(origArgIdx);
   }
+
   // Create a new apply with indirect result operands.
-  SILInstruction *callInst;
-  switch (origInst->getKind()) {
+  SILInstruction *newCallInst;
+  switch (origCallInst->getKind()) {
   case ValueKind::ApplyInst:
-    callInst = callBuilder.createApply(
+    newCallInst = callBuilder.createApply(
         loc, apply.getCallee(), apply.getSubstCalleeSILType(),
-        loweredFnConv.getSILResultType(), apply.getSubstitutions(), args,
-        cast<ApplyInst>(origInst)->isNonThrowing());
+        loweredFnConv.getSILResultType(), apply.getSubstitutions(), newCallArgs,
+        cast<ApplyInst>(origCallInst)->isNonThrowing());
     break;
   case ValueKind::TryApplyInst:
     // TODO: insert dealloc in the catch block.
@@ -513,23 +660,48 @@
   default:
     llvm_unreachable("not implemented for this instruction!");
   }
-  if (pass.valueStorageMap.contains(origInst)) {
-    pass.valueStorageMap.insertValue(callInst);
-    pass.valueStorageMap.getStorage(callInst).storageAddress =
-        pass.valueStorageMap.getStorage(origInst).storageAddress;
-    // origInst remains in the map but has no users.
+
+  // Replace all unmapped uses of the original call with uses of the new call.
+  // 
+  // TODO: handle bbargs from try_apply.
+  SILBuilder resultBuilder(
+    std::next(SILBasicBlock::iterator(origCallInst)));
+  SmallVector<Operand*, 8> origUses(origCallInst->getUses());
+  for (Operand *operand : origUses) {
+    auto *extractInst = dyn_cast<TupleExtractInst>(operand->getUser());
+    if (!extractInst) {
+      assert(origFnConv.getNumDirectSILResults() == 1);
+      assert(pass.valueStorageMap.contains(origCallInst));
+      continue;
+    }
+    unsigned origResultIdx = extractInst->getFieldNo();
+    auto resultInfo = origFnConv.getResults()[origResultIdx];
+
+    if (extractInst->getType().isAddressOnly(pass.F->getModule())) {
+      assert(loweredFnConv.isSILIndirect(resultInfo));
+      assert(pass.valueStorageMap.contains(extractInst));
+      continue;
+    }
+    if (loweredFnConv.isSILIndirect(resultInfo)) {
+      // This loadable indirect use should already be
+      // redirected to a load from the argument storage and marked dead.
+      assert(extractInst->use_empty());
+      continue;
+    }
+    // Either the new call instruction has only a single direct result, or we
+    // map the original tuple field to the new tuple field.
+    SILInstruction *newValue = newCallInst;
+    if (loweredFnConv.getNumDirectSILResults() > 1) {
+      assert(newCallInst->getType().is<TupleType>());
+      newValue = resultBuilder.createTupleExtract(
+        extractInst->getLoc(), newCallInst,
+        newDirectResultIndices[origResultIdx]);
+    }
+    extractInst->replaceAllUsesWith(newValue);
+    extractInst->eraseFromParent();
   }
-  origInst->replaceAllUsesWith(callInst);
-  pass.markDeadInst(origInst);
-  // Load concrete args, and mark the extract for deletion.
-  for (TupleExtractInst *extract : concreteResults) {
-    unsigned argIdx = firstResultIdx + extract->getFieldNo();
-    SILValue arg = args[argIdx];
-    LoadInst *loadArg = callBuilder.createLoad(
-        extract->getLoc(), arg, LoadOwnershipQualifier::Unqualified);
-    extract->replaceAllUsesWith(loadArg);
-    pass.markDeadInst(extract);
-  }
+  if (!pass.valueStorageMap.contains(origCallInst))
+    pass.markDeadInst(origCallInst);
 }
 
 //===----------------------------------------------------------------------===//
@@ -553,15 +725,21 @@
 
   void rewriteFunction() {
     for (auto &valueStorageI : pass.valueStorageMap) {
+      SILValue valueDef = valueStorageI.first;
       valueStorage = valueStorageI.second;
-      DEBUG(llvm::dbgs() << "VALUE   "; valueStorageI.first->dump());
+      DEBUG(llvm::dbgs() << "VALUE   "; valueDef->dump());
       DEBUG(if (valueStorage.storageAddress) {
-        llvm::dbgs() << "STORAGE ";
+        llvm::dbgs() << "  STORAGE ";
         valueStorage.storageAddress->dump();
       });
-      for (Operand *currOper : valueStorageI.first->getUses()) {
+      SmallVector<Operand*, 8> uses(valueDef->getUses());
+      for (Operand *oper : uses) {
+        currOper = oper;
         visit(currOper->getUser());
       }
+      currOper = nullptr;
+      if (auto *defInst = dyn_cast<SILInstruction>(valueDef))
+        visit(defInst);
     }
   }
 
@@ -572,19 +750,24 @@
   }
 
   void beforeVisit(ValueBase *V) {
-    DEBUG(llvm::dbgs() << "REWRITE "; V->dump());
+    DEBUG(llvm::dbgs() << "  REWRITE "; V->dump());
     auto *I = cast<SILInstruction>(V);
     B.setInsertionPoint(I);
     B.setCurrentDebugScope(I->getDebugScope());
   }
 
   void visitApplyInst(ApplyInst *applyInst) {
-    DEBUG(llvm::dbgs() << "CALL "; applyInst->dump();
-          llvm::dbgs() << "OPERAND "; currOper->get()->dump());
-    llvm_unreachable("Unhandled call result.");
+    if (currOper) {
+      DEBUG(llvm::dbgs() << "  CALL "; applyInst->dump();
+            llvm::dbgs() << "  OPERAND "; currOper->get()->dump());
+      llvm_unreachable("Unhandled call result.");
+    }
   }
 
   void visitCopyValueInst(CopyValueInst *copyInst) {
+    if (!currOper)
+      return;
+    
     SILValue srcAddr =
         pass.valueStorageMap.getStorage(copyInst->getOperand()).storageAddress;
     SILValue destAddr =
@@ -593,40 +776,126 @@
                      IsInitialization);
   }
   
+  void visitDebugValueInst(DebugValueInst *debugInst) {
+    SILValue addr =
+      pass.valueStorageMap.getStorage((debugInst->getOperand())).storageAddress;
+    B.createDebugValueAddr(debugInst->getLoc(), addr);
+    pass.markDeadInst(debugInst);
+  }
+  
   void visitDestroyValueInst(DestroyValueInst *destroyInst) {
-    SILValue src = destroyInst->getOperand();
+    assert(currOper->get() == destroyInst->getOperand());
+    SILValue src = currOper->get();
     SILValue addr = pass.valueStorageMap.getStorage(src).storageAddress;
     B.createDestroyAddr(destroyInst->getLoc(), addr);
     pass.markDeadInst(destroyInst);
   }
 
+  void visitLoadInst(LoadInst *loadInst) {
+    assert(!currOper);
+    // Bitwise copy the value. Two locations now share ownership. This is
+    // modeled as a take-init.
+    SILValue addr = pass.valueStorageMap.getStorage(loadInst).storageAddress;
+    if (addr != loadInst->getOperand()) {
+      B.createCopyAddr(loadInst->getLoc(), loadInst->getOperand(), addr,
+                       IsTake, IsInitialization);
+    }
+  }
+
   void visitReturnInst(ReturnInst *returnInst) {
+    assert(currOper->get() == returnInst->getOperand());
+
+    auto insertPt = SILBasicBlock::iterator(returnInst);
+    auto bbStart = returnInst->getParent()->begin();
+    while (insertPt != bbStart) {
+      --insertPt;
+      if (!isa<DeallocStackInst>(*insertPt))
+        break;
+    }
+    B.setInsertionPoint(insertPt);
+
+    // Gather direct function results.
+    unsigned numOrigDirectResults =
+      pass.F->getConventions().getNumDirectSILResults();
+    SmallVector<SILValue, 8> origDirectResultValues;
+    if (numOrigDirectResults == 1)
+      origDirectResultValues.push_back(currOper->get());
+    else {
+      auto *tupleInst = cast<TupleInst>(currOper->get());
+      origDirectResultValues.append(tupleInst->getElements().begin(),
+                                    tupleInst->getElements().end());
+      assert(origDirectResultValues.size() == numOrigDirectResults);
+    }
+
+    SILFunctionConventions origFnConv(pass.F->getConventions());
     SILFunctionConventions loweredFnConv(
         pass.F->getLoweredFunctionType(),
         SILModuleConventions::getLoweredAddressConventions());
 
-    unsigned resultArgIdx = loweredFnConv.getSILArgIndexOfFirstIndirectResult();
-    auto copyResult = [&](SILValue result) {
-      SILArgument *resultArg = B.getFunction().getArgument(resultArgIdx);
-      SILValue resultAddr =
-          pass.valueStorageMap.getStorage(result).storageAddress;
-      B.createCopyAddr(returnInst->getLoc(), resultAddr, resultArg, IsTake,
-                       IsInitialization);
-    };
-    unsigned numIndirectResults = loweredFnConv.getNumIndirectSILResults();
-    if (numIndirectResults == 1) {
-      copyResult(returnInst->getOperand());
-    } else {
-      for (unsigned endIdx = resultArgIdx + numIndirectResults;
-           resultArgIdx < endIdx; ++resultArgIdx) {
-        auto *tupleInst = cast<TupleInst>(returnInst->getOperand());
-        copyResult(tupleInst->getElement(resultArgIdx));
-      }
-    }
-    SILType emptyTy = B.getModule().Types.getLoweredType(
+    // Convert each result.
+    SmallVector<SILValue, 8> newDirectResults;
+    unsigned newResultArgIdx =
+      loweredFnConv.getSILArgIndexOfFirstIndirectResult();
+
+    for_each(
+      pass.F->getLoweredFunctionType()->getResults(),
+      origDirectResultValues, 
+      [&](SILResultInfo resultInfo, SILValue origDirectResultVal) 
+      {
+        // Assume that all original results are direct in SIL.
+        assert(!origFnConv.isSILIndirect(resultInfo));
+        if (loweredFnConv.isSILIndirect(resultInfo)) {
+          assert(newResultArgIdx < loweredFnConv.getSILArgIndexOfFirstParam());
+          SILArgument *resultArg = B.getFunction().getArgument(newResultArgIdx);
+          if (pass.valueStorageMap.contains(origDirectResultVal)) {
+            // Copy the result from local storage into the result argument.
+            SILValue resultAddr =
+              pass.valueStorageMap.getStorage(origDirectResultVal)
+              .storageAddress;
+
+            B.createCopyAddr(returnInst->getLoc(), resultAddr, resultArg,
+                             IsTake, IsInitialization);
+            ++newResultArgIdx;
+          }
+          else {
+            // Sore the result into the result argument.
+            B.createStore(returnInst->getLoc(), origDirectResultVal,
+                          resultArg, StoreOwnershipQualifier::Init);
+            llvm_unreachable("untested."); //!!!
+          }
+        } else {
+          // Record the direct result for populating the result tuple.
+          newDirectResults.push_back(origDirectResultVal);
+        }
+      });
+    assert(newDirectResults.size() == loweredFnConv.getNumDirectSILResults());
+    SILValue newReturnVal;
+    if (newDirectResults.empty()) {
+      SILType emptyTy = B.getModule().Types.getLoweredType(
         TupleType::getEmpty(B.getModule().getASTContext()));
-    auto *tupleInst = B.createTuple(returnInst->getLoc(), emptyTy, {});
-    returnInst->setOperand(tupleInst);
+      newReturnVal = B.createTuple(returnInst->getLoc(), emptyTy, {});
+    } else if (newDirectResults.size() == 1) {
+      newReturnVal = newDirectResults[0];
+    } else {
+      newReturnVal = B.createTuple(returnInst->getLoc(),
+                                   loweredFnConv.getSILResultType(),
+                                   newDirectResults);
+    }
+    returnInst->setOperand(newReturnVal);
+  }
+
+  void visitStoreInst(StoreInst *storeInst) {
+    assert(currOper->get() == storeInst->getSrc());
+    SILValue srcAddr =
+      pass.valueStorageMap.getStorage(currOper->get()).storageAddress;
+    assert(storeInst->getOwnershipQualifier() ==
+           StoreOwnershipQualifier::Unqualified);
+
+    // Bitwise copy the value. Two locations now share ownership. This is
+    // modeled as a take-init.
+    B.createCopyAddr(storeInst->getLoc(), srcAddr, storeInst->getDest(),
+                     IsTake, IsInitialization);
+    pass.markDeadInst(storeInst);
   }
 
   void visitTupleInst(TupleInst *tupleInst) {
@@ -635,15 +904,16 @@
   }
 
   void visitTupleExtractInst(TupleExtractInst *extractInst) {
-    // Tuple element instructions don't require rewrite. They are dead.
-    llvm_unreachable("Untested.");
-    return;
+    // TupleExtract merely names a storage location. It doesn't need to be
+    // rewritten.
+    assert(extractInst->use_empty()
+           || pass.valueStorageMap.getStorage(extractInst).storageAddress);
   }
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
-// AddressLowering: Top Level Function Transform.
+// AddressLowering: Top-Level Function Transform.
 //===----------------------------------------------------------------------===//
 
 namespace {
@@ -658,14 +928,14 @@
 } // end anonymous namespace
 
 void AddressLowering::runOnFunction(SILFunction *F) {
-  DEBUG(llvm::dbgs() << "LOWER "; F->dump());
-
   AddressLoweringState pass(F);
 
   // Rewrite function args and insert alloc_stack/dealloc_stack.
   OpaqueStorageAllocation allocator(pass);
   allocator.allocateOpaqueStorage();
 
+  DEBUG(llvm::dbgs() << "\nREWRITING: " << F->getName(); F->dump());
+
   // Rewrite instructions with address-only operands or results.
   AddressOnlyRewriter(pass).rewriteFunction();
 
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
index 794592e..3d8f05c 100644
--- a/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
+++ b/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
@@ -145,7 +145,7 @@
   // by apply instructions.
   bool needsReleases = false;
   CanSILFunctionType PAITy =
-      dyn_cast<SILFunctionType>(PAI->getCallee()->getType().getSwiftType());
+    PAI->getCallee()->getType().getAs<SILFunctionType>();
 
   // Emit a destroy value for each captured closure argument.
   ArrayRef<SILParameterInfo> Params = PAITy->getParameters();
@@ -228,7 +228,7 @@
       if (!TmpType.isAddressOnly(PAI->getModule())) {
         auto *Load = Builder.createLoad(PAI->getLoc(), Op,
                                         LoadOwnershipQualifier::Unqualified);
-        Builder.createReleaseValue(PAI->getLoc(), Load, Atomicity::Atomic);
+        Builder.createReleaseValue(PAI->getLoc(), Load, Builder.getDefaultAtomicity());
       } else {
         Builder.createDestroyAddr(PAI->getLoc(), Op);
       }
@@ -320,20 +320,20 @@
     for (auto Arg : ToBeReleasedArgs) {
       Builder.emitDestroyValueOperation(PAI->getLoc(), Arg);
     }
-    Builder.createStrongRelease(AI.getLoc(), PAI, Atomicity::Atomic);
+    Builder.createStrongRelease(AI.getLoc(), PAI, Builder.getDefaultAtomicity());
     Builder.setInsertionPoint(TAI->getErrorBB()->begin());
     // Release the non-consumed parameters.
     for (auto Arg : ToBeReleasedArgs) {
       Builder.emitDestroyValueOperation(PAI->getLoc(), Arg);
     }
-    Builder.createStrongRelease(AI.getLoc(), PAI, Atomicity::Atomic);
+    Builder.createStrongRelease(AI.getLoc(), PAI, Builder.getDefaultAtomicity());
     Builder.setInsertionPoint(AI.getInstruction());
   } else {
     // Release the non-consumed parameters.
     for (auto Arg : ToBeReleasedArgs) {
       Builder.emitDestroyValueOperation(PAI->getLoc(), Arg);
     }
-    Builder.createStrongRelease(AI.getLoc(), PAI, Atomicity::Atomic);
+    Builder.createStrongRelease(AI.getLoc(), PAI, Builder.getDefaultAtomicity());
   }
 
   SilCombiner->replaceInstUsesWith(*AI.getInstruction(), NAI.getInstruction());
@@ -519,7 +519,7 @@
           Builder.createDestroyAddr(FAS.getLoc(), Arg);
           break;
         case ParameterConvention::Direct_Owned:
-          Builder.createReleaseValue(FAS.getLoc(), Arg, Atomicity::Atomic);
+          Builder.createReleaseValue(FAS.getLoc(), Arg, Builder.getDefaultAtomicity());
           break;
         case ParameterConvention::Indirect_In_Guaranteed:
         case ParameterConvention::Indirect_Inout:
@@ -961,7 +961,7 @@
   // In we find arguments that are not the 'self' argument and if
   // they are of the Self type then we abort the optimization.
   for (auto Arg : AI.getArgumentsWithoutSelf()) {
-    if (Arg->getType().getSwiftType().getLValueOrInOutObjectType() ==
+    if (Arg->getType().getSwiftRValueType() ==
         AI.getArguments().back()->getType().getSwiftRValueType())
       return nullptr;
   }
@@ -1044,7 +1044,7 @@
 
   // Emit a retain for the @owned return.
   SILBuilderWithScope Builder(Call);
-  Builder.createRetainValue(Call->getLoc(), OnX, Atomicity::Atomic);
+  Builder.createRetainValue(Call->getLoc(), OnX, Builder.getDefaultAtomicity());
 
   // Emit a release for the @owned parameter, or none for a @guaranteed
   // parameter.
@@ -1056,7 +1056,7 @@
          ParamInfo == ParameterConvention::Direct_Guaranteed);
 
   if (ParamInfo == ParameterConvention::Direct_Owned)
-    Builder.createReleaseValue(Call->getLoc(), OnX, Atomicity::Atomic);
+    Builder.createReleaseValue(Call->getLoc(), OnX, Builder.getDefaultAtomicity());
 }
 
 /// Replace an application of a cast composition f_inverse(f(x)) by x.
@@ -1097,14 +1097,16 @@
     // X might not be strong_retain/release'able. Replace it by a
     // retain/release_value on X instead.
     if (isa<StrongRetainInst>(User)) {
-      SILBuilderWithScope(User).createRetainValue(User->getLoc(), X,
-                                                  Atomicity::Atomic);
+      SILBuilderWithScope Builder(User);
+      Builder.createRetainValue(User->getLoc(), X,
+                                cast<StrongRetainInst>(User)->getAtomicity());
       eraseInstFromFunction(*User);
       continue;
     }
     if (isa<StrongReleaseInst>(User)) {
-      SILBuilderWithScope(User).createReleaseValue(User->getLoc(), X,
-                                                   Atomicity::Atomic);
+      SILBuilderWithScope Builder(User);
+      Builder.createReleaseValue(User->getLoc(), X,
+                                 cast<StrongReleaseInst>(User)->getAtomicity());
       eraseInstFromFunction(*User);
       continue;
     }
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp
index c72cbb7..5949dfd 100644
--- a/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp
+++ b/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp
@@ -35,7 +35,7 @@
   if (auto *URCI = dyn_cast<UncheckedRefCastInst>(RRPI->getOperand())) {
     // (ref_to_raw_pointer (unchecked_ref_cast x))
     //    -> (ref_to_raw_pointer x)
-    if (URCI->getOperand()->getType().getSwiftType()
+    if (URCI->getOperand()->getType().getSwiftRValueType()
         ->isAnyClassReferenceType()) {
       RRPI->setOperand(URCI->getOperand());
       return URCI->use_empty() ? eraseInstFromFunction(*URCI) : nullptr;
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp
index bb59509..b8b7dfe 100644
--- a/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp
+++ b/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp
@@ -86,7 +86,7 @@
     // is going away so we need to release the stored value now.
     Builder.setInsertionPoint(SingleStore);
     Builder.createReleaseValue(AEBI->getLoc(), SingleStore->getSrc(),
-                               Atomicity::Atomic);
+                               SingleRelease->getAtomicity());
 
     // Erase the instruction that stores into the box and the release that
     // releases the box, and finally, release the box.
@@ -494,19 +494,19 @@
     // reduced to a retain_value on the payload.
     if (EI->hasOperand()) {
       return Builder.createReleaseValue(RVI->getLoc(), EI->getOperand(),
-                                        Atomicity::Atomic);
+                                        RVI->getAtomicity());
     }
   }
 
   // ReleaseValueInst of an unowned type is an unowned_release.
   if (OperandTy.is<UnownedStorageType>())
     return Builder.createUnownedRelease(RVI->getLoc(), Operand,
-                                        Atomicity::Atomic);
+                                        RVI->getAtomicity());
 
   // ReleaseValueInst of a reference type is a strong_release.
   if (OperandTy.isReferenceCounted(RVI->getModule()))
     return Builder.createStrongRelease(RVI->getLoc(), Operand,
-                                       Atomicity::Atomic);
+                                       RVI->getAtomicity());
 
   // ReleaseValueInst of a trivial type is a no-op.
   if (OperandTy.isTrivial(RVI->getModule()))
@@ -532,19 +532,19 @@
     // reduced to a retain_value on the payload.
     if (EI->hasOperand()) {
       return Builder.createRetainValue(RVI->getLoc(), EI->getOperand(),
-                                       Atomicity::Atomic);
+                                       RVI->getAtomicity());
     }
   }
 
   // RetainValueInst of an unowned type is an unowned_retain.
   if (OperandTy.is<UnownedStorageType>())
     return Builder.createUnownedRetain(RVI->getLoc(), Operand,
-                                       Atomicity::Atomic);
+                                       RVI->getAtomicity());
 
   // RetainValueInst of a reference type is a strong_release.
   if (OperandTy.isReferenceCounted(RVI->getModule())) {
     return Builder.createStrongRetain(RVI->getLoc(), Operand,
-                                      Atomicity::Atomic);
+                                      RVI->getAtomicity());
   }
 
   // RetainValueInst of a trivial type is a no-op + use propagation.
diff --git a/lib/SILOptimizer/Transforms/DeadObjectElimination.cpp b/lib/SILOptimizer/Transforms/DeadObjectElimination.cpp
index 572b588..92c338d 100644
--- a/lib/SILOptimizer/Transforms/DeadObjectElimination.cpp
+++ b/lib/SILOptimizer/Transforms/DeadObjectElimination.cpp
@@ -558,9 +558,9 @@
     // can simply ask SSAUpdater for the reaching store.
     SILValue RelVal = SSAUp.GetValueAtEndOfBlock(RelPoint->getParent());
     if (StVal->getType().isReferenceCounted(RelPoint->getModule()))
-      B.createStrongRelease(Loc, RelVal, Atomicity::Atomic);
+      B.createStrongRelease(Loc, RelVal, B.getDefaultAtomicity());
     else
-      B.createReleaseValue(Loc, RelVal, Atomicity::Atomic);
+      B.createReleaseValue(Loc, RelVal, B.getDefaultAtomicity());
   }
 }
 
diff --git a/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp b/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp
index 05586c1..ce6a1d1 100644
--- a/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp
+++ b/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp
@@ -760,19 +760,19 @@
     Builder.setInsertionPoint(&*std::next(SILBasicBlock::iterator(Call)));
     Builder.createReleaseValue(RegularLocation(SourceLoc()),
                                F->getArguments()[AD.Index],
-                               Atomicity::Atomic);
+                               Builder.getDefaultAtomicity());
   } else {
     SILBasicBlock *NormalBB = dyn_cast<TryApplyInst>(Call)->getNormalBB();
     Builder.setInsertionPoint(&*NormalBB->begin());
     Builder.createReleaseValue(RegularLocation(SourceLoc()),
                                F->getArguments()[AD.Index],
-                               Atomicity::Atomic);
+                               Builder.getDefaultAtomicity());
 
     SILBasicBlock *ErrorBB = dyn_cast<TryApplyInst>(Call)->getErrorBB();
     Builder.setInsertionPoint(&*ErrorBB->begin());
     Builder.createReleaseValue(RegularLocation(SourceLoc()),
                                F->getArguments()[AD.Index],
-                               Atomicity::Atomic);
+                               Builder.getDefaultAtomicity());
   }
 }
 
@@ -790,12 +790,12 @@
   if (isa<ApplyInst>(Call)) {
     Builder.setInsertionPoint(&*std::next(SILBasicBlock::iterator(Call)));
     Builder.createRetainValue(RegularLocation(SourceLoc()), Call,
-                              Atomicity::Atomic);
+                              Builder.getDefaultAtomicity());
   } else {
     SILBasicBlock *NormalBB = dyn_cast<TryApplyInst>(Call)->getNormalBB();
     Builder.setInsertionPoint(&*NormalBB->begin());
     Builder.createRetainValue(RegularLocation(SourceLoc()),
-                              NormalBB->getArgument(0), Atomicity::Atomic);
+                              NormalBB->getArgument(0), Builder.getDefaultAtomicity());
   }
 }
 
diff --git a/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp b/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp
index dbd8b80..0ec3d33 100644
--- a/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp
+++ b/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp
@@ -67,6 +67,7 @@
   bool visitUnmanagedRetainValueInst(UnmanagedRetainValueInst *URVI);
   bool visitUnmanagedReleaseValueInst(UnmanagedReleaseValueInst *URVI);
   bool visitUnmanagedAutoreleaseValueInst(UnmanagedAutoreleaseValueInst *UAVI);
+  bool visitCheckedCastBranchInst(CheckedCastBranchInst *CBI);
 };
 
 } // end anonymous namespace
@@ -144,7 +145,7 @@
 bool OwnershipModelEliminatorVisitor::visitCopyUnownedValueInst(
     CopyUnownedValueInst *CVI) {
   B.createStrongRetainUnowned(CVI->getLoc(), CVI->getOperand(),
-                              Atomicity::Atomic);
+                              B.getDefaultAtomicity());
   // Users of copy_value_unowned expect an owned value. So we need to convert
   // our unowned value to a ref.
   auto *UTRI =
@@ -178,7 +179,7 @@
   // Now that we have set the unqualified ownership flag, destroy value
   // operation will delegate to the appropriate strong_release, etc.
   B.createAutoreleaseValue(UAVI->getLoc(), UAVI->getOperand(),
-                           Atomicity::Atomic);
+                           UAVI->getAtomicity());
   UAVI->eraseFromParent();
   return true;
 }
@@ -195,6 +196,24 @@
   return true;
 }
 
+bool OwnershipModelEliminatorVisitor::visitCheckedCastBranchInst(
+    CheckedCastBranchInst *CBI) {
+  // In ownership qualified SIL, checked_cast_br must pass its argument to the
+  // fail case so we can clean it up. In non-ownership qualified SIL, we expect
+  // no argument from the checked_cast_br in the default case. The way that we
+  // handle this transformation is that:
+  //
+  // 1. We replace all uses of the argument to the false block with a use of the
+  // checked cast branch's operand.
+  // 2. We delete the argument from the false block.
+  SILBasicBlock *FailureBlock = CBI->getFailureBB();
+  if (FailureBlock->getNumArguments() == 0)
+    return false;
+  FailureBlock->getArgument(0)->replaceAllUsesWith(CBI->getOperand());
+  FailureBlock->eraseArgument(0);
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 //                           Top Level Entry Point
 //===----------------------------------------------------------------------===//
@@ -224,9 +243,8 @@
     }
 
     if (MadeChange) {
-      // If we made any changes, we just changed instructions, so invalidate
-      // that analysis.
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(
+          SILAnalysis::InvalidationKind::BranchesAndInstructions);
     }
   }
 
diff --git a/lib/SILOptimizer/Transforms/PerformanceInliner.cpp b/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
index ebd9d0c..fb14a28 100644
--- a/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
+++ b/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
@@ -547,6 +547,10 @@
       (ModuleName == STDLIB_NAME || ModuleName == SWIFT_ONONE_SUPPORT))
     return false;
 
+  // Do not inline into thunks.
+  if (AI.getFunction()->isThunk())
+    return false;
+
   // Always inline generic functions which are marked as
   // AlwaysInline or transparent.
   if (Callee->getInlineStrategy() == AlwaysInline || Callee->isTransparent())
diff --git a/lib/SILOptimizer/Transforms/ReleaseDevirtualizer.cpp b/lib/SILOptimizer/Transforms/ReleaseDevirtualizer.cpp
index ece72e4..797002c 100644
--- a/lib/SILOptimizer/Transforms/ReleaseDevirtualizer.cpp
+++ b/lib/SILOptimizer/Transforms/ReleaseDevirtualizer.cpp
@@ -161,7 +161,8 @@
 
   // Do what a release would do before calling the deallocator: set the object
   // in deallocating state, which means set the RC_DEALLOCATING_FLAG flag.
-  B.createSetDeallocating(ReleaseInst->getLoc(), object, Atomicity::Atomic);
+  B.createSetDeallocating(ReleaseInst->getLoc(), object,
+                          cast<RefCountingInst>(ReleaseInst)->getAtomicity());
 
   // Create the call to the destructor with the allocated object as self
   // argument.
diff --git a/lib/SILOptimizer/Transforms/SILCodeMotion.cpp b/lib/SILOptimizer/Transforms/SILCodeMotion.cpp
index d1c8b95..41f663d 100644
--- a/lib/SILOptimizer/Transforms/SILCodeMotion.cpp
+++ b/lib/SILOptimizer/Transforms/SILCodeMotion.cpp
@@ -73,17 +73,19 @@
 
   ++NumRefCountOpsSimplified;
 
+  auto *RCI = cast<RefCountingInst>(I);
+
   // If we have a retain value...
   if (isa<RetainValueInst>(I)) {
     // And our payload is refcounted, insert a strong_retain onto the
     // payload.
     if (UEDITy.isReferenceCounted(Mod)) {
-      Builder.createStrongRetain(I->getLoc(), UEDI, Atomicity::Atomic);
+      Builder.createStrongRetain(I->getLoc(), UEDI, RCI->getAtomicity());
       return;
     }
 
     // Otherwise, insert a retain_value on the payload.
-    Builder.createRetainValue(I->getLoc(), UEDI, Atomicity::Atomic);
+    Builder.createRetainValue(I->getLoc(), UEDI, RCI->getAtomicity());
     return;
   }
 
@@ -94,13 +96,13 @@
 
   // If our payload has reference semantics, insert the strong release.
   if (UEDITy.isReferenceCounted(Mod)) {
-    Builder.createStrongRelease(I->getLoc(), UEDI, Atomicity::Atomic);
+    Builder.createStrongRelease(I->getLoc(), UEDI, RCI->getAtomicity());
     return;
   }
 
   // Otherwise if our payload is non-trivial but lacking reference semantics,
   // insert the release_value.
-  Builder.createReleaseValue(I->getLoc(), UEDI, Atomicity::Atomic);
+  Builder.createReleaseValue(I->getLoc(), UEDI, RCI->getAtomicity());
 }
 
 //===----------------------------------------------------------------------===//
@@ -1545,9 +1547,9 @@
     //
     // TODO: Which debug loc should we use here? Using one of the locs from the
     // delete list seems reasonable for now...
-    SILBuilder(getBB()->begin()).createRetainValue(DeleteList[0]->getLoc(),
-                                                   EnumValue,
-                                                   Atomicity::Atomic);
+    SILBuilder Builder(getBB()->begin());
+    Builder.createRetainValue(DeleteList[0]->getLoc(), EnumValue,
+                              cast<RefCountingInst>(DeleteList[0])->getAtomicity());
     for (auto *I : DeleteList)
       I->eraseFromParent();
     ++NumSunk;
diff --git a/lib/SILOptimizer/Transforms/SimplifyCFG.cpp b/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
index 57e7554..28d247e 100644
--- a/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
+++ b/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
@@ -1875,23 +1875,6 @@
   if (!TargetFnTy || !TargetFnTy->hasErrorResult())
     return false;
 
-  // Check if the converted function type has the same number of arguments.
-  // Currently this is always the case, but who knows what convert_function can
-  // do in the future?
-  unsigned numParams = OrigFnTy->getParameters().size();
-  if (TargetFnTy->getParameters().size() != numParams)
-    return false;
-
-  // Check that the argument types are matching.
-  SILModuleConventions silConv(TAI->getModule());
-  for (unsigned Idx = 0; Idx < numParams; Idx++) {
-    if (!canCastValueToABICompatibleType(
-            TAI->getModule(),
-            silConv.getSILType(OrigFnTy->getParameters()[Idx]),
-            silConv.getSILType(TargetFnTy->getParameters()[Idx])))
-      return false;
-  }
-
   // Look through the conversions and find the real callee.
   Callee = getActualCallee(CFI->getConverted());
   CalleeType = Callee->getType();
@@ -1936,12 +1919,6 @@
     auto ResultTy = calleeConv.getSILResultType();
     auto OrigResultTy = TAI->getNormalBB()->getArgument(0)->getType();
 
-    // Bail if the cast between the actual and expected return types cannot
-    // be handled.
-    if (!canCastValueToABICompatibleType(TAI->getModule(),
-                                         ResultTy, OrigResultTy))
-      return false;
-
     SILBuilderWithScope Builder(TAI);
 
     auto TargetFnTy = CalleeFnTy;
@@ -1959,28 +1936,14 @@
     }
     SILFunctionConventions origConv(OrigFnTy, TAI->getModule());
 
-    unsigned numArgs = TAI->getNumArguments();
-
-    // First check if it is possible to convert all arguments.
-    // Currently we believe that castValueToABICompatibleType can handle all
-    // cases, so this check should never fail. We just do it to be absolutely
-    // sure that we don't crash.
-    for (unsigned i = 0; i < numArgs; ++i) {
-      if (!canCastValueToABICompatibleType(TAI->getModule(),
-                                           origConv.getSILArgumentType(i),
-                                           targetConv.getSILArgumentType(i))) {
-        return false;
-      }
-    }
-
     SmallVector<SILValue, 8> Args;
+    unsigned numArgs = TAI->getNumArguments();
     for (unsigned i = 0; i < numArgs; ++i) {
       auto Arg = TAI->getArgument(i);
       // Cast argument if required.
       Arg = castValueToABICompatibleType(&Builder, TAI->getLoc(), Arg,
                                          origConv.getSILArgumentType(i),
-                                         targetConv.getSILArgumentType(i))
-                .getValue();
+                                         targetConv.getSILArgumentType(i));
       Args.push_back(Arg);
     }
 
@@ -1998,8 +1961,7 @@
     auto *NormalBB = TAI->getNormalBB();
 
     auto CastedResult = castValueToABICompatibleType(&Builder, Loc, NewAI,
-                                                     ResultTy, OrigResultTy)
-                                                    .getValue();
+                                                     ResultTy, OrigResultTy);
 
     Builder.createBranch(Loc, NormalBB, { CastedResult });
     TAI->eraseFromParent();
diff --git a/lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp b/lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp
index 604969f..cf0eea1 100644
--- a/lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp
+++ b/lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp
@@ -143,9 +143,9 @@
       (next == Continue->end()) ? nullptr : dyn_cast<StrongReleaseInst>(next);
   if (Release && Release->getOperand() == CMI->getOperand()) {
     VirtBuilder.createStrongRelease(Release->getLoc(), CMI->getOperand(),
-                                    Atomicity::Atomic);
+                                    Release->getAtomicity());
     IdenBuilder.createStrongRelease(Release->getLoc(), DownCastedClassInstance,
-                                    Atomicity::Atomic);
+                                    Release->getAtomicity());
     Release->eraseFromParent();
   }
 
diff --git a/lib/SILOptimizer/Utils/Devirtualize.cpp b/lib/SILOptimizer/Utils/Devirtualize.cpp
index 4fa1094..318d777 100644
--- a/lib/SILOptimizer/Utils/Devirtualize.cpp
+++ b/lib/SILOptimizer/Utils/Devirtualize.cpp
@@ -546,31 +546,6 @@
     return false;
   }
 
-  // Type of the actual function to be called.
-  CanSILFunctionType GenCalleeType = F->getLoweredFunctionType();
-
-  // Type of the actual function to be called with substitutions applied.
-  CanSILFunctionType SubstCalleeType = GenCalleeType;
-
-  // For polymorphic functions, bail if the number of substitutions is
-  // not the same as the number of expected generic parameters.
-  if (GenCalleeType->isPolymorphic()) {
-    // First, find proper list of substitutions for the concrete
-    // method to be called.
-    SmallVector<Substitution, 4> Subs;
-    getSubstitutionsForCallee(Mod, GenCalleeType,
-                              ClassOrMetatypeType.getSwiftRValueType(),
-                              AI, Subs);
-    SubstCalleeType = GenCalleeType->substGenericArgs(Mod, Subs);
-  }
-
-  // Check if the optimizer knows how to cast the return type.
-  SILType ReturnType =
-      SILFunctionConventions(SubstCalleeType, Mod).getSILResultType();
-
-  if (!canCastValueToABICompatibleType(Mod, ReturnType, AI.getType()))
-      return false;
-
   return true;
 }
 
@@ -612,8 +587,7 @@
   for (auto ResultTy : substConv.getIndirectSILResultTypes()) {
     NewArgs.push_back(
         castValueToABICompatibleType(&B, AI.getLoc(), *IndirectResultArgIter,
-                                     IndirectResultArgIter->getType(), ResultTy)
-            .getValue());
+                                     IndirectResultArgIter->getType(), ResultTy));
     ++IndirectResultArgIter;
   }
 
@@ -623,8 +597,7 @@
     auto paramType = substConv.getSILType(param);
     NewArgs.push_back(
         castValueToABICompatibleType(&B, AI.getLoc(), *ParamArgIter,
-                                     ParamArgIter->getType(), paramType)
-            .getValue());
+                                     ParamArgIter->getType(), paramType));
     ++ParamArgIter;
   }
 
@@ -634,7 +607,7 @@
   NewArgs.push_back(castValueToABICompatibleType(&B, AI.getLoc(),
                                                  ClassOrMetatype,
                                                  ClassOrMetatypeType,
-                                                 SelfParamTy).getValue());
+                                                 SelfParamTy));
 
   SILType ResultTy = substConv.getSILResultType();
 
@@ -707,7 +680,7 @@
 
   // Check if any casting is required for the return value.
   ResultValue = castValueToABICompatibleType(&B, NewAI.getLoc(), ResultValue,
-                                             ResultTy, AI.getType()).getValue();
+                                             ResultTy, AI.getType());
 
   DEBUG(llvm::dbgs() << "        SUCCESS: " << F->getName() << "\n");
   NumClassDevirt++;
@@ -871,75 +844,6 @@
                                 origSubs, isDefaultWitness, NewSubs);
 }
 
-/// Check if an upcast is legal.
-/// The logic in this function is heavily based on the checks in
-/// the SILVerifier.
-bool swift::isLegalUpcast(SILType FromTy, SILType ToTy) {
-  if (ToTy.is<MetatypeType>()) {
-    CanType InstTy(ToTy.castTo<MetatypeType>()->getInstanceType());
-    if (!FromTy.is<MetatypeType>())
-      return false;
-    CanType OpInstTy(FromTy.castTo<MetatypeType>()->getInstanceType());
-    auto InstClass = InstTy->getClassOrBoundGenericClass();
-    if (!InstClass)
-      return false;
-
-    bool CanBeUpcasted =
-        InstClass->usesObjCGenericsModel()
-            ? InstClass->getDeclaredTypeInContext()->isBindableToSuperclassOf(
-                  OpInstTy, nullptr)
-            : InstTy->isExactSuperclassOf(OpInstTy, nullptr);
-
-    return CanBeUpcasted;
-  }
-
-  // Upcast from Optional<B> to Optional<A> is legal as long as B is a
-  // subclass of A.
-  if (ToTy.getSwiftRValueType().getAnyOptionalObjectType() &&
-      FromTy.getSwiftRValueType().getAnyOptionalObjectType()) {
-    ToTy = SILType::getPrimitiveObjectType(
-        ToTy.getSwiftRValueType().getAnyOptionalObjectType());
-    FromTy = SILType::getPrimitiveObjectType(
-        FromTy.getSwiftRValueType().getAnyOptionalObjectType());
-  }
-
-  auto ToClass = ToTy.getClassOrBoundGenericClass();
-  if (!ToClass)
-    return false;
-  bool CanBeUpcasted =
-      ToClass->usesObjCGenericsModel()
-          ? ToClass->getDeclaredTypeInContext()->isBindableToSuperclassOf(
-                FromTy.getSwiftRValueType(), nullptr)
-          : ToTy.isExactSuperclassOf(FromTy);
-
-  return CanBeUpcasted;
-}
-
-/// Check if we can pass/convert all arguments of the original apply
-/// as required by the found devirtualized method.
-/// FIXME: This method was introduced as a workaround. We need to
-/// revisit it and check if it is still needed.
-static bool
-canPassOrConvertAllArguments(ApplySite AI,
-                             CanSILFunctionType SubstCalleeCanType) {
-  SILFunctionConventions substConv(SubstCalleeCanType, AI.getModule());
-  unsigned substArgIdx = AI.getCalleeArgIndexOfFirstAppliedArg();
-  for (auto arg : AI.getArguments()) {
-    // Check if we can cast the provided argument into the required
-    // parameter type.
-    auto FromTy = arg->getType();
-    auto ToTy = substConv.getSILArgumentType(substArgIdx++);
-    // If types are the same, no conversion will be required.
-    if (FromTy == ToTy)
-      continue;
-    // Otherwise, it should be possible to upcast the arguments.
-    if (!isLegalUpcast(FromTy, ToTy))
-      return false;
-  }
-  assert(substArgIdx == substConv.getNumSILArguments());
-  return true;
-}
-
 /// Generate a new apply of a function_ref to replace an apply of a
 /// witness_method when we've determined the actual function we'll end
 /// up calling.
@@ -963,11 +867,6 @@
   auto CalleeCanType = F->getLoweredFunctionType();
   auto SubstCalleeCanType = CalleeCanType->substGenericArgs(Module, NewSubs);
 
-  // Bail if some of the arguments cannot be converted into
-  // types required by the found devirtualized method.
-  if (!canPassOrConvertAllArguments(AI, SubstCalleeCanType))
-    return ApplySite();
-
   // Collect arguments from the apply instruction.
   auto Arguments = SmallVector<SILValue, 4>();
 
@@ -979,7 +878,8 @@
   for (auto arg : AI.getArguments()) {
     auto paramType = substConv.getSILArgumentType(substArgIdx++);
     if (arg->getType() != paramType)
-      arg = B.createUpcast(AI.getLoc(), arg, paramType);
+      arg = castValueToABICompatibleType(&B, AI.getLoc(), arg,
+                                         arg->getType(), paramType);
     Arguments.push_back(arg);
   }
   assert(substArgIdx == substConv.getNumSILArguments());
@@ -1030,26 +930,6 @@
       return false;
   }
 
-  // Collect all the required substitutions.
-  //
-  // The complete set of substitutions may be different, e.g. because the found
-  // witness thunk F may have been created by a specialization pass and have
-  // additional generic parameters.
-  SmallVector<Substitution, 4> NewSubs;
-
-  getWitnessMethodSubstitutions(AI, F, WMI->getConformance(), NewSubs);
-
-  // Figure out the exact bound type of the function to be called by
-  // applying all substitutions.
-  auto &Module = AI.getModule();
-  auto CalleeCanType = F->getLoweredFunctionType();
-  auto SubstCalleeCanType = CalleeCanType->substGenericArgs(Module, NewSubs);
-
-  // Bail if some of the arguments cannot be converted into
-  // types required by the found devirtualized method.
-  if (!canPassOrConvertAllArguments(AI, SubstCalleeCanType))
-    return false;
-
   return true;
 }
 
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
index 7100496..2adfd48 100644
--- a/lib/SILOptimizer/Utils/Generics.cpp
+++ b/lib/SILOptimizer/Utils/Generics.cpp
@@ -52,7 +52,8 @@
 // Initialize SpecializedType iff the specialization is allowed.
 ReabstractionInfo::ReabstractionInfo(ApplySite Apply, SILFunction *OrigF,
                                      SubstitutionList ParamSubs) {
-  if (!OrigF->shouldOptimize()) {
+  if (!OrigF->shouldOptimize() ||
+      OrigF->hasSemanticsAttr("optimize.sil.specialize.generic.never")) {
     DEBUG(llvm::dbgs() << "    Cannot specialize function " << OrigF->getName()
                        << " marked to be excluded from optimizations.\n");
     return;
@@ -97,9 +98,8 @@
   }
 
   SILModule &M = OrigF->getModule();
-  SubstitutedType = SILType::substFuncType(M, InterfaceSubs,
-                                           OrigF->getLoweredFunctionType(),
-                                           /*dropGenerics = */ true);
+  SubstitutedType = OrigF->getLoweredFunctionType()->substGenericArgs(
+    M, InterfaceSubs);
 
   NumFormalIndirectResults = SubstitutedType->getNumIndirectFormalResults();
   Conversions.resize(NumFormalIndirectResults
@@ -213,9 +213,7 @@
   auto OrigFnTy = OrigF->getLoweredFunctionType();
 
   // First substitute concrete types into the existing function type.
-  auto FnTy = OrigFnTy->substGenericArgs(
-      M, QuerySubstitutionMap{SubstMap},
-        LookUpConformanceInSubstitutionMap(SubstMap));
+  auto FnTy = OrigFnTy->substGenericArgs(M, SubstMap);
 
   if ((SpecializedGenericSig &&
        SpecializedGenericSig->areAllParamsConcrete()) ||
@@ -294,7 +292,8 @@
   // First, add the old generic signature.
   Builder.addGenericSignature(OrigGenSig);
 
-  auto Source = RequirementSource::forAbstract(Builder);
+  auto Source =
+    GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
   // For each substitution with a concrete type as a replacement,
   // add a new concrete type equality requirement.
   for (auto &Req : Requirements) {
diff --git a/lib/SILOptimizer/Utils/Local.cpp b/lib/SILOptimizer/Utils/Local.cpp
index 8fe8ec5..750ea7f 100644
--- a/lib/SILOptimizer/Utils/Local.cpp
+++ b/lib/SILOptimizer/Utils/Local.cpp
@@ -44,10 +44,10 @@
   // If Ptr is refcounted itself, create the strong_retain and
   // return.
   if (Ptr->getType().isReferenceCounted(B.getModule()))
-    return B.createStrongRetain(Loc, Ptr, Atomicity::Atomic);
+    return B.createStrongRetain(Loc, Ptr, B.getDefaultAtomicity());
 
   // Otherwise, create the retain_value.
-  return B.createRetainValue(Loc, Ptr, Atomicity::Atomic);
+  return B.createRetainValue(Loc, Ptr, B.getDefaultAtomicity());
 }
 
 /// Creates a decrement on \p Ptr before insertion point \p InsertPt that
@@ -61,10 +61,10 @@
 
   // If Ptr has reference semantics itself, create a strong_release.
   if (Ptr->getType().isReferenceCounted(B.getModule()))
-    return B.createStrongRelease(Loc, Ptr, Atomicity::Atomic);
+    return B.createStrongRelease(Loc, Ptr, B.getDefaultAtomicity());
 
   // Otherwise create a release value.
-  return B.createReleaseValue(Loc, Ptr, Atomicity::Atomic);
+  return B.createReleaseValue(Loc, Ptr, B.getDefaultAtomicity());
 }
 
 /// \brief Perform a fast local check to see if the instruction is dead.
@@ -475,80 +475,63 @@
 ///
 /// NOTE: The implementation of this function is very closely related to the
 /// rules checked by SILVerifier::requireABICompatibleFunctionTypes.
-Optional<SILValue> swift::castValueToABICompatibleType(SILBuilder *B, SILLocation Loc,
+SILValue swift::castValueToABICompatibleType(SILBuilder *B, SILLocation Loc,
                                              SILValue Value,
-                                             SILType SrcTy, SILType DestTy,
-                                             bool CheckOnly) {
+                                             SILType SrcTy, SILType DestTy) {
 
   // No cast is required if types are the same.
   if (SrcTy == DestTy)
     return Value;
 
-  SILValue CastedValue;
+  assert(SrcTy.isAddress() == DestTy.isAddress() &&
+         "Addresses aren't compatible with values");
 
   if (SrcTy.isAddress() && DestTy.isAddress()) {
     // Cast between two addresses and that's it.
-    if (CheckOnly)
-      return Value;
-    CastedValue = B->createUncheckedAddrCast(Loc, Value, DestTy);
-    return CastedValue;
+    return B->createUncheckedAddrCast(Loc, Value, DestTy);
   }
 
-  if (SrcTy.isAddress() != DestTy.isAddress()) {
-    // Addresses aren't compatible with values.
-    if (CheckOnly)
-      return None;
-    llvm_unreachable("Addresses aren't compatible with values");
-    return SILValue();
-  }
-
-  auto &M = B->getModule();
-
-  // Check if src and dest types are optional.
-  auto OptionalSrcTy = SrcTy.getSwiftRValueType()
-                            .getAnyOptionalObjectType();
-  auto OptionalDestTy = DestTy.getSwiftRValueType()
-                              .getAnyOptionalObjectType();
-
   // If both types are classes and dest is the superclass of src,
   // simply perform an upcast.
-  if (SrcTy.getSwiftRValueType()->mayHaveSuperclass() &&
-      DestTy.getSwiftRValueType()->mayHaveSuperclass() &&
-      DestTy.isExactSuperclassOf(SrcTy)) {
-    if (CheckOnly)
-      return Value;
-    CastedValue = B->createUpcast(Loc, Value, DestTy);
-    return CastedValue;
+  if (DestTy.isExactSuperclassOf(SrcTy)) {
+    return B->createUpcast(Loc, Value, DestTy);
   }
 
-  SILType OptionalSrcLoweredTy;
-  SILType OptionalDestLoweredTy;
+  if (SrcTy.isHeapObjectReferenceType() &&
+      DestTy.isHeapObjectReferenceType()) {
+    return B->createUncheckedRefCast(Loc, Value, DestTy);
+  }
 
-  if (OptionalSrcTy)
-    OptionalSrcLoweredTy = M.Types.getLoweredType(OptionalSrcTy);
+  if (auto mt1 = dyn_cast<AnyMetatypeType>(SrcTy.getSwiftRValueType())) {
+    if (auto mt2 = dyn_cast<AnyMetatypeType>(DestTy.getSwiftRValueType())) {
+      if (mt1->getRepresentation() == mt2->getRepresentation()) {
+        // If B.Type needs to be casted to A.Type and
+        // A is a superclass of B, then it can be done by means
+        // of a simple upcast.
+        if (mt2.getInstanceType()->isExactSuperclassOf(
+              mt1.getInstanceType(), nullptr)) {
+          return B->createUpcast(Loc, Value, DestTy);
+        }
+ 
+        // Cast between two metatypes and that's it.
+        return B->createUncheckedBitCast(Loc, Value, DestTy);
+      }
+    }
+  }
 
-  if (OptionalDestTy)
-    OptionalDestLoweredTy = M.Types.getLoweredType(OptionalDestTy);
+  // Check if src and dest types are optional.
+  auto OptionalSrcTy = SrcTy.getAnyOptionalObjectType();
+  auto OptionalDestTy = DestTy.getAnyOptionalObjectType();
 
   // Both types are optional.
   if (OptionalDestTy && OptionalSrcTy) {
     // If both wrapped types are classes and dest is the superclass of src,
     // simply perform an upcast.
-    if (OptionalDestTy->mayHaveSuperclass() &&
-        OptionalSrcTy->mayHaveSuperclass() &&
-        OptionalDestLoweredTy.isExactSuperclassOf(OptionalSrcLoweredTy)) {
+    if (OptionalDestTy.isExactSuperclassOf(OptionalSrcTy)) {
       // Insert upcast.
-      if (CheckOnly)
-        return Value;
-      CastedValue = B->createUpcast(Loc, Value, DestTy);
-      return CastedValue;
+      return B->createUpcast(Loc, Value, DestTy);
     }
 
-    if (CheckOnly)
-      return castValueToABICompatibleType(B, Loc, Value,
-          OptionalSrcLoweredTy,
-          OptionalDestLoweredTy, CheckOnly);
-
     // Unwrap the original optional value.
     auto *SomeDecl = B->getASTContext().getOptionalSomeDecl();
     auto *NoneBB = B->getFunction().createBasicBlock();
@@ -570,10 +553,10 @@
     // Cast the unwrapped value.
     auto CastedUnwrappedValue =
         castValueToABICompatibleType(B, Loc, UnwrappedValue,
-                                     OptionalSrcLoweredTy,
-                                     OptionalDestLoweredTy).getValue();
+                                     OptionalSrcTy,
+                                     OptionalDestTy);
     // Wrap into optional.
-    CastedValue =  B->createOptionalSome(Loc, CastedUnwrappedValue, DestTy);
+    auto CastedValue =  B->createOptionalSome(Loc, CastedUnwrappedValue, DestTy);
     B->createBranch(Loc, ContBB, {CastedValue});
 
     // Handle the None case.
@@ -582,19 +565,15 @@
     B->createBranch(Loc, ContBB, {CastedValue});
     B->setInsertionPoint(ContBB->begin());
 
-    CastedValue = ContBB->getArgument(0);
-    return CastedValue;
+    return ContBB->getArgument(0);
   }
 
   // Src is not optional, but dest is optional.
   if (!OptionalSrcTy && OptionalDestTy) {
-    auto OptionalSrcCanTy =
-      OptionalType::get(SrcTy.getSwiftRValueType())->getCanonicalType();
-    auto LoweredOptionalSrcType = M.Types.getLoweredType(OptionalSrcCanTy);
-    if (CheckOnly)
-      return castValueToABICompatibleType(B, Loc, Value,
-                                          LoweredOptionalSrcType, DestTy,
-                                          CheckOnly);
+    auto OptionalSrcCanTy = OptionalType::get(SrcTy.getSwiftRValueType())
+      ->getCanonicalType();
+    auto LoweredOptionalSrcType = SILType::getPrimitiveObjectType(
+      OptionalSrcCanTy);
 
     // Wrap the source value into an optional first.
     SILValue WrappedValue = B->createOptionalSome(Loc, Value,
@@ -605,127 +584,33 @@
                                         DestTy);
   }
 
-  // Both types are not optional.
-  if (SrcTy.getSwiftRValueType()->mayHaveSuperclass() &&
-      DestTy.getSwiftRValueType()->mayHaveSuperclass()) {
-    if (CheckOnly)
-      return Value;
-
-    if (DestTy.isExactSuperclassOf(SrcTy)) {
-      // Insert upcast.
-      CastedValue = B->createUpcast(Loc, Value, DestTy);
-      return CastedValue;
-    }
-
-    // Cast the reference.
-    CastedValue = B->createUncheckedBitCast(Loc, Value, DestTy);
-    return CastedValue;
-  }
-
-  // If B.Type needs to be casted to A.Type and
-  // A is a superclass of B, then it can be done by means
-  // of a simple upcast.
-  if (isa<AnyMetatypeType>(SrcTy.getSwiftRValueType()) &&
-      isa<AnyMetatypeType>(DestTy.getSwiftRValueType()) &&
-      SrcTy.isClassOrClassMetatype() && DestTy.isClassOrClassMetatype() &&
-      DestTy.getMetatypeInstanceType(M).isExactSuperclassOf(
-          SrcTy.getMetatypeInstanceType(M))) {
-    if (CheckOnly)
-      return Value;
-    CastedValue = B->createUpcast(Loc, Value, DestTy);
-    return CastedValue;
-  }
-
-  if (auto mt1 = dyn_cast<AnyMetatypeType>(SrcTy.getSwiftRValueType())) {
-    if (auto mt2 = dyn_cast<AnyMetatypeType>(DestTy.getSwiftRValueType())) {
-      if (mt1->getRepresentation() == mt2->getRepresentation()) {
-        // Cast between two metatypes and that's it.
-        if (CheckOnly)
-          return Value;
-        CastedValue = B->createUncheckedBitCast(Loc, Value, DestTy);
-        return CastedValue;
-      }
-    }
-  }
-
-  if (SrcTy.isAddress() && DestTy.isAddress()) {
-    if (CheckOnly)
-      return Value;
-    CastedValue = B->createUncheckedAddrCast(Loc, Value, DestTy);
-    return CastedValue;
-  }
-
-  if (SrcTy.isHeapObjectReferenceType() && DestTy.isHeapObjectReferenceType()) {
-    if (CheckOnly)
-      return Value;
-    CastedValue = B->createUncheckedRefCast(Loc, Value, DestTy);
-    return CastedValue;
-  }
-
   // Handle tuple types.
   // Extract elements, cast each of them, create a new tuple.
-  if (auto tup = SrcTy.getAs<TupleType>()) {
-    SmallVector<CanType, 1> aElements, bElements;
-    auto atypes = tup.getElementTypes();
-    aElements.append(atypes.begin(), atypes.end());
-    auto btypes = DestTy.getAs<TupleType>().getElementTypes();
-    bElements.append(btypes.begin(), btypes.end());
-
-    if (CheckOnly && aElements.size() != bElements.size())
-      return None;
-
-    assert (aElements.size() == bElements.size() &&
-          "Tuple types should have the same number of elements");
-
+  if (auto SrcTupleTy = SrcTy.getAs<TupleType>()) {
     SmallVector<SILValue, 8> ExpectedTuple;
-    for (unsigned i : indices(aElements)) {
-      auto aa = M.Types.getLoweredType(aElements[i]),
-           bb = M.Types.getLoweredType(bElements[i]);
-
-      if (CheckOnly) {
-        if (!castValueToABICompatibleType(B, Loc, Value, aa, bb, CheckOnly).hasValue())
-          return None;
-        continue;
-      }
-
+    for (unsigned i = 0, e = SrcTupleTy->getNumElements(); i < e; i++) {
       SILValue Element = B->createTupleExtract(Loc, Value, i);
       // Cast the value if necessary.
-      Element = castValueToABICompatibleType(B, Loc, Element, aa, bb).getValue();
+      Element = castValueToABICompatibleType(B, Loc, Element,
+                                             SrcTy.getTupleElementType(i),
+                                             DestTy.getTupleElementType(i));
       ExpectedTuple.push_back(Element);
     }
 
-    if (CheckOnly)
-      return Value;
-
-    CastedValue = B->createTuple(Loc, DestTy, ExpectedTuple);
-    return CastedValue;
+    return B->createTuple(Loc, DestTy, ExpectedTuple);
   }
 
   // Function types are interchangeable if they're also ABI-compatible.
   if (SrcTy.getAs<SILFunctionType>()) {
     if (DestTy.getAs<SILFunctionType>()) {
-      if (CheckOnly)
-        return Value;
       // Insert convert_function.
-      CastedValue = B->createConvertFunction(Loc, Value, DestTy);
-      return CastedValue;
+      return B->createConvertFunction(Loc, Value, DestTy);
     }
   }
 
-  if (CheckOnly)
-    return None;
+  llvm::errs() << "Source type: " << SrcTy << "\n";
+  llvm::errs() << "Destination type: " << DestTy << "\n";
   llvm_unreachable("Unknown combination of types for casting");
-  return SILValue();
-}
-
-bool swift::canCastValueToABICompatibleType(SILModule &M,
-                                            SILType SrcTy, SILType DestTy) {
-  SILBuilder B(*M.begin());
-  SILLocation Loc = ArtificialUnreachableLocation();
-  auto Result = castValueToABICompatibleType(&B, Loc, SILValue(),
-                                             SrcTy, DestTy,
-                                             /* CheckOnly */ true);
-  return Result.hasValue();
 }
 
 ProjectBoxInst *swift::getOrCreateProjectBox(AllocBoxInst *ABI, unsigned Index){
@@ -1070,7 +955,7 @@
   SILBuilderWithScope Builder(PAI);
   SILLocation Loc = PAI->getLoc();
   CanSILFunctionType PAITy =
-      dyn_cast<SILFunctionType>(PAI->getCallee()->getType().getSwiftType());
+      PAI->getCallee()->getType().getAs<SILFunctionType>();
 
   // Emit a destroy value for each captured closure argument.
   ArrayRef<SILParameterInfo> Params = PAITy->getParameters();
@@ -1502,7 +1387,7 @@
          "Parameter should be @owned");
 
   // Emit a retain.
-  Builder.createRetainValue(Loc, SrcOp, Atomicity::Atomic);
+  Builder.createRetainValue(Loc, SrcOp, Builder.getDefaultAtomicity());
 
   Args.push_back(InOutOptionalParam);
   Args.push_back(SrcOp);
@@ -1515,18 +1400,18 @@
   if (auto *UCCAI = dyn_cast<UnconditionalCheckedCastAddrInst>(Inst)) {
     assert(UCCAI->getConsumptionKind() == CastConsumptionKind::TakeAlways);
     if (UCCAI->getConsumptionKind() == CastConsumptionKind::TakeAlways) {
-      Builder.createReleaseValue(Loc, SrcOp, Atomicity::Atomic);
+      Builder.createReleaseValue(Loc, SrcOp, Builder.getDefaultAtomicity());
     }
   }
 
   if (auto *CCABI = dyn_cast<CheckedCastAddrBranchInst>(Inst)) {
     if (CCABI->getConsumptionKind() == CastConsumptionKind::TakeAlways) {
-      Builder.createReleaseValue(Loc, SrcOp, Atomicity::Atomic);
+      Builder.createReleaseValue(Loc, SrcOp, Builder.getDefaultAtomicity());
     } else if (CCABI->getConsumptionKind() ==
                CastConsumptionKind::TakeOnSuccess) {
       // Insert a release in the success BB.
       Builder.setInsertionPoint(SuccessBB->begin());
-      Builder.createReleaseValue(Loc, SrcOp, Atomicity::Atomic);
+      Builder.createReleaseValue(Loc, SrcOp, Builder.getDefaultAtomicity());
     }
   }
 
@@ -1748,17 +1633,17 @@
   }
 
   if (needRetainBeforeCall)
-    Builder.createRetainValue(Loc, Src, Atomicity::Atomic);
+    Builder.createRetainValue(Loc, Src, Builder.getDefaultAtomicity());
 
   // Generate a code to invoke the bridging function.
   auto *NewAI = Builder.createApply(Loc, FnRef, SubstFnTy, ResultTy, Subs, Src,
                                     false);
 
   if (needReleaseAfterCall) {
-    Builder.createReleaseValue(Loc, Src, Atomicity::Atomic);
+    Builder.createReleaseValue(Loc, Src, Builder.getDefaultAtomicity());
   } else if (needReleaseInSucc) {
     SILBuilder SuccBuilder(SuccessBB->begin());
-    SuccBuilder.createReleaseValue(Loc, Src, Atomicity::Atomic);
+    SuccBuilder.createReleaseValue(Loc, Src, SuccBuilder.getDefaultAtomicity());
   }
   SILInstruction *NewI = NewAI;
 
diff --git a/lib/SILOptimizer/Utils/SILInliner.cpp b/lib/SILOptimizer/Utils/SILInliner.cpp
index 4cea2bd..a01756c 100644
--- a/lib/SILOptimizer/Utils/SILInliner.cpp
+++ b/lib/SILOptimizer/Utils/SILInliner.cpp
@@ -337,6 +337,7 @@
     case ValueKind::DeallocStackInst:
     case ValueKind::DeallocValueBufferInst:
     case ValueKind::DeinitExistentialAddrInst:
+    case ValueKind::DeinitExistentialOpaqueInst:
     case ValueKind::DestroyAddrInst:
     case ValueKind::ProjectValueBufferInst:
     case ValueKind::ProjectBoxInst:
diff --git a/lib/Sema/CMakeLists.txt b/lib/Sema/CMakeLists.txt
index 401e1f9..7d87dfa 100644
--- a/lib/Sema/CMakeLists.txt
+++ b/lib/Sema/CMakeLists.txt
@@ -7,6 +7,7 @@
   CSApply.cpp
   CSDiag.cpp
   CSGen.cpp
+  CSPropagate.cpp
   CSRanking.cpp
   CSSimplify.cpp
   CSSolver.cpp
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
index de33fab..4f27b76 100644
--- a/lib/Sema/CSApply.cpp
+++ b/lib/Sema/CSApply.cpp
@@ -3495,11 +3495,13 @@
     Expr *visitUnresolvedPatternExpr(UnresolvedPatternExpr *expr) {
       // If we end up here, we should have diagnosed somewhere else
       // already.
-      if (!SuppressDiagnostics) {
-        cs.TC.diagnose(expr->getLoc(), diag::pattern_in_expr,
+      Expr *simplified = simplifyExprType(expr);
+      if (!SuppressDiagnostics
+          && !simplified->getType()->is<UnresolvedType>()) {
+        cs.TC.diagnose(simplified->getLoc(), diag::pattern_in_expr,
                        expr->getSubPattern()->getKind());
       }
-      return expr;
+      return simplified;
     }
     
     Expr *visitBindOptionalExpr(BindOptionalExpr *expr) {
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
index 9c00226..1730ae3 100644
--- a/lib/Sema/CSDiag.cpp
+++ b/lib/Sema/CSDiag.cpp
@@ -5752,13 +5752,13 @@
     }
   };
 
+  auto dc = env->getOwningDeclContext();
   RequirementsListener genericReqListener;
-  auto result =
-    TC.checkGenericArguments(env->getOwningDeclContext(), argExpr->getLoc(),
-                             AFD->getLoc(), AFD->getInterfaceType(),
-                             env->getGenericSignature(), substitutions, nullptr,
-                             ConformanceCheckFlags::SuppressDependencyTracking,
-                             &genericReqListener);
+  auto result = TC.checkGenericArguments(
+      dc, argExpr->getLoc(), AFD->getLoc(), AFD->getInterfaceType(),
+      env->getGenericSignature(), QueryTypeSubstitutionMap{substitutions},
+      LookUpConformanceInModule{dc->getParentModule()}, nullptr,
+      ConformanceCheckFlags::SuppressDependencyTracking, &genericReqListener);
 
   return !result.second;
 }
@@ -5915,14 +5915,6 @@
   if (auto fn = fnType->getAs<AnyFunctionType>()) {
     using Closeness = CalleeCandidateInfo::ClosenessResultTy;
 
-    auto isGenericType = [](Type type) -> bool {
-      if (type->hasError() || type->hasTypeVariable() ||
-          type->hasUnresolvedType())
-        return false;
-
-      return type->isCanonical() && type->isUnspecializedGeneric();
-    };
-
     calleeInfo.filterList([&](UncurriedCandidate candidate) -> Closeness {
       auto resultType = candidate.getResultType();
       if (!resultType)
@@ -5933,8 +5925,7 @@
       // because there is no easy way to do that, and candidate set is going
       // to be pruned by matching of the argument types later on anyway, so
       // it's better to over report than to be too conservative.
-      if ((isGenericType(resultType) && isGenericType(fn->getResult())) ||
-          resultType->isEqual(fn->getResult()))
+      if (resultType->isEqual(fn->getResult()))
         return {CC_ExactMatch, {}};
 
       return {CC_GeneralMismatch, {}};
@@ -6086,9 +6077,13 @@
 
     if (callExpr->isImplicit() && overloadName == "~=") {
       // This binop was synthesized when typechecking an expression pattern.
-      auto diag = diagnose(lhsExpr->getLoc(),
-                    diag::cannot_match_expr_pattern_with_value,
-                           lhsType, rhsType);
+      auto diag = lhsType->is<UnresolvedType>()
+        ? diagnose(lhsExpr->getLoc(),
+                   diag::cannot_match_unresolved_expr_pattern_with_value,
+                   rhsType)
+        : diagnose(lhsExpr->getLoc(),
+                   diag::cannot_match_expr_pattern_with_value,
+                   lhsType, rhsType);
       diag.highlight(lhsExpr->getSourceRange());
       diag.highlight(rhsExpr->getSourceRange());
       if (auto optUnwrappedType = rhsType->getOptionalObjectType()) {
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
index a90ec12..f84b7dd 100644
--- a/lib/Sema/CSGen.cpp
+++ b/lib/Sema/CSGen.cpp
@@ -2670,8 +2670,13 @@
     
     Type visitUnresolvedPatternExpr(UnresolvedPatternExpr *expr) {
       // If there are UnresolvedPatterns floating around after name binding,
-      // they are pattern productions in invalid positions.
-      return ErrorType::get(CS.getASTContext());
+      // they are pattern productions in invalid positions. However, we will
+      // diagnose that condition elsewhere; to avoid unnecessary noise errors,
+      // just plop an open type variable here.
+      
+      auto locator = CS.getConstraintLocator(expr);
+      auto typeVar = CS.createTypeVariable(locator, TVO_CanBindToLValue);
+      return typeVar;
     }
 
     /// Get the type T?
@@ -3056,7 +3061,11 @@
   
   if (result)
     this->optimizeConstraints(result);
-  
+
+  // If the experimental constraint propagation pass is enabled, run it.
+  if (TC.Context.LangOpts.EnableConstraintPropagation)
+    propagateConstraints();
+
   return result;
 }
 
diff --git a/lib/Sema/CSPropagate.cpp b/lib/Sema/CSPropagate.cpp
new file mode 100644
index 0000000..79d0723
--- /dev/null
+++ b/lib/Sema/CSPropagate.cpp
@@ -0,0 +1,25 @@
+//===--- CSPropagate.cpp - Constraint Propagation -------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the constraint propagation algorithm in the solver.
+//
+//===----------------------------------------------------------------------===//
+#include "ConstraintGraph.h"
+#include "ConstraintSystem.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
+using namespace swift;
+using namespace constraints;
+
+void ConstraintSystem::propagateConstraints() {
+}
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
index d9ce9c6..d337194 100644
--- a/lib/Sema/CSSimplify.cpp
+++ b/lib/Sema/CSSimplify.cpp
@@ -3351,6 +3351,10 @@
                                              Type type2,
                                              TypeMatchOptions flags,
                                              ConstraintLocatorBuilder locator) {
+  // There's no bridging without ObjC interop.
+  if (!TC.Context.LangOpts.EnableObjCInterop)
+    return SolutionKind::Error;
+  
   TypeMatchOptions subflags = getDefaultDecompositionOptions(flags);
 
   /// Form an unresolved result.
diff --git a/lib/Sema/CSSolver.cpp b/lib/Sema/CSSolver.cpp
index 94d4dee..8a72947 100644
--- a/lib/Sema/CSSolver.cpp
+++ b/lib/Sema/CSSolver.cpp
@@ -889,7 +889,7 @@
       hasNonDependentMemberRelationalConstraints = true;
 
       // Handle unspecialized types directly.
-      if (!defaultType->isUnspecializedGeneric()) {
+      if (!defaultType->hasUnboundGenericType()) {
         if (!exactTypes.insert(defaultType->getCanonicalType()).second)
           continue;
 
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
index 82a3e5b..ef5f386 100644
--- a/lib/Sema/ConstraintSystem.h
+++ b/lib/Sema/ConstraintSystem.h
@@ -2060,6 +2060,10 @@
   /// \returns a possibly-sanitized initializer, or null if an error occurred.
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator);
 
+  /// \brief Propagate constraints in an effort to enforce local
+  /// consistency to reduce the time to solve the system.
+  void propagateConstraints();
+
   /// \brief The result of attempting to resolve a constraint or set of
   /// constraints.
   enum class SolutionKind : char {
diff --git a/lib/Sema/GenericTypeResolver.h b/lib/Sema/GenericTypeResolver.h
index 69d0ef5..63af3fb 100644
--- a/lib/Sema/GenericTypeResolver.h
+++ b/lib/Sema/GenericTypeResolver.h
@@ -144,8 +144,37 @@
 
   virtual Type resolveGenericTypeParamType(GenericTypeParamType *gp);
 
-  virtual Type resolveDependentMemberType(Type baseTy,
-                                          DeclContext *DC,
+  virtual Type resolveDependentMemberType(Type baseTy, DeclContext *DC,
+                                          SourceRange baseRange,
+                                          ComponentIdentTypeRepr *ref);
+
+  virtual Type resolveSelfAssociatedType(Type selfTy,
+                                         AssociatedTypeDecl *assocType);
+
+  virtual Type resolveTypeOfContext(DeclContext *dc);
+
+  virtual Type resolveTypeOfDecl(TypeDecl *decl);
+
+  virtual bool areSameType(Type type1, Type type2);
+
+  virtual void recordParamType(ParamDecl *decl, Type ty);
+};
+
+/// Generic type resolver that only handles what can appear in a protocol
+/// definition, i.e. Self, and Self.A.B.C dependent types.
+///
+/// This should only be used when resolving/validating where clauses in
+/// protocols.
+class ProtocolRequirementTypeResolver : public GenericTypeResolver {
+  ProtocolDecl *Proto;
+
+public:
+  explicit ProtocolRequirementTypeResolver(ProtocolDecl *proto)
+      : Proto(proto) {}
+
+  virtual Type resolveGenericTypeParamType(GenericTypeParamType *gp);
+
+  virtual Type resolveDependentMemberType(Type baseTy, DeclContext *DC,
                                           SourceRange baseRange,
                                           ComponentIdentTypeRepr *ref);
 
diff --git a/lib/Sema/ITCDecl.cpp b/lib/Sema/ITCDecl.cpp
index f3bd518..430e43a 100644
--- a/lib/Sema/ITCDecl.cpp
+++ b/lib/Sema/ITCDecl.cpp
@@ -60,6 +60,10 @@
         }
       }
     }
+
+    if (!isa<EnumDecl>(typeDecl)) {
+      options |= TR_NonEnumInheritanceClauseOuterLayer;
+    }
   } else {
     auto ext = decl.get<ExtensionDecl *>();
     inheritanceClause = ext->getInherited();
@@ -100,7 +104,7 @@
   // FIXME: Declaration validation is overkill. Sink it down into type
   // resolution when it is actually needed.
   if (auto nominal = dyn_cast<NominalTypeDecl>(dc))
-    TC.validateDecl(nominal);
+    TC.validateDeclForNameLookup(nominal);
   else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
     TC.validateExtension(ext);
   }
@@ -311,7 +315,7 @@
     } else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
       if (ext->isBeingValidated())
         return true;
-      if (ext->validated())
+      if (ext->hasValidationStarted())
         return false;
     } else {
       break;
@@ -329,7 +333,7 @@
   if (auto typeAliasDecl = dyn_cast<TypeAliasDecl>(typeDecl)) {
     if (typeAliasDecl->getDeclContext()->isModuleScopeContext() &&
         typeAliasDecl->getGenericParams() == nullptr) {
-      typeAliasDecl->setHasCompletedValidation();
+      typeAliasDecl->setValidationStarted();
 
       TypeResolutionOptions options;
       if (typeAliasDecl->getFormalAccess() <= Accessibility::FilePrivate)
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
index a9195ab..d8169a2 100644
--- a/lib/Sema/TypeCheckAttr.cpp
+++ b/lib/Sema/TypeCheckAttr.cpp
@@ -1769,6 +1769,10 @@
   // Add the requirements to the builder.
   for (auto &req : resolvedRequirements)
     Builder.addRequirement(&req);
+
+  // Check the result.
+  Builder.finalize(attr->getLocation(), genericSig->getGenericParams(),
+                   /*allowConcreteGenericParams=*/true);
 }
 
 static Accessibility getAccessForDiagnostics(const ValueDecl *D) {
diff --git a/lib/Sema/TypeCheckCaptures.cpp b/lib/Sema/TypeCheckCaptures.cpp
index 4d8b110..bb4c21b 100644
--- a/lib/Sema/TypeCheckCaptures.cpp
+++ b/lib/Sema/TypeCheckCaptures.cpp
@@ -192,7 +192,9 @@
 
     // If VD is a noescape decl, then the closure we're computing this for
     // must also be noescape.
-    if (VD->hasInterfaceType() &&
+    if (AFR.hasType() &&
+        !AFR.getType()->hasError() &&
+        VD->hasInterfaceType() &&
         VD->getInterfaceType()->is<AnyFunctionType>() &&
         VD->getInterfaceType()->castTo<AnyFunctionType>()->isNoEscape() &&
         !capture.isNoEscape() &&
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
index 2ec4bdc..11fa677 100644
--- a/lib/Sema/TypeCheckConstraints.cpp
+++ b/lib/Sema/TypeCheckConstraints.cpp
@@ -3365,16 +3365,18 @@
   // We can conditionally cast from NSError to an Error-conforming
   // type.  This is handled in the runtime, so it doesn't need a special cast
   // kind.
-  if (auto errorTypeProto = Context.getProtocol(KnownProtocolKind::Error)) {
-    if (conformsToProtocol(toType, errorTypeProto, dc,
-                           (ConformanceCheckFlags::InExpression|
-                            ConformanceCheckFlags::Used)))
-      if (auto NSErrorTy = getNSErrorType(dc))
-        if (isSubtypeOf(fromType, NSErrorTy, dc)
-            // Don't mask "always true" warnings if NSError is cast to
-            // Error itself.
-            && !isSubtypeOf(fromType, toType, dc))
-          return CheckedCastKind::ValueCast;
+  if (Context.LangOpts.EnableObjCInterop) {
+    if (auto errorTypeProto = Context.getProtocol(KnownProtocolKind::Error)) {
+      if (conformsToProtocol(toType, errorTypeProto, dc,
+                             (ConformanceCheckFlags::InExpression|
+                              ConformanceCheckFlags::Used)))
+        if (auto NSErrorTy = getNSErrorType(dc))
+          if (isSubtypeOf(fromType, NSErrorTy, dc)
+              // Don't mask "always true" warnings if NSError is cast to
+              // Error itself.
+              && !isSubtypeOf(fromType, toType, dc))
+            return CheckedCastKind::ValueCast;
+    }
   }
 
   // The runtime doesn't support casts to CF types and always lets them succeed.
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
index 80fc5d4..d324496 100644
--- a/lib/Sema/TypeCheckDecl.cpp
+++ b/lib/Sema/TypeCheckDecl.cpp
@@ -979,21 +979,14 @@
   return true;
 }
 
-/// Validate the given pattern binding declaration.
-static void validatePatternBindingDecl(TypeChecker &tc,
-                                       PatternBindingDecl *binding,
-                                       unsigned entryNumber) {
+/// Validate the \c entryNumber'th entry in \c binding.
+static void validatePatternBindingEntry(TypeChecker &tc,
+                                        PatternBindingDecl *binding,
+                                        unsigned entryNumber) {
   // If the pattern already has a type, we're done.
-  if (binding->getPattern(entryNumber)->hasType() ||
-      binding->isBeingValidated())
+  if (binding->getPattern(entryNumber)->hasType())
     return;
 
-  binding->setIsBeingValidated();
-
-  // On any path out of this function, make sure to mark the binding as done
-  // being type checked.
-  SWIFT_DEFER { binding->setIsBeingValidated(false); };
-
   // Resolve the pattern.
   auto *pattern = tc.resolvePattern(binding->getPattern(entryNumber),
                                     binding->getDeclContext(),
@@ -1078,6 +1071,19 @@
       tc.checkTypeModifyingDeclAttributes(var);
 }
 
+/// Validate the entries in the given pattern binding declaration.
+static void validatePatternBindingEntries(TypeChecker &tc,
+                                          PatternBindingDecl *binding) {
+  if (binding->hasValidationStarted())
+    return;
+
+  binding->setIsBeingValidated();
+  SWIFT_DEFER { binding->setIsBeingValidated(false); };
+
+  for (unsigned i = 0, e = binding->getNumPatternEntries(); i != e; ++i)
+    validatePatternBindingEntry(tc, binding, i);
+}
+
 void swift::makeFinal(ASTContext &ctx, ValueDecl *D) {
   if (D && !D->isFinal()) {
     D->getAttrs().add(new (ctx) FinalAttr(/*IsImplicit=*/true));
@@ -1256,7 +1262,9 @@
   if (!ED->getExtendedType().isNull() &&
       !ED->getExtendedType()->hasError()) {
     if (NominalTypeDecl *nominal = ED->getExtendedType()->getAnyNominal()) {
-      validateDecl(nominal);
+      validateDeclForNameLookup(nominal);
+      if (ED->hasDefaultAccessibility())
+        return;
       maxAccess = std::max(nominal->getFormalAccess(),
                            Accessibility::FilePrivate);
     }
@@ -3430,7 +3438,7 @@
   checkDeclAttributesEarly(PGD);
   checkDeclAttributes(PGD);
 
-  if (PGD->isInvalid() || PGD->isBeingValidated())
+  if (PGD->isInvalid() || PGD->hasValidationStarted())
     return;
   PGD->setIsBeingValidated();
   SWIFT_DEFER { PGD->setIsBeingValidated(false); };
@@ -3753,8 +3761,7 @@
 
   void visitPatternBindingDecl(PatternBindingDecl *PBD) {
     // Check all the pattern/init pairs in the PBD.
-    for (unsigned i = 0, e = PBD->getNumPatternEntries(); i != e; ++i)
-      validatePatternBindingDecl(TC, PBD, i);
+    validatePatternBindingEntries(TC, PBD);
 
     if (PBD->isBeingValidated())
       return;
@@ -3982,7 +3989,7 @@
   }
   
   void visitAssociatedTypeDecl(AssociatedTypeDecl *assocType) {
-    if (!assocType->hasInterfaceType())
+    if (!assocType->hasValidationStarted())
       TC.validateDecl(assocType);
   }
 
@@ -4334,9 +4341,28 @@
     TC.checkDeclAttributesEarly(PD);
     TC.computeAccessibility(PD);
 
-    if (!IsSecondPass)
+    if (!IsSecondPass) {
       checkUnsupportedNestedType(PD);
 
+      for (auto member : PD->getMembers()) {
+        if (auto assocType = dyn_cast<AssociatedTypeDecl>(member)) {
+          if (auto whereClause = assocType->getTrailingWhereClause()) {
+            DeclContext *lookupDC = assocType->getDeclContext();
+
+            ProtocolRequirementTypeResolver resolver(PD);
+            TypeResolutionOptions options;
+
+            for (auto &req : whereClause->getRequirements()) {
+              if (!TC.validateRequirement(whereClause->getWhereLoc(), req,
+                                          lookupDC, options, &resolver))
+                // FIXME handle error?
+                continue;
+            }
+          }
+        }
+      }
+    }
+
     if (IsSecondPass) {
       checkAccessibility(TC, PD);
       for (auto member : PD->getMembers()) {
@@ -5011,6 +5037,10 @@
         return false;
       if (func->isGeneric() != parentFunc->isGeneric())
         return false;
+    } else if (auto ctor = dyn_cast<ConstructorDecl>(decl)) {
+      auto parentCtor = cast<ConstructorDecl>(parentDecl);
+      if (ctor->isGeneric() != parentCtor->isGeneric())
+        return false;
     } else if (auto var = dyn_cast<VarDecl>(decl)) {
       auto parentVar = cast<VarDecl>(parentDecl);
       if (var->isStatic() != parentVar->isStatic())
@@ -6908,8 +6938,12 @@
   // Handling validation failure due to re-entrancy is left
   // up to the caller, who must call hasValidSignature() to
   // check that validateDecl() returned a fully-formed decl.
-  if (D->isBeingValidated())
+  if (D->hasValidationStarted()) {
+    // If this isn't reentrant (i.e. D has already been validated), the
+    // signature better be valid.
+    assert(D->isBeingValidated() || D->hasValidSignature());
     return;
+  }
 
   PrettyStackTraceDecl StackTrace("validating", D);
 
@@ -6952,40 +6986,48 @@
     llvm_unreachable("handled above");
 
   case DeclKind::AssociatedType: {
-    if (D->hasInterfaceType())
-      return;
-
     auto assocType = cast<AssociatedTypeDecl>(D);
 
     assocType->setIsBeingValidated();
     SWIFT_DEFER { assocType->setIsBeingValidated(false); };
 
+    validateAccessibility(assocType);
+
     checkDeclAttributesEarly(assocType);
     checkInheritanceClause(assocType);
 
     // Check the default definition, if there is one.
     TypeLoc &defaultDefinition = assocType->getDefaultDefinitionLoc();
-    if (!defaultDefinition.isNull() &&
-        validateType(defaultDefinition, assocType->getDeclContext())) {
-      defaultDefinition.setInvalidType(Context);
-    }
+    if (!defaultDefinition.isNull()) {
+      if (validateType(defaultDefinition, assocType->getDeclContext())) {
+        defaultDefinition.setInvalidType(Context);
+      } else {
+        // associatedtype X = X is invalid
+        auto mentionsItself =
+            defaultDefinition.getType().findIf([&](Type type) {
+              if (auto DMT = type->getAs<ArchetypeType>()) {
+                return DMT->getAssocType() == assocType;
+              }
+              return false;
+            });
 
+        if (mentionsItself) {
+          diagnose(defaultDefinition.getLoc(), diag::recursive_type_reference,
+                   assocType->getDescriptiveKind(), assocType->getName());
+          diagnose(assocType, diag::type_declared_here);
+        }
+      }
+    }
     // Finally, set the interface type.
-    assocType->computeType();
+    if (!assocType->hasInterfaceType())
+      assocType->computeType();
 
     checkDeclAttributes(assocType);
     break;
   }
 
   case DeclKind::TypeAlias: {
-    // Type aliases may not have an underlying type yet.
     auto typeAlias = cast<TypeAliasDecl>(D);
-
-    if (typeAlias->hasCompletedValidation())
-      return;
-
-    typeAlias->setHasCompletedValidation();
-
     // Check generic parameters, if needed.
     typeAlias->setIsBeingValidated();
     SWIFT_DEFER { typeAlias->setIsBeingValidated(false); };
@@ -7017,8 +7059,6 @@
   case DeclKind::Struct:
   case DeclKind::Class: {
     auto nominal = cast<NominalTypeDecl>(D);
-    if (nominal->hasInterfaceType())
-      return;
     nominal->computeType();
 
     // Check generic parameters, if needed.
@@ -7056,9 +7096,8 @@
 
   case DeclKind::Protocol: {
     auto proto = cast<ProtocolDecl>(D);
-    if (proto->hasInterfaceType())
-      return;
-    proto->computeType();
+    if (!proto->hasInterfaceType())
+      proto->computeType();
 
     // Validate the generic type signature, which is just <Self : P>.
     proto->setIsBeingValidated();
@@ -7110,8 +7149,7 @@
           diagnose(VD, diag::pattern_used_in_type, VD->getName());
 
         } else {
-          for (unsigned i = 0, e = PBD->getNumPatternEntries(); i != e; ++i)
-            validatePatternBindingDecl(*this, PBD, i);
+          validatePatternBindingEntries(*this, PBD);
         }
 
         auto parentPattern = VD->getParentPattern();
@@ -7221,23 +7259,17 @@
   }
       
   case DeclKind::Func: {
-    if (D->hasInterfaceType())
-      return;
     typeCheckDecl(D, true);
     break;
   }
 
   case DeclKind::Subscript:
   case DeclKind::Constructor:
-    if (D->hasInterfaceType())
-      return;
     typeCheckDecl(D, true);
     break;
 
   case DeclKind::Destructor:
   case DeclKind::EnumElement: {
-    if (D->hasInterfaceType())
-      return;
     if (auto container = dyn_cast<NominalTypeDecl>(D->getDeclContext())) {
       validateDecl(container);
       typeCheckDecl(D, true);
@@ -7251,6 +7283,40 @@
   assert(D->hasValidSignature());
 }
 
+void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
+  switch (D->getKind()) {
+  case DeclKind::Protocol: {
+    auto proto = cast<ProtocolDecl>(D);
+    if (proto->hasInterfaceType())
+      return;
+    proto->computeType();
+
+    validateAccessibility(proto);
+
+    // Record inherited protocols.
+    resolveInheritedProtocols(proto);
+
+    for (auto member : proto->getMembers()) {
+      if (auto ATD = dyn_cast<AssociatedTypeDecl>(member)) {
+        validateDeclForNameLookup(ATD);
+      }
+    }
+    break;
+  }
+  case DeclKind::AssociatedType: {
+    auto assocType = cast<AssociatedTypeDecl>(D);
+    if (assocType->hasInterfaceType())
+      return;
+    assocType->computeType();
+    validateAccessibility(assocType);
+    break;
+  }
+
+  default:
+    validateDecl(D);
+    break;
+  }
+}
 
 void TypeChecker::validateAccessibility(ValueDecl *D) {
   if (D->hasAccessibility())
@@ -7394,9 +7460,7 @@
 
   // Local function used to infer requirements from the extended type.
   auto inferExtendedTypeReqs = [&](GenericSignatureBuilder &builder) {
-    builder.inferRequirements(TypeLoc::withoutLoc(extInterfaceType),
-                              /*minDepth=*/0,
-                              /*maxDepth=*/genericParams->getDepth());
+    builder.inferRequirements(TypeLoc::withoutLoc(extInterfaceType));
   };
 
   // Validate the generic type signature.
@@ -7430,12 +7494,11 @@
 } // namespace swift
 
 void TypeChecker::validateExtension(ExtensionDecl *ext) {
-  // If we already validated this extension, there's nothing more to do.
-  if (ext->validated())
+  // If we're currently validating, or have already validated this extension,
+  // there's nothing more to do now.
+  if (ext->hasValidationStarted())
     return;
 
-  ext->setValidated();
-
   ext->setIsBeingValidated();
   SWIFT_DEFER { ext->setIsBeingValidated(false); };
 
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
index 737fa2f..a0dc719 100644
--- a/lib/Sema/TypeCheckGeneric.cpp
+++ b/lib/Sema/TypeCheckGeneric.cpp
@@ -128,6 +128,43 @@
         GenericEnv, type));
 }
 
+Type ProtocolRequirementTypeResolver::resolveGenericTypeParamType(
+    GenericTypeParamType *gp) {
+  assert(gp->isEqual(Proto->getSelfInterfaceType()) &&
+         "found non-Self-shaped GTPT when resolving protocol requirement");
+  return gp;
+}
+
+Type ProtocolRequirementTypeResolver::resolveDependentMemberType(
+    Type baseTy, DeclContext *DC, SourceRange baseRange,
+    ComponentIdentTypeRepr *ref) {
+  return DependentMemberType::get(baseTy, ref->getIdentifier());
+}
+
+Type ProtocolRequirementTypeResolver::resolveSelfAssociatedType(
+    Type selfTy, AssociatedTypeDecl *assocType) {
+  assert(selfTy->isEqual(Proto->getSelfInterfaceType()));
+  return assocType->getDeclaredInterfaceType();
+}
+
+Type ProtocolRequirementTypeResolver::resolveTypeOfContext(DeclContext *dc) {
+  return dc->getSelfInterfaceType();
+}
+
+Type ProtocolRequirementTypeResolver::resolveTypeOfDecl(TypeDecl *decl) {
+  return decl->getDeclaredInterfaceType();
+}
+
+bool ProtocolRequirementTypeResolver::areSameType(Type type1, Type type2) {
+  return type1->isEqual(type2);
+}
+
+void ProtocolRequirementTypeResolver::recordParamType(ParamDecl *decl,
+                                                      Type type) {
+  llvm_unreachable(
+      "recording a param type of a protocol requirement doesn't make sense");
+}
+
 Type CompleteGenericTypeResolver::resolveGenericTypeParamType(
                                               GenericTypeParamType *gp) {
   assert(gp->getDecl() && "Missing generic parameter declaration");
@@ -276,8 +313,6 @@
       builder->addGenericParameter(param);
   }
 
-  unsigned depth = genericParams->getDepth();
-
   // Now, check the inheritance clauses of each parameter.
   for (auto param : *genericParams) {
     checkInheritanceClause(param, resolver);
@@ -287,9 +322,7 @@
 
       // Infer requirements from the inherited types.
       for (const auto &inherited : param->getInherited()) {
-        builder->inferRequirements(inherited,
-                                   /*minDepth=*/depth,
-                                   /*maxDepth=*/depth);
+        builder->inferRequirements(inherited);
       }
     }
   }
@@ -298,73 +331,76 @@
   // Add the requirements clause to the builder, validating the types in
   // the requirements clause along the way.
   for (auto &req : genericParams->getRequirements()) {
-    if (req.isInvalid())
+    if (validateRequirement(genericParams->getWhereLoc(), req, lookupDC,
+                            options, resolver))
       continue;
 
-    switch (req.getKind()) {
-    case RequirementReprKind::TypeConstraint: {
-      // Validate the types.
-      if (validateType(req.getSubjectLoc(), lookupDC, options, resolver)) {
-        req.setInvalid();
-        continue;
-      }
-
-      if (validateType(req.getConstraintLoc(), lookupDC, options,
-                       resolver)) {
-        req.setInvalid();
-        continue;
-      }
-
-      // FIXME: Feels too early to perform this check.
-      if (!req.getConstraint()->isExistentialType() &&
-          !req.getConstraint()->getClassOrBoundGenericClass()) {
-        diagnose(genericParams->getWhereLoc(),
-                 diag::requires_conformance_nonprotocol,
-                 req.getSubjectLoc(), req.getConstraintLoc());
-        req.getConstraintLoc().setInvalidType(Context);
-        req.setInvalid();
-        continue;
-      }
-
-      break;
-    }
-
-    case RequirementReprKind::LayoutConstraint: {
-      // Validate the types.
-      if (validateType(req.getSubjectLoc(), lookupDC, options, resolver)) {
-        req.setInvalid();
-        continue;
-      }
-
-      if (req.getLayoutConstraintLoc().isNull()) {
-        req.setInvalid();
-        continue;
-      }
-
-      break;
-    }
-
-    case RequirementReprKind::SameType:
-      if (validateType(req.getFirstTypeLoc(), lookupDC, options,
-                       resolver)) {
-        req.setInvalid();
-        continue;
-      }
-
-      if (validateType(req.getSecondTypeLoc(), lookupDC, options,
-                       resolver)) {
-        req.setInvalid();
-        continue;
-      }
-      
-      break;
-    }
-    
     if (builder && builder->addRequirement(&req))
       req.setInvalid();
   }
 }
 
+bool TypeChecker::validateRequirement(SourceLoc whereLoc, RequirementRepr &req,
+                                      DeclContext *lookupDC,
+                                      TypeResolutionOptions options,
+                                      GenericTypeResolver *resolver) {
+  if (req.isInvalid())
+    return true;
+
+  switch (req.getKind()) {
+  case RequirementReprKind::TypeConstraint: {
+    // Validate the types.
+    if (validateType(req.getSubjectLoc(), lookupDC, options, resolver)) {
+      req.setInvalid();
+      return true;
+    }
+
+    if (validateType(req.getConstraintLoc(), lookupDC, options, resolver)) {
+      req.setInvalid();
+      return true;
+    }
+
+    // FIXME: Feels too early to perform this check.
+    if (!req.getConstraint()->isExistentialType() &&
+        !req.getConstraint()->getClassOrBoundGenericClass()) {
+      diagnose(whereLoc, diag::requires_conformance_nonprotocol,
+               req.getSubjectLoc(), req.getConstraintLoc());
+      req.getConstraintLoc().setInvalidType(Context);
+      req.setInvalid();
+      return true;
+    }
+    return false;
+  }
+
+  case RequirementReprKind::LayoutConstraint: {
+    // Validate the types.
+    if (validateType(req.getSubjectLoc(), lookupDC, options, resolver)) {
+      req.setInvalid();
+      return true;
+    }
+
+    if (req.getLayoutConstraintLoc().isNull()) {
+      req.setInvalid();
+      return true;
+    }
+    return false;
+  }
+
+  case RequirementReprKind::SameType: {
+    if (validateType(req.getFirstTypeLoc(), lookupDC, options, resolver)) {
+      req.setInvalid();
+      return true;
+    }
+
+    if (validateType(req.getSecondTypeLoc(), lookupDC, options, resolver)) {
+      req.setInvalid();
+      return true;
+    }
+    return false;
+  }
+  }
+}
+
 void
 TypeChecker::prepareGenericParamList(GenericParamList *gp,
                                      DeclContext *dc) {
@@ -488,10 +524,7 @@
       // Infer requirements from it.
       if (builder && genericParams &&
           fn->getBodyResultTypeLoc().getTypeRepr()) {
-        unsigned depth = genericParams->getDepth();
-        builder->inferRequirements(fn->getBodyResultTypeLoc(),
-                                   /*minDepth=*/depth,
-                                   /*maxDepth=*/depth);
+        builder->inferRequirements(fn->getBodyResultTypeLoc());
       }
     }
   }
@@ -827,10 +860,7 @@
   // Infer requirements from it.
   if (genericParams && builder &&
       subscript->getElementTypeLoc().getTypeRepr()) {
-    unsigned depth = genericParams->getDepth();
-    builder->inferRequirements(subscript->getElementTypeLoc(),
-                               /*minDepth=*/depth,
-                               /*maxDepth=*/depth);
+    builder->inferRequirements(subscript->getElementTypeLoc());
   }
 
   // Check the indices.
@@ -1089,34 +1119,29 @@
 
 std::pair<bool, bool> TypeChecker::checkGenericArguments(
     DeclContext *dc, SourceLoc loc, SourceLoc noteLoc, Type owner,
-    GenericSignature *genericSig, const TypeSubstitutionMap &substitutions,
+    GenericSignature *genericSig, TypeSubstitutionFn substitutions,
+    LookupConformanceFn conformances,
     UnsatisfiedDependency *unsatisfiedDependency,
     ConformanceCheckOptions conformanceOptions,
     GenericRequirementsCheckListener *listener) {
-  // Check each of the requirements.
-  ModuleDecl *module = dc->getParentModule();
-  for (const auto &req : genericSig->getRequirements()) {
-    Type firstType = req.getFirstType().subst(
-        QueryTypeSubstitutionMap{substitutions},
-        LookUpConformanceInModule(module));
-    if (firstType.isNull()) {
+  for (const auto &rawReq : genericSig->getRequirements()) {
+    auto req = rawReq.subst(substitutions, conformances);
+    if (!req) {
       // Another requirement will fail later; just continue.
       continue;
     }
 
-    Type secondType;
-    if (req.getKind() != RequirementKind::Layout)
-      secondType = req.getSecondType();
-    if (secondType) {
-      secondType = secondType.subst(QueryTypeSubstitutionMap{substitutions},
-                                    LookUpConformanceInModule(module));
-      if (secondType.isNull()) {
-        // Another requirement will fail later; just continue.
+    auto kind = req->getKind();
+    Type rawFirstType = rawReq.getFirstType();
+    Type firstType = req->getFirstType();
+    Type rawSecondType, secondType;
+    if (kind != RequirementKind::Layout) {
+      rawSecondType = rawReq.getSecondType();
+      secondType = req->getSecondType().subst(substitutions, conformances);
+      if (!secondType)
         continue;
-      }
     }
 
-    auto kind = req.getKind();
     if (listener && !listener->shouldCheck(kind, firstType, secondType))
       continue;
 
@@ -1157,10 +1182,10 @@
         diagnose(loc, diag::type_does_not_inherit, owner, firstType,
                  secondType);
 
-        diagnose(noteLoc, diag::type_does_not_inherit_requirement,
-                 req.getFirstType(), req.getSecondType(),
+        diagnose(noteLoc, diag::type_does_not_inherit_requirement, rawFirstType,
+                 rawSecondType,
                  genericSig->gatherGenericParamBindingsText(
-                     {req.getFirstType(), req.getSecondType()}, substitutions));
+                     {rawFirstType, rawSecondType}, substitutions));
 
         return std::make_pair(false, false);
       }
@@ -1171,10 +1196,10 @@
         // FIXME: Better location info for both diagnostics.
         diagnose(loc, diag::types_not_equal, owner, firstType, secondType);
 
-        diagnose(noteLoc, diag::types_not_equal_requirement, req.getFirstType(),
-                 req.getSecondType(),
+        diagnose(noteLoc, diag::types_not_equal_requirement, rawFirstType,
+                 rawSecondType,
                  genericSig->gatherGenericParamBindingsText(
-                     {req.getFirstType(), req.getSecondType()}, substitutions));
+                     {rawFirstType, rawSecondType}, substitutions));
 
         return std::make_pair(false, false);
       }
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
index 0a3131e..b2fa7ec 100644
--- a/lib/Sema/TypeCheckPattern.cpp
+++ b/lib/Sema/TypeCheckPattern.cpp
@@ -394,7 +394,7 @@
   // Unresolved member syntax '.Element' forms an EnumElement pattern. The
   // element will be resolved when we type-check the pattern.
   Pattern *visitUnresolvedMemberExpr(UnresolvedMemberExpr *ume) {
-    // We the unresolved member has an argument, turn it into a subpattern.
+    // If the unresolved member has an argument, turn it into a subpattern.
     Pattern *subPattern = nullptr;
     if (auto arg = ume->getArgument()) {
       subPattern = getSubExprPattern(arg);
@@ -402,11 +402,11 @@
     
     // FIXME: Compound names.
     return new (TC.Context) EnumElementPattern(
-                              TypeLoc(), ume->getDotLoc(),
+                              ume->getDotLoc(),
                               ume->getNameLoc().getBaseNameLoc(),
                               ume->getName().getBaseName(),
-                              nullptr,
-                              subPattern);
+                              subPattern,
+                              ume);
   }
   
   // Member syntax 'T.Element' forms a pattern if 'T' is an enum and the
@@ -1004,6 +1004,7 @@
                                       TypeResolutionOptions options,
                                       GenericTypeResolver *resolver,
                                       TypeLoc tyLoc) {
+recur:
   if (tyLoc.isNull()) {
     tyLoc = TypeLoc::withoutLoc(type);
   }
@@ -1377,6 +1378,14 @@
 
               return true;
             }
+          
+          // If we have the original expression parse tree, try reinterpreting
+          // it as an expr-pattern if enum element lookup failed, since `.foo`
+          // could also refer to a static member of the context type.
+          } else if (EEP->hasUnresolvedOriginalExpr()) {
+            P = new (Context) ExprPattern(EEP->getUnresolvedOriginalExpr(),
+                                          nullptr, nullptr);
+            goto recur;
           }
 
           diagnose(EEP->getLoc(), diag::enum_element_pattern_member_not_found,
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
index 17e3471..ddf4d8a 100644
--- a/lib/Sema/TypeCheckProtocol.cpp
+++ b/lib/Sema/TypeCheckProtocol.cpp
@@ -1073,7 +1073,8 @@
 
   // Next, add each of the requirements (mapped from the requirement's
   // interface types into the abstract type parameters).
-  auto source = RequirementSource::forAbstract(builder);
+  auto source =
+    GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
   for (auto &reqReq : reqSig->getRequirements()) {
     switch (reqReq.getKind()) {
     case RequirementKind::Conformance: {
@@ -1782,12 +1783,15 @@
     void emitDelayedDiags();
 
     ConformanceChecker(TypeChecker &tc, NormalProtocolConformance *conformance,
-                      bool suppressDiagnostics = true)
-      : WitnessChecker(tc, conformance->getProtocol(), conformance->getType(),
-                       conformance->getDeclContext()),
-        Conformance(conformance),
-        Loc(conformance->getLoc()),
-        SuppressDiagnostics(suppressDiagnostics) { }
+                       bool suppressDiagnostics = true)
+        : WitnessChecker(tc, conformance->getProtocol(), conformance->getType(),
+                         conformance->getDeclContext()),
+          Conformance(conformance), Loc(conformance->getLoc()),
+          SuppressDiagnostics(suppressDiagnostics) {
+      // The protocol may have only been validatedDeclForNameLookup'd until
+      // here, so fill in any information that's missing.
+      tc.validateDecl(conformance->getProtocol());
+    }
 
     /// Resolve all of the type witnesses.
     void resolveTypeWitnesses();
@@ -1806,6 +1810,10 @@
     /// directly as possible.
     void resolveSingleTypeWitness(AssociatedTypeDecl *assocType);
 
+    /// Check all of the protocols requirements are actually satisfied by a
+    /// the chosen type witnesses.
+    void ensureRequirementsAreSatisfied();
+
     /// Check the entire protocol conformance, ensuring that all
     /// witnesses are resolved and emitting any diagnostics.
     void checkConformance();
@@ -4447,6 +4455,28 @@
   addUsedConformances(conformance, visited);
 }
 
+void ConformanceChecker::ensureRequirementsAreSatisfied() {
+  auto proto = Conformance->getProtocol();
+  // Some other problem stopped the signature being computed.
+  if (!proto->isRequirementSignatureComputed())
+    return;
+
+  auto reqSig = proto->getRequirementSignature();
+
+  auto substitutions = SubstitutionMap::getProtocolSubstitutions(
+      proto, Conformance->getType(), ProtocolConformanceRef(Conformance));
+
+  auto result = TC.checkGenericArguments(
+      Conformance->getDeclContext(), Loc, Loc,
+      // FIXME: maybe this should be the conformance's type
+      proto->getDeclaredInterfaceType(), reqSig,
+      QuerySubstitutionMap{substitutions},
+      LookUpConformanceInSubstitutionMap{substitutions}, nullptr);
+
+  // Errors are emitted inside the checker.
+  (void)result;
+}
+
 #pragma mark Protocol conformance checking
 void ConformanceChecker::checkConformance() {
   assert(!Conformance->isComplete() && "Conformance is already complete");
@@ -4462,6 +4492,10 @@
   // Resolve all of the type witnesses.
   resolveTypeWitnesses();
 
+  // Resolution attempts to have the witnesses be correct by construction, but
+  // this isn't guaranteed, so let's double check.
+  ensureRequirementsAreSatisfied();
+
   // Ensure the conforming type is used.
   //
   // FIXME: This feels like the wrong place for this, but if we don't put
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
index 29e54c8..e0ee038 100644
--- a/lib/Sema/TypeCheckType.cpp
+++ b/lib/Sema/TypeCheckType.cpp
@@ -575,8 +575,9 @@
   for (auto tyR : genericArgs)
     args.push_back(tyR);
 
+  auto argumentOptions = options - TR_NonEnumInheritanceClauseOuterLayer;
   auto result = applyUnboundGenericArguments(type, genericDecl, loc, dc, args,
-                                             options, resolver,
+                                             argumentOptions, resolver,
                                              unsatisfiedDependency);
   if (!result)
     return result;
@@ -675,9 +676,11 @@
     assert(genericSig != nullptr);
     auto substitutions = BGT->getContextSubstitutions(BGT->getDecl());
 
-    auto result = checkGenericArguments(
-        dc, loc, noteLoc, UGT, genericSig,
-        substitutions, unsatisfiedDependency);
+    auto result =
+        checkGenericArguments(dc, loc, noteLoc, UGT, genericSig,
+                              QueryTypeSubstitutionMap{substitutions},
+                              LookUpConformanceInModule{dc->getParentModule()},
+                              unsatisfiedDependency);
 
     // Unsatisfied dependency case.
     if (result.first)
@@ -726,7 +729,7 @@
       return nullptr;
   } else {
     // Validate the declaration.
-    TC.validateDecl(typeDecl);
+    TC.validateDeclForNameLookup(typeDecl);
   }
 
   // If we didn't bail out with an unsatisfiedDependency,
@@ -1086,7 +1089,26 @@
                                 dyn_cast<GenericIdentTypeRepr>(comp), options,
                                 resolver, unsatisfiedDependency);
 
-    if (!type || type->hasError())
+    if (!type)
+      return type;
+
+    auto hasError = type->hasError();
+    if (options & TR_NonEnumInheritanceClauseOuterLayer) {
+      auto protocolOrClass =
+          hasError ? (isa<ProtocolDecl>(typeDecl) || isa<ClassDecl>(typeDecl))
+                   : (type->is<ProtocolType>() || type->is<ClassType>());
+      if (!protocolOrClass) {
+        auto diagnosedType = hasError ? typeDecl->getDeclaredInterfaceType() : type;
+        if (diagnosedType && /*FIXME:*/!hasError) {
+          TC.diagnose(comp->getIdLoc(),
+                      diag::inheritance_from_non_protocol_or_class,
+                      diagnosedType);
+          return ErrorType::get(diagnosedType);
+        }
+      }
+    }
+
+    if (hasError)
       return type;
 
     // If this is the first result we found, record it.
@@ -1318,6 +1340,16 @@
     return ErrorType::get(TC.Context);
   }
 
+  if (options & TR_NonEnumInheritanceClauseOuterLayer) {
+    auto protocolOrClass =
+        memberType->is<ProtocolType>() || memberType->is<ClassType>();
+    if (!protocolOrClass) {
+      TC.diagnose(comp->getIdLoc(),
+                  diag::inheritance_from_non_protocol_or_class, memberType);
+      return ErrorType::get(memberType);
+    }
+  }
+
   // If there are generic arguments, apply them now.
   if (auto genComp = dyn_cast<GenericIdentTypeRepr>(comp))
     memberType = TC.applyGenericArguments(
@@ -1357,8 +1389,9 @@
 
   // All remaining components use qualified lookup.
 
+  auto parentOptions = options - TR_NonEnumInheritanceClauseOuterLayer;
   // Resolve the parent type.
-  Type parentTy = resolveIdentTypeComponent(TC, DC, parentComps, options,
+  Type parentTy = resolveIdentTypeComponent(TC, DC, parentComps, parentOptions,
                                             diagnoseErrors, resolver,
                                             unsatisfiedDependency);
   if (!parentTy || parentTy->hasError()) return parentTy;
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
index 7d001ab..e681c7a 100644
--- a/lib/Sema/TypeChecker.cpp
+++ b/lib/Sema/TypeChecker.cpp
@@ -348,7 +348,7 @@
   }
 
   // Cannot extend a bound generic type.
-  if (extendedType->isSpecialized() && extendedType->getAnyNominal()) {
+  if (extendedType->isSpecialized()) {
     TC.diagnose(ED->getLoc(), diag::extension_specialization,
                 extendedType->getAnyNominal()->getName())
       .highlight(ED->getExtendedTypeLoc().getSourceRange());
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
index a331c60..aa56685 100644
--- a/lib/Sema/TypeChecker.h
+++ b/lib/Sema/TypeChecker.h
@@ -437,6 +437,11 @@
 
   /// Whether we are checking the outermost type of a computed property setter's newValue
   TR_ImmediateSetterNewValue = 0x1000000,
+
+  /// Whether we are checking the outermost layer of types in an inheritance
+  /// clause on something other than an enum (i.e. V, but not U or W, in class
+  /// T: U.V<W>)
+  TR_NonEnumInheritanceClauseOuterLayer = 0x2000000,
 };
 
 /// Option set describing how type resolution should work.
@@ -838,6 +843,9 @@
   void validateDecl(OperatorDecl *decl);
   void validateDecl(PrecedenceGroupDecl *decl);
 
+  /// Perform just enough validation for looking up names using the Decl.
+  void validateDeclForNameLookup(ValueDecl *D);
+
   /// Resolves the accessibility of the given declaration.
   void validateAccessibility(ValueDecl *D);
 
@@ -1065,7 +1073,7 @@
   }
 
   virtual void resolveDeclSignature(ValueDecl *VD) override {
-    validateDecl(VD);
+    validateDeclForNameLookup(VD);
   }
 
   virtual void bindExtension(ExtensionDecl *ext) override;
@@ -1185,6 +1193,11 @@
   /// \param nominal The generic type.
   void validateGenericTypeSignature(GenericTypeDecl *nominal);
 
+  bool validateRequirement(SourceLoc whereLoc, RequirementRepr &req,
+                           DeclContext *lookupDC,
+                           TypeResolutionOptions options = None,
+                           GenericTypeResolver *resolver = nullptr);
+
   /// Check the given set of generic arguments against the requirements in a
   /// generic signature.
   ///
@@ -1207,7 +1220,8 @@
   /// - (false, false) on failure
   std::pair<bool, bool> checkGenericArguments(
       DeclContext *dc, SourceLoc loc, SourceLoc noteLoc, Type owner,
-      GenericSignature *genericSig, const TypeSubstitutionMap &substitutions,
+      GenericSignature *genericSig, TypeSubstitutionFn substitutions,
+      LookupConformanceFn conformances,
       UnsatisfiedDependency *unsatisfiedDependency,
       ConformanceCheckOptions conformanceOptions = ConformanceCheckFlags::Used,
       GenericRequirementsCheckListener *listener = nullptr);
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
index 98f18bb..65e5ea5 100644
--- a/lib/Serialization/Deserialization.cpp
+++ b/lib/Serialization/Deserialization.cpp
@@ -1321,11 +1321,10 @@
     IdentifierID IID;
     TypeID TID = 0;
     bool isType = (recordID == XREF_TYPE_PATH_PIECE);
-    bool onlyInNominal = false;
     bool inProtocolExt = false;
     bool isStatic = false;
     if (isType)
-      XRefTypePathPieceLayout::readRecord(scratch, IID, onlyInNominal);
+      XRefTypePathPieceLayout::readRecord(scratch, IID, inProtocolExt);
     else
       XRefValuePathPieceLayout::readRecord(scratch, TID, IID, inProtocolExt,
                                            isStatic);
@@ -1496,13 +1495,12 @@
       Identifier memberName;
       Optional<swift::CtorInitializerKind> ctorInit;
       bool isType = false;
-      bool onlyInNominal = false;
       bool inProtocolExt = false;
       bool isStatic = false;
       switch (recordID) {
       case XREF_TYPE_PATH_PIECE: {
         IdentifierID IID;
-        XRefTypePathPieceLayout::readRecord(scratch, IID, onlyInNominal);
+        XRefTypePathPieceLayout::readRecord(scratch, IID, inProtocolExt);
         memberName = getIdentifier(IID);
         isType = true;
         break;
@@ -1548,7 +1546,7 @@
         return nullptr;
       }
 
-      auto members = nominal->lookupDirect(memberName, onlyInNominal);
+      auto members = nominal->lookupDirect(memberName);
       values.append(members.begin(), members.end());
       filterValues(filterTy, M, genericSig, isType, inProtocolExt, isStatic,
                    ctorInit, values);
@@ -2551,10 +2549,14 @@
     if (declOrOffset.isComplete())
       return declOrOffset;
 
-    auto assocType = createDecl<AssociatedTypeDecl>(DC, SourceLoc(),
-                                                    getIdentifier(nameID),
-                                                    SourceLoc(), this,
-                                                    defaultDefinitionID);
+    // The where-clause information is pushed up into the protocol
+    // (specifically, into its requirement signature) and
+    // serialized/deserialized there, so the actual Decl doesn't need to store
+    // it.
+    TrailingWhereClause *trailingWhere = nullptr;
+    auto assocType = createDecl<AssociatedTypeDecl>(
+        DC, SourceLoc(), getIdentifier(nameID), SourceLoc(), trailingWhere,
+        this, defaultDefinitionID);
     declOrOffset = assocType;
 
     assocType->computeType();
@@ -3467,7 +3469,6 @@
                                        DeclTypeCursor.GetCurrentBitNo()));
 
     nominal->addExtension(extension);
-    extension->setValidated(true);
 
     break;
   }
@@ -3529,7 +3530,9 @@
   if (DAttrs)
     declOrOffset.get()->getAttrs().setRawAttributeChain(DAttrs);
 
-  return declOrOffset;
+  auto decl = declOrOffset.get();
+  decl->setValidationStarted();
+  return decl;
 }
 
 /// Translate from the Serialization function type repr enum values to the AST
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
index 3153e1e..25c7df7 100644
--- a/lib/Serialization/DeserializeSIL.cpp
+++ b/lib/Serialization/DeserializeSIL.cpp
@@ -982,6 +982,10 @@
                                                 Ty,
                                                 ctxConformances);
       break;
+    case ValueKind::InitExistentialOpaqueInst:
+      ResultVal = Builder.createInitExistentialOpaque(Loc, Ty, ConcreteTy,
+                                                      operand, ctxConformances);
+      break;
     case ValueKind::InitExistentialMetatypeInst:
       ResultVal = Builder.createInitExistentialMetatype(Loc, operand, Ty,
                                                         ctxConformances);
@@ -1343,16 +1347,17 @@
 
   UNARY_INSTRUCTION(CondFail)
   REFCOUNTING_INSTRUCTION(RetainValue)
-  UNARY_INSTRUCTION(UnmanagedRetainValue)
+  REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
   UNARY_INSTRUCTION(CopyValue)
   UNARY_INSTRUCTION(CopyUnownedValue)
   UNARY_INSTRUCTION(DestroyValue)
   REFCOUNTING_INSTRUCTION(ReleaseValue)
-  UNARY_INSTRUCTION(UnmanagedReleaseValue)
+  REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
   REFCOUNTING_INSTRUCTION(AutoreleaseValue)
-  UNARY_INSTRUCTION(UnmanagedAutoreleaseValue)
+  REFCOUNTING_INSTRUCTION(UnmanagedAutoreleaseValue)
   REFCOUNTING_INSTRUCTION(SetDeallocating)
   UNARY_INSTRUCTION(DeinitExistentialAddr)
+  UNARY_INSTRUCTION(DeinitExistentialOpaque)
   UNARY_INSTRUCTION(EndBorrowArgument)
   UNARY_INSTRUCTION(DestroyAddr)
   UNARY_INSTRUCTION(IsNonnull)
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index df0d237..85f57eb 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -1803,18 +1803,17 @@
     return;
   }
 
+  bool isProtocolExt = D->getDeclContext()->getAsProtocolExtensionContext();
   if (auto type = dyn_cast<TypeDecl>(D)) {
     abbrCode = DeclTypeAbbrCodes[XRefTypePathPieceLayout::Code];
     XRefTypePathPieceLayout::emitRecord(Out, ScratchRecord, abbrCode,
                                         addIdentifierRef(type->getName()),
-                                        isa<ProtocolDecl>(
-                                          type->getDeclContext()));
+                                        isProtocolExt);
     return;
   }
 
   auto val = cast<ValueDecl>(D);
   auto ty = val->getInterfaceType()->getCanonicalType();
-  bool isProtocolExt = D->getDeclContext()->getAsProtocolExtensionContext();
   abbrCode = DeclTypeAbbrCodes[XRefValuePathPieceLayout::Code];
   XRefValuePathPieceLayout::emitRecord(Out, ScratchRecord, abbrCode,
                                        addTypeRef(ty),
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
index 08b5c75..5e60637 100644
--- a/lib/Serialization/SerializeSIL.cpp
+++ b/lib/Serialization/SerializeSIL.cpp
@@ -315,7 +315,7 @@
   FuncTable[Ctx.getIdentifier(F.getName())] = NextFuncID++;
   Funcs.push_back(Out.GetCurrentBitNo());
   unsigned abbrCode = SILAbbrCodes[SILFunctionLayout::Code];
-  TypeID FnID = S.addTypeRef(F.getLoweredType().getSwiftType());
+  TypeID FnID = S.addTypeRef(F.getLoweredType().getSwiftRValueType());
   DEBUG(llvm::dbgs() << "SILFunction " << F.getName() << " @ BitNo "
                      << Out.GetCurrentBitNo() << " abbrCode " << abbrCode
                      << " FnID " << FnID << "\n");
@@ -581,7 +581,7 @@
       break;
     }
     case ValueKind::InitExistentialOpaqueInst: {
-      auto &IEOI = cast<InitExistentialRefInst>(SI);
+      auto &IEOI = cast<InitExistentialOpaqueInst>(SI);
       operand = IEOI.getOperand();
       Ty = IEOI.getType();
       FormalConcreteType = IEOI.getFormalConcreteType();
@@ -1047,6 +1047,7 @@
   case ValueKind::DeallocStackInst:
   case ValueKind::DeallocRefInst:
   case ValueKind::DeinitExistentialAddrInst:
+  case ValueKind::DeinitExistentialOpaqueInst:
   case ValueKind::DestroyAddrInst:
   case ValueKind::IsNonnullInst:
   case ValueKind::LoadInst:
@@ -1785,7 +1786,7 @@
 void SILSerializer::writeSILGlobalVar(const SILGlobalVariable &g) {
   GlobalVarList[Ctx.getIdentifier(g.getName())] = NextGlobalVarID++;
   GlobalVarOffset.push_back(Out.GetCurrentBitNo());
-  TypeID TyID = S.addTypeRef(g.getLoweredType().getSwiftType());
+  TypeID TyID = S.addTypeRef(g.getLoweredType().getSwiftRValueType());
   DeclID dID = S.addDeclRef(g.getDecl());
   SILGlobalVarLayout::emitRecord(Out, ScratchRecord,
                                  SILAbbrCodes[SILGlobalVarLayout::Code],
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
index dc0d4ac..f193f73 100644
--- a/lib/Serialization/SerializedModuleLoader.cpp
+++ b/lib/Serialization/SerializedModuleLoader.cpp
@@ -96,7 +96,7 @@
   // FIXME: Which name should we be using here? Do we care about CPU subtypes?
   // FIXME: At the very least, don't hardcode "arch".
   llvm::SmallString<16> archFile{
-      ctx.LangOpts.getPlatformConditionValue("arch")};
+      ctx.LangOpts.getPlatformConditionValue(PlatformConditionKind::Arch)};
   llvm::SmallString<16> archDocFile{archFile};
   if (!archFile.empty()) {
     archFile += '.';
diff --git a/lib/Syntax/CMakeLists.txt b/lib/Syntax/CMakeLists.txt
index 6508584..1d20b1b 100644
--- a/lib/Syntax/CMakeLists.txt
+++ b/lib/Syntax/CMakeLists.txt
@@ -12,4 +12,5 @@
   SyntaxFactory.cpp
   SyntaxData.cpp
   TypeSyntax.cpp
+  UnknownSyntax.cpp
 )
diff --git a/lib/Syntax/DeclSyntax.cpp b/lib/Syntax/DeclSyntax.cpp
index f2fe755..c26d20e 100644
--- a/lib/Syntax/DeclSyntax.cpp
+++ b/lib/Syntax/DeclSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- DeclSyntax.cpp - Declaration Syntax Implementation -----*- C++ -*-===//
+//===--- DeclSyntax.cpp - Declaration Syntax Implementation ---------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -36,14 +36,16 @@
 UnknownDeclSyntaxData::UnknownDeclSyntaxData(RC<RawSyntax> Raw,
                                              const SyntaxData *Parent,
                                              CursorIndex IndexInParent)
-  : DeclSyntaxData(Raw, Parent, IndexInParent) {
-  assert(Raw->Kind == SyntaxKind::UnknownStmt);
+  : UnknownSyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Kind == SyntaxKind::UnknownDecl);
 }
 
 RC<UnknownDeclSyntaxData>
 UnknownDeclSyntaxData::make(RC<RawSyntax> Raw,
                             const SyntaxData *Parent,
                             CursorIndex IndexInParent) {
+  auto UnknownRaw = RawSyntax::make(SyntaxKind::UnknownDecl, Raw->Layout,
+                                    Raw->Presence);
   return RC<UnknownDeclSyntaxData> {
     new UnknownDeclSyntaxData {
       Raw, Parent, IndexInParent
@@ -55,7 +57,7 @@
 
 UnknownDeclSyntax::UnknownDeclSyntax(const RC<SyntaxData> Root,
                                      const UnknownDeclSyntaxData *Data)
-  : DeclSyntax(Root, Data) {}
+  : UnknownSyntax(Root, Data) {}
 
 #pragma mark - declaration-members Data
 
diff --git a/lib/Syntax/ExprSyntax.cpp b/lib/Syntax/ExprSyntax.cpp
index 9df2740..b7d8be9 100644
--- a/lib/Syntax/ExprSyntax.cpp
+++ b/lib/Syntax/ExprSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- ExprSyntax.cpp - Swift Expression Syntax Impl. ---------*- C++ -*-===//
+//===--- ExprSyntax.cpp - Swift Expression Syntax Impl. -------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Syntax/ExprSyntax.h"
+#include "swift/Syntax/GenericSyntax.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -41,7 +42,7 @@
 UnknownExprSyntaxData::UnknownExprSyntaxData(RC<RawSyntax> Raw,
                                              const SyntaxData *Parent,
                                              CursorIndex IndexInParent)
-  : ExprSyntaxData(Raw, Parent, IndexInParent) {
+  : UnknownSyntaxData(Raw, Parent, IndexInParent) {
   assert(Raw->Kind == SyntaxKind::UnknownExpr);
 }
 
@@ -49,9 +50,11 @@
 UnknownExprSyntaxData::make(RC<RawSyntax> Raw,
                             const SyntaxData *Parent,
                             CursorIndex IndexInParent) {
+  auto UnknownRaw = RawSyntax::make(SyntaxKind::UnknownExpr, Raw->Layout,
+                                    Raw->Presence);
   return RC<UnknownExprSyntaxData> {
     new UnknownExprSyntaxData {
-      Raw, Parent, IndexInParent
+      UnknownRaw, Parent, IndexInParent
     }
   };
 }
@@ -60,7 +63,7 @@
 
 UnknownExprSyntax::UnknownExprSyntax(const RC<SyntaxData> Root,
                                      const UnknownExprSyntaxData *Data)
-  : ExprSyntax(Root, Data) {}
+  : UnknownSyntax(Root, Data) {}
 
 #pragma mark - integer-literal-expression Data
 
@@ -97,7 +100,6 @@
   return make(Raw);
 }
 
-
 #pragma mark - integer-literal-expression API
 
 IntegerLiteralExprSyntax::
@@ -111,3 +113,428 @@
   return Data->replaceChild<IntegerLiteralExprSyntax>(NewDigits,
                                                       Cursor::Digits);
 }
+
+#pragma mark - symbolic-reference Data
+
+SymbolicReferenceExprSyntaxData::
+SymbolicReferenceExprSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent,
+                                CursorIndex IndexInParent)
+  : ExprSyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Layout.size() == 2);
+  syntax_assert_child_token(Raw,
+    SymbolicReferenceExprSyntax::Cursor::Identifier, tok::identifier);
+  syntax_assert_child_kind(Raw,
+    SymbolicReferenceExprSyntax::Cursor::GenericArgumentClause,
+    SyntaxKind::GenericArgumentClause);
+}
+
+RC<SymbolicReferenceExprSyntaxData>
+SymbolicReferenceExprSyntaxData::make(RC<RawSyntax> Raw,
+                                      const SyntaxData *Parent,
+     CursorIndex IndexInParent) {
+  return RC<SymbolicReferenceExprSyntaxData> {
+    new SymbolicReferenceExprSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<SymbolicReferenceExprSyntaxData>
+SymbolicReferenceExprSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::SymbolicReferenceExpr,
+    {
+      TokenSyntax::missingToken(tok::identifier, ""),
+      RawSyntax::missing(SyntaxKind::GenericArgumentClause),
+    },
+    SourcePresence::Present);
+  return make(Raw);
+}
+
+#pragma mark - symbolic-reference API
+
+SymbolicReferenceExprSyntax::
+SymbolicReferenceExprSyntax(const RC<SyntaxData> Root, const DataType *Data)
+  : ExprSyntax(Root, Data) {}
+
+RC<TokenSyntax> SymbolicReferenceExprSyntax::getIdentifier() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Identifier));
+}
+
+SymbolicReferenceExprSyntax SymbolicReferenceExprSyntax::
+withIdentifier(RC<TokenSyntax> NewIdentifier) const {
+  assert(NewIdentifier->getTokenKind() == tok::identifier);
+  return Data->replaceChild<SymbolicReferenceExprSyntax>(NewIdentifier,
+                                                         Cursor::Identifier);
+}
+
+llvm::Optional<GenericArgumentClauseSyntax>
+SymbolicReferenceExprSyntax::getGenericArgumentClause() const {
+  auto RawClause = getRaw()->getChild(Cursor::GenericArgumentClause);
+  if (RawClause->isMissing()) {
+    return llvm::None;
+  }
+
+  auto *MyData = getUnsafeData<SymbolicReferenceExprSyntax>();
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedGenericArgClause);
+  SyntaxData::realizeSyntaxNode<GenericArgumentClauseSyntax>(ChildPtr,
+                                                             RawClause, MyData,
+    cursorIndex(Cursor::GenericArgumentClause));
+
+  return llvm::Optional<GenericArgumentClauseSyntax> {
+    GenericArgumentClauseSyntax {
+      Root,
+      MyData->CachedGenericArgClause.get()
+    }
+  };
+}
+
+SymbolicReferenceExprSyntax SymbolicReferenceExprSyntax::
+withGenericArgumentClause(GenericArgumentClauseSyntax NewGenericArgs) const {
+  return Data->replaceChild<SymbolicReferenceExprSyntax>(
+    NewGenericArgs.getRaw(), Cursor::GenericArgumentClause);
+}
+
+#pragma mark - function-call-argument Data
+
+FunctionCallArgumentSyntaxData::
+FunctionCallArgumentSyntaxData(RC<RawSyntax> Raw,
+                               const SyntaxData *Parent,
+                               CursorIndex IndexInParent)
+  : SyntaxData(Raw, Parent, IndexInParent) {
+    syntax_assert_child_token(Raw, FunctionCallArgumentSyntax::Cursor::Label,
+                              tok::identifier);
+    syntax_assert_child_token_text(Raw,
+                                   FunctionCallArgumentSyntax::Cursor::Colon,
+                                   tok::colon, ":");
+    assert(
+      Raw->getChild(FunctionCallArgumentSyntax::Cursor::Expression)->isExpr());
+
+    syntax_assert_child_token_text(Raw,
+                                   FunctionCallArgumentSyntax::Cursor::Comma,
+                                   tok::comma, ",");
+}
+
+RC<FunctionCallArgumentSyntaxData>
+FunctionCallArgumentSyntaxData::make(RC<RawSyntax> Raw,
+                                     const SyntaxData *Parent,
+                                     CursorIndex IndexInParent) {
+  return RC<FunctionCallArgumentSyntaxData> {
+    new FunctionCallArgumentSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<FunctionCallArgumentSyntaxData> FunctionCallArgumentSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionCallArgument,
+                             {
+                               TokenSyntax::missingToken(tok::identifier, ""),
+                               TokenSyntax::missingToken(tok::colon, ":"),
+                               RawSyntax::missing(SyntaxKind::MissingExpr),
+                               TokenSyntax::missingToken(tok::comma, ",")
+                             },
+                             SourcePresence::Present);
+  return make(Raw);
+}
+
+#pragma mark - function-call-argument API
+
+FunctionCallArgumentSyntax::
+FunctionCallArgumentSyntax(const RC<SyntaxData> Root, const DataType *Data)
+  : Syntax(Root, Data) {}
+
+RC<TokenSyntax> FunctionCallArgumentSyntax::getLabel() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Label));
+}
+
+FunctionCallArgumentSyntax
+FunctionCallArgumentSyntax::withLabel(RC<TokenSyntax> NewLabel) const {
+  assert(NewLabel->getTokenKind() == tok::identifier);
+  return Data->replaceChild<FunctionCallArgumentSyntax>(NewLabel,
+                                                        Cursor::Label);
+}
+
+RC<TokenSyntax> FunctionCallArgumentSyntax::getColonToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Colon));
+}
+
+FunctionCallArgumentSyntax
+FunctionCallArgumentSyntax::withColonToken(RC<TokenSyntax> NewColon) const {
+  syntax_assert_token_is(NewColon, tok::colon, ":");
+  return Data->replaceChild<FunctionCallArgumentSyntax>(NewColon,
+                                                        Cursor::Colon);
+}
+
+llvm::Optional<ExprSyntax> FunctionCallArgumentSyntax::getExpression() const {
+
+  auto RawExpression = getRaw()->getChild(Cursor::Expression);
+  if (RawExpression->isMissing()) {
+    return llvm::None;
+  }
+
+  auto *MyData = getUnsafeData<FunctionCallArgumentSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedExpression);
+
+  SyntaxData::realizeSyntaxNode<ExprSyntax>(ChildPtr, RawExpression, MyData,
+                                            cursorIndex(Cursor::Expression));
+  
+  return ExprSyntax { Root, MyData->CachedExpression.get() };
+}
+
+FunctionCallArgumentSyntax
+FunctionCallArgumentSyntax::withExpression(ExprSyntax NewExpression) const {
+  return Data->replaceChild<FunctionCallArgumentSyntax>(NewExpression.getRaw(),
+                                                        Cursor::Expression);
+}
+
+RC<TokenSyntax> FunctionCallArgumentSyntax::getTrailingComma() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Comma));
+}
+
+FunctionCallArgumentSyntax FunctionCallArgumentSyntax::
+withTrailingComma(RC<TokenSyntax> NewTrailingComma) const {
+  syntax_assert_token_is(NewTrailingComma, tok::comma, ",");
+  return Data->replaceChild<FunctionCallArgumentSyntax>(NewTrailingComma,
+    FunctionCallArgumentSyntax::Cursor::Comma);
+}
+
+#pragma mark - function-call-argument-list Data
+
+FunctionCallArgumentListSyntaxData::
+FunctionCallArgumentListSyntaxData(const RC<RawSyntax> Raw,
+                                   const SyntaxData *Parent,
+                                   CursorIndex IndexInParent)
+  : SyntaxData(Raw, Parent, IndexInParent) {
+#ifndef NDEBUG
+  for (auto Child : Raw->Layout) {
+    assert(Child->Kind == SyntaxKind::FunctionCallArgument);
+  }
+#endif
+  for (size_t i = 0; i < Raw->Layout.size(); ++i) {
+    CachedArguments.emplace_back(nullptr);
+  }
+}
+
+RC<FunctionCallArgumentListSyntaxData>
+FunctionCallArgumentListSyntaxData::make(RC<RawSyntax> Raw,
+                                         const SyntaxData *Parent,
+                                         CursorIndex IndexInParent) {
+  return RC<FunctionCallArgumentListSyntaxData> {
+    new FunctionCallArgumentListSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<FunctionCallArgumentListSyntaxData>
+FunctionCallArgumentListSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionCallArgumentList, {},
+                             SourcePresence::Present);
+  return make(Raw);
+}
+
+#pragma mark - function-call-argument-list API
+
+FunctionCallArgumentListSyntax::
+FunctionCallArgumentListSyntax(const RC<SyntaxData> Root,
+                               const DataType *Data)
+  : Syntax(Root, Data) {}
+
+size_t
+FunctionCallArgumentListSyntax::getNumArguments() const {
+  return getRaw()->Layout.size();
+}
+
+FunctionCallArgumentSyntax
+FunctionCallArgumentListSyntax::getArgument(size_t Index) const {
+  assert(Index <= getRaw()->Layout.size());
+
+  auto RawArg = getRaw()->Layout[Index];
+
+  auto *MyData = getUnsafeData<FunctionCallArgumentListSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    MyData->CachedArguments.data() + Index);
+
+  SyntaxData::realizeSyntaxNode<FunctionCallArgumentSyntax>(ChildPtr, RawArg,
+                                                            MyData,
+                                                            Index);
+
+  return FunctionCallArgumentSyntax {
+    Root,
+    MyData->CachedArguments[Index].get()
+  };
+}
+
+FunctionCallArgumentListSyntax
+FunctionCallArgumentListSyntax::withAdditionalArgument(
+  FunctionCallArgumentSyntax AdditionalArgument) const {
+  auto NewRaw = getRaw()->append(AdditionalArgument.getRaw());
+  return Data->replaceSelf<FunctionCallArgumentListSyntax>(NewRaw);
+}
+
+#pragma mark - function-call-expression Data
+
+RC<FunctionCallArgumentListSyntaxData> CachedArgumentList;
+
+FunctionCallExprSyntaxData::FunctionCallExprSyntaxData(RC<RawSyntax> Raw,
+                           const SyntaxData *Parent,
+                           CursorIndex IndexInParent)
+    : ExprSyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Layout.size() == 4);
+  assert(Raw->getChild(FunctionCallExprSyntax::Cursor::CalledExpression)
+           ->isExpr());
+  syntax_assert_child_token_text(Raw, FunctionCallExprSyntax::Cursor::LeftParen,
+                                 tok::l_paren, "(");
+  syntax_assert_child_kind(Raw, FunctionCallExprSyntax::Cursor::ArgumentList,
+                           SyntaxKind::FunctionCallArgumentList);
+  syntax_assert_child_token_text(Raw,
+                                 FunctionCallExprSyntax::Cursor::RightParen,
+                                 tok::r_paren, ")");
+}
+
+RC<FunctionCallExprSyntaxData>
+FunctionCallExprSyntaxData::make(RC<RawSyntax> Raw, const SyntaxData *Parent,
+                                 CursorIndex IndexInParent) {
+  return RC<FunctionCallExprSyntaxData> {
+    new FunctionCallExprSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<FunctionCallExprSyntaxData> FunctionCallExprSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionCallExpr,
+  {
+    RawSyntax::missing(SyntaxKind::MissingExpr),
+    TokenSyntax::missingToken(tok::l_paren, "("),
+    RawSyntax::missing(SyntaxKind::FunctionCallArgumentList),
+    TokenSyntax::missingToken(tok::r_paren, ")"),
+  },
+  SourcePresence::Present);
+  return make(Raw);
+}
+
+
+#pragma mark - function-call-expression API
+
+FunctionCallExprSyntax::FunctionCallExprSyntax(const RC<SyntaxData> Root,
+                                               const DataType *Data)
+  : ExprSyntax(Root, Data) {}
+
+ExprSyntax FunctionCallExprSyntax::getCalledExpression() const {
+  auto RawArg = getRaw()->getChild(Cursor::CalledExpression);
+
+  auto *MyData = getUnsafeData<FunctionCallExprSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedCalledExpression);
+
+  SyntaxData::realizeSyntaxNode<ExprSyntax>(
+    ChildPtr, RawArg, MyData, cursorIndex(Cursor::CalledExpression));
+
+  return ExprSyntax {
+    Root,
+    MyData->CachedCalledExpression.get(),
+  };
+}
+
+FunctionCallExprSyntax FunctionCallExprSyntax::
+withCalledExpression(ExprSyntax NewBaseExpression) const {
+  return Data->replaceChild<FunctionCallExprSyntax>(NewBaseExpression.getRaw(),
+                                                    Cursor::CalledExpression);
+}
+
+RC<TokenSyntax> FunctionCallExprSyntax::getLeftParen() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::LeftParen));
+}
+
+FunctionCallExprSyntax
+FunctionCallExprSyntax::withLeftParen(RC<TokenSyntax> NewLeftParen) const {
+  syntax_assert_token_is(NewLeftParen, tok::l_paren, "(");
+  return Data->replaceChild<FunctionCallExprSyntax>(NewLeftParen,
+                                                    Cursor::LeftParen);
+}
+
+FunctionCallArgumentListSyntax FunctionCallExprSyntax::getArgumentList() const {
+  auto RawArg = getRaw()->getChild(Cursor::ArgumentList);
+
+  auto *MyData = getUnsafeData<FunctionCallExprSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedArgumentList);
+
+  SyntaxData::realizeSyntaxNode<FunctionCallArgumentListSyntax>(
+    ChildPtr, RawArg, MyData, cursorIndex(Cursor::ArgumentList));
+  
+  return FunctionCallArgumentListSyntax {
+    Root,
+    MyData->CachedArgumentList.get(),
+  };
+}
+
+FunctionCallExprSyntax FunctionCallExprSyntax::
+withArgumentList(FunctionCallArgumentListSyntax NewArgumentList) const {
+  return Data->replaceChild<FunctionCallExprSyntax>(NewArgumentList.getRaw(),
+                                                    Cursor::ArgumentList);
+}
+
+RC<TokenSyntax> FunctionCallExprSyntax::getRightParen() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::RightParen));
+}
+
+FunctionCallExprSyntax
+FunctionCallExprSyntax::withRightParen(RC<TokenSyntax> NewRightParen) const {
+  syntax_assert_token_is(NewRightParen, tok::r_paren, ")");
+  return Data->replaceChild<FunctionCallExprSyntax>(NewRightParen,
+                                                    Cursor::RightParen);
+}
+
+#pragma mark - function-call-expression Builder
+
+FunctionCallExprSyntaxBuilder::FunctionCallExprSyntaxBuilder()
+  : CallLayout(FunctionCallExprSyntaxData::makeBlank()->getRaw()->Layout),
+    ListLayout(
+      FunctionCallArgumentListSyntaxData::makeBlank()->getRaw()->Layout) {}
+
+FunctionCallExprSyntaxBuilder &
+FunctionCallExprSyntaxBuilder::useLeftParen(RC<TokenSyntax> LeftParen) {
+  syntax_assert_token_is(LeftParen, tok::l_paren, "(");
+  CallLayout[cursorIndex(FunctionCallExprSyntax::Cursor::LeftParen)]
+    = LeftParen;
+  return *this;
+}
+
+FunctionCallExprSyntaxBuilder &FunctionCallExprSyntaxBuilder::
+appendArgument(FunctionCallArgumentSyntax AdditionalArgument) {
+  ListLayout.push_back(AdditionalArgument.getRaw());
+  return *this;
+}
+
+FunctionCallExprSyntaxBuilder &FunctionCallExprSyntaxBuilder::
+useCalledExpression(ExprSyntax CalledExpression) {
+  CallLayout[cursorIndex(FunctionCallExprSyntax::Cursor::CalledExpression)]
+    = CalledExpression.getRaw();
+  return *this;
+}
+
+FunctionCallExprSyntaxBuilder &
+FunctionCallExprSyntaxBuilder::useRightParen(RC<TokenSyntax> RightParen) {
+  syntax_assert_token_is(RightParen, tok::r_paren, ")");
+  CallLayout[cursorIndex(FunctionCallExprSyntax::Cursor::RightParen)]
+    = RightParen;
+  return *this;
+}
+
+FunctionCallExprSyntax FunctionCallExprSyntaxBuilder::build() const {
+  auto RawArgs = RawSyntax::make(SyntaxKind::FunctionCallArgumentList,
+                                 ListLayout, SourcePresence::Present);
+  auto RawCall = RawSyntax::make(SyntaxKind::FunctionCallExpr, CallLayout,
+                                 SourcePresence::Present)
+    ->replaceChild(FunctionCallExprSyntax::Cursor::ArgumentList, RawArgs);
+  auto Data = FunctionCallExprSyntaxData::make(RawCall);
+  return { Data, Data.get() };
+}
diff --git a/lib/Syntax/Format.cpp b/lib/Syntax/Format.cpp
index 94433ac..1da34c7 100644
--- a/lib/Syntax/Format.cpp
+++ b/lib/Syntax/Format.cpp
@@ -1,4 +1,4 @@
-//===--- Format.cpp - Declaration Syntax Formatting Impl. -------*- C++ -*-===//
+//===--- Format.cpp - Declaration Syntax Formatting Impl. -----------------===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/Syntax/GenericSyntax.cpp b/lib/Syntax/GenericSyntax.cpp
index 84ca22e..e48e33a 100644
--- a/lib/Syntax/GenericSyntax.cpp
+++ b/lib/Syntax/GenericSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- GenericSyntax.cpp - Swift Generic Syntax Implementation *- C++ -*-===//
+//===--- GenericSyntax.cpp - Swift Generic Syntax Implementation ----------===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/Syntax/LegacyASTTransformer.cpp b/lib/Syntax/LegacyASTTransformer.cpp
index f6c4edd..4356df0 100644
--- a/lib/Syntax/LegacyASTTransformer.cpp
+++ b/lib/Syntax/LegacyASTTransformer.cpp
@@ -1,4 +1,4 @@
-//===--- LegacyASTTransformer.cpp - Swift lib/AST -> lib/Syntax -*- C++ -*-===//
+//===--- LegacyASTTransformer.cpp - Swift lib/AST -> lib/Syntax -----------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -19,6 +19,7 @@
 #include "swift/Syntax/StmtSyntax.h"
 #include "swift/Syntax/SyntaxFactory.h"
 #include "swift/Syntax/TokenSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -500,7 +501,7 @@
 RC<SyntaxData>
 LegacyASTTransformer::visitWhileStmt(WhileStmt *S,
                                      const SyntaxData *Parent,
-                                     const CursorIndex IndexInParent) {
+                                     const CursorIndex IndexInParent) { 
   return getUnknownStmt(S);
 }
 
diff --git a/lib/Syntax/RawSyntax.cpp b/lib/Syntax/RawSyntax.cpp
index 1d37ee8..30d5508 100644
--- a/lib/Syntax/RawSyntax.cpp
+++ b/lib/Syntax/RawSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- RawSyntax.cpp - Swift Raw Syntax Implementation --------*- C++ -*-===//
+//===--- RawSyntax.cpp - Swift Raw Syntax Implementation ------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/Syntax/Status.md b/lib/Syntax/Status.md
index 97fba0c..1c8a324 100644
--- a/lib/Syntax/Status.md
+++ b/lib/Syntax/Status.md
@@ -72,6 +72,16 @@
 - octal-literal
   - `IntegerLiteralExprSyntax`
 
+- function-call-argument
+  - `FunctionCallArgumentSyntax`
+
+- function-call-argument-list
+  - `FunctionCallArgumentListSyntax`
+
+- function-call-expression
+- function-call-argument-clause
+  - `FunctionCallExprSyntax`
+
 ### Types
 
 - type
@@ -105,6 +115,15 @@
 - metatype-type
   - `MetatypeTypeSyntax`
 
+- tuple-type
+  - `TupleTypeSyntax`
+
+- tuple-type-element
+  - `TupleTypeElementSyntax`
+
+- tuple-type-element-list
+  - `TupleTypeElementListSyntax`
+
 ### Type Attributes
 
 - attribute
@@ -181,165 +200,163 @@
 
 ## Unrepresented Grammar Productions
 
-- argument-names
+These are categorized somewhat by difficulty and priority.
+
+### Easy
+
 - array-literal
 - array-literal-items
 - as-pattern
-- availability-argument
-- availability-arguments
-- availability-condition
-- binary-expression
-- binary-expressions
-- binary-operator
-- branch-statement
-- capture-list
-- capture-list-item
-- capture-list-items
-- capture-specifier
 - case-condition
-- case-item-list
 - case-label
-- catch-clause
-- catch-clauses
-- class-declaration
-- closure-expression
-- closure-parameter
-- closure-parameter-clause
-- closure-parameter-list
-- closure-signature
-- compilation-condition
-- compiler-control-statement
-- condition
-- condition-list
-- conditional-compilation-block
-- conditional-operator
-- constant-declaration
-- declaration-modifier
 - declaration-modifiers
-- defer-statement
-- deinitializer-declaration
-- dictionary-literal
-- dictionary-literal-item
-- dictionary-literal-items
-- didSet-clause
-- do-statement
+  - declaration-modifier
 - dynamic-type-expression
-- else-clause
-- else-directive-clause
-- elseif-directive-clause
-- elseif-directive-clauses
-- enum-case-pattern
-- enum-declaration
-- explicit-member-expression
-- expression-list
-- expression-pattern
-- extension-declaration
-- extension-members
 - floating-point-literal
-- for-in-statement
 - forced-value-expression
-- function-body
-- function-call-argument
-- function-call-argument-clause
-- function-call-argument-list
-- function-call-expression
-- function-declaration
-- function-result
-- function-signature
-- getter-clause
-- getter-keyword-clause
-- getter-setter-block
-- getter-setter-keyword-block
-- guard-statement
 - identifier-list
-- if-directive-clause
-- if-statement
 - implicit-member-expression
-- import-declaration
 - import-path
 - in-out-expression
-- infix-operator-declaration
-- infix-operator-group
-- initializer-declaration
-- initializer-head
-- interpolated-string-literal
 - interpolated-text
 - interpolated-text-item
 - is-pattern
 - key-path-expression
 - line-control-statement
-- operator-declaration
-- optional-binding-condition
 - optional-chaining-expression
 - optional-pattern
-- parameter
-- parameter-clause
-- parameter-list
 - parenthesized-expression
-- pattern
-- pattern-initializer
-- pattern-initializer-list
 - platform-condition
 - platform-version
-- playground-literal
 - postfix-operator-declaration
 - precedence-group-assignment
 - precedence-group-associativity
-- precedence-group-attribute
-- precedence-group-attributes
-- precedence-group-declaration
 - precedence-group-names
-- precedence-group-relation
-- prefix-expression
-- prefix-operator
-- prefix-operator-declaration
-- primary-expression
-- protocol-associated-type-declaration
-- protocol-composition-type
-- protocol-declaration
-- repeat-while-statement
-- selector-expression
-- setter-clause
-- setter-keyword-clause
-- setter-name
 - statement-label
 - static-string-literal
-- string-literal
-- subscript-declaration
 - swift-version
-- switch-case
-- switch-cases
-- switch-statement
 - throw-statement
-- tuple-element
-- tuple-element-list
-- tuple-expression
-- tuple-pattern
-- tuple-pattern-element
-- tuple-pattern-element-list
-- tuple-type
-- tuple-type-element
-- tuple-type-element-list
-- type-casting-operator
-- type-casting-pattern
 - value-binding-pattern
-- variable-declaration
 - where-clause
-- where-expression
+- dictionary-literal
+  - dictionary-literal-items
+    - dictionary-literal-item
+- capture-list
+    - capture-list-items
+      - capture-list-item
+- defer-statement
+
+### Medium
+
+- else-directive-clause
+- elseif-directive-clauses
+  - elseif-directive-clause
+- precedence-group-declaration
+- precedence-group-relation
+- expression-list
+- availability-condition
+  - availability-arguments
+    - availability-argument
+- switch-cases
+  - switch-case
+- constant-declaration
+- catch-clauses
+  - catch-clause
+- variable-declaration
+- do-statement
+- for-in-statement
+- guard-statement
+- case-item-list
+- import-declaration
+- if-directive-clause
+- if-statement
+  - else-clause
+- protocol-associated-type-declaration
+- repeat-while-statement
 - while-statement
+- tuple-expression
+  - tuple-element-list
+    - tuple-element
+- tuple-pattern
+  - tuple-pattern-element-list
+    - tuple-pattern-element
+- switch-statement
+- explicit-member-expression
+- optional-binding-condition
+- operator-declaration
+- selector-expression
+- protocol-composition-type
+- conditional-operator
+- deinitializer-declaration
+- didSet-clause
 - willSet-clause
-- willSet-didSet-block
+- pattern-initializer-list
+  - pattern-initializer
+- prefix-expression
+- prefix-operator-declaration
+- infix-operator-declaration
+  - infix-operator-group
+- binary-expression
+
+### Hard
+
+- protocol-declaration
+- closure-expression
+  - closure-signature
+    - closure-parameter-clause
+      - closure-parameter-list
+        - closure-parameter
+- extension-declaration
+- enum-declaration
+- class-declaration
+- getter-setter-block
+  - getter-setter-keyword-block
+  - getter-keyword-clause
+    - getter-clause
+  - setter-keyword-clause
+    - setter-clause
+      - setter-name
+- subscript-declaration
+- function-declaration
+  - function-body
+  - function-result
+  - function-signature
+    - parameter-clause
+      - parameter-list
+        - parameter
+- enum-case-pattern
+- initializer-declaration
+  - initializer-head
+- interpolated-string-literal
+- conditional-compilation-block
 
 ## Trivial and Intermediate Grammar Productions
 
+- binary-expressions
+- binary-operator
+- compilation-condition
+- capture-specifier
+- precedence-group-attributes
+- precedence-group-attribute
+- prefix-operator
+- type-casting-operator
+- willSet-didSet-block
 - architecture
+- string-literal
+- argument-names
 - array-literal-item
+- type-casting-pattern
 - assignment-operator
+- expression-pattern
 - binary-digit
 - binary-literal-character
 - binary-literal-characters
+- branch-statement
 - class-member
 - class-requirement
+- condition
+- condition-list
+- compiler-control-statement
 - control-transfer-statement
 - decimal-digit
 - decimal-digits
@@ -369,6 +386,7 @@
 - identifier-characters
 - identifier-head
 - if-directive
+- where-expression
 - implicit-parameter-name
 - initializer
 - initializer-body
@@ -388,6 +406,7 @@
 - operator-character
 - operator-characters
 - operator-head
+- pattern
 - postfix-expression
 - postfix-operator
 - postfix-self-expression
@@ -396,6 +415,7 @@
 - protocol-member
 - protocol-member-declaration
 - protocol-members
+- extension-members
 - protocol-method-declaration
 - protocol-property-declaration
 - protocol-subscript-declaration
@@ -407,6 +427,7 @@
 - raw-value-style-enum-case
 - raw-value-style-enum-case-clause
 - raw-value-style-enum-case-list
+- playground-literal
 - raw-value-style-enum-member
 - raw-value-style-enum-members
 - requirement
@@ -436,9 +457,5 @@
 - variable-declaration-head
 - wildcard-expression
 - wildcard-pattern
-
-## Intermediate Grammar Productions
-
-These productions don't need to be represented directly in a class hierarchy.
-
+- primary-expression
 - generic-argument
diff --git a/lib/Syntax/StmtSyntax.cpp b/lib/Syntax/StmtSyntax.cpp
index 7f32017..89b272c 100644
--- a/lib/Syntax/StmtSyntax.cpp
+++ b/lib/Syntax/StmtSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- StmtSyntax.cpp - Swift Statement Syntax Implementation -*- C++ -*-===//
+//===--- StmtSyntax.cpp - Swift Statement Syntax Implementation -----------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -27,7 +27,7 @@
 UnknownStmtSyntaxData::UnknownStmtSyntaxData(RC<RawSyntax> Raw,
                                              const SyntaxData *Parent,
                                              CursorIndex IndexInParent)
-  : StmtSyntaxData(Raw, Parent, IndexInParent) {
+  : UnknownSyntaxData(Raw, Parent, IndexInParent) {
   assert(Raw->Kind == SyntaxKind::UnknownStmt);
 }
 
@@ -35,9 +35,11 @@
 UnknownStmtSyntaxData::make(RC<RawSyntax> Raw,
                             const SyntaxData *Parent,
                             CursorIndex IndexInParent) {
+  auto UnknownRaw = RawSyntax::make(SyntaxKind::UnknownStmt, Raw->Layout,
+                                    Raw->Presence);
   return RC<UnknownStmtSyntaxData> {
     new UnknownStmtSyntaxData {
-      Raw, Parent, IndexInParent
+      UnknownRaw, Parent, IndexInParent
     }
   };
 }
@@ -46,7 +48,7 @@
 
 UnknownStmtSyntax::UnknownStmtSyntax(const RC<SyntaxData> Root,
                                      const UnknownStmtSyntaxData *Data)
-  : StmtSyntax(Root, Data) {}
+  : UnknownSyntax(Root, Data) {}
 
 #pragma mark fallthrough-statement Data
 
diff --git a/lib/Syntax/Syntax.cpp b/lib/Syntax/Syntax.cpp
index 0d7cc30..bd4d914 100644
--- a/lib/Syntax/Syntax.cpp
+++ b/lib/Syntax/Syntax.cpp
@@ -1,4 +1,4 @@
-//===--- Syntax.cpp - Swift Syntax Implementation ---------------*- C++ -*-===//
+//===--- Syntax.cpp - Swift Syntax Implementation -------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -55,16 +55,7 @@
   return Data->isExpr();
 }
 
-#pragma mark - unknown-syntax API
-
-UnknownSyntax::UnknownSyntax(const RC<SyntaxData> Root,
-                             UnknownSyntaxData *Data)
-  : Syntax(Root, Data) {}
-
-UnknownSyntax UnknownSyntax::make(RC<RawSyntax> Raw) {
-  auto Data = UnknownSyntaxData::make(Raw);
-  return UnknownSyntax {
-    Data, Data.get()
-  };
+bool Syntax::isUnknown() const {
+  return Data->isUnknown();
 }
 
diff --git a/lib/Syntax/SyntaxData.cpp b/lib/Syntax/SyntaxData.cpp
index 56ecd4b..bc21dbf 100644
--- a/lib/Syntax/SyntaxData.cpp
+++ b/lib/Syntax/SyntaxData.cpp
@@ -1,4 +1,4 @@
-//===--- SyntaxData.cpp - Swift Syntax Data Implementation ------*- C++ -*-===//
+//===--- SyntaxData.cpp - Swift Syntax Data Implementation ----------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -15,6 +15,7 @@
 #include "swift/Syntax/GenericSyntax.h"
 #include "swift/Syntax/TypeSyntax.h"
 #include "swift/Syntax/StmtSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -61,21 +62,10 @@
   return Raw->isExpr();
 }
 
+bool SyntaxData::isUnknown() const {
+  return Raw->isUnknown();
+}
+
 void SyntaxData::dump(llvm::raw_ostream &OS) const {
   Raw->dump(OS, 0);
 }
-
-#pragma mark - unknown-syntax Data
-
-RC<UnknownSyntaxData> UnknownSyntaxData::make(RC<RawSyntax> Raw,
-                                              const SyntaxData *Parent,
-                                              CursorIndex IndexInParent) {
-  return RC<UnknownSyntaxData> {
-    new UnknownSyntaxData { Raw, Parent, IndexInParent }
-  };
-}
-
-bool UnknownSyntaxData::classof(const SyntaxData *SD) {
-  return SD->getKind() == SyntaxKind::Unknown;
-}
-
diff --git a/lib/Syntax/SyntaxFactory.cpp b/lib/Syntax/SyntaxFactory.cpp
index be37ef9..cd495f2 100644
--- a/lib/Syntax/SyntaxFactory.cpp
+++ b/lib/Syntax/SyntaxFactory.cpp
@@ -1,4 +1,4 @@
-//===--- SyntaxFactory.cpp - Swift Syntax Builder Implementation *- C++ -*-===//
+//===--- SyntaxFactory.cpp - Swift Syntax Builder Implementation ----------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -18,6 +18,7 @@
 #include "swift/Syntax/Syntax.h"
 #include "swift/Syntax/SyntaxFactory.h"
 #include "swift/Syntax/TokenSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -324,6 +325,8 @@
 
 #pragma mark - Expressions
 
+#pragma mark - integer-literal-expression
+
 IntegerLiteralExprSyntax
 SyntaxFactory::makeIntegerLiteralExpr(RC<TokenSyntax> Sign,
                                       RC<TokenSyntax> Digits) {
@@ -348,6 +351,101 @@
   return { Data, Data.get() };
 }
 
+#pragma mark - symbolic-reference
+
+SymbolicReferenceExprSyntax
+SyntaxFactory::makeSymbolicReferenceExpr(RC<TokenSyntax> Identifier,
+  llvm::Optional<GenericArgumentClauseSyntax> GenericArgs) {
+  auto Raw = RawSyntax::make(SyntaxKind::SymbolicReferenceExpr,
+    {
+      Identifier,
+      GenericArgs.hasValue()
+        ? GenericArgs.getValue().getRaw()
+        : RawSyntax::missing(SyntaxKind::GenericArgumentClause)
+    },
+    SourcePresence::Present);
+  auto Data = SymbolicReferenceExprSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+SymbolicReferenceExprSyntax SyntaxFactory::makeBlankSymbolicReferenceExpr() {
+  auto Data = SymbolicReferenceExprSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
+#pragma mark - function-call-argument
+
+FunctionCallArgumentSyntax SyntaxFactory::makeBlankFunctionCallArgument() {
+  auto Data = FunctionCallArgumentSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
+FunctionCallArgumentSyntax
+SyntaxFactory::makeFunctionCallArgument(RC<TokenSyntax> Label,
+                                        RC<TokenSyntax> Colon,
+                                        ExprSyntax ExpressionArgument,
+                                        RC<TokenSyntax> TrailingComma) {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionCallArgument,
+                             {
+                               Label,
+                               Colon,
+                               ExpressionArgument.getRaw(),
+                               TrailingComma
+                             },
+                             SourcePresence::Present);
+  auto Data = FunctionCallArgumentSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+#pragma mark - function-call-argument-list
+
+/// Make a function call argument list with the given arguments.
+FunctionCallArgumentListSyntax
+SyntaxFactory::makeFunctionCallArgumentList(
+  std::vector<FunctionCallArgumentSyntax> Arguments) {
+  RawSyntax::LayoutList Layout;
+  for (const auto &Arg : Arguments) {
+    Layout.push_back(Arg.getRaw());
+  }
+
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionCallArgumentList, Layout,
+                             SourcePresence::Present);
+  auto Data = FunctionCallArgumentListSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+
+FunctionCallArgumentListSyntax
+SyntaxFactory::makeBlankFunctionCallArgumentList() {
+  auto Data = FunctionCallArgumentListSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
+#pragma mark - function-call-expression
+
+FunctionCallExprSyntax
+SyntaxFactory::makeFunctionCallExpr(ExprSyntax CalledExpr,
+                                    RC<TokenSyntax> LeftParen,
+                                    FunctionCallArgumentListSyntax Arguments,
+                                    RC<TokenSyntax> RightParen) {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionCallExpr,
+                             {
+                               CalledExpr.getRaw(),
+                               LeftParen,
+                               Arguments.getRaw(),
+                               RightParen
+                             },
+                             SourcePresence::Present);
+  auto Data = FunctionCallExprSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+
+FunctionCallExprSyntax SyntaxFactory::makeBlankFunctionCallExpr() {
+  auto Data = FunctionCallExprSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
 
 #pragma mark - Tokens
 
@@ -771,16 +869,7 @@
 }
 
 TypeAttributeSyntax SyntaxFactory::makeBlankTypeAttribute() {
-  auto Raw = RawSyntax::make(SyntaxKind::TypeAttribute,
-                             {
-                               TokenSyntax::missingToken(tok::at_sign, "@"),
-                               TokenSyntax::missingToken(tok::identifier, ""),
-                               TokenSyntax::missingToken(tok::l_paren, "("),
-                               RawSyntax::missing(SyntaxKind::BalancedTokens),
-                               TokenSyntax::missingToken(tok::r_paren, ")"),
-                             },
-                             SourcePresence::Present);
-  auto Data = TypeAttributeSyntaxData::make(Raw);
+  auto Data = TypeAttributeSyntaxData::makeBlank();
   return TypeAttributeSyntax { Data, Data.get() };
 }
 
@@ -798,10 +887,7 @@
 }
 
 BalancedTokensSyntax SyntaxFactory::makeBlankBalancedTokens() {
-  auto Raw = RawSyntax::make(SyntaxKind::BalancedTokens,
-                             {},
-                             SourcePresence::Present);
-  auto Data = BalancedTokensSyntaxData::make(Raw);
+  auto Data = BalancedTokensSyntaxData::makeBlank();
   return BalancedTokensSyntax { Data, Data.get() };
 }
 
diff --git a/lib/Syntax/TokenSyntax.cpp b/lib/Syntax/TokenSyntax.cpp
index 297fb34..2212236 100644
--- a/lib/Syntax/TokenSyntax.cpp
+++ b/lib/Syntax/TokenSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- TokenSyntax.cpp - Swift Token Syntax Implementation ----*- C++ -*-===//
+//===--- TokenSyntax.cpp - Swift Token Syntax Implementation --------------===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/Syntax/Trivia.cpp b/lib/Syntax/Trivia.cpp
index ce1008c..f57738e 100644
--- a/lib/Syntax/Trivia.cpp
+++ b/lib/Syntax/Trivia.cpp
@@ -1,4 +1,4 @@
-//===--- Syntax.cpp - Swift Syntax Trivia Implementation --------*- C++ -*-===//
+//===--- Trivia.cpp - Swift Syntax Trivia Implementation ------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/Syntax/TypeSyntax.cpp b/lib/Syntax/TypeSyntax.cpp
index 5b9d158..d36ecae 100644
--- a/lib/Syntax/TypeSyntax.cpp
+++ b/lib/Syntax/TypeSyntax.cpp
@@ -1,4 +1,4 @@
-//===--- TypeSyntax.cpp - Swift Type Syntax Implementation ------*- C++ -*-===//
+//===--- TypeSyntax.cpp - Swift Type Syntax Implementation ----------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -118,6 +118,19 @@
   };
 }
 
+RC<TypeAttributeSyntaxData> TypeAttributeSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::TypeAttribute,
+                             {
+                               TokenSyntax::missingToken(tok::at_sign, "@"),
+                               TokenSyntax::missingToken(tok::identifier, ""),
+                               TokenSyntax::missingToken(tok::l_paren, "("),
+                               RawSyntax::missing(SyntaxKind::BalancedTokens),
+                               TokenSyntax::missingToken(tok::r_paren, ")"),
+                             },
+                             SourcePresence::Present);
+  return make(Raw);
+}
+
 #pragma mark - type-attribute API
 
 TypeAttributeSyntax::TypeAttributeSyntax(RC<SyntaxData> Root,
diff --git a/lib/Syntax/UnknownSyntax.cpp b/lib/Syntax/UnknownSyntax.cpp
new file mode 100644
index 0000000..6533926
--- /dev/null
+++ b/lib/Syntax/UnknownSyntax.cpp
@@ -0,0 +1,99 @@
+//===--- UnknownSyntax.cpp - Swift Unknown  Syntax Implementation ---------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Syntax/TokenSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
+
+using namespace swift;
+using namespace swift::syntax;
+
+#pragma mark - unknown-syntax Data
+
+UnknownSyntaxData::UnknownSyntaxData(const RC<RawSyntax> Raw,
+                                     const SyntaxData *Parent,
+                                     const CursorIndex IndexInParent)
+    : SyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->isUnknown());
+  for (auto RawChild : Raw->Layout) {
+    if (!RawChild->isToken()) {
+      CachedChildren.emplace_back(nullptr);
+    }
+  }
+}
+
+RC<UnknownSyntaxData> UnknownSyntaxData::make(RC<RawSyntax> Raw,
+                                              const SyntaxData *Parent,
+                                              CursorIndex IndexInParent) {
+
+  auto UnknownRaw = RawSyntax::make(SyntaxKind::Unknown, Raw->Layout,
+                                    Raw->Presence);
+
+  return RC<UnknownSyntaxData> {
+    new UnknownSyntaxData { UnknownRaw, Parent, IndexInParent }
+  };
+}
+
+#pragma mark - unknown-syntax API
+
+UnknownSyntax::UnknownSyntax(const RC<SyntaxData> Root,
+                             const UnknownSyntaxData *Data)
+  : Syntax(Root, Data) {}
+
+size_t UnknownSyntax::getNumChildren() const {
+  size_t Count = 0;
+  for (auto Child : getRaw()->Layout) {
+    if (Child->isToken()) {
+      continue;
+    }
+    ++Count;
+  }
+  return Count;
+}
+
+Syntax UnknownSyntax::getChild(const size_t N) const {
+  auto *MyData = getUnsafeData<UnknownSyntax>();
+
+  if (auto RealizedChild = MyData->CachedChildren[N]) {
+    return Syntax { Root, RealizedChild.get() };
+  }
+
+  assert(N < getNumChildren());
+  assert(N < getRaw()->Layout.size());
+
+  CursorIndex ChildLayoutIndex = 0;
+
+  for (size_t LayoutIndex = 0, Left = N;
+       LayoutIndex < getRaw()->Layout.size();
+       ++LayoutIndex) {
+    auto Child = getRaw()->Layout[LayoutIndex];
+    if (Child->isToken()) {
+      continue;
+    }
+    ChildLayoutIndex = LayoutIndex;
+    if (Left == 0) {
+      break;
+    }
+    --Left;
+  }
+
+  auto RawChild = getRaw()->Layout[ChildLayoutIndex];
+  assert(RawChild->Kind != SyntaxKind::Token);
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    MyData->CachedChildren.data() + N);
+
+  SyntaxData::realizeSyntaxNode<Syntax>(ChildPtr, RawChild, MyData,
+                                        ChildLayoutIndex);
+
+  return Syntax { Root, MyData->CachedChildren[N].get() };
+}
+
diff --git a/stdlib/public/SwiftShims/RefCount.h b/stdlib/public/SwiftShims/RefCount.h
index 7b59508..95f102b 100644
--- a/stdlib/public/SwiftShims/RefCount.h
+++ b/stdlib/public/SwiftShims/RefCount.h
@@ -745,6 +745,9 @@
   LLVM_ATTRIBUTE_NOINLINE
   bool tryIncrementSlow(RefCountBits oldbits);
 
+  LLVM_ATTRIBUTE_NOINLINE
+  bool tryIncrementNonAtomicSlow(RefCountBits oldbits);
+
   public:
   enum Initialized_t { Initialized };
 
@@ -859,6 +862,19 @@
     return true;
   }
 
+  bool tryIncrementNonAtomic() {
+    auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
+    if (!oldbits.hasSideTable() && oldbits.getIsDeiniting())
+      return false;
+
+    auto newbits = oldbits;
+    bool fast = newbits.incrementStrongExtraRefCount(1);
+    if (!fast)
+      return tryIncrementNonAtomicSlow(oldbits);
+    refCounts.store(newbits, std::memory_order_relaxed);
+    return true;
+  }
+
   // Simultaneously clear the pinned flag and decrement the reference
   // count. Call _swift_release_dealloc() if the reference count goes to zero.
   //
@@ -881,6 +897,11 @@
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
+  bool decrementShouldDeinitNonAtomic(uint32_t dec) {
+    return doDecrementNonAtomic<DontClearPinnedFlag, DontPerformDeinit>(dec);
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
   void decrementAndMaybeDeinit(uint32_t dec) {
     doDecrement<DontClearPinnedFlag, DoPerformDeinit>(dec);
   }
@@ -979,7 +1000,12 @@
   // object may have a side table entry.
   template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
   bool doDecrementSideTable(RefCountBits oldbits, uint32_t dec);
-  
+
+  // Second slow path of doDecrementNonAtomic, where the
+  // object may have a side table entry.
+  template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
+  bool doDecrementNonAtomicSideTable(RefCountBits oldbits, uint32_t dec);
+
   // First slow path of doDecrement, where the object may need to be deinited.
   // Side table is handled in the second slow path, doDecrementSideTable().
   template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
@@ -1021,6 +1047,42 @@
 
     return deinitNow;
   }
+
+  // First slow path of doDecrementNonAtomic, where the object may need to be deinited.
+  // Side table is handled in the second slow path, doDecrementNonAtomicSideTable().
+  template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
+  bool doDecrementNonAtomicSlow(RefCountBits oldbits, uint32_t dec) {
+    bool deinitNow;
+    auto newbits = oldbits;
+
+    bool fast = newbits.decrementStrongExtraRefCount(dec, clearPinnedFlag);
+    if (fast) {
+      // Decrement completed normally. New refcount is not zero.
+      deinitNow = false;
+    }
+    else if (oldbits.hasSideTable()) {
+      // Decrement failed because we're on some other slow path.
+      return doDecrementNonAtomicSideTable<clearPinnedFlag,
+                                           performDeinit>(oldbits, dec);
+    }
+    else {
+      // Decrement underflowed. Begin deinit.
+      // LIVE -> DEINITING
+      deinitNow = true;
+      assert(!oldbits.getIsDeiniting());  // FIXME: make this an error?
+      newbits = oldbits;  // Undo failed decrement of newbits.
+      newbits.setStrongExtraRefCount(0);
+      newbits.setIsDeiniting(true);
+      if (clearPinnedFlag)
+        newbits.setIsPinned(false);
+    }
+    refCounts.store(newbits, std::memory_order_relaxed);
+    if (performDeinit && deinitNow) {
+      _swift_release_dealloc(getHeapObject());
+    }
+
+    return deinitNow;
+  }
   
   public:  // FIXME: access control hack
 
@@ -1045,8 +1107,6 @@
 
     return false;  // don't deinit
   }
-  
-  private:
 
   // This is independently specialized below for inline and out-of-line use.
   template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
@@ -1072,6 +1132,18 @@
                                               std::memory_order_relaxed));
   }
 
+  void incrementUnownedNonAtomic(uint32_t inc) {
+    auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
+    if (oldbits.hasSideTable())
+      return oldbits.getSideTable()->incrementUnownedNonAtomic(inc);
+
+    auto newbits = oldbits;
+    assert(newbits.getUnownedRefCount() != 0);
+    newbits.incrementUnownedRefCount(inc);
+    // FIXME: overflow check?
+    refCounts.store(newbits, std::memory_order_relaxed);
+  }
+
   // Decrement the unowned reference count.
   // Return true if the caller should free the object.
   bool decrementUnownedShouldFree(uint32_t dec) {
@@ -1086,7 +1158,7 @@
       newbits = oldbits;
       newbits.decrementUnownedRefCount(dec);
       if (newbits.getUnownedRefCount() == 0) {
-        // DEINITED -> FREED  or  DEINITED -> DEAD
+        // DEINITED -> FREED, or DEINITED -> DEAD
         // Caller will free the object. Weak decrement is handled by
         // HeapObjectSideTableEntry::decrementUnownedShouldFree.
         assert(newbits.getIsDeiniting());
@@ -1100,6 +1172,29 @@
     return performFree;
   }
 
+  bool decrementUnownedShouldFreeNonAtomic(uint32_t dec) {
+    auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
+
+    if (oldbits.hasSideTable())
+      return oldbits.getSideTable()->decrementUnownedShouldFreeNonAtomic(dec);
+
+    bool performFree;
+    auto newbits = oldbits;
+    newbits.decrementUnownedRefCount(dec);
+    if (newbits.getUnownedRefCount() == 0) {
+      // DEINITED -> FREED, or DEINITED -> DEAD
+      // Caller will free the object. Weak decrement is handled by
+      // HeapObjectSideTableEntry::decrementUnownedShouldFreeNonAtomic.
+      assert(newbits.getIsDeiniting());
+      performFree = true;
+    } else {
+      performFree = false;
+    }
+    // FIXME: underflow check?
+    refCounts.store(newbits, std::memory_order_relaxed);
+    return performFree;
+  }
+
   // Return unowned reference count.
   // Note that this is not equal to the number of outstanding unowned pointers.
   uint32_t getUnownedCount() const {
@@ -1146,6 +1241,16 @@
 
     return performFree;
   }
+
+  bool decrementWeakShouldCleanUpNonAtomic() {
+    auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
+
+    auto newbits = oldbits;
+    auto performFree = newbits.decrementWeakRefCount();
+    refCounts.store(newbits, std::memory_order_relaxed);
+
+    return performFree;
+  }
   
   // Return weak reference count.
   // Note that this is not equal to the number of outstanding weak pointers.
@@ -1226,9 +1331,13 @@
     return refCounts.doDecrement<clearPinnedFlag, performDeinit>(dec);
   }
 
+  template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
+  bool decrementNonAtomicStrong(uint32_t dec) {
+    return refCounts.doDecrementNonAtomic<clearPinnedFlag, performDeinit>(dec);
+  }
+
   void decrementFromOneNonAtomic() {
-    // FIXME: can there be a non-atomic implementation?
-    decrementStrong<DontClearPinnedFlag, DontPerformDeinit>(1);
+    decrementNonAtomicStrong<DontClearPinnedFlag, DontPerformDeinit>(1);
   }
   
   bool isDeiniting() const {
@@ -1243,6 +1352,16 @@
     return refCounts.tryIncrementAndPin();
   }
 
+  bool tryIncrementNonAtomic() {
+    return refCounts.tryIncrementNonAtomic();
+  }
+
+  bool tryIncrementAndPinNonAtomic() {
+    return refCounts.tryIncrementAndPinNonAtomic();
+  }
+
+  // Return weak reference count.
+  // Note that this is not equal to the number of outstanding weak pointers.
   uint32_t getCount() const {
     return refCounts.getCount();
   }
@@ -1257,6 +1376,10 @@
     return refCounts.incrementUnowned(inc);
   }
 
+  void incrementUnownedNonAtomic(uint32_t inc) {
+    return refCounts.incrementUnownedNonAtomic(inc);
+  }
+
   bool decrementUnownedShouldFree(uint32_t dec) {
     bool shouldFree = refCounts.decrementUnownedShouldFree(dec);
     if (shouldFree) {
@@ -1268,6 +1391,17 @@
     return shouldFree;
   }
 
+  bool decrementUnownedShouldFreeNonAtomic(uint32_t dec) {
+    bool shouldFree = refCounts.decrementUnownedShouldFreeNonAtomic(dec);
+    if (shouldFree) {
+      // DEINITED -> FREED
+      // Caller will free the object.
+      decrementWeakNonAtomic();
+    }
+
+    return shouldFree;
+  }
+
   uint32_t getUnownedCount() const {
     return refCounts.getUnownedCount();
   }
@@ -1301,6 +1435,19 @@
     delete this;
   }
 
+  void decrementWeakNonAtomic() {
+    // FIXME: assertions
+    // FIXME: optimize barriers
+    bool cleanup = refCounts.decrementWeakShouldCleanUpNonAtomic();
+    if (!cleanup)
+      return;
+
+    // Weak ref count is now zero. Delete the side table entry.
+    // FREED -> DEAD
+    assert(refCounts.getUnownedCount() == 0);
+    delete this;
+  }
+
   uint32_t getWeakCount() const {
     return refCounts.getWeakCount();
   }
@@ -1327,12 +1474,12 @@
 
   // Use slow path if we can't guarantee atomicity.
   if (oldbits.hasSideTable() || oldbits.getUnownedRefCount() != 1)
-    return doDecrementSlow<clearPinnedFlag, performDeinit>(oldbits, dec);
+    return doDecrementNonAtomicSlow<clearPinnedFlag, performDeinit>(oldbits, dec);
 
   auto newbits = oldbits;
   bool fast = newbits.decrementStrongExtraRefCount(dec, clearPinnedFlag);
   if (!fast)
-    return doDecrementSlow<clearPinnedFlag, performDeinit>(oldbits, dec);
+    return doDecrementNonAtomicSlow<clearPinnedFlag, performDeinit>(oldbits, dec);
 
   refCounts.store(newbits, std::memory_order_relaxed);
   return false;  // don't deinit
@@ -1359,12 +1506,28 @@
 
 template <>
 template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
+inline bool RefCounts<InlineRefCountBits>::
+doDecrementNonAtomicSideTable(InlineRefCountBits oldbits, uint32_t dec) {
+  auto side = oldbits.getSideTable();
+  return side->decrementNonAtomicStrong<clearPinnedFlag, performDeinit>(dec);
+}
+
+template <>
+template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
 inline bool RefCounts<SideTableRefCountBits>::
 doDecrementSideTable(SideTableRefCountBits oldbits, uint32_t dec) {
   swift::crash("side table refcount must not have "
                "a side table entry of its own");
 }
 
+template <>
+template <ClearPinnedFlag clearPinnedFlag, PerformDeinit performDeinit>
+inline bool RefCounts<SideTableRefCountBits>::
+doDecrementNonAtomicSideTable(SideTableRefCountBits oldbits, uint32_t dec) {
+  swift::crash("side table refcount must not have "
+               "a side table entry of its own");
+}
+
 
 template <> inline
 HeapObject* RefCounts<InlineRefCountBits>::getHeapObject() const {
diff --git a/stdlib/public/core/Dump.swift b/stdlib/public/core/Dump.swift
index d4a2ae6..c7a6399 100644
--- a/stdlib/public/core/Dump.swift
+++ b/stdlib/public/core/Dump.swift
@@ -12,6 +12,7 @@
 
 /// Dumps an object's contents using its mirror to the specified output stream.
 @discardableResult
+@_semantics("optimize.sil.specialize.generic.never")
 public func dump<T, TargetStream : TextOutputStream>(
   _ value: T,
   to target: inout TargetStream,
@@ -37,6 +38,7 @@
 
 /// Dumps an object's contents using its mirror to standard output.
 @discardableResult
+@_semantics("optimize.sil.specialize.generic.never")
 public func dump<T>(
   _ value: T,
   name: String? = nil,
@@ -55,6 +57,7 @@
 }
 
 /// Dump an object's contents. User code should use dump().
+@_semantics("optimize.sil.specialize.generic.never")
 internal func _dump_unlocked<TargetStream : TextOutputStream>(
   _ value: Any,
   to target: inout TargetStream,
@@ -153,6 +156,7 @@
 
 /// Dump information about an object's superclass, given a mirror reflecting
 /// that superclass.
+@_semantics("optimize.sil.specialize.generic.never")
 internal func _dumpSuperclass_unlocked<TargetStream : TextOutputStream>(
   mirror: Mirror,
   to target: inout TargetStream,
diff --git a/stdlib/public/core/OutputStream.swift b/stdlib/public/core/OutputStream.swift
index 7384fb6..8ab4443 100644
--- a/stdlib/public/core/OutputStream.swift
+++ b/stdlib/public/core/OutputStream.swift
@@ -250,6 +250,7 @@
 func _opaqueSummary(_ metadata: Any.Type) -> UnsafePointer<CChar>?
 
 /// Do our best to print a value that cannot be printed directly.
+@_semantics("optimize.sil.specialize.generic.never")
 internal func _adHocPrint_unlocked<T, TargetStream : TextOutputStream>(
     _ value: T, _ mirror: Mirror, _ target: inout TargetStream,
     isDebugPrint: Bool
@@ -344,6 +345,7 @@
 }
 
 @inline(never)
+@_semantics("optimize.sil.specialize.generic.never")
 @_semantics("stdlib_binary_only")
 internal func _print_unlocked<T, TargetStream : TextOutputStream>(
   _ value: T, _ target: inout TargetStream
@@ -400,6 +402,7 @@
 // `debugPrint`
 //===----------------------------------------------------------------------===//
 
+@_semantics("optimize.sil.specialize.generic.never")
 @inline(never)
 public func _debugPrint_unlocked<T, TargetStream : TextOutputStream>(
     _ value: T, _ target: inout TargetStream
@@ -423,6 +426,7 @@
   _adHocPrint_unlocked(value, mirror, &target, isDebugPrint: true)
 }
 
+@_semantics("optimize.sil.specialize.generic.never")
 internal func _dumpPrint_unlocked<T, TargetStream : TextOutputStream>(
     _ value: T, _ mirror: Mirror, _ target: inout TargetStream
 ) {
diff --git a/stdlib/public/core/UnsafeRawBufferPointer.swift.gyb b/stdlib/public/core/UnsafeRawBufferPointer.swift.gyb
index 9a31ee7..9154c75 100644
--- a/stdlib/public/core/UnsafeRawBufferPointer.swift.gyb
+++ b/stdlib/public/core/UnsafeRawBufferPointer.swift.gyb
@@ -86,7 +86,7 @@
 ///     byteArray += someBytes[n..<someBytes.count]
 % if mutable:
 ///
-/// Assigning into a ranged subscript of an `{$Self}` instance copies bytes
+/// Assigning into a ranged subscript of an `${Self}` instance copies bytes
 /// into the memory. The next `n` bytes of the memory that `someBytes`
 /// references are copied in this code:
 ///
diff --git a/stdlib/public/runtime/CMakeLists.txt b/stdlib/public/runtime/CMakeLists.txt
index 19bb361..fbe690a 100644
--- a/stdlib/public/runtime/CMakeLists.txt
+++ b/stdlib/public/runtime/CMakeLists.txt
@@ -164,10 +164,15 @@
     set(section_magic_begin_obj "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/section_magic_begin-${arch_suffix}.dir/swift_sections.S${CMAKE_C_OUTPUT_EXTENSION}")
     set(section_magic_end_obj "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/section_magic_end-${arch_suffix}.dir/swift_sections.S${CMAKE_C_OUTPUT_EXTENSION}")
 
+    set(ld_EXECUTABLE ${CMAKE_LINKER})
+    if(${SWIFT_SDK_${prefix}_ARCH_${arch}_LINKER})
+      set(ld_EXECUTABLE ${SWIFT_SDK_${prefix}_ARCH_${arch}_LINKER})
+    endif()
+
     add_custom_command_target(section_magic_${arch_suffix}_begin_object
       COMMAND
           # Merge ImageInspectionInit.o + swift_sections.S(BEGIN) => swift_begin.o
-          ${CMAKE_LINKER} -r -o "${SWIFTLIB_DIR}/${arch_subdir}/swift_begin.o"
+          ${ld_EXECUTABLE} -r -o "${SWIFTLIB_DIR}/${arch_subdir}/swift_begin.o"
           "${section_magic_begin_obj}" "${section_magic_loader_obj}"
       OUTPUT
           "${SWIFTLIB_DIR}/${arch_subdir}/swift_begin.o"
diff --git a/stdlib/public/runtime/HeapObject.cpp b/stdlib/public/runtime/HeapObject.cpp
index 3797b6c..3a3bd61 100644
--- a/stdlib/public/runtime/HeapObject.cpp
+++ b/stdlib/public/runtime/HeapObject.cpp
@@ -344,6 +344,32 @@
   }
 }
 
+void swift::swift_nonatomic_unownedRetain(HeapObject *object)
+    SWIFT_CC(RegisterPreservingCC_IMPL) {
+  if (!isValidPointerForNativeRetain(object))
+    return;
+
+  object->refCounts.incrementUnownedNonAtomic(1);
+}
+
+void swift::swift_nonatomic_unownedRelease(HeapObject *object)
+    SWIFT_CC(RegisterPreservingCC_IMPL) {
+  if (!isValidPointerForNativeRetain(object))
+    return;
+
+  // Only class objects can be unowned-retained and unowned-released.
+  assert(object->metadata->isClassObject());
+  assert(static_cast<const ClassMetadata*>(object->metadata)->isTypeMetadata());
+
+  if (object->refCounts.decrementUnownedShouldFreeNonAtomic(1)) {
+    auto classMetadata = static_cast<const ClassMetadata*>(object->metadata);
+
+    SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
+        (object, classMetadata->getInstanceSize(),
+         classMetadata->getInstanceAlignMask());
+  }
+}
+
 void swift::swift_unownedRetain_n(HeapObject *object, int n)
     SWIFT_CC(RegisterPreservingCC_IMPL) {
   if (!isValidPointerForNativeRetain(object))
@@ -369,6 +395,31 @@
   }
 }
 
+void swift::swift_nonatomic_unownedRetain_n(HeapObject *object, int n)
+    SWIFT_CC(RegisterPreservingCC_IMPL) {
+  if (!isValidPointerForNativeRetain(object))
+    return;
+
+  object->refCounts.incrementUnownedNonAtomic(n);
+}
+
+void swift::swift_nonatomic_unownedRelease_n(HeapObject *object, int n)
+    SWIFT_CC(RegisterPreservingCC_IMPL) {
+  if (!isValidPointerForNativeRetain(object))
+    return;
+
+  // Only class objects can be unowned-retained and unowned-released.
+  assert(object->metadata->isClassObject());
+  assert(static_cast<const ClassMetadata*>(object->metadata)->isTypeMetadata());
+
+  if (object->refCounts.decrementUnownedShouldFreeNonAtomic(n)) {
+    auto classMetadata = static_cast<const ClassMetadata*>(object->metadata);
+    SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
+        (object, classMetadata->getInstanceSize(),
+         classMetadata->getInstanceAlignMask());
+  }
+}
+
 HeapObject *swift::swift_tryPin(HeapObject *object)
     SWIFT_CC(RegisterPreservingCC_IMPL) {
   assert(isValidPointerForNativeRetain(object));
@@ -449,6 +500,17 @@
     swift::swift_abortRetainUnowned(object);
 }
 
+void swift::swift_nonatomic_unownedRetainStrong(HeapObject *object)
+    SWIFT_CC(RegisterPreservingCC_IMPL) {
+  if (!isValidPointerForNativeRetain(object))
+    return;
+  assert(object->refCounts.getUnownedCount() &&
+         "object is not currently unowned-retained");
+
+  if (! object->refCounts.tryIncrementNonAtomic())
+    swift::swift_abortRetainUnowned(object);
+}
+
 void swift::swift_unownedRetainStrongAndRelease(HeapObject *object)
     SWIFT_CC(RegisterPreservingCC_IMPL) {
   if (!isValidPointerForNativeRetain(object))
@@ -465,6 +527,22 @@
   (void) dealloc;
 }
 
+void swift::swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *object)
+    SWIFT_CC(RegisterPreservingCC_IMPL) {
+  if (!isValidPointerForNativeRetain(object))
+    return;
+  assert(object->refCounts.getUnownedCount() &&
+         "object is not currently unowned-retained");
+
+  if (! object->refCounts.tryIncrementNonAtomic())
+    swift::swift_abortRetainUnowned(object);
+
+  // This should never cause a deallocation.
+  bool dealloc = object->refCounts.decrementUnownedShouldFreeNonAtomic(1);
+  assert(!dealloc && "retain-strong-and-release caused dealloc?");
+  (void) dealloc;
+}
+
 void swift::swift_unownedCheck(HeapObject *object) {
   if (!isValidPointerForNativeRetain(object)) return;
   assert(object->refCounts.getUnownedCount() &&
diff --git a/stdlib/public/runtime/Metadata.cpp b/stdlib/public/runtime/Metadata.cpp
index aab8c9d..7d2257d 100644
--- a/stdlib/public/runtime/Metadata.cpp
+++ b/stdlib/public/runtime/Metadata.cpp
@@ -2819,7 +2819,7 @@
     /// The number of bytes remaining.
     size_t Remaining;
   };
-}
+} // end anonymous namespace
 
 // A statically-allocated pool.  It's zero-initialized, so this
 // doesn't cost us anything in binary size.
diff --git a/stdlib/public/runtime/MetadataImpl.h b/stdlib/public/runtime/MetadataImpl.h
index 28d79f1..a9ca348 100644
--- a/stdlib/public/runtime/MetadataImpl.h
+++ b/stdlib/public/runtime/MetadataImpl.h
@@ -191,6 +191,11 @@
   static constexpr size_t stride = sizeof(T);
   static constexpr bool isPOD = false;
   static constexpr bool isBitwiseTakable = true;
+#ifdef SWIFT_STDLIB_USE_NONATOMIC_RC
+  static constexpr bool isAtomic = false;
+#else
+  static constexpr bool isAtomic = true;
+#endif
 
   static void destroy(T *addr) {
     Impl::release(*addr);
@@ -262,12 +267,20 @@
 struct SwiftRetainableBox :
     RetainableBoxBase<SwiftRetainableBox, HeapObject*> {
   static HeapObject *retain(HeapObject *obj) {
-    swift_retain(obj);
+    if (isAtomic) {
+      swift_retain(obj);
+    } else {
+      swift_nonatomic_retain(obj);
+    }
     return obj;
   }
 
   static void release(HeapObject *obj) {
-    swift_release(obj);
+    if (isAtomic) {
+      swift_release(obj);
+    } else {
+      swift_nonatomic_release(obj);
+    }
   }
 };
 
@@ -275,12 +288,20 @@
 struct SwiftUnownedRetainableBox :
     RetainableBoxBase<SwiftUnownedRetainableBox, HeapObject*> {
   static HeapObject *retain(HeapObject *obj) {
-    swift_unownedRetain(obj);
+    if (isAtomic) {
+      swift_unownedRetain(obj);
+    } else {
+      swift_nonatomic_unownedRetain(obj);
+    }
     return obj;
   }
 
   static void release(HeapObject *obj) {
-    swift_unownedRelease(obj);
+    if (isAtomic) {
+      swift_unownedRelease(obj);
+    } else {
+      swift_nonatomic_unownedRelease(obj);
+    }
   }
 
 #if SWIFT_OBJC_INTEROP
@@ -468,7 +489,11 @@
     swift_unknownRetain(obj);
     return obj;
 #else
-    swift_retain(static_cast<HeapObject *>(obj));
+    if (isAtomic) {
+      swift_retain(static_cast<HeapObject *>(obj));
+    } else {
+      swift_nonatomic_retain(static_cast<HeapObject *>(obj));
+    }
     return static_cast<HeapObject *>(obj);
 #endif
   }
@@ -477,7 +502,11 @@
 #if SWIFT_OBJC_INTEROP
     swift_unknownRelease(obj);
 #else
-    swift_release(static_cast<HeapObject *>(obj));
+    if (isAtomic) {
+      swift_release(static_cast<HeapObject *>(obj));
+    } else {
+      swift_nonatomic_release(static_cast<HeapObject *>(obj));
+    }
 #endif
   }
 };
diff --git a/stdlib/public/runtime/RefCount.cpp b/stdlib/public/runtime/RefCount.cpp
index 920df04..1d1b22b 100644
--- a/stdlib/public/runtime/RefCount.cpp
+++ b/stdlib/public/runtime/RefCount.cpp
@@ -2,11 +2,11 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
-// See http://swift.org/LICENSE.txt for license information
-// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
@@ -55,6 +55,16 @@
 template bool RefCounts<SideTableRefCountBits>::tryIncrementSlow(SideTableRefCountBits oldbits);
 
 template <typename RefCountBits>
+bool RefCounts<RefCountBits>::tryIncrementNonAtomicSlow(RefCountBits oldbits) {
+  if (oldbits.hasSideTable())
+    return oldbits.getSideTable()->tryIncrementNonAtomic();
+  else
+    swift::swift_abortRetainOverflow();
+}
+template bool RefCounts<InlineRefCountBits>::tryIncrementNonAtomicSlow(InlineRefCountBits oldbits);
+template bool RefCounts<SideTableRefCountBits>::tryIncrementNonAtomicSlow(SideTableRefCountBits oldbits);
+
+template <typename RefCountBits>
 bool RefCounts<RefCountBits>::tryIncrementAndPinSlow(RefCountBits oldbits) {
   if (oldbits.hasSideTable())
     return oldbits.getSideTable()->tryIncrementAndPin();
@@ -66,8 +76,10 @@
 
 template <typename RefCountBits>
 bool RefCounts<RefCountBits>::tryIncrementAndPinNonAtomicSlow(RefCountBits oldbits) {
-  // No nonatomic implementation provided.
-  return tryIncrementAndPinSlow(oldbits);
+  if (oldbits.hasSideTable())
+    return oldbits.getSideTable()->tryIncrementAndPinNonAtomic();
+  else
+    swift::swift_abortRetainOverflow();
 }
 template bool RefCounts<InlineRefCountBits>::tryIncrementAndPinNonAtomicSlow(InlineRefCountBits oldbits);
 template bool RefCounts<SideTableRefCountBits>::tryIncrementAndPinNonAtomicSlow(SideTableRefCountBits oldbits);
diff --git a/stdlib/public/runtime/WeakReference.h b/stdlib/public/runtime/WeakReference.h
index aa8f4f4..34dd52e 100644
--- a/stdlib/public/runtime/WeakReference.h
+++ b/stdlib/public/runtime/WeakReference.h
@@ -2,11 +2,11 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
-// See http://swift.org/LICENSE.txt for license information
-// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.apinotes b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.apinotes
index 747e0bb..3cff8ce 100644
--- a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.apinotes
+++ b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.apinotes
@@ -79,7 +79,16 @@
           - Name: accessorsOnlyRenamedRetypedClass
             PropertyKind:    Class
             SwiftImportAsAccessors: true
+    Protocols:
+      - Name: ProtoWithVersionedUnavailableMember
+        Methods:
+          - Selector: requirement
+            MethodKind: Instance
+            ResultType: 'ForwardClass * _Nullable'
     Functions:
       - Name: acceptDoublePointer
         SwiftName: 'acceptPointer(_:)'
         Nullability: [ O ]
+    Tags:
+      - Name: SomeCStruct
+        SwiftName: ImportantCStruct
diff --git a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.h b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.h
index b0a6023..06e48f9 100644
--- a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.h
+++ b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/APINotesFrameworkTest.h
@@ -2,6 +2,8 @@
 
 void acceptDoublePointer(double* _Nonnull ptr) __attribute__((swift_name("accept(_:)")));
 
+void oldAcceptDoublePointer(double* _Nonnull ptr) __attribute__((availability(swift, unavailable, replacement="acceptDoublePointer")));
+
 #ifdef __OBJC__
 
 __attribute__((objc_root_class))
@@ -13,5 +15,8 @@
 -(nonnull id)methodWithA:(nonnull id)a;
 @end
 
+#endif // __OBJC__
+
 #import <APINotesFrameworkTest/Properties.h>
-#endif
+#import <APINotesFrameworkTest/Protocols.h>
+#import <APINotesFrameworkTest/Types.h>
diff --git a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Properties.h b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Properties.h
index 93ab5b0..9d21bde 100644
--- a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Properties.h
+++ b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Properties.h
@@ -1,3 +1,4 @@
+#ifdef __OBJC__
 #pragma clang assume_nonnull begin
 
 __attribute__((objc_root_class))
@@ -33,3 +34,4 @@
 @end
 
 #pragma clang assume_nonnull end
+#endif // __OBJC__
diff --git a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Protocols.h b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Protocols.h
new file mode 100644
index 0000000..6a8840c
--- /dev/null
+++ b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Protocols.h
@@ -0,0 +1,11 @@
+#ifdef __OBJC__
+#pragma clang assume_nonnull begin
+
+@class ForwardClass; // used by API notes
+
+@protocol ProtoWithVersionedUnavailableMember
+- (nullable id)requirement;
+@end
+
+#pragma clang assume_nonnull end
+#endif // __OBJC__
diff --git a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h
new file mode 100644
index 0000000..c44439f
--- /dev/null
+++ b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h
@@ -0,0 +1,7 @@
+#pragma clang assume_nonnull begin
+
+struct __attribute__((swift_name("VeryImportantCStruct"))) SomeCStruct {
+	int field;
+};
+
+#pragma clang assume_nonnull end
diff --git a/test/APINotes/versioned-objc.swift b/test/APINotes/versioned-objc.swift
new file mode 100644
index 0000000..4ff367c
--- /dev/null
+++ b/test/APINotes/versioned-objc.swift
@@ -0,0 +1,16 @@
+// RUN: rm -rf %t && mkdir -p %t
+
+// RUN: not %target-swift-frontend -typecheck -F %S/Inputs/custom-frameworks -swift-version 4 %s 2>&1 | %FileCheck -check-prefix=CHECK-DIAGS -check-prefix=CHECK-DIAGS-4 %s
+// RUN: not %target-swift-frontend -typecheck -F %S/Inputs/custom-frameworks -swift-version 3 %s 2>&1 | %FileCheck -check-prefix=CHECK-DIAGS -check-prefix=CHECK-DIAGS-3 %s
+
+// REQUIRES: objc_interop
+
+import APINotesFrameworkTest
+
+// CHECK-DIAGS-4-NOT: versioned-objc.swift:[[@LINE-1]]:
+class ProtoWithVersionedUnavailableMemberImpl: ProtoWithVersionedUnavailableMember {
+  // CHECK-DIAGS-3: versioned-objc.swift:[[@LINE-1]]:7: error: type 'ProtoWithVersionedUnavailableMemberImpl' cannot conform to protocol 'ProtoWithVersionedUnavailableMember' because it has requirements that cannot be satisfied
+  func requirement() -> Any? { return nil }
+}
+
+let unrelatedDiagnostic: Int = nil
diff --git a/test/APINotes/versioned.swift b/test/APINotes/versioned.swift
index 85dd3e2..a3d7353 100644
--- a/test/APINotes/versioned.swift
+++ b/test/APINotes/versioned.swift
@@ -18,19 +18,41 @@
 func testRenamedTopLevel() {
   var value = 0.0
 
-  // CHECK-DIAGS-4-NOT: versioned.swift:[[@LINE+1]]
+  // CHECK-DIAGS-4-NOT: versioned.swift:[[@LINE+1]]:
   accept(&value)
   // CHECK-DIAGS-3: versioned.swift:[[@LINE-1]]:3: error: 'accept' has been renamed to 'acceptPointer(_:)'
   // CHECK-DIAGS-3: note: 'accept' was introduced in Swift 4
 
-  // CHECK-DIAGS-4-NOT: versioned.swift:[[@LINE+1]]
+  // CHECK-DIAGS-3-NOT: versioned.swift:[[@LINE+1]]:
   acceptPointer(&value)
   // CHECK-DIAGS-4: versioned.swift:[[@LINE-1]]:3: error: 'acceptPointer' has been renamed to 'accept(_:)'
   // CHECK-DIAGS-4: note: 'acceptPointer' was obsoleted in Swift 4
 
   acceptDoublePointer(&value)
   // CHECK-DIAGS: versioned.swift:[[@LINE-1]]:3: error: 'acceptDoublePointer' has been renamed to
-  // CHECK-DIAGS-4: 'accept(_:)'
-  // CHECK-DIAGS-3: 'acceptPointer(_:)'
+  // CHECK-DIAGS-4-SAME: 'accept(_:)'
+  // CHECK-DIAGS-3-SAME: 'acceptPointer(_:)'
   // CHECK-DIAGS: note: 'acceptDoublePointer' was obsoleted in Swift 3
+
+  oldAcceptDoublePointer(&value)
+  // CHECK-DIAGS: versioned.swift:[[@LINE-1]]:3: error: 'oldAcceptDoublePointer' has been renamed to
+  // CHECK-DIAGS-4-SAME: 'accept(_:)'
+  // CHECK-DIAGS-3-SAME: 'acceptPointer(_:)'
+  // CHECK-DIAGS: note: 'oldAcceptDoublePointer' has been explicitly marked unavailable here
+
+  _ = SomeCStruct()
+  // CHECK-DIAGS: versioned.swift:[[@LINE-1]]:7: error: 'SomeCStruct' has been renamed to
+  // CHECK-DIAGS-4-SAME: 'VeryImportantCStruct'
+  // CHECK-DIAGS-3-SAME: 'ImportantCStruct'
+  // CHECK-DIAGS: note: 'SomeCStruct' was obsoleted in Swift 3
+
+  // CHECK-DIAGS-3-NOT: versioned.swift:[[@LINE+1]]:
+  _ = ImportantCStruct()
+  // CHECK-DIAGS-4: versioned.swift:[[@LINE-1]]:7: error: 'ImportantCStruct' has been renamed to 'VeryImportantCStruct'
+  // CHECK-DIAGS-4: note: 'ImportantCStruct' was obsoleted in Swift 4
+
+  // CHECK-DIAGS-4-NOT: versioned.swift:[[@LINE+1]]:
+  _ = VeryImportantCStruct()
+  // CHECK-DIAGS-3: versioned.swift:[[@LINE-1]]:7: error: 'VeryImportantCStruct' has been renamed to 'ImportantCStruct'
+  // CHECK-DIAGS-3: note: 'VeryImportantCStruct' was introduced in Swift 4
 }
diff --git a/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some-Bridging-Header.h b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some-Bridging-Header.h
new file mode 100644
index 0000000..dc2b560
--- /dev/null
+++ b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some-Bridging-Header.h
@@ -0,0 +1,7 @@
+#import <Some/Submodule.h>
+
+@interface Thing
++ (void)fn:(KLASS*)arg;
+@end
+
+void bar(TYPE t);
diff --git a/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Headers/Some.h b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Headers/Some.h
new file mode 100644
index 0000000..ea7c87e
--- /dev/null
+++ b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Headers/Some.h
@@ -0,0 +1,2 @@
+typedef int TYPE;
+@class KLASS;
diff --git a/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Headers/Submodule.h b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Headers/Submodule.h
new file mode 100644
index 0000000..5d5f8f0
--- /dev/null
+++ b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Headers/Submodule.h
@@ -0,0 +1 @@
+int foo();
diff --git a/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Modules/module.modulemap b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Modules/module.modulemap
new file mode 100644
index 0000000..ccbb89c
--- /dev/null
+++ b/test/ClangImporter/MixedSource/Inputs/defer-supermodule-import/Some.framework/Modules/module.modulemap
@@ -0,0 +1,8 @@
+framework module Some  {
+  header "Some.h"
+  export *
+  module Submodule {
+    header "Submodule.h"
+    export *
+  }
+}
diff --git a/test/ClangImporter/MixedSource/defer-supermodule-import.swift b/test/ClangImporter/MixedSource/defer-supermodule-import.swift
new file mode 100644
index 0000000..0e6d505
--- /dev/null
+++ b/test/ClangImporter/MixedSource/defer-supermodule-import.swift
@@ -0,0 +1,21 @@
+// RUN: not %target-swift-frontend -F %S/Inputs/defer-supermodule-import -import-objc-header %S/Inputs/defer-supermodule-import/Some-Bridging-Header.h -typecheck %s 2>&1 | %FileCheck -check-prefix=HEADER-ERROR %s
+// HEADER-ERROR: Some-Bridging-Header.h:4:13: error: expected a type
+// HEADER-ERROR: Some-Bridging-Header.h:7:10: error: declaration of 'TYPE' must be imported from module 'Some' before it is required
+// REQUIRES: objc_interop
+
+// The bug we're testing here is that:
+//
+//  - Given a supermodule defining some types
+//  - Given a submodule of that supermodule
+//  - Given an _erroneous_ bridging header that imports the _submodule_ and tries
+//    to use the _supermodule's_ types
+//
+// That we emit an error. Previously we did not: Swift's "implicit supermodule
+// import" rule would fire _eagerly_, so by the time the submodule import was
+// complete the supermodule was also imported and the bridging header would pass
+// through without flagging the error. This made it possible to write textual
+// bridging headers that would not, themselves, be considered valid objc code as
+// far as clang (or more importantly: clang's PCH-generating pass) was
+// concerned.
+
+print(bar(foo()))
diff --git a/test/Constraints/closures.swift b/test/Constraints/closures.swift
index 838a3b6..d6abc11 100644
--- a/test/Constraints/closures.swift
+++ b/test/Constraints/closures.swift
@@ -266,10 +266,8 @@
 // Make sure we cannot infer an () argument from an empty parameter list.
 func acceptNothingToInt (_: () -> Int) {}
 func testAcceptNothingToInt(ac1: @autoclosure () -> Int) {
-  // expected-note@-1{{parameter 'ac1' is implicitly non-escaping because it was declared @autoclosure}}
   acceptNothingToInt({ac1($0)})
   // expected-error@-1{{contextual closure type '() -> Int' expects 0 arguments, but 1 was used in closure body}}
-  // FIXME: expected-error@-2{{closure use of non-escaping parameter 'ac1' may allow it to escape}}
 }
 
 // <rdar://problem/23570873> QoI: Poor error calling map without being able to infer "U" (closure result inference)
diff --git a/test/Constraints/generic_super_constraint.swift b/test/Constraints/generic_super_constraint.swift
index 8e29a49..c227519 100644
--- a/test/Constraints/generic_super_constraint.swift
+++ b/test/Constraints/generic_super_constraint.swift
@@ -4,11 +4,14 @@
 class Derived: Base<Int> { }
 
 func foo<T>(_ x: T) -> Derived where T: Base<Int>, T: Derived {
+	// expected-warning@-1{{redundant superclass constraint 'T' : 'Base<Int>'}}
+	// expected-note@-2{{superclass constraint 'T' : 'Derived' written here}}
   return x
 }
 
 // FIXME: Should not be an error
-// expected-error@+1{{cannot be a subclass of both 'Base<T>' and 'Derived'}}
+// expected-error@+2{{generic parameter 'U' cannot be a subclass of both 'Derived' and 'Base<T>'}}
+// expected-note@+1{{superclass constraint 'U' : 'Base<T>' written here}}
 func bar<T, U>(_ x: U, y: T) -> (Derived, Int) where U: Base<T>, U: Derived {
   // FIXME
   // expected-error@+1{{cannot convert return expression}}
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
index 3b07ff8..1183a45 100644
--- a/test/Constraints/patterns.swift
+++ b/test/Constraints/patterns.swift
@@ -114,7 +114,8 @@
   ()
 case Watch.Edition: // TODO: should warn that cast can't succeed with currently known conformances
   ()
-case .HairForceOne: // expected-error{{enum case 'HairForceOne' not found in type 'HairType'}}
+// TODO: Bad error message
+case .HairForceOne: // expected-error{{cannot convert}}
   ()
 default:
   break
@@ -254,3 +255,53 @@
 if case let doesNotExist as SomeClass:AlsoDoesNotExist {}
 // expected-error@-1 {{use of undeclared type 'AlsoDoesNotExist'}}
 // expected-error@-2 {{variable binding in a condition requires an initializer}}
+
+// `.foo` and `.bar(...)` pattern syntax should also be able to match
+// static members as expr patterns
+
+struct StaticMembers: Equatable {
+  init() {}
+  init(_: Int) {}
+  init?(opt: Int) {}
+  static var prop = StaticMembers()
+  static var optProp: Optional = StaticMembers()
+
+  static func method(_: Int) -> StaticMembers { return prop }
+  static func method(withLabel: Int) -> StaticMembers { return prop }
+  static func optMethod(_: Int) -> StaticMembers? { return optProp }
+
+  static func ==(x: StaticMembers, y: StaticMembers) -> Bool { return true }
+}
+
+let staticMembers = StaticMembers()
+let optStaticMembers: Optional = StaticMembers()
+
+switch staticMembers {
+  case .init: break // expected-error{{cannot match values of type 'StaticMembers'}}
+  case .init(opt:): break // expected-error{{cannot match values of type 'StaticMembers'}}
+  case .init(): break
+
+  case .init(0): break
+  case .init(_): break // expected-error{{'_' can only appear in a pattern}}
+  case .init(let x): break // expected-error{{cannot appear in an expression}}
+  case .init(opt: 0): break // expected-error{{not unwrapped}}
+
+  case .prop: break
+  // TODO: repeated error message
+  case .optProp: break // expected-error* {{not unwrapped}}
+
+  case .method: break // expected-error{{cannot match}}
+  case .method(0): break
+  case .method(_): break // expected-error{{'_' can only appear in a pattern}}
+  case .method(let x): break // expected-error{{cannot appear in an expression}}
+
+  case .method(withLabel:): break // expected-error{{cannot match}}
+  case .method(withLabel: 0): break
+  case .method(withLabel: _): break // expected-error{{'_' can only appear in a pattern}}
+  case .method(withLabel: let x): break // expected-error{{cannot appear in an expression}}
+
+  case .optMethod: break // expected-error{{cannot match}}
+  case .optMethod(0): break // expected-error{{not unwrapped}}
+}
+
+_ = 0
diff --git a/test/DebugInfo/linetable.swift b/test/DebugInfo/linetable.swift
index e282ca4..b4706cb 100644
--- a/test/DebugInfo/linetable.swift
+++ b/test/DebugInfo/linetable.swift
@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests %s -emit-ir -g -o - | %FileCheck %s
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests %s -S -g -o - | %FileCheck %s --check-prefix ASM-CHECK
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 import Swift
 func markUsed<T>(_ t: T) {}
diff --git a/test/Demangle/Inputs/simplified-manglings.txt b/test/Demangle/Inputs/simplified-manglings.txt
index 20cb0b9..6eea81b 100644
--- a/test/Demangle/Inputs/simplified-manglings.txt
+++ b/test/Demangle/Inputs/simplified-manglings.txt
@@ -136,9 +136,9 @@
 _TtGSaGSqC5sugar7MyClass__ ---> [MyClass?]
 _TtaC9typealias5DWARF9DIEOffset ---> DWARF.DIEOffset
 _Ttas3Int ---> Int
-_TTRXFo_dSc_dSb_XFo_iSc_iSb_ ---> thunk
-_TTRXFo_dSi_dGSqSi__XFo_iSi_iGSqSi__ ---> thunk
-_TTRGrXFo_iV18switch_abstraction1A_ix_XFo_dS0__ix_ ---> thunk
+_TTRXFo_dSc_dSb_XFo_iSc_iSb_ ---> thunk for @callee_owned (@unowned UnicodeScalar) -> (@unowned Bool)
+_TTRXFo_dSi_dGSqSi__XFo_iSi_iGSqSi__ ---> thunk for @callee_owned (@unowned Int) -> (@unowned Int?)
+_TTRGrXFo_iV18switch_abstraction1A_ix_XFo_dS0__ix_ ---> thunk for @callee_owned (@in A) -> (@out A)
 _TFCF5types1gFT1bSb_T_L0_10Collection3zimfT_T_ ---> (g(b : Bool) -> ()).(Collection #2).zim() -> ()
 _TFF17capture_promotion22test_capture_promotionFT_FT_SiU_FT_Si_promote0 ---> (test_capture_promotion() -> () -> Int).(closure #1)
 _TFIVs8_Processi10_argumentsGSaSS_U_FT_GSaSS_ ---> _Process.(variable initialization expression)._arguments
@@ -160,7 +160,7 @@
 _TTSgSi__xyz ---> _TTSgSi__xyz
 _TTSg5Si___TTSg5Si___TFSqcfT_GSqx_ ---> specialized specialized Optional.init() -> A?
 _TTSg5Vs5UInt8___TFV10specialize3XXXcfT1tx_GS0_x_ ---> specialized XXX.init(t : A) -> XXX<A>
-_TPA__TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_31 ---> partial apply for thunk
+_TPA__TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_31 ---> partial apply for thunk for @callee_owned (@owned String, @owned String) -> (@unowned Bool)
 _TiC4Meow5MyCls9subscriptFT1iSi_Sf ---> MyCls.subscript(i : Int) -> Float
 _TF8manglingX22egbpdajGbuEbxfgehfvwxnFT_T_ ---> ليهمابتكلموشعربي؟() -> ()
 _TF8manglingX24ihqwcrbEcvIaIdqgAFGpqjyeFT_T_ ---> 他们为什么不说中文() -> ()
@@ -180,8 +180,8 @@
 _TTSf1cl35_TFF7specgen6callerFSiT_U_FTSiSi_T_Si___TF7specgen12take_closureFFTSiSi_T_T_ ---> specialized take_closure((Int, Int) -> ()) -> ()
 _TTSf1cl35_TFF7specgen6callerFSiT_U_FTSiSi_T_Si___TTSg5Si___TF7specgen12take_closureFFTSiSi_T_T_ ---> specialized specialized take_closure((Int, Int) -> ()) -> ()
 _TTSg5Si___TTSf1cl35_TFF7specgen6callerFSiT_U_FTSiSi_T_Si___TF7specgen12take_closureFFTSiSi_T_T_ ---> specialized specialized take_closure((Int, Int) -> ()) -> ()
-_TTSf1cpfr24_TF8capturep6helperFSiT__n___TTRXFo_dSi_dT__XFo_iSi_dT__ ---> specialized thunk
-_TTSf1cpfr24_TF8capturep6helperFSiT__n___TTRXFo_dSi_DT__XFo_iSi_DT__ ---> specialized thunk
+_TTSf1cpfr24_TF8capturep6helperFSiT__n___TTRXFo_dSi_dT__XFo_iSi_dT__ ---> specialized thunk for @callee_owned (@unowned Int) -> (@unowned ())
+_TTSf1cpfr24_TF8capturep6helperFSiT__n___TTRXFo_dSi_DT__XFo_iSi_DT__ ---> specialized thunk for @callee_owned (@unowned Int) -> (@unowned_inner_pointer ())
 _TTSf1cpi0_cpfl0_cpse0v4u123_cpg53globalinit_33_06E7F1D906492AE070936A9B58CBAE1C_token8_cpfr36_TFtest_capture_propagation2_closure___TF7specgen12take_closureFFTSiSi_T_T_ ---> specialized take_closure((Int, Int) -> ()) -> ()
 _TTSf0gs___TFVs11_StringCore15_invariantCheckfT_T_ ---> specialized _StringCore._invariantCheck() -> ()
 _TTSf2g___TTSf2s_d___TFVs11_StringCoreCfVs13_StringBufferS_ ---> specialized specialized _StringCore.init(_StringBuffer) -> _StringCore
@@ -198,6 +198,8 @@
 _TFC3red11BaseClassEHcfzT1aSi_S0_ ---> BaseClassEH.init(a : Int) throws -> BaseClassEH
 _TFe27mangling_generic_extensionsR_S_8RunciblerVS_3Foog1aSi ---> Foo<A where ...>.a.getter
 _TFe27mangling_generic_extensionsR_S_8RunciblerVS_3Foog1bx ---> Foo<A where ...>.b.getter
-_TTRXFo_iT__iT_zoPs5Error__XFo__dT_zoPS___ ---> thunk
+_TTRXFo_iT__iT_zoPs5Error__XFo__dT_zoPS___ ---> thunk for @callee_owned (@in ()) -> (@out (), @error @owned Error)
 _TFE1a ---> _TFE1a
 _TFC4testP33_83378C430F65473055F1BD53F3ADCDB71C5doFoofT_T_ ---> C.doFoo() -> ()
+_TTRXFo_oCSo13SKPhysicsBodydVSC7CGPointdVSC8CGVectordGSpV10ObjectiveC8ObjCBool___XFdCb_dS_dS0_dS1_dGSpS3____ ---> thunk for @callee_owned (@owned SKPhysicsBody, @unowned CGPoint, @unowned CGVector, @unowned UnsafeMutablePointer<ObjCBool>) -> ()
+_T0So13SKPhysicsBodyCSC7CGPointVSC8CGVectorVSpy10ObjectiveC8ObjCBoolVGIxxyyy_AbdFSpyAIGIyByyyy_TR ---> thunk for @callee_owned (@owned SKPhysicsBody, @unowned CGPoint, @unowned CGVector, @unowned UnsafeMutablePointer<ObjCBool>) -> ()
diff --git a/test/Generics/associated_type_typo.swift b/test/Generics/associated_type_typo.swift
index e287aff..5b91c77 100644
--- a/test/Generics/associated_type_typo.swift
+++ b/test/Generics/associated_type_typo.swift
@@ -37,9 +37,9 @@
 
 // CHECK-GENERIC-LABEL: .typoAssoc4@
 // CHECK-GENERIC-NEXT: Requirements:
-// CHECK-GENERIC-NEXT:   τ_0_0 : P2 [Explicit @ {{.*}}:21]
-// CHECK-GENERIC-NEXT:   τ_0_0[.P2].AssocP2 : P1 [Explicit @ {{.*}}:21 -> Protocol requirement (P2)]
-// CHECK-GENERIC-NEXT:   τ_0_0[.P2].AssocP2[.P1].Assoc : P3 [Explicit @ {{.*}}:53]
+// CHECK-GENERIC-NEXT:   τ_0_0 : P2 [τ_0_0: Explicit @ {{.*}}:21]
+// CHECK-GENERIC-NEXT:   τ_0_0[.P2].AssocP2 : P1 [τ_0_0: Explicit @ {{.*}}:21 -> Protocol requirement (P2)]
+// CHECK-GENERIC-NEXT:   τ_0_0[.P2].AssocP2[.P1].Assoc : P3 [τ_0_0[.P2].AssocP2.assoc: Explicit @ {{.*}}:53]
 // CHECK-GENERIC-NEXT: Potential archetypes
 
 // <rdar://problem/19620340>
diff --git a/test/Generics/associated_type_where_clause.swift b/test/Generics/associated_type_where_clause.swift
new file mode 100644
index 0000000..3717b18
--- /dev/null
+++ b/test/Generics/associated_type_where_clause.swift
@@ -0,0 +1,128 @@
+// RUN: %target-typecheck-verify-swift -typecheck %s -verify -swift-version 4
+
+func needsSameType<T>(_: T.Type, _: T.Type) {}
+
+protocol Foo {}
+func needsFoo<T: Foo>(_: T.Type) {}
+
+protocol Foo2 {}
+func needsFoo2<T: Foo2>(_: T.Type) {}
+
+extension Int: Foo, Foo2 {}
+extension Float: Foo {}
+
+protocol Conforms {
+    associatedtype T where T: Foo
+}
+func needsConforms<X: Conforms>(_: X.Type) {
+    needsFoo(X.T.self)
+}
+struct ConcreteConforms: Conforms { typealias T = Int }
+struct ConcreteConforms2: Conforms { typealias T = Int }
+struct ConcreteConformsNonFoo2: Conforms { typealias T = Float }
+
+protocol NestedConforms {
+    associatedtype U where U: Conforms, U.T: Foo2
+
+    func foo(_: U)
+}
+extension NestedConforms { func foo(_: U) {} }
+func needsNestedConforms<X: NestedConforms>(_: X.Type) {
+    needsConforms(X.U.self)
+    needsFoo(X.U.T.self)
+    needsFoo2(X.U.T.self)
+}
+struct ConcreteNestedConforms: NestedConforms {
+    typealias U = ConcreteConforms
+}
+struct ConcreteNestedConformsInfer: NestedConforms {
+    func foo(_: ConcreteConforms) {}
+}
+struct BadConcreteNestedConforms: NestedConforms {
+    // expected-error@-1 {{type 'ConcreteConformsNonFoo2.T' (aka 'Float') does not conform to protocol 'Foo2'}}
+    typealias U = ConcreteConformsNonFoo2
+}
+struct BadConcreteNestedConformsInfer: NestedConforms {
+    // expected-error@-1 {{type 'ConcreteConformsNonFoo2.T' (aka 'Float') does not conform to protocol 'Foo2'}}
+    func foo(_: ConcreteConformsNonFoo2) {}
+}
+
+protocol NestedConformsDefault {
+    associatedtype U = ConcreteConforms where U: Conforms, U.T: Foo2
+}
+struct ConcreteNestedConformsDefaultDefaulted: NestedConformsDefault {}
+struct ConcreteNestedConformsDefault: NestedConformsDefault {
+    typealias U = ConcreteConforms2
+}
+func needsNestedConformsDefault<X: NestedConformsDefault>(_: X.Type) {
+    needsConforms(X.U.self)
+    needsFoo(X.U.T.self)
+    needsFoo2(X.U.T.self)
+}
+
+protocol NestedSameType {
+    associatedtype U: Conforms where U.T == Int
+
+    func foo(_: U)
+}
+extension NestedSameType { func foo(_: U) {} }
+func needsNestedSameType<X: NestedSameType>(_: X.Type) {
+    needsConforms(X.U.self)
+    needsSameType(X.U.T.self, Int.self)
+}
+struct BadConcreteNestedSameType: NestedSameType {
+    // expected-error@-1 {{'NestedSameType' requires the types 'ConcreteConformsNonFoo2.T' (aka 'Float') and 'Int' be equivalent}}
+    // expected-note@-2 {{requirement specified as 'Self.U.T' == 'Int' [with Self = BadConcreteNestedSameType]}}
+    typealias U = ConcreteConformsNonFoo2
+}
+struct BadConcreteNestedSameTypeInfer: NestedSameType {
+    // expected-error@-1 {{'NestedSameType' requires the types 'ConcreteConformsNonFoo2.T' (aka 'Float') and 'Int' be equivalent}}
+    // expected-note@-2 {{requirement specified as 'Self.U.T' == 'Int' [with Self = BadConcreteNestedSameTypeInfer]}}
+    func foo(_: ConcreteConformsNonFoo2) {}
+}
+
+protocol NestedSameTypeDefault {
+    associatedtype U: Conforms = ConcreteConforms where U.T == Int
+
+    func foo(_: U)
+}
+extension NestedSameTypeDefault { func foo(_: U) {} }
+func needsNestedSameTypeDefault<X: NestedSameTypeDefault>(_: X.Type) {
+    needsConforms(X.U.self)
+    needsSameType(X.U.T.self, Int.self)
+}
+struct ConcreteNestedSameTypeDefaultDefaulted: NestedSameTypeDefault {}
+struct ConcreteNestedSameTypeDefault: NestedSameTypeDefault {
+    typealias U = ConcreteConforms2
+}
+struct ConcreteNestedSameTypeDefaultInfer: NestedSameTypeDefault {
+    func foo(_: ConcreteConforms2) {}
+}
+
+protocol Inherits: NestedConforms {
+    associatedtype X: Conforms where X.T == U.T
+
+    func bar(_: X)
+}
+extension Inherits { func bar(_: X) {} }
+func needsInherits<X: Inherits>(_: X.Type) {
+    needsConforms(X.U.self)
+    needsConforms(X.X.self)
+    needsSameType(X.U.T.self, X.X.T.self)
+}
+struct ConcreteInherits: Inherits {
+    typealias U = ConcreteConforms
+    typealias X = ConcreteConforms
+}
+struct ConcreteInheritsDiffer: Inherits {
+    typealias U = ConcreteConforms
+    typealias X = ConcreteConforms2
+}
+/*
+FIXME: the sametype requirement gets dropped from the requirement signature
+(enumerateRequirements doesn't yield it), so this doesn't error as it should.
+struct BadConcreteInherits: Inherits {
+    typealias U = ConcreteConforms
+    typealias X = ConcreteConformsNonFoo2
+}
+*/
diff --git a/test/Generics/invalid.swift b/test/Generics/invalid.swift
index 917b013..d817ae1 100644
--- a/test/Generics/invalid.swift
+++ b/test/Generics/invalid.swift
@@ -9,7 +9,7 @@
 
 protocol he where A : B { // expected-error {{'where' clause cannot be attached to a protocol declaration}}
 
-  associatedtype vav where A : B // expected-error {{'where' clause cannot be attached to an associated type declaration}}
+  associatedtype vav where A : B // expected-error {{where clauses on associated types are fragile; use '-swift-version 4' to experiment.}}
 }
 
 
diff --git a/test/Generics/protocol_type_aliases.swift b/test/Generics/protocol_type_aliases.swift
index 3e62aa4..bc580c9 100644
--- a/test/Generics/protocol_type_aliases.swift
+++ b/test/Generics/protocol_type_aliases.swift
@@ -15,9 +15,9 @@
 
 // CHECK-LABEL: .requirementOnNestedTypeAlias@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Q [Explicit @ 22:51]
-// CHECK-NEXT:   τ_0_0[.Q].B : P [Explicit @ 22:51 -> Protocol requirement (Q)]
-// CHECK-NEXT:   τ_0_0[.Q].B[.P].A == Int [Explicit @ 22:62]
+// CHECK-NEXT:   τ_0_0 : Q [τ_0_0: Explicit @ 22:51]
+// CHECK-NEXT:   τ_0_0[.Q].B : P [τ_0_0: Explicit @ 22:51 -> Protocol requirement (Q)]
+// CHECK-NEXT:   τ_0_0[.Q].B[.P].A == Int [τ_0_0[.Q].B[.P].X: Explicit @ 22:62]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q, τ_0_0.B.A == Int>
 func requirementOnNestedTypeAlias<T>(_: T) where T: Q, T.B.X == Int {}
 
@@ -34,19 +34,19 @@
 
 // CHECK-LABEL: .requirementOnConcreteNestedTypeAlias@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Q2 [Explicit @ 42:59]
-// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [Explicit @ 42:59 -> Protocol requirement (Q2)]
-// CHECK-NEXT:   τ_0_0[.Q2].C == S<T.B.A> [Explicit @ 42:69]
-// CHECK-NEXT:   τ_0_0[.Q2].B[.P2].X == S<T.B.A> [Nested type match]
+// CHECK-NEXT:   τ_0_0 : Q2 [τ_0_0: Explicit @ 42:59]
+// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [τ_0_0: Explicit @ 42:59 -> Protocol requirement (Q2)]
+// CHECK-NEXT:   τ_0_0[.Q2].C == S<T.B.A> [τ_0_0[.Q2].C: Explicit @ 42:69]
+// CHECK-NEXT:   τ_0_0[.Q2].B[.P2].X == S<T.B.A> [τ_0_0[.Q2].B[.P2].X: Nested type match]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q2, τ_0_0.C == S<τ_0_0.B.A>>
 func requirementOnConcreteNestedTypeAlias<T>(_: T) where T: Q2, T.C == T.B.X {}
 
 // CHECK-LABEL: .concreteRequirementOnConcreteNestedTypeAlias@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Q2 [Explicit @ 51:67]
-// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [Explicit @ 51:67 -> Protocol requirement (Q2)]
-// CHECK-NEXT:   τ_0_0[.Q2].C == τ_0_0[.Q2].B[.P2].A [Explicit]
-// CHECK-NEXT:   τ_0_0[.Q2].B[.P2].X == S<T.B.A> [Nested type match]
+// CHECK-NEXT:   τ_0_0 : Q2 [τ_0_0: Explicit @ 51:67]
+// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [τ_0_0: Explicit @ 51:67 -> Protocol requirement (Q2)]
+// CHECK-NEXT:   τ_0_0[.Q2].C == τ_0_0[.Q2].B[.P2].A [τ_0_0[.Q2].C: Explicit]
+// CHECK-NEXT:   τ_0_0[.Q2].B[.P2].X == S<T.B.A> [τ_0_0[.Q2].B[.P2].X: Nested type match]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q2, τ_0_0.C == τ_0_0.B.A>
 func concreteRequirementOnConcreteNestedTypeAlias<T>(_: T) where T: Q2, S<T.C> == T.B.X {}
 
diff --git a/test/Generics/requirement_inference.swift b/test/Generics/requirement_inference.swift
index 2491c55..dc1be46 100644
--- a/test/Generics/requirement_inference.swift
+++ b/test/Generics/requirement_inference.swift
@@ -57,7 +57,7 @@
 class Box<T : Fox> {
 // CHECK-LABEL: .unpack@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Fox [Explicit]
+// CHECK-NEXT:   τ_0_0 : Fox [τ_0_0: Explicit]
   func unpack(_ x: X1<T>) {}
 }
 
@@ -77,11 +77,15 @@
 // CHECK-NEXT: Requirements:
 // CHECK-NEXT:   τ_0_0 : Canidae
 func inferSuperclassRequirement1<T : Carnivora>(_ v: V<T>) {}
+// expected-warning@-1{{redundant superclass constraint 'T' : 'Carnivora'}}
+// expected-note@-2{{superclass constraint 'T' : 'Canidae' written here}}
 
 // CHECK-LABEL: .inferSuperclassRequirement2@
 // CHECK-NEXT: Requirements:
 // CHECK-NEXT:   τ_0_0 : Canidae
 func inferSuperclassRequirement2<T : Canidae>(_ v: U<T>) {}
+// expected-warning@-1{{redundant superclass constraint 'T' : 'Carnivora'}}
+// expected-note@-2{{superclass constraint 'T' : 'Canidae' written here}}
 
 // ----------------------------------------------------------------------------
 // Same-type requirements
@@ -111,27 +115,27 @@
 
 // CHECK-LABEL: .inferSameType1@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : P3 [Inferred @ {{.*}}:32]
-// CHECK-NEXT:   τ_0_1 : P4 [Inferred @ {{.*}}:32]
-// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P1 [Inferred @ {{.*}}:32 -> Protocol requirement (P3) -> Protocol requirement (P2)]
-// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P2 [Inferred @ {{.*}}:32 -> Protocol requirement (P3)]
-// FIXME: τ_0_0[.P3].P3Assoc == τ_0_1[.P4].P4Assoc [Inferred]
+// CHECK-NEXT:   τ_0_0 : P3 [τ_0_0: Inferred @ {{.*}}:32]
+// CHECK-NEXT:   τ_0_1 : P4 [τ_0_1: Inferred @ {{.*}}:32]
+// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P1 [τ_0_0: Inferred @ {{.*}}:32 -> Protocol requirement (P3) -> Protocol requirement (P2)]
+// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P2 [τ_0_0: Inferred @ {{.*}}:32 -> Protocol requirement (P3)]
+// FIXME: τ_0_0[.P3].P3Assoc == τ_0_1[.P4].P4Assoc [τ_0_0: Inferred]
 func inferSameType1<T, U>(_ x: Model_P3_P4_Eq<T, U>) { }
 
 // CHECK-LABEL: .inferSameType2@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : P3 [Explicit @ {{.*}}:25]
-// CHECK-NEXT:   τ_0_1 : P4 [Explicit @ {{.*}}:33]
-// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P1 [Explicit @ {{.*}}:25 -> Protocol requirement (P3) -> Protocol requirement (P2)]
-// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P2 [Explicit @ {{.*}}:25 -> Protocol requirement (P3)]
-// CHECK-NEXT:   τ_0_0[.P3].P3Assoc == τ_0_1[.P4].P4Assoc [Explicit]
+// CHECK-NEXT:   τ_0_0 : P3 [τ_0_0: Explicit @ {{.*}}:25]
+// CHECK-NEXT:   τ_0_1 : P4 [τ_0_1: Explicit @ {{.*}}:33]
+// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P1 [τ_0_0: Explicit @ {{.*}}:25 -> Protocol requirement (P3) -> Protocol requirement (P2)]
+// CHECK-NEXT:   τ_0_0[.P3].P3Assoc : P2 [τ_0_0: Explicit @ {{.*}}:25 -> Protocol requirement (P3)]
+// CHECK-NEXT:   τ_0_0[.P3].P3Assoc == τ_0_1[.P4].P4Assoc [τ_0_0[.P3].P3Assoc: Explicit]
 func inferSameType2<T : P3, U : P4>(_: T, _: U) where U.P4Assoc : P2, T.P3Assoc == U.P4Assoc {}
 
 // CHECK-LABEL: .inferSameType3@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : PCommonAssoc1 [Explicit @ {{.*}}:25]
-// CHECK-NEXT:   τ_0_0 : PCommonAssoc2 [Explicit @ {{.*}}:74]
-// CHECK-NEXT:   τ_0_0[.PCommonAssoc1].CommonAssoc : P1 [Explicit @ {{.*}}:66]
+// CHECK-NEXT:   τ_0_0 : PCommonAssoc1 [τ_0_0: Explicit @ {{.*}}:25]
+// CHECK-NEXT:   τ_0_0 : PCommonAssoc2 [τ_0_0: Explicit @ {{.*}}:74]
+// CHECK-NEXT:   τ_0_0[.PCommonAssoc1].CommonAssoc : P1 [τ_0_0[.PCommonAssoc1].CommonAssoc: Explicit @ {{.*}}:66]
 // CHECK-NEXT: Potential archetypes
 func inferSameType3<T : PCommonAssoc1>(_: T) where T.CommonAssoc : P1, T : PCommonAssoc2 {}
 
@@ -177,6 +181,8 @@
 // CHECK-LABEL: sameTypeConcrete2@
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : P10, τ_0_0 : P9, τ_0_0.B == X3, τ_0_0.C == X3>
 func sameTypeConcrete2<T : P9 & P10>(_: T) where T.B : X3, T.C == T.B, T.C == X3 { }
+// expected-warning@-1{{redundant superclass constraint 'T.B' : 'X3'}}
+// expected-note@-2{{same-type constraint 'T.C' == 'X3' written here}}
 
 // Note: a standard-library-based stress test to make sure we don't inject
 // any additional requirements.
@@ -189,6 +195,13 @@
 	func f() { }
 }
 
+// CHECK-LABEL: X14.recursiveConcreteSameType
+// CHECK: Generic signature: <T, V where T == CountableRange<Int>>
+// CHECK-NEXT: Canonical generic signature: <τ_0_0, τ_1_0 where τ_0_0 == CountableRange<Int>>
+struct X14<T: Collection> where T.Iterator == IndexingIterator<T> {
+	func recursiveConcreteSameType<V>(_: V) where T == CountableRange<Int> { }
+}
+
 // rdar://problem/30478915
 protocol P11 {
   associatedtype A
diff --git a/test/Generics/superclass_constraint.swift b/test/Generics/superclass_constraint.swift
index eac9a3e..4eb15ab 100644
--- a/test/Generics/superclass_constraint.swift
+++ b/test/Generics/superclass_constraint.swift
@@ -13,8 +13,13 @@
 
 class Other { }
 
-func f1<T : A>(_: T) where T : Other {} // expected-error{{generic parameter 'T' cannot be a subclass of both 'A' and 'Other'}}
+func f1<T : A>(_: T) where T : Other {} // expected-error{{generic parameter 'T' cannot be a subclass of both 'Other' and 'A'}}
+// expected-note@-1{{superclass constraint 'T' : 'A' written here}}
+
 func f2<T : A>(_: T) where T : B {}
+// expected-warning@-1{{redundant superclass constraint 'T' : 'A'}}
+// expected-note@-2{{superclass constraint 'T' : 'B' written here}}
+
 
 class GA<T> {}
 class GB<T> : GA<T> {}
@@ -27,10 +32,16 @@
 func f6<U : GA<T>, T : P>(_: T, _: U) {}
 func f7<U, T>(_: T, _: U) where U : GA<T>, T : P {}
 
-func f8<T : GA<A>>(_: T) where T : GA<B> {} // expected-error{{generic parameter 'T' cannot be a subclass of both 'GA<A>' and 'GA<B>'}}
+func f8<T : GA<A>>(_: T) where T : GA<B> {} // expected-error{{generic parameter 'T' cannot be a subclass of both 'GA<B>' and 'GA<A>'}}
+// expected-note@-1{{superclass constraint 'T' : 'GA<A>' written here}}
 
 func f9<T : GA<A>>(_: T) where T : GB<A> {}
+// expected-warning@-1{{redundant superclass constraint 'T' : 'GA<A>'}}
+// expected-note@-2{{superclass constraint 'T' : 'GB<A>' written here}}
+
 func f10<T : GB<A>>(_: T) where T : GA<A> {}
+// expected-warning@-1{{redundant superclass constraint 'T' : 'GA<A>'}}
+// expected-note@-2{{superclass constraint 'T' : 'GB<A>' written here}}
 
 func f11<T : GA<T>>(_: T) { } // expected-error{{superclass constraint 'T' : 'GA<T>' is recursive}}
 func f12<T : GA<U>, U : GB<T>>(_: T, _: U) { } // expected-error{{superclass constraint 'U' : 'GB<T>' is recursive}} // expected-error{{superclass constraint 'T' : 'GA<U>' is recursive}}
@@ -64,15 +75,15 @@
 
 // CHECK: superclassConformance1
 // CHECK: Requirements:
-// CHECK-NEXT: τ_0_0 : C [Explicit @ {{.*}}:46]
-// CHECK-NEXT: τ_0_0 : P3 [Explicit @ {{.*}}:46 -> Superclass (C: P3)]
+// CHECK-NEXT: τ_0_0 : C [τ_0_0: Explicit @ {{.*}}:46]
+// CHECK-NEXT: τ_0_0 : P3 [τ_0_0: Explicit @ {{.*}}:46 -> Superclass (C: P3)]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : C>
 func superclassConformance1<T>(t: T) where T : C, T : P3 {}
 
 // CHECK: superclassConformance2
 // CHECK: Requirements:
-// CHECK-NEXT: τ_0_0 : C [Explicit @ {{.*}}:46]
-// CHECK-NEXT: τ_0_0 : P3 [Explicit @ {{.*}}:46 -> Superclass (C: P3)]
+// CHECK-NEXT: τ_0_0 : C [τ_0_0: Explicit @ {{.*}}:46]
+// CHECK-NEXT: τ_0_0 : P3 [τ_0_0: Explicit @ {{.*}}:46 -> Superclass (C: P3)]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : C>
 func superclassConformance2<T>(t: T) where T : C, T : P3 {}
 
@@ -82,23 +93,27 @@
 
 // CHECK: superclassConformance3
 // CHECK: Requirements:
-// CHECK-NEXT: τ_0_0 : C2 [Explicit @ {{.*}}:46]
-// CHECK-NEXT: τ_0_0 : P4 [Explicit @ {{.*}}:46 -> Superclass (C2: P4)]
+// CHECK-NEXT: τ_0_0 : C2 [τ_0_0: Explicit @ {{.*}}:46]
+// CHECK-NEXT: τ_0_0 : P4 [τ_0_0: Explicit @ {{.*}}:61 -> Superclass (C2: P4)]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : C2>
 func superclassConformance3<T>(t: T) where T : C, T : P4, T : C2 {}
+// expected-warning@-1{{redundant superclass constraint 'T' : 'C'}}
+// expected-note@-2{{superclass constraint 'T' : 'C2' written here}}
 
 protocol P5: A { } // expected-error{{non-class type 'P5' cannot inherit from class 'A'}}
 
-protocol P6: A, Other { } // expected-error{{protocol 'P6' cannot be a subclass of both 'A' and 'Other'}}
+protocol P6: A, Other { } // expected-error{{protocol 'P6' cannot be a subclass of both 'Other' and 'A'}}
 // expected-error@-1{{non-class type 'P6' cannot inherit from class 'A'}}
 // expected-error@-2{{non-class type 'P6' cannot inherit from class 'Other'}}
+// expected-note@-3{{superclass constraint 'Self' : 'A' written here}}
 
 func takeA(_: A) { }
 func takeP5<T: P5>(_ t: T) {
 	takeA(t) // okay
 }
 
-protocol P7 { // expected-error{{'Self.Assoc' cannot be a subclass of both 'A' and 'Other'}}
+protocol P7 { // expected-error{{'Self.Assoc' cannot be a subclass of both 'Other' and 'A'}}
 	associatedtype Assoc: A, Other 
 	// FIXME: expected-error@-1{{multiple inheritance from classes 'A' and 'Other'}}
+	// FIXME weird location: expected-note@-3{{superclass constraint 'Self.Assoc' : 'A' written here}}
 }
diff --git a/test/IDE/print_ast_tc_decls_errors.swift b/test/IDE/print_ast_tc_decls_errors.swift
index f226d8a..2affaa9 100644
--- a/test/IDE/print_ast_tc_decls_errors.swift
+++ b/test/IDE/print_ast_tc_decls_errors.swift
@@ -157,7 +157,7 @@
 // NO-TYREPR: {{^}}protocol ProtocolWithInheritance4 : <<error type>>, FooProtocol {{{$}}
 // TYREPR: {{^}}protocol ProtocolWithInheritance4 : FooClass, FooProtocol {{{$}}
 
-protocol ProtocolWithInheritance5 : FooClass, BarClass {} // expected-error {{non-class type 'ProtocolWithInheritance5' cannot inherit from class 'FooClass'}} expected-error {{non-class type 'ProtocolWithInheritance5' cannot inherit from class 'BarClass'}} expected-error{{protocol 'ProtocolWithInheritance5' cannot be a subclass of both 'FooClass' and 'BarClass'}}
+protocol ProtocolWithInheritance5 : FooClass, BarClass {} // expected-error {{non-class type 'ProtocolWithInheritance5' cannot inherit from class 'FooClass'}} expected-error {{non-class type 'ProtocolWithInheritance5' cannot inherit from class 'BarClass'}} expected-error{{protocol 'ProtocolWithInheritance5' cannot be a subclass of both 'BarClass' and 'FooClass'}} // expected-note{{superclass constraint 'Self' : 'FooClass' written here}}
 // NO-TYREPR: {{^}}protocol ProtocolWithInheritance5 : <<error type>>, <<error type>> {{{$}}
 // TYREPR: {{^}}protocol ProtocolWithInheritance5 : FooClass, BarClass {{{$}}
 
diff --git a/test/IDE/print_usrs.swift b/test/IDE/print_usrs.swift
index aafed58..e05000d 100644
--- a/test/IDE/print_usrs.swift
+++ b/test/IDE/print_usrs.swift
@@ -173,9 +173,9 @@
     set {}
   }
 
-  // CHECK: [[@LINE+1]]:3 c:objc(cs)ObjCClass1(cm)initWithX:{{$}}
+  // CHECK: [[@LINE+1]]:3 c:objc(cs)ObjCClass1(im)initWithX:{{$}}
   init(x: Int) {}
-  // CHECK: [[@LINE+1]]:3 c:objc(cs)ObjCClass1(cm)init{{$}}
+  // CHECK: [[@LINE+1]]:3 c:objc(cs)ObjCClass1(im)init{{$}}
   init() {}
 
   // CHECK: [[@LINE+1]]:8 c:objc(cs)ObjCClass1(im)instanceFunc1:{{$}}
diff --git a/test/IDE/range_info_basics.swift b/test/IDE/range_info_basics.swift
index 9a0b919..9483408 100644
--- a/test/IDE/range_info_basics.swift
+++ b/test/IDE/range_info_basics.swift
@@ -159,7 +159,7 @@
 // CHECK4-NEXT: <Content>aaa = aaa + 3
 // CHECK4-NEXT: if aaa == 3 { aaa = 4 }</Content>
 // CHECK4-NEXT: <Type>Void</Type>
-// CHECK4-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK4-NEXT: <Context>swift_ide_test.(file).foo()</Context>
 // CHECK4-NEXT: <Referenced>aaa</Referenced><Type>@lvalue Int</Type>
 // CHECK4-NEXT: <ASTNodes>2</ASTNodes>
 // CHECK4-NEXT: <end>
@@ -169,7 +169,7 @@
 // CHECK5-NEXT: if aaa == 3 { aaa = 4 }
 // CHECK5-NEXT: return aaa</Content>
 // CHECK5-NEXT: <Type>Int</Type>
-// CHECK5-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK5-NEXT: <Context>swift_ide_test.(file).foo()</Context>
 // CHECK5-NEXT: <Referenced>aaa</Referenced><Type>@lvalue Int</Type>
 // CHECK5-NEXT: <ASTNodes>3</ASTNodes>
 // CHECK5-NEXT: <end>
@@ -178,7 +178,7 @@
 // CHECK6-NEXT: if aaa == 3 { aaa = 4 }
 // CHECK6-NEXT: return aaa</Content>
 // CHECK6-NEXT: <Type>Int</Type>
-// CHECK6-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK6-NEXT: <Context>swift_ide_test.(file).foo()</Context>
 // CHECK6-NEXT: <Referenced>aaa</Referenced><Type>@lvalue Int</Type>
 // CHECK6-NEXT: <ASTNodes>2</ASTNodes>
 // CHECK6-NEXT: <end>
@@ -189,7 +189,7 @@
 // CHECK7-NEXT:   b = b.bigEndian.bigEndian.byteSwapped
 // CHECK7-NEXT:   print(b + c)</Content>
 // CHECK7-NEXT: <Type>()</Type>
-// CHECK7-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK7-NEXT: <Context>swift_ide_test.(file).foo2()</Context>
 // CHECK7-NEXT: <Declared>b</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK7-NEXT: <Declared>c</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK7-NEXT: <Referenced>a</Referenced><Type>Int</Type>
@@ -203,7 +203,7 @@
 // CHECK8-NEXT:   s = s.increment()
 // CHECK8-NEXT:   return c + b</Content>
 // CHECK8-NEXT: <Type>Int</Type>
-// CHECK8-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK8-NEXT: <Context>swift_ide_test.(file).foo3(s:)</Context>
 // CHECK8-NEXT: <Declared>c</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK8-NEXT: <Referenced>s</Referenced><Type>@lvalue S1</Type>
 // CHECK8-NEXT: <Referenced>b</Referenced><Type>Int</Type>
@@ -216,7 +216,7 @@
 // CHECK9-NEXT:   let c = s.foo() + b
 // CHECK9-NEXT:   return c + b</Content>
 // CHECK9-NEXT: <Type>Int</Type>
-// CHECK9-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK9-NEXT: <Context>swift_ide_test.(file).foo4(s:)</Context>
 // CHECK9-NEXT: <Declared>b</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK9-NEXT: <Declared>c</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK9-NEXT: <Referenced>s</Referenced><Type>S1</Type>
@@ -228,7 +228,7 @@
 // CHECK10: <Kind>MultiStatement</Kind>
 // CHECK10-NEXT: <Content>let a = c.c.getC().c.getC().getC().getC()
 // CHECK10-NEXT:   let b = a.c.c.c.c.getC().getC()</Content>
-// CHECK10-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK10-NEXT: <Context>swift_ide_test.(file).foo5(c:)</Context>
 // CHECK10-NEXT: <Declared>a</Declared><OutscopeReference>true</OutscopeReference>
 // CHECK10-NEXT: <Declared>b</Declared><OutscopeReference>true</OutscopeReference>
 // CHECK10-NEXT: <Referenced>c</Referenced><Type>C1</Type>
@@ -240,7 +240,7 @@
 // CHECK11-NEXT: <Content>let a = c.c.getC().c.getC().getC().getC()
 // CHECK11-NEXT:   let b = a.c.c.c.c.getC().getC()
 // CHECK11-NEXT:   let d = a.c.getC().getC().c.c</Content>
-// CHECK11-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK11-NEXT: <Context>swift_ide_test.(file).foo5(c:)</Context>
 // CHECK11-NEXT: <Declared>a</Declared><OutscopeReference>true</OutscopeReference>
 // CHECK11-NEXT: <Declared>b</Declared><OutscopeReference>true</OutscopeReference>
 // CHECK11-NEXT: <Declared>d</Declared><OutscopeReference>true</OutscopeReference>
@@ -255,7 +255,7 @@
 // CHECK12-NEXT:   let d = a.c.getC().getC().c.c
 // CHECK12-NEXT:   return a.take(another: b).take(another: d)</Content>
 // CHECK12-NEXT: <Type>C1</Type>
-// CHECK12-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK12-NEXT: <Context>swift_ide_test.(file).foo5(c:)</Context>
 // CHECK12-NEXT: <Declared>a</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK12-NEXT: <Declared>b</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK12-NEXT: <Declared>d</Declared><OutscopeReference>false</OutscopeReference>
@@ -273,7 +273,7 @@
 // CHECK13-NEXT:     b = b.bigEndian.bigEndian.byteSwapped
 // CHECK13-NEXT:     print(b + c)</Content>
 // CHECK13-NEXT: <Type>()</Type>
-// CHECK13-NEXT: <Context>swift_ide_test.(file).func decl.explicit closure discriminator=0</Context>
+// CHECK13-NEXT: <Context>swift_ide_test.(file).foo6().explicit closure discriminator=0</Context>
 // CHECK13-NEXT: <Declared>a</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK13-NEXT: <Declared>b</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK13-NEXT: <Declared>c</Declared><OutscopeReference>false</OutscopeReference>
@@ -298,7 +298,7 @@
 // CHECK14-NEXT:       return 1
 // CHECK14-NEXT:     }()</Content>
 // CHECK14-NEXT: <Type>Int</Type>
-// CHECK14-NEXT: <Context>swift_ide_test.(file).func decl.explicit closure discriminator=0</Context>
+// CHECK14-NEXT: <Context>swift_ide_test.(file).foo6().explicit closure discriminator=0</Context>
 // CHECK14-NEXT: <Declared>a</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK14-NEXT: <Declared>b</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK14-NEXT: <Declared>c</Declared><OutscopeReference>false</OutscopeReference>
@@ -320,7 +320,7 @@
 // CHECK15-NEXT:       let c = a.byteSwapped
 // CHECK15-NEXT:       b = b.bigEndian.bigEndian.byteSwapped</Content>
 // CHECK15-NEXT: <Type>()</Type>
-// CHECK15-NEXT: <Context>swift_ide_test.(file).func decl.explicit closure discriminator=0.explicit closure discriminator=0</Context>
+// CHECK15-NEXT: <Context>swift_ide_test.(file).foo6().explicit closure discriminator=0.explicit closure discriminator=0</Context>
 // CHECK15-NEXT: <Declared>a</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK15-NEXT: <Declared>b</Declared><OutscopeReference>true</OutscopeReference>
 // CHECK15-NEXT: <Declared>c</Declared><OutscopeReference>true</OutscopeReference>
@@ -337,7 +337,7 @@
 // CHECK16-NEXT:       print(b + c)
 // CHECK16-NEXT:       return 1</Content>
 // CHECK16-NEXT: <Type>Int</Type>
-// CHECK16-NEXT: <Context>swift_ide_test.(file).func decl.explicit closure discriminator=0.explicit closure discriminator=0</Context>
+// CHECK16-NEXT: <Context>swift_ide_test.(file).foo6().explicit closure discriminator=0.explicit closure discriminator=0</Context>
 // CHECK16-NEXT: <Declared>a</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK16-NEXT: <Declared>b</Declared><OutscopeReference>false</OutscopeReference>
 // CHECK16-NEXT: <Declared>c</Declared><OutscopeReference>false</OutscopeReference>
@@ -350,7 +350,7 @@
 // CHECK17: <Kind>SingleExpression</Kind>
 // CHECK17-NEXT: <Content>print(b + c)</Content>
 // CHECK17-NEXT: <Type>()</Type>
-// CHECK17-NEXT: <Context>swift_ide_test.(file).func decl.explicit closure discriminator=0.explicit closure discriminator=0</Context>
+// CHECK17-NEXT: <Context>swift_ide_test.(file).foo6().explicit closure discriminator=0.explicit closure discriminator=0</Context>
 // CHECK17-NEXT: <Referenced>b</Referenced><Type>@lvalue Int</Type>
 // CHECK17-NEXT: <Referenced>c</Referenced><Type>Int</Type>
 // CHECK17-NEXT: <ASTNodes>1</ASTNodes>
@@ -362,7 +362,7 @@
 // CHECK18-NEXT:   case 2:
 // CHECK18-NEXT:     return 1</Content>
 // CHECK18-NEXT: <Type>Void</Type>
-// CHECK18-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK18-NEXT: <Context>swift_ide_test.(file).foo7(a:)</Context>
 // CHECK18-NEXT: <Entry>Multi</Entry>
 // CHECK18-NEXT: <ASTNodes>2</ASTNodes>
 // CHECK18-NEXT: <end>
@@ -371,7 +371,7 @@
 // CHECK19-NEXT: <Content>case 1:
 // CHECK19-NEXT:     return 0</Content>
 // CHECK19-NEXT: <Type>Void</Type>
-// CHECK19-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK19-NEXT: <Context>swift_ide_test.(file).foo7(a:)</Context>
 // CHECK19-NEXT: <ASTNodes>1</ASTNodes>
 // CHECK19-NEXT: <end>
 
@@ -381,7 +381,7 @@
 // CHECK20-NEXT:   default:
 // CHECK20-NEXT:     return a</Content>
 // CHECK20-NEXT: <Type>Void</Type>
-// CHECK20-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK20-NEXT: <Context>swift_ide_test.(file).foo7(a:)</Context>
 // CHECK20-NEXT: <Entry>Multi</Entry>
 // CHECK20-NEXT: <ASTNodes>2</ASTNodes>
 // CHECK20-NEXT: <end>
diff --git a/test/IDE/reconstruct_type_from_mangled_name_invalid.swift b/test/IDE/reconstruct_type_from_mangled_name_invalid.swift
index f001da0..80deae5 100644
--- a/test/IDE/reconstruct_type_from_mangled_name_invalid.swift
+++ b/test/IDE/reconstruct_type_from_mangled_name_invalid.swift
@@ -1,5 +1,5 @@
 // RUN: %target-swift-ide-test -reconstruct-type -source-filename %s | %FileCheck %s -implicit-check-not="FAILURE"
-// REQUIRES: rdar://problem/30680565
+// REQUIRES: rdar30680565
 
 struct GS<T> {
 // CHECK: decl: struct GS<T> for 'GS'
diff --git a/test/IRGen/abitypes.swift b/test/IRGen/abitypes.swift
index a4adaea..65c8398 100644
--- a/test/IRGen/abitypes.swift
+++ b/test/IRGen/abitypes.swift
@@ -551,7 +551,7 @@
 // arm64-ios:  [[STRUCTPTR:%.*]] = bitcast i64* [[COERCED]] to %TSC14FiveByteStructV
 // arm64-ios:  [[PTR0:%.*]] = getelementptr inbounds %TSC14FiveByteStructV, %TSC14FiveByteStructV* [[STRUCTPTR]], {{i.*}} 0, {{i.*}} 0
 // arm64-ios:  [[PTR1:%.*]] = getelementptr inbounds %T10ObjectiveC8ObjCBoolV, %T10ObjectiveC8ObjCBoolV* [[PTR0]], {{i.*}} 0, {{i.*}} 0
-// arm64-ios:  [[PTR2:%.*]] = getelementptr inbounds %Sb, %Sb* [[PTR1]], {{i.*}} 0, {{i.*}} 0
+// arm64-ios:  [[PTR2:%.*]] = getelementptr inbounds %TSb, %TSb* [[PTR1]], {{i.*}} 0, {{i.*}} 0
 // arm64-ios:  store i1 false, i1* [[PTR2]], align 8
 // arm64-ios:  [[ARG:%.*]] = load i64, i64* [[COERCED]]
 // arm64-ios:  call void bitcast (void ()* @objc_msgSend to void (i8*, i8*, i64)*)(i8* {{.*}}, i8* {{.*}}, i64 [[ARG]])
diff --git a/test/IRGen/asmname.swift b/test/IRGen/asmname.swift
index 86b5589..f55275d 100644
--- a/test/IRGen/asmname.swift
+++ b/test/IRGen/asmname.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 @_silgen_name("atan2") func atan2test(_ a: Double, _ b: Double) -> Double
 
diff --git a/test/IRGen/associated_types.swift b/test/IRGen/associated_types.swift
index 6b1a4da..2260286 100644
--- a/test/IRGen/associated_types.swift
+++ b/test/IRGen/associated_types.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -emit-ir -primary-file %s | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 protocol Runcer {
   associatedtype Runcee
@@ -30,7 +30,7 @@
 class Pussycat<T : Runcible, U> {
   init() {} 
 
-  // CHECK: define hidden swiftcc void @_T016associated_types8PussycatC3eat{{[_0-9a-zA-Z]*}}F(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %C16associated_types8Pussycat* swiftself)
+  // CHECK: define hidden swiftcc void @_T016associated_types8PussycatC3eat{{[_0-9a-zA-Z]*}}F(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %T16associated_types8PussycatC* swiftself)
   func eat(_ what: T.RuncerType.Runcee, and: T.RuncerType, with: T) { }
 }
 
diff --git a/test/IRGen/bitcast.sil b/test/IRGen/bitcast.sil
index 02b8cc0..96c3c36 100644
--- a/test/IRGen/bitcast.sil
+++ b/test/IRGen/bitcast.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir| %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 sil_stage canonical
 
@@ -16,20 +16,20 @@
 
 protocol CP: class {}
 
-// CHECK-i386-LABEL: define{{( protected)?}} swiftcc i32 @bitcast_trivial(%C7bitcast1C*) {{.*}} {
-// CHECK-i386:         [[BUF:%.*]] = alloca %C7bitcast1C*, align 4
-// CHECK-i386:         store %C7bitcast1C* %0, %C7bitcast1C** [[BUF]]
-// CHECK-i386:         [[OUT_BUF:%.*]] = bitcast %C7bitcast1C** [[BUF]] to %Si*
-// CHECK-i386:         [[VALUE_BUF:%.*]] = getelementptr inbounds %Si, %Si* [[OUT_BUF]], i32 0, i32 0
+// CHECK-i386-LABEL: define{{( protected)?}} swiftcc i32 @bitcast_trivial(%T7bitcast1CC*) {{.*}} {
+// CHECK-i386:         [[BUF:%.*]] = alloca %T7bitcast1CC*, align 4
+// CHECK-i386:         store %T7bitcast1CC* %0, %T7bitcast1CC** [[BUF]]
+// CHECK-i386:         [[OUT_BUF:%.*]] = bitcast %T7bitcast1CC** [[BUF]] to %TSi*
+// CHECK-i386:         [[VALUE_BUF:%.*]] = getelementptr inbounds %TSi, %TSi* [[OUT_BUF]], i32 0, i32 0
 // CHECK-i386:         [[VALUE:%.*]] = load i32, i32* [[VALUE_BUF]], align 4
 // CHECK-i386:         ret i32 [[VALUE]]
 // CHECK-i386:       }
 
-// CHECK-x86_64-LABEL: define{{( protected)?}} swiftcc i64 @bitcast_trivial(%C7bitcast1C*) {{.*}} {
-// CHECK-x86_64:         [[BUF:%.*]] = alloca %C7bitcast1C*, align 8
-// CHECK-x86_64:         store %C7bitcast1C* %0, %C7bitcast1C** [[BUF]]
-// CHECK-x86_64:         [[OUT_BUF:%.*]] = bitcast %C7bitcast1C** [[BUF]] to %Si*
-// CHECK-x86_64:         [[VALUE_BUF:%.*]] = getelementptr inbounds %Si, %Si* [[OUT_BUF]], i32 0, i32 0
+// CHECK-x86_64-LABEL: define{{( protected)?}} swiftcc i64 @bitcast_trivial(%T7bitcast1CC*) {{.*}} {
+// CHECK-x86_64:         [[BUF:%.*]] = alloca %T7bitcast1CC*, align 8
+// CHECK-x86_64:         store %T7bitcast1CC* %0, %T7bitcast1CC** [[BUF]]
+// CHECK-x86_64:         [[OUT_BUF:%.*]] = bitcast %T7bitcast1CC** [[BUF]] to %TSi*
+// CHECK-x86_64:         [[VALUE_BUF:%.*]] = getelementptr inbounds %TSi, %TSi* [[OUT_BUF]], i32 0, i32 0
 // CHECK-x86_64:         [[VALUE:%.*]] = load i64, i64* [[VALUE_BUF]], align 8
 // CHECK-x86_64:         ret i64 [[VALUE]]
 // CHECK-x86_64:       }
@@ -54,15 +54,15 @@
   return %i : $Optional<Int>
 }
 
-// CHECK-i386-LABEL: define{{( protected)?}} swiftcc i32 @bitcast_ref(%C7bitcast1C*) {{.*}} {
+// CHECK-i386-LABEL: define{{( protected)?}} swiftcc i32 @bitcast_ref(%T7bitcast1CC*) {{.*}} {
 // CHECK-i386-NEXT:  entry:
-// CHECK-i386-NEXT:    [[VALUE:%.*]] = ptrtoint %C7bitcast1C* %0 to i32
+// CHECK-i386-NEXT:    [[VALUE:%.*]] = ptrtoint %T7bitcast1CC* %0 to i32
 // CHECK-i386-NEXT:    ret i32 [[VALUE]]
 // CHECK-i386-NEXT:  }
 
-// CHECK-x86_64-LABEL: define{{( protected)?}} swiftcc i64 @bitcast_ref(%C7bitcast1C*) {{.*}} {
+// CHECK-x86_64-LABEL: define{{( protected)?}} swiftcc i64 @bitcast_ref(%T7bitcast1CC*) {{.*}} {
 // CHECK-x86_64-NEXT:  entry:
-// CHECK-x86_64-NEXT:    [[VALUE:%.*]] = ptrtoint %C7bitcast1C* %0 to i64
+// CHECK-x86_64-NEXT:    [[VALUE:%.*]] = ptrtoint %T7bitcast1CC* %0 to i64
 // CHECK-x86_64-NEXT:    ret i64 [[VALUE]]
 // CHECK-x86_64-NEXT:  }
 sil @bitcast_ref: $@convention(thin) (C) -> Optional<C> {
@@ -88,12 +88,12 @@
 
 // CHECK-x86_64-LABEL: define hidden swiftcc i64 @unchecked_bitwise_cast(i64, i64) {{.*}} {
 // CHECK-x86_64-NEXT: entry:
-// CHECK-x86_64-NEXT: alloca <{ %Si, %Si }>, align 8
+// CHECK-x86_64-NEXT: alloca <{ %TSi, %TSi }>, align 8
 //   A bunch of GEPs happen here to get from Int to int.
 // CHECK-x86_64:      store i64 %{{.*}}, i64* %bitcast.elt._value, align 8
 // CHECK-x86_64:      store i64 %{{.*}}, i64* %bitcast.elt1._value, align 8
-// CHECK-x86_64-NEXT: %{{.*}} = bitcast <{ %Si, %Si }>* %bitcast to %Si*
-// CHECK-x86_64-NEXT: [[VAL:%.*]] = getelementptr inbounds %Si, %Si* %{{.*}}, i32 0, i32 0
+// CHECK-x86_64-NEXT: %{{.*}} = bitcast <{ %TSi, %TSi }>* %bitcast to %TSi*
+// CHECK-x86_64-NEXT: [[VAL:%.*]] = getelementptr inbounds %TSi, %TSi* %{{.*}}, i32 0, i32 0
 // CHECK-x86_64-NEXT: [[RESULT:%.*]] = load i64, i64* [[VAL]], align 8
 // CHECK-x86_64:      ret i64 [[RESULT]]
 // CHECK-x86_64-NEXT: }
@@ -107,7 +107,7 @@
 // CHECK-x86_64-LABEL: define hidden swiftcc i64 @trivial_bitwise_cast(i64, i64) {{.*}} {
 // CHECK-x86_64-NOT: trap
 // CHECK-x86_64-NOT: unreachable
-// CHECK-x86_64: bitcast <{ %Si, %Si }>* %bitcast to %Si*
+// CHECK-x86_64: bitcast <{ %TSi, %TSi }>* %bitcast to %TSi*
 // CHECK-x86_64: ret
 sil hidden [noinline] @trivial_bitwise_cast : $@convention(thin) (Int, Int) -> Int {
 bb0(%0 : $Int, %1 : $Int):
@@ -131,11 +131,11 @@
 }
 
 // CHECK-i386-LABEL: define{{( protected)?}} swiftcc i32 @unchecked_ref_cast_class_optional
-// CHECK-i386: ptrtoint %C7bitcast1A* %0 to i32
+// CHECK-i386: ptrtoint %T7bitcast1AC* %0 to i32
 // CHECK-i386-NEXT: ret i32
 
 // CHECK-x86_64-LABEL: define{{( protected)?}} swiftcc i64 @unchecked_ref_cast_class_optional
-// CHECK-x86_64: ptrtoint %C7bitcast1A* %0 to i64
+// CHECK-x86_64: ptrtoint %T7bitcast1AC* %0 to i64
 // CHECK-x86_64-NEXT: ret i64
 sil @unchecked_ref_cast_class_optional : $@convention(thin) (@owned A) -> @owned Optional<AnyObject> {
 bb0(%0 : $A):
diff --git a/test/IRGen/bitcast_different_size.sil b/test/IRGen/bitcast_different_size.sil
index 0ae508a..f4839af 100644
--- a/test/IRGen/bitcast_different_size.sil
+++ b/test/IRGen/bitcast_different_size.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s -verify | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 sil_stage canonical
 
diff --git a/test/IRGen/casts.sil b/test/IRGen/casts.sil
index 1203b76..ef94f22 100644
--- a/test/IRGen/casts.sil
+++ b/test/IRGen/casts.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -Xllvm -sil-disable-pass="External Defs To Decls" %s -emit-ir -disable-objc-attr-requires-foundation-module | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // XFAIL: linux
 
 sil_stage canonical
@@ -16,8 +16,8 @@
 sil_vtable A {}
 sil_vtable B {}
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc %C5casts1B* @unchecked_addr_cast(%C5casts1A** noalias nocapture dereferenceable({{.*}})) {{.*}} {
-// CHECK:         bitcast %C5casts1A** %0 to %C5casts1B**
+// CHECK-LABEL: define{{( protected)?}} swiftcc %T5casts1BC* @unchecked_addr_cast(%T5casts1AC** noalias nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK:         bitcast %T5casts1AC** %0 to %T5casts1BC**
 sil @unchecked_addr_cast : $(@in A) -> B {
 entry(%a : $*A):
   %b = unchecked_addr_cast %a : $*A to $*B
@@ -207,7 +207,7 @@
   unreachable
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc %objc_object* @checked_upcast(%C5casts1A*) {{.*}} {
+// CHECK-LABEL: define{{( protected)?}} swiftcc %objc_object* @checked_upcast(%T5casts1AC*) {{.*}} {
 // -- Don't need to check conformance of an object to AnyObject.
 // CHECK-NOT:     call %objc_object* @swift_dynamicCastObjCProtocolConditional
 // CHECK:         phi %objc_object*
@@ -220,14 +220,14 @@
   unreachable
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc %C5casts1A* @checked_downcast_optional({{(i32|i64)}}) {{.*}} {
-// CHECK:         [[T0:%.*]] = inttoptr {{(i32|i64)}} %0 to %C5casts1A*
-// CHECK:         [[OBJ_PTR:%.*]] = bitcast %C5casts1A* [[T0]] to i8*
+// CHECK-LABEL: define{{( protected)?}} swiftcc %T5casts1AC* @checked_downcast_optional({{(i32|i64)}}) {{.*}} {
+// CHECK:         [[T0:%.*]] = inttoptr {{(i32|i64)}} %0 to %T5casts1AC*
+// CHECK:         [[OBJ_PTR:%.*]] = bitcast %T5casts1AC* [[T0]] to i8*
 // CHECK:         [[METADATA:%.*]] = call %swift.type* @_T05casts1ACMa()
 // CHECK:         [[METADATA_PTR:%.*]] = bitcast %swift.type* [[METADATA]] to i8*
 // CHECK:         [[RESULT_PTR:%.*]] = call i8* @swift_rt_swift_dynamicCastClass(i8* [[OBJ_PTR]], i8* [[METADATA_PTR]])
-// CHECK:         [[RESULT:%.*]] = bitcast i8* [[RESULT_PTR]] to %C5casts1A*
-// CHECK:         [[COND:%.*]] = icmp ne %C5casts1A* [[RESULT]], null
+// CHECK:         [[RESULT:%.*]] = bitcast i8* [[RESULT_PTR]] to %T5casts1AC*
+// CHECK:         [[COND:%.*]] = icmp ne %T5casts1AC* [[RESULT]], null
 // CHECK:         br i1 [[COND]]
 sil @checked_downcast_optional : $@convention(thin) (Optional<A>) -> @owned A {
 entry(%a : $Optional<A>):
@@ -317,7 +317,7 @@
   return %x : $OB
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc %C5casts1B* @checked_object_to_object_casts(%C5casts1A*)
+// CHECK-LABEL: define{{( protected)?}} swiftcc %T5casts1BC* @checked_object_to_object_casts(%T5casts1AC*)
 // CHECK:         @swift_dynamicCastClassUnconditional
 sil @checked_object_to_object_casts : $@convention(thin) (A) -> B {
 entry(%a : $A):
@@ -325,7 +325,7 @@
   return %b : $B
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc %C5casts2OB* @checked_objc_object_to_object_casts(%C5casts2OA*)
+// CHECK-LABEL: define{{( protected)?}} swiftcc %T5casts2OBC* @checked_objc_object_to_object_casts(%T5casts2OAC*)
 // CHECK:         @swift_dynamicCastClassUnconditional
 sil @checked_objc_object_to_object_casts : $@convention(thin) (OA) -> OB {
 entry(%a : $OA):
diff --git a/test/IRGen/cf.sil b/test/IRGen/cf.sil
index 29993a9..606b888 100644
--- a/test/IRGen/cf.sil
+++ b/test/IRGen/cf.sil
@@ -1,10 +1,10 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -sdk %S/Inputs %s -emit-ir -import-cf-types | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // REQUIRES: objc_interop
 
 // CHECK: [[TYPE:%swift.type]] = type
-// CHECK: [[REFRIGERATOR:%CSo14CCRefrigerator]] = type
+// CHECK: [[REFRIGERATOR:%TSo14CCRefrigeratorC]] = type
 // CHECK: [[OBJC:%objc_object]] = type
 
 // CHECK: [[REFRIGERATOR_NAME:@.*]] = private unnamed_addr constant [20 x i8] c"So14CCRefrigeratorC\00"
diff --git a/test/IRGen/clang_inline.swift b/test/IRGen/clang_inline.swift
index c59b912..58eec15 100644
--- a/test/IRGen/clang_inline.swift
+++ b/test/IRGen/clang_inline.swift
@@ -12,7 +12,7 @@
 // RUN: %FileCheck %s < %t.ll
 // RUN: %FileCheck -check-prefix=NEGATIVE %s < %t.ll
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // XFAIL: linux
 
 #if IMPORT_EMPTY
@@ -21,7 +21,7 @@
 
 import gizmo
 
-// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF(%C12clang_inline16CallStaticInline* swiftself) {{.*}} {
+// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF(%T12clang_inline16CallStaticInlineC* swiftself) {{.*}} {
 class CallStaticInline {
   func ReturnZero() -> Int64 { return Int64(zero()) }
 }
@@ -29,7 +29,7 @@
 // CHECK-LABEL: define internal i32 @zero()
 // CHECK:         [[INLINEHINT_SSP_UWTABLE:#[0-9]+]] {
 
-// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF(%C12clang_inline17CallStaticInline2* swiftself) {{.*}} {
+// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF(%T12clang_inline17CallStaticInline2C* swiftself) {{.*}} {
 class CallStaticInline2 {
   func ReturnZero() -> Int64 { return Int64(wrappedZero()) }
 }
diff --git a/test/IRGen/clang_inline_reverse.swift b/test/IRGen/clang_inline_reverse.swift
index 2891dc8..f0d587b 100644
--- a/test/IRGen/clang_inline_reverse.swift
+++ b/test/IRGen/clang_inline_reverse.swift
@@ -2,19 +2,19 @@
 
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -sdk %S/Inputs -primary-file %s -emit-ir -module-name clang_inline | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // XFAIL: linux
 
 import gizmo
 
-// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF(%C12clang_inline16CallStaticInline* swiftself) {{.*}} {
+// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF(%T12clang_inline16CallStaticInlineC* swiftself) {{.*}} {
 class CallStaticInline {
   func ReturnZero() -> Int64 { return Int64(wrappedZero()) }
 }
 
 // CHECK-LABEL: define internal i32 @wrappedZero() {{#[0-9]+}} {
 
-// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF(%C12clang_inline17CallStaticInline2* swiftself) {{.*}} {
+// CHECK-LABEL: define hidden swiftcc i64 @_T012clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF(%T12clang_inline17CallStaticInline2C* swiftself) {{.*}} {
 class CallStaticInline2 {
   func ReturnZero() -> Int64 { return Int64(zero()) }
 }
diff --git a/test/IRGen/class_bounded_generics.swift b/test/IRGen/class_bounded_generics.swift
index a71fa83..242fe80 100644
--- a/test/IRGen/class_bounded_generics.swift
+++ b/test/IRGen/class_bounded_generics.swift
@@ -88,6 +88,9 @@
   // CHECK: [[INHERITED:%.*]] = load i8*, i8** %T.ClassBoundBinary, align 8
   // CHECK: [[INHERITED_WTBL:%.*]] = bitcast i8* [[INHERITED]] to i8**
   // CHECK: [[WITNESS:%.*]] = load i8*, i8** [[INHERITED_WTBL]], align 8
+  // FIXME: Redundant load of inherited conformance
+  // CHECK: [[INHERITED:%.*]] = load i8*, i8** %T.ClassBoundBinary, align 8
+  // CHECK: [[INHERITED_WTBL:%.*]] = bitcast i8* [[INHERITED]] to i8**
   // CHECK: [[WITNESS_FUNC:%.*]] = bitcast i8* [[WITNESS]] to void (%objc_object*, %swift.type*, i8**)
   // CHECK: call swiftcc void [[WITNESS_FUNC]](%objc_object* swiftself %0, %swift.type* {{.*}}, i8** [[INHERITED_WTBL]])
   x.classBoundBinaryMethod(y)
diff --git a/test/IRGen/dynamic_cast.sil b/test/IRGen/dynamic_cast.sil
index 95e89e6..0f00bdb 100644
--- a/test/IRGen/dynamic_cast.sil
+++ b/test/IRGen/dynamic_cast.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -emit-ir %s | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 // We have to claim this is raw SIL because there are critical edges from non
 // cond_br instructions.
@@ -17,7 +17,7 @@
   var v: Int
 }
 
-// CHECK: [[INT:%Si]] = type <{ [[LLVM_PTRSIZE_INT:i(32|64)]] }>
+// CHECK: [[INT:%TSi]] = type <{ [[LLVM_PTRSIZE_INT:i(32|64)]] }>
 
 // CHECK-LABEL: define{{( protected)?}} swiftcc void @testUnconditional0(
 sil @testUnconditional0 : $@convention(thin) (@in P) -> () {
diff --git a/test/IRGen/dynamic_lookup.sil b/test/IRGen/dynamic_lookup.sil
index 337bd98..af7a081 100644
--- a/test/IRGen/dynamic_lookup.sil
+++ b/test/IRGen/dynamic_lookup.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -emit-ir %s | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // REQUIRES: objc_interop
 
 import Swift
diff --git a/test/IRGen/dynamic_self.sil b/test/IRGen/dynamic_self.sil
index c8cae59..07b2c34 100644
--- a/test/IRGen/dynamic_self.sil
+++ b/test/IRGen/dynamic_self.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 sil_stage canonical
 
diff --git a/test/IRGen/enum.sil b/test/IRGen/enum.sil
index 3210f64..3daf1d2 100644
--- a/test/IRGen/enum.sil
+++ b/test/IRGen/enum.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil %s -gnone -emit-ir -disable-objc-attr-requires-foundation-module | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize --check-prefix=CHECK-%target-runtime-%target-ptrsize
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 // We have to claim this is raw SIL because there are critical edges from non
 // cond_br instructions.
@@ -10,42 +10,42 @@
 import Swift
 
 // -- Singleton enum. The representation is just the singleton payload.
-// CHECK: %O4enum9Singleton = type <{ <{ i64, i64 }> }>
+// CHECK: %T4enum9SingletonO = type <{ <{ i64, i64 }> }>
 
 // -- Singleton enum with heap object ref payload. <rdar://problem/15679353>
-// CHECK: %O4enum12SingletonRef = type <{ %swift.refcounted* }>
+// CHECK: %T4enum12SingletonRefO = type <{ %swift.refcounted* }>
 
 // -- No-payload enums. The representation is just an enum tag.
-// CHECK: %O4enum10NoPayloads = type <{ i8 }>
-// CHECK: %O4enum11NoPayloads2 = type <{ i8 }>
+// CHECK: %T4enum10NoPayloadsO = type <{ i8 }>
+// CHECK: %T4enum11NoPayloads2O = type <{ i8 }>
 
 // -- Single-payload enum, no extra inhabitants in the payload type. The
 //    representation adds a tag bit to distinguish payload from enum tag:
 //      case x(i64): X0 X1 X2 ... X63 | 0, where X0...X63 are the payload bits
 //      case y:      0  0  0  ... 0   | 1
 //      case z:      1  0  0  ... 0   | 1
-// CHECK-64: %O4enum17SinglePayloadNoXI = type <{ [8 x i8], [1 x i8] }>
-// CHECK-64: %O4enum18SinglePayloadNoXI2 = type <{ [8 x i8], [1 x i8] }>
-// CHECK-32: %O4enum17SinglePayloadNoXI = type <{ [4 x i8], [1 x i8] }>
-// CHECK-32: %O4enum18SinglePayloadNoXI2 = type <{ [4 x i8], [1 x i8] }>
+// CHECK-64: %T4enum17SinglePayloadNoXIO = type <{ [8 x i8], [1 x i8] }>
+// CHECK-64: %T4enum18SinglePayloadNoXI2O = type <{ [8 x i8], [1 x i8] }>
+// CHECK-32: %T4enum17SinglePayloadNoXIO = type <{ [4 x i8], [1 x i8] }>
+// CHECK-32: %T4enum18SinglePayloadNoXI2O = type <{ [4 x i8], [1 x i8] }>
 
 // -- Single-payload enum, spare bits. The representation uses a tag bit
 //    out of the payload to distinguish payload from enum tag:
 //      case x(i3): X0 X1 X2 0 0 0 0 0
 //      case y:     0  0  0  1 0 0 0 0
 //      case z:     1  0  0  1 0 0 0 0
-// CHECK: %O4enum21SinglePayloadSpareBit = type <{ [8 x i8] }>
+// CHECK: %T4enum21SinglePayloadSpareBitO = type <{ [8 x i8] }>
 
 // -- Single-payload enum containing a no-payload enum as its payload.
 //    The representation takes extra inhabitants starting after the greatest
 //    discriminator value used by the nested no-payload enum.
-// CHECK: %O4enum19SinglePayloadNested = type <{ [1 x i8] }>
+// CHECK: %T4enum19SinglePayloadNestedO = type <{ [1 x i8] }>
 
 // -- Single-payload enum containing another single-payload enum as its
 //    payload.
 //    The representation takes extra inhabitants from the nested enum's payload
 //    that were unused by the nested enum.
-// CHECK: %O4enum25SinglePayloadNestedNested = type <{ [1 x i8] }>
+// CHECK: %T4enum019SinglePayloadNestedD0O = type <{ [1 x i8] }>
 
 // -- Multi-payload enum, no spare bits. The representation adds tag bits
 //    to discriminate payloads. No-payload cases all share a tag.
@@ -55,7 +55,7 @@
 //      case a:     0  0  0  ... 0  0  | 1 1
 //      case b:     1  0  0  ... 0  0  | 1 1
 //      case c:     0  1  0  ... 0  0  | 1 1
-// CHECK: %O4enum23MultiPayloadNoSpareBits = type <{ [8 x i8], [1 x i8] }>
+// CHECK: %T4enum23MultiPayloadNoSpareBitsO = type <{ [8 x i8], [1 x i8] }>
 
 // -- Multi-payload enum, one spare bit. The representation uses spare bits
 //    common to all payloads to partially discriminate payloads, with added
@@ -66,7 +66,7 @@
 //      case a:     0  0  0  0  0  0  0  1 | 1
 //      case b:     1  0  0  0  0  0  0  1 | 1
 //      case c:     0  1  0  0  0  0  0  1 | 1
-// CHECK: %O4enum23MultiPayloadOneSpareBit = type <{ [8 x i8], [1 x i8] }>
+// CHECK: %T4enum23MultiPayloadOneSpareBitO = type <{ [8 x i8], [1 x i8] }>
 
 // -- Multi-payload enum, two spare bits. Same as above, except we have enough
 //    spare bits not to require any added tag bits.
@@ -76,28 +76,28 @@
 //      case a:     0  0  0  0  0  0  1  1
 //      case b:     1  0  0  0  0  0  1  1
 //      case c:     0  1  0  0  0  0  1  1
-// CHECK: %O4enum24MultiPayloadTwoSpareBits = type <{ [8 x i8] }>
+// CHECK: %T4enum24MultiPayloadTwoSpareBitsO = type <{ [8 x i8] }>
 
-// CHECK-64: %O4enum30MultiPayloadSpareBitAggregates = type <{ [16 x i8] }>
+// CHECK-64: %T4enum30MultiPayloadSpareBitAggregatesO = type <{ [16 x i8] }>
 
-// CHECK-64: %O4enum18MultiPayloadNested = type <{ [9 x i8] }>
-// CHECK-32: %O4enum18MultiPayloadNested = type <{ [5 x i8] }>
+// CHECK-64: %T4enum18MultiPayloadNestedO = type <{ [9 x i8] }>
+// CHECK-32: %T4enum18MultiPayloadNestedO = type <{ [5 x i8] }>
 
 // 32-bit object references don't have enough spare bits.
-// CHECK-64: %O4enum27MultiPayloadNestedSpareBits = type <{ [8 x i8] }>
+// CHECK-64: %T4enum27MultiPayloadNestedSpareBitsO = type <{ [8 x i8] }>
 
 // -- Dynamic enums. The type layout is opaque; we dynamically bitcast to
 //    the element type.
-// CHECK: %O4enum20DynamicSinglePayload = type <{}>
-// CHECK: [[DYNAMIC_SINGLE_EMPTY_PAYLOAD:%GO4enum20DynamicSinglePayloadT__]] = type <{ [1 x i8] }>
+// CHECK: %T4enum20DynamicSinglePayloadO = type <{}>
+// CHECK: [[DYNAMIC_SINGLE_EMPTY_PAYLOAD:%T4enum20DynamicSinglePayloadOyytG]] = type <{ [1 x i8] }>
 
 // -- Address-only multi-payload enums. We can't use spare bits.
-// CHECK-64: %O4enum32MultiPayloadAddressOnlySpareBits = type <{ [16 x i8], [1 x i8] }>
-// CHECK-32: %O4enum32MultiPayloadAddressOnlySpareBits = type <{ [8 x i8], [1 x i8] }>
+// CHECK-64: %T4enum32MultiPayloadAddressOnlySpareBitsO = type <{ [16 x i8], [1 x i8] }>
+// CHECK-32: %T4enum32MultiPayloadAddressOnlySpareBitsO = type <{ [8 x i8], [1 x i8] }>
 
-// CHECK: [[DYNAMIC_SINGLETON:%O4enum16DynamicSingleton.*]] = type <{}>
+// CHECK: [[DYNAMIC_SINGLETON:%T4enum16DynamicSingletonO.*]] = type <{}>
 
-// CHECK: %O4enum40MultiPayloadLessThan32BitsWithEmptyCases = type <{ [1 x i8], [1 x i8] }>
+// CHECK: %T4enum40MultiPayloadLessThan32BitsWithEmptyCasesO = type <{ [1 x i8], [1 x i8] }>
 
 // -- Dynamic metadata template carries a value witness table pattern
 //    we fill in on instantiation.
@@ -196,7 +196,7 @@
 }
 
 // CHECK-64: define{{( protected)?}} swiftcc void @singleton_switch(i64, i64) {{.*}} {
-// CHECK-32: define{{( protected)?}} swiftcc void @singleton_switch(%O4enum9Singleton* noalias nocapture dereferenceable(16)) {{.*}} {
+// CHECK-32: define{{( protected)?}} swiftcc void @singleton_switch(%T4enum9SingletonO* noalias nocapture dereferenceable(16)) {{.*}} {
 sil @singleton_switch : $(Singleton) -> () {
 // CHECK-64: entry:
 // CHECK-32: entry:
@@ -215,12 +215,12 @@
 }
 
 // CHECK-64: define{{( protected)?}} swiftcc void @singleton_switch_arg(i64, i64) {{.*}} {
-// CHECK-32: define{{( protected)?}} swiftcc void @singleton_switch_arg(%O4enum9Singleton* noalias nocapture dereferenceable(16)) {{.*}} {
+// CHECK-32: define{{( protected)?}} swiftcc void @singleton_switch_arg(%T4enum9SingletonO* noalias nocapture dereferenceable(16)) {{.*}} {
 sil @singleton_switch_arg : $(Singleton) -> () {
 // CHECK-64: entry:
 // CHECK-32: entry:
 entry(%u : $Singleton):
-// CHECK-32:  [[CAST:%.*]] = bitcast %O4enum9Singleton* %0 to <{ i64, i64 }>*
+// CHECK-32:  [[CAST:%.*]] = bitcast %T4enum9SingletonO* %0 to <{ i64, i64 }>*
 // CHECK-32:  [[GEP1:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[CAST]], i32 0, i32 0
 // CHECK-32:  [[ELT1:%.*]] = load i64, i64* [[GEP1]]
 // CHECK-32:  [[GEP2:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[CAST]], i32 0, i32 1
@@ -246,11 +246,11 @@
   return %x : $()
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @singleton_switch_indirect(%O4enum9Singleton* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK: define{{( protected)?}} swiftcc void @singleton_switch_indirect(%T4enum9SingletonO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK: entry:
 // CHECK:   br label %[[DEST:[0-9]+]]
 // CHECK: ; <label>:[[DEST]]
-// CHECK:   [[ADDR:%.*]] = bitcast %O4enum9Singleton* %0 to <{ i64, i64 }>*
+// CHECK:   [[ADDR:%.*]] = bitcast %T4enum9SingletonO* %0 to <{ i64, i64 }>*
 // CHECK:   ret void
 // CHECK: }
 sil @singleton_switch_indirect : $(@inout Singleton) -> () {
@@ -268,9 +268,9 @@
 // CHECK-64:   [[B:%.*]] = insertvalue { i64, i64 } [[A]], i64 %1, 1
 // CHECK-64:   ret { i64, i64 } [[B]]
 // CHECK-64: }
-// CHECK-32: define{{( protected)?}} swiftcc void @singleton_inject(%O4enum9Singleton* noalias nocapture sret, i64, i64) {{.*}} {
+// CHECK-32: define{{( protected)?}} swiftcc void @singleton_inject(%T4enum9SingletonO* noalias nocapture sret, i64, i64) {{.*}} {
 // CHECK-32: entry:
-// CHECK-32:  [[CAST:%.*]] = bitcast %O4enum9Singleton* %0 to <{ i64, i64 }>*
+// CHECK-32:  [[CAST:%.*]] = bitcast %T4enum9SingletonO* %0 to <{ i64, i64 }>*
 // CHECK-32:  [[GEP1:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[CAST]], i32 0, i32 0
 // CHECK-32:                 store i64 %1, i64* [[GEP1]]
 // CHECK-32:  [[GEP2:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[CAST]], i32 0, i32 1
@@ -284,9 +284,9 @@
   return %u : $Singleton
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @singleton_inject_indirect(i64, i64, %O4enum9Singleton* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK: define{{( protected)?}} swiftcc void @singleton_inject_indirect(i64, i64, %T4enum9SingletonO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK: entry:
-// CHECK:   [[DATA_ADDR:%.*]] = bitcast %O4enum9Singleton* %2 to <{ i64, i64 }>*
+// CHECK:   [[DATA_ADDR:%.*]] = bitcast %T4enum9SingletonO* %2 to <{ i64, i64 }>*
 // CHECK:   [[DATA_0_ADDR:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[DATA_ADDR]], i32 0, i32 0
 // CHECK:   store i64 %0, i64* [[DATA_0_ADDR]]
 // CHECK:   [[DATA_1_ADDR:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[DATA_ADDR]], i32 0, i32 1
@@ -360,10 +360,10 @@
   return %x : $()
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @no_payload_switch_indirect(%O4enum10NoPayloads* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK: define{{( protected)?}} swiftcc void @no_payload_switch_indirect(%T4enum10NoPayloadsO* nocapture dereferenceable({{.*}})) {{.*}} {
 sil @no_payload_switch_indirect : $@convention(thin) (@inout NoPayloads) -> () {
 entry(%u : $*NoPayloads):
-// CHECK:   [[TAG_ADDR:%.*]] = getelementptr inbounds %O4enum10NoPayloads, %O4enum10NoPayloads* %0, i32 0, i32 0
+// CHECK:   [[TAG_ADDR:%.*]] = getelementptr inbounds %T4enum10NoPayloadsO, %T4enum10NoPayloadsO* %0, i32 0, i32 0
 // CHECK:   [[TAG:%.*]] = load i8, i8* [[TAG_ADDR]]
 // CHECK:   switch i8 [[TAG]]
   switch_enum_addr %u : $*NoPayloads, case #NoPayloads.x!enumelt: x_dest, case #NoPayloads.y!enumelt: y_dest, case #NoPayloads.z!enumelt: z_dest
@@ -409,9 +409,9 @@
   return %u : $NoPayloads
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @no_payload_inject_z_indirect(%O4enum10NoPayloads* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK: define{{( protected)?}} swiftcc void @no_payload_inject_z_indirect(%T4enum10NoPayloadsO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK: entry:
-// CHECK:   [[TAG_ADDR:%.*]] = getelementptr inbounds %O4enum10NoPayloads, %O4enum10NoPayloads* %0, i32 0, i32 0
+// CHECK:   [[TAG_ADDR:%.*]] = getelementptr inbounds %T4enum10NoPayloadsO, %T4enum10NoPayloadsO* %0, i32 0, i32 0
 // CHECK:   store i8 2, i8* [[TAG_ADDR]]
 // CHECK:   ret void
 // CHECK: }
@@ -619,11 +619,11 @@
   return %u : $SinglePayloadNoXI2
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @single_payload_no_xi_inject_x_indirect([[WORD]], %O4enum18SinglePayloadNoXI2* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK: define{{( protected)?}} swiftcc void @single_payload_no_xi_inject_x_indirect([[WORD]], %T4enum18SinglePayloadNoXI2O* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK: entry:
-// CHECK:   [[DATA_ADDR:%.*]] = bitcast %O4enum18SinglePayloadNoXI2* %1 to [[WORD]]*
+// CHECK:   [[DATA_ADDR:%.*]] = bitcast %T4enum18SinglePayloadNoXI2O* %1 to [[WORD]]*
 // CHECK:   store [[WORD]] %0, [[WORD]]* [[DATA_ADDR]]
-// CHECK:   [[T0:%.*]] = getelementptr inbounds %O4enum18SinglePayloadNoXI2, %O4enum18SinglePayloadNoXI2* %1, i32 0, i32 1
+// CHECK:   [[T0:%.*]] = getelementptr inbounds %T4enum18SinglePayloadNoXI2O, %T4enum18SinglePayloadNoXI2O* %1, i32 0, i32 1
 // CHECK:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i1*
 // CHECK:   store i1 false, i1* [[TAG_ADDR]]
 // CHECK:   ret void
@@ -647,11 +647,11 @@
   return %u : $SinglePayloadNoXI2
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @single_payload_no_xi_inject_y_indirect(%O4enum18SinglePayloadNoXI2* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK: define{{( protected)?}} swiftcc void @single_payload_no_xi_inject_y_indirect(%T4enum18SinglePayloadNoXI2O* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK: entry:
-// CHECK:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum18SinglePayloadNoXI2* %0 to [[WORD]]*
+// CHECK:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum18SinglePayloadNoXI2O* %0 to [[WORD]]*
 // CHECK:   store [[WORD]] 0, [[WORD]]* [[PAYLOAD_ADDR]]
-// CHECK:   [[T0:%.*]] = getelementptr inbounds %O4enum18SinglePayloadNoXI2, %O4enum18SinglePayloadNoXI2* %0, i32 0, i32 1
+// CHECK:   [[T0:%.*]] = getelementptr inbounds %T4enum18SinglePayloadNoXI2O, %T4enum18SinglePayloadNoXI2O* %0, i32 0, i32 1
 // CHECK:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i1*
 // CHECK:   store i1 true, i1* [[TAG_ADDR]]
 // CHECK:   ret void
@@ -743,10 +743,10 @@
 }
 
 // CHECK-64: define{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_2([[WORD]], [[WORD]], [[WORD]], [[WORD]]) {{.*}} {
-// CHECK-32: define{{( protected)?}}  swiftcc void @aggregate_single_payload_unpack_2(%O4enum23AggregateSinglePayload2* noalias nocapture dereferenceable(16)) {{.*}} {
+// CHECK-32: define{{( protected)?}}  swiftcc void @aggregate_single_payload_unpack_2(%T4enum23AggregateSinglePayload2O* noalias nocapture dereferenceable(16)) {{.*}} {
 sil @aggregate_single_payload_unpack_2 : $@convention(thin) (AggregateSinglePayload2) -> () {
 entry(%u : $AggregateSinglePayload2):
-// CHECK-32:  [[CAST:%.*]] = bitcast %O4enum23AggregateSinglePayload2* %0 to { i32, i32, i32, i32 }*
+// CHECK-32:  [[CAST:%.*]] = bitcast %T4enum23AggregateSinglePayload2O* %0 to { i32, i32, i32, i32 }*
 // CHECK-32:  [[GEP:%.*]] = getelementptr inbounds {{.*}} [[CAST]], i32 0, i32 0
 // CHECK-32:  [[LOAD1:%.*]] = load i32, i32* [[GEP]]
 // CHECK-32:  [[LOAD2:%.*]] = load i32, i32* {{.*}}
@@ -783,10 +783,10 @@
 // CHECK-64:  %9 = insertvalue { [[WORD]], [[WORD]], [[WORD]], [[WORD]] } %8, [[WORD]] %3, 3
 // CHECK-64:  ret { [[WORD]], [[WORD]], [[WORD]], [[WORD]] } %9
 
-// CHECK-32: define{{( protected)?}} swiftcc void @aggregate_single_payload_2_inject(%O4enum23AggregateSinglePayload2* noalias nocapture sret, i32, i32, i32, i32) {{.*}} {
+// CHECK-32: define{{( protected)?}} swiftcc void @aggregate_single_payload_2_inject(%T4enum23AggregateSinglePayload2O* noalias nocapture sret, i32, i32, i32, i32) {{.*}} {
 // CHECK-32:  [[TRUNC:%.*]] = trunc i32 %1 to i21
 // CHECK-32:  [[ZEXT:%.*]] = zext i21 [[TRUNC]] to i32
-// CHECK-32:  [[CAST:%.*]] = bitcast %O4enum23AggregateSinglePayload2* %0 to { i32, i32, i32, i32 }*
+// CHECK-32:  [[CAST:%.*]] = bitcast %T4enum23AggregateSinglePayload2O* %0 to { i32, i32, i32, i32 }*
 // CHECK-32:  [[GEP:%.*]] = getelementptr inbounds {{.*}} [[CAST]], i32 0, i32 0
 // CHECK-32:  store i32 [[ZEXT]], i32* [[GEP]]
 // CHECK-32:  store i32 %2, i32*
@@ -967,13 +967,13 @@
 
 sil @single_payload_spare_bit_switch_indirect : $@convention(thin) (@inout SinglePayloadSpareBit) -> () {
 entry(%u : $*SinglePayloadSpareBit):
-// CHECK-64:  [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum21SinglePayloadSpareBit* %0 to i64*
+// CHECK-64:  [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum21SinglePayloadSpareBitO* %0 to i64*
 // CHECK-64:  [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
 // CHECK-64:  switch i64 [[PAYLOAD]]
   switch_enum_addr %u : $*SinglePayloadSpareBit, case #SinglePayloadSpareBit.x!enumelt.1: x_dest, case #SinglePayloadSpareBit.y!enumelt: y_dest, case #SinglePayloadSpareBit.z!enumelt: z_dest
 
 // CHECK-64: ; <label>:
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum21SinglePayloadSpareBit* %0 to i63*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum21SinglePayloadSpareBitO* %0 to i63*
 x_dest:
   %u2 = unchecked_take_enum_data_addr %u : $*SinglePayloadSpareBit, #SinglePayloadSpareBit.x!enumelt.1
   %a = function_ref @a : $@convention(thin) () -> ()
@@ -1003,10 +1003,10 @@
   return %u : $SinglePayloadSpareBit
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_x_indirect(i64, %O4enum21SinglePayloadSpareBit* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_x_indirect(i64, %T4enum21SinglePayloadSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
 // CHECK-64:   [[T:%.*]] = trunc i64 %0 to i63
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum21SinglePayloadSpareBit* %1 to i63*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum21SinglePayloadSpareBitO* %1 to i63*
 // CHECK-64:   store i63 [[T]], i63* [[DATA_ADDR]]
 // CHECK-64:   ret void
 // CHECK-64: }
@@ -1030,9 +1030,9 @@
   return %u : $SinglePayloadSpareBit
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_y_indirect(%O4enum21SinglePayloadSpareBit* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_y_indirect(%T4enum21SinglePayloadSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum21SinglePayloadSpareBit* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum21SinglePayloadSpareBitO* %0 to i64*
 // --                0x8000_0000_0000_0000
 // CHECK-64:   store i64 -9223372036854775808, i64* [[PAYLOAD_ADDR]]
 // CHECK-64:   ret void
@@ -1146,7 +1146,7 @@
 // CHECK-64:     i64 4, label {{%.*}}
 // CHECK-64:   ]
 // CHECK-64: ; <label>
-// CHECK-64:   inttoptr [[WORD]] %0 to %C4enum1C*
+// CHECK-64:   inttoptr [[WORD]] %0 to %T4enum1CC*
 
 // CHECK-32: define{{( protected)?}} swiftcc void @single_payload_class_switch(i32) {{.*}} {
 // CHECK-32: entry:
@@ -1156,7 +1156,7 @@
 // CHECK-32:     i32 2, label {{%.*}}
 // CHECK-32:   ]
 // CHECK-32: ; <label>
-// CHECK-32:   inttoptr [[WORD]] %0 to %C4enum1C*
+// CHECK-32:   inttoptr [[WORD]] %0 to %T4enum1CC*
 
 sil @single_payload_class_switch : $(SinglePayloadClass) -> () {
 entry(%c : $SinglePayloadClass):
@@ -1270,8 +1270,8 @@
   case w
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @dynamic_single_payload_switch(%O4enum20DynamicSinglePayload* noalias nocapture, %swift.type* %T) {{.*}} {
-// CHECK:   [[OPAQUE_ENUM:%.*]] = bitcast %O4enum20DynamicSinglePayload* %0 to %swift.opaque*
+// CHECK: define{{( protected)?}} swiftcc void @dynamic_single_payload_switch(%T4enum20DynamicSinglePayloadO* noalias nocapture, %swift.type* %T) {{.*}} {
+// CHECK:   [[OPAQUE_ENUM:%.*]] = bitcast %T4enum20DynamicSinglePayloadO* %0 to %swift.opaque*
 // CHECK:   [[CASE_INDEX:%.*]] = call i32 @swift_rt_swift_getEnumCaseSinglePayload(%swift.opaque* [[OPAQUE_ENUM]], %swift.type* %T, i32 3)
 // CHECK:   switch i32 [[CASE_INDEX]], label {{%.*}} [
 // CHECK:     i32 -1, label {{%.*}}
@@ -1295,8 +1295,8 @@
   return %v : $()
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @dynamic_single_payload_inject_x(%O4enum20DynamicSinglePayload* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T) {{.*}} {
-// CHECK:   [[ADDR:%.*]] = bitcast %O4enum20DynamicSinglePayload* %0 to %swift.opaque*
+// CHECK: define{{( protected)?}} swiftcc void @dynamic_single_payload_inject_x(%T4enum20DynamicSinglePayloadO* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T) {{.*}} {
+// CHECK:   [[ADDR:%.*]] = bitcast %T4enum20DynamicSinglePayloadO* %0 to %swift.opaque*
 // CHECK:   call void @swift_rt_swift_storeEnumTagSinglePayload(%swift.opaque* [[ADDR]], %swift.type* %T, i32 -1, i32 3)
 sil @dynamic_single_payload_inject_x : $<T> (@in T) -> @out DynamicSinglePayload<T> {
 entry(%r : $*DynamicSinglePayload<T>, %t : $*T):
@@ -1305,8 +1305,8 @@
   return %v : $()
 }
 
-// CHECK: define{{( protected)?}} swiftcc void @dynamic_single_payload_inject_y(%O4enum20DynamicSinglePayload* noalias nocapture sret, %swift.type* %T) {{.*}} {
-// CHECK:   [[ADDR:%.*]] = bitcast %O4enum20DynamicSinglePayload* %0 to %swift.opaque*
+// CHECK: define{{( protected)?}} swiftcc void @dynamic_single_payload_inject_y(%T4enum20DynamicSinglePayloadO* noalias nocapture sret, %swift.type* %T) {{.*}} {
+// CHECK:   [[ADDR:%.*]] = bitcast %T4enum20DynamicSinglePayloadO* %0 to %swift.opaque*
 // CHECK:   call void @swift_rt_swift_storeEnumTagSinglePayload(%swift.opaque* [[ADDR]], %swift.type* %T, i32 0, i32 3)
 sil @dynamic_single_payload_inject_y : $<T> () -> @out DynamicSinglePayload<T> {
 entry(%r : $*DynamicSinglePayload<T>):
@@ -1486,12 +1486,12 @@
   return %v : $()
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_no_spare_bits_switch_indirect(%O4enum23MultiPayloadNoSpareBits* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_no_spare_bits_switch_indirect(%T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} {
 sil @multi_payload_no_spare_bits_switch_indirect : $(@inout MultiPayloadNoSpareBits) -> () {
 entry(%u : $*MultiPayloadNoSpareBits):
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadNoSpareBits* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadNoSpareBits, %O4enum23MultiPayloadNoSpareBits* %0, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadNoSpareBitsO, %T4enum23MultiPayloadNoSpareBitsO* %0, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i8*
 // CHECK-64:   [[TAG:%.*]] = load i8, i8* [[TAG_ADDR]]
 // CHECK-64:   switch i8 [[TAG]]
@@ -1501,11 +1501,11 @@
   switch_enum_addr %u : $*MultiPayloadNoSpareBits, case #MultiPayloadNoSpareBits.x!enumelt.1: x_dest, case #MultiPayloadNoSpareBits.y!enumelt.1: y_dest, case #MultiPayloadNoSpareBits.z!enumelt.1: z_dest, case #MultiPayloadNoSpareBits.a!enumelt: a_dest, case #MultiPayloadNoSpareBits.b!enumelt: b_dest, case #MultiPayloadNoSpareBits.c!enumelt: c_dest
 
 // CHECK-64: ; <label>:[[X_DEST:[0-9]+]]
-// CHECK-64:   bitcast %O4enum23MultiPayloadNoSpareBits* %0 to i64*
+// CHECK-64:   bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i64*
 // CHECK-64: ; <label>:[[Y_DEST:[0-9]+]]
-// CHECK-64:   bitcast %O4enum23MultiPayloadNoSpareBits* %0 to i32*
+// CHECK-64:   bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i32*
 // CHECK-64: ; <label>:[[Z_DEST:[0-9]+]]
-// CHECK-64:   bitcast %O4enum23MultiPayloadNoSpareBits* %0 to i63*
+// CHECK-64:   bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i63*
 
 x_dest:
   %x = unchecked_take_enum_data_addr %u : $*MultiPayloadNoSpareBits, #MultiPayloadNoSpareBits.x!enumelt.1
@@ -1545,11 +1545,11 @@
   return %u : $MultiPayloadNoSpareBits
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_x_indirect(i64, %O4enum23MultiPayloadNoSpareBits* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_x_indirect(i64, %T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum23MultiPayloadNoSpareBits* %1 to i64*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum23MultiPayloadNoSpareBitsO* %1 to i64*
 // CHECK-64:   store i64 %0, i64* [[DATA_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadNoSpareBits, %O4enum23MultiPayloadNoSpareBits* %1, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadNoSpareBitsO, %T4enum23MultiPayloadNoSpareBitsO* %1, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i8*
 // CHECK-64:   store i8 0, i8* [[TAG_ADDR]]
 // CHECK-64:   ret void
@@ -1600,11 +1600,11 @@
   return %u : $MultiPayloadNoSpareBits
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_a_indirect(%O4enum23MultiPayloadNoSpareBits* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_a_indirect(%T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadNoSpareBits* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i64*
 // CHECK-64:   store i64 0, i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadNoSpareBits, %O4enum23MultiPayloadNoSpareBits* %0, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadNoSpareBitsO, %T4enum23MultiPayloadNoSpareBitsO* %0, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i8*
 // CHECK-64:   store i8 3, i8* [[TAG_ADDR]]
 // CHECK-64:   ret void
@@ -1734,9 +1734,9 @@
 
 sil @multi_payload_one_spare_bit_switch_indirect : $(@inout MultiPayloadOneSpareBit) -> () {
 entry(%u : $*MultiPayloadOneSpareBit):
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadOneSpareBit, %O4enum23MultiPayloadOneSpareBit* %0, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadOneSpareBitO, %T4enum23MultiPayloadOneSpareBitO* %0, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i1*
 // CHECK-64:   [[TAG:%.*]] = load i1, i1* [[TAG_ADDR]]
 // CHECK-64:   switch i8 {{%.*}}
@@ -1746,19 +1746,19 @@
   switch_enum_addr %u : $*MultiPayloadOneSpareBit, case #MultiPayloadOneSpareBit.x!enumelt.1: x_dest, case #MultiPayloadOneSpareBit.y!enumelt.1: y_dest, case #MultiPayloadOneSpareBit.z!enumelt.1: z_dest, case #MultiPayloadOneSpareBit.a!enumelt: a_dest, case #MultiPayloadOneSpareBit.b!enumelt: b_dest, case #MultiPayloadOneSpareBit.c!enumelt: c_dest
 
 // CHECK-64: ; <label>:[[X_PREDEST:[0-9]+]]
-// CHECK-64:   bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i62*
+// CHECK-64:   bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i62*
 
 // CHECK-64: ; <label>:[[Y_PREDEST:[0-9]+]]
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
 // --                                                   0x7FFF_FFFF_FFFF_FFFF
 // CHECK-64:   [[PAYLOAD_MASKED:%.*]] = and i64 [[PAYLOAD]], 9223372036854775807
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i64*
 // CHECK-64:   store i64 [[PAYLOAD_MASKED]], i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i63*
+// CHECK-64:   bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i63*
 
 // CHECK-64: ; <label>:[[Z_PREDEST:[0-9]+]]
-// CHECK-64:   bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i61*
+// CHECK-64:   bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i61*
 
 x_dest:
   %x = unchecked_take_enum_data_addr %u : $*MultiPayloadOneSpareBit, #MultiPayloadOneSpareBit.x!enumelt.1
@@ -1800,18 +1800,18 @@
   return %u : $MultiPayloadOneSpareBit
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_x_indirect(i64, %O4enum23MultiPayloadOneSpareBit* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_x_indirect(i64, %T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
 // CHECK-64:   [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i62
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %1 to i62*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i62*
 // CHECK-64:   store i62 [[NATIVECC_TRUNC]], i62* [[DATA_ADDR]]
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
 // --                                                   0x7FFF_FFFF_FFFF_FFFF
 // CHECK-64:   [[PAYLOAD_MASKED:%.*]] = and i64 [[PAYLOAD]], 9223372036854775807
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i64*
 // CHECK-64:   store i64 [[PAYLOAD_MASKED]], i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadOneSpareBit, %O4enum23MultiPayloadOneSpareBit* %1, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadOneSpareBitO, %T4enum23MultiPayloadOneSpareBitO* %1, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i1*
 // CHECK-64:   store i1 false, i1* [[TAG_ADDR]]
 // CHECK-64:   ret void
@@ -1841,20 +1841,20 @@
   return %u : $MultiPayloadOneSpareBit
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_y_indirect(i64, %O4enum23MultiPayloadOneSpareBit* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_y_indirect(i64, %T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
 // CHECK-64:   [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i63
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %1 to i63*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i63*
 // CHECK-64:   store i63 [[NATIVECC_TRUNC]], i63* [[DATA_ADDR]]
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
 // --                                                   0x7FFF_FFFF_FFFF_FFFF
 // CHECK-64:   [[PAYLOAD_MASKED:%.*]] = and i64 [[PAYLOAD]], 9223372036854775807
 // --                                                          0x8000_0000_0000_0000
 // CHECK-64:   [[PAYLOAD_TAGGED:%.*]] = or i64 [[PAYLOAD_MASKED]], -9223372036854775808
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i64*
 // CHECK-64:   store i64 [[PAYLOAD_TAGGED]], i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadOneSpareBit, %O4enum23MultiPayloadOneSpareBit* %1, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadOneSpareBitO, %T4enum23MultiPayloadOneSpareBitO* %1, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i1*
 // CHECK-64:   store i1 false, i1* [[TAG_ADDR]]
 // CHECK-64:   ret void
@@ -1894,12 +1894,12 @@
   return %u : $MultiPayloadOneSpareBit
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_a_indirect(%O4enum23MultiPayloadOneSpareBit* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_a_indirect(%T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum23MultiPayloadOneSpareBit* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i64*
 // --                0x8000_0000_0000_0000
 // CHECK-64:   store i64 -9223372036854775808, i64* [[PAYLOAD_ADDR]]
-// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %O4enum23MultiPayloadOneSpareBit, %O4enum23MultiPayloadOneSpareBit* %0, i32 0, i32 1
+// CHECK-64:   [[T0:%.*]] = getelementptr inbounds %T4enum23MultiPayloadOneSpareBitO, %T4enum23MultiPayloadOneSpareBitO* %0, i32 0, i32 1
 // CHECK-64:   [[TAG_ADDR:%.*]] = bitcast [1 x i8]* [[T0]] to i1*
 // CHECK-64:   store i1 true, i1* [[TAG_ADDR]]
 // CHECK-64:   ret void
@@ -2040,16 +2040,16 @@
   return %u : $MultiPayloadTwoSpareBits
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_x_indirect(i64, %O4enum24MultiPayloadTwoSpareBits* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_x_indirect(i64, %T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
 // CHECK-64:   [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i62
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %1 to i62*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i62*
 // CHECK-64:   store i62 [[NATIVECC_TRUNC]], i62* [[DATA_ADDR]]
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
 // --                                                   0x3FFF_FFFF_FFFF_FFFF
 // CHECK-64:   [[PAYLOAD_MASKED:%.*]] = and i64 [[PAYLOAD]], 4611686018427387903
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i64*
 // CHECK-64:   store i64 [[PAYLOAD_MASKED]], i64* [[PAYLOAD_ADDR]]
 // CHECK-64:   ret void
 // CHECK-64: }
@@ -2076,18 +2076,18 @@
   return %u : $MultiPayloadTwoSpareBits
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_y_indirect(i64, %O4enum24MultiPayloadTwoSpareBits* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_y_indirect(i64, %T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
 // CHECK-64:   [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i60
-// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %1 to i60*
+// CHECK-64:   [[DATA_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i60*
 // CHECK-64:   store i60 [[NATIVECC_TRUNC]], i60* [[DATA_ADDR]]
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i64*
 // CHECK-64:   [[PAYLOAD:%.*]] = load i64, i64* [[PAYLOAD_ADDR]]
 // --                                                   0x3FFF_FFFF_FFFF_FFFF
 // CHECK-64:   [[PAYLOAD_MASKED:%.*]] = and i64 [[PAYLOAD]], 4611686018427387903
 // --                                                         0x4000_0000_0000_0000
 // CHECK-64:   [[PAYLOAD_TAGGED:%.*]] = or i64 [[PAYLOAD_MASKED]], 4611686018427387904
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %1 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i64*
 // CHECK-64:   store i64 [[PAYLOAD_TAGGED]], i64* [[PAYLOAD_ADDR]]
 // CHECK-64:   ret void
 // CHECK-64: }
@@ -2125,9 +2125,9 @@
   return %u : $MultiPayloadTwoSpareBits
 }
 
-// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_a_indirect(%O4enum24MultiPayloadTwoSpareBits* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64: define{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_a_indirect(%T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
-// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %O4enum24MultiPayloadTwoSpareBits* %0 to i64*
+// CHECK-64:   [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %0 to i64*
 // --                0xC000_0000_0000_0000
 // CHECK-64:   store i64 -4611686018427387904, i64* [[PAYLOAD_ADDR]]
 // CHECK-64:   ret void
@@ -2189,11 +2189,11 @@
 // CHECK-64:     i64 -9223372036854775800, label {{%.*}}
 // CHECK-64:   ]
 // -- Extract x(C)
-// CHECK-64:   inttoptr i64 %0 to %C4enum1C*
+// CHECK-64:   inttoptr i64 %0 to %T4enum1CC*
 // -- Extract y(D)
 // --                                     0x3fffffffffffffff
 // CHECK-64:   [[MASKED:%.*]] = and i64 %0, 4611686018427387903
-// CHECK-64:   inttoptr i64 [[MASKED]] to %C4enum1D*
+// CHECK-64:   inttoptr i64 [[MASKED]] to %T4enum1DC*
 
 // CHECK-32-LABEL: define{{( protected)?}} swiftcc void @multi_payload_classes_switch(i32) {{.*}} {
 // CHECK-32:   %1 = trunc i32 %0 to i8
@@ -2208,10 +2208,10 @@
 // CHECK-32:     i32 6, label {{%.*}}
 // CHECK-32:   ]
 // -- Extract x(C)
-// CHECK-32:   inttoptr i32 %0 to %C4enum1C*
+// CHECK-32:   inttoptr i32 %0 to %T4enum1CC*
 // -- Extract y(D)
 // CHECK-32:   [[MASKED:%.*]] = and i32 %0, -4
-// CHECK-32:   inttoptr i32 [[MASKED]] to %C4enum1D*
+// CHECK-32:   inttoptr i32 [[MASKED]] to %T4enum1DC*
 
 sil @multi_payload_classes_switch : $(MultiPayloadClasses) -> () {
 entry(%c : $MultiPayloadClasses):
@@ -2261,8 +2261,8 @@
 // CHECK-64: ; <label>:[[Y_DEST]]
 // --                                        0x3fffffffffffffff
 // CHECK-64:   [[Y_MASKED:%.*]] = and i64 %0, 4611686018427387903
-// CHECK-64:   [[Y_0:%.*]] = inttoptr i64 [[Y_MASKED]] to %C4enum1C*
-// CHECK-64:   [[Y_1:%.*]] = inttoptr i64 %1 to %C4enum1C*
+// CHECK-64:   [[Y_0:%.*]] = inttoptr i64 [[Y_MASKED]] to %T4enum1CC*
+// CHECK-64:   [[Y_1:%.*]] = inttoptr i64 %1 to %T4enum1CC*
 // CHECK-64: ; <label>:[[Z_DEST]]
 // --                                        0x3fffffffffffffff
 // CHECK-64:   [[Z_MASKED:%.*]] = and i64 %0, 4611686018427387903
@@ -2297,7 +2297,7 @@
 }
 
 // CHECK-LABEL: define{{( protected)?}} swiftcc void @multi_payload_nested_switch
-// CHECK:   %1 = bitcast %O4enum18MultiPayloadNested* %0 to { [[WORD]], i8 }*
+// CHECK:   %1 = bitcast %T4enum18MultiPayloadNestedO* %0 to { [[WORD]], i8 }*
 // CHECK:   %2 = getelementptr
 // CHECK:   %3 = load [[WORD]], [[WORD]]* %2
 // CHECK:   %4 = getelementptr
@@ -2331,9 +2331,9 @@
   case B(MultiPayloadInnerSpareBits)
 }
 
-// CHECK-64-LABEL: define{{( protected)?}} swiftcc void @multi_payload_nested_spare_bits_switch(%O4enum27MultiPayloadNestedSpareBits* noalias nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-64-LABEL: define{{( protected)?}} swiftcc void @multi_payload_nested_spare_bits_switch(%T4enum27MultiPayloadNestedSpareBitsO* noalias nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-64: entry:
-// CHECK-64:   %1 = bitcast %O4enum27MultiPayloadNestedSpareBits* %0 to [[WORD]]*
+// CHECK-64:   %1 = bitcast %T4enum27MultiPayloadNestedSpareBitsO* %0 to [[WORD]]*
 // CHECK-64:   %2 = load [[WORD]], [[WORD]]* %1
 // CHECK-64:   %3 = lshr [[WORD]] %2, 61
 // CHECK-64:   %4 = trunc [[WORD]] %3 to i1
@@ -2402,7 +2402,7 @@
   case Y(Builtin.Int32)
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc void @multi_payload_address_only_destroy(%O4enum28MultiPayloadAddressOnlyFixed* noalias nocapture dereferenceable({{.*}}))
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @multi_payload_address_only_destroy(%T4enum28MultiPayloadAddressOnlyFixedO* noalias nocapture dereferenceable({{.*}}))
 sil @multi_payload_address_only_destroy : $@convention(thin) (@in MultiPayloadAddressOnlyFixed) -> () {
 entry(%m : $*MultiPayloadAddressOnlyFixed):
   destroy_addr %m : $*MultiPayloadAddressOnlyFixed
@@ -2422,7 +2422,7 @@
   case Y(AddressOnlySpareBitsPayload)
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc void @multi_payload_address_only_spare_bits(%O4enum32MultiPayloadAddressOnlySpareBits* noalias nocapture dereferenceable({{.*}}))
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @multi_payload_address_only_spare_bits(%T4enum32MultiPayloadAddressOnlySpareBitsO* noalias nocapture dereferenceable({{.*}}))
 sil @multi_payload_address_only_spare_bits : $@convention(thin) (@in MultiPayloadAddressOnlySpareBits) -> () {
 entry(%m : $*MultiPayloadAddressOnlySpareBits):
   destroy_addr %m : $*MultiPayloadAddressOnlySpareBits
@@ -2561,7 +2561,7 @@
 weak var delegate: delegateProtocol?
 }
 
-// CHECK-64-LABEL: define{{( protected)?}} swiftcc void @weak_optional(%GSqV4enum17StructWithWeakVar_* noalias nocapture dereferenceable({{.*}}))
+// CHECK-64-LABEL: define{{( protected)?}} swiftcc void @weak_optional(%T4enum17StructWithWeakVarVSg* noalias nocapture dereferenceable({{.*}}))
 sil @weak_optional : $@convention(thin) (@in StructWithWeakVar?) -> () {
 entry(%x : $*StructWithWeakVar?):
   // CHECK-64:      icmp eq [[WORD]] {{%.*}}, 0
@@ -2714,8 +2714,8 @@
 // CHECK-64:         %6 = or i128 %5, 18446744073709551616
 
 // CHECK-LABEL: define linkonce_odr hidden i32 @_T04enum40MultiPayloadLessThan32BitsWithEmptyCasesOwug(%swift.opaque* %value
-// CHECK:  [[VAL00:%.*]] = bitcast %swift.opaque* %value to %O4enum40MultiPayloadLessThan32BitsWithEmptyCases*
-// CHECK:  [[VAL01:%.*]] = bitcast %O4enum40MultiPayloadLessThan32BitsWithEmptyCases* [[VAL00]] to i8*
+// CHECK:  [[VAL00:%.*]] = bitcast %swift.opaque* %value to %T4enum40MultiPayloadLessThan32BitsWithEmptyCasesO*
+// CHECK:  [[VAL01:%.*]] = bitcast %T4enum40MultiPayloadLessThan32BitsWithEmptyCasesO* [[VAL00]] to i8*
 // CHECK:  [[VAL02:%.*]] = load {{.*}} [[VAL01]]
 // CHECK:  [[VAL03:%.*]] = getelementptr inbounds {{.*}} [[VAL00]], i32 0, i32 1
 // CHECK:  [[VAL04:%.*]] = bitcast {{.*}} [[VAL03]] to i8*
@@ -2736,7 +2736,7 @@
 
 // CHECK: <label>:[[TLABEL]]
 // CHECK:  [[VAL03:%.*]] = trunc i32 %tag to i8
-// CHECK:  [[VAL04:%.*]] = bitcast %O4enum40MultiPayloadLessThan32BitsWithEmptyCases* [[VAL00]] to i8*
+// CHECK:  [[VAL04:%.*]] = bitcast %T4enum40MultiPayloadLessThan32BitsWithEmptyCasesO* [[VAL00]] to i8*
 // CHECK:  store i8 [[VAL03]], i8* [[VAL04]]
 // CHECK:  [[VAL05:%.*]] = getelementptr inbounds {{.*}} [[VAL00]], i32 0, i32 1
 // CHECK:  [[VAL06:%.*]] = bitcast [1 x i8]* [[VAL05]] to i8*
diff --git a/test/IRGen/enum_spare_bits.sil b/test/IRGen/enum_spare_bits.sil
index f9d4cf9..faf16ed 100644
--- a/test/IRGen/enum_spare_bits.sil
+++ b/test/IRGen/enum_spare_bits.sil
@@ -2,7 +2,7 @@
 // RUN: %build-irgen-test-overlays
 // RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -Xllvm -new-mangling-for-tests %s -emit-ir | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // REQUIRES: objc_interop
 
 import Swift
@@ -17,15 +17,15 @@
   case A(C), B(D)
 }
 // can use spare bits—both payloads are Swift-defined classes
-// CHECK-32: %O15enum_spare_bits10SwiftClass = type <{ [4 x i8] }>
-// CHECK-64: %O15enum_spare_bits10SwiftClass = type <{ [8 x i8] }>
+// CHECK-32: %T15enum_spare_bits10SwiftClassO = type <{ [4 x i8] }>
+// CHECK-64: %T15enum_spare_bits10SwiftClassO = type <{ [8 x i8] }>
 
 enum ObjCClass {
   case A(NSObject), B(C)
 }
 // can't use spare bits—NSObject is an ObjC-defined class
-// CHECK-32: %O15enum_spare_bits9ObjCClass = type <{ [4 x i8] }>
-// CHECK-64: %O15enum_spare_bits9ObjCClass = type <{ [8 x i8], [1 x i8] }>
+// CHECK-32: %T15enum_spare_bits9ObjCClassO = type <{ [4 x i8] }>
+// CHECK-64: %T15enum_spare_bits9ObjCClassO = type <{ [8 x i8], [1 x i8] }>
 
 @objc @unsafe_no_objc_tagged_pointer
 protocol NoTaggedPointers {}
@@ -34,24 +34,24 @@
   case A(AnyObject), B(C)
 }
 // can't use spare bits—existential may be bound to tagged pointer type
-// CHECK-32: %O15enum_spare_bits11Existential = type <{ [4 x i8] }>
-// CHECK-64: %O15enum_spare_bits11Existential = type <{ [8 x i8], [1 x i8] }>
+// CHECK-32: %T15enum_spare_bits11ExistentialO = type <{ [4 x i8] }>
+// CHECK-64: %T15enum_spare_bits11ExistentialO = type <{ [8 x i8], [1 x i8] }>
 
 enum ExistentialNoTaggedPointers {
   case A(NoTaggedPointers), B(C)
 }
 // can use spare bits—@unsafe_no_objc_tagged_pointer says it's ok
-// CHECK-32: %O15enum_spare_bits27ExistentialNoTaggedPointers = type <{ [4 x i8] }>
-// CHECK-64: %O15enum_spare_bits27ExistentialNoTaggedPointers = type <{ [8 x i8] }>
+// CHECK-32: %T15enum_spare_bits27ExistentialNoTaggedPointersO = type <{ [4 x i8] }>
+// CHECK-64: %T15enum_spare_bits27ExistentialNoTaggedPointersO = type <{ [8 x i8] }>
 
 enum Archetype<T: AnyObject> {
   case A(T), B(C)
 }
 // can't use spare bits—archetype may be bound to tagged pointer type
-// CHECK-32: [[ARCHETYPE:%GO15enum_spare_bits9ArchetypeCS_1C_]] = type <{ [4 x i8], [1 x i8] }>
-// CHECK-32: [[ARCHETYPE_OBJC:%GO15enum_spare_bits9ArchetypeCSo8NSObject_]] = type <{ [4 x i8], [1 x i8] }>
-// CHECK-64: [[ARCHETYPE:%GO15enum_spare_bits9ArchetypeCS_1C_]] = type <{ [8 x i8], [1 x i8] }>
-// CHECK-64: [[ARCHETYPE_OBJC:%GO15enum_spare_bits9ArchetypeCSo8NSObject_]] = type <{ [8 x i8], [1 x i8] }>
+// CHECK-32: [[ARCHETYPE:%T15enum_spare_bits9ArchetypeOyAA1CCG]] = type <{ [4 x i8], [1 x i8] }>
+// CHECK-32: [[ARCHETYPE_OBJC:%T15enum_spare_bits9ArchetypeOySo8NSObjectCG]] = type <{ [4 x i8], [1 x i8] }>
+// CHECK-64: [[ARCHETYPE:%T15enum_spare_bits9ArchetypeOyAA1CCG]] = type <{ [8 x i8], [1 x i8] }>
+// CHECK-64: [[ARCHETYPE_OBJC:%T15enum_spare_bits9ArchetypeOySo8NSObjectCG]] = type <{ [8 x i8], [1 x i8] }>
 
 sil_global @swiftClass: $SwiftClass
 sil_global @objcClass: $ObjCClass
diff --git a/test/IRGen/fixlifetime.sil b/test/IRGen/fixlifetime.sil
index d00ad60..c6d0d6a 100644
--- a/test/IRGen/fixlifetime.sil
+++ b/test/IRGen/fixlifetime.sil
@@ -2,31 +2,31 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-sil -emit-ir -disable-llvm-optzns -Ounchecked %s | %FileCheck --check-prefix=CHECK-%target-runtime %s
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-sil -emit-ir -disable-llvm-optzns -Onone %s | %FileCheck --check-prefix=ONONE %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 // At -Onone we don't run the LLVM ARC optimizer, so the fixLifetime call is
 // unnecessary.
 // ONONE-NOT: @__swift_fixLifetime
 
-// CHECK-objc-LABEL: define{{( protected)?}} swiftcc void @test(%C11fixlifetime1C*, %objc_object*, i8**, i8*, %swift.refcounted*, %V11fixlifetime3Agg* noalias nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-objc-LABEL: define{{( protected)?}} swiftcc void @test(%T11fixlifetime1CC*, %objc_object*, i8**, i8*, %swift.refcounted*, %T11fixlifetime3AggV* noalias nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-objc: entry:
-// CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%C11fixlifetime1C*)*)(%C11fixlifetime1C*
+// CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC*)*)(%T11fixlifetime1CC*
 // CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%objc_object*)*)(%objc_object*
 // CHECK-objc:  call void @__swift_fixLifetime(%swift.refcounted*
-// CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%C11fixlifetime1C*)*)(%C11fixlifetime1C*
+// CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC*)*)(%T11fixlifetime1CC*
 // CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%objc_object*)*)(%objc_object*
 // CHECK-objc:  call void @__swift_fixLifetime(%swift.refcounted*
-// CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%C11fixlifetime1C**)*)(%C11fixlifetime1C**
+// CHECK-objc:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC**)*)(%T11fixlifetime1CC**
 
-// CHECK-native-LABEL: define{{( protected)?}} swiftcc void @test(%C11fixlifetime1C*, %swift.refcounted*, i8**, i8*, %swift.refcounted*, %V11fixlifetime3Agg* noalias nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-native-LABEL: define{{( protected)?}} swiftcc void @test(%T11fixlifetime1CC*, %swift.refcounted*, i8**, i8*, %swift.refcounted*, %T11fixlifetime3AggV* noalias nocapture dereferenceable({{.*}})) {{.*}} {
 // CHECK-native: entry:
-// CHECK-native:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%C11fixlifetime1C*)*)(%C11fixlifetime1C*
+// CHECK-native:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC*)*)(%T11fixlifetime1CC*
 // CHECK-native:  call void @__swift_fixLifetime(%swift.refcounted*
 // CHECK-native:  call void @__swift_fixLifetime(%swift.refcounted*
-// CHECK-native:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%C11fixlifetime1C*)*)(%C11fixlifetime1C*
+// CHECK-native:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC*)*)(%T11fixlifetime1CC*
 // CHECK-native:  call void @__swift_fixLifetime(%swift.refcounted*
 // CHECK-native:  call void @__swift_fixLifetime(%swift.refcounted*
-// CHECK-native:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%C11fixlifetime1C**)*)(%C11fixlifetime1C**
+// CHECK-native:  call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC**)*)(%T11fixlifetime1CC**
 
 sil_stage canonical
 
diff --git a/test/IRGen/function_types.sil b/test/IRGen/function_types.sil
index 876004f..9e36338 100644
--- a/test/IRGen/function_types.sil
+++ b/test/IRGen/function_types.sil
@@ -1,21 +1,18 @@
-// RUN: %swift -target x86_64-apple-macosx10.9 -module-name function_types %s -emit-ir -o - | %FileCheck %s
-// RUN: %swift -target i386-apple-ios7.1 %s -module-name function_types -emit-ir -o - | %FileCheck %s
-// RUN: %swift -target x86_64-apple-ios7.1 %s -module-name function_types -emit-ir -o - | %FileCheck %s
-// RUN: %swift -target armv7-apple-ios7.1 %s -module-name function_types -emit-ir -o - | %FileCheck %s
-// RUN: %swift -target arm64-apple-ios7.1 %s -module-name function_types -emit-ir -o - | %FileCheck %s
-// RUN: %swift -target x86_64-unknown-linux-gnu -disable-objc-interop %s -module-name function_types -emit-ir -o - | %FileCheck %s
+// RUN: %swift -target x86_64-apple-macosx10.9 -module-name function_types -assume-parsing-unqualified-ownership-sil %s -emit-ir -o - | %FileCheck %s
+// RUN: %swift -target i386-apple-ios7.1 %s -module-name function_types -assume-parsing-unqualified-ownership-sil -emit-ir -o - | %FileCheck %s
+// RUN: %swift -target x86_64-apple-ios7.1 %s -module-name function_types -assume-parsing-unqualified-ownership-sil -emit-ir -o - | %FileCheck %s
+// RUN: %swift -target armv7-apple-ios7.1 %s -module-name function_types -assume-parsing-unqualified-ownership-sil -emit-ir -o - | %FileCheck %s
+// RUN: %swift -target arm64-apple-ios7.1 %s -module-name function_types -assume-parsing-unqualified-ownership-sil -emit-ir -o - | %FileCheck %s
+// RUN: %swift -target x86_64-unknown-linux-gnu -disable-objc-interop %s -module-name function_types -assume-parsing-unqualified-ownership-sil -emit-ir -o - | %FileCheck %s
 
 // REQUIRES: CODEGENERATOR=X86
 // REQUIRES: CODEGENERATOR=ARM
 
-// FIXME: SR-3603 test is failing after being unintentionally disabled for a while
-// REQUIRES: SR3603
- 
 import Builtin
 
 sil_stage canonical
 
-// CHECK-LABEL: define{{( protected)?}} i8* @thin_func_value(i8*) {{.*}} {
+// CHECK-LABEL: define{{( protected)?}} swiftcc i8* @thin_func_value(i8*) {{.*}} {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret i8* %0
 // CHECK-NEXT:  }
@@ -24,7 +21,7 @@
   return %x : $@convention(thin) () -> ()
 }
 
-// CHECK-LABEL: define{{( protected)?}} { i8*, %swift.refcounted* } @thick_func_value(i8*, %swift.refcounted*) {{.*}} {
+// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @thick_func_value(i8*, %swift.refcounted*) {{.*}} {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    call void @swift_rt_swift_retain(%swift.refcounted* %1) {{#[0-9]+}}
 // CHECK-NEXT:    call void @swift_rt_swift_release(%swift.refcounted* %1) {{#[0-9]+}}
@@ -39,11 +36,9 @@
   return %x : $() -> ()
 }
 
-// CHECK-LABEL: define{{( protected)?}} { i8*, i8** } @thin_witness_value(i8*, i8**) {{.*}} {
+// CHECK-LABEL: define{{( protected)?}} swiftcc i8* @thin_witness_value(i8*) {{.*}} {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[T0:%.*]] = insertvalue { i8*, i8** } undef, i8* %0, 0
-// CHECK-NEXT:    [[T1:%.*]] = insertvalue { i8*, i8** } [[T0]], i8** %1, 1
-// CHECK-NEXT:    ret { i8*, i8** } [[T1]]
+// CHECK-NEXT:    ret i8* %0
 // CHECK-NEXT:  }
 sil @thin_witness_value : $@convention(thin) (@convention(witness_method) () -> ()) -> @convention(witness_method) () -> () {
 entry(%x : $@convention(witness_method) () -> ()):
@@ -54,9 +49,9 @@
 
 sil @out_void_return : $@convention(thin) () -> @out X
 
-// CHECK-LABEL: define{{( protected)?}} void @use_void_return_value(%V14function_types1X* noalias nocapture sret) {{.*}} {
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @use_void_return_value(%T14function_types1XV* noalias nocapture sret) {{.*}} {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @out_void_return(%V14function_types1X* noalias nocapture sret %0)
+// CHECK-NEXT:    call swiftcc void @out_void_return(%T14function_types1XV* noalias nocapture sret %0)
 // CHECK-NEXT:    ret void
 // CHECK-NEXT:  }
 sil @use_void_return_value : $@convention(thin) () -> @out X {
@@ -66,7 +61,7 @@
   return %z : $()
 }
 
-// CHECK-LABEL: define{{( protected)?}} i1 @test_is_nonnull_function(i8*, %swift.refcounted*) {{.*}} {
+// CHECK-LABEL: define{{( protected)?}} swiftcc i1 @test_is_nonnull_function(i8*, %swift.refcounted*) {{.*}} {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:  %2 = icmp ne i8* %0, null
 // CHECK-NEXT:  ret i1 %2
@@ -78,7 +73,7 @@
   return %3 : $Builtin.Int1                                 // id: %5
 }
 
-// CHECK-LABEL: define{{( protected)?}} i8* @test_function_to_pointer(i8*)
+// CHECK-LABEL: define{{( protected)?}} swiftcc i8* @test_function_to_pointer(i8*)
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret i8* %0
 sil @test_function_to_pointer : $@convention(thin) (@convention(thin) () -> ()) -> Builtin.RawPointer {
@@ -87,7 +82,7 @@
   return %1 : $Builtin.RawPointer
 }
 
-// CHECK-LABEL: define{{( protected)?}} i8* @test_pointer_to_function(i8*)
+// CHECK-LABEL: define{{( protected)?}} swiftcc i8* @test_pointer_to_function(i8*)
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret i8* %0
 sil @test_pointer_to_function : $@convention(thin) (Builtin.RawPointer) -> @convention(thin) () -> () {
diff --git a/test/IRGen/generic_class_anyobject.swift b/test/IRGen/generic_class_anyobject.swift
index 3e47b8b..f5d9d4c 100644
--- a/test/IRGen/generic_class_anyobject.swift
+++ b/test/IRGen/generic_class_anyobject.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // REQUIRES: objc_interop
 
 func foo<T: AnyObject>(_ x: T) -> T { return x }
diff --git a/test/IRGen/generic_classes_objc.sil b/test/IRGen/generic_classes_objc.sil
index ba563fa..e476e6f 100644
--- a/test/IRGen/generic_classes_objc.sil
+++ b/test/IRGen/generic_classes_objc.sil
@@ -2,7 +2,7 @@
 // RUN: %build-irgen-test-overlays
 // RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -Xllvm -new-mangling-for-tests %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // REQUIRES: objc_interop
 
 import Builtin
diff --git a/test/IRGen/generic_ternary.swift b/test/IRGen/generic_ternary.swift
index 5a240cb..ed7c99d 100644
--- a/test/IRGen/generic_ternary.swift
+++ b/test/IRGen/generic_ternary.swift
@@ -1,10 +1,10 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 // <rdar://problem/13793646>
 struct OptionalStreamAdaptor<T : IteratorProtocol> {
-  // CHECK: define hidden swiftcc void @_T015generic_ternary21OptionalStreamAdaptorV4next{{[_0-9a-zA-Z]*}}F(%Sq{{.*}}* noalias nocapture sret, %swift.type* %"OptionalStreamAdaptor<T>", %V15generic_ternary21OptionalStreamAdaptor* nocapture swiftself dereferenceable({{.*}}))
+  // CHECK: define hidden swiftcc void @_T015generic_ternary21OptionalStreamAdaptorV4next{{[_0-9a-zA-Z]*}}F(%TSq{{.*}}* noalias nocapture sret, %swift.type* %"OptionalStreamAdaptor<T>", %T15generic_ternary21OptionalStreamAdaptorV* nocapture swiftself dereferenceable({{.*}}))
   mutating
   func next() -> Optional<T.Element> {
     return x[0].next()
diff --git a/test/IRGen/indirect_return.swift b/test/IRGen/indirect_return.swift
index 2cb0b95..8d0957fb 100644
--- a/test/IRGen/indirect_return.swift
+++ b/test/IRGen/indirect_return.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 // CHECK: define hidden swiftcc void @_T015indirect_return11generic_get{{[_0-9a-zA-Z]*}}F
 func generic_get<T>(p: UnsafeMutablePointer<T>) -> T {
diff --git a/test/IRGen/infinite_archetype.swift b/test/IRGen/infinite_archetype.swift
index 5a974f3..f6b503d 100644
--- a/test/IRGen/infinite_archetype.swift
+++ b/test/IRGen/infinite_archetype.swift
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 protocol Fooable {
   associatedtype Foo
diff --git a/test/IRGen/lazy_multi_file.swift b/test/IRGen/lazy_multi_file.swift
index dc4274e..fd343b2 100644
--- a/test/IRGen/lazy_multi_file.swift
+++ b/test/IRGen/lazy_multi_file.swift
@@ -1,17 +1,17 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -primary-file %s %S/Inputs/lazy_multi_file_helper.swift -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
-// CHECK: %C15lazy_multi_file8Subclass = type <{ %swift.refcounted, %[[OPTIONAL_INT_TY:GSqSi_]], [{{[0-9]+}} x i8], %SS }>
+// CHECK: %T15lazy_multi_file8SubclassC = type <{ %swift.refcounted, %[[OPTIONAL_INT_TY:TSiSg]], [{{[0-9]+}} x i8], %TSS }>
 // CHECK: %[[OPTIONAL_INT_TY]] = type <{ [{{[0-9]+}} x i8], [1 x i8] }>
-// CHECK: %V15lazy_multi_file13LazyContainer = type <{ %[[OPTIONAL_INT_TY]] }>
+// CHECK: %T15lazy_multi_file13LazyContainerV = type <{ %[[OPTIONAL_INT_TY]] }>
 
 class Subclass : LazyContainerClass {
   final var str = "abc"
 
-  // CHECK-LABEL: @_T015lazy_multi_file8SubclassC6getStrSSyF(%C15lazy_multi_file8Subclass* swiftself) {{.*}} {
+  // CHECK-LABEL: @_T015lazy_multi_file8SubclassC6getStrSSyF(%T15lazy_multi_file8SubclassC* swiftself) {{.*}} {
   func getStr() -> String {
-    // CHECK: = getelementptr inbounds %C15lazy_multi_file8Subclass, %C15lazy_multi_file8Subclass* %0, i32 0, i32 3
+    // CHECK: = getelementptr inbounds %T15lazy_multi_file8SubclassC, %T15lazy_multi_file8SubclassC* %0, i32 0, i32 3
     return str
   }
 }
diff --git a/test/IRGen/metatype_casts.sil b/test/IRGen/metatype_casts.sil
index 2c2a2cc..598440a 100644
--- a/test/IRGen/metatype_casts.sil
+++ b/test/IRGen/metatype_casts.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // XFAIL: linux
 
 import Swift
@@ -68,8 +68,8 @@
 class OtherClass : SomeClass {}
 sil_vtable OtherClass {}
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc void @value_metatype_cast(%C14metatype_casts9SomeClass*)
-// CHECK:         [[T0:%.*]] = bitcast %C14metatype_casts9SomeClass* %0 to %swift.type**
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @value_metatype_cast(%T14metatype_casts9SomeClassC*)
+// CHECK:         [[T0:%.*]] = bitcast %T14metatype_casts9SomeClassC* %0 to %swift.type**
 // CHECK:         [[T1:%.*]] = load %swift.type*, %swift.type** [[T0]]
 // CHECK:         [[T2:%.*]] = icmp eq %swift.type* [[T1]], {{.*}} @_T014metatype_casts10OtherClassCMf
 sil @value_metatype_cast : $@convention(thin) (SomeClass) -> () {
diff --git a/test/IRGen/nondominant.sil b/test/IRGen/nondominant.sil
index e4c58c5..11740b8 100644
--- a/test/IRGen/nondominant.sil
+++ b/test/IRGen/nondominant.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 import Builtin
 
diff --git a/test/IRGen/objc_alloc.sil b/test/IRGen/objc_alloc.sil
index 364ac71..2d95809 100644
--- a/test/IRGen/objc_alloc.sil
+++ b/test/IRGen/objc_alloc.sil
@@ -2,7 +2,7 @@
 // RUN: %build-irgen-test-overlays
 // RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil %s -emit-ir | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 // REQUIRES: objc_interop
 
 sil_stage canonical
diff --git a/test/IRGen/protocol_extensions.sil b/test/IRGen/protocol_extensions.sil
index aea3760..2bd52c1 100644
--- a/test/IRGen/protocol_extensions.sil
+++ b/test/IRGen/protocol_extensions.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s | %FileCheck %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 import Builtin
 
diff --git a/test/IRGen/select_enum_single_payload.sil b/test/IRGen/select_enum_single_payload.sil
index a187bb0..f3d0aae 100644
--- a/test/IRGen/select_enum_single_payload.sil
+++ b/test/IRGen/select_enum_single_payload.sil
@@ -1,5 +1,5 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil %s -emit-ir | %FileCheck %s --check-prefix=CHECK-%target-ptrsize
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 sil_stage canonical
 
diff --git a/test/IRGen/sil_witness_methods.sil b/test/IRGen/sil_witness_methods.sil
index 3681428..4e0d3dc 100644
--- a/test/IRGen/sil_witness_methods.sil
+++ b/test/IRGen/sil_witness_methods.sil
@@ -85,7 +85,7 @@
   return %m : $@thick Foo.Type
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc %swift.type* @generic_type_generic_method_witness(%swift.opaque* noalias nocapture, %swift.type* %Z, %T19sil_witness_methods3BarC{{(.1)?}}** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable)
+// CHECK-LABEL: define{{( protected)?}} swiftcc %swift.type* @generic_type_generic_method_witness(%swift.opaque* noalias nocapture, %swift.type* %Z, %T19sil_witness_methods3BarC{{.*}}** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable)
 sil @generic_type_generic_method_witness : $@convention(witness_method) <T, U, V, Z> (@in Z, @in Bar<T, U, V>) -> @thick Bar<T, U, V>.Type {
 entry(%z : $*Z, %x : $*Bar<T, U, V>):
   %t = metatype $@thick T.Type
diff --git a/test/IRGen/witness_method.sil b/test/IRGen/witness_method.sil
index de663e7..9aff540 100644
--- a/test/IRGen/witness_method.sil
+++ b/test/IRGen/witness_method.sil
@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil %s -emit-ir | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 sil_stage canonical
 
@@ -60,14 +60,14 @@
   }
 }
 
-// CHECK-LABEL: define{{( protected)?}} swiftcc void @testGenericWitnessMethod(%swift.opaque* noalias nocapture sret, %V14witness_method6SyncUp* noalias nocapture, %swift.type* %T)
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @testGenericWitnessMethod(%swift.opaque* noalias nocapture sret, %T14witness_method6SyncUpV* noalias nocapture, %swift.type* %T)
 // CHECK: entry:
 // CHECK:   [[METADATA:%.*]] = call %swift.type* @_T014witness_method6SyncUpVMa(%swift.type* %T)
 // CHECK:   [[WTABLE:%.*]] = call i8** @_T014witness_method6SyncUpVyxGAA7SynergyAAlWa(%swift.type* [[METADATA]])
 // CHECK:   [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[WTABLE]], i32 1
 // CHECK:   [[WITNESS_FN:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
 // CHECK:   [[WITNESS:%.*]] = bitcast i8* [[WITNESS_FN]] to void (%swift.opaque*, %swift.opaque*, %swift.type*, i8**)*
-// CHECK:   [[ARG:%.*]] = bitcast %V14witness_method6SyncUp* %1 to %swift.opaque*
+// CHECK:   [[ARG:%.*]] = bitcast %T14witness_method6SyncUpV* %1 to %swift.opaque*
 // CHECK:   call swiftcc void [[WITNESS]](%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture swiftself [[ARG]], %swift.type* [[METADATA]], i8** [[WTABLE]])
 // CHECK:   ret void
 
diff --git a/test/IRGen/witness_method_phi.sil b/test/IRGen/witness_method_phi.sil
index d00962e..4447936 100644
--- a/test/IRGen/witness_method_phi.sil
+++ b/test/IRGen/witness_method_phi.sil
@@ -10,7 +10,6 @@
   br bb1(%1 : $@convention(witness_method) <T: P> (@in P) -> ())
 
 // CHECK:         phi i8* [ %0, %entry ]
-// CHECK-NEXT:    phi i8** [ %T.P, %entry ]
 bb1(%2 : $@convention(witness_method) <T: P> (@in P) -> ()):
   unreachable
 }
diff --git a/test/Index/kinds.swift b/test/Index/kinds.swift
index c550867..1ddd0bf 100644
--- a/test/Index/kinds.swift
+++ b/test/Index/kinds.swift
@@ -43,10 +43,16 @@
 class AClass {
   // CHECK: [[@LINE-1]]:7 | class/Swift | AClass | s:14swift_ide_test6AClassC | Def | rel: 0
 
-  // InstanceMethod
-  func instanceMethod() {}
-  // CHECK: [[@LINE-1]]:8 | instance-method/Swift | instanceMethod() | s:14swift_ide_test6AClassC14instanceMethodyyF | Def,RelChild | rel: 1
-  // CHECK-NEXT:  RelChild | AClass | s:14swift_ide_test6AClassC
+  // InstanceMethod + Parameters
+  func instanceMethod(a: Int, b b: Int, _ c: Int, d _: Int, _: Int) {}
+  // CHECK: [[@LINE-1]]:8 | instance-method/Swift | instanceMethod(a:b:_:d:_:) | s:14swift_ide_test6AClassC14instanceMethodySi1a_Si1bSiSi1dSitF | Def,RelChild | rel: 1
+  // CHECK-NEXT: RelChild | AClass | s:14swift_ide_test6AClassC
+  // CHECK: [[@LINE-3]]:23 | param/Swift | a | s:14swift_ide_test6AClassC14instanceMethodySi1a_Si1bSiSi1dSitFAEL_Siv | Def,RelChild | rel: 1
+  // CHECK-NEXT: RelChild | instanceMethod(a:b:_:d:_:) | s:14swift_ide_test6AClassC14instanceMethodySi1a_Si1bSiSi1dSitF
+  // CHECK-NOT: [[@LINE-5]]:33 | param/Swift | b | s:{{.*}} | Def,RelChild | rel: 1
+  // CHECK-NOT: [[@LINE-6]]:43 | param/Swift | c | s:{{.*}} | Def,RelChild | rel: 1
+  // CHECK-NOT: [[@LINE-7]]:53 | param/Swift | d | s:{{.*}} | Def,RelChild | rel: 1
+  // CHECK-NOT: [[@LINE-8]]:61 | param/Swift | _ | s:{{.*}} | Def,RelChild | rel: 1
 
   // ClassMethod
   class func classMethod() {}
diff --git a/test/Index/roles.swift b/test/Index/roles.swift
index ba39b63..757a19a 100644
--- a/test/Index/roles.swift
+++ b/test/Index/roles.swift
@@ -37,13 +37,15 @@
     // CHECK: [[@LINE-1]]:3 | function/acc-get/Swift | getter:z | s:14swift_ide_test1zSifg | Def,RelChild,RelAcc | rel: 1
 
     return y
-    // CHECK: [[@LINE-1]]:12 | variable/Swift | y | s:14swift_ide_test1ySiv | Ref,Read | rel: 0
+    // CHECK: [[@LINE-1]]:12 | variable/Swift | y | s:14swift_ide_test1ySiv | Ref,Read,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | getter:z | s:14swift_ide_test1zSifg
   }
   set {
     // CHECK: [[@LINE-1]]:3 | function/acc-set/Swift | setter:z | s:14swift_ide_test1zSifs | Def,RelChild,RelAcc | rel: 1
 
     y = newValue
-    // CHECK: [[@LINE-1]]:5 | variable/Swift | y | s:14swift_ide_test1ySiv | Ref,Writ | rel: 0
+    // CHECK: [[@LINE-1]]:5 | variable/Swift | y | s:14swift_ide_test1ySiv | Ref,Writ,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | setter:z | s:14swift_ide_test1zSifs
   }
 }
 // Write + Read of z
@@ -54,22 +56,40 @@
 // CHECK: [[@LINE-4]]:5 | function/acc-get/Swift | getter:z | s:14swift_ide_test1zSifg | Ref,Call,Impl | rel: 0
 
 // Call
-func aCalledFunction() {}
-// CHECK: [[@LINE-1]]:6 | function/Swift | aCalledFunction() | s:14swift_ide_test15aCalledFunctionyyF | Def | rel: 0
+func aCalledFunction(a: Int, b: inout Int) {
+// CHECK: [[@LINE-1]]:6 | function/Swift | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF | Def | rel: 0
+// CHECK: [[@LINE-2]]:22 | param/Swift | a | s:{{.*}} | Def,RelChild | rel: 1
+// CHECK-NEXT: RelChild | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF
+// CHECK: [[@LINE-4]]:30 | param/Swift | b | s:{{.*}} | Def,RelChild | rel: 1
+// CHECK-NEXT: RelChild | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF
 
-aCalledFunction()
-// CHECK: [[@LINE-1]]:1 | function/Swift | aCalledFunction() | s:14swift_ide_test15aCalledFunctionyyF | Ref,Call | rel: 0
+  var _ = a + b
+  // CHECK: [[@LINE-1]]:11 | param/Swift | a | s:{{.*}} | Ref,Read,RelCont | rel: 1
+  // CHECK-NEXT: RelCont | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF
+  // CHECK: [[@LINE-3]]:15 | param/Swift | b | s:{{.*}} | Ref,Read,RelCont | rel: 1
+  // CHECK-NEXT: RelCont | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF
+
+  b = a + 1
+  // CHECK: [[@LINE-1]]:3 | param/Swift | b | s:{{.*}} | Ref,Writ,RelCont | rel: 1
+  // CHECK-NEXT: RelCont | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF
+  // CHECK: [[@LINE-3]]:7 | param/Swift | a | s:{{.*}} | Ref,Read,RelCont | rel: 1
+  // CHECK-NEXT: RelCont | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF
+}
+
+aCalledFunction(a: 1, b: &z)
+// CHECK: [[@LINE-1]]:1 | function/Swift | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF | Ref,Call | rel: 0
+// CHECK: [[@LINE-2]]:27 | variable/Swift | z | s:14swift_ide_test1zSiv | Ref,Read,Writ | rel: 0
 
 func aCaller() {
   // CHECK: [[@LINE-1]]:6 | function/Swift | aCaller() | s:14swift_ide_test7aCalleryyF | Def | rel: 0
 
-  aCalledFunction()
-  // CHECK: [[@LINE-1]]:3 | function/Swift | aCalledFunction() | s:14swift_ide_test15aCalledFunctionyyF | Ref,Call,RelCall | rel: 1
-  // CHECK-NEXT: RelCall | aCaller() | s:14swift_ide_test7aCalleryyF
+  aCalledFunction(a: 1, b: &z)
+  // CHECK: [[@LINE-1]]:3 | function/Swift | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF | Ref,Call,RelCall,RelCont | rel: 1
+  // CHECK-NEXT: RelCall,RelCont | aCaller() | s:14swift_ide_test7aCalleryyF
 }
 
-let _ = aCalledFunction
-// CHECK: [[@LINE-1]]:9 | function/Swift | aCalledFunction() | s:14swift_ide_test15aCalledFunctionyyF | Ref | rel: 0
+let aRef = aCalledFunction
+// CHECK: [[@LINE-1]]:12 | function/Swift | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF | Ref | rel: 0
 
 // RelationChildOf, Implicit
 struct AStruct {
@@ -82,15 +102,16 @@
     // CHECK-NEXT: RelChild | AStruct | s:14swift_ide_test7AStructV
 
     x += 1
-    // CHECK: [[@LINE-1]]:5 | instance-property/Swift | x | s:14swift_ide_test7AStructV1xSiv | Ref,Read,Writ | rel: 0
-    // CHECK: [[@LINE-2]]:5 | function/acc-get/Swift | getter:x | s:14swift_ide_test7AStructV1xSifg | Ref,Call,Impl,RelRec,RelCall | rel: 2
-    // CHECK-NEXT: RelCall | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
+    // CHECK: [[@LINE-1]]:5 | instance-property/Swift | x | s:14swift_ide_test7AStructV1xSiv | Ref,Read,Writ,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
+    // CHECK: [[@LINE-3]]:5 | function/acc-get/Swift | getter:x | s:14swift_ide_test7AStructV1xSifg | Ref,Call,Impl,RelRec,RelCall,RelCont | rel: 2
+    // CHECK-NEXT: RelCall,RelCont | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
     // CHECK-NEXT: RelRec | AStruct | s:14swift_ide_test7AStructV
-    // CHECK: [[@LINE-5]]:5 | function/acc-set/Swift | setter:x | s:14swift_ide_test7AStructV1xSifs | Ref,Call,Impl,RelRec,RelCall | rel: 2
-    // CHECK-NEXT: RelCall | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
+    // CHECK: [[@LINE-6]]:5 | function/acc-set/Swift | setter:x | s:14swift_ide_test7AStructV1xSifs | Ref,Call,Impl,RelRec,RelCall,RelCont | rel: 2
+    // CHECK-NEXT: RelCall,RelCont | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
     // CHECK-NEXT: RelRec | AStruct | s:14swift_ide_test7AStructV
-    // CHECK: [[@LINE-8]]:7 | function/infix-operator/Swift | +=(_:_:) | s:s2peoiySiz_SitF | Ref,Call,RelCall | rel: 1
-    // CHECK-NEXT: RelCall | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
+    // CHECK: [[@LINE-9]]:7 | function/infix-operator/Swift | +=(_:_:) | s:s2peoiySiz_SitF | Ref,Call,RelCall,RelCont | rel: 1
+    // CHECK-NEXT: RelCall,RelCont | aMethod() | s:14swift_ide_test7AStructV7aMethodyyF
   }
 
   // RelationChildOf, RelationAccessorOf
@@ -243,3 +264,47 @@
 // CHECK: [[@LINE-2]]:22 | instance-method/Swift | foo() | s:14swift_ide_test6AClassC3fooSiyF | Ref,Call,Dyn,RelRec | rel: 1
 // CHECK-NEXT: RelRec | AClass | s:14swift_ide_test6AClassC
 
+// RelationContainedBy
+let contained = 2
+// CHECK: [[@LINE-1]]:5 | variable/Swift | contained | s:14swift_ide_test9containedSiv | Def | rel: 0
+
+func containing() {
+// CHECK: [[@LINE-1]]:6 | function/Swift | containing() | s:14swift_ide_test10containingyyF | Def | rel: 0
+  let _ = contained
+  // CHECK: [[@LINE-1]]:11 | variable/Swift | contained | s:14swift_ide_test9containedSiv | Ref,Read,RelCont | rel: 1
+  // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+
+  var x = contained
+  // CHECK: [[@LINE-1]]:11 | variable/Swift | contained | s:14swift_ide_test9containedSiv | Ref,Read,RelCont | rel: 1
+  // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+
+  struct LocalStruct {
+    var i: AClass = AClass(x: contained)
+    // CHECK: [[@LINE-1]]:12 | class/Swift | AClass | s:14swift_ide_test6AClassC | Ref,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+    // CHECK: [[@LINE-3]]:21 | class/Swift | AClass | s:14swift_ide_test6AClassC | Ref,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+    // CHECK: [[@LINE-5]]:31 | variable/Swift | contained | s:14swift_ide_test9containedSiv | Ref,Read,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+
+    init(i _: AClass) {}
+    // CHECK: [[@LINE-1]]:15 | class/Swift | AClass | s:14swift_ide_test6AClassC | Ref,RelCont | rel: 1
+    // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+
+    func inner() -> Int {
+      let _: AClass = AClass(x: contained)
+      // CHECK: [[@LINE-1]]:14 | class/Swift | AClass | s:14swift_ide_test6AClassC | Ref,RelCont | rel: 1
+      // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+      // CHECK: [[@LINE-3]]:23 | class/Swift | AClass | s:14swift_ide_test6AClassC | Ref,RelCont | rel: 1
+      // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+      // CHECK: [[@LINE-5]]:33 | variable/Swift | contained | s:14swift_ide_test9containedSiv | Ref,Read,RelCont | rel: 1
+      // CHECK-NEXT: RelCont | containing() | s:14swift_ide_test10containingyyF
+
+      aCalledFunction(a: 1, b: &z)
+      // CHECK: [[@LINE-1]]:7 | function/Swift | aCalledFunction(a:b:) | s:14swift_ide_test15aCalledFunctionySi1a_Siz1btF | Ref,Call,RelCall,RelCont | rel: 1
+      // CHECK-NEXT: RelCall,RelCont | containing() | s:14swift_ide_test10containingyyF
+
+      return contained
+    }
+  }
+}
diff --git a/test/Inputs/clang-importer-sdk/usr/include/objc_generics.h b/test/Inputs/clang-importer-sdk/usr/include/objc_generics.h
index fe1cef5..439ee9f 100644
--- a/test/Inputs/clang-importer-sdk/usr/include/objc_generics.h
+++ b/test/Inputs/clang-importer-sdk/usr/include/objc_generics.h
@@ -67,6 +67,9 @@
 
 @end
 
+@interface PettableOverextendedMetaphor: NSObject <Pettable>
+@end
+
 @protocol Fungible
 @end
 
diff --git a/test/Inputs/comment_to_something_conversion.swift b/test/Inputs/comment_to_something_conversion.swift
index 5f118e3..83cf5d1 100644
--- a/test/Inputs/comment_to_something_conversion.swift
+++ b/test/Inputs/comment_to_something_conversion.swift
@@ -11,7 +11,7 @@
 
 /// Aaa.  init().
 public init() {}
-// CHECK: {{.*}}DocCommentAsXML=[<Function file="{{.*}}" line="{{.*}}" column="{{.*}}"><Name>init()</Name><USR>c:objc(cs)A010_AttachToEntities(cm)init</USR><Declaration>public init()</Declaration><Abstract><Para>Aaa.  init().</Para></Abstract></Function>]
+// CHECK: {{.*}}DocCommentAsXML=[<Function file="{{.*}}" line="{{.*}}" column="{{.*}}"><Name>init()</Name><USR>c:objc(cs)A010_AttachToEntities(im)init</USR><Declaration>public init()</Declaration><Abstract><Para>Aaa.  init().</Para></Abstract></Function>]
 
 /// Aaa.  subscript(i: Int).
 public subscript(i: Int) -> Int {
diff --git a/test/Interpreter/generic_subscript.swift b/test/Interpreter/generic_subscript.swift
new file mode 100644
index 0000000..8e8a4d4
--- /dev/null
+++ b/test/Interpreter/generic_subscript.swift
@@ -0,0 +1,132 @@
+//===--- generic_subscript.swift ------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+//
+
+import StdlibUnittest
+
+
+var GenericSubscriptTestSuite = TestSuite("GenericSubscript")
+
+struct S<T> : P {
+  typealias Element = T
+  var t: T
+
+  subscript<U>(a: (T) -> U, b: (U) -> T) -> U {
+    get {
+      print(T.self)
+      print(U.self)
+
+      return a(t)
+    }
+    set {
+      print(T.self)
+      print(U.self)
+
+      t = b(newValue)
+    }
+  }
+}
+
+protocol P {
+  associatedtype Element
+  subscript<U>(a: (Element) -> U, b: (U) -> Element) -> U { get set }
+}
+
+func increment<T : P>(p: inout T) where T.Element == String {
+  p[{Int($0)!}, {String($0)}] += 1
+}
+
+GenericSubscriptTestSuite.test("Basic") {
+  var s = S<String>(t: "0")
+  increment(p: &s)
+  expectEqual(s.t, "1")
+}
+
+protocol AnySubscript {
+  subscript(k: AnyHashable) -> Any? { get set }
+}
+
+struct AnyDictionary : AnySubscript {
+  var dict: [AnyHashable : Any] = [:]
+
+  subscript(k: AnyHashable) -> Any? {
+    get {
+      return dict[k]
+    }
+    set {
+      dict[k] = newValue
+    }
+  }
+}
+
+extension AnySubscript {
+  subscript<K : Hashable, V>(k k: K) -> V? {
+    get {
+      return self[k] as! V?
+    }
+    set {
+      self[k] = newValue
+    }
+  }
+}
+
+GenericSubscriptTestSuite.test("ProtocolExtensionConcrete") {
+  var dict = AnyDictionary()
+
+  func doIt(dict: inout AnyDictionary) {
+    dict["a" ] = 0
+    dict[k: "a"]! += 1
+  }
+
+  doIt(dict: &dict)
+
+  expectEqual(dict["a"]! as! Int, 1)
+  expectEqual(dict[k: "a"]!, 1)
+}
+
+GenericSubscriptTestSuite.test("ProtocolExtensionAbstract") {
+  var dict = AnyDictionary()
+
+  func doIt<T : AnySubscript>(dict: inout T) {
+    dict["a" ] = 0
+    dict[k: "a"]! += 1
+  }
+
+  doIt(dict: &dict)
+
+  expectEqual(dict["a"]! as! Int, 1)
+  expectEqual(dict[k: "a"]!, 1)
+}
+
+protocol GenericSubscript : AnySubscript {
+  subscript<K : Hashable, V>(k k: K) -> V? { get set }
+}
+
+extension AnyDictionary : GenericSubscript { }
+
+GenericSubscriptTestSuite.test("ProtocolExtensionWitness") {
+  var dict = AnyDictionary()
+
+  func doIt<T : GenericSubscript>(dict: inout T) {
+    dict["a" ] = 0
+    dict[k: "a"]! += 1
+  }
+
+  doIt(dict: &dict)
+
+  expectEqual(dict["a"]! as! Int, 1)
+  expectEqual(dict[k: "a"]!, 1)
+}
+
+runAllTests()
diff --git a/test/NameBinding/scope_map.swift b/test/NameBinding/scope_map.swift
index ae85d46..4067a15 100644
--- a/test/NameBinding/scope_map.swift
+++ b/test/NameBinding/scope_map.swift
@@ -368,7 +368,7 @@
 // CHECK-EXPANDED: {{^}}  `-BraceStmt {{.*}} [142:41 - 155:1] expanded
 // CHECK-EXPANDED-NEXT: {{^}} `-PatternBinding {{.*}} entry 0 [143:7 - 155:1] expanded
 // CHECK-EXPANDED-NEXT: {{^}}    `-AfterPatternBinding {{.*}} entry 0 [143:17 - 155:1] expanded
-// CHECK-EXPANDED-NEXT: {{^}}      |-Accessors {{.*}} scope_map.(file).func decl.computed@{{.*}}scope_map.swift:143:7 [143:21 - 149:3] expanded
+// CHECK-EXPANDED-NEXT: {{^}}      |-Accessors {{.*}} scope_map.(file).funcWithComputedProperties(i:).computed@{{.*}}scope_map.swift:143:7 [143:21 - 149:3] expanded
 // CHECK-EXPANDED-NEXT: {{^}}       |-AbstractFunctionDecl {{.*}} _ [144:5 - 145:5] expanded
 // CHECK-EXPANDED-NEXT: {{^}}        `-AbstractFunctionParams {{.*}} _ param 0:0 [144:5 - 145:5] expanded
 // CHECK-EXPANDED: {{^}}          `-BraceStmt {{.*}} [144:9 - 145:5] expanded
diff --git a/test/Parse/enum.swift b/test/Parse/enum.swift
index b7989a7..63296e1 100644
--- a/test/Parse/enum.swift
+++ b/test/Parse/enum.swift
@@ -3,7 +3,7 @@
 // FIXME: this test only passes on platforms which have Float80.
 // <rdar://problem/19508460> Floating point enum raw values are not portable
 
-// REQUIRES: CPU=i386 || CPU=x86_64
+// REQUIRES: CPU=i386_or_x86_64
 
 enum Empty {}
 
diff --git a/test/Parse/matching_patterns.swift b/test/Parse/matching_patterns.swift
index d7766ec..57dd399 100644
--- a/test/Parse/matching_patterns.swift
+++ b/test/Parse/matching_patterns.swift
@@ -100,7 +100,7 @@
     }
 
     switch foo {
-    case .Naught: // expected-error{{enum case 'Naught' not found in type 'Foo'}}
+    case .Naught: // expected-error{{pattern cannot match values of type 'Foo'}}
       ()
     case .A, .B, .C:
       ()
@@ -137,7 +137,7 @@
 var notAnEnum = 0
 
 switch notAnEnum {
-case .Foo: // expected-error{{enum case 'Foo' not found in type 'Int'}}
+case .Foo: // expected-error{{pattern cannot match values of type 'Int'}}
   ()
 }
 
@@ -264,10 +264,8 @@
 // expected-error@-1{{'+++' is not a prefix unary operator}}
   ()
 case (_, var e, 3) +++ (1, 2, 3):
-// expected-error@-1{{binary operator '+++' cannot be applied to operands of type '(_, <<error type>>, Int)' and '(Int, Int, Int)'}}
-// expected-note@-2{{expected an argument list of type '((Int, Int, Int), (Int, Int, Int))'}}
-// expected-error@-3{{'var' binding pattern cannot appear in an expression}}
-// expected-error@-4{{'var' binding pattern cannot appear in an expression}}
+// expected-error@-1{{'_' can only appear in a pattern}}
+// expected-error@-2{{'var' binding pattern cannot appear in an expression}}
   ()
 }
 
diff --git a/test/Parse/switch.swift b/test/Parse/switch.swift
index 6741c3b..7e2b81ae 100644
--- a/test/Parse/switch.swift
+++ b/test/Parse/switch.swift
@@ -264,7 +264,7 @@
 
 func enumElementSyntaxOnTuple() {
   switch (1, 1) {
-  case .Bar: // expected-error {{enum case 'Bar' not found in type '(Int, Int)'}}
+  case .Bar: // expected-error {{pattern cannot match values of type '(Int, Int)'}}
     break
   default:
     break
diff --git a/test/PrintAsObjC/extensions.swift b/test/PrintAsObjC/extensions.swift
index 49fd2e1..6b6974a 100644
--- a/test/PrintAsObjC/extensions.swift
+++ b/test/PrintAsObjC/extensions.swift
@@ -84,7 +84,7 @@
   func anyOldMethod() {}
 }
 
-// CHECK-LABEL: @interface GenericClass (SWIFT_EXTENSION(extensions))
+// CHECK-LABEL: @interface GenericClass<T> (SWIFT_EXTENSION(extensions))
 // CHECK-NEXT: - (void)bar;
 // CHECK-NEXT: @end
 extension GenericClass {
@@ -115,3 +115,17 @@
   class func fromColor(_ color: NSColor) -> NSString? { return nil; }
 }
 
+// CHECK-LABEL: @interface PettableContainer<T> (SWIFT_EXTENSION(extensions))
+// CHECK-NEXT: - (PettableContainer<T> * _Nonnull)duplicate SWIFT_WARN_UNUSED_RESULT;
+// CHECK-NEXT: - (PettableContainer<T> * _Nonnull)duplicate2 SWIFT_WARN_UNUSED_RESULT;
+// CHECK-NEXT: - (PettableContainer<PettableOverextendedMetaphor *> * _Nonnull)duplicate3 SWIFT_WARN_UNUSED_RESULT;
+// CHECK-NEXT: - (T _Nonnull)extract SWIFT_WARN_UNUSED_RESULT;
+// CHECK-NEXT: - (T _Nullable)extract2 SWIFT_WARN_UNUSED_RESULT;
+// CHECK-NEXT: @end
+extension PettableContainer {
+  func duplicate() -> PettableContainer { fatalError() }
+  func duplicate2() -> PettableContainer<T> { fatalError() }
+  func duplicate3() -> PettableContainer<PettableOverextendedMetaphor> { fatalError() }
+  func extract() -> T { fatalError() }
+  func extract2() -> T? { fatalError() }
+}
diff --git a/test/Runtime/weak-reference-racetests.swift b/test/Runtime/weak-reference-racetests.swift
index a3235f5..40a1a2c 100644
--- a/test/Runtime/weak-reference-racetests.swift
+++ b/test/Runtime/weak-reference-racetests.swift
@@ -1,5 +1,6 @@
 // RUN: %target-run-simple-swift
 // REQUIRES: executable_test
+// UNSUPPORTED: nonatomic_rc
 
 import StdlibUnittest
 
diff --git a/test/SIL/Parser/opaque_values_parse.sil b/test/SIL/Parser/opaque_values_parse.sil
index cf286a1..1ae6709 100644
--- a/test/SIL/Parser/opaque_values_parse.sil
+++ b/test/SIL/Parser/opaque_values_parse.sil
@@ -1,9 +1,54 @@
 // RUN: %target-sil-opt -enable-sil-opaque-values -enable-sil-verify-all -emit-sorted-sil %s | %FileCheck %s
 
 import Builtin
+import Swift
 
 sil_stage canonical
 
+protocol Foo {
+  func foo()
+}
+
+struct S : Foo {
+  func foo()
+  init()
+}
+
+// CHECK-LABEL: sil @castOpaque : $@convention(thin) (Int) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Int):
+// CHECK:  unconditional_checked_cast_opaque [[ARG]] : $Int to $Foo
+// CHECK-LABEL: } // end sil function 'castOpaque'
+sil @castOpaque : $@convention(thin) (Int) -> () {
+bb0(%0 : $Int):
+  %c = unconditional_checked_cast_opaque %0 : $Int to $Foo
+  %t = tuple ()
+  return %t : $()
+}
+
+// CHECK-LABEL: sil @initDeinitExistentialOpaque : $@convention(thin) <T> (@in T) -> () {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK:  [[IE:%.*]] = init_existential_opaque [[ARG]] : $T, $T, $Any
+// CHECK:  deinit_existential_opaque [[IE]] : $Any
+// CHECK-LABEL: } // end sil function 'initDeinitExistentialOpaque'
+sil @initDeinitExistentialOpaque : $@convention(thin) <T> (@in T) -> () {
+bb0(%0 : $T):
+  %i = init_existential_opaque %0 : $T, $T, $Any
+  %d = deinit_existential_opaque %i : $Any
+  %t = tuple ()
+  return %t : $()
+}
+
+// CHECK-LABEL: sil @openExistentialOpaque : $@convention(thin) (@in Foo) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Foo):
+// CHECK:  open_existential_opaque [[ARG]] : $Foo to $@opened("2E9EACA6-FD59-11E6-B016-685B3593C496") Foo
+// CHECK-LABEL: } // end sil function 'openExistentialOpaque'
+sil @openExistentialOpaque : $@convention(thin) (@in Foo) -> () {
+bb0(%0 : $Foo):
+  %o = open_existential_opaque %0 : $Foo to $@opened("2E9EACA6-FD59-11E6-B016-685B3593C496") Foo
+  %t = tuple ()
+  return %t : $()
+}
+
 // Test @callee_guaranteed parsing.
 // ----
 
@@ -38,15 +83,6 @@
 // Test @in_guaranteed parsing.
 // ----
 
-protocol Foo {
-  func foo()
-}
-
-struct S : Foo {
-  func foo()
-  init()
-}
-
 sil @doWithS : $@convention(method) (S) -> ()
 
 // CHECK-LABEL: sil hidden [transparent] [thunk] @parse_mutating : $@convention(witness_method) (@in_guaranteed S) -> () {
diff --git a/test/SIL/Parser/undef.sil b/test/SIL/Parser/undef.sil
index 68c83d6..fadb388 100644
--- a/test/SIL/Parser/undef.sil
+++ b/test/SIL/Parser/undef.sil
@@ -244,14 +244,6 @@
   bridge_object_to_word undef : $Builtin.BridgeObject to $Builtin.Word
   // CHECK: thin_to_thick_function undef : $@convention(thin) () -> () to $() -> ()
   thin_to_thick_function undef : $@convention(thin) () -> () to $() -> ()
-  // CHECK: thick_to_objc_metatype undef : $@thick C.Type to $@objc_metatype C.Type
-  thick_to_objc_metatype undef : $@thick C.Type to $@objc_metatype C.Type
-  // CHECK: objc_to_thick_metatype undef : $@objc_metatype C.Type to $@thick C.Type
-  objc_to_thick_metatype undef : $@objc_metatype C.Type to $@thick C.Type
-  // CHECK: objc_metatype_to_object undef : $@objc_metatype C.Type to $AnyObject
-  objc_metatype_to_object undef : $@objc_metatype C.Type to $AnyObject
-  // CHECK: objc_existential_metatype_to_object undef : $@objc_metatype P.Type to $AnyObject
-  objc_existential_metatype_to_object undef : $@objc_metatype P.Type to $AnyObject
   // CHECK: is_nonnull undef : $C
   is_nonnull undef : $C
 
diff --git a/test/SIL/Parser/undef_objc.sil b/test/SIL/Parser/undef_objc.sil
new file mode 100644
index 0000000..b4119cd
--- /dev/null
+++ b/test/SIL/Parser/undef_objc.sil
@@ -0,0 +1,23 @@
+// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil %s | %target-sil-opt -assume-parsing-unqualified-ownership-sil | %FileCheck %s
+// REQUIRES: objc_interop
+
+sil_stage raw
+
+import Builtin
+import Swift
+
+protocol P { }
+class C { }
+
+sil @general_test : $() -> () {
+bb0:
+  // CHECK: thick_to_objc_metatype undef : $@thick C.Type to $@objc_metatype C.Type
+  thick_to_objc_metatype undef : $@thick C.Type to $@objc_metatype C.Type
+  // CHECK: objc_to_thick_metatype undef : $@objc_metatype C.Type to $@thick C.Type
+  objc_to_thick_metatype undef : $@objc_metatype C.Type to $@thick C.Type
+  // CHECK: objc_metatype_to_object undef : $@objc_metatype C.Type to $AnyObject
+  objc_metatype_to_object undef : $@objc_metatype C.Type to $AnyObject
+  // CHECK: objc_existential_metatype_to_object undef : $@objc_metatype P.Type to $AnyObject
+  objc_existential_metatype_to_object undef : $@objc_metatype P.Type to $AnyObject
+  unreachable
+}
diff --git a/test/SIL/Serialization/opaque_values_serialize.sil b/test/SIL/Serialization/opaque_values_serialize.sil
index 680516d..945b17a 100644
--- a/test/SIL/Serialization/opaque_values_serialize.sil
+++ b/test/SIL/Serialization/opaque_values_serialize.sil
@@ -9,6 +9,51 @@
 sil_stage canonical
 
 import Builtin
+import Swift
+
+protocol Foo {
+  func foo()
+}
+
+struct S : Foo {
+  func foo()
+  init()
+}
+
+// CHECK-LABEL: sil @castOpaque : $@convention(thin) (Int) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Int):
+// CHECK:  unconditional_checked_cast_opaque [[ARG]] : $Int to $Foo
+// CHECK-LABEL: } // end sil function 'castOpaque'
+sil @castOpaque : $@convention(thin) (Int) -> () {
+bb0(%0 : $Int):
+  %c = unconditional_checked_cast_opaque %0 : $Int to $Foo
+  %t = tuple ()
+  return %t : $()
+}
+
+// CHECK-LABEL: sil @initDeinitExistentialOpaque : $@convention(thin) <T> (@in T) -> () {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK:  [[IE:%.*]] = init_existential_opaque [[ARG]] : $T, $T, $Any
+// CHECK:  deinit_existential_opaque [[IE]] : $Any
+// CHECK-LABEL: } // end sil function 'initDeinitExistentialOpaque'
+sil @initDeinitExistentialOpaque : $@convention(thin) <T> (@in T) -> () {
+bb0(%0 : $T):
+  %i = init_existential_opaque %0 : $T, $T, $Any
+  %d = deinit_existential_opaque %i : $Any
+  %t = tuple ()
+  return %t : $()
+}
+
+// CHECK-LABEL: sil @openExistentialOpaque : $@convention(thin) (@in Foo) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Foo):
+// CHECK:  open_existential_opaque [[ARG]] : $Foo to $@opened({{.*}}) Foo
+// CHECK-LABEL: } // end sil function 'openExistentialOpaque'
+sil @openExistentialOpaque : $@convention(thin) (@in Foo) -> () {
+bb0(%0 : $Foo):
+  %o = open_existential_opaque %0 : $Foo to $@opened("2E9EACA6-FD59-11E6-B016-685B3593C496") Foo
+  %t = tuple ()
+  return %t : $()
+}
 
 // Test @in/@out serialization.
 // ----
@@ -25,15 +70,6 @@
 // Test @in_guaranteed serialization.
 // ----
 
-protocol Foo {
-  func foo()
-}
-
-struct S : Foo {
-  func foo()
-  init()
-}
-
 sil @doWithS : $@convention(method) (S) -> ()
 
 // CHECK-LABEL: sil hidden [transparent] [thunk] @serialize_mutating : $@convention(witness_method) (@in_guaranteed S) -> () {
diff --git a/test/SIL/ownership-verifier/use_verifier.sil b/test/SIL/ownership-verifier/use_verifier.sil
index 7405276..782008b 100644
--- a/test/SIL/ownership-verifier/use_verifier.sil
+++ b/test/SIL/ownership-verifier/use_verifier.sil
@@ -528,17 +528,18 @@
   destroy_value %1 : $SuperKlass
   br bb3
 
-bb2:
+bb2(%2 : @owned $Builtin.NativeObject):
+  destroy_value %2 : $Builtin.NativeObject
   br bb3
 
 bb3:
-  %2 = metatype $@thick SuperKlass.Type
-  checked_cast_br %2 : $@thick SuperKlass.Type to $@thick SubKlass.Type, bb4, bb5
+  %3 = metatype $@thick SuperKlass.Type
+  checked_cast_br %3 : $@thick SuperKlass.Type to $@thick SubKlass.Type, bb4, bb5
 
-bb4(%3 : @trivial $@thick SubKlass.Type):
+bb4(%4 : @trivial $@thick SubKlass.Type):
   br bb6
 
-bb5:
+bb5(%5 : @trivial $@thick SuperKlass.Type):
   br bb6
 
 bb6:
diff --git a/test/SILGen/accessors.swift b/test/SILGen/accessors.swift
index 1f74097..3f124b0 100644
--- a/test/SILGen/accessors.swift
+++ b/test/SILGen/accessors.swift
@@ -65,7 +65,7 @@
 // CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
 
 // CHECK:    [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : $Builtin.RawPointer):
-// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout A, @thick A.Type) -> ()
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout A, @thick A.Type) -> ()
 // CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $A
 // SEMANTIC SIL TODO: This is an issue caused by the callback for materializeForSet in the class case taking the value as @inout when it should really take it as @guaranteed.
 // CHECK-NEXT: store [[BORROWED_ARG_LHS]] to [init] [[TEMP2]] : $*A
@@ -128,7 +128,7 @@
 // CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
 //
 // CHECK:    [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : $Builtin.RawPointer):
-// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
 // CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $B
 // CHECK-NEXT: store [[BORROWED_ARG_RHS]] to [init] [[TEMP2]] : $*B
 // CHECK-NEXT: [[T0:%.*]] = metatype $@thick B.Type
@@ -154,7 +154,7 @@
 // CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
 //
 // CHECK:    [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : $Builtin.RawPointer):
-// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
 // CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $B
 // CHECK-NEXT: store [[BORROWED_ARG_LHS]] to [init] [[TEMP2]] : $*B
 // CHECK-NEXT: [[T0:%.*]] = metatype $@thick B.Type
diff --git a/test/SILGen/addressors.swift b/test/SILGen/addressors.swift
index ec23481..fe274de 100644
--- a/test/SILGen/addressors.swift
+++ b/test/SILGen/addressors.swift
@@ -331,6 +331,14 @@
 // CHECK:   store [[VALUE]] to [[T2]] : $*Int32
 // CHECK:   strong_release [[OWNER]] : $Builtin.NativeObject
 
+//   materializeForSet callback for G.value
+// CHECK-LABEL: sil hidden [transparent] @_T010addressors1GC5values5Int32VfmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout G, @thick G.Type) -> () {
+// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*G, [[SELFTYPE:%3]] : $@thick G.Type):
+// CHECK:   [[T0:%.*]] = project_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+// CHECK:   [[OWNER:%.*]] = load [[T0]]
+// CHECK:   strong_release [[OWNER]] : $Builtin.NativeObject
+// CHECK:   dealloc_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+
 //   materializeForSet for G.value
 // CHECK-LABEL: sil hidden [transparent] @_T010addressors1GC5values5Int32Vfm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed G) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
 // CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $G):
@@ -355,14 +363,6 @@
 // CHECK:   [[RESULT:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
 // CHECK:   return [[RESULT]]
 
-//   materializeForSet callback for G.value
-// CHECK-LABEL: sil hidden [transparent] @_T010addressors1GC5values5Int32VfmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout G, @thick G.Type) -> () {
-// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*G, [[SELFTYPE:%3]] : $@thick G.Type):
-// CHECK:   [[T0:%.*]] = project_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
-// CHECK:   [[OWNER:%.*]] = load [[T0]]
-// CHECK:   strong_release [[OWNER]] : $Builtin.NativeObject
-// CHECK:   dealloc_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
-
 class H {
   var data: UnsafeMutablePointer<Int32> = UnsafeMutablePointer.allocate(capacity: 100)
 
@@ -451,6 +451,14 @@
 // CHECK:   store [[VALUE]] to [[T2]] : $*Int32
 // CHECK:   strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
 
+//   materializeForSet callback for I.value
+// CHECK-LABEL: sil hidden [transparent] @_T010addressors1IC5values5Int32VfmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout I, @thick I.Type) -> () {
+// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*I, [[SELFTYPE:%3]] : $@thick I.Type):
+// CHECK:   [[T0:%.*]] = project_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+// CHECK:   [[OWNER:%.*]] = load [[T0]]
+// CHECK:   strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK:   dealloc_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+
 // CHECK-LABEL: sil hidden [transparent] @_T010addressors1IC5values5Int32Vfm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed I) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
 // CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $I):
 //   Call the addressor.
@@ -474,14 +482,6 @@
 // CHECK:   [[RESULT:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
 // CHECK:   return [[RESULT]]
 
-//   materializeForSet callback for I.value
-// CHECK-LABEL: sil hidden [transparent] @_T010addressors1IC5values5Int32VfmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout I, @thick I.Type) -> () {
-// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*I, [[SELFTYPE:%3]] : $@thick I.Type):
-// CHECK:   [[T0:%.*]] = project_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
-// CHECK:   [[OWNER:%.*]] = load [[T0]]
-// CHECK:   strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
-// CHECK:   dealloc_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
-
 struct RecInner {
   subscript(i: Int32) -> Int32 {
     mutating get { return i }
diff --git a/test/SILGen/c_materializeForSet_linkage.swift b/test/SILGen/c_materializeForSet_linkage.swift
index 0825c55..3d9b221 100644
--- a/test/SILGen/c_materializeForSet_linkage.swift
+++ b/test/SILGen/c_materializeForSet_linkage.swift
@@ -19,8 +19,8 @@
 // CHECK-LABEL: sil shared [transparent] [fragile] @_T0SC7NSPointV1xSffm
 // CHECK-LABEL: sil shared [transparent] [fragile] @_T0SC7NSPointV1ySffm
 
-// CHECK-LABEL: sil shared @_T0So16NSReferencePointC1xSffm
-// CHECK-LABEL: sil shared @_T0So16NSReferencePointC1ySffm
-
 // CHECK-LABEL: sil shared @_T0So16NSReferencePointC1xSffmytfU_
+// CHECK-LABEL: sil shared @_T0So16NSReferencePointC1xSffm
+
 // CHECK-LABEL: sil shared @_T0So16NSReferencePointC1ySffmytfU_
+// CHECK-LABEL: sil shared @_T0So16NSReferencePointC1ySffm
diff --git a/test/SILGen/casts.swift b/test/SILGen/casts.swift
index 3e9a92f..e493c45 100644
--- a/test/SILGen/casts.swift
+++ b/test/SILGen/casts.swift
@@ -16,11 +16,20 @@
 
 // CHECK-LABEL: sil hidden @_T05casts3isa{{[_0-9a-zA-Z]*}}F
 func isa(b: B) -> Bool {
-  // CHECK: checked_cast_br {{%.*}}, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
-  // CHECK: [[YES]]({{%.*}}):
+  // CHECK: bb0([[ARG:%.*]] : $B):
+  // CHECK:   [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+  // CHECK:   [[COPIED_BORROWED_ARG:%.*]] = copy_value [[BORROWED_ARG]]
+  // CHECK:   checked_cast_br [[COPIED_BORROWED_ARG]] : $B to $D, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
+  //
+  // CHECK: [[YES]]([[CASTED_VALUE:%.*]] : $D):
   // CHECK:   integer_literal {{.*}} -1
-  // CHECK: [[NO]]:
+  // CHECK:   destroy_value [[CASTED_VALUE]]
+  // CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
+  //
+  // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $B):
+  // CHECK:   destroy_value [[ORIGINAL_VALUE]]
   // CHECK:   integer_literal {{.*}} 0
+  // CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
   return b is D
 }
 
@@ -42,15 +51,22 @@
   return b as! T
 }
 
+// This is making sure that we do not have the default propagating behavior in
+// the address case.
+//
 // CHECK-LABEL: sil hidden @_T05casts12is_archetype{{[_0-9a-zA-Z]*}}F
 func is_archetype<T : B>(b: B, _: T) -> Bool {
-  // CHECK: checked_cast_br {{%.*}}, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
-  // CHECK: [[YES]]({{%.*}}):
+  // CHECK: bb0([[ARG1:%.*]] : $B, [[ARG2:%.*]] : $T):
+  // CHECK:   checked_cast_br {{%.*}}, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
+  // CHECK: [[YES]]([[CASTED_ARG:%.*]] : $T):
   // CHECK:   integer_literal {{.*}} -1
-  // CHECK: [[NO]]:
+  // CHECK:   destroy_value [[CASTED_ARG]]
+  // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $B):
+  // CHCEK:   destroy_value [[CASTED_ARG]]
   // CHECK:   integer_literal {{.*}} 0
   return b is T
 }
+// CHECK: } // end sil function '_T05casts12is_archetype{{[_0-9a-zA-Z]*}}F'
 
 // CHECK: sil hidden @_T05casts20downcast_conditional{{[_0-9a-zA-Z]*}}F
 // CHECK:   checked_cast_br {{%.*}} : $B to $D
diff --git a/test/SILGen/constrained_extensions.swift b/test/SILGen/constrained_extensions.swift
index 61223b0..e6820ca 100644
--- a/test/SILGen/constrained_extensions.swift
+++ b/test/SILGen/constrained_extensions.swift
@@ -10,8 +10,9 @@
 
   // CHECK-LABEL: sil @_T0Sa22constrained_extensionsSiRszlE16instancePropertySifg : $@convention(method) (@guaranteed Array<Int>) -> Int
   // CHECK-LABEL: sil @_T0Sa22constrained_extensionsSiRszlE16instancePropertySifs : $@convention(method) (Int, @inout Array<Int>) -> ()
+  // CHECK-LABEL: sil [transparent] [fragile] @_T0Sa22constrained_extensionsSiRszlE16instancePropertySifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Array<Int>, @thick Array<Int>.Type) -> ()
   // CHECK-LABEL: sil [transparent] [fragile] @_T0Sa22constrained_extensionsSiRszlE16instancePropertySifm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Array<Int>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
-  // CHECK-LABEL: sil [transparent] [fragile] @_T0Sa22constrained_extensionsSiRszlE16instancePropertySifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Array<Int>, @thick Array<Int>.Type) -> ()
+
   public var instanceProperty: Element {
     get {
       return self[0]
@@ -70,8 +71,8 @@
 
   // CHECK-LABEL: sil @_T0s10DictionaryV22constrained_extensionsSiRszr0_lE16instancePropertyq_fg : $@convention(method) <Key, Value where Key == Int> (@guaranteed Dictionary<Int, Value>) -> @out Value
   // CHECK-LABEL: sil @_T0s10DictionaryV22constrained_extensionsSiRszr0_lE16instancePropertyq_fs : $@convention(method) <Key, Value where Key == Int> (@in Value, @inout Dictionary<Int, Value>) -> ()
+  // CHECK-LABEL: sil [transparent] [fragile] @_T0s10DictionaryV22constrained_extensionsSiRszr0_lE16instancePropertyq_fmytfU_ : $@convention(method) <Key, Value where Key == Int> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Int, Value>, @thick Dictionary<Int, Value>.Type) -> ()
   // CHECK-LABEL: sil [transparent] [fragile] @_T0s10DictionaryV22constrained_extensionsSiRszr0_lE16instancePropertyq_fm : $@convention(method) <Key, Value where Key == Int> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Int, Value>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
-  // CHECK-LABEL: sil [transparent] [fragile] @_T0s10DictionaryV22constrained_extensionsSiRszr0_lE16instancePropertyq_fmytfU_ : $@convention(thin) <Key, Value where Key == Int> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Int, Value>, @thick Dictionary<Int, Value>.Type) -> ()
   public var instanceProperty: Value {
     get {
       return self[0]!
diff --git a/test/SILGen/generic_casts.swift b/test/SILGen/generic_casts.swift
index 959d179..6269058 100644
--- a/test/SILGen/generic_casts.swift
+++ b/test/SILGen/generic_casts.swift
@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-runtime %s
 
 protocol ClassBound : class {}
 protocol NotClassBound {}
@@ -57,16 +57,21 @@
 func class_archetype_to_class_archetype
 <T:ClassBound, U:ClassBound>(_ t:T) -> U {
   return t as! U
-  // CHECK: unconditional_checked_cast_addr {{.*}} T in {{%.*}} : $*T to U in [[DOWNCAST_ADDR:%.*]] : $*U
-  // CHECK: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]]
-  // CHECK: return [[DOWNCAST]] : $U
+  // Error bridging can change the identity of class-constrained archetypes.
+  // CHECK-objc: unconditional_checked_cast_addr {{.*}} T in {{%.*}} : $*T to U in [[DOWNCAST_ADDR:%.*]] : $*U
+  // CHECK-objc: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]]
+  // CHECK-objc: return [[DOWNCAST]] : $U
+
+  // CHECK-native: [[DOWNCAST:%.*]] = unconditional_checked_cast {{.*}} : $T to $U
 }
 
 // CHECK-LABEL: sil hidden @_TF13generic_casts34class_archetype_is_class_archetype{{.*}}
 func class_archetype_is_class_archetype
 <T:ClassBound, U:ClassBound>(_ t:T, u:U.Type) -> Bool {
   return t is U
-  // CHECK: checked_cast_addr_br {{.*}} T in {{%.*}} : $*T to U in {{%.*}} : $*U
+  // Error bridging can change the identity of class-constrained archetypes.
+  // CHECK-objc: checked_cast_addr_br {{.*}} T in {{%.*}} : $*T to U in {{%.*}} : $*U
+  // CHECK-native: checked_cast_br {{.*}} : $T to $U
 }
 
 // CHECK-LABEL: sil hidden @_TF13generic_casts38opaque_archetype_to_addr_only_concrete{{.*}}
@@ -156,16 +161,19 @@
 func class_existential_to_class_archetype
 <T:ClassBound>(_ p:ClassBound) -> T {
   return p as! T
-  // CHECK: unconditional_checked_cast_addr {{.*}} ClassBound in {{%.*}} : $*ClassBound to T in [[DOWNCAST_ADDR:%.*]] : $*T
-  // CHECK: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]]
-  // CHECK: return [[DOWNCAST]] : $T
+  // CHECK-objc: unconditional_checked_cast_addr {{.*}} ClassBound in {{%.*}} : $*ClassBound to T in [[DOWNCAST_ADDR:%.*]] : $*T
+  // CHECK-objc: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]]
+  // CHECK-objc: return [[DOWNCAST]] : $T
+
+  // CHECK-native: [[DOWNCAST:%.*]] = unconditional_checked_cast {{.*}} : $ClassBound to $T
 }
 
 // CHECK-LABEL: sil hidden @_TF13generic_casts36class_existential_is_class_archetype{{.*}}
 func class_existential_is_class_archetype
 <T:ClassBound>(_ p:ClassBound, _: T) -> Bool {
   return p is T
-  // CHECK: checked_cast_addr_br {{.*}} ClassBound in {{%.*}} : $*ClassBound to T in {{%.*}} : $*T
+  // CHECK-objc: checked_cast_addr_br {{.*}} ClassBound in {{%.*}} : $*ClassBound to T in {{%.*}} : $*T
+  // CHECK-native: checked_cast_br {{.*}} : $ClassBound to $T
 }
 
 // CHECK-LABEL: sil hidden @_TF13generic_casts40opaque_existential_to_addr_only_concrete{{.*}}
diff --git a/test/SILGen/if_while_binding.swift b/test/SILGen/if_while_binding.swift
index 2f0d3c1..93d8159 100644
--- a/test/SILGen/if_while_binding.swift
+++ b/test/SILGen/if_while_binding.swift
@@ -309,8 +309,8 @@
   // CHECK:   [[DERIVED_CLS_SOME:%.*]] = enum $Optional<DerivedClass>, #Optional.some!enumelt.1, [[DERIVED_CLS]] : $DerivedClass
   // CHECK:   br [[MERGE:bb[0-9]+]]([[DERIVED_CLS_SOME]] : $Optional<DerivedClass>)
 
-  // CHECK: [[ISBASEBB]]:
-  // CHECK:   destroy_value [[CLS]] : $BaseClass
+  // CHECK: [[ISBASEBB]]([[BASECLASS:%.*]] : $BaseClass):
+  // CHECK:   destroy_value [[BASECLASS]] : $BaseClass
   // CHECK:   = enum $Optional<DerivedClass>, #Optional.none!enumelt
   // CHECK:   br [[MERGE]](
 
diff --git a/test/SILGen/lifetime.swift b/test/SILGen/lifetime.swift
index 39a4ab5..47cad67 100644
--- a/test/SILGen/lifetime.swift
+++ b/test/SILGen/lifetime.swift
@@ -380,7 +380,7 @@
   // CHECK: [[ADDR:%.*]] = pointer_to_address [[PTR]]
   // CHECK: [[MARKED_ADDR:%.*]] = mark_dependence [[ADDR]] : $*Aleph on [[R2]]
   // CHECK: {{.*}}([[CALLBACK_ADDR:%.*]] : 
-  // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout RefWithProp, @thick RefWithProp.Type) -> ()
+  // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout RefWithProp, @thick RefWithProp.Type) -> ()
   // CHECK: [[TEMP:%.*]] = alloc_stack $RefWithProp
   // CHECK: store [[R2]] to [init] [[TEMP]]
   // CHECK: apply [[CALLBACK]]({{.*}}, [[STORAGE]], [[TEMP]], {{%.*}})
diff --git a/test/SILGen/materializeForSet.swift b/test/SILGen/materializeForSet.swift
index c92c9d6..7f3d867 100644
--- a/test/SILGen/materializeForSet.swift
+++ b/test/SILGen/materializeForSet.swift
@@ -6,6 +6,14 @@
 // The ordering here is unfortunate: we generate the property
 // getters and setters after we've processed the decl.
 
+  // CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet4BaseC8computedSifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> () {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Base, [[SELFTYPE:%.*]] : $@thick Base.Type):
+// CHECK:   [[T0:%.*]] = load_borrow [[SELF]]
+// CHECK:   [[T1:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK:   [[T2:%.*]] = load [trivial] [[T1]] : $*Int
+// CHECK:   [[SETTER:%.*]] = function_ref @_T017materializeForSet4BaseC8computedSifs
+// CHECK:   apply [[SETTER]]([[T2]], [[T0]])
+
 // CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet4BaseC8computedSifm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed Base) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
 // CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $Base):
 // CHECK:   [[ADDR:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
@@ -13,21 +21,13 @@
 // CHECK:   [[T1:%.*]] = apply [[T0]]([[SELF]])
 // CHECK:   store [[T1]] to [trivial] [[ADDR]] : $*Int
 // CHECK:   [[BUFFER:%.*]] = address_to_pointer [[ADDR]]
-// CHECK:   [[T0:%.*]] = function_ref @_T017materializeForSet4BaseC8computedSifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> ()
+// CHECK:   [[T0:%.*]] = function_ref @_T017materializeForSet4BaseC8computedSifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> ()
 // CHECK:   [[T2:%.*]] = thin_function_to_pointer [[T0]]
 // CHECK:   [[T3:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T2]] : $Builtin.RawPointer
 // CHECK:   [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[T3]] : $Optional<Builtin.RawPointer>)
 // CHECK:   return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
 // CHECK: }
 
-// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet4BaseC8computedSifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> () {
-// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Base, [[SELFTYPE:%.*]] : $@thick Base.Type):
-// CHECK:   [[T0:%.*]] = load_borrow [[SELF]]
-// CHECK:   [[T1:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
-// CHECK:   [[T2:%.*]] = load [trivial] [[T1]] : $*Int
-// CHECK:   [[SETTER:%.*]] = function_ref @_T017materializeForSet4BaseC8computedSifs
-// CHECK:   apply [[SETTER]]([[T2]], [[T0]])
-
 // CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet4BaseC6storedSifm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed Base) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
 // CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $Base):
 // CHECK:   [[T0:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.stored
@@ -68,6 +68,21 @@
 // an abstraction pattern present.
 
 extension Derived : Abstractable {}
+
+// CHECK: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14storedFunction6ResultQzycfmytfU_TW : $@convention(witness_method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Derived, @thick Derived.Type) -> ()
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
+// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_owned () -> @out Int
+// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[RESULT_ADDR]] : $*@callee_owned () -> @out Int
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @_T0SiIxr_SiIxd_TR : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
+// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [[REABSTRACTOR]]([[VALUE]])
+// CHECK-NEXT: [[FN:%.*]] = class_method [[SELF]] : $Base, #Base.storedFunction!setter.1 : (Base) -> (@escaping () -> Int) -> ()
+// CHECK-NEXT: apply [[FN]]([[NEWVALUE]], [[SELF]])
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
 // CHECK: sil hidden [transparent] [thunk] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14storedFunction{{[_0-9a-zA-Z]*}}fmTW
 // CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived):
 // CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_owned () -> @out Int
@@ -92,17 +107,17 @@
 // CHECK-NEXT: dealloc_stack [[TEMP]]
 // CHECK-NEXT: return [[T0]]
 
-// CHECK: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14storedFunction6ResultQzycfmytfU_TW : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Derived, @thick Derived.Type) -> ()
+// CHECK: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP19finalStoredFunction6ResultQzycfmytfU_TW :
 // CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
 // CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
 // CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
 // CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_owned () -> @out Int
 // CHECK-NEXT: [[VALUE:%.*]] = load [take] [[RESULT_ADDR]] : $*@callee_owned () -> @out Int
-// CHECK-NEXT: function_ref
+// CHECK-NEXT: // function_ref
 // CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @_T0SiIxr_SiIxd_TR : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
 // CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [[REABSTRACTOR]]([[VALUE]])
-// CHECK-NEXT: [[FN:%.*]] = class_method [[SELF]] : $Base, #Base.storedFunction!setter.1 : (Base) -> (@escaping () -> Int) -> ()
-// CHECK-NEXT: apply [[FN]]([[NEWVALUE]], [[SELF]])
+// CHECK-NEXT: [[ADDR:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.finalStoredFunction
+// CHECK-NEXT: assign [[NEWVALUE]] to [[ADDR]]
 // CHECK-NEXT: tuple ()
 // CHECK-NEXT: return
 
@@ -125,19 +140,18 @@
 // CHECK-NEXT: [[T0:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
 // CHECK-NEXT: return [[T0]]
 
-// CHECK: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP19finalStoredFunction6ResultQzycfmytfU_TW :
-// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
-// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
-// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
-// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_owned () -> @out Int
-// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[RESULT_ADDR]] : $*@callee_owned () -> @out Int
-// CHECK-NEXT: // function_ref
-// CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @_T0SiIxr_SiIxd_TR : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
-// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [[REABSTRACTOR]]([[VALUE]])
-// CHECK-NEXT: [[ADDR:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.finalStoredFunction
-// CHECK-NEXT: assign [[NEWVALUE]] to [[ADDR]]
-// CHECK-NEXT: tuple ()
-// CHECK-NEXT: return
+// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14staticFunction6ResultQzycfmZytfU_TW
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*@thick Derived.Type, %3 : $@thick Derived.Type.Type):
+// CHECK-NEXT: [[SELF:%.*]] = load_borrow %2 : $*@thick Derived.Type
+// CHECK-NEXT: [[BASE_SELF:%.*]] = upcast [[SELF]] : $@thick Derived.Type to $@thick Base.Type
+// CHECK-NEXT: [[BUFFER:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_owned () -> @out Int
+// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[BUFFER]] : $*@callee_owned () -> @out Int
+// CHECK:      [[REABSTRACTOR:%.*]] = function_ref @_T0SiIxr_SiIxd_TR : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
+// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [[REABSTRACTOR]]([[VALUE]]) : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
+// CHECK:      [[SETTER_FN:%.*]] = function_ref @_T017materializeForSet4BaseC14staticFunctionSiycfsZ : $@convention(method) (@owned @callee_owned () -> Int, @thick Base.Type) -> ()
+// CHECK-NEXT: apply [[SETTER_FN]]([[NEWVALUE]], [[BASE_SELF]]) : $@convention(method) (@owned @callee_owned () -> Int, @thick Base.Type) -> ()
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]] : $()
 
 // CHECK-LABEL: sil hidden [transparent] [thunk] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14staticFunction6ResultQzycfmZTW
 // CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $@thick Derived.Type):
@@ -153,26 +167,13 @@
 // CHECK-NEXT: destroy_addr [[OUT]] : $*@callee_owned () -> Int
 // CHECK-NEXT: store [[NEWVALUE]] to [init] [[RESULT_ADDR]] : $*@callee_owned () -> @out Int
 // CHECK-NEXT: [[ADDR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_owned () -> @out Int to $Builtin.RawPointer
-// CHECK:      [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14staticFunction6ResultQzycfmZytfU_TW : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> ()
-// CHECK-NEXT: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]] : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> () to $Builtin.RawPointer
+// CHECK:      [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14staticFunction6ResultQzycfmZytfU_TW : $@convention(witness_method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> ()
+// CHECK-NEXT: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]] : $@convention(witness_method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> () to $Builtin.RawPointer
 // CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]] : $Builtin.RawPointer
 // CHECK-NEXT: [[RESULT:%.*]] = tuple ([[ADDR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
 // CHECK-NEXT: dealloc_stack [[OUT]] : $*@callee_owned () -> Int
 // CHECK-NEXT: return [[RESULT]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
 
-// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14staticFunction6ResultQzycfmZytfU_TW
-// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*@thick Derived.Type, %3 : $@thick Derived.Type.Type):
-// CHECK-NEXT: [[SELF:%.*]] = load_borrow %2 : $*@thick Derived.Type
-// CHECK-NEXT: [[BASE_SELF:%.*]] = upcast [[SELF]] : $@thick Derived.Type to $@thick Base.Type
-// CHECK-NEXT: [[BUFFER:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_owned () -> @out Int
-// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[BUFFER]] : $*@callee_owned () -> @out Int
-// CHECK:      [[REABSTRACTOR:%.*]] = function_ref @_T0SiIxr_SiIxd_TR : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
-// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [[REABSTRACTOR]]([[VALUE]]) : $@convention(thin) (@owned @callee_owned () -> @out Int) -> Int
-// CHECK:      [[SETTER_FN:%.*]] = function_ref @_T017materializeForSet4BaseC14staticFunctionSiycfsZ : $@convention(method) (@owned @callee_owned () -> Int, @thick Base.Type) -> ()
-// CHECK-NEXT: apply [[SETTER_FN]]([[NEWVALUE]], [[BASE_SELF]]) : $@convention(method) (@owned @callee_owned () -> Int, @thick Base.Type) -> ()
-// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
-// CHECK-NEXT: return [[RESULT]] : $()
-
 protocol ClassAbstractable : class {
   associatedtype Result
   var storedFunction: () -> Result { get set }
@@ -212,7 +213,7 @@
 // CHECK:   [[T1:%.*]] = apply [[T0]]([[SELF]])
 // CHECK:   store [[T1]] to [trivial] [[T2]] : $*Int
 // CHECK:   [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK:   [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet06HasDidC0C6storedSifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
+// CHECK:   [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet06HasDidC0C6storedSifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
 // CHECK:   [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
 // CHECK:   [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
 // CHECK:   [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
@@ -231,7 +232,7 @@
 // CHECK:   [[T1:%.*]] = apply [[T0]]([[SELF]])
 // CHECK:   store [[T1]] to [trivial] [[T2]] : $*Int
 // CHECK:   [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK:   [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet06HasDidC0C8computedSifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
+// CHECK:   [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet06HasDidC0C8computedSifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
 // CHECK:   [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
 // CHECK:   [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
 // CHECK:   [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
@@ -244,22 +245,7 @@
     didSet {}
   }
 
-// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet012HasStoredDidC0C6storedSifm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasStoredDidSet) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
-// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasStoredDidSet):
-// CHECK:   [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
-// CHECK:   [[T0:%.*]] = function_ref @_T017materializeForSet012HasStoredDidC0C6storedSifg
-// CHECK:   [[T1:%.*]] = apply [[T0]]([[SELF]])
-// CHECK:   store [[T1]] to [trivial] [[T2]] : $*Int
-// CHECK:   [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK:   [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet012HasStoredDidC0C6storedSifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> ()
-// CHECK:   [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
-// CHECK:   [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
-// CHECK:   [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
-// CHECK:   return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
-// CHECK: }
-}
-
-// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet012HasStoredDidC0C6storedSifmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> () {
+// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet012HasStoredDidC0C6storedSifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> () {
 // CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*HasStoredDidSet, [[METATYPE:%.*]] : $@thick HasStoredDidSet.Type):
 // CHECK:   [[SELF_VALUE:%.*]] = load_borrow [[SELF]] : $*HasStoredDidSet
 // CHECK:   [[BUFFER_ADDR:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
@@ -269,6 +255,21 @@
 // CHECK:   return
 // CHECK: }
 
+// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet012HasStoredDidC0C6storedSifm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasStoredDidSet) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasStoredDidSet):
+// CHECK:   [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK:   [[T0:%.*]] = function_ref @_T017materializeForSet012HasStoredDidC0C6storedSifg
+// CHECK:   [[T1:%.*]] = apply [[T0]]([[SELF]])
+// CHECK:   store [[T1]] to [trivial] [[T2]] : $*Int
+// CHECK:   [[BUFFER:%.*]] = address_to_pointer [[T2]]
+// CHECK:   [[CALLBACK_FN:%.*]] = function_ref @_T017materializeForSet012HasStoredDidC0C6storedSifmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> ()
+// CHECK:   [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
+// CHECK:   [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
+// CHECK:   [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK:   return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+}
+
 class HasWeak {
   weak var weakvar: HasWeak?
 }
@@ -279,7 +280,7 @@
 // CHECK:   [[T1:%.*]] = load_weak [[T0]] : $*@sil_weak Optional<HasWeak>
 // CHECK:   store [[T1]] to [init] [[T2]] : $*Optional<HasWeak>
 // CHECK:   [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK:   [[T0:%.*]] = function_ref @_T017materializeForSet7HasWeakC7weakvarACSgXwfmytfU_ : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasWeak, @thick HasWeak.Type) -> () 
+// CHECK:   [[T0:%.*]] = function_ref @_T017materializeForSet7HasWeakC7weakvarACSgXwfmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasWeak, @thick HasWeak.Type) -> () 
 // CHECK:   [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, {{.*}} : $Optional<Builtin.RawPointer>)
 // CHECK:   return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
 // CHECK: }
@@ -336,10 +337,13 @@
 // CHECK: }
 
 // CHECK-LABEL:  sil hidden [transparent] [thunk] @_T017materializeForSet4BillVAA8TotalledAaaDP5totalSifmTW : $@convention(witness_method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Bill) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
-// CHECK:  bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Bill):
-// CHECK:    [[T0:%.*]] = function_ref @_T017materializeForSet4BillV5totalSifm
-// CHECK:    [[T1:%.*]] = apply [[T0]]([[BUFFER]], [[STORAGE]], [[SELF]])
-// CHECK:    return [[T1]] :
+// CHECK:        bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Bill):
+// CHECK:          [[T0:%.*]] = function_ref @_T017materializeForSet4BillV5totalSifm
+// CHECK-NEXT:     [[T1:%.*]] = apply [[T0]]([[BUFFER]], [[STORAGE]], [[SELF]])
+// CHECK-NEXT:     [[LEFT:%.*]] = tuple_extract [[T1]]
+// CHECK-NEXT:     [[RIGHT:%.*]] = tuple_extract [[T1]]
+// CHECK-NEXT:     [[T1:%.*]] = tuple ([[LEFT]] : $Builtin.RawPointer, [[RIGHT]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT:     return [[T1]] :
 
 protocol AddressOnlySubscript {
   associatedtype Index
@@ -355,6 +359,47 @@
 
 func increment(_ x: inout Int) { x += 1 }
 
+// Generic subscripts.
+
+protocol GenericSubscriptProtocol {
+  subscript<T>(_: T) -> T { get set }
+}
+
+struct GenericSubscriptWitness : GenericSubscriptProtocol {
+  subscript<T>(_: T) -> T { get { } set { } }
+}
+
+// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet23GenericSubscriptWitnessV9subscriptxxclufmytfU_ : $@convention(method) <T> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericSubscriptWitness, @thick GenericSubscriptWitness.Type) -> () {
+// CHECK:       bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*GenericSubscriptWitness, %3 : $@thick GenericSubscriptWitness.Type):
+// CHECK:         [[BUFFER:%.*]] = project_value_buffer $T in %1 : $*Builtin.UnsafeValueBuffer
+// CHECK-NEXT:    [[INDICES:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*T
+// CHECK:         [[SETTER:%.*]] = function_ref @_T017materializeForSet23GenericSubscriptWitnessV9subscriptxxclufs : $@convention(method) <τ_0_0> (@in τ_0_0, @in τ_0_0, @inout GenericSubscriptWitness) -> ()
+// CHECK-NEXT:    apply [[SETTER]]<T>([[INDICES]], [[BUFFER]], %2) : $@convention(method) <τ_0_0> (@in τ_0_0, @in τ_0_0, @inout GenericSubscriptWitness) -> ()
+// CHECK-NEXT:    dealloc_value_buffer $*T in %1 : $*Builtin.UnsafeValueBuffer
+// CHECK-NEXT:    [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT:    return [[RESULT]] : $()
+
+// CHECK-LABEL sil hidden [transparent] [thunk] @_T017materializeForSet23GenericSubscriptWitnessVAA0dE8ProtocolAaaDP9subscriptqd__qd__clufmTW : $@convention(witness_method) <τ_0_0> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in τ_0_0, @inout GenericSubscriptWitness) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK:      bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*T, %3 : $*GenericSubscriptWitness):
+// CHECK-NEXT:   [[BUFFER:%.*]] = alloc_value_buffer $T in %1 : $*Builtin.UnsafeValueBuffer
+// CHECK-NEXT:   copy_addr %2 to [initialization] [[BUFFER]] : $*T
+// CHECK-NEXT:   [[VALUE:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*T
+// CHECK-NEXT:   [[SELF:%.*]] = load [trivial] %3 : $*GenericSubscriptWitness
+// CHECK:        [[GETTER:%.*]] = function_ref @_T017materializeForSet23GenericSubscriptWitnessV9subscriptxxclufg : $@convention(method) <τ_0_0> (@in τ_0_0, GenericSubscriptWitness) -> @out τ_0_0
+// CHECK-NEXT:   apply [[GETTER]]<T>([[VALUE]], %2, [[SELF]]) : $@convention(method) <τ_0_0> (@in τ_0_0, GenericSubscriptWitness) -> @out τ_0_0
+// CHECK-NEXT:   [[VALUE_PTR:%.*]] = address_to_pointer [[VALUE]] : $*T to $Builtin.RawPointer
+// CHECK:        [[CALLBACK:%.*]] = function_ref @_T017materializeForSet23GenericSubscriptWitnessV9subscriptxxclufmytfU_
+// CHECK-NEXT:   [[CALLBACK_PTR:%.*]] = thin_function_to_pointer [[CALLBACK]] : $@convention(method) <τ_0_0> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericSubscriptWitness, @thick GenericSubscriptWitness.Type) -> () to $Builtin.RawPointer
+// CHECK-NEXT:   [[CALLBACK_OPTIONAL:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_PTR]] : $Builtin.RawPointer
+// CHECK-NEXT:   [[RESULT:%.*]] = tuple ([[VALUE_PTR]] : $Builtin.RawPointer, [[CALLBACK_OPTIONAL]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT:   return [[RESULT]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+
+extension GenericSubscriptProtocol {
+  subscript<T>(t: T) -> T { get { } set { } }
+}
+
+struct GenericSubscriptDefaultWitness : GenericSubscriptProtocol { }
+
 // Test for materializeForSet vs static properties of structs.
 
 protocol Beverage {
@@ -435,6 +480,18 @@
 
 struct TuxedoPanda : Panda { }
 
+// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet11TuxedoPandaVAA0E0AaaDP1xxxcfmytfU_TW : $@convention(witness_method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout TuxedoPanda, @thick TuxedoPanda.Type) -> ()
+
+  // FIXME: Useless re-abstractions
+
+  // CHECK: function_ref @_T017materializeForSet11TuxedoPandaVACIxir_AcCIxyd_TR : $@convention(thin) (TuxedoPanda, @owned @callee_owned (@in TuxedoPanda) -> @out TuxedoPanda) -> TuxedoPanda
+
+  // CHECK: function_ref @_T017materializeForSet5PandaPAAE1xxxcfs : $@convention(method) <τ_0_0 where τ_0_0 : Panda> (@owned @callee_owned (@in τ_0_0) -> @out τ_0_0, @inout τ_0_0) -> ()
+
+  // CHECK: function_ref @_T017materializeForSet11TuxedoPandaVACIxyd_AcCIxir_TR : $@convention(thin) (@in TuxedoPanda, @owned @callee_owned (TuxedoPanda) -> TuxedoPanda) -> @out TuxedoPanda
+
+// CHECK: }
+
 // CHECK-LABEL: sil hidden [transparent] [thunk] @_T017materializeForSet11TuxedoPandaVAA0E0AaaDP1xxxcfmTW
 
 // Call the getter:
@@ -454,19 +511,7 @@
 
 // The callback:
 
-  // CHECK: function_ref @_T017materializeForSet11TuxedoPandaVAA0E0AaaDP1xxxcfmytfU_TW : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout TuxedoPanda, @thick TuxedoPanda.Type) -> ()
-
-// CHECK: }
-
-// CHECK-LABEL: sil hidden [transparent] @_T017materializeForSet11TuxedoPandaVAA0E0AaaDP1xxxcfmytfU_TW : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout TuxedoPanda, @thick TuxedoPanda.Type) -> ()
-
-  // FIXME: Useless re-abstractions
-
-  // CHECK: function_ref @_T017materializeForSet11TuxedoPandaVACIxir_AcCIxyd_TR : $@convention(thin) (TuxedoPanda, @owned @callee_owned (@in TuxedoPanda) -> @out TuxedoPanda) -> TuxedoPanda
-
-  // CHECK: function_ref @_T017materializeForSet5PandaPAAE1xxxcfs : $@convention(method) <τ_0_0 where τ_0_0 : Panda> (@owned @callee_owned (@in τ_0_0) -> @out τ_0_0, @inout τ_0_0) -> ()
-
-  // CHECK: function_ref @_T017materializeForSet11TuxedoPandaVACIxyd_AcCIxir_TR : $@convention(thin) (@in TuxedoPanda, @owned @callee_owned (TuxedoPanda) -> TuxedoPanda) -> @out TuxedoPanda
+  // CHECK: function_ref @_T017materializeForSet11TuxedoPandaVAA0E0AaaDP1xxxcfmytfU_TW : $@convention(witness_method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout TuxedoPanda, @thick TuxedoPanda.Type) -> ()
 
 // CHECK: }
 
diff --git a/test/SILGen/opaque_values_silgen.swift b/test/SILGen/opaque_values_silgen.swift
index a6e20bb..e8387d6 100644
--- a/test/SILGen/opaque_values_silgen.swift
+++ b/test/SILGen/opaque_values_silgen.swift
@@ -290,3 +290,93 @@
 func s190___return_foo_var() -> Foo {
   return foo_var
 }
+
+// Tests deinit of opaque existentials
+// ---
+// CHECK-LABEL: sil hidden @_T020opaque_values_silgen21s200______use_foo_varyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK:   [[GLOBAL:%.*]] = global_addr {{.*}} : $*Foo
+// CHECK:   [[LOAD_GLOBAL:%.*]] = load [copy] [[GLOBAL]] : $*Foo
+// CHECK:   [[OPEN_VAR:%.*]] = open_existential_opaque [[LOAD_GLOBAL]] : $Foo
+// CHECK:   [[WITNESS:%.*]] = witness_method $@opened
+// CHECK:   apply [[WITNESS]]
+// CHECK:   destroy_value [[OPEN_VAR]]
+// CHECK:   deinit_existential_opaque [[LOAD_GLOBAL]] : $Foo
+// CHECK:   return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '_T020opaque_values_silgen21s200______use_foo_varyyF'
+func s200______use_foo_var() {
+  foo_var.foo()
+}
+
+// Tests composition erasure of opaque existentials + copy into of opaques
+// ---
+// CHECK-LABEL: sil hidden @_T020opaque_values_silgen21s210______compErasures5Error_psAC_AA3FoopF : $@convention(thin) (@in Error & Foo) -> @owned Error {
+// CHECK: bb0([[ARG:%.*]] : $Error & Foo):
+// CHECK:   [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+// CHECK:   [[OPAQUE_ARG:%.*]] = open_existential_opaque [[BORROWED_ARG]] : $Error & Foo to $@opened({{.*}}) Error & Foo
+// CHECK:   [[EXIST_BOX:%.*]] = alloc_existential_box $Error, $@opened({{.*}}) Error & Foo
+// CHECK:   [[PROJ_BOX:%.*]] = project_existential_box $@opened({{.*}}) Error & Foo in [[EXIST_BOX]]
+// CHECK:   [[COPY_OPAQUE:%.*]] = copy_value [[OPAQUE_ARG]] : $@opened({{.*}}) Error & Foo
+// CHECK:   store [[COPY_OPAQUE]] to [init] [[PROJ_BOX]] : $*@opened({{.*}}) Error & Foo
+// CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
+// CHECK:   destroy_value [[ARG]] : $Error & Foo
+// CHECK:   return [[EXIST_BOX]] : $Error
+// CHECK-LABEL: } // end sil function '_T020opaque_values_silgen21s210______compErasures5Error_psAC_AA3FoopF'
+func s210______compErasure(_ x: Foo & Error) -> Error {
+  return x
+}
+
+// Tests that existential boxes can contain opaque types
+// ---
+// CHECK-LABEL: sil hidden @_T020opaque_values_silgen21s220_____openExistBoxSSs5Error_pF : $@convention(thin) (@owned Error) -> @owned String {
+// CHECK: bb0([[ARG:%.*]] : $Error):
+// CHECK:   [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+// CHECK:   [[OPAQUE_ARG:%.*]] = open_existential_box [[BORROWED_ARG]] : $Error to $@opened({{.*}}) Error
+// CHECK:   [[RET_STRING:%.*]] = apply{{.*}}<@opened({{.*}}) Error>([[OPAQUE_ARG]]) : $@convention(witness_method) <τ_0_0 where τ_0_0 : Error> (@in_guaranteed τ_0_0) -> @owned String
+// CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
+// CHECK:   destroy_value [[ARG]] : $Error
+// CHECK:   return [[RET_STRING]] : $String
+// CHECK-LABEL: } // end sil function '_T020opaque_values_silgen21s220_____openExistBoxSSs5Error_pF'
+func s220_____openExistBox(_ x: Error) -> String {
+  return x._domain
+}
+
+// Tests LogicalPathComponent's writeback for opaque value types
+// ---
+// CHECK-LABEL: sil @_T0s10DictionaryV20opaque_values_silgenE22inoutAccessOfSubscriptyq_3key_tF : $@convention(method) <Key, Value where Key : Hashable> (@in Value, @inout Dictionary<Key, Value>) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Value, [[ARG1:%.*]] : $*Dictionary<Key, Value>):
+// CHECK:   [[OPTIONAL_ALLOC:%.*]] = alloc_stack $Optional<Value>
+// CHECK:   switch_enum_addr [[OPTIONAL_ALLOC]] : $*Optional<Value>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb2:
+// CHECK:   [[OPTIONAL_LOAD:%.*]] = load [take] [[OPTIONAL_ALLOC]] : $*Optional<Value>
+// CHECK:   apply {{.*}}<Key, Value>([[OPTIONAL_LOAD]], {{.*}}, [[ARG1]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@in Optional<τ_0_1>, @in τ_0_1, @inout Dictionary<τ_0_0, τ_0_1>) -> ()
+// CHECK:   return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '_T0s10DictionaryV20opaque_values_silgenE22inoutAccessOfSubscriptyq_3key_tF'
+
+// Tests materializeForSet's createSetterCallback for opaque values
+// ---
+// CHECK-LABEL: sil [transparent] [fragile] @_T0s10DictionaryV20opaque_values_silgenE9subscriptq_Sgq_cfmytfU_ : $@convention(method) <Key, Value where Key : Hashable> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Key, Value>, @thick Dictionary<Key, Value>.Type) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Builtin.RawPointer, [[ARG1:%.*]] : $*Builtin.UnsafeValueBuffer, [[ARG2:%.*]] : $*Dictionary<Key, Value>, [[ARG3:%.*]] : $@thick Dictionary<Key, Value>.Type):
+// CHECK:   [[PROJ_VAL1:%.*]] = project_value_buffer $Value in [[ARG1]] : $*Builtin.UnsafeValueBuffer
+// CHECK:   [[LOAD_VAL1:%.*]] = load [take] [[PROJ_VAL1]] : $*Value
+// CHECK:   [[ADDR_VAL0:%.*]] = pointer_to_address [[ARG0]] : $Builtin.RawPointer to [strict] $*Optional<Value>
+// CHECK:   [[LOAD_VAL0:%.*]] = load [take] [[ADDR_VAL0]] : $*Optional<Value>
+// CHECK:   apply {{.*}}<Key, Value>([[LOAD_VAL0]], [[LOAD_VAL1]], [[ARG2]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@in Optional<τ_0_1>, @in τ_0_1, @inout Dictionary<τ_0_0, τ_0_1>) -> ()
+// CHECK:   return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '_T0s10DictionaryV20opaque_values_silgenE9subscriptq_Sgq_cfmytfU_'
+extension Dictionary {
+  public subscript(key: Value) -> Value? {
+    @inline(__always)
+    get {
+      return key
+    }
+    set(newValue) {
+    }
+  }
+  
+  public mutating func inoutAccessOfSubscript(key: Value) {
+    func increment(x: inout Value) { }
+
+    increment(x: &self[key]!)
+  }
+}
diff --git a/test/SILGen/optional-cast.swift b/test/SILGen/optional-cast.swift
index 1ca7fa4..e2ed3eb 100644
--- a/test/SILGen/optional-cast.swift
+++ b/test/SILGen/optional-cast.swift
@@ -30,8 +30,8 @@
 // CHECK-NEXT: br [[CONT:bb[0-9]+]]
 //
 //   If not, destroy_value the A and inject nothing into x.
-// CHECK:    [[NOT_B]]:
-// CHECK-NEXT: destroy_value [[VAL]]
+// CHECK:    [[NOT_B]]([[ORIGINAL_VALUE:%.*]] : $A):
+// CHECK-NEXT: destroy_value [[ORIGINAL_VALUE]]
 // CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<B>, #Optional.none
 // CHECK-NEXT: br [[CONT]]
 //
@@ -111,8 +111,8 @@
 // CHECK-NEXT: br [[SWITCH_OB2:bb[0-9]+]](
 //
 //   If not, inject nothing into an optional.
-// CHECK:    [[NOT_B]]:
-// CHECK-NEXT: destroy_value [[VAL]]
+// CHECK:    [[NOT_B]]([[ORIGINAL_VALUE:%.*]] : $A):
+// CHECK-NEXT: destroy_value [[ORIGINAL_VALUE]]
 // CHECK-NEXT: enum $Optional<B>, #Optional.none!enumelt
 // CHECK-NEXT: br [[SWITCH_OB2]](
 //
@@ -174,9 +174,10 @@
 // CHECK:         [[VAL:%.*]] = unchecked_enum_data [[ARG_COPY]]
 // CHECK-NEXT:    [[X_VALUE:%.*]] = init_enum_data_addr [[PB]] : $*Optional<B>, #Optional.some
 // CHECK-NEXT:    checked_cast_br [[VAL]] : $AnyObject to $B, [[IS_B:bb.*]], [[NOT_B:bb[0-9]+]]
-// CHECK:       [[IS_B]](
-// CHECK:       [[NOT_B]]:
-// CHECK:         destroy_value [[VAL]]
+// CHECK:       [[IS_B]]([[CASTED_VALUE:%.*]] : $B):
+// CHECK:         store [[CASTED_VALUE]] to [init] [[X_VALUE]]
+// CHECK:       [[NOT_B]]([[ORIGINAL_VALUE:%.*]] : $AnyObject):
+// CHECK:         destroy_value [[ORIGINAL_VALUE]]
 // CHECK: } // end sil function '_T04main3bazys9AnyObject_pSgF'
 func baz(_ y : AnyObject?) {
   var x = (y as? B)
diff --git a/test/SILGen/properties.swift b/test/SILGen/properties.swift
index e54101b..3e66fde 100644
--- a/test/SILGen/properties.swift
+++ b/test/SILGen/properties.swift
@@ -227,7 +227,7 @@
   // -- writeback to val.ref.val_prop
   // CHECK: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
   // CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : $Builtin.RawPointer):
-  // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Ref, @thick Ref.Type) -> ()
+  // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Ref, @thick Ref.Type) -> ()
   // CHECK: [[REF_MAT:%.*]] = alloc_stack $Ref
   // CHECK: store [[VAL_REF]] to [init] [[REF_MAT]]
   // CHECK: [[T0:%.*]] = metatype $@thick Ref.Type
diff --git a/test/SILGen/protocol_resilience.swift b/test/SILGen/protocol_resilience.swift
index 8b7b32c..35e64a5 100644
--- a/test/SILGen/protocol_resilience.swift
+++ b/test/SILGen/protocol_resilience.swift
@@ -120,8 +120,8 @@
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE26mutablePropertyWithDefaultSifg
 // CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSifs
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE26mutablePropertyWithDefaultSifs
-// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSifm
 // CHECK-LABEL: sil [transparent] @_T019protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSifmytfU_
+// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSifm
   public var mutablePropertyWithDefault: Int {
     get { return 0 }
     set { }
@@ -136,8 +136,8 @@
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE33mutableGenericPropertyWithDefault1TQzfg
 // CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzfs
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE33mutableGenericPropertyWithDefault1TQzfs
-// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzfm
 // CHECK-LABEL: sil [transparent] @_T019protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzfmytfU_
+// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzfm
   public var mutableGenericPropertyWithDefault: T {
     get {
       return T(default: ())
@@ -149,8 +149,8 @@
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE9subscript1TQzAFcfg
 // CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP9subscript1TQzAFcfs
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE9subscript1TQzAFcfs
-// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP9subscript1TQzAFcfm
 // CHECK-LABEL: sil [transparent] @_T019protocol_resilience16ResilientStorageP9subscript1TQzAFcfmytfU_
+// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP9subscript1TQzAFcfm
   public subscript(x: T) -> T {
     get {
       return x
@@ -162,8 +162,8 @@
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE36mutatingGetterWithNonMutatingDefaultSifg
 // CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSifs
 // CHECK-LABEL: sil @_T019protocol_resilience16ResilientStoragePAAE36mutatingGetterWithNonMutatingDefaultSifs
-// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSifm
 // CHECK-LABEL: sil [transparent] @_T019protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSifmytfU_
+// CHECK-LABEL: sil [transparent] [thunk] @_T019protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSifm
   public var mutatingGetterWithNonMutatingDefault: Int {
     get {
       return 0
diff --git a/test/SILOptimizer/address_lowering.sil b/test/SILOptimizer/address_lowering.sil
index 1e937e8..db8221f 100644
--- a/test/SILOptimizer/address_lowering.sil
+++ b/test/SILOptimizer/address_lowering.sil
@@ -5,12 +5,12 @@
 sil_stage canonical
 // CHECK: sil_stage lowered
 
-// CHECK-LABEL: sil hidden @addrlower_identity : $@convention(thin) <T> (@in T) -> @out T {
+// CHECK-LABEL: sil hidden @f010_addrlower_identity : $@convention(thin) <T> (@in T) -> @out T {
 // CHECK: bb0(%0 : $*T, %1 : $*T):
 // CHECK: copy_addr [take] %1 to [initialization] %0 : $*T
 // CHECK: return %{{.*}} : $()
-// CHECK-LABEL: } // end sil function 'addrlower_identity'
-sil hidden @addrlower_identity : $@convention(thin) <T> (@in T) -> @out T {
+// CHECK-LABEL: } // end sil function 'f010_addrlower_identity'
+sil hidden @f010_addrlower_identity : $@convention(thin) <T> (@in T) -> @out T {
 bb0(%0 : $T):
   return %0 : $T
 }
@@ -29,7 +29,7 @@
 // Test returning an opaque tuple of tuples as a concrete tuple.
 // The multiResult call is specialized, but the SIL result convention does not change.
 // ---
-// CHECK-LABEL: sil @f030_callMultiResult : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64, Builtin.Int64, Builtin.Int64) {
+// CHECK-LABEL: sil @f021_callMultiResult : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64, Builtin.Int64, Builtin.Int64) {
 // CHECK: bb0(%0 : $Builtin.Int64):
 // CHECK:  %[[FN:.*]] = function_ref @f020_multiResult : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0, @out τ_0_0)
 // CHECK:  %[[IN:.*]] = alloc_stack $Builtin.Int64
@@ -39,16 +39,16 @@
 // CHECK:  %[[OUT3:.*]] = alloc_stack $Builtin.Int64
 // CHECK:  %{{.*}} = apply %[[FN]]<Builtin.Int64>(%[[OUT1]], %[[OUT2]], %[[OUT3]], %[[IN]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0, @out τ_0_0)
 // CHECK:  %[[R3:.*]] = load %[[OUT3]] : $*Builtin.Int64
-// CHECK:  %[[R2:.*]] = load %[[OUT2]] : $*Builtin.Int64
-// CHECK:  %[[R1:.*]] = load %[[OUT1]] : $*Builtin.Int64
 // CHECK:  dealloc_stack %[[OUT3]] : $*Builtin.Int64
+// CHECK:  %[[R2:.*]] = load %[[OUT2]] : $*Builtin.Int64
 // CHECK:  dealloc_stack %[[OUT2]] : $*Builtin.Int64
+// CHECK:  %[[R1:.*]] = load %[[OUT1]] : $*Builtin.Int64
 // CHECK:  dealloc_stack %[[OUT1]] : $*Builtin.Int64
 // CHECK:  dealloc_stack %[[IN]] : $*Builtin.Int64
 // CHECK:  %[[R:.*]] = tuple (%[[R1]] : $Builtin.Int64, %[[R2]] : $Builtin.Int64, %[[R3]] : $Builtin.Int64)
 // CHECK:  return %[[R]] : $(Builtin.Int64, Builtin.Int64, Builtin.Int64)
-// CHECK-LABEL: } // end sil function 'f030_callMultiResult'
-sil @f030_callMultiResult : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64, Builtin.Int64, Builtin.Int64) {
+// CHECK-LABEL: } // end sil function 'f021_callMultiResult'
+sil @f021_callMultiResult : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64, Builtin.Int64, Builtin.Int64) {
 bb0(%0 : $Builtin.Int64):
   %1 = function_ref @f020_multiResult : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0, @out τ_0_0)
   %2 = apply %1<Builtin.Int64>(%0) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0, @out τ_0_0)
@@ -58,3 +58,318 @@
   %6 = tuple (%3 : $Builtin.Int64, %4 : $Builtin.Int64, %5 : $Builtin.Int64)
   return %6 : $(Builtin.Int64, Builtin.Int64, Builtin.Int64)
 }
+
+// CHECK-LABEL: sil @f030_returnPair : $@convention(thin) <T> (@in T) -> (@out T, @out T) {
+// CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T):
+// CHECK:   %[[LOCAL:.*]] = alloc_stack $T
+// CHECK:   copy_addr %2 to [initialization] %[[LOCAL]] : $*T
+// CHECK:   copy_addr [take] %[[LOCAL]] to [initialization] %0 : $*T
+// CHECK:   copy_addr [take] %2 to [initialization] %1 : $*T
+// CHECK:   %[[R:.*]] = tuple ()
+// CHECK:   dealloc_stack %[[LOCAL]] : $*T
+// CHECK:   return %[[R]] : $()
+// CHECK-LABEL: } // end sil function 'f030_returnPair'
+sil @f030_returnPair : $@convention(thin) <T> (@in T) -> (@out T, @out T) {
+bb0(%0 : $T):
+  %2 = copy_value %0 : $T
+  %3 = tuple (%2 : $T, %0 : $T)
+  return %3 : $(T, T)
+}
+
+// CHECK-LABEL: sil @f031_unusedIndirect : $@convention(thin) <T> (@in T) -> @out T {
+// CHECK: bb0(%0 : $*T, %1 : $*T):
+// CHECK:   %[[LOC2:.*]] = alloc_stack $T
+// CHECK:   %[[OUT2:.*]] = alloc_stack $T
+// CHECK:   %[[LOC1:.*]] = alloc_stack $T
+// CHECK:   %[[OUT1:.*]] = alloc_stack $T
+// CHECK:   %[[LOC0:.*]] = alloc_stack $T
+// CHECK:   // function_ref f030_returnPair
+// CHECK:   %7 = function_ref @f030_returnPair : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0)
+// CHECK:   copy_addr %1 to [initialization] %[[LOC0]] : $*T
+// CHECK:   %[[IN:.*]] = alloc_stack $T
+// CHECK:   copy_addr [take] %[[LOC0]] to [initialization] %[[IN]] : $*T
+// CHECK:   %11 = apply %7<T>(%[[OUT1]], %[[OUT2]], %[[IN]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0)
+// CHECK:   dealloc_stack %[[IN]] : $*T
+// CHECK:   copy_addr %[[OUT1]] to [initialization] %[[LOC1]] : $*T
+// CHECK:   copy_addr %[[OUT2]] to [initialization] %[[LOC2]] : $*T
+// CHECK:   destroy_addr %[[OUT1]] : $*T
+// CHECK:   destroy_addr %[[OUT2]] : $*T
+// CHECK:   destroy_addr %[[LOC1]] : $*T
+// CHECK:   destroy_addr %1 : $*T
+// CHECK:   copy_addr [take] %[[LOC2]] to [initialization] %0 : $*T
+// CHECK:   %[[R:.*]] = tuple ()
+// CHECK:   dealloc_stack %[[LOC0]] : $*T
+// CHECK:   dealloc_stack %[[OUT1]] : $*T
+// CHECK:   dealloc_stack %[[LOC1]] : $*T
+// CHECK:   dealloc_stack %[[OUT2]] : $*T
+// CHECK:   dealloc_stack %[[LOC2]] : $*T
+// CHECK:   return %[[R]] : $()
+// CHECK-LABEL: } // end sil function 'f031_unusedIndirect'
+sil @f031_unusedIndirect : $@convention(thin) <T> (@in T) -> @out T {
+bb0(%0 : $T):
+  %2 = function_ref @f030_returnPair : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0)
+  %3 = copy_value %0 : $T
+  %4 = apply %2<T>(%3) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @out τ_0_0)
+  %5 = tuple_extract %4 : $(T, T), 0
+  %6 = copy_value %5 : $T
+  %7 = tuple_extract %4 : $(T, T), 1
+  %8 = copy_value %7 : $T
+  destroy_value %4 : $(T, T)
+  destroy_value %6 : $T
+  destroy_value %0 : $T
+  return %8 : $T
+}
+
+sil hidden @f040_consumeArg : $@convention(thin) <T> (@in T) -> () {
+bb0(%0 : $T):
+  destroy_value %0 : $T
+  %3 = tuple ()
+  return %3 : $()
+}
+
+// CHECK-LABEL: sil @f041_opaqueArg : $@convention(thin) <T> (@in T) -> () {
+// CHECK: bb0(%0 : $*T):
+// CHECK:  %[[LOC:.*]] = alloc_stack $T
+// CHECK:  %[[FN:.*]] = function_ref @f040_consumeArg : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
+// CHECK:  copy_addr %0 to [initialization] %[[LOC]] : $*T
+// CHECK:  %[[ARG:.*]] = alloc_stack $T
+// CHECK:  copy_addr [take] %[[LOC]] to [initialization] %[[ARG]] : $*T
+// CHECK:  %{{.*}} = apply %[[FN]]<T>(%[[ARG]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
+// CHECK:  dealloc_stack %[[ARG]] : $*T
+// CHECK:  destroy_addr %0 : $*T
+// CHECK:  %[[R:.*]] = tuple ()
+// CHECK:  dealloc_stack %[[LOC]] : $*T
+// CHECK:  return %[[R]] : $()
+// CHECK-LABEL: } // end sil function 'f041_opaqueArg'
+sil @f041_opaqueArg : $@convention(thin) <T> (@in T) -> () {
+bb0(%0 : $T):
+  %2 = function_ref @f040_consumeArg : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
+  %3 = copy_value %0 : $T
+  %4 = apply %2<T>(%3) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
+  destroy_value %0 : $T
+  %6 = tuple ()
+  return %6 : $()
+}
+
+// CHECK-LABEL: sil @f050_storeinout : $@convention(thin) <T> (@inout T, @inout T, @in T) -> () {
+// CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T):
+// CHECK:   %[[PREV2:.*]] = alloc_stack $T
+// CHECK:   %[[ARG2:.*]] = alloc_stack $T
+// CHECK:   %[[PREV1:.*]] = alloc_stack $T
+// CHECK:   %[[ARG1:.*]] = alloc_stack $T
+// CHECK:   debug_value_addr %0 : $*T, var, name "t", argno 1
+// CHECK:   debug_value_addr %1 : $*T, var, name "u", argno 2
+// CHECK:   debug_value_addr %2 : $*T
+// CHECK:   copy_addr %2 to [initialization] %[[ARG1]] : $*T
+// CHECK:   copy_addr [take] %0 to [initialization] %[[PREV1]] : $*T
+// CHECK:   copy_addr [take] %[[ARG1]] to [initialization] %0 : $*T
+// CHECK:   destroy_addr %[[PREV1]] : $*T
+// CHECK:   copy_addr %2 to [initialization] %[[ARG2]] : $*T
+// CHECK:   copy_addr [take] %1 to [initialization] %[[PREV2]] : $*T
+// CHECK:   copy_addr [take] %[[ARG2]] to [initialization] %1 : $*T
+// CHECK:   destroy_addr %[[PREV2]] : $*T
+// CHECK:   destroy_addr %2 : $*T
+// CHECK:   %19 = tuple ()
+// CHECK:   dealloc_stack %[[ARG1]] : $*T
+// CHECK:   dealloc_stack %[[PREV1]] : $*T
+// CHECK:   dealloc_stack %[[ARG2]] : $*T
+// CHECK:   dealloc_stack %[[PREV2]] : $*T
+// CHECK:   return %19 : $()
+// CHECK-LABEL: } // end sil function 'f050_storeinout'
+sil @f050_storeinout : $@convention(thin) <T> (@inout T, @inout T, @in T) -> () {
+bb0(%0 : $*T, %1 : $*T, %2 : $T):
+  debug_value_addr %0 : $*T, var, name "t", argno 1
+  debug_value_addr %1 : $*T, var, name "u", argno 2
+  debug_value %2 : $T, let, name "x", argno 3
+  %6 = copy_value %2 : $T
+  %7 = load %0 : $*T
+  store %6 to %0 : $*T
+  destroy_value %7 : $T
+  %10 = copy_value %2 : $T
+  %11 = load %1 : $*T
+  store %10 to %1 : $*T
+  destroy_value %11 : $T
+  destroy_value %2 : $T
+  %15 = tuple ()
+  return %15 : $()
+}
+
+sil hidden @f060_mutate : $@convention(thin) <T> (@inout T, @in T) -> () {
+bb0(%0 : $*T, %1 : $T):
+  %4 = copy_value %1 : $T
+  %5 = load %0 : $*T
+  store %4 to %0 : $*T
+  destroy_value %5 : $T
+  destroy_value %1 : $T
+  %9 = tuple ()
+  return %9 : $()
+}
+
+// CHECK-LABEL: sil @f061_callinout : $@convention(thin) <T> (@in T) -> () {
+// CHECK: bb0(%0 : $*T):
+// CHECK:   %[[LOC2:.*]] = alloc_stack $T
+// CHECK:   %[[LOC1:.*]] = alloc_stack $T
+// CHECK:   %[[INOUT:.*]] = alloc_stack $T, var, name "u"
+// CHECK:   copy_addr %0 to [initialization] %[[LOC1]] : $*T
+// CHECK:   copy_addr [take] %[[LOC1]] to [initialization] %[[INOUT]] : $*T
+// CHECK:   %[[FN:.*]] = function_ref @f060_mutate : $@convention(thin) <τ_0_0> (@inout τ_0_0, @in τ_0_0) -> ()
+// CHECK:   copy_addr %0 to [initialization] %[[LOC2]] : $*T
+// CHECK:   %[[IN:.*]] = alloc_stack $T
+// CHECK:   copy_addr [take] %[[LOC2]] to [initialization] %[[IN]] : $*T
+// CHECK:   %{{.*}} = apply %[[FN]]<T>(%[[INOUT]], %[[IN]]) : $@convention(thin) <τ_0_0> (@inout τ_0_0, @in τ_0_0) -> ()
+// CHECK:   dealloc_stack %[[IN]] : $*T
+// CHECK:   destroy_addr %[[INOUT]] : $*T
+// CHECK:   destroy_addr %0 : $*T
+// CHECK:   %[[R:.*]] = tuple ()
+// CHECK:   dealloc_stack %[[INOUT]] : $*T
+// CHECK:   dealloc_stack %[[LOC1]] : $*T
+// CHECK:   dealloc_stack %[[LOC2]] : $*T
+// CHECK:   return %[[R]] : $()
+// CHECK-LABEL: } // end sil function 'f061_callinout'
+sil @f061_callinout : $@convention(thin) <T> (@in T) -> () {
+bb0(%0 : $T):
+  %1 = alloc_stack $T, var, name "u"
+  %3 = copy_value %0 : $T
+  store %3 to %1 : $*T
+  %5 = function_ref @f060_mutate : $@convention(thin) <τ_0_0> (@inout τ_0_0, @in τ_0_0) -> ()
+  %6 = copy_value %0 : $T
+  %7 = apply %5<T>(%1, %6) : $@convention(thin) <τ_0_0> (@inout τ_0_0, @in τ_0_0) -> ()
+  destroy_addr %1 : $*T
+  destroy_value %0 : $T
+  %10 = tuple ()
+  dealloc_stack %1 : $*T
+  return %10 : $()
+}
+
+public protocol C : class {}
+
+// CHECK-LABEL: sil @f070_mixedResult1 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @owned C) {
+// CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $C):
+// CHECK:   copy_addr [take] %1 to [initialization] %0 : $*T
+// CHECK:   return %2 : $C
+// CHECK-LABEL: } // end sil function 'f070_mixedResult1'
+sil @f070_mixedResult1 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @owned C) {
+bb0(%0 : $T, %1 : $C):
+  %4 = tuple (%0 : $T, %1 : $C)
+  return %4 : $(T, C)
+}
+
+// CHECK-LABEL: sil @f071_mixedResult2 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @out T, @owned C, @owned C) {
+// CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T, %3 : $C):
+// CHECK:   %[[L:.*]] = alloc_stack $T
+// CHECK:   copy_addr %2 to [initialization] %[[L]] : $*T
+// CHECK:   strong_retain %3 : $C
+// CHECK:   copy_addr [take] %[[L]] to [initialization] %0 : $*T
+// CHECK:   copy_addr [take] %2 to [initialization] %1 : $*T
+// CHECK:   %[[T:.*]] = tuple (%3 : $C, %3 : $C)
+// CHECK:   dealloc_stack %[[L]] : $*T
+// CHECK:   return %[[T]] : $(C, C)
+// CHECK-LABEL: } // end sil function 'f071_mixedResult2'
+sil @f071_mixedResult2 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @out T, @owned C, @owned C) {
+bb0(%0 : $T, %1 : $C):
+  %4 = copy_value %0 : $T
+  strong_retain %1 : $C
+  %6 = tuple (%4 : $T, %0 : $T, %1 : $C, %1 : $C)
+  return %6 : $(T, T, C, C)
+}
+
+// CHECK-LABEL: sil @f072_callMixedResult1 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @owned C) {
+// CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $C):
+// CHECK:   %[[LOUT:.*]] = alloc_stack $T
+// CHECK:   %[[OUT:.*]] = alloc_stack $T
+// CHECK:   %[[LIN:.*]] = alloc_stack $T
+// CHECK:   // function_ref f070_mixedResult1
+// CHECK:   %[[F:.*]] = function_ref @f070_mixedResult1 : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @owned C)
+// CHECK:   copy_addr %1 to [initialization] %[[LIN]] : $*T
+// CHECK:   strong_retain %2 : $C
+// CHECK:   %[[IN:.*]] = alloc_stack $T
+// CHECK:   copy_addr [take] %[[LIN]] to [initialization] %[[IN]] : $*T
+// CHECK:   %11 = apply %[[F]]<T>(%[[OUT]], %[[IN]], %2) : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @owned C)
+// CHECK:   dealloc_stack %[[IN]] : $*T
+// CHECK:   copy_addr %[[OUT]] to [initialization] %[[LOUT]] : $*T
+// CHECK:   strong_retain %11 : $C
+// CHECK:   destroy_addr %[[OUT]] : $*T
+// CHECK:   strong_release %11 : $C
+// CHECK:   strong_release %2 : $C
+// CHECK:   destroy_addr %1 : $*T
+// CHECK:   copy_addr [take] %[[LOUT]] to [initialization] %0 : $*T
+// CHECK:   dealloc_stack %[[LIN]] : $*T
+// CHECK:   dealloc_stack %[[OUT]] : $*T
+// CHECK:   dealloc_stack %[[LOUT]] : $*T
+// CHECK:   return %11 : $C
+// CHECK-LABEL: } // end sil function 'f072_callMixedResult1'
+sil @f072_callMixedResult1 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @owned C) {
+bb0(%0 : $T, %1 : $C):
+  %4 = function_ref @f070_mixedResult1 : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @owned C)
+  %5 = copy_value %0 : $T
+  strong_retain %1 : $C
+  %7 = apply %4<T>(%5, %1) : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @owned C)
+  %8 = tuple_extract %7 : $(T, C), 0
+  %9 = copy_value %8 : $T
+  %10 = tuple_extract %7 : $(T, C), 1
+  strong_retain %10 : $C
+  destroy_value %7 : $(T, C)
+  strong_release %1 : $C
+  destroy_value %0 : $T
+  %15 = tuple (%9 : $T, %10 : $C)
+  return %15 : $(T, C)
+}
+
+// CHECK-LABEL: sil @f073_callMixedResult2 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @out T, @owned C, @owned C) {
+// CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T, %3 : $C):
+// CHECK:   %[[LOC2:.*]] = alloc_stack $T
+// CHECK:   %[[OUT2:.*]] = alloc_stack $T
+// CHECK:   %[[LOC1:.*]] = alloc_stack $T
+// CHECK:   %[[OUT1:.*]] = alloc_stack $T
+// CHECK:   %[[LOC0:.*]] = alloc_stack $T
+// CHECK:   %[[F:.*]] = function_ref @f071_mixedResult2 : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @out τ_0_0, @owned C, @owned C)
+// CHECK:   copy_addr %2 to [initialization] %[[LOC0]] : $*T
+// CHECK:   strong_retain %3 : $C
+// CHECK:   %[[IN:.*]] = alloc_stack $T
+// CHECK:   copy_addr [take] %[[LOC0]] to [initialization] %[[IN]] : $*T
+// CHECK:   %[[R:.*]] = apply %[[F]]<T>(%[[OUT1]], %[[OUT2]], %[[IN]], %3) : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @out τ_0_0, @owned C, @owned C)
+// CHECK:   %[[T2:.*]] = tuple_extract %[[R]] : $(C, C), 1
+// CHECK:   %[[T1:.*]] = tuple_extract %[[R]] : $(C, C), 0
+// CHECK:   dealloc_stack %[[IN]] : $*T
+// CHECK:   copy_addr %[[OUT1]] to [initialization] %[[LOC1]] : $*T
+// CHECK:   copy_addr %[[OUT2]] to [initialization] %[[LOC2]] : $*T
+// CHECK:   strong_retain %[[T1]] : $C
+// CHECK:   strong_retain %[[T2]] : $C
+// CHECK:   destroy_addr %[[OUT1]] : $*T
+// CHECK:   destroy_addr %[[OUT2]] : $*T
+// CHECK:   strong_release %[[T1]] : $C
+// CHECK:   strong_release %[[T2]] : $C
+// CHECK:   strong_release %3 : $C
+// CHECK:   destroy_addr %2 : $*T
+// CHECK:   copy_addr [take] %[[LOC1]] to [initialization] %0 : $*T
+// CHECK:   copy_addr [take] %[[LOC2]] to [initialization] %1 : $*T
+// CHECK:   %[[T:.*]] = tuple (%[[T1]] : $C, %[[T2]] : $C)
+// CHECK:   dealloc_stack %[[LOC0]] : $*T
+// CHECK:   dealloc_stack %[[OUT1]] : $*T
+// CHECK:   dealloc_stack %[[LOC1]] : $*T
+// CHECK:   dealloc_stack %[[OUT2]] : $*T
+// CHECK:   dealloc_stack %[[LOC2]] : $*T
+// CHECK:   return %[[T]] : $(C, C)
+// CHECK-LABEL: } // end sil function 'f073_callMixedResult2'
+sil @f073_callMixedResult2 : $@convention(thin) <T> (@in T, @owned C) -> (@out T, @out T, @owned C, @owned C) {
+bb0(%0 : $T, %1 : $C):
+  %4 = function_ref @f071_mixedResult2 : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @out τ_0_0, @owned C, @owned C)
+  %5 = copy_value %0 : $T
+  strong_retain %1 : $C
+  %7 = apply %4<T>(%5, %1) : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned C) -> (@out τ_0_0, @out τ_0_0, @owned C, @owned C)
+  %8 = tuple_extract %7 : $(T, T, C, C), 0
+  %9 = copy_value %8 : $T
+  %10 = tuple_extract %7 : $(T, T, C, C), 1
+  %11 = copy_value %10 : $T
+  %12 = tuple_extract %7 : $(T, T, C, C), 2
+  strong_retain %12 : $C
+  %14 = tuple_extract %7 : $(T, T, C, C), 3
+  strong_retain %14 : $C
+  destroy_value %7 : $(T, T, C, C)
+  strong_release %1 : $C
+  destroy_value %0 : $T
+  %19 = tuple (%9 : $T, %11 : $T, %12 : $C, %14 : $C)
+  return %19 : $(T, T, C, C)
+}
+
+sil_default_witness_table C {}
diff --git a/test/SILOptimizer/capture_promotion_generic_context.sil b/test/SILOptimizer/capture_promotion_generic_context.sil
index 1eb5b86..b7b2812 100644
--- a/test/SILOptimizer/capture_promotion_generic_context.sil
+++ b/test/SILOptimizer/capture_promotion_generic_context.sil
@@ -35,16 +35,11 @@
   return %k : $@callee_owned () -> Int
 }
 
-// Applying the caller's substitutions to a generic closure callee would also
-// be disastrous, but it appears that capture promotion currently bails out
-// on generic closures. This test is included to ensure there aren't regressions
-// if capture promotion is ever generalized to generic closures.
-
 protocol P {}
 
-// TODO: Ought to be promotable, but currently is not.
-// rdar://problem/28948735
-// CHECK-LABEL: sil @generic_promotable_box
+// CHECK-LABEL: sil @_TTSf2n_i__generic_promotable_box : $@convention(thin) <T> (@in T, Builtin.Int32) -> Builtin.Int32
+// CHECK:       bb0(%0 : $*T, %1 : $Builtin.Int32):
+// CHECK-NEXT:    return %1 : $Builtin.Int32
 
 sil @generic_promotable_box : $@convention(thin) <T> (@in T, <τ_0_0> { var τ_0_0 } <Int>) -> Int {
 entry(%0 : $*T, %b : $<τ_0_0> { var τ_0_0 } <Int>):
@@ -54,8 +49,12 @@
 }
 
 // CHECK-LABEL: sil @call_generic_promotable_box_from_different_generic
-// CHECK:         [[F:%.*]] = function_ref @generic_promotable_box
-// CHECK:         partial_apply [[F]]<U>(
+// CHECK:       bb0(%0 : $*T, %1 : $*U, %2 : $Builtin.Int32):
+// CHECK-NEXT:    destroy_addr %0 : $*T
+// CHECK-NEXT:    destroy_addr %1 : $*U
+// CHECK:         [[F:%.*]] = function_ref @_TTSf2n_i__generic_promotable_box : $@convention(thin) <τ_0_0> (@in τ_0_0, Builtin.Int32) -> Builtin.Int32
+// CHECK-NEXT:    [[CLOSURE:%.*]] = partial_apply [[F]]<U>(%2)
+// CHECK-NEXT:    return [[CLOSURE]]
 
 sil @call_generic_promotable_box_from_different_generic : $@convention(thin) <T, U: P> (@in T, @in U, Int) -> @owned @callee_owned (@in U) -> Int {
 entry(%0 : $*T, %1 : $*U, %2 : $Int):
diff --git a/test/SILOptimizer/cse.sil b/test/SILOptimizer/cse.sil
index 10e8c82..f101457 100644
--- a/test/SILOptimizer/cse.sil
+++ b/test/SILOptimizer/cse.sil
@@ -720,104 +720,6 @@
   %33 = return %32 : $()
 }
 
-// CHECK-LABEL: sil @cse_value_metatype
-// CHECK: value_metatype $@objc_metatype
-// CHECK: objc_metatype_to_object
-// CHECK-NOT: value_metatype $@objc_metatype
-// CHECK: strong_release
-// CHECK: return
-sil @cse_value_metatype : $@convention(thin) <T where T : AnyObject> (@owned T) -> @owned (AnyObject, AnyObject) {
-bb0(%0 : $T):
-  %2 = value_metatype $@objc_metatype T.Type, %0 : $T
-  %4 = objc_metatype_to_object %2 : $@objc_metatype T.Type to $AnyObject
-  %5 = value_metatype $@objc_metatype T.Type, %0 : $T
-  %7 = objc_metatype_to_object %5 : $@objc_metatype T.Type to $AnyObject
-  strong_release %0 : $T
-  %9 = tuple (%4: $AnyObject, %7: $AnyObject)
-  return %9 : $(AnyObject, AnyObject)
-}
-
-
-@objc(XX) protocol XX {
-}
-
-// CHECK-LABEL: sil @cse_existential_metatype
-// CHECK: existential_metatype $@objc_metatype
-// CHECK: objc_existential_metatype_to_object
-// CHECK-NOT: existential_metatype $@objc_metatype
-// CHECK: strong_release
-// CHECK: return
-sil @cse_existential_metatype : $@convention(thin) (@owned XX) -> @owned (AnyObject, AnyObject) {
-bb0(%0 : $XX):
-  %2 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
-  %4 = objc_existential_metatype_to_object %2 : $@objc_metatype XX.Type to $AnyObject
-  %5 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
-  %6 = objc_existential_metatype_to_object %5 : $@objc_metatype XX.Type to $AnyObject
-  strong_release %0 : $XX
-  %7 = tuple (%4: $AnyObject, %6: $AnyObject)
-  return %7 : $(AnyObject, AnyObject)
-}
-
-// CHECK-LABEL: sil @nocse_existential_metatype_addr
-// CHECK: store
-// CHECK: existential_metatype $@thick Any.Type
-// CHECK: store
-// CHECK: existential_metatype $@thick Any.Type
-// CHECK: return
-sil @nocse_existential_metatype_addr : $@convention(thin) (@owned B, @owned B) -> (@thick Any.Type, @thick Any.Type) {
-bb0(%0 : $B, %1 : $B):
-  %2 = alloc_stack $Any
-  %3 = init_existential_addr %2 : $*Any, $B
-  store %0 to %3 : $*B
-  %5 = existential_metatype $@thick Any.Type, %2 : $*Any
-  store %1 to %3 : $*B
-  %7 = existential_metatype $@thick Any.Type, %2 : $*Any
-  strong_release %1 : $B
-  strong_release %0 : $B
-  %99 = tuple (%5 : $@thick Any.Type, %7 : $@thick Any.Type)
-  dealloc_stack %2 : $*Any
-  return %99 : $(@thick Any.Type, @thick Any.Type)
-}
-
-
-// CHECK-LABEL: sil @cse_objc_metatype_to_object
-// CHECK: value_metatype $@objc_metatype
-// CHECK: objc_metatype_to_object
-// CHECK-NOT: value_metatype $@objc_metatype
-// CHECK-NOT: objc_metatype_to_object
-// CHECK: strong_release
-// CHECK: return
-sil @cse_objc_metatype_to_object : $@convention(thin) <T where T : AnyObject> (@owned T) -> @owned (AnyObject, AnyObject) {
-bb0(%0 : $T):
-  %2 = value_metatype $@objc_metatype T.Type, %0 : $T
-  %4 = objc_metatype_to_object %2 : $@objc_metatype T.Type to $AnyObject
-  %5 = value_metatype $@objc_metatype T.Type, %0 : $T
-  %7 = objc_metatype_to_object %5 : $@objc_metatype T.Type to $AnyObject
-  strong_release %0 : $T
-  %9 = tuple (%4: $AnyObject, %7: $AnyObject)
-  return %9 : $(AnyObject, AnyObject)
-}
-
-
-// CHECK-LABEL: sil @cse_objc_existential_metatype_to_object
-// CHECK: existential_metatype $@objc_metatype
-// CHECK: objc_existential_metatype_to_object
-// CHECK-NOT: existential_metatype $@objc_metatype
-// CHECK-NOT: objc_existential_metatype_to_object
-// CHECK: strong_release
-// CHECK: return
-sil @cse_objc_existential_metatype_to_object : $@convention(thin) (@owned XX) -> @owned (AnyObject, AnyObject) {
-bb0(%0 : $XX):
-  %2 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
-  %4 = objc_existential_metatype_to_object %2 : $@objc_metatype XX.Type to $AnyObject
-  %5 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
-  %6 = objc_existential_metatype_to_object %5 : $@objc_metatype XX.Type to $AnyObject
-  strong_release %0 : $XX
-  %7 = tuple (%4: $AnyObject, %6: $AnyObject)
-  return %7 : $(AnyObject, AnyObject)
-}
-
-
 // CHECK-LABEL: sil @cse_raw_pointer_to_ref
 // CHECK: raw_pointer_to_ref
 // CHECK-NOT: raw_pointer_to_ref
@@ -937,24 +839,6 @@
   return %3: $(Builtin.Int1, Builtin.Int1)
 }
 
-
-@objc
-class XXX {
-}
-
-// CHECK-LABEL: sil @cse_objc_to_thick_metatype
-// CHECK: objc_to_thick_metatype
-// CHECK-NOT: objc_to_thick_metatype
-// CHECK: tuple
-// CHECK: return
-sil @cse_objc_to_thick_metatype : $@convention(thin) (@objc_metatype XXX.Type) -> (@thick XXX.Type, @thick XXX.Type) {
-bb0(%0 : $@objc_metatype XXX.Type):
-  %1 = objc_to_thick_metatype %0 : $@objc_metatype XXX.Type to $@thick XXX.Type
-  %2 = objc_to_thick_metatype %0 : $@objc_metatype XXX.Type to $@thick XXX.Type
-  %3 = tuple (%1: $@thick XXX.Type, %2: $@thick XXX.Type)
-  return %3: $(@thick XXX.Type, @thick XXX.Type)
-}
-
 // CHECK-LABEL: sil @cse_bridge_object_to_ref
 // CHECK: bridge_object_to_ref
 // CHECK-NOT: bridge_object_to_ref
diff --git a/test/SILOptimizer/cse_objc.sil b/test/SILOptimizer/cse_objc.sil
index 0d0a71c..40d3be1 100644
--- a/test/SILOptimizer/cse_objc.sil
+++ b/test/SILOptimizer/cse_objc.sil
@@ -154,6 +154,118 @@
   return %13 : $()
 }
 
+// CHECK-LABEL: sil @cse_value_metatype
+// CHECK: value_metatype $@objc_metatype
+// CHECK: objc_metatype_to_object
+// CHECK-NOT: value_metatype $@objc_metatype
+// CHECK: strong_release
+// CHECK: return
+sil @cse_value_metatype : $@convention(thin) <T where T : AnyObject> (@owned T) -> @owned (AnyObject, AnyObject) {
+bb0(%0 : $T):
+  %2 = value_metatype $@objc_metatype T.Type, %0 : $T
+  %4 = objc_metatype_to_object %2 : $@objc_metatype T.Type to $AnyObject
+  %5 = value_metatype $@objc_metatype T.Type, %0 : $T
+  %7 = objc_metatype_to_object %5 : $@objc_metatype T.Type to $AnyObject
+  strong_release %0 : $T
+  %9 = tuple (%4: $AnyObject, %7: $AnyObject)
+  return %9 : $(AnyObject, AnyObject)
+}
+
+// CHECK-LABEL: sil @cse_existential_metatype
+// CHECK: existential_metatype $@objc_metatype
+// CHECK: objc_existential_metatype_to_object
+// CHECK-NOT: existential_metatype $@objc_metatype
+// CHECK: strong_release
+// CHECK: return
+sil @cse_existential_metatype : $@convention(thin) (@owned XX) -> @owned (AnyObject, AnyObject) {
+bb0(%0 : $XX):
+  %2 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
+  %4 = objc_existential_metatype_to_object %2 : $@objc_metatype XX.Type to $AnyObject
+  %5 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
+  %6 = objc_existential_metatype_to_object %5 : $@objc_metatype XX.Type to $AnyObject
+  strong_release %0 : $XX
+  %7 = tuple (%4: $AnyObject, %6: $AnyObject)
+  return %7 : $(AnyObject, AnyObject)
+}
+
+class B {}
+
+// CHECK-LABEL: sil @nocse_existential_metatype_addr
+// CHECK: store
+// CHECK: existential_metatype $@thick Any.Type
+// CHECK: store
+// CHECK: existential_metatype $@thick Any.Type
+// CHECK: return
+sil @nocse_existential_metatype_addr : $@convention(thin) (@owned B, @owned B) -> (@thick Any.Type, @thick Any.Type) {
+bb0(%0 : $B, %1 : $B):
+  %2 = alloc_stack $Any
+  %3 = init_existential_addr %2 : $*Any, $B
+  store %0 to %3 : $*B
+  %5 = existential_metatype $@thick Any.Type, %2 : $*Any
+  store %1 to %3 : $*B
+  %7 = existential_metatype $@thick Any.Type, %2 : $*Any
+  strong_release %1 : $B
+  strong_release %0 : $B
+  %99 = tuple (%5 : $@thick Any.Type, %7 : $@thick Any.Type)
+  dealloc_stack %2 : $*Any
+  return %99 : $(@thick Any.Type, @thick Any.Type)
+}
+
+
+// CHECK-LABEL: sil @cse_objc_metatype_to_object
+// CHECK: value_metatype $@objc_metatype
+// CHECK: objc_metatype_to_object
+// CHECK-NOT: value_metatype $@objc_metatype
+// CHECK-NOT: objc_metatype_to_object
+// CHECK: strong_release
+// CHECK: return
+sil @cse_objc_metatype_to_object : $@convention(thin) <T where T : AnyObject> (@owned T) -> @owned (AnyObject, AnyObject) {
+bb0(%0 : $T):
+  %2 = value_metatype $@objc_metatype T.Type, %0 : $T
+  %4 = objc_metatype_to_object %2 : $@objc_metatype T.Type to $AnyObject
+  %5 = value_metatype $@objc_metatype T.Type, %0 : $T
+  %7 = objc_metatype_to_object %5 : $@objc_metatype T.Type to $AnyObject
+  strong_release %0 : $T
+  %9 = tuple (%4: $AnyObject, %7: $AnyObject)
+  return %9 : $(AnyObject, AnyObject)
+}
+
+
+// CHECK-LABEL: sil @cse_objc_existential_metatype_to_object
+// CHECK: existential_metatype $@objc_metatype
+// CHECK: objc_existential_metatype_to_object
+// CHECK-NOT: existential_metatype $@objc_metatype
+// CHECK-NOT: objc_existential_metatype_to_object
+// CHECK: strong_release
+// CHECK: return
+sil @cse_objc_existential_metatype_to_object : $@convention(thin) (@owned XX) -> @owned (AnyObject, AnyObject) {
+bb0(%0 : $XX):
+  %2 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
+  %4 = objc_existential_metatype_to_object %2 : $@objc_metatype XX.Type to $AnyObject
+  %5 = existential_metatype $@objc_metatype XX.Type, %0 : $XX
+  %6 = objc_existential_metatype_to_object %5 : $@objc_metatype XX.Type to $AnyObject
+  strong_release %0 : $XX
+  %7 = tuple (%4: $AnyObject, %6: $AnyObject)
+  return %7 : $(AnyObject, AnyObject)
+}
+
+@objc
+class XXX {
+}
+
+// CHECK-LABEL: sil @cse_objc_to_thick_metatype
+// CHECK: objc_to_thick_metatype
+// CHECK-NOT: objc_to_thick_metatype
+// CHECK: tuple
+// CHECK: return
+sil @cse_objc_to_thick_metatype : $@convention(thin) (@objc_metatype XXX.Type) -> (@thick XXX.Type, @thick XXX.Type) {
+bb0(%0 : $@objc_metatype XXX.Type):
+  %1 = objc_to_thick_metatype %0 : $@objc_metatype XXX.Type to $@thick XXX.Type
+  %2 = objc_to_thick_metatype %0 : $@objc_metatype XXX.Type to $@thick XXX.Type
+  %3 = tuple (%1: $@thick XXX.Type, %2: $@thick XXX.Type)
+  return %3: $(@thick XXX.Type, @thick XXX.Type)
+}
+
 sil_vtable Bar {
   #Bar.init!initializer.1: _TFC4test3BarcfMS0_FT_S0_	// test.Bar.init (test.Bar.Type)() -> test.Bar
   #Bar.walk!1: _TFC4test3Bar4walkfS0_FT_T_	// test.Bar.walk (test.Bar)() -> ()
diff --git a/test/SILOptimizer/devirt_materializeForSet.swift b/test/SILOptimizer/devirt_materializeForSet.swift
index e84bc40..77b805b 100644
--- a/test/SILOptimizer/devirt_materializeForSet.swift
+++ b/test/SILOptimizer/devirt_materializeForSet.swift
@@ -5,7 +5,7 @@
 
 // CHECK-LABEL: sil [transparent] [fragile] [thunk] @_T024devirt_materializeForSet7BaseFooCAA0F0AaaDP3barSSfmTW
 // CHECK: checked_cast_br [exact] %{{.*}} : $BaseFoo to $ChildFoo
-// CHECK: thin_function_to_pointer %{{.*}} : $@convention(thin) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout ChildFoo, @thick ChildFoo.Type) -> () to $Builtin.RawPointer
+// CHECK: thin_function_to_pointer %{{.*}} : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout ChildFoo, @thick ChildFoo.Type) -> () to $Builtin.RawPointer
 // CHECK: enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, %{{.*}} : $Builtin.RawPointer
 // CHECK: tuple (%{{.*}} : $Builtin.RawPointer, %{{.*}} : $Optional<Builtin.RawPointer>)
 
diff --git a/test/SILOptimizer/existential_type_propagation.sil b/test/SILOptimizer/existential_type_propagation.sil
index 814ae81..d43dec7 100644
--- a/test/SILOptimizer/existential_type_propagation.sil
+++ b/test/SILOptimizer/existential_type_propagation.sil
@@ -253,18 +253,17 @@
 // Check that sil-combine does not crash on this example and does not generate a wrong
 // upcast.
 // CHECK-LABEL: sil @silcombine_dont_generate_wrong_upcasts_during_devirt
-// CHECK-NOT: upcast
-// CHECK: witness_method $XXX, #PPP.foo!1 : {{.*}} : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
-// CHECK-NOT: upcast
+// CHECK: [[SELF:%.*]] = unchecked_ref_cast %0 : $BBB to $XXX
+// CHECK: [[WITNESS_THUNK:%.*]] = function_ref @_TTWC4nix23XXXS_3PPPS_FS1_3foofT_T_ : $@convention(witness_method) (@guaranteed XXX) -> ()
+// CHECK: apply [[WITNESS_THUNK]]([[SELF]])
 // CHECK: return
 sil @silcombine_dont_generate_wrong_upcasts_during_devirt: $@convention(thin) (@owned BBB) -> () {
 bb0(%0 : $BBB):
   strong_retain %0 : $BBB
   %3 = init_existential_ref %0 : $BBB : $BBB, $PPP
   %5 = open_existential_ref %3 : $PPP to $@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP
-  %6 = witness_method $XXX, #PPP.foo!1, %5 : $@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
+  %6 = witness_method $BBB, #PPP.foo!1, %5 : $@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
   %7 = apply %6<@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP>(%5) : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
-  %8 = apply %6<@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP>(%5) : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
   strong_release %3 : $PPP
   %9 = tuple ()
   strong_release %0 : $BBB
@@ -279,8 +278,6 @@
 // CHECK-NOT: witness_method
 // CHECK: [[FR1:%.*]] = function_ref @_TTWC4nix23XXXS_3PPPS_FS1_3foofT_T_
 // CHECK: apply [[FR1]](%0)
-// CHECK: [[FR2:%.*]] = function_ref @_TTWC4nix23XXXS_3PPPS_FS1_3foofT_T_
-// CHECK: apply [[FR2]](%0)
 // CHECK: return
 sil @silcombine_devirt_both_applies_of_witness_method : $@convention(thin) (@owned XXX) -> () {
 bb0(%0 : $XXX):
@@ -289,7 +286,6 @@
   %5 = open_existential_ref %3 : $PPP to $@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP
   %6 = witness_method $@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP, #PPP.foo!1, %5 : $@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
   %7 = apply %6<@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP>(%5) : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
-  %8 = apply %6<@opened("0AC9A62E-926E-11E6-8BF5-685B35C48C83") PPP>(%5) : $@convention(witness_method) <τ_0_0 where τ_0_0 : PPP> (@guaranteed τ_0_0) -> ()
   strong_release %3 : $PPP
   %9 = tuple ()
   strong_release %0 : $XXX
diff --git a/test/SILOptimizer/ownership_model_eliminator.sil b/test/SILOptimizer/ownership_model_eliminator.sil
index bedfe79..70288dd 100644
--- a/test/SILOptimizer/ownership_model_eliminator.sil
+++ b/test/SILOptimizer/ownership_model_eliminator.sil
@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt -ownership-model-eliminator %s | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-ownership -ownership-model-eliminator %s | %FileCheck %s
 
 sil_stage canonical
 
@@ -10,7 +10,7 @@
 class C {}
 
 // CHECK-LABEL: sil @load : $@convention(thin) (@in Builtin.NativeObject, @in Builtin.Int32) -> () {
-// CHECK: bb0([[ARG1:%[0-9]+]] : $*Builtin.NativeObject, [[ARG2:%[0-9]+]] : $*Builtin.Int32):
+// CHECK: bb0([[ARG1:%[0-9]+]] : @trivial $*Builtin.NativeObject, [[ARG2:%[0-9]+]] : @trivial $*Builtin.Int32):
 // CHECK: [[LOAD2:%[0-9]+]] = load [[ARG1]] : $*Builtin.NativeObject
 // CHECK: apply {{%[0-9]+}}([[LOAD2]])
 // CHECK: [[LOAD3:%[0-9]+]] = load [[ARG1]] : $*Builtin.NativeObject
@@ -19,7 +19,7 @@
 // CHECK: [[LOAD4:%[0-9]+]] = load [[ARG2]] : $*Builtin.Int32
 // CHECK: apply {{%[0-9]+}}([[LOAD4]])
 sil @load : $@convention(thin) (@in Builtin.NativeObject, @in Builtin.Int32) -> () {
-bb0(%0 : $*Builtin.NativeObject, %1 : $*Builtin.Int32):
+bb0(%0 : @trivial $*Builtin.NativeObject, %1 : @trivial $*Builtin.Int32):
   %use_native_object_func = function_ref @use_native_object : $@convention(thin) (@owned Builtin.NativeObject) -> ()
   %use_int32_func = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
 
@@ -37,28 +37,32 @@
 }
 
 // CHECK-LABEL: sil @store : $@convention(thin) (@in Builtin.NativeObject, Builtin.NativeObject, @in Builtin.Int32, Builtin.Int32) -> ()
-// CHECK: bb0([[ARG1:%[0-9]+]] : $*Builtin.NativeObject, [[ARG2:%[0-9]+]] : $Builtin.NativeObject, [[ARG3:%[0-9]+]] : $*Builtin.Int32, [[ARG4:%[0-9]+]] : $Builtin.Int32):
+// CHECK: bb0([[ARG1:%[0-9]+]] : @trivial $*Builtin.NativeObject, [[ARG2:%[0-9]+]] : @unowned $Builtin.NativeObject, [[ARG3:%[0-9]+]] : @trivial $*Builtin.Int32, [[ARG4:%[0-9]+]] : @trivial $Builtin.Int32):
+// CHECK: strong_retain [[ARG2]]
+// CHECK: strong_retain [[ARG2]]
 // CHECK: store [[ARG2]] to [[ARG1]] : $*Builtin.NativeObject
 // CHECK: [[OLDVAL:%[0-9]+]] = load [[ARG1]] : $*Builtin.NativeObject
 // CHECK: store [[ARG2]] to [[ARG1]] : $*Builtin.NativeObject
 // CHECK: strong_release [[OLDVAL]]
 // CHECK: store [[ARG4]] to [[ARG3]] : $*Builtin.Int32
 sil @store : $@convention(thin) (@in Builtin.NativeObject, Builtin.NativeObject, @in Builtin.Int32, Builtin.Int32) -> () {
-bb0(%0 : $*Builtin.NativeObject, %1 : $Builtin.NativeObject, %2 : $*Builtin.Int32, %3 : $Builtin.Int32):
-  store %1 to [init] %0 : $*Builtin.NativeObject
-  store %1 to [assign] %0 : $*Builtin.NativeObject
+bb0(%0 : @trivial $*Builtin.NativeObject, %1 : @unowned $Builtin.NativeObject, %2 : @trivial $*Builtin.Int32, %3 : @trivial $Builtin.Int32):
+  %4 = copy_value %1 : $Builtin.NativeObject
+  %5 = copy_value %1 : $Builtin.NativeObject
+  store %4 to [init] %0 : $*Builtin.NativeObject
+  store %5 to [assign] %0 : $*Builtin.NativeObject
   store %3 to [trivial] %2 : $*Builtin.Int32
   %9999 = tuple()
   return %9999 : $()
 }
 
 // CHECK-LABEL: sil @borrow : $@convention(thin) (@in Builtin.NativeObject) -> () {
-// CHECK: bb0([[ARG:%[0-9]+]] : $*Builtin.NativeObject):
+// CHECK: bb0([[ARG:%[0-9]+]] : @trivial $*Builtin.NativeObject):
 // CHECK: [[BORROWED_VALUE:%[0-9]+]] = load [[ARG]] : $*Builtin.NativeObject
 // CHECK: unchecked_ref_cast [[BORROWED_VALUE]]
 // CHECK-NOT: end_borrow
 sil @borrow : $@convention(thin) (@in Builtin.NativeObject) -> () {
-bb0(%0 : $*Builtin.NativeObject):
+bb0(%0 : @trivial $*Builtin.NativeObject):
   %1 = load_borrow %0 : $*Builtin.NativeObject
   %2 = unchecked_ref_cast %1 : $Builtin.NativeObject to $Builtin.NativeObject
   end_borrow %1 from %0 : $Builtin.NativeObject, $*Builtin.NativeObject
@@ -69,12 +73,12 @@
 sil @opaque_function : $@convention(thin) () -> ()
 
 // CHECK-LABEL: sil @copy_value_destroy_value : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
-// CHECK: bb0([[ARG1:%.*]] : $Builtin.NativeObject):
+// CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject):
 // CHECK: strong_retain [[ARG1]]
 // CHECK: strong_release [[ARG1]]
 // CHECK: return [[ARG1]]
 sil @copy_value_destroy_value : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
-bb0(%0 : $Builtin.NativeObject):
+bb0(%0 : @owned $Builtin.NativeObject):
   %1 = function_ref @opaque_function : $@convention(thin) () -> ()
   %2 = copy_value %0 : $Builtin.NativeObject
   apply %1() : $@convention(thin) () -> ()
@@ -83,28 +87,30 @@
 }
 
 // CHECK-LABEL: sil @begin_borrow_store_borrow : $@convention(thin) (@owned Builtin.NativeObject) -> () {
-// CHECK: bb0([[ARG:%.*]] : $Builtin.NativeObject):
+// CHECK: bb0([[ARG:%.*]] : @owned $Builtin.NativeObject):
 // CHECK-NEXT: [[MEM:%.*]] = alloc_stack $Builtin.NativeObject
 // CHECK-NEXT: store [[ARG]] to [[MEM]] : $*Builtin.NativeObject
 // CHECK-NEXT: dealloc_stack [[MEM]] : $*Builtin.NativeObject
+// CHECK-NEXT: strong_release [[ARG]]
 // CHECK-NEXT: tuple ()
 // CHECK-NEXT: return
 // CHECK: } // end sil function 'begin_borrow_store_borrow'
 sil @begin_borrow_store_borrow : $@convention(thin) (@owned Builtin.NativeObject) -> () {
-bb0(%0 : $Builtin.NativeObject):
+bb0(%0 : @owned $Builtin.NativeObject):
   %1 = begin_borrow %0 : $Builtin.NativeObject
   end_borrow %1 from %0 : $Builtin.NativeObject, $Builtin.NativeObject
   %2 = alloc_stack $Builtin.NativeObject
-  store_borrow %0 to %2 : $*Builtin.NativeObject
-  end_borrow %2 from %0 : $*Builtin.NativeObject, $Builtin.NativeObject
+  %3 = begin_borrow %0 : $Builtin.NativeObject
+  store_borrow %3 to %2 : $*Builtin.NativeObject
+  end_borrow %3 from %0 : $Builtin.NativeObject, $Builtin.NativeObject
   dealloc_stack %2 : $*Builtin.NativeObject
-
+  destroy_value %0 : $Builtin.NativeObject
   %9999 = tuple()
   return %9999 : $()
 }
 
 // CHECK-LABEL: sil @copy_unowned_value_test : $@convention(thin) (@owned @sil_unowned Builtin.NativeObject) -> () {
-// CHECK: bb0([[ARG:%.*]] : $@sil_unowned Builtin.NativeObject):
+// CHECK: bb0([[ARG:%.*]] : @owned $@sil_unowned Builtin.NativeObject):
 // CHECK-NEXT: strong_retain_unowned [[ARG]] : $@sil_unowned Builtin.NativeObject
 // CHECK-NEXT: [[OWNED_ARG:%.*]] = unowned_to_ref [[ARG]] : $@sil_unowned Builtin.NativeObject to $Builtin.NativeObject
 // CHECK-NEXT: strong_release [[OWNED_ARG]] : $Builtin.NativeObject
@@ -112,7 +118,7 @@
 // CHECK-NEXT: tuple ()
 // CHECK-NEXT: return
 sil @copy_unowned_value_test : $@convention(thin) (@owned @sil_unowned Builtin.NativeObject) -> () {
-bb0(%0 : $@sil_unowned Builtin.NativeObject):
+bb0(%0 : @owned $@sil_unowned Builtin.NativeObject):
   %1 = copy_unowned_value %0 : $@sil_unowned Builtin.NativeObject
   destroy_value %1 : $Builtin.NativeObject
   destroy_value %0 : $@sil_unowned Builtin.NativeObject
@@ -121,14 +127,14 @@
 }
 
 // CHECK-LABEL: sil @unmanaged_retain_release_test : $@convention(thin) (@owned Builtin.NativeObject, @owned C) -> () {
-// CHECK: bb0([[ARG1:%.*]] : $Builtin.NativeObject, [[ARG2:%.*]] : $C):
+// CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $C):
 // CHECK: strong_retain [[ARG1]] : $Builtin.NativeObject
 // CHECK: autorelease_value [[ARG2]] : $C
 // CHECK: strong_release [[ARG1]] : $Builtin.NativeObject
 // CHECK: strong_release [[ARG1]] : $Builtin.NativeObject
 // CHECK: } // end sil function 'unmanaged_retain_release_test'
 sil @unmanaged_retain_release_test : $@convention(thin) (@owned Builtin.NativeObject, @owned C) -> () {
-bb0(%0 : $Builtin.NativeObject, %1 : $C):
+bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $C):
   unmanaged_retain_value %0 : $Builtin.NativeObject
   unmanaged_autorelease_value %1 : $C
   br bb1
@@ -136,6 +142,35 @@
 bb1:
   unmanaged_release_value %0 : $Builtin.NativeObject
   destroy_value %0 : $Builtin.NativeObject
+  destroy_value %1 : $C
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil @checked_cast_br_lowered : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK: bb0([[ARG:%.*]] : @owned $Builtin.NativeObject):
+// CHECK:   checked_cast_br [[ARG]] : $Builtin.NativeObject to $C, [[SUCCBB:bb[0-9]+]], [[FAILBB:bb[0-9]+]]
+//
+// CHECK: [[SUCCBB]]([[CASTED_VALUE:%.*]] : @owned $C):
+// CHECK-NEXT:   strong_release [[CASTED_VALUE]]
+// CHECK-NEXT:   br bb3
+//
+// CHECK: [[FAILBB]]:
+// CHECK-NEXT:   strong_release [[ARG]]
+// CHECK-NEXT:   br bb3
+sil @checked_cast_br_lowered : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject):
+  checked_cast_br %0 : $Builtin.NativeObject to $C, bb1, bb2
+
+bb1(%1 : @owned $C):
+  destroy_value %1 : $C
+  br bb3
+
+bb2(%2 : @owned $Builtin.NativeObject):
+  destroy_value %2 : $Builtin.NativeObject
+  br bb3
+
+bb3:
   %9999 = tuple()
   return %9999 : $()
 }
diff --git a/test/SILOptimizer/sil_combine.sil b/test/SILOptimizer/sil_combine.sil
index 47ac926..2b31c1a 100644
--- a/test/SILOptimizer/sil_combine.sil
+++ b/test/SILOptimizer/sil_combine.sil
@@ -1969,34 +1969,6 @@
   init()
 }
 
-// CHECK-LABEL: sil @remove_release_objc_metatype_to_object
-// CHECK-NOT: strong_release {{%[0-9]+}} : $AnyObject
-sil @remove_release_objc_metatype_to_object : $@convention(thin) () -> () {
-bb0:
-  %0 = metatype $@thick XXImpl.Type                // user: %1
-  %1 = thick_to_objc_metatype %0 : $@thick XXImpl.Type to $@objc_metatype XXImpl.Type // user: %2
-  %2 = objc_metatype_to_object %1 : $@objc_metatype XXImpl.Type to $AnyObject // users: %3, %4
-  debug_value %2 : $AnyObject  // id: %3
-  strong_release %2 : $AnyObject                  // id: %4
-  %5 = tuple ()                                   // user: %6
-  return %5 : $()                                 // id: %6
-}
-
-// CHECK-LABEL: sil @remove_release_objc_existential_metatype_to_object
-// CHECK-NOT: strong_release {{%[0-9]+}} : $AnyObject
-sil @remove_release_objc_existential_metatype_to_object: $@convention(thin) (@owned XX) -> () {
-bb0(%0 : $XX):
-  debug_value %0 : $XX                   // id: %1
-  %2 = existential_metatype $@thick XX.Type, %0 : $XX // user: %3
-  %3 = thick_to_objc_metatype %2 : $@thick XX.Type to $@objc_metatype XX.Type // user: %4
-  %4 = objc_existential_metatype_to_object %3 : $@objc_metatype XX.Type to $AnyObject // users: %5, %6
-  debug_value %4 : $AnyObject, let, name "obj1" // id: %5
-  strong_release %4 : $AnyObject                  // id: %6
-  strong_release %0 : $XX                         // id: %7
-  %8 = tuple ()                                   // user: %9
-  return %8 : $()                                 // id: %9
-}
-
 // CHECK-LABEL: sil @unowned_round_trips : $@convention(thin) (B, @sil_unowned B, AnyObject, @sil_unmanaged AnyObject) -> (B, @sil_unowned B, AnyObject, @sil_unmanaged AnyObject) {
 // CHECK: bb0(
 // CHECK-NEXT: tuple
diff --git a/test/SILOptimizer/sil_combine_objc.sil b/test/SILOptimizer/sil_combine_objc.sil
index e631e6d..ed1e877 100644
--- a/test/SILOptimizer/sil_combine_objc.sil
+++ b/test/SILOptimizer/sil_combine_objc.sil
@@ -151,3 +151,39 @@
   return %4 : $Int
 }
 
+@objc(XX) protocol XX {
+}
+
+class XXImpl : XX {
+  @objc deinit
+  init()
+}
+
+// CHECK-LABEL: sil @remove_release_objc_metatype_to_object
+// CHECK-NOT: strong_release {{%[0-9]+}} : $AnyObject
+sil @remove_release_objc_metatype_to_object : $@convention(thin) () -> () {
+bb0:
+  %0 = metatype $@thick XXImpl.Type                // user: %1
+  %1 = thick_to_objc_metatype %0 : $@thick XXImpl.Type to $@objc_metatype XXImpl.Type // user: %2
+  %2 = objc_metatype_to_object %1 : $@objc_metatype XXImpl.Type to $AnyObject // users: %3, %4
+  debug_value %2 : $AnyObject  // id: %3
+  strong_release %2 : $AnyObject                  // id: %4
+  %5 = tuple ()                                   // user: %6
+  return %5 : $()                                 // id: %6
+}
+
+// CHECK-LABEL: sil @remove_release_objc_existential_metatype_to_object
+// CHECK-NOT: strong_release {{%[0-9]+}} : $AnyObject
+sil @remove_release_objc_existential_metatype_to_object: $@convention(thin) (@owned XX) -> () {
+bb0(%0 : $XX):
+  debug_value %0 : $XX                   // id: %1
+  %2 = existential_metatype $@thick XX.Type, %0 : $XX // user: %3
+  %3 = thick_to_objc_metatype %2 : $@thick XX.Type to $@objc_metatype XX.Type // user: %4
+  %4 = objc_existential_metatype_to_object %3 : $@objc_metatype XX.Type to $AnyObject // users: %5, %6
+  debug_value %4 : $AnyObject, let, name "obj1" // id: %5
+  strong_release %4 : $AnyObject                  // id: %6
+  strong_release %0 : $XX                         // id: %7
+  %8 = tuple ()                                   // user: %9
+  return %8 : $()                                 // id: %9
+}
+
diff --git a/test/Sema/circular_decl_checking.swift b/test/Sema/circular_decl_checking.swift
index 28998c9..1e556fb 100644
--- a/test/Sema/circular_decl_checking.swift
+++ b/test/Sema/circular_decl_checking.swift
@@ -44,9 +44,8 @@
 
 
 protocol AProtocol {
+  // FIXME: Should produce an error here, but it's currently causing problems.
   associatedtype e : e
-  // expected-error@-1 {{type 'e' references itself}}
-  // expected-note@-2 {{type declared here}}
 }
 
 
diff --git a/test/Serialization/Inputs/alias.swift b/test/Serialization/Inputs/alias.swift
index eff05c2..6786981 100644
--- a/test/Serialization/Inputs/alias.swift
+++ b/test/Serialization/Inputs/alias.swift
@@ -26,3 +26,8 @@
   }
 }
 public typealias BaseAlias = Base
+
+public protocol ProtoWrapper {}
+extension ProtoWrapper {
+  public typealias Boolean = Bool
+}
diff --git a/test/Serialization/Inputs/has_xref.swift b/test/Serialization/Inputs/has_xref.swift
index 46d3759..48aa625 100644
--- a/test/Serialization/Inputs/has_xref.swift
+++ b/test/Serialization/Inputs/has_xref.swift
@@ -3,6 +3,7 @@
 
 public func numeric(_ x: MyInt64) {}
 public func conditional(_ x: AliasWrapper.Boolean) {}
+public func conditional2(_ x: ProtoWrapper.Boolean) {}
 public func longInt(_ x: Int.EspeciallyMagicalInt) {}
 
 public func numericArray(_ x: IntSlice) {}
diff --git a/test/Serialization/xref.swift b/test/Serialization/xref.swift
index db2c249..547976d 100644
--- a/test/Serialization/xref.swift
+++ b/test/Serialization/xref.swift
@@ -14,6 +14,7 @@
 
 numeric(42)
 conditional(true)
+conditional2(true)
 longInt(42)
 numericArray([42])
 
diff --git a/test/attr/attr_specialize.swift b/test/attr/attr_specialize.swift
index 32b2fd9..83438fc 100644
--- a/test/attr/attr_specialize.swift
+++ b/test/attr/attr_specialize.swift
@@ -50,6 +50,7 @@
   @_specialize(where T == Int)
   @_specialize(where T == T) // expected-error{{Only concrete type same-type requirements are supported by '_specialize' attribute}}
   @_specialize(where T == S<T>) // expected-error{{Only concrete type same-type requirements are supported by '_specialize' attribute}}
+	// expected-error@-1{{same-type constraint 'T' == 'S<T>' is recursive}}
   @_specialize(where T == Int, U == Int) // expected-error{{use of undeclared type 'U'}}
   func noGenericParams() {}
 
@@ -115,6 +116,8 @@
 @_specialize(where X:_Trivial(8), Y == Int)
 @_specialize(where X == Int, Y == Int)
 @_specialize(where X == Int, X == Int) // expected-error{{too few type parameters are specified in '_specialize' attribute (got 1, but expected 2)}} expected-error{{Missing constraint for 'Y' in '_specialize' attribute}}
+// expected-warning@-1{{redundant same-type constraint 'X' == 'Int'}}
+// expected-note@-2{{same-type constraint 'X' == 'Int' written here}}
 @_specialize(where Y:_Trivial(32), X == Float)
 @_specialize(where X1 == Int, Y1 == Int) // expected-error{{use of undeclared type 'X1'}} expected-error{{use of undeclared type 'Y1'}} expected-error{{too few type parameters are specified in '_specialize' attribute (got 0, but expected 2)}} expected-error{{Missing constraint for 'X' in '_specialize' attribute}} expected-error{{Missing constraint for 'Y' in '_specialize' attribute}}
 public func funcWithTwoGenericParameters<X, Y>(x: X, y: Y) {
diff --git a/test/decl/inherit/inherit.swift b/test/decl/inherit/inherit.swift
index 05e9069..5c45988 100644
--- a/test/decl/inherit/inherit.swift
+++ b/test/decl/inherit/inherit.swift
@@ -30,11 +30,15 @@
 // Protocol composition in inheritance clauses
 struct S3 : P, P & Q { } // expected-error {{duplicate inheritance from 'P'}}
                          // expected-error @-1 {{protocol composition is neither allowed nor needed here}}
+                         // expected-error @-2 {{'Q' requires that 'S3' inherit from 'A'}}
+                         // expected-note @-3 {{requirement specified as 'Self' : 'A' [with Self = S3]}}
 struct S4 : P, P { }     // expected-error {{duplicate inheritance from 'P'}}
 struct S6 : P & { }      // expected-error {{expected identifier for type name}}
                          // expected-error @-1 {{protocol composition is neither allowed nor needed here}}
 struct S7 : protocol<P, Q> { }  // expected-warning {{'protocol<...>' composition syntax is deprecated; join the protocols using '&'}}
                                 // expected-error @-1 {{protocol composition is neither allowed nor needed here}}{{13-22=}} {{26-27=}}
+                                // expected-error @-2 {{'Q' requires that 'S7' inherit from 'A'}}
+                                // expected-note @-3 {{requirement specified as 'Self' : 'A' [with Self = S7]}}
 
 class GenericBase<T> {}
 
diff --git a/test/decl/protocol/protocols.swift b/test/decl/protocol/protocols.swift
index a57bba5..f82826b 100644
--- a/test/decl/protocol/protocols.swift
+++ b/test/decl/protocol/protocols.swift
@@ -36,7 +36,7 @@
   v1.creator = "Me"                   // expected-error {{cannot assign to property: 'creator' is a get-only property}}
 }
 
-protocol Bogus : Int {} // expected-error{{inheritance from non-protocol type 'Int'}}
+protocol Bogus : Int {} // expected-error{{inheritance from non-protocol, non-class type 'Int'}}
 
 // Explicit conformance checks (successful).
 
diff --git a/test/decl/protocol/req/recursion.swift b/test/decl/protocol/req/recursion.swift
index d559d82..5b61cb1 100644
--- a/test/decl/protocol/req/recursion.swift
+++ b/test/decl/protocol/req/recursion.swift
@@ -20,17 +20,18 @@
   // expected-note@-1{{type declared here}}
   // expected-note@-2{{protocol requires nested type 'Z'; do you want to add it?}}
 
-  associatedtype Z2 = Z3 // expected-note{{type declared here}}
+  associatedtype Z2 = Z3
   // expected-note@-1{{protocol requires nested type 'Z2'; do you want to add it?}}
-  associatedtype Z3 = Z2 // expected-error{{associated type 'Z2' references itself}}
+  associatedtype Z3 = Z2
   // expected-note@-1{{protocol requires nested type 'Z3'; do you want to add it?}}
 
-  associatedtype Z4 = Self.Z4 // expected-error{{associated type 'Z4' is not a member type of 'Self'}}
-  // expected-note@-1{{protocol requires nested type 'Z4'; do you want to add it?}}
+  associatedtype Z4 = Self.Z4 // expected-error{{associated type 'Z4' references itself}}
+  // expected-note@-1{{type declared here}}
+  // expected-note@-2{{protocol requires nested type 'Z4'; do you want to add it?}}
 
   associatedtype Z5 = Self.Z6
   // expected-note@-1{{protocol requires nested type 'Z5'; do you want to add it?}}
-  associatedtype Z6 = Self.Z5 // expected-error{{associated type 'Z5' is not a member type of 'Self'}}
+  associatedtype Z6 = Self.Z5
   // expected-note@-1{{protocol requires nested type 'Z6'; do you want to add it?}}
 }
 
diff --git a/test/expr/capture/noescape-error.swift b/test/expr/capture/noescape-error.swift
new file mode 100644
index 0000000..448d20a
--- /dev/null
+++ b/test/expr/capture/noescape-error.swift
@@ -0,0 +1,11 @@
+// RUN: %target-swift-frontend -typecheck -verify %s
+
+class C {}
+class D {}
+
+func f1(f : (inout Int) -> ()) {}
+
+func f2(f : (inout Any) -> ()) {
+    // TODO: Error here is still pretty bad...
+    f1 { f(&$0) } // expected-error{{conversion from 'Int' to 'Any'}}
+}
diff --git a/test/lit.cfg b/test/lit.cfg
index a7f618b..dd05346 100644
--- a/test/lit.cfg
+++ b/test/lit.cfg
@@ -465,6 +465,9 @@
 config.available_features.add("OS=" + run_os)
 config.available_features.add("PTRSIZE=" + run_ptrsize)
 
+if run_cpu == "i386" or run_cpu == "x86_64":
+  config.available_features.add("CPU=i386_or_x86_64")
+
 config.available_features.add("SWIFT_VERSION=" + swift_version)
 
 if "optimized_stdlib" in config.available_features:
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index dc33f68..0184045 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -68,6 +68,9 @@
 if "@SWIFT_STDLIB_ENABLE_RESILIENCE@" == "TRUE":
     config.available_features.add("resilient_stdlib")
 
+if "@SWIFT_STDLIB_USE_NONATOMIC_RC@" == "TRUE":
+    config.available_features.add("nonatomic_rc")
+
 if "@SWIFT_HAVE_WORKING_STD_REGEX@" == "FALSE":
     config.available_features.add('broken_std_regex')
 
diff --git a/test/stdlib/CommandLine.swift b/test/stdlib/CommandLine.swift
index cfbfa55..6b0e851 100644
--- a/test/stdlib/CommandLine.swift
+++ b/test/stdlib/CommandLine.swift
@@ -7,6 +7,7 @@
 // RUN: %target-build-swift %t/CommandLineStressTest.o %t/CommandLineStressTestSwift.o -o %t/CommandLineStressTest
 // RUN: %target-run %t/CommandLineStressTest foo bar baz qux quux corge grault garply waldo fred plugh xyzzy and thud
 // REQUIRES: executable_test
+// UNSUPPORTED: nonatomic_rc
 
 // This file is an empty stub to call into the command line stress test which
 // houses `main`.
diff --git a/test/stdlib/DispatchDeprecationWatchOS.swift b/test/stdlib/DispatchDeprecationWatchOS.swift
index 3341bb3..bbc5fc6 100644
--- a/test/stdlib/DispatchDeprecationWatchOS.swift
+++ b/test/stdlib/DispatchDeprecationWatchOS.swift
@@ -1,5 +1,5 @@
 // RUN: %swift -typecheck -target i386-apple-watchos2.0 -verify -sdk %sdk %s
-// REQUIRES: OS=watchos
+// REQUIRES: CPU=i386, OS=watchos
 // REQUIRES: objc_interop
 
 import Foundation
diff --git a/test/stdlib/TestData.swift b/test/stdlib/TestData.swift
index 97954b7..4d106bb 100644
--- a/test/stdlib/TestData.swift
+++ b/test/stdlib/TestData.swift
@@ -991,9 +991,7 @@
 DataTests.test("test_repeatingValueInitialization") { TestData().test_repeatingValueInitialization() }
 
 // XCTest does not have a crash detection, whereas lit does
-DataTests.test("bounding failure subdata")
-        .skip(.always("fails with resilient stdlib (rdar://problem/30560514)"))
-        .code {
+DataTests.test("bounding failure subdata") {
     let data = "Hello World".data(using: .utf8)!
     expectCrashLater()
     let c = data.subdata(in: 5..<200)
@@ -1051,7 +1049,9 @@
     data.append("hello", count: Int.min)
 }
 
-DataTests.test("bounding failure subscript") {
+DataTests.test("bounding failure subscript")
+        .skip(.always("fails with resilient stdlib (rdar://problem/30560514)"))
+        .code {
     var data = "Hello World".data(using: .utf8)!
     expectCrashLater()
     data[100] = 4
diff --git a/test/stmt/Inputs/Foundation-with-NSError.swift b/test/stmt/Inputs/Foundation-with-NSError.swift
new file mode 100644
index 0000000..0005b24
--- /dev/null
+++ b/test/stmt/Inputs/Foundation-with-NSError.swift
@@ -0,0 +1 @@
+public class NSError: Error {}
diff --git a/test/stmt/errors_nonobjc.swift b/test/stmt/errors_nonobjc.swift
new file mode 100644
index 0000000..2c3369d
--- /dev/null
+++ b/test/stmt/errors_nonobjc.swift
@@ -0,0 +1,19 @@
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %target-swift-frontend -emit-module -module-name Foundation -o %t/Foundation.swiftmodule %S/Inputs/Foundation-with-NSError.swift
+// RUN: %target-swift-frontend -I %t -typecheck -verify %s
+// UNSUPPORTED: objc_interop
+
+import Foundation
+
+// Catching `as NSError` ought *not* to be exhaustive when ObjC interop is
+// disabled. It's just another error type.
+
+func bar() throws {}
+
+func foo() {
+  do {
+    try bar() // expected-error{{enclosing catch is not exhaustive}}
+  } catch _ as NSError {
+  }
+}
diff --git a/test/stmt/errors_objc.swift b/test/stmt/errors_objc.swift
new file mode 100644
index 0000000..42caa10
--- /dev/null
+++ b/test/stmt/errors_objc.swift
@@ -0,0 +1,14 @@
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify %s
+// REQUIRES: objc_interop
+
+import Foundation
+
+// Catching `as NSError` ought to be exhaustive when ObjC interop is enabled.
+func bar() throws {}
+
+func foo() {
+  do {
+    try bar()
+  } catch _ as NSError {
+  }
+}
diff --git a/test/stmt/statements.swift b/test/stmt/statements.swift
index b33944c..f927ee7 100644
--- a/test/stmt/statements.swift
+++ b/test/stmt/statements.swift
@@ -247,7 +247,7 @@
 
 func brokenSwitch(_ x: Int) -> Int {
   switch x {
-  case .Blah(var rep): // expected-error{{enum case 'Blah' not found in type 'Int'}}
+  case .Blah(var rep): // expected-error{{pattern cannot match values of type 'Int'}}
     return rep
   }
 }
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftIndexing.cpp b/tools/SourceKit/lib/SwiftLang/SwiftIndexing.cpp
index 8e3d9aa..f9256f0 100644
--- a/tools/SourceKit/lib/SwiftLang/SwiftIndexing.cpp
+++ b/tools/SourceKit/lib/SwiftLang/SwiftIndexing.cpp
@@ -65,6 +65,8 @@
   }
 
   Action startSourceEntity(const IndexSymbol &symbol) override {
+    if (symbol.symInfo.Kind == SymbolKind::Parameter)
+      return Skip;
 
     // report any parent relations to this reference
     if (symbol.roles & (SymbolRoleSet)SymbolRole::RelationBaseOf) {
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
index 31e8986..765dd8e 100644
--- a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
+++ b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
@@ -724,8 +724,6 @@
 
   DelayedStringRetriever OverUSRsStream(SS);
 
-  SmallVector<std::pair<unsigned, unsigned>, 4> OverUSROffs;
-
   ide::walkOverriddenDecls(VD,
     [&](llvm::PointerUnion<const ValueDecl*, const clang::NamedDecl*> D) {
       OverUSRsStream.startPiece();
diff --git a/tools/sil-opt/SILOpt.cpp b/tools/sil-opt/SILOpt.cpp
index 03ac94c..12a4da6 100644
--- a/tools/sil-opt/SILOpt.cpp
+++ b/tools/sil-opt/SILOpt.cpp
@@ -240,6 +240,8 @@
   Invocation.getLangOptions().DisableAvailabilityChecking = true;
   Invocation.getLangOptions().EnableAccessControl = false;
   Invocation.getLangOptions().EnableObjCAttrRequiresFoundation = false;
+  Invocation.getLangOptions().EnableObjCInterop =
+    llvm::Triple(Target).isOSDarwin();
 
   Invocation.getLangOptions().ASTVerifierProcessCount =
       ASTVerifierProcessCount;
diff --git a/tools/swift-syntax-format/swift-syntax-format.cpp b/tools/swift-syntax-format/swift-syntax-format.cpp
index 5ceed50..4d41650 100644
--- a/tools/swift-syntax-format/swift-syntax-format.cpp
+++ b/tools/swift-syntax-format/swift-syntax-format.cpp
@@ -1,4 +1,4 @@
-//===--- swift-syntax-test.cpp - Reflection Syntax testing application ----===//
+//===--- swift-syntax-format.cpp - Reflection Syntax testing application --===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/unittests/Syntax/CMakeLists.txt b/unittests/Syntax/CMakeLists.txt
index bdb109f..d812d93 100644
--- a/unittests/Syntax/CMakeLists.txt
+++ b/unittests/Syntax/CMakeLists.txt
@@ -6,7 +6,9 @@
   StmtSyntaxTests.cpp
   ThreadSafeCachingTests.cpp
   TriviaTests.cpp
-  TypeSyntaxTests.cpp)
+  TypeSyntaxTests.cpp
+  UnknownSyntaxTests.cpp
+  )
 
 target_link_libraries(SwiftSyntaxTests
   swiftSyntax)
diff --git a/unittests/Syntax/ExprSyntaxTests.cpp b/unittests/Syntax/ExprSyntaxTests.cpp
index 4be2a07..ae95b65 100644
--- a/unittests/Syntax/ExprSyntaxTests.cpp
+++ b/unittests/Syntax/ExprSyntaxTests.cpp
@@ -9,3 +9,480 @@
 #pragma mark - integer-literal-expression
 
 // TODO
+
+#pragma mark - symbolic-reference
+
+TEST(ExprSyntaxTests, SymbolicReferenceExprGetAPIs) {
+  {
+    auto Array = SyntaxFactory::makeIdentifier("Array", {}, {});
+    auto IntType = SyntaxFactory::makeTypeIdentifier("Int", {}, {});
+    GenericArgumentClauseBuilder ArgBuilder;
+    ArgBuilder
+      .useLeftAngleBracket(SyntaxFactory::makeLeftAngleToken({}, {}))
+      .useRightAngleBracket(SyntaxFactory::makeRightAngleToken({}, {}))
+      .addGenericArgument(llvm::None, IntType);
+
+    auto GenericArgs = ArgBuilder.build();
+
+    auto Ref = SyntaxFactory::makeSymbolicReferenceExpr(Array, GenericArgs);
+
+    ASSERT_EQ(Ref.getIdentifier(), Array);
+
+    auto GottenArgs = Ref.getGenericArgumentClause().getValue();
+    auto GottenArgs2 = Ref.getGenericArgumentClause().getValue();
+    ASSERT_TRUE(GottenArgs.hasSameIdentityAs(GottenArgs2));
+
+    {
+      llvm::SmallString<48> Scratch;
+      llvm::raw_svector_ostream OS(Scratch);
+      GottenArgs.print(OS);
+      ASSERT_EQ(OS.str().str(), "<Int>");
+    }
+  }
+}
+
+TEST(ExprSyntaxTests, SymbolicReferenceExprMakeAPIs) {
+  auto Array = SyntaxFactory::makeIdentifier("Array", {}, {});
+  auto IntType = SyntaxFactory::makeTypeIdentifier("Int", {}, {});
+  GenericArgumentClauseBuilder ArgBuilder;
+  ArgBuilder
+    .useLeftAngleBracket(SyntaxFactory::makeLeftAngleToken({}, {}))
+    .useRightAngleBracket(SyntaxFactory::makeRightAngleToken({}, {}))
+    .addGenericArgument(llvm::None, IntType);
+  auto GenericArgs = ArgBuilder.build();
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankSymbolicReferenceExpr().print(OS);
+    EXPECT_EQ(OS.str().str(), "");
+  }
+
+  {
+    auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto BlankArgs = SyntaxFactory::makeBlankGenericArgumentClause();
+
+    SyntaxFactory::makeSymbolicReferenceExpr(Foo, BlankArgs).print(OS);
+    EXPECT_EQ(OS.str().str(), "foo");
+  }
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeSymbolicReferenceExpr(Array, GenericArgs).print(OS);
+    ASSERT_EQ(OS.str().str(), "Array<Int>");
+  }
+}
+
+TEST(ExprSyntaxTests, SymbolicReferenceExprWithAPIs) {
+  auto Array = SyntaxFactory::makeIdentifier("Array", {}, {});
+  auto IntType = SyntaxFactory::makeTypeIdentifier("Int", {}, {});
+  GenericArgumentClauseBuilder ArgBuilder;
+  ArgBuilder
+    .useLeftAngleBracket(SyntaxFactory::makeLeftAngleToken({}, {}))
+    .useRightAngleBracket(SyntaxFactory::makeRightAngleToken({}, {}))
+    .addGenericArgument(llvm::None, IntType);
+  auto GenericArgs = ArgBuilder.build();
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankSymbolicReferenceExpr()
+      .withIdentifier(Array)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "Array");
+  }
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankSymbolicReferenceExpr()
+      .withGenericArgumentClause(GenericArgs)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "<Int>");
+  }
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankSymbolicReferenceExpr()
+      .withIdentifier(Array)
+      .withGenericArgumentClause(GenericArgs)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "Array<Int>");
+  }
+}
+
+#pragma mark - function-call-argument
+
+TEST(ExprSyntaxTests, FunctionCallArgumentGetAPIs) {
+  auto X = SyntaxFactory::makeIdentifier("x", {}, {});
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+
+  {
+    auto Arg = SyntaxFactory::makeFunctionCallArgument(X, Colon, SymbolicRef,
+                                                       Comma);
+
+    ASSERT_EQ(X, Arg.getLabel());
+    ASSERT_EQ(Colon, Arg.getColonToken());
+
+    auto GottenExpr = Arg.getExpression().getValue();
+    auto GottenExpr2 = Arg.getExpression().getValue();
+    ASSERT_TRUE(GottenExpr.hasSameIdentityAs(GottenExpr2));
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    GottenExpr.print(OS);
+    ASSERT_EQ("foo", OS.str().str());
+
+    ASSERT_EQ(Comma, Arg.getTrailingComma());
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallArgumentMakeAPIs) {
+  auto X = SyntaxFactory::makeIdentifier("x", {}, {});
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallArgument().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallArgument()
+      .withExpression(SymbolicRef).print(OS);
+    ASSERT_EQ(OS.str().str(), "foo");
+  }
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeFunctionCallArgument(X, Colon, SymbolicRef, Comma)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "x: foo, ");
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallArgumentWithAPIs) {
+  auto X = SyntaxFactory::makeIdentifier("x", {}, {});
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallArgument()
+      .withLabel(X)
+      .withColonToken(Colon)
+      .withExpression(SymbolicRef)
+      .withTrailingComma(Comma)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "x: foo, ");
+  }
+}
+
+#pragma mark - function-call-argument-list
+
+namespace {
+FunctionCallArgumentListSyntax getFullArgumentList() {
+  auto X = SyntaxFactory::makeIdentifier("x", {}, {});
+  auto Y = SyntaxFactory::makeIdentifier("y", {}, {});
+  auto Z = SyntaxFactory::makeIdentifier("z", {}, {});
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+
+  auto Arg = SyntaxFactory::makeFunctionCallArgument(X, Colon, SymbolicRef,
+                                                     Comma);
+
+  return SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .withAdditionalArgument(Arg)
+    .withAdditionalArgument(Arg.withLabel(Y))
+    .withAdditionalArgument(Arg.withLabel(Z).withTrailingComma(NoComma));
+}
+
+FunctionCallArgumentListSyntax getLabellessArgumentList() {
+  auto NoSign = TokenSyntax::missingToken(tok::oper_prefix, "");
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto TwoDigits = SyntaxFactory::makeIntegerLiteralToken("2", {}, {});
+  auto ThreeDigits = SyntaxFactory::makeIntegerLiteralToken("3", {}, {});
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(NoSign, OneDigits);
+  auto NoLabel = TokenSyntax::missingToken(tok::identifier, "");
+  auto NoColon = TokenSyntax::missingToken(tok::colon, ":");
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+  auto Two = SyntaxFactory::makeIntegerLiteralExpr(NoSign, TwoDigits);
+  auto Three = SyntaxFactory::makeIntegerLiteralExpr(NoSign, ThreeDigits);
+
+  auto OneArg = SyntaxFactory::makeFunctionCallArgument(NoLabel, NoColon, One,
+                                                        Comma);
+  auto TwoArg = SyntaxFactory::makeFunctionCallArgument(NoLabel, NoColon, Two,
+                                                        Comma);
+  auto ThreeArg = SyntaxFactory::makeFunctionCallArgument(NoLabel, NoColon,
+                                                          Three, NoComma);
+
+  return SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .withAdditionalArgument(OneArg)
+    .withAdditionalArgument(TwoArg)
+    .withAdditionalArgument(ThreeArg);
+}
+}
+
+TEST(ExprSyntaxTests, FunctionCallArgumentListGetAPIs) {
+  auto X = SyntaxFactory::makeIdentifier("x", {}, {});
+  auto Y = SyntaxFactory::makeIdentifier("y", {}, {});
+  auto Z = SyntaxFactory::makeIdentifier("z", {}, {});
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+
+  auto Arg = SyntaxFactory::makeFunctionCallArgument(X, Colon, SymbolicRef,
+                                                     Comma);
+
+  auto ArgList = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .withAdditionalArgument(Arg)
+    .withAdditionalArgument(Arg.withLabel(Y))
+    .withAdditionalArgument(Arg.withLabel(Z).withTrailingComma(NoComma));
+
+  ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+
+  {
+    llvm::SmallString<16> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto GottenArg1 = ArgList.getArgument(0);
+    auto GottenArg1_2 = ArgList.getArgument(0);
+    ASSERT_TRUE(GottenArg1.hasSameIdentityAs(GottenArg1_2));
+    GottenArg1.print(OS);
+    ASSERT_EQ(OS.str().str(), "x: foo, ");
+  }
+
+  {
+    llvm::SmallString<16> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto GottenArg2 = ArgList.getArgument(1);
+    auto GottenArg2_2 = ArgList.getArgument(1);
+    ASSERT_TRUE(GottenArg2.hasSameIdentityAs(GottenArg2_2));
+    GottenArg2.print(OS);
+    ASSERT_EQ(OS.str().str(), "y: foo, ");
+  }
+
+  {
+    llvm::SmallString<16> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto GottenArg3 = ArgList.getArgument(2);
+    auto GottenArg3_2 = ArgList.getArgument(2);
+    ASSERT_TRUE(GottenArg3.hasSameIdentityAs(GottenArg3_2));
+    GottenArg3.print(OS);
+    ASSERT_EQ(OS.str().str(), "z: foo");
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallArgumentListMakeAPIs) {
+  {
+    llvm::SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallArgumentList().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+    auto X = SyntaxFactory::makeIdentifier("x", {}, {});
+    auto Y = SyntaxFactory::makeIdentifier("y", {}, {});
+    auto Z = SyntaxFactory::makeIdentifier("z", {}, {});
+    auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+    auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+    auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo,
+                                                                llvm::None);
+    auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+    auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+
+    auto Arg = SyntaxFactory::makeFunctionCallArgument(X, Colon, SymbolicRef,
+                                                       Comma);
+
+    std::vector<FunctionCallArgumentSyntax> Args {
+      Arg, Arg.withLabel(Y), Arg.withLabel(Z).withTrailingComma(NoComma)
+    };
+
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto ArgList = SyntaxFactory::makeFunctionCallArgumentList(Args);
+    ArgList.print(OS);
+    ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+    ASSERT_EQ(OS.str().str(), "x: foo, y: foo, z: foo");
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallArgumentListWithAPIs) {
+  auto ArgList = getFullArgumentList();
+  llvm::SmallString<64> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+  ArgList.print(OS);
+  ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+  ASSERT_EQ(OS.str().str(), "x: foo, y: foo, z: foo");
+}
+
+#pragma mark - function-call-expression
+
+TEST(ExprSyntaxTests, FunctionCallExprGetAPIs) {
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto LeftParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto ArgList = getFullArgumentList();
+  auto RightParen = SyntaxFactory::makeRightParenToken({}, {});
+
+  auto Call = SyntaxFactory::makeFunctionCallExpr(SymbolicRef, LeftParen,
+                                                  ArgList, RightParen);
+
+  {
+    auto GottenExpression1 = Call.getCalledExpression();
+    auto GottenExpression2 = Call.getCalledExpression();
+    ASSERT_TRUE(GottenExpression1.hasSameIdentityAs(GottenExpression2));
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    GottenExpression1.print(OS);
+    ASSERT_EQ(OS.str().str(), "foo");
+  }
+
+  ASSERT_EQ(LeftParen, Call.getLeftParen());
+  ASSERT_EQ(RightParen, Call.getRightParen());
+
+  {
+    auto GottenArgs1 = Call.getArgumentList();
+    auto GottenArgs2 = Call.getArgumentList();
+    ASSERT_TRUE(GottenArgs1.hasSameIdentityAs(GottenArgs2));
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    GottenArgs1.print(OS);
+    ASSERT_EQ(OS.str().str(), "x: foo, y: foo, z: foo");
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallExprMakeAPIs) {
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto LeftParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto ArgList = getFullArgumentList();
+  auto RightParen = SyntaxFactory::makeRightParenToken({}, {});
+
+  {
+    auto Call = SyntaxFactory::makeFunctionCallExpr(SymbolicRef, LeftParen,
+                                                    ArgList, RightParen);
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    Call.print(OS);
+    ASSERT_EQ(OS.str().str(), "foo(x: foo, y: foo, z: foo)");
+  }
+
+  {
+    llvm::SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallExpr().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallExprWithAPIs) {
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+  auto LeftParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto ArgList = getFullArgumentList();
+  auto RightParen = SyntaxFactory::makeRightParenToken({}, {});
+
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallExpr()
+      .withCalledExpression(SymbolicRef)
+      .withLeftParen(LeftParen)
+      .withRightParen(RightParen)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "foo()");
+  }
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallExpr()
+      .withCalledExpression(SymbolicRef)
+      .withLeftParen(LeftParen)
+      .withArgumentList(getLabellessArgumentList())
+      .withRightParen(RightParen)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "foo(1, 2, 3)");
+  }
+}
+
+TEST(ExprSyntaxTests, FunctionCallExprBuilderAPIs) {
+  FunctionCallExprSyntaxBuilder CallBuilder;
+
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    CallBuilder.build().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+
+  auto LeftParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto RightParen = SyntaxFactory::makeRightParenToken({}, {});
+
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    CallBuilder.useLeftParen(LeftParen);
+    CallBuilder.useRightParen(RightParen);
+    CallBuilder.build().print(OS);
+    ASSERT_EQ(OS.str().str(), "()");
+  }
+
+  auto NoSign = TokenSyntax::missingToken(tok::oper_prefix, "");
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto TwoDigits = SyntaxFactory::makeIntegerLiteralToken("2", {}, {});
+  auto ThreeDigits = SyntaxFactory::makeIntegerLiteralToken("3", {}, {});
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(NoSign, OneDigits);
+  auto NoLabel = TokenSyntax::missingToken(tok::identifier, "");
+  auto NoColon = TokenSyntax::missingToken(tok::colon, ":");
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto SymbolicRef = SyntaxFactory::makeSymbolicReferenceExpr(Foo, llvm::None);
+
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    CallBuilder.useCalledExpression(SymbolicRef);
+    CallBuilder.build().print(OS);
+    ASSERT_EQ(OS.str().str(), "foo()");
+  }
+
+  auto OneArg = SyntaxFactory::makeFunctionCallArgument(NoLabel, NoColon, One,
+                                                        Comma);
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    CallBuilder.appendArgument(OneArg);
+    CallBuilder.build().print(OS);
+    ASSERT_EQ(OS.str().str(), "foo(1, )");
+  }
+
+  {
+    llvm::SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    CallBuilder.appendArgument(OneArg.withTrailingComma(NoComma));
+    CallBuilder.build().print(OS);
+    ASSERT_EQ(OS.str().str(), "foo(1, 1)");
+  }
+}
diff --git a/unittests/Syntax/ThreadSafeCachingTests.cpp b/unittests/Syntax/ThreadSafeCachingTests.cpp
index 9718330..d4e55b1 100644
--- a/unittests/Syntax/ThreadSafeCachingTests.cpp
+++ b/unittests/Syntax/ThreadSafeCachingTests.cpp
@@ -4,18 +4,78 @@
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
+#include <future>
 #include <thread>
+#include <queue>
 
 using namespace swift;
 using namespace swift::syntax;
 
-static void getExpressionFrom(ReturnStmtSyntax Return,
-                              uintptr_t *DataPointer) {
+static uintptr_t getExpressionFrom(ReturnStmtSyntax Return) {
   auto Expression = Return.getExpression().getValue();
-  auto Data = Expression.getDataPointer();
-  *DataPointer = reinterpret_cast<uintptr_t>(Data);
+  return reinterpret_cast<uintptr_t>(Expression.getDataPointer());
 }
 
+class Pool {
+  static constexpr size_t NumThreads = 2;
+  using FuncTy = std::function<uintptr_t(ReturnStmtSyntax)>;
+  std::vector<std::thread> Workers;
+  std::queue<std::function<void()>> Tasks;
+  std::mutex QueueLock;
+  std::condition_variable Condition;
+  bool Stop;
+
+public:
+  Pool() : Stop(false) {
+    for(size_t i = 0; i < NumThreads; ++i)
+      Workers.emplace_back([this] {
+        while (true) {
+          std::function<void()> Task;
+          {
+            std::unique_lock<std::mutex> L(QueueLock);
+
+            Condition.wait(L, [this]{
+              return Stop || !Tasks.empty();
+            });
+
+            if(Stop && Tasks.empty()) {
+              return;
+            }
+
+            Task = std::move(Tasks.front());
+            Tasks.pop();
+          }
+
+          Task();
+        }
+      });
+  }
+
+  std::future<uintptr_t> run(FuncTy Func, ReturnStmtSyntax Return) {
+    auto Task = std::make_shared<std::packaged_task<uintptr_t()>>(
+      std::bind(Func, Return));
+
+    auto Future = Task->get_future();
+    {
+      std::unique_lock<std::mutex> L(QueueLock);
+      Tasks.emplace([Task](){ (*Task)(); });
+    }
+    Condition.notify_one();
+    return Future;
+  }
+
+  ~Pool() {
+    {
+      std::lock_guard<std::mutex> L(QueueLock);
+      Stop = true;
+    }
+    Condition.notify_all();
+    for(auto &Worker : Workers) {
+      Worker.join();
+    }
+  }
+};
+
 // Tests that, when multiple threads ask for a child node of the same syntax
 // node:
 // - Only one thread inserts the realized child into the parent
@@ -26,29 +86,22 @@
   auto One = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
   auto MinusOne = SyntaxFactory::makeIntegerLiteralExpr(Minus, One);
 
+  Pool P;
+
   for (unsigned i = 0; i < 10000; ++i) {
-    llvm::SmallString<48> Scratch;
-    llvm::raw_svector_ostream OS(Scratch);
     auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne);
 
-    uintptr_t FirstDataPointer;
-    uintptr_t SecondDataPointer;
+    auto Future1 = P.run(getExpressionFrom, Return);
+    auto Future2 = P.run(getExpressionFrom, Return);
 
-    std::thread first(getExpressionFrom, Return, &FirstDataPointer);
-    std::thread second(getExpressionFrom, Return, &SecondDataPointer);
-    first.join();
-    second.join();
+    auto FirstDataPointer = Future1.get();
+    auto SecondDataPointer = Future2.get();
 
     auto DataPointer = reinterpret_cast<uintptr_t>(
       Return.getExpression().getValue().getDataPointer());
 
     ASSERT_EQ(FirstDataPointer, SecondDataPointer);
     ASSERT_EQ(FirstDataPointer, DataPointer);
-
-    if (FirstDataPointer != SecondDataPointer ||
-        FirstDataPointer != DataPointer) {
-      break;
-    }
   }
 }
 
diff --git a/unittests/Syntax/TriviaTests.cpp b/unittests/Syntax/TriviaTests.cpp
index beca54f..3890cdc 100644
--- a/unittests/Syntax/TriviaTests.cpp
+++ b/unittests/Syntax/TriviaTests.cpp
@@ -255,9 +255,9 @@
 }
 
 TEST(TriviaTests, size) {
-  ASSERT_EQ(Trivia().size(), 0);
-  ASSERT_EQ(Trivia::spaces(1).size(), 1);
+  ASSERT_EQ(Trivia().size(), size_t(0));
+  ASSERT_EQ(Trivia::spaces(1).size(), size_t(1));
 
   // Trivia doesn't currently coalesce on its own.
-  ASSERT_EQ((Trivia::spaces(1) + Trivia::spaces(1)).size(), 2);
+  ASSERT_EQ((Trivia::spaces(1) + Trivia::spaces(1)).size(), size_t(2));
 }
diff --git a/unittests/Syntax/UnknownSyntaxTests.cpp b/unittests/Syntax/UnknownSyntaxTests.cpp
new file mode 100644
index 0000000..9173e51
--- /dev/null
+++ b/unittests/Syntax/UnknownSyntaxTests.cpp
@@ -0,0 +1,191 @@
+#include "swift/Syntax/ExprSyntax.h"
+#include "swift/Syntax/GenericSyntax.h"
+#include "swift/Syntax/SyntaxFactory.h"
+#include "swift/Syntax/UnknownSyntax.h"
+#include "llvm/ADT/SmallString.h"
+#include "gtest/gtest.h"
+
+using llvm::None;
+using llvm::SmallString;
+
+using namespace swift;
+using namespace swift::syntax;
+
+SymbolicReferenceExprSyntax getCannedSymbolicRef() {
+  // First, make a symbolic reference to an 'Array<Int>'
+  auto Array = SyntaxFactory::makeIdentifier("Array", {}, {});
+  auto IntType = SyntaxFactory::makeTypeIdentifier("Int", {}, {});
+  GenericArgumentClauseBuilder ArgBuilder;
+  ArgBuilder
+    .useLeftAngleBracket(SyntaxFactory::makeLeftAngleToken({}, {}))
+    .useRightAngleBracket(SyntaxFactory::makeRightAngleToken({}, {}))
+    .addGenericArgument(llvm::None, IntType);
+
+  return SyntaxFactory::makeSymbolicReferenceExpr(Array, ArgBuilder.build());
+}
+
+FunctionCallExprSyntax getCannedFunctionCall() {
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto RParen = SyntaxFactory::makeRightParenToken({}, {});
+
+  auto Label = SyntaxFactory::makeIdentifier("elements", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto NoSign = TokenSyntax::missingToken(tok::oper_prefix, "");
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(NoSign, OneDigits);
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+
+  auto Arg = SyntaxFactory::makeFunctionCallArgument(Label, Colon, One,
+                                                     NoComma);
+  auto Args = SyntaxFactory::makeFunctionCallArgumentList({ Arg });
+
+  return SyntaxFactory::makeFunctionCallExpr(getCannedSymbolicRef(), LParen,
+                                             Args, RParen);
+}
+
+TEST(UnknownSyntaxTests, UnknownSyntaxMakeAPIs) {
+  {
+    auto SymbolicRef = getCannedSymbolicRef();
+
+    // Print the known symbolic reference. It should print as "Array<Int>".
+    SmallString<48> KnownScratch;
+    llvm::raw_svector_ostream KnownOS(KnownScratch);
+    SymbolicRef.print(KnownOS);
+    ASSERT_EQ(KnownOS.str().str(), "Array<Int>");
+
+    // Wrap that symbolic reference as an UnknownSyntax. This has the same
+    // RawSyntax layout but with the Unknown Kind.
+    auto UnknownSymbolicRefData = UnknownSyntaxData::make(SymbolicRef.getRaw());
+
+    auto Unknown = UnknownSyntax {
+      UnknownSymbolicRefData,
+      UnknownSymbolicRefData.get()
+    };
+
+    // Print the unknown syntax. It should also print as "Array<Int>".
+    SmallString<48> UnknownScratch;
+    llvm::raw_svector_ostream UnknownOS(UnknownScratch);
+    Unknown.print(UnknownOS);
+
+    ASSERT_EQ(KnownOS.str().str(), UnknownOS.str().str());
+  }
+}
+
+TEST(UnknownSyntaxTests, UnknownSyntaxGetAPIs) {
+  auto Call = getCannedFunctionCall();
+
+  // Function call child 0 -> layout child 0 -> called expression
+  {
+    // Pull the called expression from the function call, which should print
+    // as "Array<Int>"
+    SmallString<48> KnownScratch;
+    llvm::raw_svector_ostream KnownOS(KnownScratch);
+    auto GottenExpr = Call.getCalledExpression();
+    GottenExpr.print(KnownOS);
+
+    // Wrap that call as an UnknownExprSyntax. This has the same
+    // RawSyntax layout but with the UnknownExpr Kind.
+    auto UnknownCallData = UnknownExprSyntaxData::make(Call.getRaw());
+
+    auto Unknown = UnknownExprSyntax {
+      UnknownCallData,
+      UnknownCallData.get()
+    };
+
+    ASSERT_EQ(Unknown.getNumChildren(), size_t(2));
+
+    // Get the second child from the unknown call, which is the argument list.
+    // This should print the same as the known one: "elements: 1"
+    SmallString<48> UnknownScratch;
+    llvm::raw_svector_ostream UnknownOS(UnknownScratch);
+    auto ExprGottenFromUnknown = Unknown.getChild(0)
+      .castTo<SymbolicReferenceExprSyntax>();
+    ExprGottenFromUnknown.print(UnknownOS);
+
+    ASSERT_EQ(KnownOS.str().str(), UnknownOS.str().str());
+
+    auto ExprGottenFromUnknown2 = Unknown.getChild(0);
+    ASSERT_TRUE(ExprGottenFromUnknown
+                .hasSameIdentityAs(ExprGottenFromUnknown2));
+  }
+
+  // Function call child 1 -> layout child 2 -> function call argument list
+  {
+    // Pull the argument list from the function call, which should print
+    // as "elements: 1"
+    SmallString<48> KnownScratch;
+    llvm::raw_svector_ostream KnownOS(KnownScratch);
+    auto GottenArgs = Call.getArgumentList();
+    GottenArgs.print(KnownOS);
+
+    // Wrap that symbolic reference as an UnknownSyntax. This has the same
+    // RawSyntax layout but with the Unknown Kind.
+    auto UnknownCallData = UnknownSyntaxData::make(Call.getRaw());
+
+    auto Unknown = UnknownSyntax {
+      UnknownCallData,
+      UnknownCallData.get()
+    };
+
+    ASSERT_EQ(Unknown.getNumChildren(), size_t(2));
+
+    // Get the second child from the unknown call, which is the argument list.
+    // This should print the same as the known one: "elements: 1"
+    SmallString<48> UnknownScratch;
+    llvm::raw_svector_ostream UnknownOS(UnknownScratch);
+    auto ArgsGottenFromUnknown = Unknown.getChild(1)
+      .castTo<FunctionCallArgumentListSyntax>();
+    ArgsGottenFromUnknown.print(UnknownOS);
+
+    ASSERT_EQ(KnownOS.str().str(), UnknownOS.str().str());
+
+    auto ArgsGottenFromUnknown2 = Unknown.getChild(1);
+    ASSERT_TRUE(ArgsGottenFromUnknown
+                  .hasSameIdentityAs(ArgsGottenFromUnknown2));
+  }
+}
+
+TEST(UnknownSyntaxTests, EmbedUnknownExpr) {
+  auto SymbolicRef = getCannedSymbolicRef();
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto RParen = SyntaxFactory::makeRightParenToken({}, {});
+  auto EmptyArgs = SyntaxFactory::makeBlankFunctionCallArgumentList();
+
+  SmallString<48> KnownScratch;
+  llvm::raw_svector_ostream KnownOS(KnownScratch);
+  auto CallWithKnownExpr = SyntaxFactory::makeFunctionCallExpr(SymbolicRef,
+                                                               LParen,
+                                                               EmptyArgs,
+                                                               RParen);
+  CallWithKnownExpr.print(KnownOS);
+
+  // Let's make a function call expression where the called expression is
+  // actually unknown. It should print the same and have the same structure
+  // as one with a known called expression.
+  auto UnknownSymbolicRefData =
+    UnknownExprSyntaxData::make(SymbolicRef.getRaw());
+
+  auto UnknownSymbolicRef = UnknownExprSyntax {
+    UnknownSymbolicRefData,
+    UnknownSymbolicRefData.get()
+  }.castTo<ExprSyntax>();
+
+  SmallString<48> UnknownScratch;
+  llvm::raw_svector_ostream UnknownOS(UnknownScratch);
+
+  auto CallWithUnknownExpr = CallWithKnownExpr
+    .withCalledExpression(UnknownSymbolicRef);
+
+  CallWithUnknownExpr.print(UnknownOS);
+
+  ASSERT_EQ(KnownOS.str().str(), UnknownOS.str().str());
+}
+
+TEST(UnknownSyntaxTests, EmbedUnknownDecl) {
+  // TODO
+}
+
+TEST(UnknownSyntaxTests, EmbedUnknownStmt) {
+  // TODO
+}
+
diff --git a/utils/build-presets.ini b/utils/build-presets.ini
index 7ee57ad..2d5b62e 100644
--- a/utils/build-presets.ini
+++ b/utils/build-presets.ini
@@ -188,6 +188,21 @@
 skip-test-tvos-host
 skip-test-watchos-host
 
+[preset: buildbot,tools=RA,stdlib=RD,single-thread]
+mixin-preset=
+    mixin_buildbot_tools_RA_stdlib_RD
+
+dash-dash
+
+# Enable non-atomic build of the stdlib
+swift-stdlib-use-nonatomic-rc=true
+
+# Don't run host tests for iOS, tvOS and watchOS platforms to make the build
+# faster.
+skip-test-ios-host
+skip-test-tvos-host
+skip-test-watchos-host
+
 [preset: buildbot,tools=R,stdlib=RD]
 mixin-preset=
     mixin_buildbot_tools_R_stdlib_RD
diff --git a/utils/build-script-impl b/utils/build-script-impl
index 9f832ab..c1e12b2 100755
--- a/utils/build-script-impl
+++ b/utils/build-script-impl
@@ -71,6 +71,7 @@
     swift-stdlib-build-type     "Debug"          "the CMake build variant for Swift"
     swift-stdlib-enable-assertions "1"           "enable assertions in Swift"
     swift-stdlib-enable-resilience "0"           "build the Swift stdlib and overlays with resilience enabled"
+    swift-stdlib-use-nonatomic-rc "0"            "build the Swift stdlib and overlays with nonatomic reference count operations enabled"
     swift-stdlib-sil-serialize-all "1"           "build the Swift stdlib and overlays with all method bodies serialized"
     lldb-build-type             "Debug"          "the CMake build variant for LLDB"
     llbuild-build-type          "Debug"          "the CMake build variant for llbuild"
@@ -1654,6 +1655,9 @@
     if [[ $(is_cmake_release_build_type "${SWIFT_BUILD_TYPE}") ]] ; then
         echo -n " -fno-stack-protector"
     fi
+    if [[ "$(true_false "${SWIFT_STDLIB_USE_NONATOMIC_RC}")" == "TRUE" ]]; then
+        echo -n " -DSWIFT_STDLIB_USE_NONATOMIC_RC"
+    fi
 }
 
 function cmake_config_opt() {
@@ -2113,6 +2117,7 @@
                     -DSWIFT_STDLIB_BUILD_TYPE:STRING="${SWIFT_STDLIB_BUILD_TYPE}"
                     -DSWIFT_STDLIB_ASSERTIONS:BOOL=$(true_false "${SWIFT_STDLIB_ENABLE_ASSERTIONS}")
                     -DSWIFT_STDLIB_ENABLE_RESILIENCE:BOOL=$(true_false "${SWIFT_STDLIB_ENABLE_RESILIENCE}")
+                    -DSWIFT_STDLIB_USE_NONATOMIC_RC:BOOL=$(true_false "${SWIFT_STDLIB_USE_NONATOMIC_RC}")
                     -DSWIFT_STDLIB_SIL_SERIALIZE_ALL:BOOL=$(true_false "${SWIFT_STDLIB_SIL_SERIALIZE_ALL}")
                     -DSWIFT_NATIVE_LLVM_TOOLS_PATH:STRING="${native_llvm_tools_path}"
                     -DSWIFT_NATIVE_CLANG_TOOLS_PATH:STRING="${native_clang_tools_path}"
diff --git a/utils/rusage.py b/utils/rusage.py
index b2354f2..e37e359 100755
--- a/utils/rusage.py
+++ b/utils/rusage.py
@@ -91,7 +91,7 @@
 args = parser.parse_args()
 if len(args.remainder) == 0:
     parser.print_help()
-    exit(1)
+    sys.exit(1)
 
 if args.enforce:
     if args.time is not None:
diff --git a/utils/sil-mode.el b/utils/sil-mode.el
index 371d66a..6d390d0 100644
--- a/utils/sil-mode.el
+++ b/utils/sil-mode.el
@@ -51,7 +51,7 @@
                     font-lock-keyword-face)
 
    ;; Highlight attributes written in [...].
-   '("\\[\\(.+\\)\\]" 1 font-lock-keyword-face)
+   '("\\[\\(.+?\\)\\]" 1 font-lock-keyword-face)
 
    ;; SIL Instructions - Allocation/Deallocation.
    `(,(regexp-opt '("alloc_stack" "alloc_ref" "alloc_ref_dynamic" "alloc_box"
@@ -121,7 +121,8 @@
    ;; Protocol and Protocol Composition Types
    `(,(regexp-opt '("init_existential_addr" "deinit_existential_addr"
                     "open_existential_addr"
-                    "init_existential_opaque" "open_existential_opaque"
+                    "init_existential_opaque" "deinit_existential_opaque"
+                    "open_existential_opaque"
                     "alloc_existential_box" "project_existential_box"
                     "open_existential_box" "dealloc_existential_box"
                     "init_existential_ref" "open_existential_ref"
diff --git a/utils/swift_build_support/swift_build_support/products/product.py b/utils/swift_build_support/swift_build_support/products/product.py
index f9df4a5..f3f841a 100644
--- a/utils/swift_build_support/swift_build_support/products/product.py
+++ b/utils/swift_build_support/swift_build_support/products/product.py
@@ -26,7 +26,7 @@
 
         The name of the source code directory of this product.
         It provides a customization point for Product subclasses. It is set to
-        the value of product_name() by default for this reason. 
+        the value of product_name() by default for this reason.
         """
         return cls.product_name()
 
diff --git a/utils/vim/syntax/sil.vim b/utils/vim/syntax/sil.vim
index c2bad45..1aea5ad 100644
--- a/utils/vim/syntax/sil.vim
+++ b/utils/vim/syntax/sil.vim
@@ -36,7 +36,7 @@
 syn keyword swiftKeyword metatype value_metatype existential_metatype skipwhite
 syn keyword swiftKeyword retain_value release_value tuple tuple_extract tuple_element_addr struct struct_extract struct_element_addr ref_element_addr skipwhite
 syn keyword swiftKeyword init_enum_data_addr unchecked_enum_data unchecked_take_enum_data_addr inject_enum_addr skipwhite
-syn keyword swiftKeyword init_existential_addr init_existential_opaque init_existential_metatype deinit_existential_addr open_existential_addr open_existential_box open_existential_metatype init_existential_ref open_existential_ref open_existential_opaque skipwhite
+syn keyword swiftKeyword init_existential_addr init_existential_opaque init_existential_metatype deinit_existential_addr deinit_existential_opaque open_existential_addr open_existential_box open_existential_metatype init_existential_ref open_existential_ref open_existential_opaque skipwhite
 syn keyword swiftKeyword upcast address_to_pointer pointer_to_address pointer_to_thin_function unchecked_addr_cast unchecked_ref_cast unchecked_ref_cast_addr ref_to_raw_pointer ref_to_bridge_object ref_to_unmanaged unmanaged_to_ref raw_pointer_to_ref skipwhite
 syn keyword swiftKeyword convert_function thick_to_objc_metatype thin_function_to_pointer objc_to_thick_metatype thin_to_thick_function is_nonnull unchecked_ref_bit_cast unchecked_trivial_bit_cast bridge_object_to_ref bridge_object_to_word unchecked_bitwise_cast skipwhite
 syn keyword swiftKeyword objc_existential_metatype_to_object objc_metatype_to_object objc_protocol skipwhite
diff --git a/validation-test/BuildSystem/LTO/object-files-do-have-bitcode.test-sh b/validation-test/BuildSystem/LTO/object-files-do-have-bitcode.test-sh
index 5d76bf4..67f0c59 100755
--- a/validation-test/BuildSystem/LTO/object-files-do-have-bitcode.test-sh
+++ b/validation-test/BuildSystem/LTO/object-files-do-have-bitcode.test-sh
@@ -13,14 +13,14 @@
 # REQUIRES: OS=macosx
 # RUN: %s %swift_obj_root
 
-if [[ -n "$(find $1/lib -iname '*.cpp.o' -type f -exec file {} \; | grep -v -e bitcode -e bit-code)" ]]; then
+if find $1/lib -iname '*.cpp.o' -type f -exec file {} \; | grep -q -v -e bitcode -e bit-code; then
     echo "Found a ./lib non-bitcode object file!"
     exit 1
 else
     echo "All ./lib object files are bit-code files!"
 fi
 
-if [[ -n "$(find $1/unittests -iname '*.cpp.o' -type f -exec file {} \; | grep -v -e bitcode -e bit-code)" ]]; then
+if find $1/unittests -iname '*.cpp.o' -type f -exec file {} \; | grep -q -v -e bitcode -e bit-code; then
     echo "Found a ./unittests non-bitcode object file!"
     exit 1
 else
diff --git a/validation-test/BuildSystem/LTO/target-libraries-do-not-have-bitcode.test-sh b/validation-test/BuildSystem/LTO/target-libraries-do-not-have-bitcode.test-sh
index 6ce1fd8..5404295 100755
--- a/validation-test/BuildSystem/LTO/target-libraries-do-not-have-bitcode.test-sh
+++ b/validation-test/BuildSystem/LTO/target-libraries-do-not-have-bitcode.test-sh
@@ -34,7 +34,7 @@
     mkdir -p "${LIB_TEMP_DIR}"
     cd "${LIB_TEMP_DIR}"
     ar -x ${ARCHIVE}
-    if [[ -n "$(find ./ -iname '*.o' -exec file {} \; | grep -e bitcode -e bit-code)" ]]; then
+    if find ./ -iname '*.o' -exec file {} \; | grep -q -e bitcode -e bit-code; then
         echo "Found bitcode file in thin archive: ${ARCHIVE}"
         exit 1
     else
@@ -78,7 +78,7 @@
         cd ${arch}
         ar -x "${LIB_ARCHIVE_DIR}/${THIN_ARCHIVE}"
 
-        if [[ -n "$(find ./ -iname '*.o' -exec file {} \; | grep -e bitcode -e bit-code)" ]]; then
+        if find ./ -iname '*.o' -exec file {} \; | grep -q -e bitcode -e bit-code; then
             echo "Found bitcode file in thin archive: ${THIN_ARCHIVE}. Taken from thick archive: ${ARCHIVE}"
             exit 1
         else
diff --git a/validation-test/StdlibUnittest/RaceTest.swift b/validation-test/StdlibUnittest/RaceTest.swift
index a63fd18..53c0e2c 100644
--- a/validation-test/StdlibUnittest/RaceTest.swift
+++ b/validation-test/StdlibUnittest/RaceTest.swift
@@ -1,5 +1,6 @@
 // RUN: %target-build-swift -Xfrontend -disable-access-control -module-name a %s -o %t.out
 // RUN: %target-run %t.out | %FileCheck %s
+// UNSUPPORTED: nonatomic_rc
 
 import StdlibUnittest
 #if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
diff --git a/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift b/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift
new file mode 100644
index 0000000..479b7b8
--- /dev/null
+++ b/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift
@@ -0,0 +1,9 @@
+// This source file is part of the Swift.org open source project
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+{extension{func 丏(UInt=1 + 1 + 1 as?Int){a
diff --git a/validation-test/compiler_crashers/28703-swift-typebase-getdesugaredtype.swift b/validation-test/compiler_crashers/28703-swift-typebase-getdesugaredtype.swift
new file mode 100644
index 0000000..e4d7ab4
--- /dev/null
+++ b/validation-test/compiler_crashers/28703-swift-typebase-getdesugaredtype.swift
@@ -0,0 +1,9 @@
+// This source file is part of the Swift.org open source project
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+func b(UInt=1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 as?Int){a
diff --git a/validation-test/compiler_crashers/28704-swift-newmangling-astmangler-appendcontext-swift-declcontext-const.swift b/validation-test/compiler_crashers/28704-swift-newmangling-astmangler-appendcontext-swift-declcontext-const.swift
new file mode 100644
index 0000000..56a136a
--- /dev/null
+++ b/validation-test/compiler_crashers/28704-swift-newmangling-astmangler-appendcontext-swift-declcontext-const.swift
@@ -0,0 +1,9 @@
+// This source file is part of the Swift.org open source project
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+protocol A{var f={struct ManagedBuffer{var f=(t:f
diff --git a/validation-test/compiler_crashers/28705-swift-typebase-getcanonicaltype.swift b/validation-test/compiler_crashers/28705-swift-typebase-getcanonicaltype.swift
new file mode 100644
index 0000000..2483570
--- /dev/null
+++ b/validation-test/compiler_crashers/28705-swift-typebase-getcanonicaltype.swift
@@ -0,0 +1,13 @@
+// This source file is part of the Swift.org open source project
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+{
+struct c{}func t(UInt= 1 + 1 + 1 + 1 as?Int){
+{{
+protocol P{extension{class C:P{
+protocol defaulImplementation unon
diff --git a/validation-test/compiler_crashers_2/0074-rdar28544316.swift b/validation-test/compiler_crashers_2/0074-rdar28544316.swift
new file mode 100644
index 0000000..f967f8d
--- /dev/null
+++ b/validation-test/compiler_crashers_2/0074-rdar28544316.swift
@@ -0,0 +1,38 @@
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+// REQUIRES: asserts
+
+class PropertyDataSource<O: PropertyHosting> {
+}
+
+protocol TableViewCellFactoryType {
+    associatedtype Item
+}
+
+public protocol PropertyHosting {
+    associatedtype PType: Hashable, EntityOwned
+}
+
+public protocol EntityOwned: class {
+    associatedtype Owner
+}
+
+public protocol PropertyType: class {
+}
+
+func useType<T>(cellType: T.Type) {
+}
+
+final class PropertyTableViewAdapter<Factory: TableViewCellFactoryType>
+    where
+    Factory.Item: PropertyType,
+    Factory.Item.Owner: PropertyHosting,
+    Factory.Item.Owner.PType == Factory.Item
+{
+    typealias Item = Factory.Item
+    
+    let dataManager: PropertyDataSource<Factory.Item.Owner>
+    init(dataManager: PropertyDataSource<Factory.Item.Owner>) {
+      useType(cellType: Factory.Item.Owner.self)
+      self.dataManager = dataManager
+    }
+}
diff --git a/validation-test/compiler_crashers_2/0076-sr3500.swift b/validation-test/compiler_crashers_2/0076-sr3500.swift
new file mode 100644
index 0000000..2a514fe
--- /dev/null
+++ b/validation-test/compiler_crashers_2/0076-sr3500.swift
@@ -0,0 +1,12 @@
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+
+protocol A {
+  associatedtype Coordinate: Strideable
+  func doSomething(_: Range<Coordinate>) -> Coordinate.Stride
+}
+
+extension A where Coordinate == Int {
+  func extensionFunc(_ range: Range<Coordinate>) {
+    _ = doSomething(range)
+  }
+}
diff --git a/validation-test/compiler_crashers_2/0079-rdar30354669.swift b/validation-test/compiler_crashers_2/0079-rdar30354669.swift
new file mode 100644
index 0000000..6dacf98
--- /dev/null
+++ b/validation-test/compiler_crashers_2/0079-rdar30354669.swift
@@ -0,0 +1,30 @@
+// RUN: not --crash %target-swift-frontend -primary-file %s -emit-ir
+
+public func ==<T: EquatableMetaType>(lhs: T, rhs: T) -> Bool {
+    return type(of: lhs) == type(of: lhs)
+}
+
+
+public protocol EquatableMetaType {
+}
+
+
+class Block : Equatable, EquatableMetaType {
+}
+
+extension Array where Element : Block {
+    func indexByType(of: Element) -> Array.Index? {
+        let count = self.count
+        var result: Array.Index = 0
+        
+        for i in self {
+            if i == of {
+                return result
+            }
+            if result < count {
+                result += 1
+            }
+        }
+        return nil
+    }
+}
diff --git a/validation-test/compiler_crashers_2_fixed/0077-sr3884.swift b/validation-test/compiler_crashers_2_fixed/0077-sr3884.swift
new file mode 100644
index 0000000..d50643c
--- /dev/null
+++ b/validation-test/compiler_crashers_2_fixed/0077-sr3884.swift
@@ -0,0 +1,22 @@
+// RUN: %target-swift-frontend %s -emit-ir
+
+protocol DataSourceItem { }
+
+protocol TableDataSourceItem : DataSourceItem { }
+
+
+class DataSource<T : DataSourceItem> { }
+
+class TableDataSource<T : TableDataSourceItem>: DataSource<T> { }
+
+
+class DataSourceBuilder<T : TableDataSourceItem, U : TableDataSource<T>> { }
+
+class TableDataSourceBuilder<T : TableDataSourceItem, U : TableDataSource<T>> : DataSourceBuilder<T, U> { }
+
+
+enum MyItem: TableDataSourceItem { }
+
+class MyBuilder : TableDataSourceBuilder<MyItem, TableDataSource<MyItem>> { }
+
+let builder = MyBuilder()
diff --git a/validation-test/compiler_crashers_2_fixed/0078-sr4059.swift b/validation-test/compiler_crashers_2_fixed/0078-sr4059.swift
new file mode 100644
index 0000000..a073b13
--- /dev/null
+++ b/validation-test/compiler_crashers_2_fixed/0078-sr4059.swift
@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend %s -emit-ir
+
+class Base {
+  init<S: Sequence>(_ s: S) where S.Iterator.Element == UInt8 { }
+}
+
+class Sub: Base {
+  init(_ b: [UInt8]) { super.init(b) }
+}
\ No newline at end of file
diff --git a/validation-test/compiler_crashers_fixed/28445-gp-getouterparameters-proto-getdeclcontext-getgenericparamsofcontext-failed.swift b/validation-test/compiler_crashers_fixed/28445-gp-getouterparameters-proto-getdeclcontext-getgenericparamsofcontext-failed.swift
index 240c285..18fddac 100644
--- a/validation-test/compiler_crashers_fixed/28445-gp-getouterparameters-proto-getdeclcontext-getgenericparamsofcontext-failed.swift
+++ b/validation-test/compiler_crashers_fixed/28445-gp-getouterparameters-proto-getdeclcontext-getgenericparamsofcontext-failed.swift
@@ -6,6 +6,9 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // RUN: not %target-swift-frontend %s -emit-ir
+// FIXME(huonw): where clauses on associatedtypes broke this
+// XFAIL: *
+// REQUIRES: asserts
 class A{let f= <c
 protocol A{
 typealias e:A{}
diff --git a/validation-test/compiler_crashers_fixed/28547-env-dependent-type-in-non-generic-context.swift b/validation-test/compiler_crashers_fixed/28547-env-dependent-type-in-non-generic-context.swift
index 5d170bb..d8533f9 100644
--- a/validation-test/compiler_crashers_fixed/28547-env-dependent-type-in-non-generic-context.swift
+++ b/validation-test/compiler_crashers_fixed/28547-env-dependent-type-in-non-generic-context.swift
@@ -6,5 +6,8 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // RUN: not %target-swift-frontend %s -emit-ir
+// FIXME(huonw): where clauses on associatedtypes broke this
+// XFAIL: *
+// REQUIRES: asserts
 class A:a
 protocol a{typealias B:A.B
diff --git a/validation-test/lit.site.cfg.in b/validation-test/lit.site.cfg.in
index 7c6b75f..9c4fce1 100644
--- a/validation-test/lit.site.cfg.in
+++ b/validation-test/lit.site.cfg.in
@@ -68,6 +68,9 @@
 if "@SWIFT_STDLIB_ENABLE_RESILIENCE@" == "TRUE":
     config.available_features.add("resilient_stdlib")
 
+if "@SWIFT_STDLIB_USE_NONATOMIC_RC@" == "TRUE":
+    config.available_features.add("nonatomic_rc")
+
 if "@CMAKE_GENERATOR@" == "Xcode":
     xcode_bin_dir = os.path.join(config.llvm_obj_root, "@LLVM_BUILD_TYPE@",
                                  'bin')
diff --git a/validation-test/stdlib/ArrayBridging.swift b/validation-test/stdlib/ArrayBridging.swift
index 626fe4c..a6bea01 100644
--- a/validation-test/stdlib/ArrayBridging.swift
+++ b/validation-test/stdlib/ArrayBridging.swift
@@ -9,6 +9,7 @@
 
 // REQUIRES: objc_interop
 // REQUIRES: executable_test
+// UNSUPPORTED: nonatomic_rc
 
 import StdlibUnittest
 import Foundation
diff --git a/validation-test/stdlib/AtomicInt.swift b/validation-test/stdlib/AtomicInt.swift
index 52701c0..b076bce 100644
--- a/validation-test/stdlib/AtomicInt.swift
+++ b/validation-test/stdlib/AtomicInt.swift
@@ -4,6 +4,7 @@
 // RUN: %target-build-swift -module-name a %s -o %t.out -O
 // RUN: %target-run %t.out
 // REQUIRES: executable_test
+// UNSUPPORTED: nonatomic_rc
 
 import SwiftPrivate
 import StdlibUnittest
diff --git a/validation-test/stdlib/DictionaryBridging.swift b/validation-test/stdlib/DictionaryBridging.swift
index 5ca3e25..2dc33e4 100644
--- a/validation-test/stdlib/DictionaryBridging.swift
+++ b/validation-test/stdlib/DictionaryBridging.swift
@@ -8,6 +8,7 @@
 // REQUIRES: executable_test
 
 // REQUIRES: objc_interop
+// UNSUPPORTED: nonatomic_rc
 
 import StdlibUnittest
 import Foundation
diff --git a/validation-test/stdlib/ErrorProtocol.swift b/validation-test/stdlib/ErrorProtocol.swift
index 5c2b557..a62bdf1 100644
--- a/validation-test/stdlib/ErrorProtocol.swift
+++ b/validation-test/stdlib/ErrorProtocol.swift
@@ -1,6 +1,7 @@
 // RUN: %target-run-simple-swift
 // REQUIRES: executable_test
 // REQUIRES: objc_interop
+// UNSUPPORTED: nonatomic_rc
 
 import SwiftPrivate
 import StdlibUnittest