diff --git a/docs/SIL.rst b/docs/SIL.rst
index 6e45602..3b8ad25 100644
--- a/docs/SIL.rst
+++ b/docs/SIL.rst
@@ -84,7 +84,7 @@
   If an arithmetic overflow occurs during the constant expression computation, a diagnostic
   is issued.
 - **Return analysis** verifies that each function returns a value on every
-  code path and doesn't "fall of the end" of its definition, which is an error.
+  code path and doesn't "fall off the end" of its definition, which is an error.
   It also issues an error when a ``noreturn`` function returns.
 - **Critical edge splitting** splits all critical edges from terminators that
   don't support arbitrary basic block arguments (all non cond_branch
diff --git a/include/swift/AST/AvailabilitySpec.h b/include/swift/AST/AvailabilitySpec.h
index 787f819..d5ebba9 100644
--- a/include/swift/AST/AvailabilitySpec.h
+++ b/include/swift/AST/AvailabilitySpec.h
@@ -31,7 +31,7 @@
     /// A platform-version constraint of the form "PlatformName X.Y.Z"
     PlatformVersionConstraint,
 
-    /// A wildcard constraint, spelled '*', that is be equivalent
+    /// A wildcard constraint, spelled '*', that is equivalent
     /// to CurrentPlatformName >= MinimumDeploymentTargetVersion
     OtherPlatform,
 
diff --git a/include/swift/AST/DiagnosticsCommon.def b/include/swift/AST/DiagnosticsCommon.def
index a000471..678d17f 100644
--- a/include/swift/AST/DiagnosticsCommon.def
+++ b/include/swift/AST/DiagnosticsCommon.def
@@ -58,8 +58,6 @@
 // Generic disambiguation
 NOTE(while_parsing_as_left_angle_bracket,none,
      "while parsing this '<' as a type parameter bracket", ())
-NOTE(while_parsing_as_less_operator,none,
-     "while parsing this '<' as an operator", ())
 
 
 // FIXME: This is used both as a parse error (a literal "super" outside a
diff --git a/include/swift/AST/DiagnosticsDriver.def b/include/swift/AST/DiagnosticsDriver.def
index 65d061a..eed9c38 100644
--- a/include/swift/AST/DiagnosticsDriver.def
+++ b/include/swift/AST/DiagnosticsDriver.def
@@ -113,6 +113,10 @@
         "unable to determine when '%0' was last modified: %1",
         (StringRef, StringRef))
 
+WARNING(warn_unable_to_load_dependencies, none,
+        "unable to load dependencies file \"%0\", disabling incremental mode",
+        (StringRef))
+
 ERROR(error_input_changed_during_build,none,
       "input file '%0' was modified during the build",
       (StringRef))
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
index c5e2979..0cc1062 100644
--- a/include/swift/AST/DiagnosticsParse.def
+++ b/include/swift/AST/DiagnosticsParse.def
@@ -448,6 +448,10 @@
       "expected constant in SIL code", ())
 ERROR(referenced_value_no_accessor,none,
       "referenced declaration has no %select{getter|setter}0", (unsigned))
+ERROR(expected_sil_value_ownership_kind,none,
+      "expected value ownership kind in SIL code", ())
+ERROR(expected_sil_colon,none,
+      "expected ':' before %0", (StringRef))
 
 // SIL Values
 ERROR(sil_value_redefinition,none,
@@ -591,6 +595,8 @@
       "sil protocol not found %0", (Identifier))
 ERROR(sil_witness_assoc_not_found,none,
       "sil associated type decl not found %0", (Identifier))
+ERROR(sil_witness_assoc_conf_not_found,none,
+      "sil associated type path for conformance not found %0", (StringRef))
 ERROR(sil_witness_protocol_conformance_not_found,none,
       "sil protocol conformance not found", ())
 
@@ -749,8 +755,6 @@
       "default arguments are not allowed in subscripts", ())
 ERROR(no_default_arg_curried,none,
       "default arguments are not allowed in curried parameter lists", ())
-WARNING(let_on_param_is_redundant, none,
-      "'let' keyword is unnecessary; function parameters are immutable by default", (unsigned))
 ERROR(var_pattern_in_var,none,
       "'%select{var|let}0' cannot appear nested inside another 'var' or "
       "'let' pattern", (unsigned))
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
index 42e442f..221461d 100644
--- a/include/swift/AST/DiagnosticsSema.def
+++ b/include/swift/AST/DiagnosticsSema.def
@@ -45,11 +45,6 @@
 NOTE(extended_type_declared_here,none,
      "extended type declared here", ())
 
-NOTE(while_converting_default_tuple_value,none,
-     "while converting default tuple value to element type %0", (Type))
-NOTE(while_converting_subscript_index,none,
-     "while converting subscript index to expected type %0", (Type))
-
 //------------------------------------------------------------------------------
 // Constraint solver diagnostics
 //------------------------------------------------------------------------------
@@ -915,8 +910,6 @@
       "%select{local function|closure}0 that captures "
       "%select{context|generic parameters|dynamic Self type}1",
       (bool, unsigned))
-NOTE(c_function_pointer_captures_here,none,
-     "%0 captured here", (Identifier))
 
 //------------------------------------------------------------------------------
 // Type Check Declarations
@@ -1508,8 +1501,6 @@
 
 ERROR(redundant_conformance,none,
       "redundant conformance of %0 to protocol %1", (Type, DeclName))
-NOTE(protocol_conformance_implied_here,none,
-     "implied protocol conformance %0 here can be made explicit", (Identifier))
 
 // "Near matches"
 WARNING(optional_req_near_match,none,
@@ -1517,9 +1508,6 @@
         (DescriptiveDeclKind, DeclName, DeclName, DeclName))
 NOTE(optional_req_nonobjc_near_match_add_objc,none,
      "add '@objc' to provide an Objective-C entrypoint", ())
-NOTE(optional_req_nonobjc_to_objc,none,
-     "rename to %0 to satisfy this requirement",
-     (DeclName))
 NOTE(optional_req_near_match_move,none,
      "move %0 to %select{an|another}1 extension to silence this warning",
      (DeclName, unsigned))
@@ -1775,8 +1763,6 @@
       "static declarations are already final", ())
 ERROR(open_decl_cannot_be_final,none,
       "%0 cannot be declared both 'final' and 'open'", (DescriptiveDeclKind))
-NOTE(decl_init_here,none,
-     "initial value is here", ())
 
 
 // Inheritance
@@ -2069,9 +2055,6 @@
 #define SELECT_APPLICATION_MAIN "select{'UIApplicationMain'|'NSApplicationMain'}"
 #define SELECT_APPLICATION_DELEGATE "select{'UIApplicationDelegate'|'NSApplicationDelegate'}"
 
-ERROR(attr_ApplicationMain_not_class,none,
-      "%" SELECT_APPLICATION_MAIN "0 attribute may only be used on classes",
-      (unsigned))
 ERROR(attr_ApplicationMain_not_ApplicationDelegate,none,
       "%" SELECT_APPLICATION_MAIN "0 class must conform to the %" SELECT_APPLICATION_DELEGATE "0 protocol",
       (unsigned))
@@ -2125,17 +2108,7 @@
      "found this candidate", ())
 NOTE(found_candidate_type,none,
      "found candidate with type %0", (Type))
-NOTE(first_declaration,none,
-     "first declaration", ())
-NOTE(second_declaration,none,
-     "second declaration", ())
 
-ERROR(no_IntegerLiteralType_found,none,
-      "standard library error: IntegerLiteralType not defined", ())
-ERROR(no_FloatLiteralType_found,none,
-      "standard library error: FloatLiteralType not defined", ())
-ERROR(no_StringLiteralType_found,none,
-      "standard library error: StringLiteralType not defined", ())
 ERROR(no_MaxBuiltinIntegerType_found,none,
    "standard library error: _MaxBuiltinIntegerType is not properly defined", ())
 ERROR(no_MaxBuiltinFloatType_found,none,
@@ -2241,9 +2214,6 @@
       "'" TRY_KIND_SELECT(0) "' following assignment operator does not cover "
       "everything to its right", (unsigned))
 
-NOTE(subscript_decl_here,none,
-     "subscript operator declared here", ())
-
 ERROR(broken_bool,none, "type 'Bool' is broken", ())
 
 WARNING(inject_forced_downcast,none,
@@ -3465,10 +3435,6 @@
         "%select{variable|parameter}1 %0 was written to, but never read",
         (Identifier, unsigned))
 
-WARNING(extraneous_default_args_in_call, none,
-        "call to %0 has extraneous arguments that could use defaults",
-        (DeclName))
-
 //------------------------------------------------------------------------------
 // Circular reference diagnostics
 //------------------------------------------------------------------------------
diff --git a/include/swift/AST/GenericEnvironment.h b/include/swift/AST/GenericEnvironment.h
index 0db7f0f..cba8da9 100644
--- a/include/swift/AST/GenericEnvironment.h
+++ b/include/swift/AST/GenericEnvironment.h
@@ -242,6 +242,8 @@
 
   SubstitutionList getForwardingSubstitutions() const;
 
+  void dump(raw_ostream &os) const;
+
   void dump() const;
 };
   
diff --git a/include/swift/AST/GenericSignature.h b/include/swift/AST/GenericSignature.h
index a859f92..54f572c 100644
--- a/include/swift/AST/GenericSignature.h
+++ b/include/swift/AST/GenericSignature.h
@@ -123,13 +123,6 @@
     return const_cast<GenericSignature *>(this)->getRequirementsBuffer();
   }
 
-  /// Check if the generic signature makes all generic parameters
-  /// concrete.
-  bool areAllParamsConcrete() const {
-    auto iter = getAllDependentTypes();
-    return iter.begin() == iter.end();
-  }
-
   /// Only allow allocation by doing a placement new.
   void *operator new(size_t Bytes, void *Mem) {
     assert(Mem);
@@ -174,11 +167,6 @@
   void getSubstitutions(const SubstitutionMap &subMap,
                         SmallVectorImpl<Substitution> &result) const;
 
-  /// Return a range that iterates through all of the types that require
-  /// substitution, which includes the generic parameter types as well as
-  /// other dependent types that require additional conformances.
-  SmallVector<Type, 4> getAllDependentTypes() const;
-
   /// Enumerate all of the dependent types in the type signature that will
   /// occur in substitution lists (in order), along with the set of
   /// conformance requirements placed on that dependent type.
@@ -191,6 +179,33 @@
   bool enumeratePairedRequirements(
          llvm::function_ref<bool(Type, ArrayRef<Requirement>)> fn) const;
 
+  /// Return a vector of all generic parameters that are not subject to
+  /// a concrete same-type constraint.
+  SmallVector<GenericTypeParamType *, 2> getSubstitutableParams() const;
+
+  /// Check if the generic signature makes all generic parameters
+  /// concrete.
+  bool areAllParamsConcrete() const {
+    return !enumeratePairedRequirements(
+      [](Type, ArrayRef<Requirement>) -> bool {
+        return true;
+      });
+  }
+
+  /// Return the size of a SubstitutionList built from this signature.
+  ///
+  /// Don't add new calls of this -- the representation of SubstitutionList
+  /// will be changing soon.
+  unsigned getSubstitutionListSize() const {
+    unsigned result = 0;
+    enumeratePairedRequirements(
+      [&](Type, ArrayRef<Requirement>) -> bool {
+        result++;
+        return false;
+      });
+    return result;
+  }
+
   /// Determines whether this GenericSignature is canonical.
   bool isCanonical() const;
   
diff --git a/include/swift/AST/GenericSignatureBuilder.h b/include/swift/AST/GenericSignatureBuilder.h
index ed575c4..9b2fe86 100644
--- a/include/swift/AST/GenericSignatureBuilder.h
+++ b/include/swift/AST/GenericSignatureBuilder.h
@@ -32,6 +32,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <functional>
 #include <memory>
@@ -590,6 +591,8 @@
     case Concrete:
       return 0;
     }
+
+    llvm_unreachable("Unhandled RequirementSourceKind in switch.");
   }
 
   /// Determines whether we have been provided with an acceptable storage kind
@@ -618,6 +621,8 @@
     case Concrete:
       return false;
     }
+
+    llvm_unreachable("Unhandled RequirementSourceKind in switch.");
   }
 
 public:
diff --git a/include/swift/AST/ProtocolConformance.h b/include/swift/AST/ProtocolConformance.h
index 3d9f492..0dfdf5f 100644
--- a/include/swift/AST/ProtocolConformance.h
+++ b/include/swift/AST/ProtocolConformance.h
@@ -339,6 +339,10 @@
   /// the requirements of those protocols.
   InheritedConformanceMap InheritedMapping;
 
+  /// Conformances that satisfy each of conformance requirements of the
+  /// requirement signature of the protocol.
+  ArrayRef<ProtocolConformanceRef> SignatureConformances;
+
   LazyMemberLoader *Resolver = nullptr;
   uint64_t ResolverContextData;
 
@@ -440,6 +444,18 @@
                       const Substitution &substitution,
                       TypeDecl *typeDecl) const;
 
+  /// Given a dependent type expressed in terms of the self parameter,
+  /// map it into the context of this conformance.
+  Type getAssociatedType(Type assocType,
+                         LazyResolver *resolver = nullptr) const;
+
+  /// Given that the requirement signature of the protocol directly states
+  /// that the given dependent type must conform to the given protocol,
+  /// return its associated conformance.
+  ProtocolConformanceRef
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
+                           LazyResolver *resolver = nullptr) const;
+
   /// Retrieve the value witness corresponding to the given requirement.
   ///
   /// Note that a generic witness will only be specialized if the conformance
@@ -481,6 +497,17 @@
     InheritedMapping[proto] = conformance;
   }
 
+  /// Retrieve the protocol conformances that satisfy the requirements of the
+  /// protocol, which line up with the conformance constraints in the
+  /// protocol's requirement signature.
+  ArrayRef<ProtocolConformanceRef> getSignatureConformances() const {
+    return SignatureConformances;
+  }
+
+  /// Copy the given protocol conformances for the requirement signature into
+  /// the normal conformance.
+  void setSignatureConformances(ArrayRef<ProtocolConformanceRef> conformances);
+
   /// Determine whether the witness for the given type requirement
   /// is the default definition.
   bool usesDefaultDefinition(AssociatedTypeDecl *requirement) const {
diff --git a/include/swift/AST/ProtocolConformanceRef.h b/include/swift/AST/ProtocolConformanceRef.h
index 7972750..1368cff 100644
--- a/include/swift/AST/ProtocolConformanceRef.h
+++ b/include/swift/AST/ProtocolConformanceRef.h
@@ -20,7 +20,6 @@
 #include "llvm/ADT/PointerUnion.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/Type.h"
-#include "swift/AST/ProtocolConformance.h"
 
 namespace llvm {
   class raw_ostream;
@@ -28,6 +27,8 @@
 
 namespace swift {
 
+class ProtocolConformance;
+
 /// A ProtocolConformanceRef is a handle to a protocol conformance which
 /// may be either concrete or abstract.
 ///
diff --git a/include/swift/AST/Requirement.h b/include/swift/AST/Requirement.h
index b4dfde3..650c0ef 100644
--- a/include/swift/AST/Requirement.h
+++ b/include/swift/AST/Requirement.h
@@ -19,6 +19,7 @@
 
 #include "swift/AST/Type.h"
 #include "llvm/ADT/PointerIntPair.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace swift {
 
@@ -109,6 +110,8 @@
     case RequirementKind::Layout:
       return Requirement(getKind(), newFirst, getLayoutConstraint());
     }
+
+    llvm_unreachable("Unhandled RequirementKind in switch.");
   }
 
   /// \brief Retrieve the layout constraint.
diff --git a/include/swift/AST/SubstitutionMap.h b/include/swift/AST/SubstitutionMap.h
index 8209350..6ecc02c 100644
--- a/include/swift/AST/SubstitutionMap.h
+++ b/include/swift/AST/SubstitutionMap.h
@@ -83,12 +83,6 @@
   /// Retrieve the conformances for the given type.
   ArrayRef<ProtocolConformanceRef> getConformances(CanType type) const;
 
-  /// Look up the replacement for the given type parameter or interface type.
-  /// Note that this only finds replacements for maps that are directly
-  /// stored inside the map. In most cases, you should call Type::subst()
-  /// instead, since that will resolve member types also.
-  Type lookupSubstitution(CanSubstitutableType type) const;
-
   bool empty() const {
     return subMap.empty();
   }
@@ -149,6 +143,13 @@
 private:
   friend class GenericSignature;
   friend class GenericEnvironment;
+  friend struct QuerySubstitutionMap;
+
+  /// Look up the replacement for the given type parameter or interface type.
+  /// Note that this only finds replacements for maps that are directly
+  /// stored inside the map. In most cases, you should call Type::subst()
+  /// instead, since that will resolve member types also.
+  Type lookupSubstitution(CanSubstitutableType type) const;
 
   // You should not need to call these directly to build SubstitutionMaps;
   // instead, use GenericSignature::getSubstitutionMap() or
diff --git a/include/swift/Basic/Defer.h b/include/swift/Basic/Defer.h
index 23ba2ea..8b20dce 100644
--- a/include/swift/Basic/Defer.h
+++ b/include/swift/Basic/Defer.h
@@ -23,10 +23,10 @@
 namespace swift {
   template <typename F>
   class DoAtScopeExit {
-    F &Fn;
+    F Fn;
     void operator=(DoAtScopeExit&) = delete;
   public:
-    DoAtScopeExit(F &Fn) : Fn(Fn){}
+    DoAtScopeExit(F &&Fn) : Fn(std::move(Fn)) {}
     ~DoAtScopeExit() {
       Fn();
     }
@@ -36,7 +36,7 @@
     struct DeferTask {};
     template<typename F>
     DoAtScopeExit<typename std::decay<F>::type> operator+(DeferTask, F&& fn) {
-      return DoAtScopeExit<typename std::decay<F>::type>(fn);
+      return DoAtScopeExit<typename std::decay<F>::type>(std::move(fn));
     }
   }
 } // end namespace swift
diff --git a/include/swift/Basic/Demangle.h b/include/swift/Basic/Demangle.h
index 3635a8b..60bd414 100644
--- a/include/swift/Basic/Demangle.h
+++ b/include/swift/Basic/Demangle.h
@@ -207,6 +207,9 @@
 
   // Only to be used by the demangler parsers.
   void addChild(NodePointer Child, NodeFactory &Factory);
+
+  // Reverses the order of children.
+  void reverseChildren(size_t StartingAt = 0);
 };
 
 /// Returns true if the mangledName starts with the swift mangling prefix.
@@ -289,6 +292,20 @@
   /// or ObjC-as-swift thunks.
   bool isThunkSymbol(llvm::StringRef MangledName);
 
+  /// Returns the mangled name of the target of a thunk.
+  ///
+  /// \returns Returns the remaining name after removing the thunk mangling
+  /// characters from \p MangledName. If \p MangledName is not a thunk symbol,
+  /// an empty string is returned.
+  std::string getThunkTarget(llvm::StringRef MangledName);
+
+  /// Returns true if the \p mangledName refers to a function which conforms to
+  /// the Swift calling convention.
+  ///
+  /// The return value is unspecified if the \p MangledName does not refer to a
+  /// function symbol.
+  bool hasSwiftCallingConvention(llvm::StringRef MangledName);
+
   /// Deallocates all nodes.
   ///
   /// The memory which is used for nodes is not freed but recycled for the next
diff --git a/include/swift/Basic/Demangler.h b/include/swift/Basic/Demangler.h
index a1ca433..d30736b 100644
--- a/include/swift/Basic/Demangler.h
+++ b/include/swift/Basic/Demangler.h
@@ -35,6 +35,8 @@
 namespace swift {
 namespace Demangle {
 
+class CharVector;
+  
 /// The allocator for demangling nodes and other demangling-internal stuff.
 ///
 /// It implements a simple bump-pointer allocator.
@@ -77,15 +79,15 @@
 #endif
   }
   
-  ~NodeFactory() {
+  virtual ~NodeFactory() {
     freeSlabs(CurrentSlab);
 #ifdef NODE_FACTORY_DEBUGGING
     std::cerr << "Delete NodeFactory " << this << "\n";
 #endif
   }
   
-  void clear();
-
+  virtual void clear();
+  
   /// Allocates an object of type T or an array of objects of type T.
   template<typename T> T *Allocate(size_t NumObjects = 1) {
     size_t ObjectSize = NumObjects * sizeof(T);
@@ -173,6 +175,12 @@
   /// The \p Text string is copied.
   NodePointer createNode(Node::Kind K, llvm::StringRef Text);
 
+  /// Creates a node of kind \p K with a \p Text payload.
+  ///
+  /// The \p Text string is already allocted with the Factory and therefore
+  /// it is _not_ copied.
+  NodePointer createNode(Node::Kind K, const CharVector &Text);
+  
   /// Creates a node of kind \p K with a \p Text payload, which must be a C
   /// string literal.
   ///
@@ -180,6 +188,92 @@
   NodePointer createNode(Node::Kind K, const char *Text);
 };
 
+/// A vector with a storage managed by a NodeFactory.
+///
+/// This Vector class only provides the minimal functionality needed by the
+/// Demangler.
+template<typename T> class Vector {
+
+protected:
+  T *Elems = nullptr;
+  size_t NumElems = 0;
+  size_t Capacity = 0;
+
+public:
+  
+  typedef T *iterator;
+
+  Vector() { }
+
+  /// Construct a vector with an inital capacity.
+  explicit Vector(NodeFactory &Factory, size_t InitialCapacity) {
+    init(Factory, InitialCapacity);
+  }
+
+  /// Clears the content and re-allocates the buffer with an initial capacity.
+  void init(NodeFactory &Factory, size_t InitialCapacity) {
+    Elems = Factory.Allocate<T>(InitialCapacity);
+    NumElems = 0;
+    Capacity = InitialCapacity;
+  }
+  
+  void free() {
+    Capacity = 0;
+    Elems = 0;
+  }
+  
+  iterator begin() { return Elems; }
+  iterator end() { return Elems + NumElems; }
+  
+  T &operator[](size_t Idx) {
+    assert(Idx < NumElems);
+    return Elems[Idx];
+  }
+
+  const T &operator[](size_t Idx) const {
+    assert(Idx < NumElems);
+    return Elems[Idx];
+  }
+  
+  size_t size() const { return NumElems; }
+
+  bool empty() const { return NumElems == 0; }
+
+  T &back() { return (*this)[NumElems - 1]; }
+
+  void push_back(const T &NewElem, NodeFactory &Factory) {
+    if (NumElems >= Capacity)
+      Factory.Reallocate(Elems, Capacity, /*Growth*/ 1);
+    assert(NumElems < Capacity);
+    Elems[NumElems++] = NewElem;
+  }
+
+  T pop_back_val() {
+    if (empty())
+      return T();
+    T Val = (*this)[NumElems - 1];
+    NumElems--;
+    return Val;
+  }
+};
+
+/// A vector of chars (a string) with a storage managed by a NodeFactory.
+///
+/// This CharVector class only provides the minimal functionality needed by the
+/// Demangler.
+class CharVector : public Vector<char> {
+public:
+  // Append another string.
+  void append(StringRef Rhs, NodeFactory &Factory);
+
+  // Append an integer as readable number.
+  void append(int Number, NodeFactory &Factory);
+
+  StringRef str() const {
+    return StringRef(Elems, NumElems);
+  }
+};
+
 /// The demangler.
 ///
 /// It de-mangles a string and it also ownes the returned node-tree. This means
@@ -194,22 +288,14 @@
     size_t Pos;
   };
 
-  std::vector<NodeWithPos> NodeStack;
-  std::vector<NodePointer> Substitutions;
-  std::vector<unsigned> PendingSubstitutions;
+  Vector<NodeWithPos> NodeStack;
+  Vector<NodePointer> Substitutions;
+  Vector<unsigned> PendingSubstitutions;
 
   static const int MaxNumWords = 26;
   StringRef Words[MaxNumWords];
   int NumWords = 0;
 
-  static NodePointer pop_back_val(std::vector<NodePointer> &NodeVector) {
-    if (NodeVector.empty())
-      return nullptr;
-    NodePointer Val = NodeVector.back();
-    NodeVector.pop_back();
-    return Val;
-  }
-
   bool nextIf(StringRef str) {
     if (!Text.substr(Pos).startswith(str)) return false;
     Pos += str.size();
@@ -241,16 +327,11 @@
   }
 
   void pushNode(NodePointer Nd) {
-    NodeStack.push_back({ Nd, Pos });
+    NodeStack.push_back({ Nd, Pos }, *this);
   }
 
   NodePointer popNode() {
-    if (!NodeStack.empty()) {
-      NodePointer Val = NodeStack.back().Node;
-      NodeStack.pop_back();
-      return Val;
-    }
-    return nullptr;
+    return NodeStack.pop_back_val().Node;
   }
 
   NodePointer popNode(Node::Kind kind) {
@@ -279,7 +360,7 @@
   
   void addSubstitution(NodePointer Nd) {
     if (Nd)
-      Substitutions.push_back(Nd);
+      Substitutions.push_back(Nd, *this);
   }
 
   NodePointer addChild(NodePointer Parent, NodePointer Child);
@@ -326,7 +407,7 @@
   NodePointer popProtocol();
   NodePointer demangleBoundGenericType();
   NodePointer demangleBoundGenericArgs(NodePointer nominalType,
-                                    const std::vector<NodePointer> &TypeLists,
+                                    const Vector<NodePointer> &TypeLists,
                                     size_t TypeListIdx);
   NodePointer demangleInitializer();
   NodePointer demangleImplParamConvention();
@@ -367,6 +448,8 @@
 
 public:
   Demangler() {}
+  
+  void clear() override;
 
   /// Demangle the given symbol and return the parse tree.
   ///
diff --git a/include/swift/Basic/Version.h b/include/swift/Basic/Version.h
index 20d6ce5..9c36999 100644
--- a/include/swift/Basic/Version.h
+++ b/include/swift/Basic/Version.h
@@ -52,13 +52,16 @@
 /// a: [0 - 999]
 /// b: [0 - 999]
 class Version {
-  SmallVector<uint64_t, 5> Components;
+  SmallVector<unsigned, 5> Components;
 public:
   /// Create the empty compiler version - this always compares greater
   /// or equal to any other CompilerVersion, as in the case of building Swift
   /// from latest sources outside of a build/integration/release context.
   Version() = default;
 
+  /// Create a literal version from a list of components.
+  Version(std::initializer_list<unsigned> Values) : Components(Values) {}
+
   /// Create a version from a string in source code.
   ///
   /// Must include only groups of digits separated by a dot.
@@ -94,11 +97,15 @@
   /// away any 5th component that might be in this version.
   operator clang::VersionTuple() const;
 
-  /// Return whether this version is a valid Swift language version number
-  /// to set the compiler to using -swift-version; this is not the same as
-  /// the set of Swift versions that have ever existed, just those that we
-  /// are attempting to maintain backward-compatibility support for.
-  bool isValidEffectiveLanguageVersion() const;
+  /// Returns the concrete version to use when \e this version is provided as
+  /// an argument to -swift-version.
+  ///
+  /// This is not the same as the set of Swift versions that have ever existed,
+  /// just those that we are attempting to maintain backward-compatibility
+  /// support for. It's also common for valid versions to produce a different
+  /// result; for example "-swift-version 3" at one point instructed the
+  /// compiler to act as if it is version 3.1.
+  Optional<Version> getEffectiveLanguageVersion() const;
 
   /// Whether this version is in the Swift 3 family
   bool isVersion3() const { return !empty() && Components[0] == 3; }
@@ -141,6 +148,10 @@
 raw_ostream &operator<<(raw_ostream &os, const Version &version);
 
 /// Retrieves the numeric {major, minor} Swift version.
+///
+/// Note that this is the underlying version of the language, ignoring any
+/// -swift-version flags that may have been used in a particular invocation of
+/// the compiler.
 std::pair<unsigned, unsigned> getSwiftNumericVersion();
 
 /// Retrieves a string representing the complete Swift version, which includes
diff --git a/include/swift/Driver/Compilation.h b/include/swift/Driver/Compilation.h
index ef4db3e..ad43cbf 100644
--- a/include/swift/Driver/Compilation.h
+++ b/include/swift/Driver/Compilation.h
@@ -41,6 +41,7 @@
 namespace driver {
   class Driver;
   class ToolChain;
+  class PerformJobsState;
 
 /// An enum providing different levels of output which should be produced
 /// by a Compilation.
@@ -56,6 +57,7 @@
 };
 
 class Compilation {
+  friend class PerformJobsState;
 private:
   /// The DiagnosticEngine to which this Compilation should emit diagnostics.
   DiagnosticEngine &Diags;
@@ -136,6 +138,10 @@
   /// rebuilt.
   bool ShowIncrementalBuildDecisions = false;
 
+  /// When true, traces the lifecycle of each driver job. Provides finer
+  /// detail than ShowIncrementalBuildDecisions.
+  bool ShowJobLifecycle = false;
+
   static const Job *unwrap(const std::unique_ptr<const Job> &p) {
     return p.get();
   }
@@ -194,6 +200,10 @@
     ShowIncrementalBuildDecisions = value;
   }
 
+  void setShowJobLifecycle(bool value = true) {
+    ShowJobLifecycle = value;
+  }
+
   void setCompilationRecordPath(StringRef path) {
     assert(CompilationRecordPath.empty() && "already set");
     CompilationRecordPath = path;
diff --git a/include/swift/Driver/Job.h b/include/swift/Driver/Job.h
index 6963f2a..1839506 100644
--- a/include/swift/Driver/Job.h
+++ b/include/swift/Driver/Job.h
@@ -168,6 +168,9 @@
   /// terminating output with the given \p terminator.
   void printCommandLine(raw_ostream &Stream, StringRef Terminator = "\n") const;
 
+  /// Print a short summary of this Job to the given \p Stream.
+  void printSummary(raw_ostream &Stream) const;
+
   /// Print the command line for this Job to the given \p stream,
   /// and include any extra environment variables that will be set.
   ///
diff --git a/include/swift/Option/Options.td b/include/swift/Option/Options.td
index 4570b2f..dff7665 100644
--- a/include/swift/Option/Options.td
+++ b/include/swift/Option/Options.td
@@ -91,6 +91,9 @@
 def driver_show_incremental : Flag<["-"], "driver-show-incremental">,
   InternalDebugOpt,
   HelpText<"With -v, dump information about why files are being rebuilt">;
+def driver_show_job_lifecycle : Flag<["-"], "driver-show-job-lifecycle">,
+  InternalDebugOpt,
+  HelpText<"Show every step in the lifecycle of driver jobs">;
 def driver_use_filelists : Flag<["-"], "driver-use-filelists">,
   InternalDebugOpt, HelpText<"Pass input files as filelists whenever possible">;
 
diff --git a/include/swift/Runtime/Config.h b/include/swift/Runtime/Config.h
index 2ad75a6..d8683e5 100644
--- a/include/swift/Runtime/Config.h
+++ b/include/swift/Runtime/Config.h
@@ -17,6 +17,9 @@
 #ifndef SWIFT_RUNTIME_CONFIG_H
 #define SWIFT_RUNTIME_CONFIG_H
 
+// Bring in visibility attribute macros for library visibility.
+#include "llvm/Support/Compiler.h"
+
 /// Does the current Swift platform support "unbridged" interoperation
 /// with Objective-C?  If so, the implementations of various types must
 /// implicitly handle Objective-C pointers.
@@ -185,9 +188,6 @@
 
 #endif
 
-// Bring in visibility attribute macros for library visibility.
-#include "llvm/Support/Compiler.h"
-
 // Generates a name of the runtime entry's implementation by
 // adding an underscore as a prefix and a suffix.
 #define SWIFT_RT_ENTRY_IMPL(Name) _##Name##_
diff --git a/include/swift/Runtime/Metadata.h b/include/swift/Runtime/Metadata.h
index 4a8ceb0..ff984f4 100644
--- a/include/swift/Runtime/Metadata.h
+++ b/include/swift/Runtime/Metadata.h
@@ -1993,7 +1993,7 @@
       return nullptr;
 
     auto asWords = reinterpret_cast<
-      ConstTargetMetadataPointer<Runtime, TargetMetadata> const *>(this);
+      ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> const *>(this);
     return (asWords + Description->GenericParams.Offset);
   }
 
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
index 1088268..2f83a47 100644
--- a/include/swift/SIL/SILBuilder.h
+++ b/include/swift/SIL/SILBuilder.h
@@ -1280,6 +1280,18 @@
         getSILDebugLocation(Loc), Operand, atomicity));
   }
 
+  EndLifetimeInst *createEndLifetime(SILLocation Loc, SILValue Operand) {
+    return insert(new (F.getModule())
+                      EndLifetimeInst(getSILDebugLocation(Loc), Operand));
+  }
+
+  UncheckedOwnershipConversionInst *
+  createUncheckedOwnershipConversion(SILLocation Loc, SILValue Operand,
+                                     ValueOwnershipKind Kind) {
+    return insert(new (F.getModule()) UncheckedOwnershipConversionInst(
+        getSILDebugLocation(Loc), Operand, Kind));
+  }
+
   FixLifetimeInst *createFixLifetime(SILLocation Loc, SILValue Operand) {
     return insert(new (F.getModule())
                       FixLifetimeInst(getSILDebugLocation(Loc), Operand));
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
index 9184783..f36f99a 100644
--- a/include/swift/SIL/SILCloner.h
+++ b/include/swift/SIL/SILCloner.h
@@ -1700,9 +1700,30 @@
                                    getOpValue(Inst->getOperand())));
 }
 
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::visitMarkDependenceInst(MarkDependenceInst *Inst) {
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitEndLifetimeInst(EndLifetimeInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(Inst,
+                getBuilder().createEndLifetime(getOpLocation(Inst->getLoc()),
+                                               getOpValue(Inst->getOperand())));
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitUncheckedOwnershipConversionInst(
+    UncheckedOwnershipConversionInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  ValueOwnershipKind Kind = SILValue(Inst).getOwnershipKind();
+  if (getOpValue(Inst->getOperand()).getOwnershipKind() ==
+      ValueOwnershipKind::Trivial) {
+    Kind = ValueOwnershipKind::Trivial;
+  }
+  doPostProcess(Inst, getBuilder().createUncheckedOwnershipConversion(
+                          getOpLocation(Inst->getLoc()),
+                          getOpValue(Inst->getOperand()), Kind));
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitMarkDependenceInst(MarkDependenceInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   doPostProcess(Inst,
     getBuilder().createMarkDependence(getOpLocation(Inst->getLoc()),
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
index 77766a7..bfd2236 100644
--- a/include/swift/SIL/SILInstruction.h
+++ b/include/swift/SIL/SILInstruction.h
@@ -4337,6 +4337,48 @@
       : UnaryInstructionBase(DebugLoc, Operand) {}
 };
 
+/// EndLifetimeInst - An artificial end lifetime use of a value for the purpose
+/// of working around verification problems.
+///
+/// Specifically, the signature of destroying deinit takes self at +0 and
+/// returns self at +1. This is an issue since a deallocating deinit takes in
+/// self at +1. Previously, we could rely on the deallocating bit being set in
+/// the object header to allow SILGen to statically balance the +1 from the
+/// deallocating deinit. This is because deallocating values used to be
+/// immortal. The runtime now asserts if we release a deallocating value,
+/// meaning such an approach does not work. This instruction acts as a "fake"
+/// lifetime ending use allowing for static verification of deallocating
+/// destroyers, without an actual release being emitted (avoiding the runtime
+/// assert).
+class EndLifetimeInst
+    : public UnaryInstructionBase<ValueKind::EndLifetimeInst, SILInstruction,
+                                  /*HAS_RESULT*/ false> {
+  friend SILBuilder;
+
+  EndLifetimeInst(SILDebugLocation DebugLoc, SILValue Operand)
+      : UnaryInstructionBase(DebugLoc, Operand) {}
+};
+
+/// An unsafe conversion in between ownership kinds.
+///
+/// This is used today in destructors where due to objective-c legacy
+/// constraints, we need to be able to convert a guaranteed paramter to an owned
+/// parameter.
+class UncheckedOwnershipConversionInst
+    : public UnaryInstructionBase<ValueKind::UncheckedOwnershipConversionInst> {
+  friend SILBuilder;
+
+  ValueOwnershipKind Kind;
+
+  UncheckedOwnershipConversionInst(SILDebugLocation DebugLoc, SILValue operand,
+                                   ValueOwnershipKind Kind)
+      : UnaryInstructionBase(DebugLoc, operand, operand->getType()),
+        Kind(Kind) {}
+
+public:
+  ValueOwnershipKind getConversionOwnershipKind() const { return Kind; }
+};
+
 /// MarkDependenceInst - Marks that one value depends on another for
 /// validity in a non-obvious way.
 class MarkDependenceInst : public SILInstruction {
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
index 770fec1..1c9b8a9 100644
--- a/include/swift/SIL/SILNodes.def
+++ b/include/swift/SIL/SILNodes.def
@@ -164,6 +164,8 @@
   INST(UnmanagedAutoreleaseValueInst, RefCountingInst, unmanaged_autorelease_value, MayHaveSideEffects, DoesNotRelease)
   INST(CopyUnownedValueInst, SILInstruction, copy_unowned_value, MayHaveSideEffects, DoesNotRelease)
   INST(DestroyValueInst, SILInstruction, destroy_value, MayHaveSideEffects, MayRelease)
+  INST(EndLifetimeInst, SILInstruction, end_lifetime, MayHaveSideEffects, MayRelease)
+  INST(UncheckedOwnershipConversionInst, SILInstruction, unchecked_ownership_conversion, MayHaveSideEffects, MayRelease)
 
   // IsUnique does not actually write to memory but should be modeled
   // as such. Its operand is a pointer to an object reference. The
diff --git a/include/swift/SIL/SILValue.h b/include/swift/SIL/SILValue.h
index 4909013..f21e166 100644
--- a/include/swift/SIL/SILValue.h
+++ b/include/swift/SIL/SILValue.h
@@ -114,6 +114,11 @@
   ValueOwnershipKind(SILModule &M, SILType Type,
                      SILArgumentConvention Convention);
 
+  /// Parse Value into a ValueOwnershipKind.
+  ///
+  /// *NOTE* Emits an unreachable if an invalid value is passed in.
+  explicit ValueOwnershipKind(StringRef Value);
+
   operator innerty() const { return Value; }
 
   Optional<ValueOwnershipKind> merge(ValueOwnershipKind RHS) const;
diff --git a/include/swift/SIL/SILWitnessTable.h b/include/swift/SIL/SILWitnessTable.h
index 5ded6fa..284d100 100644
--- a/include/swift/SIL/SILWitnessTable.h
+++ b/include/swift/SIL/SILWitnessTable.h
@@ -62,8 +62,9 @@
   /// A witness table entry describing the witness for an associated type's
   /// protocol requirement.
   struct AssociatedTypeProtocolWitness {
-    /// The associated type required.
-    AssociatedTypeDecl *Requirement;
+    /// The associated type required.  A dependent type in the protocol's
+    /// context.
+    CanType Requirement;
     /// The protocol requirement on the type.
     ProtocolDecl *Protocol;
     /// The ProtocolConformance satisfying the requirement. Null if the
diff --git a/include/swift/SIL/SILWitnessVisitor.h b/include/swift/SIL/SILWitnessVisitor.h
index 9d8c266..5d3e9a9 100644
--- a/include/swift/SIL/SILWitnessVisitor.h
+++ b/include/swift/SIL/SILWitnessVisitor.h
@@ -49,27 +49,77 @@
 
 public:
   void visitProtocolDecl(ProtocolDecl *protocol) {
-    // Visit inherited protocols.
-    // TODO: We need to figure out all the guarantees we want here.
-    // It would be abstractly good to allow conversion to a base
-    // protocol to be trivial, but it's not clear that there's
-    // really a structural guarantee we can rely on here.
-    for (auto baseProto : protocol->getInheritedProtocols()) {
-      // ObjC protocols do not have witnesses.
-      if (!Lowering::TypeConverter::protocolRequiresWitnessTable(baseProto))
+    // Associated types get added after the inherited conformances, but
+    // before all the function requirements.
+    bool haveAddedAssociatedTypes = false;
+    auto addAssociatedTypes = [&] {
+      if (haveAddedAssociatedTypes) return;
+      haveAddedAssociatedTypes = true;
+
+      for (Decl *member : protocol->getMembers()) {
+        if (auto associatedType = dyn_cast<AssociatedTypeDecl>(member)) {
+          // TODO: only add associated types when they're new?
+          asDerived().addAssociatedType(associatedType);
+        }
+      }
+    };
+
+    for (auto &reqt : protocol->getRequirementSignature()
+                              ->getCanonicalSignature()->getRequirements()) {
+      switch (reqt.getKind()) {
+      // These requirements don't show up in the witness table.
+      case RequirementKind::Superclass:
+      case RequirementKind::SameType:
+      case RequirementKind::Layout:
         continue;
 
-      asDerived().addOutOfLineBaseProtocol(baseProto);
+      case RequirementKind::Conformance: {
+        auto type = CanType(reqt.getFirstType());
+        assert(type->isTypeParameter());
+        auto requirement =
+          cast<ProtocolType>(CanType(reqt.getSecondType()))->getDecl();
+
+        // ObjC protocols do not have witnesses.
+        if (!Lowering::TypeConverter::protocolRequiresWitnessTable(requirement))
+          continue;
+
+        // If the type parameter is 'self', consider this to be protocol
+        // inheritance.  In the canonical signature, these should all
+        // come before any protocol requirements on associated types.
+        if (auto parameter = dyn_cast<GenericTypeParamType>(type)) {
+          assert(type->isEqual(protocol->getSelfInterfaceType()));
+          assert(!haveAddedAssociatedTypes &&
+                 "unexpected ordering of conformances");
+          assert(parameter->getDepth() == 0 && parameter->getIndex() == 0 &&
+                 "non-self type parameter in protocol");
+          asDerived().addOutOfLineBaseProtocol(requirement);
+          continue;
+        }
+
+        // Add the associated types if we haven't yet.
+        addAssociatedTypes();
+
+        // Otherwise, add an associated requirement.
+        asDerived().addAssociatedConformance(type, requirement);
+        continue;
+      }
+      }
+      llvm_unreachable("bad requirement kind");
     }
 
-    /// Visit the witnesses for the direct members of a protocol.
+    // Add the associated types if we haven't yet.
+    addAssociatedTypes();
+
+    // Visit the witnesses for the direct members of a protocol.
     for (Decl *member : protocol->getMembers())
       ASTVisitor<T>::visit(member);
   }
 
   /// Fallback for unexpected protocol requirements.
   void visitDecl(Decl *d) {
+#ifndef NDEBUG
     d->print(llvm::errs());
+#endif
     llvm_unreachable("unhandled protocol requirement");
   }
 
@@ -94,11 +144,7 @@
   }
 
   void visitAssociatedTypeDecl(AssociatedTypeDecl *td) {
-    SmallVector<ProtocolDecl *, 4> protos;
-    for (auto p : td->getConformingProtocols())
-      protos.push_back(p);
-    ProtocolType::canonicalizeProtocols(protos);
-    asDerived().addAssociatedType(td, protos);
+    // We already visited these in the first pass.
   }
     
   void visitTypeAliasDecl(TypeAliasDecl *tad) {
diff --git a/include/swift/SILOptimizer/Utils/Generics.h b/include/swift/SILOptimizer/Utils/Generics.h
index cf4395d..58406b6 100644
--- a/include/swift/SILOptimizer/Utils/Generics.h
+++ b/include/swift/SILOptimizer/Utils/Generics.h
@@ -115,6 +115,15 @@
                                            bool HasUnboundGenericParams);
 
   void createSubstitutedAndSpecializedTypes();
+  bool prepareAndCheck(ApplySite Apply, SILFunction *Callee,
+                       SubstitutionList ParamSubs);
+  void specializeConcreteAndGenericSubstitutions(ApplySite Apply,
+                                                 SILFunction *Callee,
+                                                 SubstitutionList ParamSubs);
+  void specializeConcreteSubstitutions(ApplySite Apply, SILFunction *Callee,
+                                       SubstitutionList ParamSubs);
+
+  ReabstractionInfo() {}
 public:
   /// Constructs the ReabstractionInfo for generic function \p Orig with
   /// substitutions \p ParamSubs.
@@ -219,6 +228,10 @@
 
   /// Returns true if it is a partial generic specialization.
   bool isPartialSpecialization() const;
+
+  /// Returns true if a given apply can be specialized.
+  static bool canBeSpecialized(ApplySite Apply, SILFunction *Callee,
+                               SubstitutionList ParamSubs);
 };
 
 /// Helper class for specializing a generic function given a list of
diff --git a/include/swift/Serialization/ModuleFormat.h b/include/swift/Serialization/ModuleFormat.h
index e790e71..3bf2312 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 = 321; // Last change: restrict to extension
+const uint16_t VERSION_MINOR = 325; // Last change: unchecked_ownership_conver
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;
diff --git a/include/swift/SwiftDemangle/SwiftDemangle.h b/include/swift/SwiftDemangle/SwiftDemangle.h
index eb02d7e..8cf4ca5 100644
--- a/include/swift/SwiftDemangle/SwiftDemangle.h
+++ b/include/swift/SwiftDemangle/SwiftDemangle.h
@@ -53,6 +53,14 @@
                                                  char *OutputBuffer,
                                                  size_t Length);
 
+/// \brief Demangles a Swift function name and returns true if the function
+/// conforms to the Swift calling convention.
+///
+/// \returns true if the function conforms to the Swift calling convention.
+/// The return value is unspecified if the \p MangledName does not refer to a
+/// function symbol.
+int swift_demangle_hasSwiftCallingConvention(const char *MangledName);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/include/swift/Syntax/DeclSyntax.h b/include/swift/Syntax/DeclSyntax.h
index eb936fa..e5fa79e 100644
--- a/include/swift/Syntax/DeclSyntax.h
+++ b/include/swift/Syntax/DeclSyntax.h
@@ -18,10 +18,10 @@
 #ifndef SWIFT_SYNTAX_DECLSYNTAX_H
 #define SWIFT_SYNTAX_DECLSYNTAX_H
 
-#include "swift/Syntax/GenericSyntax.h"
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/RawSyntax.h"
 #include "swift/Syntax/Syntax.h"
+#include "swift/Syntax/SyntaxCollection.h"
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
 #include "swift/Syntax/TypeSyntax.h"
@@ -32,6 +32,148 @@
 namespace swift {
 namespace syntax {
 
+class ExprSyntax;
+class ExprSyntaxData;
+class CodeBlockStmtSyntax;
+class CodeBlockStmtSyntaxData;
+class TypeAttributesSyntax;
+class TypeAttributesSyntaxData;
+class DeclModifierListSyntax;
+class GenericWhereClauseSyntax;
+class GenericWhereClauseSyntaxData;
+class GenericParameterListSyntax;
+class GenericParameterListSyntaxData;
+
+#pragma mark declaration-modifier Data
+
+class DeclModifierSyntaxData final : public SyntaxData {
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class Syntax;
+  friend class DeclModifierSyntax;
+
+  DeclModifierSyntaxData(const RC<RawSyntax> Raw,
+                         const SyntaxData *Parent = nullptr,
+                         const CursorIndex IndexInParent = 0);
+
+  static RC<DeclModifierSyntaxData> make(const RC<RawSyntax> Raw,
+                                         const SyntaxData *Parent = nullptr,
+                                         const CursorIndex IndexInParent = 0);
+
+  static RC<DeclModifierSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *SD) {
+    return SD->getKind() == SyntaxKind::DeclModifier;
+  }
+};
+
+#pragma mark declaration-modifier API
+
+/// declaration-modifier -> access-level-modifier
+///                       | mutation-modifier
+///                       | 'class'
+///                       | 'convenience­'
+///                       | 'dynamic­'
+///                       | 'final­'
+///                       | 'infix­'
+///                       | 'lazy­'
+///                       | 'optional­'
+///                       | 'override'
+///                       | 'postfix'
+///                       | 'prefix'
+///                       | 'required'
+///                       | 'static'
+///                       | 'unowned­'
+///                       | 'unowned­(­safe­)­'
+///                       | 'unowned­(­unsafe­)­'
+///                       | 'weak­'
+/// access-level-modifier -> 'private' | 'private' '(' 'set' ')'
+///                        | 'fileprivate' | 'fileprivate' '(' 'set' ')'
+///                        | 'internal' | 'internal' '(' 'set' ')'
+///                        | 'public' | 'public' '(' 'set' ')'
+///                        | 'open' | 'open' '(' 'set' ')'
+/// mutation-modifier -> 'mutating' | 'nonmutating'
+class DeclModifierSyntax final : public Syntax {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class DeclModifierSyntaxData;
+
+  enum class Cursor : CursorIndex {
+    Name,
+    LeftParen,
+    Argument,
+    RightParen
+  };
+
+  DeclModifierSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
+public:
+  using DataType = DeclModifierSyntaxData;
+
+  /// Return the name of the modifier.
+  RC<TokenSyntax> getName() const;
+
+  /// Return a DeclModifierSyntax with the given name.
+  DeclModifierSyntax withName(RC<TokenSyntax> NewName) const;
+
+  /// Return the left parenthesis '(' token as a part of the argument clause,
+  /// if there is one.
+  RC<TokenSyntax> getLeftParenToken() const;
+
+  /// Return a DeclModifierSyntax with the given left parenthesis '(' token.
+  DeclModifierSyntax withLeftParenToken(RC<TokenSyntax> NewLeftParen) const;
+
+  /// Get the argument to the declaration modifier.
+  ///
+  /// This is either:
+  /// - 'set' for the access modifiers such as 'private' or 'public', or
+  /// - 'safe' / 'unsafe' for the 'unowned' modifier.
+  RC<TokenSyntax> getArgument() const;
+
+  /// Return a DeclModifierSyntax with the given argument.
+  DeclModifierSyntax withArgument(RC<TokenSyntax> NewArgument) const;
+
+  /// Return the right parenthesis ')' token as a part of the argument clause,
+  /// if there is one.
+  RC<TokenSyntax> getRightParenToken() const;
+
+  /// Return a DeclModifierSyntax with the given right parenthesis ')' token.
+  DeclModifierSyntax withRightParenToken(RC<TokenSyntax> NewRightParen) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::DeclModifier;
+  }
+};
+
+#pragma mark declaration-modifiers Data
+
+using DeclModifierListSyntaxData =
+  SyntaxCollectionData<SyntaxKind::DeclModifierList, DeclModifierSyntax>;
+
+#pragma mark declaration-modifiers API
+
+class DeclModifierListSyntax final :
+  public SyntaxCollection<SyntaxKind::DeclModifierList, DeclModifierSyntax> {
+
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class FunctionDeclSyntax;
+
+  using DataType = DeclModifierListSyntaxData;
+
+  DeclModifierListSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : SyntaxCollection(Root, Data) {}
+
+public:
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::DeclModifierList;
+  }
+};
+
 #pragma mark declaration Data
 
 class DeclSyntaxData : public SyntaxData {
@@ -380,6 +522,368 @@
   TypeAliasDeclSyntax build() const;
 };
 
+#pragma mark - function-parameter Data
+
+class FunctionParameterSyntaxData final : public SyntaxData {
+
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class FunctionParameterSyntax;
+
+  RC<TypeSyntaxData> CachedTypeSyntax;
+  RC<ExprSyntaxData> CachedDefaultValue;
+
+  FunctionParameterSyntaxData(RC<RawSyntax> Raw,
+                              const SyntaxData *Parent = nullptr,
+                              CursorIndex IndexInParent = 0);
+  static RC<FunctionParameterSyntaxData>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0);
+  static RC<FunctionParameterSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *SD) {
+    return SD->getKind() == SyntaxKind::FunctionParameter;
+  }
+};
+
+#pragma mark - function-parameter API
+
+/// parameter ->
+/// external-parameter-name? local-parameter-name ':'
+///   type '...'? '='? expression? ','?
+class FunctionParameterSyntax final : public Syntax {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class FunctionParameterSyntaxData;
+
+  enum class Cursor : CursorIndex {
+    ExternalName,
+    LocalName,
+    Colon,
+    Type,
+    Ellipsis,
+    DefaultEqual,
+    DefaultExpression,
+    TrailingComma,
+  };
+
+public:
+  using DataType = FunctionParameterSyntaxData;
+
+  FunctionParameterSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
+  /// Get the external name of the parameter, if there is one.
+  RC<TokenSyntax> getExternalName() const;
+
+  /// Return a FunctionParameterSyntax with the given external name.
+  FunctionParameterSyntax
+  withExternalName(RC<TokenSyntax> NewExternalName) const;
+
+  /// Return the local name of the parameter.
+  RC<TokenSyntax> getLocalName() const;
+
+  /// Return a FunctionParameterSyntax with the given local name.
+  FunctionParameterSyntax
+  withLocalName(RC<TokenSyntax> NewLocalName) const;
+
+  /// Return the colon ':' token between the local name and type of the
+  /// parameter.
+  RC<TokenSyntax> getColonToken() const;
+
+  /// Return a FunctionParameterSyntax with the given colon token between
+  /// the local name and type.
+  FunctionParameterSyntax
+  withColonToken(RC<TokenSyntax> NewColonToken) const;
+
+  /// Return the syntax for the type of this parameter.
+  llvm::Optional<TypeSyntax> getTypeSyntax() const;
+
+  /// Return a FunctionParameterSyntax with the given parameter type syntax.
+  FunctionParameterSyntax
+  withTypeSyntax(llvm::Optional<TypeSyntax> NewType) const;
+
+  /// Return the equal '=' token in between the parameter type and the default
+  /// value, if there is one.
+  RC<TokenSyntax> getEqualToken() const;
+
+  /// Return a FunctionParameterSyntax with the given equal '=' token in
+  /// between the parameter type and the default value.
+  FunctionParameterSyntax withEqualToken(RC<TokenSyntax> NewEqualToken) const;
+
+  /// Return the expresion for the default value of the parameter, if there
+  /// is one.
+  llvm::Optional<ExprSyntax> getDefaultValue() const;
+
+  /// Return a FunctionParameterSyntax with the given default value. To remove
+  /// the default value, pass llvm::None.
+  FunctionParameterSyntax
+  withDefaultValue(llvm::Optional<ExprSyntax> NewDefaultValue) const;
+
+  /// Return the trailing comma on the parameter, if there is one.
+  RC<TokenSyntax> getTrailingComma() const;
+
+  /// Return a FunctionParameterSyntax with the given trailing comma.
+  FunctionParameterSyntax
+  withTrailingComma(RC<TokenSyntax> NewTrailingComma) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionParameter;
+  }
+};
+
+#pragma mark - function-parameter-list Data
+
+using FunctionParameterListSyntaxData =
+  SyntaxCollectionData<SyntaxKind::FunctionParameterList,
+  FunctionParameterSyntax>;
+
+#pragma mark - function-parameter-list API
+
+/// parameter-list -> parameteter | parameter ',' parameter-list
+class FunctionParameterListSyntax final : public
+  SyntaxCollection<SyntaxKind::FunctionParameterList, FunctionParameterSyntax> {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class FunctionSignatureSyntax;
+
+  using DataType = FunctionParameterListSyntaxData;
+
+  FunctionParameterListSyntax(const RC<SyntaxData> Root,
+                              const DataType *Data)
+    : SyntaxCollection(Root, Data) {}
+
+public:
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionParameterList;
+  }
+};
+
+#pragma mark - function-signature Data
+
+class FunctionSignatureSyntaxData final : public SyntaxData {
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class FunctionSignatureSyntax;
+
+  RC<FunctionParameterListSyntaxData> CachedParameterList;
+  RC<TypeAttributesSyntaxData> CachedReturnTypeAttributes;
+  RC<TypeSyntaxData> CachedReturnTypeSyntax;
+
+  FunctionSignatureSyntaxData(const RC<RawSyntax> Raw,
+                              const SyntaxData *Parent = nullptr,
+                              const CursorIndex IndexInParent = 0);
+
+  static RC<FunctionSignatureSyntaxData>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0);
+  static RC<FunctionSignatureSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *SD) {
+    return SD->getKind() == SyntaxKind::FunctionSignature;
+  }
+};
+
+#pragma mark - function-signature API
+
+/// function-signature ->
+///   '(' parameter-list? ')' (throws | rethrows)? '->' attributes? type
+class FunctionSignatureSyntax final : public Syntax {
+  friend struct SyntaxBuilder;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class FunctionSignatureSyntaxData;
+
+  enum class Cursor : CursorIndex {
+    LeftParen,
+    ParameterList,
+    RightParen,
+    ThrowsOrRethrows,
+    Arrow,
+    ReturnTypeAttributes,
+    ReturnType,
+  };
+
+public:
+  using DataType = FunctionSignatureSyntaxData;
+
+  FunctionSignatureSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
+  /// Return the left parenthesis '(' token enclosing the parameter list.
+  RC<TokenSyntax> getLeftParenToken() const;
+
+  /// Return a FunctionSignatureSyntax with the given left parentesis '(' token
+  /// enclosing the parameter list.
+  FunctionSignatureSyntax
+  withLeftParenToken(RC<TokenSyntax> NewLeftParen) const;
+
+  /// Return the parameter list for this signature.
+  FunctionParameterListSyntax getParameterList() const;
+
+  /// Return the parameter list for this signature.
+  FunctionSignatureSyntax
+  withParameterList(FunctionParameterListSyntax NewParameterList) const;
+
+  /// Return the right parenthesis ')' token enclosing the parameter list.
+  RC<TokenSyntax> getRightParenToken() const;
+
+  /// Return a FunctionSignatureSyntax with the given right parentesis ')' token
+  /// enclosing the parameter list.
+  FunctionSignatureSyntax
+  withRightParenToken(RC<TokenSyntax> NewRightParen) const;
+
+  /// Return the 'throws' token in this signature if it exists.
+  RC<TokenSyntax> getThrowsToken() const;
+
+  /// Return a FunctionSignatureSyntax with the given 'throws' token.
+  FunctionSignatureSyntax withThrowsToken(RC<TokenSyntax> NewThrowsToken) const;
+
+  /// Return the 'rethrows' token in this signature if it exists;
+  RC<TokenSyntax> getRethrowsToken() const;
+
+  /// Return a FunctionSignatureSyntax with the given 'rethrows' token.
+  FunctionSignatureSyntax
+  withRethrowsToken(RC<TokenSyntax> NewRethrowsToken) const;
+
+  /// Return the arrow '->' token for the signature.
+  RC<TokenSyntax> getArrowToken() const;
+
+  /// Return a FunctionSignatureSyntax with the given arrow token
+  FunctionSignatureSyntax withArrowToken(RC<TokenSyntax> NewArrowToken) const;
+
+  /// Return the return type attributes for the signature.
+  TypeAttributesSyntax getReturnTypeAttributes() const;
+
+  /// Return a FunctionSignatureSyntax with the given return type attributes.
+  FunctionSignatureSyntax
+  withReturnTypeAttributes(TypeAttributesSyntax NewReturnTypeAttributes) const;
+
+  /// Return the syntax for the return type of the signature.
+  TypeSyntax getReturnTypeSyntax() const;
+
+  /// Return a FunctionSignatureSyntax with the given return type.
+  FunctionSignatureSyntax withReturnTypeSyntax(TypeSyntax NewReturnType) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionSignature;
+  }
+};
+
+#pragma mark - function-declaration Data
+
+class FunctionDeclSyntaxData final : public SyntaxData {
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class FunctionDeclSyntax;
+
+  RC<TypeAttributesSyntaxData> CachedAttributes;
+  RC<DeclModifierListSyntaxData> CachedModifiers;
+  RC<GenericParameterClauseSyntaxData> CachedGenericParams;
+  RC<FunctionSignatureSyntaxData> CachedSignature;
+  RC<GenericWhereClauseSyntaxData> CachedGenericWhereClause;
+  RC<CodeBlockStmtSyntaxData> CachedBody;
+
+  FunctionDeclSyntaxData(const RC<RawSyntax> Raw,
+                         const SyntaxData *Parent = nullptr,
+                         const CursorIndex IndexInParent = 0);
+
+  static RC<FunctionDeclSyntaxData> make(const RC<RawSyntax> Raw,
+                                         const SyntaxData *Parent = nullptr,
+                                         const CursorIndex IndexInParent = 0);
+  static RC<FunctionDeclSyntaxData> makeBlank();
+
+public:
+  static bool classof(const SyntaxData *SD) {
+    return SD->getKind() == SyntaxKind::FunctionDecl;
+  }
+};
+
+#pragma mark - function-declaration API
+
+class FunctionDeclSyntax final : public Syntax {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class FunctionDeclSyntaxData;
+
+  enum class Cursor : CursorIndex {
+    Attributes,
+    Modifiers,
+    FuncKeyword,
+    Identifier,
+    GenericParameterClause,
+    Signature,
+    GenericWhereClause,
+    Body
+  };
+
+  using DataType = FunctionDeclSyntaxData;
+
+  FunctionDeclSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
+public:
+  /// Get the attributes of this function declaration.
+  TypeAttributesSyntax getAttributes() const;
+
+  /// Return a FunctionDeclSyntax with the given attributes.
+  FunctionDeclSyntax withAttributes(TypeAttributesSyntax NewAttributes) const;
+
+  /// Get the modifiers of this function declaration.
+  DeclModifierListSyntax getModifiers() const;
+
+  /// Return a FunctionDeclSyntax with the given modifiers.
+  FunctionDeclSyntax withModifiers(DeclModifierListSyntax NewModifiers) const;
+
+  /// Return the 'func' keyword of tis function declaration.
+  RC<TokenSyntax> getFuncKeyword() const;
+
+  /// Return a FunctionDeclSyntax with the given 'func' keyword.
+  FunctionDeclSyntax withFuncKeyword(RC<TokenSyntax> NewFuncKeyword) const;
+
+  /// Return the identifier of the function declaration.
+  RC<TokenSyntax> getIdentifier() const;
+
+  /// Return a FunctionDeclSyntax with the given identifier.
+  FunctionDeclSyntax withIdentifier(RC<TokenSyntax> NewIdentifier) const;
+
+  /// Return the generic parameter clause of the function declaration, if
+  /// there is one. Otherwise, return llvm::None.
+  llvm::Optional<GenericParameterClauseSyntax>
+  getGenericParameterClause() const;
+
+  /// Return a FunctionDeclSyntax with the given generic parameter clause.
+  /// To remove the generic parameters, pass in llvm::None.
+  FunctionDeclSyntax withGenericParameterClause(
+    llvm::Optional<GenericParameterClauseSyntax> NewGenericParams) const;
+
+  /// Return the signature of the function declaration.
+  FunctionSignatureSyntax getSignature() const;
+
+  /// Return a FunctionDeclSyntax with the given function signature.
+  FunctionDeclSyntax withSignature(FunctionSignatureSyntax NewSignature) const;
+
+  /// Return the body of the function declaration, if there is one.
+  ///
+  /// As an example, function declarations in protocols have no body.
+  llvm::Optional<CodeBlockStmtSyntax> getBody() const;
+
+  /// Return a FunctionDeclSyntax with the given body. To remove the body,
+  /// pass in llvm::None.
+  FunctionDeclSyntax
+  withBody(llvm::Optional<CodeBlockStmtSyntax> NewBody) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::FunctionDecl;
+  }
+};
+
 } // end namespace syntax
 } // end namespace swift
 
diff --git a/include/swift/Syntax/ExprSyntax.h b/include/swift/Syntax/ExprSyntax.h
index 5dbebda..1dfbf14 100644
--- a/include/swift/Syntax/ExprSyntax.h
+++ b/include/swift/Syntax/ExprSyntax.h
@@ -22,6 +22,8 @@
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/Syntax.h"
 #include "swift/Syntax/SyntaxData.h"
+#include "swift/Syntax/SyntaxCollection.h"
+#include "swift/Syntax/SyntaxCollectionData.h"
 #include "swift/Syntax/TokenSyntax.h"
 #include "swift/Syntax/UnknownSyntax.h"
 
@@ -51,6 +53,7 @@
 };
 
 class ExprSyntax : public Syntax {
+  friend class FunctionParameterSyntax;
 public:
   using DataType = ExprSyntaxData;
 
@@ -248,7 +251,6 @@
 
 /// function-call-argument -> label? ':'? (expression | operator) ','?
 class FunctionCallArgumentSyntax : public Syntax {
-
   using DataType = FunctionCallArgumentSyntaxData;
 
   friend struct SyntaxFactory;
@@ -256,6 +258,10 @@
   friend class Syntax;
   friend class FunctionCallArgumentSyntaxData;
   friend class FunctionCallArgumentListSyntax;
+  friend class SyntaxCollectionData<SyntaxKind::FunctionCallArgumentList,
+                                    FunctionCallArgumentSyntax>;
+  friend class SyntaxCollection<SyntaxKind::FunctionCallArgumentList,
+                                FunctionCallArgumentSyntax>;
 
   enum class Cursor {
     Label,
@@ -305,37 +311,18 @@
 
 #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;
-  }
-};
+using FunctionCallArgumentListSyntaxData =
+  SyntaxCollectionData<SyntaxKind::FunctionCallArgumentList,
+    FunctionCallArgumentSyntax>;
 
 #pragma mark - function-call-argument-list API
 
 /// function-call-argument-list -> function-call-argument
 ///                                function-call-argument-list?
-class FunctionCallArgumentListSyntax : public Syntax {
+class FunctionCallArgumentListSyntax
+  : public SyntaxCollection<SyntaxKind::FunctionCallArgumentList,
+                            FunctionCallArgumentSyntax> {
   friend struct SyntaxFactory;
-  friend class FunctionCallArgumentListSyntaxData;
   friend class FunctionCallExprSyntax;
   friend class Syntax;
   friend class SyntaxData;
@@ -346,17 +333,6 @@
                                  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;
   }
diff --git a/include/swift/Syntax/GenericSyntax.h b/include/swift/Syntax/GenericSyntax.h
index 753018e..d8510db 100644
--- a/include/swift/Syntax/GenericSyntax.h
+++ b/include/swift/Syntax/GenericSyntax.h
@@ -19,6 +19,7 @@
 #define SWIFT_SYNTAX_GENERICSYNTAX_H
 
 #include "swift/Syntax/References.h"
+#include "swift/Syntax/SyntaxCollection.h"
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
 
@@ -30,10 +31,50 @@
 class TypeIdentifierSyntax;
 class TypeIdentifierSyntaxData;
 
+#pragma mark - generic-requirement Data
+
+class GenericRequirementSyntaxData : public SyntaxData {
+  friend class GenericRequirementSyntax;
+  friend class SyntaxData;
+
+protected:
+  GenericRequirementSyntaxData(const RC<RawSyntax> Raw,
+                               const SyntaxData *Parent = nullptr,
+                               const CursorIndex IndexInParent = 0)
+  : SyntaxData(Raw, Parent, IndexInParent) {}
+
+public:
+  static bool classof(const SyntaxData *SD) {
+    return SD->getKind() == SyntaxKind::ConformanceRequirement ||
+      SD->getKind() == SyntaxKind::SameTypeRequirement;
+  }
+};
+
+#pragma mark - generic-requirement API
+
+class GenericRequirementSyntax : public Syntax {
+  friend class Syntax;
+  friend class SyntaxData;
+  friend class GenericRequirementSyntaxData;
+
+public:
+  using DataType = GenericRequirementSyntaxData;
+
+  GenericRequirementSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::ConformanceRequirement ||
+    S->getKind() == SyntaxKind::SameTypeRequirement;
+  }
+};
+
 #pragma mark - conformance-requirement Data
 
-class ConformanceRequirementSyntaxData final : public SyntaxData {
+class ConformanceRequirementSyntaxData final
+    : public GenericRequirementSyntaxData {
   friend class SyntaxData;
+
   RC<TypeIdentifierSyntaxData> CachedConformingTypeIdentifier;
   RC<TypeSyntaxData> InheritedType;
 
@@ -44,18 +85,24 @@
   make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
        CursorIndex IndexInParent = 0);
   static RC<ConformanceRequirementSyntaxData> makeBlank();
+
 public:
   static bool classof(const SyntaxData *S) {
     return S->getKind() == SyntaxKind::ConformanceRequirement;
   }
+  static bool classof(const GenericRequirementSyntaxData *SD) {
+    return SD->getKind() == SyntaxKind::ConformanceRequirement;
+  }
 };
 
 #pragma mark - conformance-requirement API
 
 /// conformance-requirement -> type-identifier : type-identifier
-class ConformanceRequirementSyntax final : public Syntax {
+class ConformanceRequirementSyntax final : public GenericRequirementSyntax {
 
   friend class ConformanceRequirementSyntaxData;
+  friend class SyntaxData;
+  friend class Syntax;
 
   enum Cursor : CursorIndex {
     LeftTypeIdentifier,
@@ -73,6 +120,8 @@
   static ConformanceRequirementSyntax makeBlank();
 
 public:
+  using DataType = ConformanceRequirementSyntaxData;
+
   /// Return the conforming "left-hand" type identifier in the
   /// conformance requirement.
   TypeIdentifierSyntax getConformingTypeIdentifier() const;
@@ -99,13 +148,18 @@
   static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::ConformanceRequirement;
   }
+  static bool classof(const GenericRequirementSyntax *S) {
+    return S->getKind() == SyntaxKind::ConformanceRequirement;
+  }
 };
 
 #pragma mark - same-type-requirement Data
 
-class SameTypeRequirementSyntaxData final : public SyntaxData {
+class SameTypeRequirementSyntaxData final
+    : public GenericRequirementSyntaxData {
   friend struct SyntaxFactory;
   friend class SyntaxData;
+
   RC<TypeIdentifierSyntaxData> CachedLeftTypeIdentifier;
   RC<TypeSyntaxData> CachedRightType;
 
@@ -129,8 +183,9 @@
 /// same-type-requirement -> type-identifier == type
 class SameTypeRequirementSyntax final : public Syntax {
   friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
   friend class SameTypeRequirementSyntaxData;
-
   enum Cursor : CursorIndex {
     LeftTypeIdentifier,
     EqualityToken,
@@ -141,6 +196,7 @@
                             const SameTypeRequirementSyntaxData *Data);
 
 public:
+  using DataType = SameTypeRequirementSyntaxData;
 
   /// Return the type identifier on the left side of the same-type requirement.
   TypeIdentifierSyntax getLeftTypeIdentifier() const;
@@ -277,9 +333,9 @@
 
   RC<GenericParameterListSyntaxData> CachedGenericParameterList;
 
-  GenericParameterClauseSyntaxData(RC<RawSyntax> Raw,
+  GenericParameterClauseSyntaxData(const RC<RawSyntax> Raw,
                                    const SyntaxData *Parent = nullptr,
-                                   CursorIndex IndexInParent = 0);
+                                   const CursorIndex IndexInParent = 0);
   static RC<GenericParameterClauseSyntaxData>
   make(RC<RawSyntax> Raw,
        const SyntaxData *Parent = nullptr,
@@ -299,6 +355,8 @@
   friend struct SyntaxFactory;
   friend class GenericParameterClauseSyntaxData;
   friend class GenericParameterClauseBuilder;
+  friend class FunctionDeclSyntax;
+
   enum class Cursor : CursorIndex {
     LeftAngleBracketToken,
     GenericParameterList,
@@ -478,6 +536,35 @@
   }
 };
 
+#pragma mark - generic-requirement-list Data
+
+using GenericRequirementListSyntaxData =
+  SyntaxCollectionData<SyntaxKind::GenericRequirementList,
+  GenericRequirementSyntax>;
+
+#pragma mark - generic-requirement-list API
+
+/// requirement-list -> requirement | requirement ',' requirement-list
+///
+/// requirement -> conformance-requirement | same-type-requirement
+class GenericRequirementListSyntax final
+  : public SyntaxCollection<SyntaxKind::GenericRequirementList,
+      GenericRequirementSyntax> {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
+
+  using DataType = GenericRequirementListSyntaxData;
+
+  GenericRequirementListSyntax(const RC<SyntaxData> Root,
+                               const DataType *Data)
+      : SyntaxCollection(Root, Data) {}
+public:
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::GenericRequirementList;
+  }
+};
+
 #pragma mark - generic-argument-clause Builder
 
 class GenericArgumentClauseBuilder {
@@ -500,47 +587,6 @@
   GenericArgumentClauseSyntax build() const;
 };
 
-#pragma mark - generic-requirement-list Data
-
-class GenericRequirementListSyntaxData final : public SyntaxData {
-  friend class SyntaxData;
-  GenericRequirementListSyntaxData(RC<RawSyntax> Raw,
-                                   const SyntaxData *Parent = nullptr,
-                                   CursorIndex IndexInParent = 0);
-  static RC<GenericRequirementListSyntaxData>
-  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
-       CursorIndex IndexInParent = 0);
-  static RC<GenericRequirementListSyntaxData> makeBlank();
-public:
-  static bool classof(const SyntaxData *S) {
-    return S->getKind() == SyntaxKind::GenericRequirementList;
-  }
-};
-
-#pragma mark - generic-requirement-list API
-
-/// requirement-list -> requirement | requirement ',' requirement-list
-///
-/// requirement -> conformance-requirement | same-type-requirement
-class GenericRequirementListSyntax final : public Syntax {
-  friend struct SyntaxFactory;
-
-  GenericRequirementListSyntax(RC<SyntaxData> Root,
-                               GenericRequirementListSyntaxData *Data);
-
-  static GenericRequirementListSyntax make(RC<RawSyntax> Raw);
-  static GenericRequirementListSyntax makeBlank();
-
-public:
-  // TODO: getRequirement(unsigned n) const;
-  // TODO: withAddedRequirement(llvm::Optional<RC<TokenSyntax>> MaybeComma,
-  //                            GenericRequirementSyntax NewRequirement) const;
-
-  static bool classof(const Syntax *S) {
-    return S->getKind() == SyntaxKind::GenericRequirementList;
-  }
-};
-
 #pragma mark - generic-where-clause Data
 
 class GenericWhereClauseSyntaxData final : public SyntaxData {
@@ -549,12 +595,12 @@
 
   RC<GenericRequirementListSyntaxData> CachedRequirementList;
 
-  GenericWhereClauseSyntaxData(RC<RawSyntax> Raw,
+  GenericWhereClauseSyntaxData(const RC<RawSyntax> Raw,
                                const SyntaxData *Parent = nullptr,
-                               CursorIndex IndexInParent = 0);
-  static RC<GenericWhereClauseSyntaxData> make(RC<RawSyntax> Raw,
-                                               const SyntaxData *Parent = nullptr,
-                                               CursorIndex IndexInParent = 0);
+                               const CursorIndex IndexInParent = 0);
+  static RC<GenericWhereClauseSyntaxData>
+  make(const RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       const CursorIndex IndexInParent = 0);
   static RC<GenericWhereClauseSyntaxData> makeBlank();
 
 public:
@@ -568,12 +614,16 @@
 /// generic-where-clause -> 'where' requirement-list
 class GenericWhereClauseSyntax final : public Syntax {
   friend struct SyntaxFactory;
+  friend class Syntax;
+  friend class SyntaxData;
   friend class GenericWhereClauseSyntaxData;
   enum class Cursor : CursorIndex {
-    WhereToken,
+    WhereKeyword,
     RequirementList,
   };
 
+  using DataType = GenericWhereClauseSyntaxData;
+
   GenericWhereClauseSyntax(RC<SyntaxData> Root,
                            const GenericWhereClauseSyntaxData *Data);
 
diff --git a/include/swift/Syntax/Rewriter.h b/include/swift/Syntax/Rewriter.h
index 224373d..ae7c208 100644
--- a/include/swift/Syntax/Rewriter.h
+++ b/include/swift/Syntax/Rewriter.h
@@ -24,6 +24,7 @@
 
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/DeclSyntax.h"
+#include "swift/Syntax/GenericSyntax.h"
 #include "swift/Syntax/ExprSyntax.h"
 #include "swift/Syntax/StmtSyntax.h"
 #include "swift/Syntax/Syntax.h"
diff --git a/include/swift/Syntax/StmtSyntax.h b/include/swift/Syntax/StmtSyntax.h
index d4c93a5..f0bba83 100644
--- a/include/swift/Syntax/StmtSyntax.h
+++ b/include/swift/Syntax/StmtSyntax.h
@@ -57,9 +57,11 @@
 ///            | do-statement ';'?
 ///            | compiler-control-statement ';'?
 class StmtSyntax : public Syntax {
+  friend class Syntax;
 protected:
   StmtSyntax(const RC<SyntaxData> Root, const StmtSyntaxData *Data);
 public:
+  using DataType = StmtSyntaxData;
   static bool classof(const Syntax *S) {
     return S->isStmt();
   }
@@ -130,6 +132,7 @@
   };
   friend struct SyntaxFactory;
   friend class CodeBlockStmtSyntaxData;
+  friend class FunctionDeclSyntax;
 
   CodeBlockStmtSyntax(const RC<SyntaxData> Root, CodeBlockStmtSyntaxData *Data);
 
@@ -166,58 +169,33 @@
 #pragma mark -
 #pragma mark statements Data
 
-class StmtListSyntaxData final : public StmtSyntaxData {
-  friend class SyntaxData;
-  friend class StmtListSyntax;
-  friend class StmtListSyntaxBuilder;
-
-  StmtListSyntaxData(RC<RawSyntax> Raw,
-                     const SyntaxData *Parent = nullptr,
-                     CursorIndex IndexInParent = 0);
-  static RC<StmtListSyntaxData> make(RC<RawSyntax> Raw,
-                                     const SyntaxData *Parent = nullptr,
-                                     CursorIndex IndexInParent = 0);
-  static RC<StmtListSyntaxData> makeBlank();
-
-public:
-  static bool classof(const SyntaxData *SD) {
-    return SD->getKind() == SyntaxKind::StmtList;
-  }
-};
+using StmtListSyntaxData =
+  SyntaxCollectionData<SyntaxKind::StmtList, StmtSyntax>;
 
 #pragma mark -
 #pragma mark statements API
 
 /// statements -> statement
 ///             | statement statements
-class StmtListSyntax final : public Syntax {
+class StmtListSyntax final
+    : public SyntaxCollection<SyntaxKind::StmtList, StmtSyntax> {
   friend struct SyntaxFactory;
-  friend class StmtListSyntaxBuilder;
+  friend class Syntax;
   friend class SyntaxData;
+  friend class FunctionDeclSyntax;
 
   using DataType = StmtListSyntaxData;
 
-  StmtListSyntax(const RC<SyntaxData> Root, const StmtListSyntaxData *Data);
-public:
-  /// Returns a new statement list with an additional statement.
-  StmtListSyntax withAddedStatement(Syntax AdditionalStatement) const;
+  StmtListSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : SyntaxCollection(Root, Data) {}
 
+public:
   static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::StmtList;
   }
 };
 
 #pragma mark -
-#pragma mark statements Builder
-
-class StmtListSyntaxBuilder final {
-  RawSyntax::LayoutList StmtListLayout;
-public:
-  StmtListSyntaxBuilder &addStatement(Syntax Statement);
-  StmtListSyntax build() const;
-};
-
-#pragma mark -
 #pragma mark fallthrough-statement Data
 
 class FallthroughStmtSyntaxData final : public StmtSyntaxData {
diff --git a/include/swift/Syntax/Syntax.h b/include/swift/Syntax/Syntax.h
index 7be6fd9..d1cc24d 100644
--- a/include/swift/Syntax/Syntax.h
+++ b/include/swift/Syntax/Syntax.h
@@ -52,7 +52,6 @@
   friend class SyntaxData;
   friend class LegacyASTTransformer;
   friend class sema::Semantics;
-  using DataType = SyntaxData;
 
 #define SYNTAX(Id, Parent) friend class Id##Syntax;
 #include "swift/Syntax/SyntaxKinds.def"
@@ -75,6 +74,8 @@
   }
 
 public:
+  using DataType = SyntaxData;
+
   Syntax(const RC<SyntaxData> Root, const SyntaxData *Data);
 
   /// Get the kind of syntax.
@@ -150,7 +151,7 @@
   /// Print a debug representation of the syntax node to standard error.
   void dump() const;
 
-  bool hasSameIdentityAs(const Syntax &Other) {
+  bool hasSameIdentityAs(const Syntax &Other) const {
     return Root == Other.Root && Data == Other.Data;
   }
 
diff --git a/include/swift/Syntax/SyntaxCollection.h b/include/swift/Syntax/SyntaxCollection.h
new file mode 100644
index 0000000..37b87c8
--- /dev/null
+++ b/include/swift/Syntax/SyntaxCollection.h
@@ -0,0 +1,183 @@
+#ifndef SWIFT_SYNTAX_SYNTAXCOLLECTION_H
+#define SWIFT_SYNTAX_SYNTAXCOLLECTION_H
+
+#include "swift/Syntax/Syntax.h"
+#include "swift/Syntax/SyntaxCollectionData.h"
+
+namespace swift {
+namespace syntax {
+
+template <SyntaxKind CollectionKind, typename Element>
+struct SyntaxCollectionIterator {
+  const SyntaxCollection<CollectionKind, Element> &Collection;
+  size_t Index;
+
+  Element operator*() {
+    return Collection[Index];
+  }
+
+  SyntaxCollectionIterator<CollectionKind, Element> &operator++() {
+    ++Index;
+    return *this;
+  }
+
+  bool
+  operator==(const SyntaxCollectionIterator<CollectionKind, Element> &Other) {
+    return Collection.hasSameIdentityAs(Other.Collection) &&
+    Index == Other.Index;
+  }
+
+  bool
+  operator!=(const SyntaxCollectionIterator<CollectionKind, Element> &Other) {
+    return !operator==(Other);
+
+  }
+};
+
+/// A generic unbounded collection of syntax nodes
+template <SyntaxKind CollectionKind, typename Element>
+class SyntaxCollection : public Syntax {
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class Syntax;
+  using DataType = SyntaxCollectionData<CollectionKind, Element>;
+
+protected:
+  SyntaxCollection(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
+public:
+
+  /// Returns true if the collection is empty.
+  bool empty() const {
+    return size() == 0;
+  }
+
+  /// Returns the number of elements in the collection.
+  size_t size() const {
+    return getRaw()->Layout.size();
+  }
+
+  SyntaxCollectionIterator<CollectionKind, Element> begin() const {
+    return SyntaxCollectionIterator<CollectionKind, Element> {
+      *this,
+      0,
+    };
+  }
+
+  SyntaxCollectionIterator<CollectionKind, Element> end() const {
+    return SyntaxCollectionIterator<CollectionKind, Element> {
+      *this,
+      getRaw()->Layout.size(),
+    };
+  }
+
+  /// Return the element at the given Index.
+  ///
+  /// Precondition: Index < size()
+  /// Precondition: !empty()
+  Element operator[](const size_t Index) const {
+    assert(Index < size());
+    assert(!empty());
+
+    auto RawElement = getRaw()->Layout[Index];
+    auto *MyData = getUnsafeData<SyntaxCollection<CollectionKind, Element>>();
+
+    if (auto Data = MyData->CachedElements[Index].get()) {
+      return Element { Root, Data };
+    }
+
+    auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+      MyData->CachedElements.data() + Index);
+
+    SyntaxData::realizeSyntaxNode<Element>(ChildPtr, RawElement, MyData, Index);
+
+    return Element {
+      Root,
+      MyData->CachedElements[Index].get()
+    };
+  }
+
+  /// Return a new collection with the given element added to the end.
+  SyntaxCollection<CollectionKind, Element>
+  appending(Element E) const {
+    auto NewLayout = getRaw()->Layout;
+    NewLayout.push_back(E.getRaw());
+    auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  /// Return a new collection with an element removed from the end.
+  ///
+  /// Precondition: !empty()
+  SyntaxCollection<CollectionKind, Element> removingLast() const {
+    assert(!empty());
+    auto NewLayout = getRaw()->Layout;
+    NewLayout.pop_back();
+    auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  /// Return a new collection with the given element appended to the front.
+  SyntaxCollection<CollectionKind, Element>
+  prepending(Element E) const {
+    RawSyntax::LayoutList NewLayout = { E.getRaw() };
+    std::copy(getRaw()->Layout.begin(),
+              getRaw()->Layout.end(),
+              std::back_inserter(NewLayout));
+    auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  /// Return a new collection with an element removed from the end.
+  ///
+  /// Precondition: !empty()
+  SyntaxCollection<CollectionKind, Element> removingFirst() const {
+    assert(!empty());
+    RawSyntax::LayoutList NewLayout;
+    std::copy(getRaw()->Layout.begin() + 1,
+              getRaw()->Layout.end(),
+              std::back_inserter(NewLayout));
+    auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  /// Return a new collection with the Element inserted at index i.
+  ///
+  /// Precondition: i <= size()
+  SyntaxCollection<CollectionKind, Element>
+  inserting(size_t i, Element E) const {
+    assert(i <= size());
+    RawSyntax::LayoutList NewLayout;
+    std::copy(getRaw()->Layout.begin(), getRaw()->Layout.begin() + i,
+              std::back_inserter(NewLayout));
+    NewLayout.push_back(E.getRaw());
+    std::copy(getRaw()->Layout.begin() + i, getRaw()->Layout.end(),
+              std::back_inserter(NewLayout));
+    auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  /// Return a new collection with the element removed at index i.
+  SyntaxCollection<CollectionKind, Element> removing(size_t i) const {
+    auto NewLayout = getRaw()->Layout;
+    NewLayout.erase(NewLayout.begin() + i);
+    auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  /// Return an empty syntax collection of this type.
+  SyntaxCollection<CollectionKind, Element> cleared() const {
+    auto Raw = RawSyntax::make(CollectionKind, {}, getRaw()->Presence);
+    return Data->replaceSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+  }
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == CollectionKind;
+  }
+};
+
+} // end namespace syntax
+} // end namespace swift
+
+#endif // SWIFT_SYNTAX_SYNTAXCOLLECTION_H
diff --git a/include/swift/Syntax/SyntaxCollectionData.h b/include/swift/Syntax/SyntaxCollectionData.h
new file mode 100644
index 0000000..1970f3b
--- /dev/null
+++ b/include/swift/Syntax/SyntaxCollectionData.h
@@ -0,0 +1,53 @@
+#ifndef SWIFT_SYNTAX_SYNTAXCOLLECTIONDATA_H
+#define SWIFT_SYNTAX_SYNTAXCOLLECTIONDATA_H
+
+#include "swift/Syntax/SyntaxData.h"
+
+namespace swift {
+namespace syntax {
+
+template <SyntaxKind CollectionKind, typename ElementType>
+class SyntaxCollection;
+
+template <SyntaxKind CollectionKind, typename ElementType>
+class SyntaxCollectionData : public SyntaxData {
+  friend class SyntaxCollection<CollectionKind, ElementType>;
+  std::vector<RC<typename ElementType::DataType>> CachedElements;
+
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class FunctionCallExprSyntaxBuilder;
+
+  SyntaxCollectionData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+                       CursorIndex IndexInParent = 0)
+      : SyntaxData(Raw, Parent, IndexInParent),
+        CachedElements(Raw->Layout.size(), nullptr) {
+    assert(Raw->Kind == CollectionKind);
+  }
+
+  static RC<SyntaxCollectionData<CollectionKind, ElementType>>
+  make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+       CursorIndex IndexInParent = 0) {
+
+    return RC<SyntaxCollectionData<CollectionKind, ElementType>> {
+      new SyntaxCollectionData<CollectionKind, ElementType> {
+        Raw, Parent, IndexInParent
+      }
+    };
+  }
+
+  static RC<SyntaxCollectionData<CollectionKind, ElementType>> makeBlank() {
+    auto Raw = RawSyntax::make(CollectionKind, {}, SourcePresence::Present);
+    return make(Raw);
+  }
+
+public:
+  static bool classof(const SyntaxData *SD) {
+    return SD->getKind() == CollectionKind;
+  }
+};
+
+} // end namespace syntax
+} // end namespace swift
+
+#endif
diff --git a/include/swift/Syntax/SyntaxData.h b/include/swift/Syntax/SyntaxData.h
index f27e59e..8fcd79b 100644
--- a/include/swift/Syntax/SyntaxData.h
+++ b/include/swift/Syntax/SyntaxData.h
@@ -77,7 +77,7 @@
   ///
   /// If there is no parent, this is 0.
   const CursorIndex IndexInParent;
-protected:
+
   SyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
              CursorIndex IndexInParent = 0)
     : Raw(Raw), Parent(Parent), IndexInParent(IndexInParent) {}
diff --git a/include/swift/Syntax/SyntaxFactory.h b/include/swift/Syntax/SyntaxFactory.h
index d1d74c8..c99c8d3 100644
--- a/include/swift/Syntax/SyntaxFactory.h
+++ b/include/swift/Syntax/SyntaxFactory.h
@@ -51,6 +51,26 @@
   makeUnknownSyntax(llvm::ArrayRef<RC<TokenSyntax>> Tokens);
 
 #pragma mark - Declarations
+
+#pragma mark - declaration-modifier
+
+  /// Make a declaration modifier with the specified elements.
+  static DeclModifierSyntax
+  makeDeclModifier(RC<TokenSyntax> Name, RC<TokenSyntax> LeftParen,
+                   RC<TokenSyntax> Argument, RC<TokenSyntax> RightParen);
+
+  /// Make a declaration modifier with all missing elements.
+  static DeclModifierSyntax makeBlankDeclModifier();
+
+  /// Make a declaration modifier list with the specified modifiers.
+  static DeclModifierListSyntax
+  makeDeclModifierList(const std::vector<DeclModifierSyntax> &Modifiers);
+
+  /// Make an empty declaration modifier list.
+  static DeclModifierListSyntax makeBlankDeclModifierList();
+
+#pragma mark - struct-declaration
+
   /// Make a struct declaration with the specified elements.
   static StructDeclSyntax
   makeStructDecl(RC<TokenSyntax> StructToken, RC<TokenSyntax> Identifier,
@@ -73,6 +93,65 @@
   /// Make an empty list of declaration members.
   static DeclMembersSyntax makeBlankDeclMembers();
 
+  /// Make a function declaration with the specified elements.
+  static FunctionDeclSyntax
+  makeFunctionDecl(TypeAttributesSyntax Attributes,
+                   DeclModifierListSyntax Modifiers,
+                   RC<TokenSyntax> FuncKeyword,
+                   RC<TokenSyntax> Identifier,
+                   llvm::Optional<GenericParameterClauseSyntax> GenericParams,
+                   FunctionSignatureSyntax Signature,
+                   llvm::Optional<GenericWhereClauseSyntax> GenericWhereClause,
+                   llvm::Optional<CodeBlockStmtSyntax> Body);
+
+  /// Make a function declaration with all missing elements.
+  static FunctionDeclSyntax makeBlankFunctionDecl();
+
+#pragma mark - function-parameter
+
+  /// Make a function parameter with the given elements.
+  static FunctionParameterSyntax
+  makeFunctionParameter(RC<TokenSyntax> ExternalName, RC<TokenSyntax> LocalName,
+                        RC<TokenSyntax> Colon,
+                        llvm::Optional<TypeSyntax> ParameterTypeSyntax,
+                        RC<TokenSyntax> Ellipsis,
+                        RC<TokenSyntax> Equal,
+                        llvm::Optional<ExprSyntax> DefaultValue,
+                        RC<TokenSyntax> TrailingComma);
+
+  /// Make a function parameter with all elements marked as missing.
+  static FunctionParameterSyntax makeBlankFunctionParameter();
+
+#pragma mark - function-parameter-list
+
+  /// Make a function parameter list with the given parameters.
+  static FunctionParameterListSyntax makeFunctionParameterList(
+    const std::vector<FunctionParameterSyntax> &Parameters);
+
+  /// Make an empty function parameter list.
+  static FunctionParameterListSyntax makeBlankFunctionParameterList();
+
+#pragma mark - function-signature
+
+  /// Make a function signature with the given elements.
+  static FunctionSignatureSyntax
+  makeFunctionSignature(RC<TokenSyntax> LeftParen,
+                        FunctionParameterListSyntax ParameterList,
+                        RC<TokenSyntax> RightParen,
+                        RC<TokenSyntax> ThrowsOrRethrows,
+                        RC<TokenSyntax> Arrow,
+                        TypeAttributesSyntax ReturnTypeAttributes,
+                        TypeSyntax ReturnTypeSyntax);
+
+  /// Make a blank function signature.
+  static FunctionSignatureSyntax makeBlankFunctionSignature();
+
+  //-/ Make a function declaration with the given elements.
+  // TODO
+
+  //-/ Make a blank function declaration.
+  // TODO
+
 #pragma mark - Statements
 
   /// Make a code block with the specified elements.
@@ -119,6 +198,12 @@
   /// marked as missing.
   static ReturnStmtSyntax makeBlankReturnStmt();
 
+  /// Make a statement list from a loosely connected list of statements.
+  static StmtListSyntax makeStmtList(const std::vector<StmtSyntax> &Statements);
+
+  /// Make an empty statement list.
+  static StmtListSyntax makeBlankStmtList();
+
 #pragma mark - Expressions
 
   /// Make an integer literal with the given '+'/'-' sign and string of digits.
@@ -168,6 +253,19 @@
 
 #pragma mark - Tokens
 
+  /// Make a 'static' keyword with the specified leading and trailing trivia.
+  static RC<TokenSyntax> makeStaticKeyword(const Trivia &LeadingTrivia,
+                                           const Trivia &TrailingTrivia);
+
+
+  /// Make a 'public' keyword with the specified leading and trailing trivia.
+  static RC<TokenSyntax> makePublicKeyword(const Trivia &LeadingTrivia,
+                                           const Trivia &TrailingTrivia);
+
+  /// Make a 'func' keyword with the specified leading and trailing trivia.
+  static RC<TokenSyntax> makeFuncKeyword(const Trivia &LeadingTrivia,
+                                         const Trivia &TrailingTrivia);
+
   /// Make a 'fallthrough' keyword with the specified leading and
   /// trailing trivia.
   static RC<TokenSyntax> makeFallthroughKeyword(const Trivia &LeadingTrivia,
@@ -213,6 +311,17 @@
   static RC<TokenSyntax> makeRightParenToken(const Trivia &LeadingTrivia,
                                             const Trivia &TrailingTrivia);
 
+  /// Make a left brace '{' token with the specified leading and
+  /// trailing trivia.
+  static RC<TokenSyntax> makeLeftBraceToken(const Trivia &LeadingTrivia,
+                                            const Trivia &TrailingTrivia);
+
+  /// Make a right brace '}' token with the specified leading and
+  /// trailing trivia.
+  static RC<TokenSyntax> makeRightBraceToken(const Trivia &LeadingTrivia,
+                                             const Trivia &TrailingTrivia);
+
+
   /// Make a left square bracket '[' token with the specified leading and
   /// trailing trivia.
   static RC<TokenSyntax>
@@ -333,6 +442,8 @@
   /// Make a set of type attributes with all elements marked as missing.
   static TypeAttributesSyntax makeBlankTypeAttributes();
 
+#pragma mark - balanced-tokens
+
   /// Make a list of balanced tokens.
   static BalancedTokensSyntax
   makeBalancedTokens(RawSyntax::LayoutList Tokens);
@@ -340,6 +451,8 @@
   /// Make an empty list of balanced tokens.
   static BalancedTokensSyntax makeBlankBalancedTokens();
 
+#pragma mark - type-identifier
+
   /// Make a non-generic type identifier with some name.
   static TypeIdentifierSyntax
   makeTypeIdentifier(OwnedString Name, const Trivia &LeadingTrivia,
@@ -356,6 +469,8 @@
   /// Make a bare "Self" type.
   static TypeIdentifierSyntax makeSelfTypeIdentifier();
 
+#pragma mark - tuple-type
+
   /// Make a bare "()" void tuple type
   static TupleTypeSyntax makeVoidTupleType();
 
@@ -366,6 +481,8 @@
   /// Make a tuple type element without a label.
   static TupleTypeElementSyntax makeTupleTypeElement(TypeSyntax ElementType);
 
+#pragma mark - optional-type
+
   /// Make an optional type, such as `Int?`
   static OptionalTypeSyntax
   makeOptionalType(TypeSyntax BaseType, const Trivia &TrailingTrivia);
@@ -373,6 +490,8 @@
   /// Make an optional type with all elements marked as missing.
   static OptionalTypeSyntax makeBlankOptionalType();
 
+#pragma mark - implicitly-unwrapped-optional-type
+
   /// Make an implicitly unwrapped optional type, such as `Int!`
   static ImplicitlyUnwrappedOptionalTypeSyntax
   makeImplicitlyUnwrappedOptionalType(TypeSyntax BaseType,
@@ -381,6 +500,8 @@
   static ImplicitlyUnwrappedOptionalTypeSyntax
   makeBlankImplicitlyUnwrappedOptionalType();
 
+#pragma mark - metatype-type
+
   /// Make a metatype type, as in `T.Type`
   /// `Type` is a terminal token here, not a placeholder for something else.
   static MetatypeTypeSyntax makeMetatypeType(TypeSyntax BaseType,
@@ -390,6 +511,8 @@
   /// Make a metatype type with all elements marked as missing.
   static MetatypeTypeSyntax makeBlankMetatypeType();
 
+#pragma mark - array-type
+
   /// Make a sugared Array type, as in `[MyType]`.
   static ArrayTypeSyntax makeArrayType(RC<TokenSyntax> LeftSquareBracket,
                                        TypeSyntax ElementType,
@@ -398,6 +521,8 @@
   /// Make an array type with all elements marked as missing.
   static ArrayTypeSyntax makeBlankArrayType();
 
+#pragma mark - dictionary-type
+
   /// Make a Dictionary type, as in `[Key : Value]`.
   static DictionaryTypeSyntax
   makeDictionaryType(RC<TokenSyntax> LeftSquareBracket, TypeSyntax KeyType,
@@ -407,6 +532,8 @@
   /// Make an a dictionary type with all elements marked as missing.
   static DictionaryTypeSyntax makeBlankDictionaryType();
 
+#pragma mark - function-type-argument
+
   /// Make a function argument type syntax with the specified elements.
   static FunctionTypeArgumentSyntax
   makeFunctionTypeArgument(RC<TokenSyntax> ExternalParameterName,
@@ -431,6 +558,8 @@
   /// Make a function argument type syntax with all elements marked as missing.
   static FunctionTypeArgumentSyntax makeBlankFunctionArgumentType();
 
+#pragma mark - function-type
+
   /// Make a function type, for example, `(Int, Int) throws -> Int`
   static FunctionTypeSyntax
   makeFunctionType(TypeAttributesSyntax TypeAttributes,
@@ -442,6 +571,8 @@
   /// Make a function type with all elements marked as missing.
   static FunctionTypeSyntax makeBlankFunctionType();
 
+#pragma mark - type-argument-list
+
   /// Make a list of type arguments with all elements marked as missing.
   static TypeArgumentListSyntax makeBlankTypeArgumentList();
 
@@ -464,6 +595,14 @@
   makeSameTypeRequirement(TypeIdentifierSyntax LeftTypeIdentifier,
                           RC<TokenSyntax> EqualityToken, TypeSyntax RightType);
 
+  /// Make a list of generic requirements with the given loosely collected
+  /// requirements/
+  static GenericRequirementListSyntax makeGenericRequirementList(
+    std::vector<GenericRequirementSyntax> &Requirements);
+
+  /// Make an empty list of generic requirements.
+  static GenericRequirementListSyntax makeBlankGenericRequirementList();
+
   /// Make a same-type requirement with all elements marked as missing.
   static SameTypeRequirementSyntax makeBlankSameTypeRequirement();
 
diff --git a/include/swift/Syntax/SyntaxKinds.def b/include/swift/Syntax/SyntaxKinds.def
index 941d50d..2c0fa59 100644
--- a/include/swift/Syntax/SyntaxKinds.def
+++ b/include/swift/Syntax/SyntaxKinds.def
@@ -40,8 +40,9 @@
   SYNTAX(UnknownDecl, DeclSyntax)
   SYNTAX(StructDecl, DeclSyntax)
   SYNTAX(TypeAliasDecl, DeclSyntax)
+  SYNTAX(FunctionDecl, DeclSyntax)
 
-SYNTAX_RANGE(Decl, MissingDecl, TypeAliasDecl)
+SYNTAX_RANGE(Decl, MissingDecl, FunctionDecl)
 
 SYNTAX(DeclMembers, Syntax)
 SYNTAX(GenericParameter, Syntax)
@@ -52,8 +53,9 @@
 SYNTAX(GenericRequirementList, Syntax)
 SYNTAX(GenericArgumentClause, Syntax)
 SYNTAX(GenericArgumentList, Syntax)
-SYNTAX(ConformanceRequirement, Syntax)
-SYNTAX(SameTypeRequirement, Syntax)
+ABSTRACT_SYNTAX(GenericRequirementSyntax, Syntax)
+  SYNTAX(ConformanceRequirement, GenericRequirementSyntax)
+  SYNTAX(SameTypeRequirement, GenericRequirementSyntax)
 SYNTAX(TypeArgumentList, Syntax)
 
 // Types
@@ -98,6 +100,11 @@
 SYNTAX(FunctionTypeArgument, Syntax)
 SYNTAX(FunctionCallArgumentList, Syntax)
 SYNTAX(FunctionCallArgument, Syntax)
+SYNTAX(FunctionSignature, Syntax)
+SYNTAX(FunctionParameterList, Syntax)
+SYNTAX(FunctionParameter, Syntax)
+SYNTAX(DeclModifier, Syntax)
+SYNTAX(DeclModifierList, Syntax)
 
 #undef ABSTRACT_SYNTAX
 #undef DECL
diff --git a/include/swift/Syntax/TypeSyntax.h b/include/swift/Syntax/TypeSyntax.h
index 07bf362..d8bee68 100644
--- a/include/swift/Syntax/TypeSyntax.h
+++ b/include/swift/Syntax/TypeSyntax.h
@@ -186,13 +186,16 @@
   friend struct SyntaxFactory;
   friend class TypeAttributesSyntaxData;
   friend class SyntaxData;
+  friend class FunctionSignatureSyntax;
+  friend class FunctionDeclSyntax;
 
   using DataType = TypeAttributesSyntaxData;
 
   TypeAttributesSyntax(RC<SyntaxData> Root,
                        const TypeAttributesSyntaxData *Data);
 public:
-  // TODO: TODO: TypeAttributesSyntax::getAttribute
+  // TODO: Convert to SyntaxCollection
+  // 
 
   TypeAttributesSyntax
   addTypeAttribute(TypeAttributeSyntax NewTypeAttribute) const;
@@ -235,6 +238,8 @@
 class TypeSyntax : public Syntax {
   using DataType = TypeSyntaxData;
   friend class SyntaxData;
+  friend class FunctionParameterSyntax;
+  friend class FunctionSignatureSyntax;
 protected:
   TypeSyntax(const RC<SyntaxData> Root, const TypeSyntaxData *Data);
 public:
diff --git a/include/swift/Syntax/UnknownSyntax.h b/include/swift/Syntax/UnknownSyntax.h
index 7158e03..39d265b 100644
--- a/include/swift/Syntax/UnknownSyntax.h
+++ b/include/swift/Syntax/UnknownSyntax.h
@@ -1,4 +1,4 @@
-//===--- UnknownSyntax.h - Swift Unknown Syntax Interface -----------------===//
+//===--- UnknownSyntax.h - Swift Unknown Syntax Interface -------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 70f5135..1045062 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -28,6 +28,7 @@
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/ModuleLoader.h"
 #include "swift/AST/NameLookup.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/RawComment.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
@@ -3606,6 +3607,36 @@
   return nullptr;
 }
 
+bool ForeignRepresentationInfo::isRepresentableAsOptional() const {
+  switch (getKind()) {
+  case ForeignRepresentableKind::None:
+    llvm_unreachable("this type is not representable");
+
+  case ForeignRepresentableKind::Trivial:
+    return Storage.getPointer() != 0;
+
+  case ForeignRepresentableKind::Bridged: {
+    auto KPK_ObjectiveCBridgeable = KnownProtocolKind::ObjectiveCBridgeable;
+    ProtocolDecl *proto = getConformance()->getProtocol();
+    assert(proto->isSpecificProtocol(KPK_ObjectiveCBridgeable) &&
+           "unknown protocol; does it support optional?");
+    (void)proto;
+    (void)KPK_ObjectiveCBridgeable;
+
+    return true;
+  }
+
+  case ForeignRepresentableKind::BridgedError:
+    return true;
+
+  case ForeignRepresentableKind::Object:
+  case ForeignRepresentableKind::StaticBridged:
+    llvm_unreachable("unexpected kind in ForeignRepresentableCacheEntry");
+  }
+
+  llvm_unreachable("Unhandled ForeignRepresentableKind in switch.");
+}
+
 ForeignRepresentationInfo
 ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
                                          ForeignLanguage language,
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
index 7be8ea7..9d35f66 100644
--- a/lib/AST/ASTDumper.cpp
+++ b/lib/AST/ASTDumper.cpp
@@ -29,6 +29,7 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/raw_ostream.h"
@@ -207,6 +208,8 @@
   case SILFunctionType::Representation::WitnessMethod: return "witness_method";
   case SILFunctionType::Representation::Closure: return "closure";
   }
+
+  llvm_unreachable("Unhandled SILFunctionTypeRepresentation in switch.");
 }
 static StringRef
 getAbstractStorageDeclKindString(AbstractStorageDecl::StorageKindTy value) {
@@ -230,6 +233,8 @@
   case AbstractStorageDecl::Computed:
     return "computed";
   }
+
+  llvm_unreachable("Unhandled AbstractStorageDecl in switch.");
 }
 static StringRef getImportKindString(ImportKind value) {
   switch (value) {
@@ -242,6 +247,8 @@
   case ImportKind::Var: return "var";
   case ImportKind::Func: return "func";
   }
+  
+  llvm_unreachable("Unhandled ImportKind in switch.");
 }
 static StringRef getAccessibilityString(Accessibility value) {
   switch (value) {
@@ -251,6 +258,8 @@
   case Accessibility::Public: return "public";
   case Accessibility::Open: return "open";
   }
+
+  llvm_unreachable("Unhandled Accessibility in switch.");
 }
 static StringRef
 getForeignErrorConventionKindString(ForeignErrorConvention::Kind value) {
@@ -261,6 +270,8 @@
   case ForeignErrorConvention::NilResult: return "NilResult";
   case ForeignErrorConvention::NonNilError: return "NonNilError";
   }
+
+  llvm_unreachable("Unhandled ForeignErrorConvention in switch.");
 }
 static StringRef getDefaultArgumentKindString(DefaultArgumentKind value) {
   switch (value) {
@@ -276,6 +287,8 @@
     case DefaultArgumentKind::EmptyDictionary: return "[:]";
     case DefaultArgumentKind::Normal: return "normal";
   }
+
+  llvm_unreachable("Unhandled DefaultArgumentKind in switch.");
 }
 static StringRef getAccessorKindString(AccessorKind value) {
   switch (value) {
@@ -288,6 +301,8 @@
     case AccessorKind::IsAddressor: return "addressor";
     case AccessorKind::IsMutableAddressor: return "mutableAddressor";
   }
+
+  llvm_unreachable("Unhandled AccessorKind in switch.");
 }
 static StringRef getAccessKindString(AccessKind value) {
   switch (value) {
@@ -295,6 +310,8 @@
     case AccessKind::Write: return "write";
     case AccessKind::ReadWrite: return "readwrite";
   }
+
+  llvm_unreachable("Unhandled AccessKind in switch.");
 }
 static StringRef
 getMagicIdentifierLiteralExprKindString(MagicIdentifierLiteralExpr::Kind value) {
@@ -305,6 +322,8 @@
     case MagicIdentifierLiteralExpr::Column: return "#column";
     case MagicIdentifierLiteralExpr::DSOHandle: return "#dsohandle";
   }
+
+  llvm_unreachable("Unhandled MagicIdentifierLiteralExpr in switch.");
 }
 static StringRef
 getObjCSelectorExprKindString(ObjCSelectorExpr::ObjCSelectorKind value) {
@@ -313,6 +332,8 @@
     case ObjCSelectorExpr::Getter: return "getter";
     case ObjCSelectorExpr::Setter: return "setter";
   }
+
+  llvm_unreachable("Unhandled ObjCSelectorExpr in switch.");
 }
 static StringRef getAccessSemanticsString(AccessSemantics value) {
   switch (value) {
@@ -321,6 +342,8 @@
     case AccessSemantics::DirectToAccessor: return "direct_to_accessor";
     case AccessSemantics::BehaviorInitialization: return "behavior_init";
   }
+
+  llvm_unreachable("Unhandled AccessSemantics in switch.");
 }
 static StringRef getMetatypeRepresentationString(MetatypeRepresentation value) {
   switch (value) {
@@ -328,6 +351,8 @@
     case MetatypeRepresentation::Thick: return "thick";
     case MetatypeRepresentation::ObjC: return "@objc";
   }
+
+  llvm_unreachable("Unhandled MetatypeRepresentation in switch.");
 }
 static StringRef
 getStringLiteralExprEncodingString(StringLiteralExpr::Encoding value) {
@@ -336,6 +361,8 @@
     case StringLiteralExpr::UTF16: return "utf16";
     case StringLiteralExpr::OneUnicodeScalar: return "unicodeScalar";
   }
+
+  llvm_unreachable("Unhandled StringLiteral in switch.");
 }
 static StringRef getCtorInitializerKindString(CtorInitializerKind value) {
   switch (value) {
@@ -344,6 +371,8 @@
     case CtorInitializerKind::ConvenienceFactory: return "convenience_factory";
     case CtorInitializerKind::Factory: return "factory";
   }
+
+  llvm_unreachable("Unhandled CtorInitializerKind in switch.");
 }
 static StringRef getOptionalTypeKindString(OptionalTypeKind value) {
   switch (value) {
@@ -351,6 +380,8 @@
     case OTK_Optional: return "Optional";
     case OTK_ImplicitlyUnwrappedOptional: return "ImplicitlyUnwrappedOptional";
   }
+
+  llvm_unreachable("Unhandled OptionalTypeKind in switch.");
 }
 static StringRef getAssociativityString(Associativity value) {
   switch (value) {
@@ -358,6 +389,8 @@
     case Associativity::Left: return "left";
     case Associativity::Right: return "right";
   }
+
+  llvm_unreachable("Unhandled Associativity in switch.");
 }
 
 //===----------------------------------------------------------------------===//
@@ -2615,10 +2648,18 @@
   };
 
   switch (getKind()) {
-  case ProtocolConformanceKind::Normal:
+  case ProtocolConformanceKind::Normal: {
+    auto normal = cast<NormalProtocolConformance>(this);
+
     printCommon("normal");
     // Maybe print information about the conforming context?
+
+    for (auto conformance : normal->getSignatureConformances()) {
+      out << '\n';
+      conformance.dump(out, indent + 2);
+    }
     break;
+  }
 
   case ProtocolConformanceKind::Inherited: {
     auto conf = cast<InheritedProtocolConformance>(this);
@@ -3109,13 +3150,17 @@
   Type(const_cast<TypeBase *>(this)).dump(os, indent);
 }
 
-void GenericEnvironment::dump() const {
-  llvm::errs() << "Generic environment:\n";
+void GenericEnvironment::dump(raw_ostream &os) const {
+  os << "Generic environment:\n";
   for (auto gp : getGenericParams()) {
-    gp->dump();
-    mapTypeIntoContext(gp)->dump();
+    gp->dump(os);
+    mapTypeIntoContext(gp)->dump(os);
   }
-  llvm::errs() << "Generic parameters:\n";
+  os << "Generic parameters:\n";
   for (auto paramTy : getGenericParams())
-    paramTy->dump();
+    paramTy->dump(os);
+}
+
+void GenericEnvironment::dump() const {
+  dump(llvm::errs());
 }
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
index e70cdfb..03cb39b 100644
--- a/lib/AST/ASTVerifier.cpp
+++ b/lib/AST/ASTVerifier.cpp
@@ -1997,7 +1997,8 @@
 
         if (auto req = dyn_cast<ValueDecl>(member)) {
           if (!normal->hasWitness(req)) {
-            if (req->getAttrs().isUnavailable(Ctx) &&
+            if ((req->getAttrs().isUnavailable(Ctx) ||
+                 req->getAttrs().hasAttribute<OptionalAttr>()) &&
                 proto->isObjC()) {
               continue;
             }
@@ -2025,6 +2026,40 @@
           continue;
         }
       }
+
+      // Make sure we have the right signature conformances.
+      if (!normal->isInvalid()){
+        auto conformances = normal->getSignatureConformances();
+        unsigned idx = 0;
+        for (auto req : proto->getRequirementSignature()->getRequirements()) {
+          if (req.getKind() != RequirementKind::Conformance)
+            continue;
+
+          if (idx >= conformances.size()) {
+            Out << "error: not enough conformances for requirement signature\n";
+            normal->dump(Out);
+            abort();
+          }
+
+          auto reqProto =
+            req.getSecondType()->castTo<ProtocolType>()->getDecl();
+          if (reqProto != conformances[idx].getRequirement()) {
+            Out << "error: wrong protocol in signature conformances: have "
+              << conformances[idx].getRequirement()->getName().str()
+              << ", expected " << reqProto->getName().str()<< "\n";
+            normal->dump(Out);
+            abort();
+          }
+
+          ++idx;
+        }
+
+        if (idx != conformances.size()) {
+          Out << "error: too many conformances for requirement signature\n";
+          normal->dump(Out);
+          abort();
+        }
+      }
     }
 
     void verifyGenericEnvironment(Decl *D,
diff --git a/lib/AST/ASTWalker.cpp b/lib/AST/ASTWalker.cpp
index 3bdcbe3..e790ae4 100644
--- a/lib/AST/ASTWalker.cpp
+++ b/lib/AST/ASTWalker.cpp
@@ -197,6 +197,10 @@
   }
 
   bool visitAbstractTypeParamDecl(AbstractTypeParamDecl *TPD) {
+    for (auto Inherit: TPD->getInherited()) {
+      if (doIt(Inherit))
+        return true;
+    }
     return false;
   }
 
@@ -207,10 +211,6 @@
       for (auto GP : NTD->getGenericParams()->getParams()) {
         if (doIt(GP))
           return true;
-        for(auto Inherit: GP->getInherited()) {
-          if (doIt(Inherit))
-            return true;
-        }
       }
       // Visit param conformance
       for (auto &Req : NTD->getGenericParams()->getRequirements()) {
@@ -266,10 +266,6 @@
       for (auto &P : AFD->getGenericParams()->getParams()) {
         if (doIt(P))
           return true;
-        for (auto Inherit : P->getInherited()) {
-          if (doIt(Inherit))
-            return true;
-        }
       }
 
       // Visit param conformance
diff --git a/lib/AST/ForeignRepresentationInfo.h b/lib/AST/ForeignRepresentationInfo.h
index 7dd0629..05fdb94 100644
--- a/lib/AST/ForeignRepresentationInfo.h
+++ b/lib/AST/ForeignRepresentationInfo.h
@@ -13,7 +13,6 @@
 #ifndef SWIFT_FOREIGNREPRESENTATIONINFO_H
 #define SWIFT_FOREIGNREPRESENTATIONINFO_H
 
-#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
@@ -21,6 +20,8 @@
 
 namespace swift {
 
+class ProtocolConformance;
+
 class ForeignRepresentationInfo {
   using PayloadTy =
     llvm::PointerEmbeddedInt<uintptr_t, sizeof(uintptr_t) * CHAR_BIT - 3>;
@@ -112,35 +113,7 @@
   }
 
   /// Returns true if the optional version of this type is also representable.
-  bool isRepresentableAsOptional() const {
-    switch (getKind()) {
-    case ForeignRepresentableKind::None:
-      llvm_unreachable("this type is not representable");
-
-    case ForeignRepresentableKind::Trivial:
-      return Storage.getPointer() != 0;
-
-    case ForeignRepresentableKind::Bridged: {
-      auto KPK_ObjectiveCBridgeable = KnownProtocolKind::ObjectiveCBridgeable;
-      ProtocolDecl *proto = getConformance()->getProtocol();
-      assert(proto->isSpecificProtocol(KPK_ObjectiveCBridgeable) &&
-             "unknown protocol; does it support optional?");
-      (void)proto;
-      (void)KPK_ObjectiveCBridgeable;
-
-      return true;
-    }
-
-    case ForeignRepresentableKind::BridgedError:
-      return true;
-
-    case ForeignRepresentableKind::Object:
-    case ForeignRepresentableKind::StaticBridged:
-      llvm_unreachable("unexpected kind in ForeignRepresentableCacheEntry");
-    }
-
-    llvm_unreachable("Unhandled ForeignRepresentableKind in switch.");
-  }
+  bool isRepresentableAsOptional() const;
 };
 
 } // end namespace swift
diff --git a/lib/AST/GenericEnvironment.cpp b/lib/AST/GenericEnvironment.cpp
index a1f739b..e2e805a 100644
--- a/lib/AST/GenericEnvironment.cpp
+++ b/lib/AST/GenericEnvironment.cpp
@@ -395,25 +395,27 @@
 getSubstitutionMap(SubstitutionList subs) const {
   SubstitutionMap result;
 
-  for (auto depTy : getGenericSignature()->getAllDependentTypes()) {
+  getGenericSignature()->enumeratePairedRequirements(
+    [&](Type depTy, ArrayRef<Requirement> reqts) -> bool {
+      // Map the interface type to a context type.
+      auto contextTy = depTy.subst(QueryInterfaceTypeSubstitutions(this),
+                                   MakeAbstractConformanceForGenericType());
 
-    // Map the interface type to a context type.
-    auto contextTy = depTy.subst(QueryInterfaceTypeSubstitutions(this),
-                                 MakeAbstractConformanceForGenericType());
+      auto sub = subs.front();
+      subs = subs.slice(1);
 
-    auto sub = subs.front();
-    subs = subs.slice(1);
+      // Record the replacement type and its conformances.
+      if (auto *archetype = contextTy->getAs<ArchetypeType>()) {
+        result.addSubstitution(CanArchetypeType(archetype), sub.getReplacement());
+        assert(reqts.size() == sub.getConformances().size());
+        for (auto conformance : sub.getConformances())
+          result.addConformance(CanType(archetype), conformance);
+        return false;
+      }
 
-    // Record the replacement type and its conformances.
-    if (auto *archetype = contextTy->getAs<ArchetypeType>()) {
-      result.addSubstitution(CanArchetypeType(archetype), sub.getReplacement());
-      for (auto conformance : sub.getConformances())
-        result.addConformance(CanType(archetype), conformance);
-      continue;
-    }
-
-    assert(contextTy->hasError());
-  }
+      assert(contextTy->hasError());
+      return false;
+    });
 
   assert(subs.empty() && "did not use all substitutions?!");
 
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
index 56747a6..d4c5b3b 100644
--- a/lib/AST/GenericSignature.cpp
+++ b/lib/AST/GenericSignature.cpp
@@ -78,6 +78,20 @@
   return params;
 }
 
+
+SmallVector<GenericTypeParamType *, 2>
+GenericSignature::getSubstitutableParams() const {
+  SmallVector<GenericTypeParamType *, 2> result;
+
+  enumeratePairedRequirements([&](Type depTy, ArrayRef<Requirement>) -> bool {
+    if (auto *paramTy = depTy->getAs<GenericTypeParamType>())
+      result.push_back(paramTy);
+    return false;
+  });
+
+  return result;
+}
+
 std::string GenericSignature::gatherGenericParamBindingsText(
     ArrayRef<Type> types, TypeSubstitutionFn substitutions) const {
   llvm::SmallPtrSet<GenericTypeParamType *, 2> knownGenericParams;
@@ -375,21 +389,21 @@
 GenericSignature::getSubstitutionMap(SubstitutionList subs) const {
   SubstitutionMap result;
 
-  // An empty parameter list gives an empty map.
-  if (subs.empty())
-    assert(getGenericParams().empty() || areAllParamsConcrete());
+  enumeratePairedRequirements(
+    [&](Type depTy, ArrayRef<Requirement> reqts) -> bool {
+      auto sub = subs.front();
+      subs = subs.slice(1);
 
-  for (auto depTy : getAllDependentTypes()) {
-    auto sub = subs.front();
-    subs = subs.slice(1);
+      auto canTy = depTy->getCanonicalType();
+      if (isa<SubstitutableType>(canTy))
+        result.addSubstitution(cast<SubstitutableType>(canTy),
+                               sub.getReplacement());
+      assert(reqts.size() == sub.getConformances().size());
+      for (auto conformance : sub.getConformances())
+        result.addConformance(canTy, conformance);
 
-    auto canTy = depTy->getCanonicalType();
-    if (isa<SubstitutableType>(canTy))
-      result.addSubstitution(cast<SubstitutableType>(canTy),
-                             sub.getReplacement());
-    for (auto conformance : sub.getConformances())
-      result.addConformance(canTy, conformance);
-  }
+      return false;
+    });
 
   assert(subs.empty() && "did not use all substitutions?!");
   populateParentMap(result);
@@ -430,16 +444,6 @@
   return subMap;
 }
 
-SmallVector<Type, 4> GenericSignature::getAllDependentTypes() const {
-  SmallVector<Type, 4> result;
-  enumeratePairedRequirements([&](Type type, ArrayRef<Requirement>) {
-    result.push_back(type);
-    return false;
-  });
-
-  return result;
-}
-
 void GenericSignature::
 getSubstitutions(const TypeSubstitutionMap &subs,
                  GenericSignature::LookupConformanceFn lookupConformance,
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
index b3f69c4..71dc8b2 100644
--- a/lib/AST/GenericSignatureBuilder.cpp
+++ b/lib/AST/GenericSignatureBuilder.cpp
@@ -160,6 +160,8 @@
       return false;
     }
   }
+
+  llvm_unreachable("Unhandled RequirementSourceKind in switch.");
 }
 
 const void *RequirementSource::getOpaqueStorage() const {
@@ -182,6 +184,8 @@
   case StorageKind::AssociatedTypeDecl:
     return storage.assocType;
   }
+
+  llvm_unreachable("Unhandled StorageKind in switch.");
 }
 
 const void *RequirementSource::getExtraOpaqueStorage() const {
@@ -210,6 +214,8 @@
     // need to keep them for the requirement signature.
     return parent->kind != RequirementSignatureSelf;
   }
+
+  llvm_unreachable("Unhandled RequirementSourceKind in switch.");
 }
 
 bool RequirementSource::isDerivedViaConcreteConformance() const {
@@ -418,6 +424,8 @@
   case StorageKind::AssociatedTypeDecl:
     return storage.assocType->getProtocol();
   }
+
+  llvm_unreachable("Unhandled StorageKind in switch.");
 }
 
 SourceLoc RequirementSource::getLoc() const {
@@ -569,6 +577,8 @@
   case Inferred:
     return RequirementSource::forInferred(pa, storage.get<const TypeRepr *>());
   }
+
+  llvm_unreachable("Unhandled FloatingPointRequirementSourceKind in switch.");
 }
 
 SourceLoc FloatingRequirementSource::getLoc() const {
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
index 52e5a4e..aeb4904 100644
--- a/lib/AST/ProtocolConformance.cpp
+++ b/lib/AST/ProtocolConformance.cpp
@@ -252,6 +252,25 @@
   return getRootNormalConformance()->getBehaviorDecl();
 }
 
+void NormalProtocolConformance::setSignatureConformances(
+                               ArrayRef<ProtocolConformanceRef> conformances) {
+  auto &ctx = getProtocol()->getASTContext();
+  SignatureConformances = ctx.AllocateCopy(conformances);
+
+#if !NDEBUG
+  unsigned idx = 0;
+  for (auto req : getProtocol()->getRequirementSignature()->getRequirements()) {
+    if (req.getKind() == RequirementKind::Conformance) {
+      assert(idx < conformances.size());
+      assert(conformances[idx].getRequirement() ==
+               req.getSecondType()->castTo<ProtocolType>()->getDecl());
+      ++idx;
+    }
+  }
+  assert(idx == conformances.size() && "Too many conformances");
+#endif
+}
+
 void NormalProtocolConformance::resolveLazyInfo() const {
   assert(Resolver);
   assert(isComplete());
@@ -317,6 +336,103 @@
   TypeWitnesses[assocType] = std::make_pair(substitution, typeDecl);
 }
 
+/// TypeWitnesses is keyed by the protocol's own declarations, but
+/// DependentMemberTypes will sometimes store a base protocol's declaration.
+/// Map to the derived declaration if possible.
+static AssociatedTypeDecl *getOwnAssociatedTypeDecl(ProtocolDecl *protocol,
+                                                    AssociatedTypeDecl *assoc) {
+  // Fast path.
+  if (assoc->getProtocol() == protocol) return assoc;
+
+  // Search the protocol.
+  for (auto member : protocol->getMembers()) {
+    if (auto memberAssoc = dyn_cast<AssociatedTypeDecl>(member)) {
+      if (memberAssoc->getName() == assoc->getName()) {
+        return memberAssoc;
+      }
+    }
+  }
+
+  // Just assume this is fine.
+  return assoc;
+}
+
+Type NormalProtocolConformance::getAssociatedType(Type assocType,
+                                                LazyResolver *resolver) const {
+  assert(assocType->isTypeParameter() &&
+         "associated type must be a type parameter");
+
+  // Fast path.
+  auto type = assocType->getCanonicalType();
+  if (isa<GenericTypeParamType>(type)) {
+    assert(type->isEqual(getProtocol()->getSelfInterfaceType()) &&
+           "type parameter in protocol was not Self");
+    return getType();
+  }
+
+  auto memberType = cast<DependentMemberType>(type);
+
+  // TODO: make this handle multiple levels of dependent member type.
+  assert(memberType.getBase()->isEqual(getProtocol()->getSelfInterfaceType()) &&
+         "dependent member in protocol was not rooted in Self");
+
+  auto assocTypeDecl =
+    getOwnAssociatedTypeDecl(getProtocol(), memberType->getAssocType());
+  auto &subst = getTypeWitnessSubstAndDecl(assocTypeDecl, resolver).first;
+  return subst.getReplacement();
+}
+
+ProtocolConformanceRef
+NormalProtocolConformance::getAssociatedConformance(Type assocType,
+                                                    ProtocolDecl *protocol,
+                                                LazyResolver *resolver) const {
+  assert(assocType->isTypeParameter() &&
+         "associated type must be a type parameter");
+
+#ifndef NDEBUG
+  bool foundInRequirements = false;
+  for (auto &reqt :
+         getProtocol()->getRequirementSignature()->getRequirements()) {
+    if (reqt.getKind() == RequirementKind::Conformance &&
+        reqt.getFirstType()->isEqual(assocType) &&
+        reqt.getSecondType()->castTo<ProtocolType>()->getDecl() == protocol) {
+      foundInRequirements = true;
+      break;
+    }
+  }
+  assert(foundInRequirements &&
+         "requested conformance was not a direct requirement of the protocol");
+#endif
+
+  auto type = assocType->getCanonicalType();
+
+  if (isa<GenericTypeParamType>(type)) {
+    assert(type->isEqual(getProtocol()->getSelfInterfaceType()) &&
+           "type parameter in protocol was not Self");
+    auto conf = getInheritedConformance(protocol);
+    assert(conf && "inherited conformances cannot be abstract");
+    return ProtocolConformanceRef(conf);
+  }
+
+  auto memberType = cast<DependentMemberType>(type);
+
+  // For now, NormalProtocolConformance does not store indirect associations.
+  assert(memberType.getBase()->isEqual(getProtocol()->getSelfInterfaceType()) &&
+         "dependent member in protocol was not rooted in Self");
+
+  auto assocTypeDecl =
+    getOwnAssociatedTypeDecl(getProtocol(), memberType->getAssocType());
+  auto &subst = getTypeWitnessSubstAndDecl(assocTypeDecl, resolver).first;
+
+  // Scan the conformances for the exact conformance.
+  // TODO: should we allow indirect conformances for convenience of use?
+  for (auto &conf : subst.getConformances()) {
+    if (conf.getRequirement() == protocol)
+      return conf;
+  }
+  llvm_unreachable("missing conformance to protocol");
+}
+
   /// Retrieve the value witness corresponding to the given requirement.
 Witness NormalProtocolConformance::getWitness(ValueDecl *requirement,
                                               LazyResolver *resolver) const {
@@ -347,7 +463,11 @@
   assert(getProtocol() == cast<ProtocolDecl>(requirement->getDeclContext()) &&
          "requirement in wrong protocol");
   assert(Mapping.count(requirement) == 0 && "Witness already known");
-  assert((!isComplete() || isInvalid()) && "Conformance already complete?");
+  assert((!isComplete() || isInvalid() ||
+          requirement->getAttrs().hasAttribute<OptionalAttr>() ||
+          requirement->getAttrs().isUnavailable(
+                                        requirement->getASTContext())) &&
+				 "Conformance already complete?");
   Mapping[requirement] = witness;
 }
 
diff --git a/lib/AST/SourceEntityWalker.cpp b/lib/AST/SourceEntityWalker.cpp
index d6a28c3..5aa4cbf 100644
--- a/lib/AST/SourceEntityWalker.cpp
+++ b/lib/AST/SourceEntityWalker.cpp
@@ -335,6 +335,9 @@
 }
 
 std::pair<bool, Pattern *> SemaAnnotator::walkToPatternPre(Pattern *P) {
+  if (P->isImplicit())
+    return { true, P };
+
   if (auto *EP = dyn_cast<EnumElementPattern>(P)) {
     auto *Element = EP->getElementDecl();
     if (!Element)
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 659ad44..e801028 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -23,6 +23,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/APFloat.h"
diff --git a/lib/Basic/Demangle.cpp b/lib/Basic/Demangle.cpp
index 281883f..af9bb55 100644
--- a/lib/Basic/Demangle.cpp
+++ b/lib/Basic/Demangle.cpp
@@ -2331,7 +2331,9 @@
 bool
 swift::Demangle::isSwiftSymbol(const char *mangledName) {
   // The old mangling.
-  if (mangledName[0] == '_' && mangledName[1] == 'T')
+  if (mangledName[0] == '_'
+      // Also accept the future mangling prefix.
+      && (mangledName[1] == 'T' || mangledName[1] == 'S'))
     return true;
 
   // The new mangling.
diff --git a/lib/Basic/Demangler.cpp b/lib/Basic/Demangler.cpp
index 70ded11..0856944 100644
--- a/lib/Basic/Demangler.cpp
+++ b/lib/Basic/Demangler.cpp
@@ -137,7 +137,10 @@
 
 NodePointer Context::demangleSymbolAsNode(llvm::StringRef MangledName) {
 #ifndef NO_NEW_DEMANGLING
-  if (MangledName.startswith(MANGLING_PREFIX_STR)) {
+  if (MangledName.startswith(MANGLING_PREFIX_STR)
+      // Also accept the future mangling prefix.
+      // TODO: remove this line as soon as MANGLING_PREFIX_STR gets "_S".
+      || MangledName.startswith("_S")) {
     return D->demangleSymbol(MangledName);
   }
 #endif
@@ -171,7 +174,10 @@
 }
 
 bool Context::isThunkSymbol(llvm::StringRef MangledName) {
-  if (MangledName.startswith(MANGLING_PREFIX_STR)) {
+  if (MangledName.startswith(MANGLING_PREFIX_STR)
+      // Also accept the future mangling prefix.
+      // TODO: remove this line as soon as MANGLING_PREFIX_STR gets "_S".
+      || MangledName.startswith("_S")) {
     // First do a quick check
     if (MangledName.endswith("TA") ||  // partial application forwarder
         MangledName.endswith("Ta") ||  // ObjC partial application forwarder
@@ -202,13 +208,60 @@
     StringRef Remaining = MangledName.substr(2);
     if (Remaining.startswith("To") ||   // swift-as-ObjC thunk
         Remaining.startswith("TO") ||   // ObjC-as-swift thunk
-        Remaining.startswith("PA")) {  // (ObjC) partial application forwarder
+        Remaining.startswith("PA_") ||  // partial application forwarder
+        Remaining.startswith("PAo_")) { // ObjC partial application forwarder
       return true;
     }
   }
   return false;
 }
-  
+
+std::string Context::getThunkTarget(llvm::StringRef MangledName) {
+  if (!isThunkSymbol(MangledName))
+    return std::string();
+
+  if (MangledName.startswith(MANGLING_PREFIX_STR)
+      // Also accept the future mangling prefix.
+      // TODO: remove this line as soon as MANGLING_PREFIX_STR gets "_S".
+      || MangledName.startswith("_S")) {
+
+    return MangledName.substr(0, MangledName.size() - 2).str();
+  }
+  // Old mangling.
+  assert(MangledName.startswith("_T"));
+  StringRef Remaining = MangledName.substr(2);
+  if (Remaining.startswith("PA_"))
+    return Remaining.substr(3).str();
+  if (Remaining.startswith("PAo_"))
+    return Remaining.substr(4).str();
+  assert(Remaining.startswith("To") || Remaining.startswith("TO"));
+  return std::string("_T") + Remaining.substr(2).str();
+}
+
+bool Context::hasSwiftCallingConvention(llvm::StringRef MangledName) {
+  Node *Global = demangleSymbolAsNode(MangledName);
+  if (!Global || Global->getKind() != Node::Kind::Global ||
+      Global->getNumChildren() == 0)
+    return false;
+
+  Node *TopLevel = Global->getFirstChild();
+  switch (TopLevel->getKind()) {
+    // Functions, which don't have the swift calling conventions:
+    case Node::Kind::TypeMetadataAccessFunction:
+    case Node::Kind::ValueWitness:
+    case Node::Kind::ProtocolWitnessTableAccessor:
+    case Node::Kind::GenericProtocolWitnessTableInstantiationFunction:
+    case Node::Kind::LazyProtocolWitnessTableAccessor:
+    case Node::Kind::AssociatedTypeMetadataAccessor:
+    case Node::Kind::AssociatedTypeWitnessTableAccessor:
+    case Node::Kind::ObjCAttribute:
+      return false;
+    default:
+      break;
+  }
+  return true;
+}
+
 NodePointer Context::createNode(Node::Kind K) {
   return D->createNode(K);
 }
@@ -257,6 +310,11 @@
   addChild(Child, *Ctx.D);
 }
 
+void Node::reverseChildren(size_t StartingAt) {
+  assert(StartingAt <= NumChildren);
+  std::reverse(Children + StartingAt, Children + NumChildren);
+}
+
 //////////////////////////////////
 // NodeFactory member functions //
 //////////////////////////////////
@@ -297,18 +355,49 @@
 NodePointer NodeFactory::createNode(Node::Kind K, llvm::StringRef Text) {
   return new (Allocate<Node>()) Node(K, Text.copy(*this));
 }
+NodePointer NodeFactory::createNode(Node::Kind K, const CharVector &Text) {
+  return new (Allocate<Node>()) Node(K, Text.str());
+}
 NodePointer NodeFactory::createNode(Node::Kind K, const char *Text) {
   return new (Allocate<Node>()) Node(K, llvm::StringRef(Text));
 }
 
 //////////////////////////////////
+// CharVector member functions  //
+//////////////////////////////////
+
+void CharVector::append(StringRef Rhs, NodeFactory &Factory) {
+  if (NumElems + Rhs.size() > Capacity)
+    Factory.Reallocate(Elems, Capacity, /*Growth*/ Rhs.size());
+  memcpy(Elems + NumElems, Rhs.data(), Rhs.size());
+  NumElems += Rhs.size();
+  assert(NumElems <= Capacity);
+}
+
+void CharVector::append(int Number, NodeFactory &Factory) {
+  const int MaxIntPrintSize = 8;
+  if (NumElems + MaxIntPrintSize > Capacity)
+    Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxIntPrintSize);
+  int Length = snprintf(Elems + NumElems, MaxIntPrintSize, "%d", Number);
+  assert(Length > 0 && Length < MaxIntPrintSize);
+  NumElems += Length;
+}
+
+//////////////////////////////////
 // Demangler member functions   //
 //////////////////////////////////
 
+void Demangler::clear() {
+  NodeStack.free();
+  Substitutions.free();
+  PendingSubstitutions.free();
+  NodeFactory::clear();
+}
+
 void Demangler::init(StringRef MangledName) {
-  NodeStack.clear();
-  Substitutions.clear();
-  PendingSubstitutions.clear();
+  NodeStack.init(*this, 16);
+  Substitutions.init(*this, 16);
+  PendingSubstitutions.init(*this, 4);
   NumWords = 0;
   Text = MangledName;
   Pos = 0;
@@ -317,7 +406,10 @@
 NodePointer Demangler::demangleSymbol(StringRef MangledName) {
   init(MangledName);
 
-  if (!nextIf(MANGLING_PREFIX_STR))
+  if (!nextIf(MANGLING_PREFIX_STR)
+      // Also accept the future mangling prefix.
+      // TODO: remove this line as soon as MANGLING_PREFIX_STR gets "_S".
+      && !nextIf("_S"))
     return nullptr;
 
   NodePointer topLevel = createNode(Node::Kind::Global);
@@ -625,7 +717,7 @@
       hasWordSubsts = true;
     }
   }
-  std::string Identifier;
+  CharVector Identifier;
   do {
     while (hasWordSubsts && isLetter(peekChar())) {
       char c = nextChar();
@@ -641,7 +733,7 @@
         return nullptr;
       assert(WordIdx < MaxNumWords);
       StringRef Slice = Words[WordIdx];
-      Identifier.append(Slice.data(), Slice.size());
+      Identifier.append(Slice, *this);
     }
     if (nextIf('0'))
       break;
@@ -654,10 +746,12 @@
       return nullptr;
     StringRef Slice = StringRef(Text.data() + Pos, numChars);
     if (isPunycoded) {
-      if (!Punycode::decodePunycodeUTF8(Slice, Identifier))
+      std::string PunycodedString;
+      if (!Punycode::decodePunycodeUTF8(Slice, PunycodedString))
         return nullptr;
+      Identifier.append(StringRef(PunycodedString), *this);
     } else {
-      Identifier.append(Slice.data(), Slice.size());
+      Identifier.append(Slice, *this);
       int wordStartPos = -1;
       for (int Idx = 0, End = (int)Slice.size(); Idx <= End; ++Idx) {
         char c = (Idx < End ? Slice[Idx] : 0);
@@ -688,12 +782,11 @@
 
   static const char op_char_table[] = "& @/= >    <*!|+?%-~   ^ .";
 
-  std::string OpStr;
-  OpStr.reserve(Ident->getText().size());
+  CharVector OpStr;
   for (signed char c : Ident->getText()) {
     if (c < 0) {
       // Pass through Unicode characters.
-      OpStr.push_back(c);
+      OpStr.push_back(c, *this);
       continue;
     }
     if (!isLowerLetter(c))
@@ -701,7 +794,7 @@
     char o = op_char_table[c - 'a'];
     if (o == ' ')
       return nullptr;
-    OpStr.push_back(o);
+    OpStr.push_back(o, *this);
   }
   switch (nextChar()) {
     case 'i': return createNode(Node::Kind::InfixOperator, OpStr);
@@ -772,16 +865,20 @@
       int size = demangleIndex() - 1;
       if (size <= 0)
         return nullptr;
-      Ty = createNode(Node::Kind::BuiltinTypeName,
-               std::move(DemanglerPrinter() << "Builtin.Float" << size).str());
+      CharVector name;
+      name.append("Builtin.Float", *this);
+      name.append(size, *this);
+      Ty = createNode(Node::Kind::BuiltinTypeName, name);
       break;
     }
     case 'i': {
       int size = demangleIndex() - 1;
       if (size <= 0)
         return nullptr;
-      Ty = createNode(Node::Kind::BuiltinTypeName,
-                          (DemanglerPrinter() << "Builtin.Int" << size).str());
+      CharVector name;
+      name.append("Builtin.Int", *this);
+      name.append(size, *this);
+      Ty = createNode(Node::Kind::BuiltinTypeName, name);
       break;
     }
     case 'v': {
@@ -792,9 +889,12 @@
       if (!EltType || EltType->getKind() != Node::Kind::BuiltinTypeName ||
           !EltType->getText().startswith("Builtin."))
         return nullptr;
-      Ty = createNode(Node::Kind::BuiltinTypeName,
-                      (DemanglerPrinter() << "Builtin.Vec" << elts << "x" <<
-                      EltType->getText().substr(sizeof("Builtin.") - 1)).str());
+      CharVector name;
+      name.append("Builtin.Vec", *this);
+      name.append(elts, *this);
+      name.push_back('x', *this);
+      name.append(EltType->getText().substr(sizeof("Builtin.") - 1), *this);
+      Ty = createNode(Node::Kind::BuiltinTypeName, name);
       break;
     }
     case 'O':
@@ -880,7 +980,6 @@
                                          Node::Kind::NonVariadicTuple);
 
   if (!popNode(Node::Kind::EmptyList)) {
-    std::vector<NodePointer> Nodes;
     bool firstElem = false;
     do {
       firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
@@ -893,12 +992,10 @@
       if (!Ty)
         return nullptr;
       TupleElmt->addChild(Ty, *this);
-      Nodes.push_back(TupleElmt);
+      Root->addChild(TupleElmt, *this);
     } while (!firstElem);
 
-    while (NodePointer TupleElmt = pop_back_val(Nodes)) {
-      Root->addChild(TupleElmt, *this);
-    }
+    Root->reverseChildren();
   }
   return createType(Root);
 }
@@ -907,18 +1004,16 @@
   NodePointer Root = createNode(Node::Kind::TypeList);
 
   if (!popNode(Node::Kind::EmptyList)) {
-    std::vector<NodePointer> Nodes;
     bool firstElem = false;
     do {
       firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
       NodePointer Ty = popNode(Node::Kind::Type);
       if (!Ty)
         return nullptr;
-      Nodes.push_back(Ty);
-    } while (!firstElem);
-    while (NodePointer Ty = pop_back_val(Nodes)) {
       Root->addChild(Ty, *this);
-    }
+    } while (!firstElem);
+    
+    Root->reverseChildren();
   }
   return Root;
 }
@@ -931,17 +1026,15 @@
 }
 
 NodePointer Demangler::demangleBoundGenericType() {
-  std::vector<NodePointer> TypeListList;
-  std::vector<NodePointer> Types;
+  Vector<NodePointer> TypeListList(*this, 4);
   for (;;) {
     NodePointer TList = createNode(Node::Kind::TypeList);
-    TypeListList.push_back(TList);
+    TypeListList.push_back(TList, *this);
     while (NodePointer Ty = popNode(Node::Kind::Type)) {
-      Types.push_back(Ty);
-    }
-    while (NodePointer Ty = pop_back_val(Types)) {
       TList->addChild(Ty, *this);
     }
+    TList->reverseChildren();
+
     if (popNode(Node::Kind::EmptyList))
       break;
     if (!popNode(Node::Kind::FirstElementMarker))
@@ -952,7 +1045,7 @@
 }
 
 NodePointer Demangler::demangleBoundGenericArgs(NodePointer Nominal,
-                                    const std::vector<NodePointer> &TypeLists,
+                                    const Vector<NodePointer> &TypeLists,
                                     size_t TypeListIdx) {
   if (!Nominal || Nominal->getNumChildren() < 2)
     return nullptr;
@@ -1001,7 +1094,7 @@
 }
 
 NodePointer Demangler::demangleImplParamConvention() {
-  StringRef attr;
+  const char *attr = nullptr;
   switch (nextChar()) {
     case 'i': attr = "@in"; break;
     case 'l': attr = "@inout"; break;
@@ -1020,7 +1113,7 @@
 }
 
 NodePointer Demangler::demangleImplResultConvention(Node::Kind ConvKind) {
-  StringRef attr;
+  const char *attr = nullptr;
   switch (nextChar()) {
     case 'r': attr = "@out"; break;
     case 'o': attr = "@owned"; break;
@@ -1136,19 +1229,6 @@
   }
 }
 
-static std::string getArchetypeName(Node::IndexType index,
-                                    Node::IndexType depth) {
-  DemanglerPrinter name;
-  do {
-    name << (char)('A' + (index % 26));
-    index /= 26;
-  } while (index);
-  if (depth != 0)
-    name << depth;
-  return std::move(name).str();
-}
-
-
 NodePointer Demangler::demangleArchetype() {
   switch (nextChar()) {
     case 'a': {
@@ -1201,19 +1281,19 @@
 
 NodePointer Demangler::demangleAssociatedTypeCompound(
                                                   NodePointer GenericParamIdx) {
-  std::vector<NodePointer> AssocTyNames;
+  Vector<NodePointer> AssocTyNames(*this, 4);
   bool firstElem = false;
   do {
     firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
     NodePointer AssocTyName = popAssocTypeName();
     if (!AssocTyName)
       return nullptr;
-    AssocTyNames.push_back(AssocTyName);
+    AssocTyNames.push_back(AssocTyName, *this);
   } while (!firstElem);
 
   NodePointer Base = GenericParamIdx;
 
-  while (NodePointer AssocTy = pop_back_val(AssocTyNames)) {
+  while (NodePointer AssocTy = AssocTyNames.pop_back_val()) {
     NodePointer depTy = createNode(Node::Kind::DependentMemberType);
     depTy = addChild(depTy, createType(Base));
     Base = addChild(depTy, AssocTy);
@@ -1235,11 +1315,17 @@
 NodePointer Demangler::getDependentGenericParamType(int depth, int index) {
   if (depth < 0 || index < 0)
     return nullptr;
-  DemanglerPrinter PrintName;
-  PrintName << getArchetypeName(index, depth);
-  
-  auto paramTy = createNode(Node::Kind::DependentGenericParamType,
-                                     std::move(PrintName).str());
+
+  CharVector name;
+  int idxChar = index;
+  do {
+    name.push_back((char)('A' + (idxChar % 26)), *this);
+    idxChar /= 26;
+  } while (idxChar);
+  if (depth != 0)
+    name.append(depth, *this);
+
+  auto paramTy = createNode(Node::Kind::DependentGenericParamType, name);
   paramTy->addChild(createNode(Node::Kind::Index, depth), *this);
   paramTy->addChild(createNode(Node::Kind::Index, index), *this);
   return paramTy;
@@ -1372,10 +1458,10 @@
       case FunctionSigSpecializationParamKind::ConstantPropGlobal:
       case FunctionSigSpecializationParamKind::ConstantPropString:
       case FunctionSigSpecializationParamKind::ClosureProp: {
-        std::vector<NodePointer> Types;
+        size_t FixedChildren = Param->getNumChildren();
         while (NodePointer Ty = popNode(Node::Kind::Type)) {
           assert(ParamKind == FunctionSigSpecializationParamKind::ClosureProp);
-          Types.push_back(Ty);
+          Param = addChild(Param, Ty);
         }
         NodePointer Name = popNode(Node::Kind::Identifier);
         if (!Name)
@@ -1389,9 +1475,7 @@
         }
         addChild(Param, createNode(
           Node::Kind::FunctionSignatureSpecializationParamPayload, Text));
-        while (NodePointer Ty = pop_back_val(Types)) {
-          Param = addChild(Param, Ty);
-        }
+        Param->reverseChildren(FixedChildren);
         break;
       }
       default:
@@ -1499,9 +1583,9 @@
   Param->addChild(createNode(
         Node::Kind::FunctionSignatureSpecializationParamKind, unsigned(Kind)),
         *this);
-  std::string Str;
+  CharVector Str;
   while (isDigit(peekChar())) {
-    Str += nextChar();
+    Str.push_back(nextChar(), *this);
   }
   if (Str.empty())
     return nullptr;
@@ -1801,28 +1885,21 @@
   NodePointer TypeList = createNode(Node::Kind::TypeList);
   NodePointer ProtoList = createWithChild(Node::Kind::ProtocolList, TypeList);
   if (!popNode(Node::Kind::EmptyList)) {
-    std::vector<NodePointer> ProtoNames;
     bool firstElem = false;
     do {
       firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
       NodePointer Proto = popProtocol();
       if (!Proto)
         return nullptr;
-      ProtoNames.push_back(Proto);
+      TypeList->addChild(Proto, *this);
     } while (!firstElem);
 
-    while (NodePointer Proto = pop_back_val(ProtoNames)) {
-      TypeList->addChild(Proto, *this);
-    }
+    TypeList->reverseChildren();
   }
   return createType(ProtoList);
 }
 
 NodePointer Demangler::demangleGenericSignature(bool hasParamCounts) {
-  std::vector<NodePointer> Requirements;
-  while (NodePointer Req = popNode(isRequirement)) {
-    Requirements.push_back(Req);
-  }
   NodePointer Sig = createNode(Node::Kind::DependentGenericSignature);
   if (hasParamCounts) {
     while (!nextIf('l')) {
@@ -1840,9 +1917,11 @@
   }
   if (Sig->getNumChildren() == 0)
     return nullptr;
-  while (NodePointer Req = pop_back_val(Requirements)) {
+  size_t NumCounts = Sig->getNumChildren();
+  while (NodePointer Req = popNode(isRequirement)) {
     Sig->addChild(Req, *this);
   }
+  Sig->reverseChildren(NumCounts);
   return Sig;
 }
 
@@ -1905,7 +1984,7 @@
     auto c = nextChar();
     NodePointer size = nullptr;
     NodePointer alignment = nullptr;
-    StringRef name;
+    const char *name = nullptr;
     if (c == 'U') {
       name = "U";
     } else if (c == 'R') {
diff --git a/lib/Basic/Version.cpp b/lib/Basic/Version.cpp
index f38da00..220f1e2 100644
--- a/lib/Basic/Version.cpp
+++ b/lib/Basic/Version.cpp
@@ -242,16 +242,11 @@
 }
 
 Version Version::getCurrentLanguageVersion() {
-#ifndef SWIFT_VERSION_STRING
-#error Swift language version is not set!
+#if SWIFT_VERSION_PATCHLEVEL
+  return {SWIFT_VERSION_MAJOR, SWIFT_VERSION_MINOR, SWIFT_VERSION_PATCHLEVEL};
+#else
+  return {SWIFT_VERSION_MAJOR, SWIFT_VERSION_MINOR};
 #endif
-  auto currentVersion = Version::parseVersionString(
-    SWIFT_VERSION_STRING, SourceLoc(), nullptr);
-  assert(currentVersion.hasValue() &&
-         "Embedded Swift language version couldn't be parsed: '"
-         SWIFT_VERSION_STRING
-         "'");
-  return currentVersion.getValue();
 }
 
 raw_ostream &operator<<(raw_ostream &os, const Version &version) {
@@ -304,18 +299,35 @@
   }
 }
 
-bool Version::isValidEffectiveLanguageVersion() const {
-  for (auto verStr : getValidEffectiveVersions()) {
-    auto v = parseVersionString(verStr, SourceLoc(), nullptr);
-    assert(v.hasValue());
-    // In this case, use logical-equality _and_ precision-equality. We do not
-    // want to permit users requesting effective language versions more precise
-    // than our whitelist (eg. we permit 3 but not 3.0 or 3.0.0), since
-    // accepting such an argument promises more than we're able to deliver.
-    if (v == *this && v.getValue().size() == size())
-      return true;
+Optional<Version> Version::getEffectiveLanguageVersion() const {
+  switch (size()) {
+  case 0:
+    return None;
+  case 1:
+    break;
+  default:
+    // We do not want to permit users requesting more precise effective language
+    // versions since accepting such an argument promises more than we're able
+    // to deliver.
+    return None;
   }
-  return false;
+
+  // FIXME: When we switch to Swift 4 by default, the "3" case should return
+  // a version newer than any released 3.x compiler (probably "3.2"), and the
+  // "4" case should start returning getCurrentLanguageVersion. We should
+  // also check for the presence of SWIFT_VERSION_PATCHLEVEL, and if that's
+  // set apply it to the "3" case, so that Swift 4.0.1 will automatically
+  // have a compatibility mode of 3.2.1.
+  switch (Components[0]) {
+  case 3:
+    static_assert(SWIFT_VERSION_MAJOR == 3,
+                  "getCurrentLanguageVersion is no longer correct here");
+    return Version::getCurrentLanguageVersion();
+  case 4:
+    return Version{4, 0};
+  default:
+    return None;
+  }
 }
 
 Version Version::asMajorVersion() const {
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
index 6fcdebc..8028752 100644
--- a/lib/ClangImporter/ImportDecl.cpp
+++ b/lib/ClangImporter/ImportDecl.cpp
@@ -6952,6 +6952,7 @@
     };
     return getDeclName(*left).compare(getDeclName(*right));
   });
+
   // Schedule any that aren't complete.
   for (auto *inherited : inheritedProtos) {
     ModuleDecl *M = conformance->getDeclContext()->getParentModule();
@@ -6964,6 +6965,24 @@
                                          inheritedConformance->getConcrete());
   }
 
+  // Collect conformances for the requirement signature.
+  SmallVector<ProtocolConformanceRef, 4> reqConformances;
+  for (auto req : proto->getRequirementSignature()->getRequirements()) {
+    if (req.getKind() != RequirementKind::Conformance)
+      continue;
+
+    assert(req.getFirstType()->isEqual(proto->getSelfInterfaceType()));
+    auto reqProto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+
+    ModuleDecl *M = conformance->getDeclContext()->getParentModule();
+    auto reqConformance = M->lookupConformance(conformance->getType(),
+                                               reqProto, /*resolver=*/nullptr);
+    assert(reqConformance && reqConformance->isConcrete() &&
+           "required conformance not found");
+    reqConformances.push_back(*reqConformance);
+  }
+  conformance->setSignatureConformances(reqConformances);
+
   conformance->setState(ProtocolConformanceState::Complete);
 }
 
diff --git a/lib/ClangImporter/ImportName.cpp b/lib/ClangImporter/ImportName.cpp
index b00f41f..e330bfc 100644
--- a/lib/ClangImporter/ImportName.cpp
+++ b/lib/ClangImporter/ImportName.cpp
@@ -37,6 +37,7 @@
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <memory>
 
@@ -79,6 +80,8 @@
   case ImportNameVersion::Swift4:
     return 4;
   }
+
+  llvm_unreachable("Unhandled ImportNameVersion in switch.");
 }
 
 
diff --git a/lib/Driver/Compilation.cpp b/lib/Driver/Compilation.cpp
index e6f2ca0..7ae5be6 100644
--- a/lib/Driver/Compilation.cpp
+++ b/lib/Driver/Compilation.cpp
@@ -44,6 +44,45 @@
 using namespace swift::driver;
 using namespace llvm::opt;
 
+struct LogJob {
+  const Job *j;
+  LogJob(const Job *j) : j(j) {}
+};
+
+struct LogJobArray {
+  const ArrayRef<const Job *> js;
+  LogJobArray(const ArrayRef<const Job *> js) : js(js) {}
+};
+
+struct LogJobSet {
+  const SmallPtrSetImpl<const Job*> &js;
+  LogJobSet(const SmallPtrSetImpl<const Job*> &js) : js(js) {}
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const LogJob &lj) {
+  lj.j->printSummary(os);
+  return os;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const LogJobArray &ljs) {
+  os << "[";
+  interleave(ljs.js,
+             [&](Job const *j) { os << LogJob(j); },
+             [&]() { os << ' '; });
+  os << "]";
+  return os;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const LogJobSet &ljs) {
+  os << "{";
+  interleave(ljs.js,
+             [&](Job const *j) { os << LogJob(j); },
+             [&]() { os << ' '; });
+  os << "}";
+  return os;
+}
+
+
 Compilation::Compilation(DiagnosticEngine &Diags, OutputLevel Level,
                          std::unique_ptr<InputArgList> InputArgs,
                          std::unique_ptr<DerivedArgList> TranslatedArgs,
@@ -65,10 +104,21 @@
     ShowDriverTimeCompilation(ShowDriverTimeCompilation) {
 };
 
+static bool writeFilelistIfNecessary(const Job *job, DiagnosticEngine &diags);
+
 using CommandSet = llvm::SmallPtrSet<const Job *, 16>;
 
-namespace {
-  struct PerformJobsState {
+
+using InputInfoMap = llvm::SmallMapVector<const llvm::opt::Arg *,
+                                          CompileJobAction::InputInfo, 16>;
+
+namespace swift {
+namespace driver {
+  class PerformJobsState {
+
+    /// The containing Compilation object.
+    Compilation &Comp;
+
     /// All jobs which have been scheduled for execution (whether or not
     /// they've finished execution), or which have been determined that they
     /// don't need to run.
@@ -89,8 +139,548 @@
     ///
     /// Only intended for source files.
     llvm::SmallDenseMap<const Job *, bool, 16> UnfinishedCommands;
+
+    /// Jobs that incremental-mode has decided it can skip.
+    CommandSet DeferredCommands;
+
+    /// Jobs in the initial set with Condition::Always, or lacking existing
+    /// .swiftdeps files.
+    SmallVector<const Job *, 16> InitialOutOfDateCommands;
+
+    /// Dependency graph for deciding which jobs are dirty (need running)
+    /// or clean (can be skipped).
+    using DependencyGraph = DependencyGraph<const Job *>;
+    DependencyGraph DepGraph;
+
+    /// Helper for tracing the propagation of marks in the graph.
+    DependencyGraph::MarkTracer ActualIncrementalTracer;
+    DependencyGraph::MarkTracer *IncrementalTracer = nullptr;
+
+    /// TaskQueue for execution.
+    std::unique_ptr<TaskQueue> TQ;
+
+    /// Cumulative result of PerformJobs(), accumulated from subprocesses.
+    int Result = EXIT_SUCCESS;
+
+    /// Timers for monitoring execution time of subprocesses.
+    llvm::TimerGroup DriverTimerGroup {"driver", "Driver Compilation Time"};
+    llvm::SmallDenseMap<const Job *, std::unique_ptr<llvm::Timer>, 16>
+    DriverTimers;
+
+    void noteBuilding(const Job *cmd, StringRef reason) {
+      if (!Comp.ShowIncrementalBuildDecisions)
+        return;
+      if (ScheduledCommands.count(cmd))
+        return;
+      llvm::outs() << "Queuing " << reason << ": " << LogJob(cmd) << "\n";
+      IncrementalTracer->printPath(
+        llvm::outs(), cmd, [](raw_ostream &out, const Job *base) {
+          out << llvm::sys::path::filename(base->getOutput().getBaseInput(0));
+        });
+    }
+
+    const Job *findUnfinishedJob(ArrayRef<const Job *> JL) {
+      for (const Job *Cmd : JL) {
+        if (!FinishedCommands.count(Cmd))
+          return Cmd;
+      }
+      return nullptr;
+    }
+
+    /// Schedule the given Job if it has not been scheduled and if all of
+    /// its inputs are in FinishedCommands.
+    void scheduleCommandIfNecessaryAndPossible(const Job *Cmd) {
+      if (ScheduledCommands.count(Cmd)) {
+        if (Comp.ShowJobLifecycle) {
+          llvm::outs() << "Already scheduled: " << LogJob(Cmd) << "\n";
+        }
+        return;
+      }
+
+      if (auto Blocking = findUnfinishedJob(Cmd->getInputs())) {
+        BlockingCommands[Blocking].push_back(Cmd);
+        if (Comp.ShowJobLifecycle) {
+          llvm::outs() << "Blocked by: " << LogJob(Blocking)
+                       << ", now blocking jobs: "
+                       << LogJobArray(BlockingCommands[Blocking]) << "\n";
+        }
+        return;
+      }
+
+      // FIXME: Failing here should not take down the whole process.
+      bool success = writeFilelistIfNecessary(Cmd, Comp.Diags);
+      assert(success && "failed to write filelist");
+      (void)success;
+
+      assert(Cmd->getExtraEnvironment().empty() &&
+             "not implemented for compilations with multiple jobs");
+      ScheduledCommands.insert(Cmd);
+      if (Comp.ShowJobLifecycle)
+        llvm::outs() << "Added to TaskQueue: " << LogJob(Cmd) << "\n";
+      TQ->addTask(Cmd->getExecutable(), Cmd->getArguments(), llvm::None,
+                  (void *)Cmd);
+    }
+
+    /// When a task finishes, check other Jobs that may be blocked.
+    void markFinished(const Job *Cmd, bool Skipped=false) {
+      if (Comp.ShowJobLifecycle) {
+        llvm::outs() << "Job "
+                     << (Skipped ? "skipped" : "finished")
+                     << ": " << LogJob(Cmd) << "\n";
+      }
+      FinishedCommands.insert(Cmd);
+
+      auto BlockedIter = BlockingCommands.find(Cmd);
+      if (BlockedIter != BlockingCommands.end()) {
+        auto AllBlocked = std::move(BlockedIter->second);
+        if (Comp.ShowJobLifecycle) {
+          llvm::outs() << "Scheduling maybe-unblocked jobs: "
+                       << LogJobArray(AllBlocked) << "\n";
+        }
+        BlockingCommands.erase(BlockedIter);
+        for (auto *Blocked : AllBlocked)
+          scheduleCommandIfNecessaryAndPossible(Blocked);
+      }
+    }
+
+    /// Callback which will be called immediately after a task has started. This
+    /// callback may be used to provide output indicating that the task began.
+    void taskBegan(ProcessId Pid, void *Context) {
+      // TODO: properly handle task began.
+      const Job *BeganCmd = (const Job *)Context;
+
+      if (Comp.ShowDriverTimeCompilation) {
+        llvm::SmallString<128> TimerName;
+        llvm::raw_svector_ostream OS(TimerName);
+        OS << LogJob(BeganCmd);
+        DriverTimers.insert({
+            BeganCmd,
+              std::unique_ptr<llvm::Timer>(
+                new llvm::Timer("task", OS.str(), DriverTimerGroup))
+              });
+        DriverTimers[BeganCmd]->startTimer();
+      }
+
+      // For verbose output, print out each command as it begins execution.
+      if (Comp.Level == OutputLevel::Verbose)
+        BeganCmd->printCommandLine(llvm::errs());
+      else if (Comp.Level == OutputLevel::Parseable)
+        parseable_output::emitBeganMessage(llvm::errs(), *BeganCmd, Pid);
+    }
+
+    void
+    dependencyLoadFailed(StringRef DependenciesFile, bool Warn=true) {
+      if (Warn && Comp.ShowIncrementalBuildDecisions)
+        Comp.Diags.diagnose(SourceLoc(),
+                            diag::warn_unable_to_load_dependencies,
+                            DependenciesFile);
+      Comp.disableIncrementalBuild();
+      for (const Job *Cmd : DeferredCommands)
+        scheduleCommandIfNecessaryAndPossible(Cmd);
+      DeferredCommands.clear();
+    }
+
+    /// Helper that reloads a job's .swiftdeps file after the job exits, and
+    /// re-runs transitive marking to ensure everything is properly invalidated
+    /// by any new dependency edges introduced by it.
+    template <unsigned N>
+    void reloadAndRemarkDeps(const Job *FinishedCmd,
+                             int ReturnCode,
+                             SmallVector<const Job *, N> &Dependents) {
+      const CommandOutput &Output = FinishedCmd->getOutput();
+      StringRef DependenciesFile =
+        Output.getAdditionalOutputForType(types::TY_SwiftDeps);
+
+      if (DependenciesFile.empty()) {
+        // If this job doesn't track dependencies, it must always be run.
+        // Note: In theory CheckDependencies makes sense as well (for a leaf
+        // node in the dependency graph), and maybe even NewlyAdded (for very
+        // coarse dependencies that always affect downstream nodes), but we're
+        // not using either of those right now, and this logic should probably
+        // be revisited when we are.
+        assert(FinishedCmd->getCondition() == Job::Condition::Always);
+      } else {
+        // If we have a dependency file /and/ the frontend task exited normally,
+        // we can be discerning about what downstream files to rebuild.
+        if (ReturnCode == EXIT_SUCCESS || ReturnCode == EXIT_FAILURE) {
+          bool wasCascading = DepGraph.isMarked(FinishedCmd);
+
+          switch (DepGraph.loadFromPath(FinishedCmd, DependenciesFile)) {
+          case DependencyGraphImpl::LoadResult::HadError:
+            if (ReturnCode == EXIT_SUCCESS) {
+              dependencyLoadFailed(DependenciesFile);
+              Dependents.clear();
+            } // else, let the next build handle it.
+            break;
+          case DependencyGraphImpl::LoadResult::UpToDate:
+            if (!wasCascading)
+              break;
+            LLVM_FALLTHROUGH;
+          case DependencyGraphImpl::LoadResult::AffectsDownstream:
+            DepGraph.markTransitive(Dependents, FinishedCmd,
+                                    IncrementalTracer);
+            break;
+          }
+        } else {
+          // If there's an abnormal exit (a crash), assume the worst.
+          switch (FinishedCmd->getCondition()) {
+          case Job::Condition::NewlyAdded:
+            // The job won't be treated as newly added next time. Conservatively
+            // mark it as affecting other jobs, because some of them may have
+            // completed already.
+            DepGraph.markTransitive(Dependents, FinishedCmd,
+                                    IncrementalTracer);
+            break;
+          case Job::Condition::Always:
+            // Any incremental task that shows up here has already been marked;
+            // we didn't need to wait for it to finish to start downstream
+            // tasks.
+            assert(DepGraph.isMarked(FinishedCmd));
+            break;
+          case Job::Condition::RunWithoutCascading:
+            // If this file changed, it might have been a non-cascading change
+            // and it might not. Unfortunately, the interface hash has been
+            // updated or compromised, so we don't actually know anymore; we
+            // have to conservatively assume the changes could affect other
+            // files.
+            DepGraph.markTransitive(Dependents, FinishedCmd,
+                                    IncrementalTracer);
+            break;
+          case Job::Condition::CheckDependencies:
+            // If the only reason we're running this is because something else
+            // changed, then we can trust the dependency graph as to whether
+            // it's a cascading or non-cascading change. That is, if whatever
+            // /caused/ the error isn't supposed to affect other files, and
+            // whatever /fixes/ the error isn't supposed to affect other files,
+            // then there's no need to recompile any other inputs. If either of
+            // those are false, we /do/ need to recompile other inputs.
+            break;
+          }
+        }
+      }
+    }
+
+    /// Callback which will be called immediately after a task has finished
+    /// execution. Determines if execution should continue, and also schedule
+    /// any additional Jobs which we now know we need to run.
+    TaskFinishedResponse
+    taskFinished(ProcessId Pid, int ReturnCode, StringRef Output,
+                 StringRef Errors, void *Context) {
+      const Job *FinishedCmd = (const Job *)Context;
+
+      if (Comp.ShowDriverTimeCompilation) {
+        DriverTimers[FinishedCmd]->stopTimer();
+      }
+
+      if (Comp.Level == OutputLevel::Parseable) {
+        // Parseable output was requested.
+        parseable_output::emitFinishedMessage(llvm::errs(), *FinishedCmd, Pid,
+                                              ReturnCode, Output);
+      } else {
+        // Otherwise, send the buffered output to stderr, though only if we
+        // support getting buffered output.
+        if (TaskQueue::supportsBufferingOutput())
+          llvm::errs() << Output;
+      }
+
+      // In order to handle both old dependencies that have disappeared and new
+      // dependencies that have arisen, we need to reload the dependency file.
+      // Do this whether or not the build succeeded.
+      SmallVector<const Job *, 16> Dependents;
+      if (Comp.getIncrementalBuildEnabled()) {
+        reloadAndRemarkDeps(FinishedCmd, ReturnCode, Dependents);
+      }
+
+      if (ReturnCode != EXIT_SUCCESS) {
+        // The task failed, so return true without performing any further
+        // dependency analysis.
+
+        // Store this task's ReturnCode as our Result if we haven't stored
+        // anything yet.
+        if (Result == EXIT_SUCCESS)
+          Result = ReturnCode;
+
+        if (!isa<CompileJobAction>(FinishedCmd->getSource()) ||
+            ReturnCode != EXIT_FAILURE) {
+          Comp.Diags.diagnose(SourceLoc(), diag::error_command_failed,
+                              FinishedCmd->getSource().getClassName(),
+                              ReturnCode);
+        }
+
+        return Comp.ContinueBuildingAfterErrors ?
+          TaskFinishedResponse::ContinueExecution :
+          TaskFinishedResponse::StopExecution;
+      }
+
+      // When a task finishes, we need to reevaluate the other commands that
+      // might have been blocked.
+      markFinished(FinishedCmd);
+
+      for (const Job *Cmd : Dependents) {
+        DeferredCommands.erase(Cmd);
+        noteBuilding(Cmd, "because of dependencies discovered later");
+        scheduleCommandIfNecessaryAndPossible(Cmd);
+      }
+
+      return TaskFinishedResponse::ContinueExecution;
+    }
+
+    TaskFinishedResponse
+    taskSignalled(ProcessId Pid, StringRef ErrorMsg, StringRef Output,
+                  StringRef Errors, void *Context, Optional<int> Signal) {
+      const Job *SignalledCmd = (const Job *)Context;
+
+      if (Comp.ShowDriverTimeCompilation) {
+        DriverTimers[SignalledCmd]->stopTimer();
+      }
+
+      if (Comp.Level == OutputLevel::Parseable) {
+        // Parseable output was requested.
+        parseable_output::emitSignalledMessage(llvm::errs(), *SignalledCmd,
+                                               Pid, ErrorMsg, Output, Signal);
+      } else {
+        // Otherwise, send the buffered output to stderr, though only if we
+        // support getting buffered output.
+        if (TaskQueue::supportsBufferingOutput())
+          llvm::errs() << Output;
+      }
+
+      if (!ErrorMsg.empty())
+        Comp.Diags.diagnose(SourceLoc(), diag::error_unable_to_execute_command,
+                            ErrorMsg);
+
+      if (Signal.hasValue()) {
+        Comp.Diags.diagnose(SourceLoc(), diag::error_command_signalled,
+                            SignalledCmd->getSource().getClassName(),
+                            Signal.getValue());
+      } else {
+        Comp.Diags.diagnose(SourceLoc(),
+                            diag::error_command_signalled_without_signal_number,
+                            SignalledCmd->getSource().getClassName());
+      }
+
+      // Since the task signalled, unconditionally set result to -2.
+      Result = -2;
+
+      return TaskFinishedResponse::StopExecution;
+    }
+
+  public:
+    PerformJobsState(Compilation &Comp) : Comp(Comp) {
+      if (Comp.SkipTaskExecution)
+        TQ.reset(new DummyTaskQueue(Comp.NumberOfParallelCommands));
+      else
+        TQ.reset(new TaskQueue(Comp.NumberOfParallelCommands));
+      if (Comp.ShowIncrementalBuildDecisions)
+        IncrementalTracer = &ActualIncrementalTracer;
+    }
+
+    /// Schedule all jobs we can from the initial list provided by Compilation.
+    void scheduleInitialJobs() {
+      for (const Job *Cmd : Comp.getJobs()) {
+        if (!Comp.getIncrementalBuildEnabled()) {
+          scheduleCommandIfNecessaryAndPossible(Cmd);
+          continue;
+        }
+
+        // Try to load the dependencies file for this job. If there isn't one, we
+        // always have to run the job, but it doesn't affect any other jobs. If
+        // there should be one but it's not present or can't be loaded, we have to
+        // run all the jobs.
+        // FIXME: We can probably do better here!
+        Job::Condition Condition = Job::Condition::Always;
+        StringRef DependenciesFile =
+          Cmd->getOutput().getAdditionalOutputForType(types::TY_SwiftDeps);
+        if (!DependenciesFile.empty()) {
+          if (Cmd->getCondition() == Job::Condition::NewlyAdded) {
+            DepGraph.addIndependentNode(Cmd);
+          } else {
+            switch (DepGraph.loadFromPath(Cmd, DependenciesFile)) {
+            case DependencyGraphImpl::LoadResult::HadError:
+              dependencyLoadFailed(DependenciesFile, /*Warn=*/false);
+              break;
+            case DependencyGraphImpl::LoadResult::UpToDate:
+              Condition = Cmd->getCondition();
+              break;
+            case DependencyGraphImpl::LoadResult::AffectsDownstream:
+              llvm_unreachable("we haven't marked anything in this graph yet");
+            }
+          }
+        }
+
+        switch (Condition) {
+        case Job::Condition::Always:
+          if (Comp.getIncrementalBuildEnabled() && !DependenciesFile.empty()) {
+            InitialOutOfDateCommands.push_back(Cmd);
+            DepGraph.markIntransitive(Cmd);
+          }
+          LLVM_FALLTHROUGH;
+        case Job::Condition::RunWithoutCascading:
+          noteBuilding(Cmd, "(initial)");
+          scheduleCommandIfNecessaryAndPossible(Cmd);
+          break;
+        case Job::Condition::CheckDependencies:
+          DeferredCommands.insert(Cmd);
+          break;
+        case Job::Condition::NewlyAdded:
+          llvm_unreachable("handled above");
+        }
+      }
+    }
+
+    /// Schedule transitive closure of initial jobs, and external jobs.
+    void scheduleAdditionalJobs() {
+      if (Comp.getIncrementalBuildEnabled()) {
+        SmallVector<const Job *, 16> AdditionalOutOfDateCommands;
+
+        // We scheduled all of the files that have actually changed. Now add the
+        // files that haven't changed, so that they'll get built in parallel if
+        // possible and after the first set of files if it's not.
+        for (auto *Cmd : InitialOutOfDateCommands) {
+          DepGraph.markTransitive(AdditionalOutOfDateCommands, Cmd,
+                                  IncrementalTracer);
+        }
+
+        for (auto *transitiveCmd : AdditionalOutOfDateCommands)
+          noteBuilding(transitiveCmd, "because of the initial set");
+        size_t firstSize = AdditionalOutOfDateCommands.size();
+
+        // Check all cross-module dependencies as well.
+        for (StringRef dependency : DepGraph.getExternalDependencies()) {
+          llvm::sys::fs::file_status depStatus;
+          if (!llvm::sys::fs::status(dependency, depStatus))
+            if (depStatus.getLastModificationTime() < Comp.LastBuildTime)
+              continue;
+
+          // If the dependency has been modified since the oldest built file,
+          // or if we can't stat it for some reason (perhaps it's been deleted?),
+          // trigger rebuilds through the dependency graph.
+          DepGraph.markExternal(AdditionalOutOfDateCommands, dependency);
+        }
+
+        for (auto *externalCmd :
+               llvm::makeArrayRef(AdditionalOutOfDateCommands).slice(firstSize)) {
+          noteBuilding(externalCmd, "because of external dependencies");
+        }
+
+        for (auto *AdditionalCmd : AdditionalOutOfDateCommands) {
+          if (!DeferredCommands.count(AdditionalCmd))
+            continue;
+          scheduleCommandIfNecessaryAndPossible(AdditionalCmd);
+          DeferredCommands.erase(AdditionalCmd);
+        }
+      }
+    }
+
+    void runTaskQueueToCompletion() {
+      do {
+        using namespace std::placeholders;
+        // Ask the TaskQueue to execute.
+        TQ->execute(std::bind(&PerformJobsState::taskBegan, this,
+                              _1, _2),
+                    std::bind(&PerformJobsState::taskFinished, this,
+                              _1, _2, _3, _4, _5),
+                    std::bind(&PerformJobsState::taskSignalled, this,
+                              _1, _2, _3, _4, _5, _6));
+
+        // Mark all remaining deferred commands as skipped.
+        for (const Job *Cmd : DeferredCommands) {
+          if (Comp.Level == OutputLevel::Parseable) {
+            // Provide output indicating this command was skipped if parseable output
+            // was requested.
+            parseable_output::emitSkippedMessage(llvm::errs(), *Cmd);
+          }
+
+          ScheduledCommands.insert(Cmd);
+          markFinished(Cmd, /*Skipped=*/true);
+        }
+        DeferredCommands.clear();
+
+        // ...which may allow us to go on and do later tasks.
+      } while (Result == 0 && TQ->hasRemainingTasks());
+    }
+
+    void checkUnfinishedJobs() {
+      if (Result == 0) {
+        assert(BlockingCommands.empty() &&
+               "some blocking commands never finished properly");
+      } else {
+        // Make sure we record any files that still need to be rebuilt.
+        for (const Job *Cmd : Comp.getJobs()) {
+          // Skip files that don't use dependency analysis.
+          StringRef DependenciesFile =
+            Cmd->getOutput().getAdditionalOutputForType(types::TY_SwiftDeps);
+          if (DependenciesFile.empty())
+            continue;
+
+          // Don't worry about commands that finished or weren't going to run.
+          if (FinishedCommands.count(Cmd))
+            continue;
+          if (!ScheduledCommands.count(Cmd))
+            continue;
+
+          bool isCascading = true;
+          if (Comp.getIncrementalBuildEnabled())
+            isCascading = DepGraph.isMarked(Cmd);
+          UnfinishedCommands.insert({Cmd, isCascading});
+        }
+      }
+    }
+
+    void populateInputInfoMap(InputInfoMap &inputs) const {
+      for (auto &entry : UnfinishedCommands) {
+        for (auto *action : entry.first->getSource().getInputs()) {
+          auto inputFile = dyn_cast<InputAction>(action);
+          if (!inputFile)
+            continue;
+
+          CompileJobAction::InputInfo info;
+          info.previousModTime = entry.first->getInputModTime();
+          info.status = entry.second ?
+            CompileJobAction::InputInfo::NeedsCascadingBuild :
+            CompileJobAction::InputInfo::NeedsNonCascadingBuild;
+          inputs[&inputFile->getInputArg()] = info;
+        }
+      }
+
+      for (const Job *entry : FinishedCommands) {
+        const auto *compileAction = dyn_cast<CompileJobAction>(&entry->getSource());
+        if (!compileAction)
+          continue;
+
+        for (auto *action : compileAction->getInputs()) {
+          auto inputFile = dyn_cast<InputAction>(action);
+          if (!inputFile)
+            continue;
+
+          CompileJobAction::InputInfo info;
+          info.previousModTime = entry->getInputModTime();
+          info.status = CompileJobAction::InputInfo::UpToDate;
+          inputs[&inputFile->getInputArg()] = info;
+        }
+      }
+
+      // Sort the entries by input order.
+      static_assert(IsTriviallyCopyable<CompileJobAction::InputInfo>::value,
+                    "llvm::array_pod_sort relies on trivially-copyable data");
+      using InputInfoEntry = std::decay<decltype(inputs.front())>::type;
+      llvm::array_pod_sort(inputs.begin(), inputs.end(),
+                           [](const InputInfoEntry *lhs,
+                              const InputInfoEntry *rhs) -> int {
+                             auto lhsIndex = lhs->first->getIndex();
+                             auto rhsIndex = rhs->first->getIndex();
+                             return (lhsIndex < rhsIndex) ? -1 : (lhsIndex > rhsIndex) ? 1 : 0;
+                           });
+    }
+
+    int getResult() {
+      if (Result == 0)
+        Result = Comp.Diags.hadAnyError();
+      return Result;
+    }
   };
-} // end anonymous namespace
+} // driver
+} // swift
 
 Compilation::~Compilation() = default;
 
@@ -100,64 +690,6 @@
   return result;
 }
 
-static const Job *findUnfinishedJob(ArrayRef<const Job *> JL,
-                                    const CommandSet &FinishedCommands) {
-  for (const Job *Cmd : JL) {
-    if (!FinishedCommands.count(Cmd))
-      return Cmd;
-  }
-  return nullptr;
-}
-
-using InputInfoMap =
-  llvm::SmallMapVector<const llvm::opt::Arg *, CompileJobAction::InputInfo, 16>;
-
-static void populateInputInfoMap(InputInfoMap &inputs,
-                                 const PerformJobsState &endState) {
-  for (auto &entry : endState.UnfinishedCommands) {
-    for (auto *action : entry.first->getSource().getInputs()) {
-      auto inputFile = dyn_cast<InputAction>(action);
-      if (!inputFile)
-        continue;
-
-      CompileJobAction::InputInfo info;
-      info.previousModTime = entry.first->getInputModTime();
-      info.status = entry.second ?
-          CompileJobAction::InputInfo::NeedsCascadingBuild :
-          CompileJobAction::InputInfo::NeedsNonCascadingBuild;
-      inputs[&inputFile->getInputArg()] = info;
-    }
-  }
-
-  for (const Job *entry : endState.FinishedCommands) {
-    const auto *compileAction = dyn_cast<CompileJobAction>(&entry->getSource());
-    if (!compileAction)
-      continue;
-
-    for (auto *action : compileAction->getInputs()) {
-      auto inputFile = dyn_cast<InputAction>(action);
-      if (!inputFile)
-        continue;
-
-      CompileJobAction::InputInfo info;
-      info.previousModTime = entry->getInputModTime();
-      info.status = CompileJobAction::InputInfo::UpToDate;
-      inputs[&inputFile->getInputArg()] = info;
-    }
-  }
-
-  // Sort the entries by input order.
-  static_assert(IsTriviallyCopyable<CompileJobAction::InputInfo>::value,
-                "llvm::array_pod_sort relies on trivially-copyable data");
-  using InputInfoEntry = std::decay<decltype(inputs.front())>::type;
-  llvm::array_pod_sort(inputs.begin(), inputs.end(),
-                       [](const InputInfoEntry *lhs,
-                          const InputInfoEntry *rhs) -> int {
-    auto lhsIndex = lhs->first->getIndex();
-    auto rhsIndex = rhs->first->getIndex();
-    return (lhsIndex < rhsIndex) ? -1 : (lhsIndex > rhsIndex) ? 1 : 0;
-  });
-}
 
 static void checkForOutOfDateInputs(DiagnosticEngine &diags,
                                     const InputInfoMap &inputs) {
@@ -274,448 +806,23 @@
 }
 
 int Compilation::performJobsImpl() {
-  // Create a TaskQueue for execution.
-  std::unique_ptr<TaskQueue> TQ;
-  if (SkipTaskExecution)
-    TQ.reset(new DummyTaskQueue(NumberOfParallelCommands));
-  else
-    TQ.reset(new TaskQueue(NumberOfParallelCommands));
 
-  PerformJobsState State;
+  PerformJobsState State(*this);
 
-  using DependencyGraph = DependencyGraph<const Job *>;
-  DependencyGraph DepGraph;
-  SmallPtrSet<const Job *, 16> DeferredCommands;
-  SmallVector<const Job *, 16> InitialOutOfDateCommands;
-
-  DependencyGraph::MarkTracer ActualIncrementalTracer;
-  DependencyGraph::MarkTracer *IncrementalTracer = nullptr;
-  if (ShowIncrementalBuildDecisions)
-    IncrementalTracer = &ActualIncrementalTracer;
-
-  auto noteBuilding = [&] (const Job *cmd, StringRef reason) {
-    if (!ShowIncrementalBuildDecisions)
-      return;
-    if (State.ScheduledCommands.count(cmd))
-      return;
-    llvm::outs() << "Queuing "
-                 << llvm::sys::path::filename(cmd->getOutput().getBaseInput(0))
-                 << " " << reason << "\n";
-    IncrementalTracer->printPath(llvm::outs(), cmd,
-                                 [](raw_ostream &out, const Job *base) {
-      out << llvm::sys::path::filename(base->getOutput().getBaseInput(0));
-    });
-  };
-
-  // Set up scheduleCommandIfNecessaryAndPossible.
-  // This will only schedule the given command if it has not been scheduled
-  // and if all of its inputs are in FinishedCommands.
-  auto scheduleCommandIfNecessaryAndPossible = [&] (const Job *Cmd) {
-    if (State.ScheduledCommands.count(Cmd))
-      return;
-
-    if (auto Blocking = findUnfinishedJob(Cmd->getInputs(),
-                                          State.FinishedCommands)) {
-      State.BlockingCommands[Blocking].push_back(Cmd);
-      return;
-    }
-
-    // FIXME: Failing here should not take down the whole process.
-    bool success = writeFilelistIfNecessary(Cmd, Diags);
-    assert(success && "failed to write filelist");
-    (void)success;
-
-    assert(Cmd->getExtraEnvironment().empty() &&
-           "not implemented for compilations with multiple jobs");
-    State.ScheduledCommands.insert(Cmd);
-    TQ->addTask(Cmd->getExecutable(), Cmd->getArguments(), llvm::None,
-                (void *)Cmd);
-  };
-
-  // When a task finishes, we need to reevaluate the other commands that
-  // might have been blocked.
-  auto markFinished = [&] (const Job *Cmd) {
-    State.FinishedCommands.insert(Cmd);
-
-    auto BlockedIter = State.BlockingCommands.find(Cmd);
-    if (BlockedIter != State.BlockingCommands.end()) {
-      auto AllBlocked = std::move(BlockedIter->second);
-      State.BlockingCommands.erase(BlockedIter);
-      for (auto *Blocked : AllBlocked)
-        scheduleCommandIfNecessaryAndPossible(Blocked);
-    }
-  };
-
-  // Schedule all jobs we can.
-  for (const Job *Cmd : getJobs()) {
-    if (!getIncrementalBuildEnabled()) {
-      scheduleCommandIfNecessaryAndPossible(Cmd);
-      continue;
-    }
-
-    // Try to load the dependencies file for this job. If there isn't one, we
-    // always have to run the job, but it doesn't affect any other jobs. If
-    // there should be one but it's not present or can't be loaded, we have to
-    // run all the jobs.
-    // FIXME: We can probably do better here!
-    Job::Condition Condition = Job::Condition::Always;
-    StringRef DependenciesFile =
-      Cmd->getOutput().getAdditionalOutputForType(types::TY_SwiftDeps);
-    if (!DependenciesFile.empty()) {
-      if (Cmd->getCondition() == Job::Condition::NewlyAdded) {
-        DepGraph.addIndependentNode(Cmd);
-      } else {
-        switch (DepGraph.loadFromPath(Cmd, DependenciesFile)) {
-        case DependencyGraphImpl::LoadResult::HadError:
-          disableIncrementalBuild();
-          for (const Job *Cmd : DeferredCommands)
-            scheduleCommandIfNecessaryAndPossible(Cmd);
-          DeferredCommands.clear();
-          break;
-        case DependencyGraphImpl::LoadResult::UpToDate:
-          Condition = Cmd->getCondition();
-          break;
-        case DependencyGraphImpl::LoadResult::AffectsDownstream:
-          llvm_unreachable("we haven't marked anything in this graph yet");
-        }
-      }
-    }
-
-    switch (Condition) {
-    case Job::Condition::Always:
-      if (getIncrementalBuildEnabled() && !DependenciesFile.empty()) {
-        InitialOutOfDateCommands.push_back(Cmd);
-        DepGraph.markIntransitive(Cmd);
-      }
-      LLVM_FALLTHROUGH;
-    case Job::Condition::RunWithoutCascading:
-      noteBuilding(Cmd, "(initial)");
-      scheduleCommandIfNecessaryAndPossible(Cmd);
-      break;
-    case Job::Condition::CheckDependencies:
-      DeferredCommands.insert(Cmd);
-      break;
-    case Job::Condition::NewlyAdded:
-      llvm_unreachable("handled above");
-    }
-  }
-
-  if (getIncrementalBuildEnabled()) {
-    SmallVector<const Job *, 16> AdditionalOutOfDateCommands;
-
-    // We scheduled all of the files that have actually changed. Now add the
-    // files that haven't changed, so that they'll get built in parallel if
-    // possible and after the first set of files if it's not.
-    for (auto *Cmd : InitialOutOfDateCommands) {
-      DepGraph.markTransitive(AdditionalOutOfDateCommands, Cmd,
-                              IncrementalTracer);
-    }
-
-    for (auto *transitiveCmd : AdditionalOutOfDateCommands)
-      noteBuilding(transitiveCmd, "because of the initial set:");
-    size_t firstSize = AdditionalOutOfDateCommands.size();
-
-    // Check all cross-module dependencies as well.
-    for (StringRef dependency : DepGraph.getExternalDependencies()) {
-      llvm::sys::fs::file_status depStatus;
-      if (!llvm::sys::fs::status(dependency, depStatus))
-        if (depStatus.getLastModificationTime() < LastBuildTime)
-          continue;
-
-      // If the dependency has been modified since the oldest built file,
-      // or if we can't stat it for some reason (perhaps it's been deleted?),
-      // trigger rebuilds through the dependency graph.
-      DepGraph.markExternal(AdditionalOutOfDateCommands, dependency);
-    }
-
-    for (auto *externalCmd :
-            llvm::makeArrayRef(AdditionalOutOfDateCommands).slice(firstSize)) {
-      noteBuilding(externalCmd, "because of external dependencies");
-    }
-
-    for (auto *AdditionalCmd : AdditionalOutOfDateCommands) {
-      if (!DeferredCommands.count(AdditionalCmd))
-        continue;
-      scheduleCommandIfNecessaryAndPossible(AdditionalCmd);
-      DeferredCommands.erase(AdditionalCmd);
-    }
-  }
-
-  int Result = EXIT_SUCCESS;
-  llvm::TimerGroup DriverTimerGroup("driver", "Driver Compilation Time");
-  llvm::SmallDenseMap<const Job *, std::unique_ptr<llvm::Timer>, 16>
-    DriverTimers;
-
-  // Set up a callback which will be called immediately after a task has
-  // started. This callback may be used to provide output indicating that the
-  // task began.
-  auto taskBegan = [&] (ProcessId Pid, void *Context) {
-    // TODO: properly handle task began.
-    const Job *BeganCmd = (const Job *)Context;
-
-    if (ShowDriverTimeCompilation) {
-      llvm::SmallString<128> TimerName;
-      llvm::raw_svector_ostream OS(TimerName);
-
-      OS << BeganCmd->getSource().getClassName();
-      for (auto A : BeganCmd->getSource().getInputs()) {
-        if (const InputAction *IA = dyn_cast<InputAction>(A)) {
-          OS << " " << IA->getInputArg().getValue();
-        }
-      }
-      for (auto J : BeganCmd->getInputs()) {
-        for (auto A : J->getSource().getInputs()) {
-          if (const InputAction *IA = dyn_cast<InputAction>(A)) {
-            OS << " " << IA->getInputArg().getValue();
-          }
-        }
-      }
-
-      DriverTimers.insert({
-        BeganCmd,
-        std::unique_ptr<llvm::Timer>(
-          new llvm::Timer("task", OS.str(), DriverTimerGroup))
-      });
-      DriverTimers[BeganCmd]->startTimer();
-    }
-
-    // For verbose output, print out each command as it begins execution.
-    if (Level == OutputLevel::Verbose)
-      BeganCmd->printCommandLine(llvm::errs());
-    else if (Level == OutputLevel::Parseable)
-      parseable_output::emitBeganMessage(llvm::errs(), *BeganCmd, Pid);
-  };
-
-  // Set up a callback which will be called immediately after a task has
-  // finished execution. This callback should determine if execution should
-  // continue (if execution should stop, this callback should return true), and
-  // it should also schedule any additional commands which we now know need
-  // to run.
-  auto taskFinished = [&](ProcessId Pid, int ReturnCode, StringRef Output,
-                          StringRef Errors,
-                          void *Context) -> TaskFinishedResponse {
-    const Job *FinishedCmd = (const Job *)Context;
-
-    if (ShowDriverTimeCompilation) {
-      DriverTimers[FinishedCmd]->stopTimer();
-    }
-
-    if (Level == OutputLevel::Parseable) {
-      // Parseable output was requested.
-      parseable_output::emitFinishedMessage(llvm::errs(), *FinishedCmd, Pid,
-                                            ReturnCode, Output);
-    } else {
-      // Otherwise, send the buffered output to stderr, though only if we
-      // support getting buffered output.
-      if (TaskQueue::supportsBufferingOutput())
-        llvm::errs() << Output;
-    }
-
-    // In order to handle both old dependencies that have disappeared and new
-    // dependencies that have arisen, we need to reload the dependency file.
-    // Do this whether or not the build succeeded.
-    SmallVector<const Job *, 16> Dependents;
-    if (getIncrementalBuildEnabled()) {
-      const CommandOutput &Output = FinishedCmd->getOutput();
-      StringRef DependenciesFile =
-        Output.getAdditionalOutputForType(types::TY_SwiftDeps);
-
-      if (DependenciesFile.empty()) {
-        // If this job doesn't track dependencies, it must always be run.
-        // Note: In theory CheckDependencies makes sense as well (for a leaf
-        // node in the dependency graph), and maybe even NewlyAdded (for very
-        // coarse dependencies that always affect downstream nodes), but we're
-        // not using either of those right now, and this logic should probably
-        // be revisited when we are.
-        assert(FinishedCmd->getCondition() == Job::Condition::Always);
-      } else {
-        // If we have a dependency file /and/ the frontend task exited normally,
-        // we can be discerning about what downstream files to rebuild.
-        if (ReturnCode == EXIT_SUCCESS || ReturnCode == EXIT_FAILURE) {
-          bool wasCascading = DepGraph.isMarked(FinishedCmd);
-
-          switch (DepGraph.loadFromPath(FinishedCmd, DependenciesFile)) {
-          case DependencyGraphImpl::LoadResult::HadError:
-            if (ReturnCode == EXIT_SUCCESS) {
-              disableIncrementalBuild();
-              for (const Job *Cmd : DeferredCommands)
-                scheduleCommandIfNecessaryAndPossible(Cmd);
-              DeferredCommands.clear();
-              Dependents.clear();
-            } // else, let the next build handle it.
-            break;
-          case DependencyGraphImpl::LoadResult::UpToDate:
-            if (!wasCascading)
-              break;
-            LLVM_FALLTHROUGH;
-          case DependencyGraphImpl::LoadResult::AffectsDownstream:
-            DepGraph.markTransitive(Dependents, FinishedCmd);
-            break;
-          }
-        } else {
-          // If there's an abnormal exit (a crash), assume the worst.
-          switch (FinishedCmd->getCondition()) {
-          case Job::Condition::NewlyAdded:
-            // The job won't be treated as newly added next time. Conservatively
-            // mark it as affecting other jobs, because some of them may have
-            // completed already.
-            DepGraph.markTransitive(Dependents, FinishedCmd);
-            break;
-          case Job::Condition::Always:
-            // Any incremental task that shows up here has already been marked;
-            // we didn't need to wait for it to finish to start downstream
-            // tasks.
-            assert(DepGraph.isMarked(FinishedCmd));
-            break;
-          case Job::Condition::RunWithoutCascading:
-            // If this file changed, it might have been a non-cascading change
-            // and it might not. Unfortunately, the interface hash has been
-            // updated or compromised, so we don't actually know anymore; we
-            // have to conservatively assume the changes could affect other
-            // files.
-            DepGraph.markTransitive(Dependents, FinishedCmd);
-            break;
-          case Job::Condition::CheckDependencies:
-            // If the only reason we're running this is because something else
-            // changed, then we can trust the dependency graph as to whether
-            // it's a cascading or non-cascading change. That is, if whatever
-            // /caused/ the error isn't supposed to affect other files, and
-            // whatever /fixes/ the error isn't supposed to affect other files,
-            // then there's no need to recompile any other inputs. If either of
-            // those are false, we /do/ need to recompile other inputs.
-            break;
-          }
-        }
-      }
-    }
-
-    if (ReturnCode != EXIT_SUCCESS) {
-      // The task failed, so return true without performing any further
-      // dependency analysis.
-
-      // Store this task's ReturnCode as our Result if we haven't stored
-      // anything yet.
-      if (Result == EXIT_SUCCESS)
-        Result = ReturnCode;
-
-      if (!isa<CompileJobAction>(FinishedCmd->getSource()) ||
-          ReturnCode != EXIT_FAILURE) {
-        Diags.diagnose(SourceLoc(), diag::error_command_failed,
-                       FinishedCmd->getSource().getClassName(),
-                       ReturnCode);
-      }
-
-      return ContinueBuildingAfterErrors ?
-          TaskFinishedResponse::ContinueExecution :
-          TaskFinishedResponse::StopExecution;
-    }
-
-    // When a task finishes, we need to reevaluate the other commands that
-    // might have been blocked.
-    markFinished(FinishedCmd);
-
-    for (const Job *Cmd : Dependents) {
-      DeferredCommands.erase(Cmd);
-      noteBuilding(Cmd, "because of dependencies discovered later");
-      scheduleCommandIfNecessaryAndPossible(Cmd);
-    }
-
-    return TaskFinishedResponse::ContinueExecution;
-  };
-
-  auto taskSignalled = [&](ProcessId Pid, StringRef ErrorMsg, StringRef Output,
-                           StringRef Errors,
-                           void *Context, Optional<int> Signal) -> TaskFinishedResponse {
-    const Job *SignalledCmd = (const Job *)Context;
-
-    if (ShowDriverTimeCompilation) {
-      DriverTimers[SignalledCmd]->stopTimer();
-    }
-
-    if (Level == OutputLevel::Parseable) {
-      // Parseable output was requested.
-      parseable_output::emitSignalledMessage(llvm::errs(), *SignalledCmd, Pid,
-                                             ErrorMsg, Output, Signal);
-    } else {
-      // Otherwise, send the buffered output to stderr, though only if we
-      // support getting buffered output.
-      if (TaskQueue::supportsBufferingOutput())
-        llvm::errs() << Output;
-    }
-
-    if (!ErrorMsg.empty())
-      Diags.diagnose(SourceLoc(), diag::error_unable_to_execute_command,
-                     ErrorMsg);
-    
-    if (Signal.hasValue()) {
-      Diags.diagnose(SourceLoc(), diag::error_command_signalled,
-                     SignalledCmd->getSource().getClassName(), Signal.getValue());
-    } else {
-      Diags.diagnose(SourceLoc(), diag::error_command_signalled_without_signal_number,
-                     SignalledCmd->getSource().getClassName());
-    }
-
-    // Since the task signalled, unconditionally set result to -2.
-    Result = -2;
-
-    return TaskFinishedResponse::StopExecution;
-  };
-
-  do {
-    // Ask the TaskQueue to execute.
-    TQ->execute(taskBegan, taskFinished, taskSignalled);
-
-    // Mark all remaining deferred commands as skipped.
-    for (const Job *Cmd : DeferredCommands) {
-      if (Level == OutputLevel::Parseable) {
-        // Provide output indicating this command was skipped if parseable output
-        // was requested.
-        parseable_output::emitSkippedMessage(llvm::errs(), *Cmd);
-      }
-
-      State.ScheduledCommands.insert(Cmd);
-      markFinished(Cmd);
-    }
-
-    // ...which may allow us to go on and do later tasks.
-  } while (Result == 0 && TQ->hasRemainingTasks());
-
-  if (Result == 0) {
-    assert(State.BlockingCommands.empty() &&
-           "some blocking commands never finished properly");
-  } else {
-    // Make sure we record any files that still need to be rebuilt.
-    for (const Job *Cmd : getJobs()) {
-      // Skip files that don't use dependency analysis.
-      StringRef DependenciesFile =
-          Cmd->getOutput().getAdditionalOutputForType(types::TY_SwiftDeps);
-      if (DependenciesFile.empty())
-        continue;
-
-      // Don't worry about commands that finished or weren't going to run.
-      if (State.FinishedCommands.count(Cmd))
-        continue;
-      if (!State.ScheduledCommands.count(Cmd))
-        continue;
-
-      bool isCascading = true;
-      if (getIncrementalBuildEnabled())
-        isCascading = DepGraph.isMarked(Cmd);
-      State.UnfinishedCommands.insert({Cmd, isCascading});
-    }
-  }
+  State.scheduleInitialJobs();
+  State.scheduleAdditionalJobs();
+  State.runTaskQueueToCompletion();
+  State.checkUnfinishedJobs();
 
   if (!CompilationRecordPath.empty() && !SkipTaskExecution) {
     InputInfoMap InputInfo;
-    populateInputInfoMap(InputInfo, State);
+    State.populateInputInfoMap(InputInfo);
     checkForOutOfDateInputs(Diags, InputInfo);
     writeCompilationRecord(CompilationRecordPath, ArgsHash, BuildStartTime,
                            InputInfo);
   }
 
-  if (Result == 0)
-    Result = Diags.hadAnyError();
-  return Result;
+  return State.getResult();
 }
 
 int Compilation::performSingleCommand(const Job *Cmd) {
diff --git a/lib/Driver/DependencyGraph.cpp b/lib/Driver/DependencyGraph.cpp
index 1b321eb..6db9006 100644
--- a/lib/Driver/DependencyGraph.cpp
+++ b/lib/Driver/DependencyGraph.cpp
@@ -425,10 +425,15 @@
       }
       StringRef memberPart = name.str().substr(splitPoint+1);
 
-      out << " provides member '" << memberPart << "' of type '"
-          << swift::Demangle::demangleTypeAsString(typePart)
-          << "'\n";
-
+      if (memberPart.empty()) {
+        out << " provides non-private members of type '"
+            << swift::Demangle::demangleTypeAsString(typePart)
+            << "'\n";
+      } else {
+        out << " provides member '" << memberPart << "' of type '"
+            << swift::Demangle::demangleTypeAsString(typePart)
+            << "'\n";
+      }
     } else if (entry.KindMask.contains(DependencyKind::DynamicLookupName)) {
       out << " provides AnyObject member '" << entry.Name << "'\n";
 
diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp
index 3990de9..525b511 100644
--- a/lib/Driver/Driver.cpp
+++ b/lib/Driver/Driver.cpp
@@ -470,6 +470,8 @@
     ArgList->hasArg(options::OPT_driver_skip_execution);
   bool ShowIncrementalBuildDecisions =
     ArgList->hasArg(options::OPT_driver_show_incremental);
+  bool ShowJobLifecycle =
+    ArgList->hasArg(options::OPT_driver_show_job_lifecycle);
 
   bool Incremental = ArgList->hasArg(options::OPT_incremental);
   if (ArgList->hasArg(options::OPT_whole_module_optimization)) {
@@ -642,9 +644,12 @@
       ContinueBuildingAfterErrors)
     C->setContinueBuildingAfterErrors();
 
-  if (ShowIncrementalBuildDecisions)
+  if (ShowIncrementalBuildDecisions || ShowJobLifecycle)
     C->setShowsIncrementalBuildDecisions();
 
+  if (ShowJobLifecycle)
+    C->setShowJobLifecycle();
+
   // This has to happen after building jobs, because otherwise we won't even
   // emit .swiftdeps files for the next build.
   if (rebuildEverything)
diff --git a/lib/Driver/Job.cpp b/lib/Driver/Job.cpp
index 10733cf..d4a8beb 100644
--- a/lib/Driver/Job.cpp
+++ b/lib/Driver/Job.cpp
@@ -13,7 +13,9 @@
 #include "swift/Basic/STLExtras.h"
 #include "swift/Driver/Job.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Option/Arg.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -106,3 +108,42 @@
   printArguments(os, Arguments);
   os << Terminator;
 }
+
+void Job::printSummary(raw_ostream &os) const {
+  // Deciding how to describe our inputs is a bit subtle; if we are a Job built
+  // from a JobAction that itself has InputActions sources, then we collect
+  // those up. Otherwise it's more correct to talk about our inputs as the
+  // outputs of our input-jobs.
+  SmallVector<std::string, 4> Inputs;
+
+  for (const Action *A : getSource().getInputs())
+    if (const InputAction *IA = dyn_cast<InputAction>(A))
+      Inputs.push_back(IA->getInputArg().getValue());
+
+  for (const Job *J : getInputs())
+    for (const std::string &f : J->getOutput().getPrimaryOutputFilenames())
+      Inputs.push_back(f);
+
+  size_t limit = 3;
+  size_t actual = Inputs.size();
+  if (actual > limit) {
+    Inputs.erase(Inputs.begin() + limit, Inputs.end());
+  }
+
+  os << "{" << getSource().getClassName() << ": ";
+  interleave(getOutput().getPrimaryOutputFilenames(),
+             [&](const std::string &Arg) {
+               os << llvm::sys::path::filename(Arg);
+             },
+             [&] { os << ' '; });
+  os << " <= ";
+  interleave(Inputs,
+             [&](const std::string &Arg) {
+               os << llvm::sys::path::filename(Arg);
+             },
+             [&] { os << ' '; });
+  if (actual > limit) {
+    os << " ... " << (actual-limit) << " more";
+  }
+  os << "}";
+}
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
index 6fbb2a2..49c09b0 100644
--- a/lib/Frontend/CompilerInvocation.cpp
+++ b/lib/Frontend/CompilerInvocation.cpp
@@ -802,7 +802,7 @@
 
   // Check for an unneeded minor version, otherwise just list valid versions
   if (vers.hasValue() && !vers.getValue().empty() &&
-      vers.getValue().asMajorVersion().isValidEffectiveLanguageVersion()) {
+      vers.getValue().asMajorVersion().getEffectiveLanguageVersion()) {
     diags.diagnose(SourceLoc(), diag::note_swift_version_major,
                    vers.getValue()[0]);
   } else {
@@ -822,12 +822,15 @@
   if (auto A = Args.getLastArg(OPT_swift_version)) {
     auto vers = version::Version::parseVersionString(
       A->getValue(), SourceLoc(), &Diags);
-    if (vers.hasValue() &&
-        vers.getValue().isValidEffectiveLanguageVersion()) {
-      Opts.EffectiveLanguageVersion = vers.getValue();
-    } else {
-      diagnoseSwiftVersion(vers, A, Args, Diags);
+    bool isValid = false;
+    if (vers.hasValue()) {
+      if (auto effectiveVers = vers.getValue().getEffectiveLanguageVersion()) {
+        Opts.EffectiveLanguageVersion = effectiveVers.getValue();
+        isValid = true;
+      }
     }
+    if (!isValid)
+      diagnoseSwiftVersion(vers, A, Args, Diags);
   }
 
   Opts.AttachCommentsToDecls |= Args.hasArg(OPT_dump_api_path);
diff --git a/lib/IRGen/DebugTypeInfo.cpp b/lib/IRGen/DebugTypeInfo.cpp
index 551ea82..98f1546 100644
--- a/lib/IRGen/DebugTypeInfo.cpp
+++ b/lib/IRGen/DebugTypeInfo.cpp
@@ -50,16 +50,15 @@
                        Info.getBestKnownAlignment());
 }
 
-DebugTypeInfo DebugTypeInfo::getLocalVariable(DeclContext *DeclCtx,
+DebugTypeInfo DebugTypeInfo::getLocalVariable(DeclContext *DC,
                                               VarDecl *Decl, swift::Type Ty,
                                               const TypeInfo &Info,
                                               bool Unwrap) {
 
-  auto DeclType = Ty;
-  if (DeclCtx)
-    DeclType = (Decl->hasType()
-                    ? Decl->getType()
-                    : DeclCtx->mapTypeIntoContext(Decl->getInterfaceType()));
+  auto DeclType = (Decl->hasType()
+                   ? Decl->getType()
+                   : Decl->getDeclContext()->mapTypeIntoContext(
+                     Decl->getInterfaceType()));
   auto RealType = Ty;
   if (Unwrap) {
     DeclType = DeclType->getInOutObjectType();
@@ -75,7 +74,7 @@
   // the type hasn't been mucked with by an optimization pass.
   auto *Type = DeclSelfType->isEqual(RealType) ? DeclType.getPointer()
                                                : RealType.getPointer();
-  return getFromTypeInfo(DeclCtx, Type, Info);
+  return getFromTypeInfo(DC, Type, Info);
 }
 
 DebugTypeInfo DebugTypeInfo::getMetadata(swift::Type Ty, llvm::Type *StorageTy,
diff --git a/lib/IRGen/DebugTypeInfo.h b/lib/IRGen/DebugTypeInfo.h
index 87d389e..dc398e8 100644
--- a/lib/IRGen/DebugTypeInfo.h
+++ b/lib/IRGen/DebugTypeInfo.h
@@ -37,7 +37,8 @@
 /// for a type.
 class DebugTypeInfo {
 public:
-  /// The DeclContext if this is has an Archetype.
+  /// The DeclContext of the function. This might not be the DeclContext of
+  /// the variable if inlining took place.
   DeclContext *DeclCtx;
   /// The type we need to emit may be different from the type
   /// mentioned in the Decl, for example, stripped of qualifiers.
diff --git a/lib/IRGen/GenArchetype.cpp b/lib/IRGen/GenArchetype.cpp
index 8fc2a0c..88aa338 100644
--- a/lib/IRGen/GenArchetype.cpp
+++ b/lib/IRGen/GenArchetype.cpp
@@ -74,49 +74,70 @@
   return metadata;
 }
 
-static bool declaresDirectConformance(AssociatedTypeDecl *associatedType,
-                                      ProtocolDecl *target) {
-  for (auto protocol : associatedType->getConformingProtocols()) {
-    if (protocol == target)
-      return true;
-  }
-  return false;
+namespace {
+  struct ConformancePath {
+    CanArchetypeType ParentArchetype;
+    ProtocolDecl *ParentProtocol;
+    CanType Path;
+  };
 }
 
-static AssociatedTypeDecl *
-findConformanceDeclaration(ArrayRef<ProtocolDecl*> conformsTo,
-                           AssociatedTypeDecl *associatedType,
-                           ProtocolDecl *target) {
-  // Fast path: this associated type declaration declares the
-  // desired conformance.
-  if (declaresDirectConformance(associatedType, target))
-    return associatedType;
-
-  // Otherwise, look at the conformance list.
-  for (auto source : conformsTo) {
-    // Do a lookup in this protocol.
-    auto results = source->lookupDirect(associatedType->getFullName());
-    for (auto lookupResult: results) {
-      if (auto sourceAssociatedType =
-            dyn_cast<AssociatedTypeDecl>(lookupResult)) {
-        if (declaresDirectConformance(sourceAssociatedType, target))
-          return sourceAssociatedType;
+static Optional<ConformancePath>
+declaresDirectConformance(ProtocolDecl *source,
+                          AssociatedTypeDecl *associatedType,
+                          ProtocolDecl *target) {
+  for (auto &reqt : source->getRequirementSignature()->getRequirements()) {
+    if (reqt.getKind() != RequirementKind::Conformance)
+      continue;
+    if (reqt.getSecondType()->castTo<ProtocolType>()->getDecl() != target)
+      continue;
+    auto path = reqt.getFirstType()->getCanonicalType();
+    if (auto memberType = dyn_cast<DependentMemberType>(path)) {
+      if (isa<GenericTypeParamType>(memberType.getBase())) {
+        assert(memberType.getBase()->isEqual(source->getSelfInterfaceType()));
+        if (memberType->getName() == associatedType->getName())
+          return ConformancePath{ CanArchetypeType(), source, path };
       }
     }
+  }
+  return None;
+}
+
+static Optional<ConformancePath>
+findConformanceRecursive(ArrayRef<ProtocolDecl*> conformsTo,
+                         AssociatedTypeDecl *associatedType,
+                         ProtocolDecl *target) {
+  for (auto source : conformsTo) {
+    // Check the protocol directly.
+    if (source != associatedType->getProtocol())
+      if (auto result = declaresDirectConformance(source, associatedType,
+                                                  target))
+        return result;
 
     // Recurse into implied protocols.
-    if (auto result =
-          findConformanceDeclaration(source->getInheritedProtocols(),
-                                     associatedType, target)) {
+    if (auto result = findConformanceRecursive(source->getInheritedProtocols(),
+                                               associatedType, target))
       return result;
-    }
   }
 
   // Give up.
-  return nullptr;
+  return None;
 }
 
-static IRGenFunction::ArchetypeAccessPath
+static Optional<ConformancePath>
+findConformanceDeclaration(ArrayRef<ProtocolDecl*> conformsTo,
+                           AssociatedTypeDecl *associatedType,
+                           ProtocolDecl *target) {
+  // Fast path: if the protocol that made this associated type
+  // declaration declared the desired conformance, we can use it directly.
+  if (auto result = declaresDirectConformance(associatedType->getProtocol(),
+                                              associatedType, target))
+    return result;
+
+  return findConformanceRecursive(conformsTo, associatedType, target);
+}
+
+static ConformancePath
 findAccessPathDeclaringConformance(IRGenFunction &IGF,
                                    CanArchetypeType archetype,
                                    ProtocolDecl *protocol) {
@@ -128,14 +149,20 @@
     auto association =
       findConformanceDeclaration(parent->getConformsTo(),
                                  archetype->getAssocType(), protocol);
-    if (association) return { parent, association };
+    if (association) {
+      association->ParentArchetype = parent;
+      return *association;
+    }
   }
 
   for (auto accessPath : IGF.getArchetypeAccessPaths(archetype)) {
     auto association =
       findConformanceDeclaration(accessPath.BaseType->getConformsTo(),
                                  accessPath.Association, protocol);
-    if (association) return { accessPath.BaseType, association };
+    if (association) {
+      association->ParentArchetype = accessPath.BaseType;
+      return *association;
+    }
   }
 
   llvm_unreachable("no relation found that declares conformance to target");
@@ -197,16 +224,30 @@
 
     // If that's not present, this conformance must be implied by some
     // associated-type relationship.
+
+    // First, find the right access path.
     auto accessPath =
       findAccessPathDeclaringConformance(IGF, archetype, protocol);
 
-    // To do this, we need the metadata for the associated type.
-    auto associatedMetadata = emitArchetypeTypeMetadataRef(IGF, archetype);
+    // Get the metadata for the parent.
+    llvm::Value *parentMetadata =
+      emitArchetypeTypeMetadataRef(IGF, accessPath.ParentArchetype);
 
-    CanArchetypeType parent = accessPath.BaseType;
-    AssociatedTypeDecl *association = accessPath.Association;
-    wtable = emitAssociatedTypeWitnessTableRef(IGF, parent, association,
-                                               associatedMetadata,
+    // Get the conformance of the parent to the protocol which declares
+    // the associated conformance.
+    llvm::Value *parentWTable =
+      emitArchetypeWitnessTableRef(IGF, accessPath.ParentArchetype,
+                                   accessPath.ParentProtocol);
+
+    // Get the metadata for the associated type, i.e. this type.
+    auto archetypeMetadata = emitArchetypeTypeMetadataRef(IGF, archetype);
+
+    // Call the accessor.
+    wtable = emitAssociatedTypeWitnessTableRef(IGF, parentMetadata,
+                                               parentWTable,
+                                               accessPath.ParentProtocol,
+                                               accessPath.Path,
+                                               archetypeMetadata,
                                                protocol);
 
     setProtocolWitnessTableName(IGF.IGM, wtable, archetype, protocol);
@@ -361,34 +402,6 @@
   return emitAssociatedTypeMetadataRef(IGF, originMetadata, wtable, associate);
 }
 
-llvm::Value *
-irgen::emitAssociatedTypeWitnessTableRef(IRGenFunction &IGF,
-                                         CanArchetypeType origin,
-                                         AssociatedTypeDecl *associate,
-                                         llvm::Value *associateMetadata,
-                                         ProtocolDecl *associateProtocol) {
-  // We might really be asking for information associated with a more refined
-  // associated type declaration.
-  associate = findConformanceDeclaration(origin->getConformsTo(),
-                                         associate,
-                                         associateProtocol);
-  assert(associate &&
-         "didn't find any associatedtype declaration declaring "
-         "direct conformance to target protocol");
-
-  // Find the conformance of the origin to the associated type's protocol.
-  llvm::Value *wtable = emitArchetypeWitnessTableRef(IGF, origin,
-                                                     associate->getProtocol());
-
-  // Find the origin's type metadata.
-  llvm::Value *originMetadata = emitArchetypeTypeMetadataRef(IGF, origin);
-
-  // FIXME: will this ever be an indirect requirement?
-  return emitAssociatedTypeWitnessTableRef(IGF, originMetadata, wtable,
-                                           associate, associateMetadata,
-                                           associateProtocol);
-}
-
 const TypeInfo *TypeConverter::convertArchetypeType(ArchetypeType *archetype) {
   assert(isExemplarArchetype(archetype) && "lowering non-exemplary archetype");
 
diff --git a/lib/IRGen/GenArchetype.h b/lib/IRGen/GenArchetype.h
index c6e495a..6baa977 100644
--- a/lib/IRGen/GenArchetype.h
+++ b/lib/IRGen/GenArchetype.h
@@ -53,14 +53,6 @@
                                              CanArchetypeType origin,
                                              AssociatedTypeDecl *associate);
 
-  /// Emit a witness table reference for a specific conformance of an
-  /// associated type of an archetype.
-  llvm::Value *emitAssociatedTypeWitnessTableRef(IRGenFunction &IGF,
-                                                 CanArchetypeType origin,
-                                                 AssociatedTypeDecl *associate,
-                                                 llvm::Value *associateMetadata,
-                                               ProtocolDecl *associateProtocol);
-
   /// Emit a dynamic metatype lookup for the given archetype.
   llvm::Value *emitDynamicTypeOfOpaqueArchetype(IRGenFunction &IGF,
                                                 Address archetypeAddr,
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
index ac932a7..46c949d 100644
--- a/lib/IRGen/GenDecl.cpp
+++ b/lib/IRGen/GenDecl.cpp
@@ -3303,16 +3303,15 @@
 llvm::Function *
 IRGenModule::getAddrOfAssociatedTypeWitnessTableAccessFunction(
                                   const NormalProtocolConformance *conformance,
-                                  AssociatedTypeDecl *associate,
-                                  ProtocolDecl *associateProtocol) {
+                                  CanType associatedType,
+                                  ProtocolDecl *associatedProtocol) {
   checkEligibleConf(conformance);
   auto forDefinition = ForDefinition;
 
-  assert(conformance->getProtocol() == associate->getProtocol());
   LinkEntity entity =
     LinkEntity::forAssociatedTypeWitnessTableAccessFunction(conformance,
-                                                            associate,
-                                                            associateProtocol);
+                                                            associatedType,
+                                                            associatedProtocol);
   llvm::Function *&entry = GlobalFuncs[entity];
   if (entry) {
     if (forDefinition) updateLinkageForDefinition(*this, entry, entity);
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
index 1102627..b7a5862 100644
--- a/lib/IRGen/GenProto.cpp
+++ b/lib/IRGen/GenProto.cpp
@@ -639,40 +639,31 @@
 
   /// A class which lays out a witness table in the abstract.
   class WitnessTableLayout : public SILWitnessVisitor<WitnessTableLayout> {
-    unsigned NumWitnesses = 0;
     SmallVector<WitnessTableEntry, 16> Entries;
 
-    WitnessIndex getNextIndex() {
-      return WitnessIndex(NumWitnesses++, /*isPrefix=*/false);
-    }
-
   public:
     /// The next witness is an out-of-line base protocol.
     void addOutOfLineBaseProtocol(ProtocolDecl *baseProto) {
-      Entries.push_back(
-             WitnessTableEntry::forOutOfLineBase(baseProto, getNextIndex()));
+      Entries.push_back(WitnessTableEntry::forOutOfLineBase(baseProto));
     }
 
     void addMethod(FuncDecl *func) {
-      Entries.push_back(WitnessTableEntry::forFunction(func, getNextIndex()));
+      Entries.push_back(WitnessTableEntry::forFunction(func));
     }
 
     void addConstructor(ConstructorDecl *ctor) {
-      Entries.push_back(WitnessTableEntry::forFunction(ctor, getNextIndex()));
+      Entries.push_back(WitnessTableEntry::forFunction(ctor));
     }
 
-    void addAssociatedType(AssociatedTypeDecl *ty,
-                           ArrayRef<ProtocolDecl *> protos) {
-      // An associated type takes up a spot for the type metadata and for the
-      // witnesses to all its conformances.
+    void addAssociatedType(AssociatedTypeDecl *ty) {
+      Entries.push_back(WitnessTableEntry::forAssociatedType(ty));
+    }
+
+    void addAssociatedConformance(CanType path, ProtocolDecl *protocol) {
       Entries.push_back(
-                      WitnessTableEntry::forAssociatedType(ty, getNextIndex()));
-      for (auto *proto : protos)
-        if (Lowering::TypeConverter::protocolRequiresWitnessTable(proto))
-          ++NumWitnesses;
+                   WitnessTableEntry::forAssociatedConformance(path, protocol));
     }
 
-    unsigned getNumWitnesses() const { return NumWitnesses; }
     ArrayRef<WitnessTableEntry> getEntries() const { return Entries; }
   };
 
@@ -769,12 +760,11 @@
         if (!Lowering::TypeConverter::protocolRequiresWitnessTable(base))
           continue;
 
-        auto &baseEntry = protoInfo.getWitnessEntry(base);
-        assert(baseEntry.isBase());
+        auto baseIndex = protoInfo.getBaseIndex(base);
 
         // Compute the length down to this base.
         unsigned lengthToBase = lengthSoFar;
-        if (baseEntry.isOutOfLineBase()) {
+        if (!baseIndex.isPrefix()) {
           lengthToBase++;
 
           // Don't consider this path if we reach a length that can't
@@ -803,8 +793,8 @@
         foundBetter = true;
 
         // Add the link from proto to base if necessary.
-        if (baseEntry.isOutOfLineBase()) {
-          ReversePath.push_back(baseEntry.getOutOfLineBaseIndex());
+        if (!baseIndex.isPrefix()) {
+          ReversePath.push_back(baseIndex);
 
         // If it isn't necessary, then we might be able to
         // short-circuit considering the bases of this protocol.
@@ -1048,8 +1038,8 @@
              && "sil witness table does not match protocol");
       assert(entry.getBaseProtocolWitness().Requirement == baseProto
              && "sil witness table does not match protocol");
-      auto piEntry = PI.getWitnessEntry(baseProto);
-      assert(piEntry.getOutOfLineBaseIndex().getValue() == Table.size()
+      auto piIndex = PI.getBaseIndex(baseProto);
+      assert(piIndex.getValue() == Table.size()
              && "offset doesn't match ProtocolInfo layout");
 #endif
       
@@ -1092,8 +1082,8 @@
              && "sil witness table does not match protocol");
       assert(entry.getMethodWitness().Requirement.getDecl() == requirement
              && "sil witness table does not match protocol");
-      auto piEntry = PI.getWitnessEntry(requirement);
-      assert(piEntry.getFunctionIndex().getValue() == Table.size()
+      auto piIndex = PI.getFunctionIndex(requirement);
+      assert(piIndex.getValue() == Table.size()
              && "offset doesn't match ProtocolInfo layout");
 #endif
 
@@ -1118,16 +1108,15 @@
       return addMethodFromSILWitnessTable(requirement);
     }
 
-    void addAssociatedType(AssociatedTypeDecl *requirement,
-                           ArrayRef<ProtocolDecl *> protos) {
+    void addAssociatedType(AssociatedTypeDecl *requirement) {
 #ifndef NDEBUG
       auto &entry = SILEntries.front();
       assert(entry.getKind() == SILWitnessTable::AssociatedType
              && "sil witness table does not match protocol");
       assert(entry.getAssociatedTypeWitness().Requirement == requirement
              && "sil witness table does not match protocol");
-      auto piEntry = PI.getWitnessEntry(requirement);
-      assert(piEntry.getAssociatedTypeIndex().getValue() == Table.size()
+      auto piIndex = PI.getAssociatedTypeIndex(requirement);
+      assert(piIndex.getValue() == Table.size()
              && "offset doesn't match ProtocolInfo layout");
 #endif
 
@@ -1135,7 +1124,6 @@
 
       const Substitution &sub =
         Conformance.getTypeWitness(requirement, nullptr);
-      assert(protos.size() == sub.getConformances().size());
 
       // This type will be expressed in terms of the archetypes
       // of the conforming context.
@@ -1145,34 +1133,41 @@
       llvm::Constant *metadataAccessFunction =
         getAssociatedTypeMetadataAccessFunction(requirement, associate);
       Table.push_back(metadataAccessFunction);
+    }
 
+    void addAssociatedConformance(Type associatedType, ProtocolDecl *protocol) {
       // FIXME: Add static witness tables for type conformances.
-      for (auto index : indices(protos)) {
-        ProtocolDecl *protocol = protos[index];
-        auto associatedConformance = sub.getConformances()[index];
 
-        if (!Lowering::TypeConverter::protocolRequiresWitnessTable(protocol))
-          continue;
+      CanType associate = Conformance.getAssociatedType(associatedType)
+                                    ->getCanonicalType();
+      assert(!associate->hasTypeParameter());
+
+      ProtocolConformanceRef associatedConformance =
+        Conformance.getAssociatedConformance(associatedType, protocol);
 
 #ifndef NDEBUG
-        auto &entry = SILEntries.front();
-        (void)entry;
-        assert(entry.getKind() == SILWitnessTable::AssociatedTypeProtocol
-               && "sil witness table does not match protocol");
-        auto associatedWitness = entry.getAssociatedTypeProtocolWitness();
-        assert(associatedWitness.Requirement == requirement
-               && "sil witness table does not match protocol");
-        assert(associatedWitness.Protocol == protocol
-               && "sil witness table does not match protocol");
+      auto &entry = SILEntries.front();
+      (void)entry;
+      assert(entry.getKind() == SILWitnessTable::AssociatedTypeProtocol
+             && "sil witness table does not match protocol");
+      auto associatedWitness = entry.getAssociatedTypeProtocolWitness();
+      assert(associatedWitness.Requirement->isEqual(associatedType)
+             && "sil witness table does not match protocol");
+      assert(associatedWitness.Protocol == protocol
+             && "sil witness table does not match protocol");
+      auto piIndex =
+        PI.getAssociatedConformanceIndex(associatedType->getCanonicalType(),
+                                         protocol);
+      assert(piIndex.getValue() == Table.size()
+             && "offset doesn't match ProtocolInfo layout");
 #endif
 
-        SILEntries = SILEntries.slice(1);
+      SILEntries = SILEntries.slice(1);
 
-        llvm::Constant *wtableAccessFunction = 
-          getAssociatedTypeWitnessTableAccessFunction(requirement, associate,
-                                            protocol, associatedConformance);
-        Table.push_back(wtableAccessFunction);
-      }
+      llvm::Constant *wtableAccessFunction = 
+        getAssociatedTypeWitnessTableAccessFunction(CanType(associatedType),
+                                 associate, protocol, associatedConformance);
+      Table.push_back(wtableAccessFunction);
     }
 
   private:
@@ -1183,7 +1178,7 @@
                                             CanType associatedType);
 
     llvm::Constant *
-    getAssociatedTypeWitnessTableAccessFunction(AssociatedTypeDecl *requirement,
+    getAssociatedTypeWitnessTableAccessFunction(CanType depAssociatedType,
                                                 CanType associatedType,
                                                 ProtocolDecl *protocol,
                                         ProtocolConformanceRef conformance);
@@ -1344,8 +1339,19 @@
   }
 }
 
+static void buildAssociatedTypeValueName(CanType depAssociatedType,
+                                         SmallString<128> &name) {
+  if (auto memberType = dyn_cast<DependentMemberType>(depAssociatedType)) {
+    buildAssociatedTypeValueName(memberType.getBase(), name);
+    name += '.';
+    name += memberType->getName().str();
+  } else {
+    assert(isa<GenericTypeParamType>(depAssociatedType)); // Self
+  }
+}
+
 llvm::Constant *WitnessTableBuilder::
-getAssociatedTypeWitnessTableAccessFunction(AssociatedTypeDecl *requirement,
+getAssociatedTypeWitnessTableAccessFunction(CanType depAssociatedType,
                                             CanType associatedType,
                                             ProtocolDecl *associatedProtocol,
                                 ProtocolConformanceRef associatedConformance) {
@@ -1359,7 +1365,7 @@
   // Otherwise, emit an access function.
   llvm::Function *accessor =
     IGM.getAddrOfAssociatedTypeWitnessTableAccessFunction(&Conformance,
-                                                          requirement,
+                                                          depAssociatedType,
                                                           associatedProtocol);
 
   IRGenFunction IGF(IGM, accessor);
@@ -1372,16 +1378,19 @@
 
   // We use a non-standard name for the type that states the association
   // requirement rather than the concrete type.
-  if (IGM.EnableValueNames)
-    associatedTypeMetadata->setName(Twine(ConcreteType->getString())
-                                      + "." + requirement->getNameStr());
+  if (IGM.EnableValueNames) {
+    SmallString<128> name;
+    name += ConcreteType->getString();
+    buildAssociatedTypeValueName(depAssociatedType, name);
+    associatedTypeMetadata->setName(name);
+  }
 
   llvm::Value *self = parameters.claimNext();
   setTypeMetadataName(IGM, self, ConcreteType);
 
   Address destTable(parameters.claimNext(), IGM.getPointerAlignment());
   setProtocolWitnessTableName(IGM, destTable.getAddress(), ConcreteType,
-                              requirement->getProtocol());
+                              Conformance.getProtocol());
 
   const ConformanceInfo *conformanceI = nullptr;
   if (associatedConformance.isConcrete()) {
@@ -1642,8 +1651,7 @@
     layout.visitProtocolDecl(protocol);
 
   // Create a ProtocolInfo object from the layout.
-  ProtocolInfo *info = ProtocolInfo::create(layout.getNumWitnesses(),
-                                            layout.getEntries());
+  ProtocolInfo *info = ProtocolInfo::create(layout.getEntries());
   info->NextConverted = FirstProtocol;
   FirstProtocol = info;
 
@@ -1655,11 +1663,10 @@
 }
 
 /// Allocate a new ProtocolInfo.
-ProtocolInfo *ProtocolInfo::create(unsigned numWitnesses,
-                                   ArrayRef<WitnessTableEntry> table) {
+ProtocolInfo *ProtocolInfo::create(ArrayRef<WitnessTableEntry> table) {
   size_t bufferSize = totalSizeToAlloc<WitnessTableEntry>(table.size());
   void *buffer = ::operator new(bufferSize);
-  return new(buffer) ProtocolInfo(numWitnesses, table);
+  return new(buffer) ProtocolInfo(table);
 }
 
 ProtocolInfo::~ProtocolInfo() {
@@ -2069,13 +2076,13 @@
 
     if (source) {
       auto &pi = IGF.IGM.getProtocolInfo(protocol);
-      auto &entry = pi.getWitnessEntry(inheritedProtocol);
-      assert(entry.isOutOfLineBase());
-      source = emitInvariantLoadOfOpaqueWitness(IGF, source,
-                                                entry.getOutOfLineBaseIndex());
-      source = IGF.Builder.CreateBitCast(source, IGF.IGM.WitnessTablePtrTy);
-      setProtocolWitnessTableName(IGF.IGM, source, sourceKey.Type,
-                                  inheritedProtocol);
+      auto index = pi.getBaseIndex(inheritedProtocol);
+      if (!index.isPrefix()) {
+        source = emitInvariantLoadOfOpaqueWitness(IGF, source, index);
+        source = IGF.Builder.CreateBitCast(source, IGF.IGM.WitnessTablePtrTy);
+        setProtocolWitnessTableName(IGF.IGM, source, sourceKey.Type,
+                                    inheritedProtocol);
+      }
     }
     return source;
   }
@@ -2752,7 +2759,7 @@
 
   // Find the witness we're interested in.
   auto &fnProtoInfo = IGF.IGM.getProtocolInfo(conformance.getRequirement());
-  auto index = fnProtoInfo.getWitnessEntry(fn).getFunctionIndex();
+  auto index = fnProtoInfo.getFunctionIndex(fn);
   llvm::Value *witness = emitInvariantLoadOfOpaqueWitness(IGF, wtable, index);
   
   // Cast the witness pointer to i8*.
@@ -2779,7 +2786,7 @@
                                                   llvm::Value *wtable,
                                           AssociatedTypeDecl *associatedType) {
   auto &pi = IGF.IGM.getProtocolInfo(associatedType->getProtocol());
-  auto index = pi.getWitnessEntry(associatedType).getAssociatedTypeIndex();
+  auto index = pi.getAssociatedTypeIndex(associatedType);
   llvm::Value *witness = emitInvariantLoadOfOpaqueWitness(IGF, wtable, index);
 
   // Cast the witness to the appropriate function type.
@@ -2818,12 +2825,13 @@
 irgen::emitAssociatedTypeWitnessTableRef(IRGenFunction &IGF,
                                          llvm::Value *parentMetadata,
                                          llvm::Value *wtable,
-                                         AssociatedTypeDecl *associatedType,
+                                         ProtocolDecl *parentProtocol,
+                                         CanType associatedType,
                                          llvm::Value *associatedTypeMetadata,
                                          ProtocolDecl *associatedProtocol) {
-  auto &pi = IGF.IGM.getProtocolInfo(associatedType->getProtocol());
-  auto index = pi.getWitnessEntry(associatedType)
-                 .getAssociatedTypeWitnessTableIndex(associatedProtocol);
+  auto &pi = IGF.IGM.getProtocolInfo(parentProtocol);
+  auto index =
+    pi.getAssociatedConformanceIndex(associatedType, associatedProtocol);
   llvm::Value *witness = emitInvariantLoadOfOpaqueWitness(IGF, wtable, index);
 
   // Cast the witness to the appropriate function type.
diff --git a/lib/IRGen/GenProto.h b/lib/IRGen/GenProto.h
index f924346..48b67a6 100644
--- a/lib/IRGen/GenProto.h
+++ b/lib/IRGen/GenProto.h
@@ -71,21 +71,23 @@
                                              llvm::Value *wtable,
                                            AssociatedTypeDecl *associatedType);
 
-  /// Given a type T and an associated type X of a protocol PT to which
+  /// Given a type T and an associated type path X.Y of a protocol PT to which
   /// T conforms, where X is required to implement some protocol PX, return
-  /// the witness table witnessing the conformance of T.X to PX.
+  /// the witness table witnessing the conformance of T.X.Y to PX.
   ///
-  /// PX must be a direct requirement of X.
+  /// PX must be a direct requirement of PT.
   ///
   /// \param parentMetadata - the type metadata for T
   /// \param wtable - the witness table witnessing the conformance of T to PT
-  /// \param associatedType - the declaration of X; a member of PT
-  /// \param associatedTypeMetadata - the type metadata for T.X
+  /// \param parentProtocol - PT
+  /// \param associatedType - the path X.Y, a dependent type within PT
+  /// \param associatedTypeMetadata - the type metadata for T.X.Y
   /// \param associatedProtocol - the declaration of PX
   llvm::Value *emitAssociatedTypeWitnessTableRef(IRGenFunction &IGF,
                                                  llvm::Value *parentMetadata,
                                                  llvm::Value *wtable,
-                                          AssociatedTypeDecl *associatedType,
+                                          ProtocolDecl *parentProtocol,
+                                          CanType associatedType,
                                           llvm::Value *associatedTypeMetadata,
                                           ProtocolDecl *associatedProtocol);
 
diff --git a/lib/IRGen/IRGenMangler.h b/lib/IRGen/IRGenMangler.h
index 33c5245..026d0a0 100644
--- a/lib/IRGen/IRGenMangler.h
+++ b/lib/IRGen/IRGenMangler.h
@@ -120,16 +120,25 @@
 
   std::string mangleAssociatedTypeWitnessTableAccessFunction(
                                       const ProtocolConformance *Conformance,
-                                      StringRef AssocTyName,
+                                      CanType AssociatedType,
                                       const ProtocolDecl *Proto) {
     beginMangling();
     appendProtocolConformance(Conformance);
-    appendIdentifier(AssocTyName);
+    appendAssociatedTypePath(AssociatedType);
     appendNominalType(Proto);
     appendOperator("WT");
     return finalize();
   }
 
+  void appendAssociatedTypePath(CanType associatedType) {
+    if (auto memberType = dyn_cast<DependentMemberType>(associatedType)) {
+      appendAssociatedTypePath(memberType.getBase());
+      appendIdentifier(memberType->getName().str());
+    } else {
+      assert(isa<GenericTypeParamType>(associatedType));
+    }
+  }
+
   std::string mangleReflectionBuiltinDescriptor(Type type) {
     return mangleTypeSymbol(type, "MB");
   }
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
index e5282b1..ede0aae 100644
--- a/lib/IRGen/IRGenModule.h
+++ b/lib/IRGen/IRGenModule.h
@@ -968,7 +968,7 @@
                                            AssociatedTypeDecl *associatedType);
   llvm::Function *getAddrOfAssociatedTypeWitnessTableAccessFunction(
                                            const NormalProtocolConformance *C,
-                                           AssociatedTypeDecl *associatedType,
+                                           CanType depAssociatedType,
                                            ProtocolDecl *requiredProtocol);
 
   Address getAddrOfObjCISAMask();
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
index 97e61fb..73408ac 100644
--- a/lib/IRGen/IRGenSIL.cpp
+++ b/lib/IRGen/IRGenSIL.cpp
@@ -898,6 +898,13 @@
   void visitInitBlockStorageHeaderInst(InitBlockStorageHeaderInst *i);
   
   void visitFixLifetimeInst(FixLifetimeInst *i);
+  void visitEndLifetimeInst(EndLifetimeInst *i) {
+    llvm_unreachable("unimplemented");
+  }
+  void
+  visitUncheckedOwnershipConversionInst(UncheckedOwnershipConversionInst *i) {
+    llvm_unreachable("unimplemented");
+  }
   void visitBeginBorrowInst(BeginBorrowInst *i) {
     llvm_unreachable("unimplemented");
   }
diff --git a/lib/IRGen/Linking.cpp b/lib/IRGen/Linking.cpp
index 0fdcbfc..5ecd6c5 100644
--- a/lib/IRGen/Linking.cpp
+++ b/lib/IRGen/Linking.cpp
@@ -80,6 +80,15 @@
   buffer.write(Result.data(), Result.size());
 }
 
+static void mangleAssociatedTypePath(Mangler &mangler, CanType assocType) {
+  if (auto memberType = dyn_cast<DependentMemberType>(assocType)) {
+    mangleAssociatedTypePath(mangler, memberType.getBase());
+    mangler.mangleIdentifier(memberType->getName().str());
+  } else {
+    assert(isa<GenericTypeParamType>(assocType));
+  }
+}
+
 /// Mangle this entity into the given stream.
 std::string LinkEntity::mangleOld() const {
   // Almost everything below gets the common prefix:
@@ -209,13 +218,15 @@
     mangler.mangleIdentifier(getAssociatedType()->getNameStr());
     return mangler.finalize();
 
-  //   global ::= 'WT' protocol-conformance identifier nominal-type
-  case Kind::AssociatedTypeWitnessTableAccessFunction:
+  //   global ::= 'WT' protocol-conformance identifier+ nominal-type
+  case Kind::AssociatedTypeWitnessTableAccessFunction: {
     mangler.append("_TWT");
     mangler.mangleProtocolConformance(getProtocolConformance());
-    mangler.mangleIdentifier(getAssociatedType()->getNameStr());
-    mangler.mangleProtocolDecl(getAssociatedProtocol());
+    auto assocConf = getAssociatedConformance();
+    mangleAssociatedTypePath(mangler, assocConf.first);
+    mangler.mangleProtocolDecl(assocConf.second);
     return mangler.finalize();
+  }
 
   // For all the following, this rule was imposed above:
   //   global ::= local-marker? entity            // some identifiable thing
@@ -412,11 +423,12 @@
       return mangler.mangleAssociatedTypeMetadataAccessFunction(
                   getProtocolConformance(), getAssociatedType()->getNameStr());
 
-      //   global ::= 'WT' protocol-conformance identifier nominal-type
-    case Kind::AssociatedTypeWitnessTableAccessFunction:
+      //   global ::= protocol-conformance identifier+ nominal-type 'WT'
+    case Kind::AssociatedTypeWitnessTableAccessFunction: {
+      auto assocConf = getAssociatedConformance();
       return mangler.mangleAssociatedTypeWitnessTableAccessFunction(
-                  getProtocolConformance(), getAssociatedType()->getNameStr(),
-                  getAssociatedProtocol());
+                  getProtocolConformance(), assocConf.first, assocConf.second);
+    }
 
       // For all the following, this rule was imposed above:
       //   global ::= local-marker? entity            // some identifiable thing
diff --git a/lib/IRGen/Linking.h b/lib/IRGen/Linking.h
index fce2224..37c30f9 100644
--- a/lib/IRGen/Linking.h
+++ b/lib/IRGen/Linking.h
@@ -83,8 +83,12 @@
     MetadataAddressShift = 8, MetadataAddressMask = 0x0300,
     IsPatternShift = 10, IsPatternMask = 0x0400,
 
-    // This field appears in associated type access function kinds.
+    // This field appears in associated type access functions.
     AssociatedTypeIndexShift = 8, AssociatedTypeIndexMask = ~KindMask,
+
+    // This field appears in associated conformance access functions.
+    AssociatedConformanceIndexShift = 8,
+    AssociatedConformanceIndexMask = ~KindMask,
   };
 #define LINKENTITY_SET_FIELD(field, value) (value << field##Shift)
 #define LINKENTITY_GET_FIELD(value, field) ((value & field##Mask) >> field##Shift)
@@ -160,8 +164,8 @@
 
     /// A function which returns the witness table for a protocol-constrained
     /// associated type of a protocol.  The secondary pointer is a
-    /// ProtocolConformance*.  The primary pointer is a ProtocolDecl*.
-    /// The index of the associated type declaration is stored in the data.
+    /// ProtocolConformance*.  The index of the associated conformance
+    /// requirement is stored in the data.
     AssociatedTypeWitnessTableAccessFunction,
 
     /// A reflection metadata descriptor for the associated type witnesses of a
@@ -264,16 +268,28 @@
 
   void setForProtocolConformanceAndAssociatedType(Kind kind,
                                                   const ProtocolConformance *c,
-                                                  AssociatedTypeDecl *associate,
-                                   ProtocolDecl *associatedProtocol = nullptr) {
+                                                  AssociatedTypeDecl *associate) {
     assert(isProtocolConformanceKind(kind));
-    Pointer = associatedProtocol;
+    Pointer = nullptr;
     SecondaryPointer = const_cast<void*>(static_cast<const void*>(c));
     Data = LINKENTITY_SET_FIELD(Kind, unsigned(kind)) |
            LINKENTITY_SET_FIELD(AssociatedTypeIndex,
                                 getAssociatedTypeIndex(c, associate));
   }
 
+  void setForProtocolConformanceAndAssociatedConformance(Kind kind,
+                                                  const ProtocolConformance *c,
+                                                  CanType associatedType,
+                                            ProtocolDecl *associatedProtocol) {
+    assert(isProtocolConformanceKind(kind));
+    Pointer = associatedProtocol;
+    SecondaryPointer = const_cast<void*>(static_cast<const void*>(c));
+    Data = LINKENTITY_SET_FIELD(Kind, unsigned(kind)) |
+           LINKENTITY_SET_FIELD(AssociatedConformanceIndex,
+                                getAssociatedConformanceIndex(c, associatedType,
+                                                          associatedProtocol));
+  }
+
   // We store associated types using their index in their parent protocol
   // in order to avoid bloating LinkEntity out to three key pointers.
   static unsigned getAssociatedTypeIndex(const ProtocolConformance *conformance,
@@ -299,6 +315,37 @@
     llvm_unreachable("didn't find associated type in protocol?");
   }
 
+  // We store associated conformances using their index in the requirement
+  // list of the requirement signature of the conformance's protocol.
+  static unsigned getAssociatedConformanceIndex(
+                                      const ProtocolConformance *conformance,
+                                                CanType associatedType,
+                                                ProtocolDecl *requirement) {
+    unsigned index = 0;
+    for (auto &reqt : conformance->getProtocol()->getRequirementSignature()
+                                                ->getRequirements()) {
+      if (reqt.getKind() == RequirementKind::Conformance &&
+          reqt.getFirstType()->getCanonicalType() == associatedType &&
+          reqt.getSecondType()->castTo<ProtocolType>()->getDecl() ==
+                                                                requirement) {
+        return index;
+      }
+      ++index;
+    }
+    llvm_unreachable("requirement not found in protocol");
+  }
+
+  static std::pair<CanType, ProtocolDecl*>
+  getAssociatedConformanceByIndex(const ProtocolConformance *conformance,
+                                  unsigned index) {
+    auto &reqt =
+      conformance->getProtocol()->getRequirementSignature()
+                                ->getRequirements()[index];
+    assert(reqt.getKind() == RequirementKind::Conformance);
+    return { reqt.getFirstType()->getCanonicalType(),
+             reqt.getSecondType()->castTo<ProtocolType>()->getDecl() };
+  }
+
   void setForType(Kind kind, CanType type) {
     assert(isTypeKind(kind));
     Pointer = type.getPointer();
@@ -493,12 +540,12 @@
 
   static LinkEntity
   forAssociatedTypeWitnessTableAccessFunction(const ProtocolConformance *C,
-                                              AssociatedTypeDecl *associate,
-                                              ProtocolDecl *associateProtocol) {
+                                              CanType associatedType,
+                                              ProtocolDecl *associatedProtocol){
     LinkEntity entity;
-    entity.setForProtocolConformanceAndAssociatedType(
-                Kind::AssociatedTypeWitnessTableAccessFunction, C, associate,
-                                                      associateProtocol);
+    entity.setForProtocolConformanceAndAssociatedConformance(
+                     Kind::AssociatedTypeWitnessTableAccessFunction, C,
+                     associatedType, associatedProtocol);
     return entity;
   }
 
@@ -576,12 +623,17 @@
   }
 
   AssociatedTypeDecl *getAssociatedType() const {
-    assert(getKind() == Kind::AssociatedTypeMetadataAccessFunction ||
-           getKind() == Kind::AssociatedTypeWitnessTableAccessFunction);
+    assert(getKind() == Kind::AssociatedTypeMetadataAccessFunction);
     return getAssociatedTypeByIndex(getProtocolConformance(),
                               LINKENTITY_GET_FIELD(Data, AssociatedTypeIndex));
   }
 
+  std::pair<CanType, ProtocolDecl *> getAssociatedConformance() const {
+    assert(getKind() == Kind::AssociatedTypeWitnessTableAccessFunction);
+    return getAssociatedConformanceByIndex(getProtocolConformance(),
+                       LINKENTITY_GET_FIELD(Data, AssociatedConformanceIndex));
+  }
+
   ProtocolDecl *getAssociatedProtocol() const {
     assert(getKind() == Kind::AssociatedTypeWitnessTableAccessFunction);
     return reinterpret_cast<ProtocolDecl*>(Pointer);
diff --git a/lib/IRGen/ProtocolInfo.h b/lib/IRGen/ProtocolInfo.h
index d197b1c..ed7af13 100644
--- a/lib/IRGen/ProtocolInfo.h
+++ b/lib/IRGen/ProtocolInfo.h
@@ -52,92 +52,110 @@
 };
 
 /// A witness to a specific element of a protocol.  Every
-/// ProtocolTypeInfo stores one of these for each declaration in the
-/// protocol.
-/// 
-/// The structure of a witness varies by the type of declaration:
-///   - a function requires a single witness, the function;
-///   - a variable requires two witnesses, a getter and a setter;
-///   - a subscript requires two witnesses, a getter and a setter;
-///   - a type requires a pointer to the metadata for that type and
-///     to witness tables for each of the protocols it obeys.
+/// ProtocolTypeInfo stores one of these for each requirement
+/// introduced by the protocol.
 class WitnessTableEntry {
-  Decl *Member;
-  WitnessIndex BeginIndex;
+public:
+  void *MemberOrAssociatedType;
+  ProtocolDecl *Protocol;
 
- WitnessTableEntry(Decl *member, WitnessIndex begin)
-   : Member(member), BeginIndex(begin) {}
+  WitnessTableEntry(void *member, ProtocolDecl *protocol)
+    : MemberOrAssociatedType(member), Protocol(protocol) {}
 
 public:
   WitnessTableEntry() = default;
 
-  Decl *getMember() const {
-    return Member;
-  }
-
-  static WitnessTableEntry forPrefixBase(ProtocolDecl *proto) {
-    return WitnessTableEntry(proto, WitnessIndex(0, /*isPrefix=*/ true));
-  }
-
-  static WitnessTableEntry forOutOfLineBase(ProtocolDecl *proto,
-                                            WitnessIndex index) {
-    return WitnessTableEntry(proto, index);
+  static WitnessTableEntry forOutOfLineBase(ProtocolDecl *proto) {
+    assert(proto != nullptr);
+    return WitnessTableEntry(nullptr, proto);
   }
 
   /// Is this a base-protocol entry?
-  bool isBase() const { return isa<ProtocolDecl>(Member); }
+  bool isBase() const { return MemberOrAssociatedType == nullptr; }
 
-  /// Is the table for this base-protocol entry "out of line",
-  /// i.e. there is a witness which indirectly points to it, or is
-  /// it a prefix of the layout of this protocol?
+  bool matchesBase(ProtocolDecl *proto) const {
+    assert(proto != nullptr);
+    return MemberOrAssociatedType == nullptr && Protocol == proto;
+  }
+
+  /// Given that this is a base-protocol entry, is the table
+  /// "out of line"?
   bool isOutOfLineBase() const {
     assert(isBase());
-    return !BeginIndex.isPrefix();
+    return true;
   }
 
-  /// Return the index at which to find the table for this
-  /// base-protocol entry.
-  WitnessIndex getOutOfLineBaseIndex() const {
-    assert(isOutOfLineBase());
-    return BeginIndex;
+  ProtocolDecl *getBase() const {
+    assert(isBase());
+    return Protocol;
   }
 
-  static WitnessTableEntry forFunction(AbstractFunctionDecl *func,
-                                       WitnessIndex index) {
-    return WitnessTableEntry(func, index);
+  static WitnessTableEntry forFunction(AbstractFunctionDecl *func) {
+    assert(func != nullptr);
+    return WitnessTableEntry(func, nullptr);
   }
   
-  bool isFunction() const { return isa<AbstractFunctionDecl>(Member); }
+  bool isFunction() const {
+    return Protocol == nullptr &&
+           isa<AbstractFunctionDecl>(
+             static_cast<Decl*>(MemberOrAssociatedType));
+  }
 
-  WitnessIndex getFunctionIndex() const {
+  bool matchesFunction(AbstractFunctionDecl *func) const {
+    assert(func != nullptr);
+    return MemberOrAssociatedType == func && Protocol == nullptr;
+  }
+
+  AbstractFunctionDecl *getFunction() const {
     assert(isFunction());
-    return BeginIndex;
-  }
-  
-  static WitnessTableEntry forAssociatedType(AssociatedTypeDecl *ty,
-                                             WitnessIndex index) {
-    return WitnessTableEntry(ty, index);
-  }
-  
-  bool isAssociatedType() const { return isa<AssociatedTypeDecl>(Member); }
-  
-  WitnessIndex getAssociatedTypeIndex() const {
-    assert(isAssociatedType());
-    return BeginIndex;
+    return static_cast<AbstractFunctionDecl*>(MemberOrAssociatedType);
   }
 
-  WitnessIndex
-  getAssociatedTypeWitnessTableIndex(ProtocolDecl *target) const {
-    assert(!BeginIndex.isPrefix());
-    auto index = BeginIndex.getValue() + 1;
-    for (auto protocol :
-           cast<AssociatedTypeDecl>(Member)->getConformingProtocols()) {
-      if (protocol == target) {
-        return WitnessIndex(index, false);
-      }
-      index++;
-    }
-    llvm_unreachable("protocol not in direct conformance list?");
+  static WitnessTableEntry forAssociatedType(AssociatedTypeDecl *ty) {
+    return WitnessTableEntry(ty, nullptr);
+  }
+  
+  bool isAssociatedType() const {
+    return Protocol == nullptr &&
+           isa<AssociatedTypeDecl>(
+             static_cast<Decl*>(MemberOrAssociatedType));
+  }
+
+  bool matchesAssociatedType(AssociatedTypeDecl *assocType) const {
+    assert(assocType != nullptr);
+    return MemberOrAssociatedType == assocType && Protocol == nullptr;
+  }
+
+  AssociatedTypeDecl *getAssociatedType() const {
+    assert(isAssociatedType());
+    return static_cast<AssociatedTypeDecl*>(MemberOrAssociatedType);
+  }
+
+  static WitnessTableEntry forAssociatedConformance(CanType path,
+                                                    ProtocolDecl *requirement) {
+    assert(path && requirement != nullptr);
+    return WitnessTableEntry(path.getPointer(), requirement);
+  }
+
+  bool isAssociatedConformance() const {
+    return Protocol != nullptr && MemberOrAssociatedType != nullptr;
+  }
+
+  bool matchesAssociatedConformance(CanType path,
+                                    ProtocolDecl *requirement) const {
+    assert(path && requirement != nullptr);
+    return MemberOrAssociatedType == path.getPointer() &&
+           Protocol == requirement;
+  }
+
+  CanType getAssociatedConformancePath() const {
+    assert(isAssociatedConformance());
+    return CanType(static_cast<TypeBase *>(MemberOrAssociatedType));
+  }
+
+  ProtocolDecl *getAssociatedConformanceRequirement() const {
+    assert(isAssociatedConformance());
+    return Protocol;
   }
 };
 
@@ -150,9 +168,6 @@
   const ProtocolInfo *NextConverted;
   friend class TypeConverter;
 
-  /// The number of witnesses in the protocol.
-  unsigned NumWitnesses;
-
   /// The number of table entries in this protocol layout.
   unsigned NumTableEntries;
 
@@ -161,14 +176,13 @@
   mutable llvm::SmallDenseMap<const ProtocolConformance*, ConformanceInfo*, 2>
     Conformances;
 
-  ProtocolInfo(unsigned numWitnesses, ArrayRef<WitnessTableEntry> table)
-    : NumWitnesses(numWitnesses), NumTableEntries(table.size()) {
+  ProtocolInfo(ArrayRef<WitnessTableEntry> table)
+      : NumTableEntries(table.size()) {
     std::uninitialized_copy(table.begin(), table.end(),
                             getTrailingObjects<WitnessTableEntry>());
   }
 
-  static ProtocolInfo *create(unsigned numWitnesses,
-                              ArrayRef<WitnessTableEntry> table);
+  static ProtocolInfo *create(ArrayRef<WitnessTableEntry> table);
 
 public:
   const ConformanceInfo &getConformance(IRGenModule &IGM,
@@ -178,20 +192,53 @@
   /// The number of witness slots in a conformance to this protocol;
   /// in other words, the size of the table in words.
   unsigned getNumWitnesses() const {
-    return NumWitnesses;
+    return NumTableEntries;
   }
 
   ArrayRef<WitnessTableEntry> getWitnessEntries() const {
     return {getTrailingObjects<WitnessTableEntry>(), NumTableEntries};
   }
 
-  const WitnessTableEntry &getWitnessEntry(Decl *member) const {
-    // FIXME: do a binary search if the number of witnesses is large
-    // enough.
-    for (auto &witness : getWitnessEntries())
-      if (witness.getMember() == member)
-        return witness;
-    llvm_unreachable("didn't find entry for member!");
+  WitnessIndex getBaseIndex(ProtocolDecl *protocol) const {
+    auto entries = getWitnessEntries();
+    for (auto &witness : entries) {
+      if (witness.matchesBase(protocol)) {
+        if (witness.isOutOfLineBase()) {
+          return WitnessIndex(&witness - entries.begin(), false);
+        } else {
+          return WitnessIndex(0, true);
+        }
+      }
+    }
+    llvm_unreachable("didn't find entry for base");
+  }
+
+  WitnessIndex getFunctionIndex(AbstractFunctionDecl *function) const {
+    auto entries = getWitnessEntries();
+    for (auto &witness : entries) {
+      if (witness.matchesFunction(function))
+        return WitnessIndex(&witness - entries.begin(), false);
+    }
+    llvm_unreachable("didn't find entry for function");
+  }
+
+  WitnessIndex getAssociatedTypeIndex(AssociatedTypeDecl *assocType) const {
+    auto entries = getWitnessEntries();
+    for (auto &witness : entries) {
+      if (witness.matchesAssociatedType(assocType))
+        return WitnessIndex(&witness - entries.begin(), false);
+    }
+    llvm_unreachable("didn't find entry for associated type");
+  }
+
+  WitnessIndex getAssociatedConformanceIndex(CanType path,
+                                             ProtocolDecl *requirement) const {
+    auto entries = getWitnessEntries();
+    for (auto &witness : entries) {
+      if (witness.matchesAssociatedConformance(path, requirement))
+        return WitnessIndex(&witness - entries.begin(), false);
+    }
+    llvm_unreachable("didn't find entry for associated conformance");
   }
 
   ~ProtocolInfo();
diff --git a/lib/Index/Index.cpp b/lib/Index/Index.cpp
index 52bf53c..dc07a83 100644
--- a/lib/Index/Index.cpp
+++ b/lib/Index/Index.cpp
@@ -355,7 +355,7 @@
   bool startEntity(Decl *D, IndexSymbol &Info);
   bool startEntityDecl(ValueDecl *D);
 
-  bool reportRelatedRef(ValueDecl *D, SourceLoc Loc, SymbolRoleSet Relations, Decl *Related);
+  bool reportRelatedRef(ValueDecl *D, SourceLoc Loc, bool isImplicit, SymbolRoleSet Relations, Decl *Related);
   bool reportRelatedTypeRef(const TypeLoc &Ty, SymbolRoleSet Relations, Decl *Related);
   bool reportInheritedTypeRefs(ArrayRef<TypeLoc> Inherited, Decl *Inheritee);
   NominalTypeDecl *getTypeLocAsNominalTypeDecl(const TypeLoc &Ty);
@@ -624,13 +624,16 @@
   return startEntity(D, Info);
 }
 
-bool IndexSwiftASTWalker::reportRelatedRef(ValueDecl *D, SourceLoc Loc, SymbolRoleSet Relations, Decl *Related) {
+bool IndexSwiftASTWalker::reportRelatedRef(ValueDecl *D, SourceLoc Loc, bool isImplicit,
+                                           SymbolRoleSet Relations, Decl *Related) {
   if (!shouldIndex(D))
     return true;
 
   IndexSymbol Info;
   if (addRelation(Info, Relations, Related))
     return true;
+  if (isImplicit)
+    Info.roles |= (unsigned)SymbolRole::Implicit;
 
   // don't report this ref again when visitDeclReference reports it
   repressRefAtLoc(Loc);
@@ -655,9 +658,24 @@
 
   if (IdentTypeRepr *T = dyn_cast_or_null<IdentTypeRepr>(Ty.getTypeRepr())) {
     auto Comps = T->getComponentRange();
-    if (auto NTD =
-            dyn_cast_or_null<NominalTypeDecl>(Comps.back()->getBoundDecl())) {
-      if (!reportRelatedRef(NTD, Comps.back()->getIdLoc(), Relations, Related))
+    SourceLoc IdLoc = Comps.back()->getIdLoc();
+    NominalTypeDecl *NTD = nullptr;
+    bool isImplicit = false;
+    if (auto *VD = Comps.back()->getBoundDecl()) {
+      if (auto *TAD = dyn_cast<TypeAliasDecl>(VD)) {
+        IndexSymbol Info;
+        if (!reportRef(TAD, IdLoc, Info))
+          return false;
+        if (auto Ty = TAD->getUnderlyingTypeLoc().getType()) {
+          NTD = Ty->getAnyNominal();
+          isImplicit = true;
+        }
+      } else {
+        NTD = dyn_cast<NominalTypeDecl>(VD);
+      }
+    }
+    if (NTD) {
+      if (!reportRelatedRef(NTD, IdLoc, isImplicit, Relations, Related))
         return false;
     }
     return true;
@@ -665,7 +683,7 @@
 
   if (Ty.getType()) {
     if (auto nominal = Ty.getType()->getAnyNominal())
-      if (!reportRelatedRef(nominal, Ty.getLoc(), Relations, Related))
+      if (!reportRelatedRef(nominal, Ty.getLoc(), /*isImplicit=*/false, Relations, Related))
         return false;
   }
   return true;
@@ -752,8 +770,8 @@
   if (!startEntity(D, Info))
     return false;
 
-  if (!reportRelatedRef(NTD, Loc, (SymbolRoleSet)SymbolRole::RelationExtendedBy,
-                        D))
+  if (!reportRelatedRef(NTD, Loc, /*isImplicit=*/false,
+                        (SymbolRoleSet)SymbolRole::RelationExtendedBy, D))
       return false;
   if (!reportInheritedTypeRefs(D->getInherited(), D))
       return false;
diff --git a/lib/Parse/ParseIfConfig.cpp b/lib/Parse/ParseIfConfig.cpp
index f6c064d..378b897 100644
--- a/lib/Parse/ParseIfConfig.cpp
+++ b/lib/Parse/ParseIfConfig.cpp
@@ -1,4 +1,4 @@
-//===--- ParseDecl.cpp - Swift Language Parser for #if directives -- ------===//
+//===--- ParseIfConfig.cpp - Swift Language Parser for #if directives -----===//
 //
 // This source file is part of the Swift.org open source project
 //
diff --git a/lib/Parse/ParseSIL.cpp b/lib/Parse/ParseSIL.cpp
index dedf8c8..0ce7d6c 100644
--- a/lib/Parse/ParseSIL.cpp
+++ b/lib/Parse/ParseSIL.cpp
@@ -200,6 +200,25 @@
       return parseSILIdentifier(Result, L, Diagnostic(ID, Args...));
     }
 
+    template <typename T, typename... DiagArgTypes, typename... ArgTypes>
+    bool parseSILIdentifierSwitch(T &Result, ArrayRef<StringRef> Strings,
+                                  Diag<DiagArgTypes...> ID, ArgTypes... Args) {
+      Identifier TmpResult;
+      SourceLoc L;
+      if (parseSILIdentifier(TmpResult, L, Diagnostic(ID, Args...))) {
+        return true;
+      }
+
+      auto Iter = std::find(Strings.begin(), Strings.end(), TmpResult.str());
+      if (Iter == Strings.end()) {
+        P.diagnose(P.Tok, Diagnostic(ID, Args...));
+        return true;
+      }
+
+      Result = ValueOwnershipKind(*Iter);
+      return false;
+    }
+
     template<typename ...DiagArgTypes, typename ...ArgTypes>
     bool parseSILIdentifier(Identifier &Result, SourceLoc &L,
                             Diag<DiagArgTypes...> ID, ArgTypes... Args) {
@@ -226,31 +245,17 @@
       TypeLoc = P.Tok.getLoc();
       return parseASTType(result);
     }
-    bool parseSILOwnership(Optional<ValueOwnershipKind> &OwnershipKind) {
-      // We pare here @ <identifier>.
-      if (P.consumeIf(tok::at_sign) && P.Tok.isNot(tok::identifier)) {
+    bool parseSILOwnership(ValueOwnershipKind &OwnershipKind) {
+      // We parse here @ <identifier>.
+      if (!P.consumeIf(tok::at_sign)) {
         // Add error here.
         return true;
       }
 
-      OwnershipKind =
-          llvm::StringSwitch<Optional<ValueOwnershipKind>>(P.Tok.getText())
-              .Case("trivial",
-                    Optional<ValueOwnershipKind>(ValueOwnershipKind::Trivial))
-              .Case("unowned",
-                    Optional<ValueOwnershipKind>(ValueOwnershipKind::Unowned))
-              .Case("owned",
-                    Optional<ValueOwnershipKind>(ValueOwnershipKind::Owned))
-              .Case("guaranteed", Optional<ValueOwnershipKind>(
-                                      ValueOwnershipKind::Guaranteed))
-              .Default(None);
-
-      if (OwnershipKind.hasValue()) {
-        P.consumeToken();
-        return false;
-      }
-
-      return true;
+      StringRef AllOwnershipKinds[4] = {"trivial", "unowned", "owned",
+                                        "guaranteed"};
+      return parseSILIdentifierSwitch(OwnershipKind, AllOwnershipKinds,
+                                      diag::expected_sil_value_ownership_kind);
     }
     bool parseSILType(SILType &Result,
                       GenericEnvironment *&genericEnv,
@@ -1443,41 +1448,41 @@
 
   auto loc = parses[0].loc;
 
-  // Collect conformance requirements in a convenient form.
-  llvm::DenseMap<TypeBase *, SmallVector<ProtocolDecl *, 2>> conformsTo;
-  for (auto reqt : env->getGenericSignature()->getRequirements()) {
-    if (reqt.getKind() == RequirementKind::Conformance) {
-      auto canTy = reqt.getFirstType()->getCanonicalType();
-      auto nominal = reqt.getSecondType()->getAnyNominal();
-      conformsTo[canTy.getPointer()].push_back(cast<ProtocolDecl>(nominal));
-    }
-  }
-
   // The replacement is for the corresponding dependent type by ordering.
-  for (auto depTy : env->getGenericSignature()->getAllDependentTypes()) {
+  auto result = env->getGenericSignature()->enumeratePairedRequirements(
+    [&](Type depTy, ArrayRef<Requirement> reqts) -> bool {
+      if (parses.empty()) {
+        SP.P.diagnose(loc, diag::sil_missing_substitutions);
+        return true;
+      }
+      auto parsed = parses.front();
+      parses = parses.slice(1);
 
-    auto canTy = depTy->getCanonicalType().getPointer();
+      SmallVector<ProtocolConformanceRef, 2> conformances;
+      SmallVector<ProtocolDecl *, 2> protocols;
+      for (auto reqt : reqts) {
+        protocols.push_back(reqt.getSecondType()
+                            ->castTo<ProtocolType>()->getDecl());
+      }
 
-    if (parses.empty()) {
-      SP.P.diagnose(loc, diag::sil_missing_substitutions);
-      return true;
-    }
-    auto parsed = parses.front();
-    parses = parses.slice(1);
+      if (getConformancesForSubstitution(SP.P, protocols,
+                                         parsed.replacement,
+                                         parsed.loc, conformances))
+        return true;
 
-    SmallVector<ProtocolConformanceRef, 2> conformances;
-    if (getConformancesForSubstitution(SP.P, conformsTo[canTy],
-                                       parsed.replacement,
-                                       parsed.loc, conformances))
-      return true;
+      subs.push_back({parsed.replacement,
+                      SP.P.Context.AllocateCopy(conformances)});
+      return false;
+    });
 
-    subs.push_back({parsed.replacement,
-                    SP.P.Context.AllocateCopy(conformances)});
-  }
+  if (result)
+    return true;
+
   if (!parses.empty()) {
     SP.P.diagnose(loc, diag::sil_too_many_substitutions);
     return true;
   }
+
   return false;
 }
 
@@ -2124,6 +2129,7 @@
   } break;
 
     UNARY_INSTRUCTION(FixLifetime)
+    UNARY_INSTRUCTION(EndLifetime)
     UNARY_INSTRUCTION(CopyBlock)
     UNARY_INSTRUCTION(IsUnique)
     UNARY_INSTRUCTION(IsUniqueOrPinned)
@@ -2164,6 +2170,29 @@
    break;
  }
 
+ // unchecked_ownership_conversion <reg> : <type>, <ownership> to <ownership>
+ case ValueKind::UncheckedOwnershipConversionInst: {
+   ValueOwnershipKind LHSKind = ValueOwnershipKind::Any;
+   ValueOwnershipKind RHSKind = ValueOwnershipKind::Any;
+   SourceLoc Loc;
+
+   if (parseTypedValueRef(Val, Loc, B) ||
+       P.parseToken(tok::comma, diag::expected_sil_colon,
+                    "unchecked_ownership_conversion value ownership kind "
+                    "conversion specification") ||
+       parseSILOwnership(LHSKind) || parseVerbatim("to") ||
+       parseSILOwnership(RHSKind) || parseSILDebugLocation(InstLoc, B)) {
+     return true;
+   }
+
+   if (Val.getOwnershipKind() != LHSKind) {
+     return true;
+   }
+
+   ResultVal = B.createUncheckedOwnershipConversion(InstLoc, Val, RHSKind);
+   break;
+ }
+
  case ValueKind::LoadInst: {
    LoadOwnershipQualifier Qualifier;
    SourceLoc AddrLoc;
@@ -4166,7 +4195,7 @@
     if (P.consumeIf(tok::l_paren)) {
       do {
         SILType Ty;
-        Optional<ValueOwnershipKind> OwnershipKind;
+        ValueOwnershipKind OwnershipKind = ValueOwnershipKind::Any;
         SourceLoc NameLoc;
         StringRef Name = P.Tok.getText();
         if (P.parseToken(tok::sil_local_name, NameLoc,
@@ -4190,9 +4219,7 @@
         if (IsEntry) {
           Arg = BB->createFunctionArgument(Ty);
         } else {
-          Arg = BB->createPHIArgument(
-              Ty, OwnershipKind.getValueOr(
-                      ValueOwnershipKind(ValueOwnershipKind::Any)));
+          Arg = BB->createPHIArgument(Ty, OwnershipKind);
         }
         setLocalValue(Arg, Name, NameLoc);
       } while (P.consumeIf(tok::comma));
@@ -4566,7 +4593,7 @@
 }
 
 static AssociatedTypeDecl *parseAssociatedTypeDecl(Parser &P, SILParser &SP,
-           ProtocolDecl *proto) {
+                                                   ProtocolDecl *proto) {
   Identifier DeclName;
   SourceLoc DeclLoc;
   if (SP.parseSILIdentifier(DeclName, DeclLoc, diag::expected_sil_value_name))
@@ -4584,6 +4611,59 @@
   return dyn_cast<AssociatedTypeDecl>(VD);
 }
 
+static bool parseAssociatedTypePath(SILParser &SP,
+                                    SmallVectorImpl<Identifier> &path) {
+  do {
+    Identifier name;
+    SourceLoc loc;
+    if (SP.parseSILIdentifier(name, loc, diag::expected_sil_value_name))
+      return false;
+    path.push_back(name);
+  } while (SP.P.consumeIf(tok::period));
+
+  return true;
+}
+
+static bool matchesAssociatedTypePath(CanType assocType,
+                                      ArrayRef<Identifier> path) {
+  if (auto memberType = dyn_cast<DependentMemberType>(assocType)) {
+    return (!path.empty() &&
+            memberType->getName() == path.back() &&
+            matchesAssociatedTypePath(memberType.getBase(), path.drop_back()));
+  } else {
+    assert(isa<GenericTypeParamType>(assocType));
+    return path.empty();
+  }
+}
+
+static CanType parseAssociatedTypePath(Parser &P, SILParser &SP,
+                                       ProtocolDecl *proto) {
+  SourceLoc loc = SP.P.Tok.getLoc();
+  SmallVector<Identifier, 4> path;
+  if (!parseAssociatedTypePath(SP, path))
+    return CanType();
+
+  // This is only used for parsing associated conformances, so we can
+  // go ahead and just search the requirement signature for something that
+  // matches the path.
+  for (auto &reqt : proto->getRequirementSignature()->getRequirements()) {
+    if (reqt.getKind() != RequirementKind::Conformance)
+      continue;
+    CanType assocType = reqt.getFirstType()->getCanonicalType();
+    if (matchesAssociatedTypePath(assocType, path))
+      return assocType;
+  }
+
+  SmallString<128> name;
+  name += path[0].str();
+  for (auto elt : makeArrayRef(path).slice(1)) {
+    name += '.';
+    name += elt.str();
+  }
+  P.diagnose(loc, diag::sil_witness_assoc_conf_not_found, name);
+  return CanType();
+}
+
 static NormalProtocolConformance *parseNormalProtocolConformance(Parser &P,
            SILParser &SP, Type ConformingTy, ProtocolDecl *&proto) {
   Identifier ModuleKeyword, ModuleName;
@@ -4827,8 +4907,7 @@
       if (EntryKeyword.str() == "associated_type_protocol") {
         if (parseToken(tok::l_paren, diag::expected_sil_witness_lparen))
           return true;
-        AssociatedTypeDecl *assoc = parseAssociatedTypeDecl(*this,
-                                        WitnessState, proto);
+        CanType assoc = parseAssociatedTypePath(*this, WitnessState, proto);
         if (!assoc)
           return true;
         if (parseToken(tok::colon, diag::expected_sil_witness_colon))
@@ -4851,7 +4930,7 @@
         }
 
         witnessEntries.push_back(SILWitnessTable::AssociatedTypeProtocolWitness{
-          assoc, proto, ProtocolConformanceRef(conformance)
+          assoc, proto, conformance
         });
         continue;
       }
diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
index a00630c..cbdd9b7 100644
--- a/lib/Parse/Parser.cpp
+++ b/lib/Parse/Parser.cpp
@@ -620,7 +620,6 @@
   return false;
 }
 
-
 /// parseAnyIdentifier - Consume an identifier or operator if present and return
 /// its name in Result.  Otherwise, emit an error and return true.
 bool Parser::parseAnyIdentifier(Identifier &Result, SourceLoc &Loc,
diff --git a/lib/SIL/Mangle.cpp b/lib/SIL/Mangle.cpp
index 9e3b8e2..25a1a25 100644
--- a/lib/SIL/Mangle.cpp
+++ b/lib/SIL/Mangle.cpp
@@ -21,6 +21,7 @@
 #include "swift/AST/Mangle.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/Punycode.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILType.h"
@@ -44,33 +45,21 @@
 //                           Generic Specialization
 //===----------------------------------------------------------------------===//
 
-static void mangleSubstitution(Mangler &M, Substitution Sub) {
-  M.mangleType(Sub.getReplacement()->getCanonicalType(), 0);
-  for (auto C : Sub.getConformances()) {
-    if (C.isAbstract())
-      return;
-    M.mangleProtocolConformance(C.getConcrete());
-  }
-}
-
 void GenericSpecializationMangler::mangleSpecialization() {
   Mangler &M = getMangler();
   // This is a full specialization.
   SILFunctionType *FTy = Function->getLoweredFunctionType();
   CanGenericSignature Sig = FTy->getGenericSignature();
-
-  unsigned idx = 0;
-  for (Type DepType : Sig->getAllDependentTypes()) {
-    // It is sufficient to only mangle the substitutions of the "primary"
-    // dependent types. As all other dependent types are just derived from the
-    // primary types, this will give us unique symbol names.
-    if (DepType->is<GenericTypeParamType>()) {
-      mangleSubstitution(M, Subs[idx]);
-      M.append('_');
+  auto SubMap = Sig->getSubstitutionMap(Subs);
+  for (Type DepType : Sig->getSubstitutableParams()) {
+    M.mangleType(DepType.subst(SubMap)->getCanonicalType(), 0);
+    for (auto C : SubMap.getConformances(DepType->getCanonicalType())) {
+      if (C.isAbstract())
+        return;
+      M.mangleProtocolConformance(C.getConcrete());
     }
-    ++idx;
+    M.append('_');
   }
-  assert(idx == Subs.size() && "subs not parallel to dependent types");
 }
 
 void PartialSpecializationMangler::mangleSpecialization() {
diff --git a/lib/SIL/PrettyStackTrace.cpp b/lib/SIL/PrettyStackTrace.cpp
index 633ef3c..e7230ed 100644
--- a/lib/SIL/PrettyStackTrace.cpp
+++ b/lib/SIL/PrettyStackTrace.cpp
@@ -18,6 +18,7 @@
 #include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILModule.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
diff --git a/lib/SIL/SILOwnershipVerifier.cpp b/lib/SIL/SILOwnershipVerifier.cpp
index 70da549..c8e7eea 100644
--- a/lib/SIL/SILOwnershipVerifier.cpp
+++ b/lib/SIL/SILOwnershipVerifier.cpp
@@ -383,6 +383,7 @@
 CONSTANT_OWNERSHIP_INST(Owned, true, UnownedRelease)
 CONSTANT_OWNERSHIP_INST(Owned, true, InitExistentialRef)
 CONSTANT_OWNERSHIP_INST(Owned, true, OpenExistentialOpaque)
+CONSTANT_OWNERSHIP_INST(Owned, true, EndLifetime)
 CONSTANT_OWNERSHIP_INST(Trivial, false, AddressToPointer)
 CONSTANT_OWNERSHIP_INST(Trivial, false, BindMemory)
 CONSTANT_OWNERSHIP_INST(Trivial, false, CheckedCastAddrBranch)
@@ -476,6 +477,7 @@
 ACCEPTS_ANY_OWNERSHIP_INST(UncheckedTrivialBitCast)
 ACCEPTS_ANY_OWNERSHIP_INST(ExistentialMetatype)
 ACCEPTS_ANY_OWNERSHIP_INST(ValueMetatype)
+ACCEPTS_ANY_OWNERSHIP_INST(UncheckedOwnershipConversion)
 #undef ACCEPTS_ANY_OWNERSHIP_INST
 
 // Trivial if trivial typed, otherwise must accept owned?
diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
index 654a13a..0dc077b 100644
--- a/lib/SIL/SILPrinter.cpp
+++ b/lib/SIL/SILPrinter.cpp
@@ -1234,6 +1234,13 @@
     *this << getIDAndType(operand) << " to " << CI->getType();
   }
 
+  void visitUncheckedOwnershipConversionInst(
+      UncheckedOwnershipConversionInst *UOCI) {
+    *this << getIDAndType(UOCI->getOperand()) << ", "
+          << "@" << UOCI->getOperand().getOwnershipKind() << " to "
+          << "@" << UOCI->getConversionOwnershipKind();
+  }
+
   void visitConvertFunctionInst(ConvertFunctionInst *CI) {
     printUncheckedConversionInst(CI, CI->getOperand());
   }
@@ -1549,6 +1556,11 @@
   void visitFixLifetimeInst(FixLifetimeInst *RI) {
     *this << getIDAndType(RI->getOperand());
   }
+
+  void visitEndLifetimeInst(EndLifetimeInst *ELI) {
+    *this << getIDAndType(ELI->getOperand());
+  }
+
   void visitMarkDependenceInst(MarkDependenceInst *MDI) {
     *this << getIDAndType(MDI->getValue()) << " on "
           << getIDAndType(MDI->getBase());
@@ -2246,6 +2258,19 @@
   print(llvm::errs());
 }
 
+/// Returns true if anything was printed.
+static bool printAssociatedTypePath(llvm::raw_ostream &OS, CanType path) {
+  if (auto memberType = dyn_cast<DependentMemberType>(path)) {
+    if (printAssociatedTypePath(OS, memberType.getBase()))
+      OS << '.';
+    OS << memberType->getName().str();
+    return true;
+  } else {
+    assert(isa<GenericTypeParamType>(path));
+    return false;
+  }
+}
+
 void SILWitnessTable::print(llvm::raw_ostream &OS, bool Verbose) const {
   PrintOptions Options = PrintOptions::printSIL();
   PrintOptions QualifiedSILTypeOptions = PrintOptions::printQualifiedSILType();
@@ -2301,9 +2326,9 @@
     case AssociatedTypeProtocol: {
       // associated_type_protocol (AssociatedTypeName: Protocol): <conformance>
       auto &assocProtoWitness = witness.getAssociatedTypeProtocolWitness();
-      OS << "associated_type_protocol ("
-         << assocProtoWitness.Requirement->getName() << ": "
-         << assocProtoWitness.Protocol->getName() << "): ";
+      OS << "associated_type_protocol (";
+      (void) printAssociatedTypePath(OS, assocProtoWitness.Requirement);
+      OS << ": " << assocProtoWitness.Protocol->getName() << "): ";
       if (assocProtoWitness.Witness.isConcrete())
         assocProtoWitness.Witness.getConcrete()->printName(OS, Options);
       else
diff --git a/lib/SIL/SILType.cpp b/lib/SIL/SILType.cpp
index 1a154c7..1cb2a04 100644
--- a/lib/SIL/SILType.cpp
+++ b/lib/SIL/SILType.cpp
@@ -376,7 +376,6 @@
   assert(MetatypeType->is<AnyMetatypeType>() &&
          "This method should only be called on SILTypes with an underlying "
          "metatype type.");
-  assert(isObject() && "Should only be called on object types.");
   Type instanceType =
     MetatypeType->castTo<AnyMetatypeType>()->getInstanceType();
 
diff --git a/lib/SIL/SILValue.cpp b/lib/SIL/SILValue.cpp
index f9bf589..9c069b5 100644
--- a/lib/SIL/SILValue.cpp
+++ b/lib/SIL/SILValue.cpp
@@ -16,6 +16,7 @@
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILVisitor.h"
+#include "llvm/ADT/StringSwitch.h"
 
 using namespace swift;
 
@@ -143,6 +144,19 @@
   return (LHSVal == RHSVal) ? Optional<ValueOwnershipKind>(*this) : None;
 }
 
+ValueOwnershipKind::ValueOwnershipKind(StringRef S) {
+  auto Result = llvm::StringSwitch<Optional<ValueOwnershipKind::innerty>>(S)
+                    .Case("trivial", ValueOwnershipKind::Trivial)
+                    .Case("unowned", ValueOwnershipKind::Unowned)
+                    .Case("owned", ValueOwnershipKind::Owned)
+                    .Case("guaranteed", ValueOwnershipKind::Guaranteed)
+                    .Case("any", ValueOwnershipKind::Any)
+                    .Default(None);
+  if (!Result.hasValue())
+    llvm_unreachable("Invalid string representation of ValueOwnershipKind");
+  Value = Result.getValue();
+}
+
 //===----------------------------------------------------------------------===//
 //                 Instruction ValueOwnershipKind Computation
 //===----------------------------------------------------------------------===//
@@ -333,6 +347,7 @@
 NO_RESULT_OWNERSHIP_INST(DeinitExistentialAddr)
 NO_RESULT_OWNERSHIP_INST(DeinitExistentialOpaque)
 NO_RESULT_OWNERSHIP_INST(CondFail)
+NO_RESULT_OWNERSHIP_INST(EndLifetime)
 
 // Terminators. These do not produce SILValue, so they do not have a
 // ValueOwnershipKind. They do have ownership implications in terms of the
@@ -459,6 +474,12 @@
   return visitForwardingInst(UBCI);
 }
 
+ValueOwnershipKind
+ValueOwnershipKindVisitor::visitUncheckedOwnershipConversionInst(
+    UncheckedOwnershipConversionInst *I) {
+  return I->getConversionOwnershipKind();
+}
+
 // An enum without payload is trivial. One with non-trivial payload is
 // forwarding.
 ValueOwnershipKind
diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
index 541709a..49d7170 100644
--- a/lib/SIL/SILVerifier.cpp
+++ b/lib/SIL/SILVerifier.cpp
@@ -1649,14 +1649,8 @@
   }
 
   // Is a SIL type a potential lowering of a formal type?
-  static bool isLoweringOf(SILType loweredType,
-                           CanType formalType) {
-    
-    
-    // Dynamic self has the same lowering as its contained type.
-    if (auto dynamicSelf = dyn_cast<DynamicSelfType>(formalType))
-      formalType = CanType(dynamicSelf->getSelfType());
-
+  bool isLoweringOf(SILType loweredType,
+                    CanType formalType) {
     // Optional lowers its contained type. The difference between Optional
     // and IUO is lowered away.
     SILType loweredObjectType = loweredType
@@ -1670,9 +1664,10 @@
     }
 
     // Metatypes preserve their instance type through lowering.
-    if (auto loweredMT = loweredType.getAs<MetatypeType>()) {
+    if (loweredType.is<MetatypeType>()) {
       if (auto formalMT = dyn_cast<MetatypeType>(formalType)) {
-        return loweredMT.getInstanceType() == formalMT.getInstanceType();
+        return isLoweringOf(loweredType.getMetatypeInstanceType(F.getModule()),
+                            formalMT.getInstanceType());
       }
     }
     if (auto loweredEMT = loweredType.getAs<ExistentialMetatypeType>()) {
@@ -1701,7 +1696,11 @@
         }
         return true;
       }
-    
+
+    // Dynamic self has the same lowering as its contained type.
+    if (auto dynamicSelf = dyn_cast<DynamicSelfType>(formalType))
+      formalType = dynamicSelf.getSelfType();
+
     // Other types are preserved through lowering.
     return loweredType.getSwiftRValueType() == formalType;
   }
@@ -3011,7 +3010,7 @@
   void checkSwitchValueInst(SwitchValueInst *SVI) {
     // TODO: Type should be either integer or function
     auto Ty = SVI->getOperand()->getType();
-    require(Ty.getAs<BuiltinIntegerType>() || Ty.getAs<SILFunctionType>(),
+    require(Ty.is<BuiltinIntegerType>() || Ty.is<SILFunctionType>(),
             "switch_value operand should be either of an integer "
             "or function type");
 
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
index dbc9b5d..fefc5ec 100644
--- a/lib/SILGen/SILGenApply.cpp
+++ b/lib/SILGen/SILGenApply.cpp
@@ -32,12 +32,10 @@
 using namespace Lowering;
 
 /// Retrieve the type to use for a method found via dynamic lookup.
-static CanAnyFunctionType getDynamicMethodFormalType(SILGenModule &SGM,
-                                                     SILValue proto,
+static CanAnyFunctionType getDynamicMethodFormalType(SILValue proto,
                                                      ValueDecl *member,
-                                                     SILDeclRef methodName,
                                                      Type memberType) {
-  auto &ctx = SGM.getASTContext();
+  auto &ctx = member->getASTContext();
   CanType selfTy;
   if (member->isInstanceMember()) {
     selfTy = ctx.TheUnknownObjectType;
@@ -189,9 +187,6 @@
   SILValue SelfValue;
   SubstitutionList Substitutions;
   CanAnyFunctionType OrigFormalInterfaceType;
-  CanFunctionType SubstFormalType;
-  Optional<SILLocation> SpecializeLoc;
-  bool HasSubstitutions = false;
   Optional<SmallVector<ManagedValue, 2>> Captures;
 
   // The pointer back to the AST node that produced the callee.
@@ -201,28 +196,24 @@
 
   Callee(ManagedValue indirectValue,
          CanAnyFunctionType origFormalType,
-         CanFunctionType substFormalType,
          SILLocation L)
     : kind(Kind::IndirectValue),
       IndirectValue(indirectValue),
       OrigFormalInterfaceType(origFormalType),
-      SubstFormalType(substFormalType),
       Loc(L)
   {}
 
   static CanAnyFunctionType getConstantFormalInterfaceType(SILGenFunction &gen,
-                                                  SILDeclRef fn) {
+                                                           SILDeclRef fn) {
     return gen.SGM.Types.getConstantInfo(fn.atUncurryLevel(0))
              .FormalInterfaceType;
   }
 
   Callee(SILGenFunction &gen, SILDeclRef standaloneFunction,
-         CanFunctionType substFormalType,
          SILLocation l)
     : kind(Kind::StandaloneFunction), Constant(standaloneFunction),
       OrigFormalInterfaceType(getConstantFormalInterfaceType(gen,
                                                            standaloneFunction)),
-      SubstFormalType(substFormalType),
       Loc(l)
   {
   }
@@ -231,170 +222,86 @@
          SILGenFunction &gen,
          SILValue selfValue,
          SILDeclRef methodName,
-         CanFunctionType substFormalType,
          SILLocation l)
     : kind(methodKind), Constant(methodName), SelfValue(selfValue),
       OrigFormalInterfaceType(getConstantFormalInterfaceType(gen, methodName)),
-      SubstFormalType(substFormalType),
       Loc(l)
   {
   }
 
-  /// Build a clause that looks like 'origParamType' but uses 'selfType'
-  /// in place of the underlying archetype.
-  static CanType buildSubstSelfType(CanType origParamType, CanType selfType,
-                                    ASTContext &ctx) {
-    assert(!isa<LValueType>(origParamType) && "Self can't be @lvalue");
-    if (auto lv = dyn_cast<InOutType>(origParamType)) {
-      selfType = buildSubstSelfType(lv.getObjectType(), selfType, ctx);
-      return CanInOutType::get(selfType);
-    }
-
-    if (auto tuple = dyn_cast<TupleType>(origParamType)) {
-      assert(tuple->getNumElements() == 1);
-      selfType = buildSubstSelfType(tuple.getElementType(0), selfType, ctx);
-
-      auto field = tuple->getElement(0).getWithType(selfType);
-      return CanType(TupleType::get(field, ctx));
-    }
-
-    assert(isa<MetatypeType>(origParamType) == isa<MetatypeType>(selfType));
-    assert(origParamType->getRValueInstanceType()->isTypeParameter());
-    assert(selfType->getRValueInstanceType()->is<ArchetypeType>());
-
-    return selfType;
-  }
-
   CanArchetypeType getWitnessMethodSelfType() const {
-    return cast<ArchetypeType>(SubstFormalType.getInput()
+    return cast<ArchetypeType>(getSubstFormalType().getInput()
         ->getRValueInstanceType()
         ->getCanonicalType());
   }
 
   CanSILFunctionType getSubstFunctionType(SILGenModule &SGM,
                                           CanSILFunctionType origFnType) const {
-    if (!HasSubstitutions) return origFnType;
-    
     return origFnType->substGenericArgs(SGM.M, Substitutions);
   }
 
-  /// Add the 'self' clause back to the substituted formal type of
-  /// this protocol method.
-  void addProtocolSelfToFormalType(SILGenModule &SGM, SILDeclRef name,
-                                   CanType protocolSelfType) {
-    // The result types of the expressions yielding protocol values
-    // (reflected in SubstFormalType) reflect an implicit level of
-    // function application, including some extra polymorphic
-    // substitution.
-    HasSubstitutions = true;
-
-    auto &ctx = SGM.getASTContext();
-
-    // Add the 'self' parameter back.  We want it to look like a
-    // substitution of the appropriate clause from the original type.
-    auto selfType = OrigFormalInterfaceType.getInput();
-    auto substSelfType =
-      buildSubstSelfType(selfType, protocolSelfType, ctx);
-
-    auto extInfo = FunctionType::ExtInfo(FunctionType::Representation::Thin,
-                                         /*throws*/ OrigFormalInterfaceType->throws());
-
-    SubstFormalType = CanFunctionType::get(substSelfType, SubstFormalType,
-                                           extInfo);
-  }
-
   /// Add the 'self' type to the substituted function type of this
   /// dynamic callee.
-  void addDynamicCalleeSelfToFormalType(SILGenModule &SGM,
-                                        CanAnyFunctionType substFormalType) {
+  void addDynamicCalleeSelfToFormalType(Type substFormalType) {
     assert(kind == Kind::DynamicMethod);
 
-    // Add the dynamic self type to the substituted type. Even if the dynamic
-    // callee came from a generic ObjC class, when we find it on AnyObject the
-    // parameters should be substituted with their upper bound types.
     OrigFormalInterfaceType
-      = getDynamicMethodFormalType(SGM, SelfValue,
+      = getDynamicMethodFormalType(SelfValue,
                                    Constant.getDecl(),
-                                   Constant, substFormalType);
+                                   substFormalType);
     assert(!OrigFormalInterfaceType->hasTypeParameter());
-
-    // Add a self clause to the substituted type.
-    auto selfType = OrigFormalInterfaceType.getInput();
-    SubstFormalType
-      = CanFunctionType::get(selfType, SubstFormalType,
-                             OrigFormalInterfaceType->getExtInfo());
   }
 
 public:
 
   static Callee forIndirect(ManagedValue indirectValue,
                             CanAnyFunctionType origFormalType,
-                            CanFunctionType substFormalType,
                             SILLocation l) {
-    return Callee(indirectValue,
-                  origFormalType,
-                  substFormalType,
-                  l);
+    return Callee(indirectValue, origFormalType, l);
   }
   static Callee forDirect(SILGenFunction &gen, SILDeclRef c,
-                          CanFunctionType substFormalType,
                           SILLocation l) {
-    return Callee(gen, c, substFormalType, l);
+    return Callee(gen, c, l);
   }
   static Callee forEnumElement(SILGenFunction &gen, SILDeclRef c,
-                               CanFunctionType substFormalType,
                                SILLocation l) {
     assert(isa<EnumElementDecl>(c.getDecl()));
-    return Callee(Kind::EnumElement, gen, SILValue(),
-                  c, substFormalType, l);
+    return Callee(Kind::EnumElement, gen, SILValue(), c, l);
   }
   static Callee forClassMethod(SILGenFunction &gen, SILValue selfValue,
                                SILDeclRef name,
-                               CanFunctionType substFormalType,
                                SILLocation l) {
-    return Callee(Kind::ClassMethod, gen, selfValue, name,
-                  substFormalType, l);
+    return Callee(Kind::ClassMethod, gen, selfValue, name, l);
   }
   static Callee forSuperMethod(SILGenFunction &gen, SILValue selfValue,
                                SILDeclRef name,
-                               CanFunctionType substFormalType,
                                SILLocation l) {
     while (auto *UI = dyn_cast<UpcastInst>(selfValue))
       selfValue = UI->getOperand();
 
-    return Callee(Kind::SuperMethod, gen, selfValue, name,
-                  substFormalType, l);
+    return Callee(Kind::SuperMethod, gen, selfValue, name, l);
   }
   static Callee forArchetype(SILGenFunction &gen,
                              SILValue optOpeningInstruction,
                              CanType protocolSelfType,
                              SILDeclRef name,
-                             CanFunctionType substFormalType,
                              SILLocation l) {
-    Callee callee(Kind::WitnessMethod, gen, optOpeningInstruction, name,
-                  substFormalType, l);
-    callee.addProtocolSelfToFormalType(gen.SGM, name, protocolSelfType);
+    Callee callee(Kind::WitnessMethod, gen, optOpeningInstruction, name, l);
     return callee;
   }
   static Callee forDynamic(SILGenFunction &gen, SILValue proto,
-                           SILDeclRef name, CanFunctionType substFormalType,
+                           SILDeclRef name, Type substFormalType,
                            SILLocation l) {
-    Callee callee(Kind::DynamicMethod, gen, proto, name,
-                  substFormalType, l);
-    callee.addDynamicCalleeSelfToFormalType(gen.SGM, substFormalType);
+    Callee callee(Kind::DynamicMethod, gen, proto, name, l);
+    callee.addDynamicCalleeSelfToFormalType(substFormalType);
     return callee;
   }
   Callee(Callee &&) = default;
   Callee &operator=(Callee &&) = default;
 
-  void setSubstitutions(SILGenFunction &gen,
-                        SILLocation loc,
-                        SubstitutionList newSubs) {
+  void setSubstitutions(SubstitutionList newSubs) {
     assert(Substitutions.empty() && "Already have substitutions?");
     Substitutions = newSubs;
-
-    SpecializeLoc = loc;
-    HasSubstitutions = true;
   }
   
   void setCaptures(SmallVectorImpl<ManagedValue> &&captures) {
@@ -416,7 +323,13 @@
   }
 
   CanFunctionType getSubstFormalType() const {
-    return SubstFormalType;
+    if (auto *gft = OrigFormalInterfaceType->getAs<GenericFunctionType>()) {
+      return cast<FunctionType>(
+        gft->substGenericArgs(getSubstitutions())
+          ->getCanonicalType());
+    }
+
+    return cast<FunctionType>(OrigFormalInterfaceType);
   }
 
   unsigned getNaturalUncurryLevel() const {
@@ -452,7 +365,7 @@
     case Kind::IndirectValue:
       assert(level == 0 && "can't curry indirect function");
       mv = IndirectValue;
-      assert(!HasSubstitutions);
+      assert(Substitutions.empty());
       break;
 
     case Kind::StandaloneFunction: {
@@ -566,8 +479,9 @@
       constant = Constant.atUncurryLevel(level);
       // Lower the substituted type from the AST, which should have any generic
       // parameters in the original signature erased to their upper bounds.
-      auto objcFormalType = SubstFormalType.withExtInfo(
-         SubstFormalType->getExtInfo()
+      auto substFormalType = getSubstFormalType();
+      auto objcFormalType = substFormalType.withExtInfo(
+         substFormalType->getExtInfo()
            .withSILRepresentation(SILFunctionTypeRepresentation::ObjCMethod));
       auto fnType = gen.SGM.M.Types
         .getUncachedSILFunctionTypeForConstant(*constant, objcFormalType);
@@ -655,7 +569,6 @@
   SILGenFunction &gen;
   SILLocation loc;
   ArgumentSource &selfValue;
-  CanFunctionType substFnType;
   SILParameterInfo selfParam;
   AbstractFunctionDecl *fd;
   ProtocolDecl *protocol;
@@ -663,9 +576,8 @@
 
 public:
   ArchetypeCalleeBuilder(SILGenFunction &gen, SILLocation loc,
-                         SILDeclRef inputConstant, ArgumentSource &selfValue,
-                         CanFunctionType substFnType)
-      : gen(gen), loc(loc), selfValue(selfValue), substFnType(substFnType),
+                         SILDeclRef inputConstant, ArgumentSource &selfValue)
+      : gen(gen), loc(loc), selfValue(selfValue),
         selfParam(), fd(cast<AbstractFunctionDecl>(inputConstant.getDecl())),
         protocol(cast<ProtocolDecl>(fd->getDeclContext())),
         constant(inputConstant.asForeign(protocol->isObjC())) {}
@@ -687,11 +599,7 @@
       setSelfValueToAddress(selfLoc, address);
     }
 
-    // The protocol self is implicitly decurried.
-    substFnType = cast<FunctionType>(substFnType.getResult());
-
-    return Callee::forArchetype(gen, openingSite, getSelfType(), constant,
-                                substFnType, loc);
+    return Callee::forArchetype(gen, openingSite, getSelfType(), constant, loc);
   }
 
 private:
@@ -773,10 +681,9 @@
 static Callee prepareArchetypeCallee(SILGenFunction &gen, SILLocation loc,
                                      SILDeclRef constant,
                                      ArgumentSource &selfValue,
-                                     CanFunctionType substFnType,
                                      SubstitutionList &substitutions) {
   // Construct an archetype call.
-  ArchetypeCalleeBuilder Builder{gen, loc, constant, selfValue, substFnType};
+  ArchetypeCalleeBuilder Builder{gen, loc, constant, selfValue};
   return Builder.build();
 }
 
@@ -863,70 +770,18 @@
     visit(e);
   }
 
-  /// Get the type of the function for substitution purposes.
-  ///
-  /// \param otherCtorRefUsesAllocating If true, the OtherConstructorDeclRef
-  /// refers to the initializing
-  CanFunctionType getSubstFnType(bool otherCtorRefUsesAllocating = false) {
-    // TODO: optimize this if there are no specializes in play
-    auto getSiteType = [&](ApplyExpr *site, bool otherCtorRefUsesAllocating) {
-      if (otherCtorRefUsesAllocating) {
-        // We have a reference to an initializing constructor, but we will
-        // actually be using the allocating constructor. Update the type
-        // appropriately.
-        // FIXME: Re-derive the type from the declaration + substitutions?
-        auto ctorRef = cast<OtherConstructorDeclRefExpr>(site->getSemanticFn());
-        auto fnType = ctorRef->getType()->castTo<FunctionType>();
-        auto selfTy = MetatypeType::get(
-                        fnType->getInput()->getInOutObjectType());
-        return CanFunctionType::get(selfTy->getCanonicalType(),
-                                    fnType->getResult()->getCanonicalType(),
-                                    fnType->getExtInfo());
-      }
-
-      return cast<FunctionType>(site->getFn()->getType()->getCanonicalType());
-    };
-
-    CanFunctionType fnType;
-
-    auto addSite = [&](ApplyExpr *site, bool otherCtorRefUsesAllocating) {
-      auto siteType = getSiteType(site, otherCtorRefUsesAllocating);
-
-      // If this is the first call site, use its formal type directly.
-      if (!fnType) {
-        fnType = siteType;
-        return;
-      }
-
-      fnType = CanFunctionType::get(siteType.getInput(), fnType,
-                                    siteType->getExtInfo());
-    };
-
-    for (auto callSite : CallSites) {
-      addSite(callSite, false);
-    }
-
-    // The self application might be a DynamicMemberRefExpr.
-    if (auto selfApply = dyn_cast_or_null<ApplyExpr>(SelfApplyExpr)) {
-      addSite(selfApply, otherCtorRefUsesAllocating);
-    }
-
-    assert(fnType && "found no call sites?");
-    return fnType;
-  }
-
   /// Fall back to an unknown, indirect callee.
   void visitExpr(Expr *e) {
     ManagedValue fn = SGF.emitRValueAsSingleValue(e);
     auto origType = cast<AnyFunctionType>(e->getType()->getCanonicalType());
-    setCallee(Callee::forIndirect(fn, origType, getSubstFnType(), e));
+    setCallee(Callee::forIndirect(fn, origType, e));
   }
 
   void visitLoadExpr(LoadExpr *e) {
     // TODO: preserve the function pointer at its original abstraction level
     ManagedValue fn = SGF.emitRValueAsSingleValue(e);
     auto origType = cast<AnyFunctionType>(e->getType()->getCanonicalType());
-    setCallee(Callee::forIndirect(fn, origType, getSubstFnType(), e));
+    setCallee(Callee::forIndirect(fn, origType, e));
   }
 
   /// Add a call site to the curry.
@@ -1005,7 +860,6 @@
         // to the +0 value in memory.  We just pass in the address since
         // archetypes are address-only.
 
-        auto substFnType = getSubstFnType();
         assert(!CallSites.empty());
         ApplyExpr *thisCallSite = CallSites.back();
         CallSites.pop_back();
@@ -1039,7 +893,7 @@
 
         // Prepare the callee.  This can modify both selfValue and subs.
         Callee theCallee = prepareArchetypeCallee(SGF, e, constant, selfValue,
-                                                  substFnType, subs);
+                                                  subs);
         AssumedPlusZeroSelf = selfValue.isRValue()
           && selfValue.forceAndPeekRValue(SGF).peekIsPlusZeroRValueOrTrivial();
 
@@ -1048,7 +902,7 @@
 
         // If there are substitutions, add them now.
         if (!subs.empty())
-          ApplyCallee->setSubstitutions(SGF, e, subs);
+          ApplyCallee->setSubstitutions(subs);
 
         return;
       }
@@ -1127,13 +981,11 @@
                             SILDeclRef::ConstructAtNaturalUncurryLevel,
                             requiresForeignEntryPoint(afd));
 
-        setCallee(Callee::forClassMethod(SGF, selfValue,
-                                         constant, getSubstFnType(), e));
+        setCallee(Callee::forClassMethod(SGF, selfValue, constant, e));
 
         // If there are substitutions, add them.
         if (e->getDeclRef().isSpecialized()) {
-          ApplyCallee->setSubstitutions(SGF, e,
-                                        e->getDeclRef().getSubstitutions());
+          ApplyCallee->setSubstitutions(e->getDeclRef().getSubstitutions());
         }
 
         return;
@@ -1154,29 +1006,18 @@
                           && requiresForeignEntryPoint(e->getDecl()));
 
     // Otherwise, we have a statically-dispatched call.
-    CanFunctionType substFnType = getSubstFnType();
-
-    auto afd = dyn_cast<AbstractFunctionDecl>(e->getDecl());
-    if (afd) {
-      // If there are captures, put the placeholder curry level in the formal
-      // type.
-      // TODO: Eliminate the need for this.
-      if (SGF.SGM.M.Types.hasLoweredLocalCaptures(afd))
-        substFnType = CanFunctionType::get(
-          SGF.getASTContext().TheEmptyTupleType, substFnType);
-    }
-
     SubstitutionList subs;
     if (e->getDeclRef().isSpecialized())
       subs = e->getDeclRef().getSubstitutions();
 
     // Enum case constructor references are open-coded.
     if (isa<EnumElementDecl>(e->getDecl()))
-      setCallee(Callee::forEnumElement(SGF, constant, substFnType, e));
+      setCallee(Callee::forEnumElement(SGF, constant, e));
     else
-      setCallee(Callee::forDirect(SGF, constant, substFnType, e));
+      setCallee(Callee::forDirect(SGF, constant, e));
     
     // If the decl ref requires captures, emit the capture params.
+    auto afd = dyn_cast<AbstractFunctionDecl>(e->getDecl());
     if (afd) {
       // FIXME: We should be checking hasLocalCaptures() on the lowered
       // captures in the constant info too, to generate more efficient
@@ -1195,7 +1036,7 @@
         (!afd ||
          !afd->getDeclContext()->isLocalContext() ||
          afd->getCaptureInfo().hasGenericParamCaptures()))
-      ApplyCallee->setSubstitutions(SGF, e, subs);
+      ApplyCallee->setSubstitutions(subs);
   }
   
   void visitAbstractClosureExpr(AbstractClosureExpr *e) {
@@ -1217,24 +1058,10 @@
     if (e->getCaptureInfo().hasGenericParamCaptures())
       subs = SGF.getForwardingSubstitutions();
 
-    CanFunctionType substFnType = getSubstFnType();
-    
-    // FIXME: We should be checking hasLocalCaptures() on the lowered
-    // captures in the constant info above, to generate more efficient
-    // code for mutually recursive local functions which otherwise
-    // capture no state.
-
-    // If there are captures, put the placeholder curry level in the formal
-    // type.
-    // TODO: Eliminate the need for this.
-    bool hasCaptures = SGF.SGM.M.Types.hasLoweredLocalCaptures(e);
-    if (hasCaptures)
-      substFnType = CanFunctionType::get(
-                         SGF.getASTContext().TheEmptyTupleType, substFnType);
-
-    setCallee(Callee::forDirect(SGF, constant, substFnType, e));
+    setCallee(Callee::forDirect(SGF, constant, e));
     
     // If the closure requires captures, emit them.
+    bool hasCaptures = SGF.SGM.M.Types.hasLoweredLocalCaptures(e);
     if (hasCaptures) {
       SmallVector<ManagedValue, 4> captures;
       SGF.emitCaptures(e, e, CaptureEmission::ImmediateApplication,
@@ -1243,7 +1070,7 @@
     }
     // If there are substitutions, add them.
     if (!subs.empty())
-      ApplyCallee->setSubstitutions(SGF, e, subs);
+      ApplyCallee->setSubstitutions(subs);
   }
   
   void visitOtherConstructorDeclRefExpr(OtherConstructorDeclRefExpr *e) {
@@ -1251,12 +1078,11 @@
     // constructors imported from Clang (which won't have a direct entry point)
     // or to delegate to a designated initializer.
     setCallee(Callee::forDirect(SGF,
-                SILDeclRef(e->getDecl(), SILDeclRef::Kind::Initializer),
-                                getSubstFnType(), e));
+                SILDeclRef(e->getDecl(), SILDeclRef::Kind::Initializer), e));
 
     // If there are substitutions, add them.
     if (e->getDeclRef().isSpecialized())
-      ApplyCallee->setSubstitutions(SGF, e, e->getDeclRef().getSubstitutions());
+      ApplyCallee->setSubstitutions(e->getDeclRef().getSubstitutions());
   }
   void visitDotSyntaxBaseIgnoredExpr(DotSyntaxBaseIgnoredExpr *e) {
     setSideEffect(e->getLHS());
@@ -1338,16 +1164,15 @@
 
     if (!canUseStaticDispatch(SGF, constant)) {
       // ObjC super calls require dynamic dispatch.
-      setCallee(Callee::forSuperMethod(SGF, super.getValue(), constant,
-                                       getSubstFnType(), fn));
+      setCallee(Callee::forSuperMethod(SGF, super.getValue(), constant, fn));
     } else {
       // Native Swift super calls to final methods are direct.
-      setCallee(Callee::forDirect(SGF, constant, getSubstFnType(), fn));
+      setCallee(Callee::forDirect(SGF, constant, fn));
     }
 
     // If there are any substitutions for the callee, apply them now.
     if (!substitutions.empty())
-      ApplyCallee->setSubstitutions(SGF, fn, substitutions);
+      ApplyCallee->setSubstitutions(substitutions);
   }
 
   /// Walk the given \c selfArg expression that produces the appropriate
@@ -1508,9 +1333,7 @@
                              SILDeclRef::ConstructAtNaturalUncurryLevel,
                              requiresForeignEntryPoint(ctorRef->getDecl()));
       setCallee(Callee::forArchetype(SGF, SILValue(),
-                     self.getType().getSwiftRValueType(), constant,
-                     cast<FunctionType>(expr->getType()->getCanonicalType()),
-                     expr));
+                     self.getType().getSwiftRValueType(), constant, expr));
     } else if (getMethodDispatch(ctorRef->getDecl())
                  == MethodDispatch::Class) {
       // Dynamic dispatch to the initializer.
@@ -1524,7 +1347,7 @@
                              SILDeclRef::ConstructAtBestResilienceExpansion,
                              SILDeclRef::ConstructAtNaturalUncurryLevel,
                              requiresForeignEntryPoint(ctorRef->getDecl())),
-                  getSubstFnType(), fn));
+                  fn));
     } else {
       // Directly call the peer constructor.
       setCallee(
@@ -1537,13 +1360,12 @@
                      SILDeclRef::ConstructAtBestResilienceExpansion,
                      SILDeclRef::ConstructAtNaturalUncurryLevel,
                      requiresForeignEntryPoint(ctorRef->getDecl())),
-            getSubstFnType(useAllocatingCtor), fn));
+            fn));
     }
 
     // Set up the substitutions, if we have any.
     if (ctorRef->getDeclRef().isSpecialized())
-      ApplyCallee->setSubstitutions(SGF, fn,
-                                    ctorRef->getDeclRef().getSubstitutions());
+      ApplyCallee->setSubstitutions(ctorRef->getDeclRef().getSubstitutions());
 
     return true;
   }
@@ -1634,8 +1456,10 @@
                         SILDeclRef::ConstructAtNaturalUncurryLevel,
                         /*isObjC=*/true);
 
+      auto substFormalType = dynamicMemberRef->getType()
+          ->getAnyOptionalObjectType();
       setCallee(Callee::forDynamic(SGF, base.getValue(), member,
-                                   getSubstFnType(), e));
+                                   substFormalType, e));
     };
 
     // When we have an open existential, open it and then emit the
@@ -4712,19 +4536,12 @@
                                             SubstitutionList subs,
                                             ArrayRef<ManagedValue> args,
                                             SGFContext ctx) {
+  auto callee = Callee::forDirect(*this, SILDeclRef(fn), loc);
+  callee.setSubstitutions(subs);
+
   auto origFormalType =
     cast<AnyFunctionType>(fn->getInterfaceType()->getCanonicalType());
-  CanFunctionType substFormalType;
-  if (!subs.empty()) {
-    auto genericFnType = cast<GenericFunctionType>(origFormalType);
-    auto applied = genericFnType->substGenericArgs(subs);
-    substFormalType = cast<FunctionType>(applied->getCanonicalType());
-  } else {
-    substFormalType = cast<FunctionType>(origFormalType);
-  }
-
-  auto callee = Callee::forDirect(*this, SILDeclRef(fn), substFormalType, loc);
-  callee.setSubstitutions(*this, loc, subs);
+  auto substFormalType = callee.getSubstFormalType();
 
   ManagedValue mv;
   CanSILFunctionType substFnType;
@@ -4771,37 +4588,12 @@
                      SILDeclRef::ConstructAtBestResilienceExpansion,
                      SILDeclRef::ConstructAtNaturalUncurryLevel,
                      requiresForeignEntryPoint(ctor));
-  SILConstantInfo initConstant = SGF.getConstantInfo(initRef);
+  auto initConstant = SGF.getConstantInfo(initRef);
+  auto subs = init.getSubstitutions();
 
   // Scope any further writeback just within this operation.
   FormalEvaluationScope writebackScope(SGF);
 
-  // Determine the formal and substituted types.
-  CanFunctionType substFormalType;
-  auto subs = init.getSubstitutions();
-  if (!subs.empty()) {
-    auto genericFnType = cast<GenericFunctionType>(
-        initConstant.FormalInterfaceType);
-    auto applied = genericFnType->substGenericArgs(subs);
-    substFormalType = cast<FunctionType>(applied->getCanonicalType());
-  } else {
-    substFormalType = cast<FunctionType>(initConstant.FormalInterfaceType);
-  }
-
-  // For an inheritable initializer, determine whether we'll need to adjust the
-  // result type.
-  bool requiresDowncast = false;
-  if (ctor->isInheritable() && overriddenSelfType) {
-    CanType substResultType = substFormalType;
-    for (unsigned i : range(ctor->getNumParameterLists())) {
-      (void)i;
-      substResultType = cast<FunctionType>(substResultType).getResult();
-    }
-
-    if (!substResultType->isEqual(overriddenSelfType))
-      requiresDowncast = true;
-  }
-
   // Form the metatype argument.
   ManagedValue selfMetaVal;
   SILType selfMetaTy;
@@ -4841,13 +4633,28 @@
                               RValue(SGF, loc,
                                      selfMetaVal.getType().getSwiftRValueType(),
                                      selfMetaVal));
-    callee.emplace(prepareArchetypeCallee(SGF, loc, initRef, selfSource,
-                                          substFormalType, subs));
+    callee.emplace(prepareArchetypeCallee(SGF, loc, initRef, selfSource, subs));
   } else {
-    callee.emplace(Callee::forDirect(SGF, initRef, substFormalType, loc));
+    callee.emplace(Callee::forDirect(SGF, initRef, loc));
   }
   if (!subs.empty())
-    callee->setSubstitutions(SGF, loc, subs);
+    callee->setSubstitutions(subs);
+
+  auto substFormalType = callee->getSubstFormalType();
+
+  // For an inheritable initializer, determine whether we'll need to adjust the
+  // result type.
+  bool requiresDowncast = false;
+  if (ctor->isInheritable() && overriddenSelfType) {
+    CanType substResultType = substFormalType;
+    for (unsigned i : range(ctor->getNumParameterLists())) {
+      (void)i;
+      substResultType = cast<FunctionType>(substResultType).getResult();
+    }
+
+    if (!substResultType->isEqual(overriddenSelfType))
+      requiresDowncast = true;
+  }
 
   // Form the call emission.
   CallEmission emission(SGF, std::move(*callee), std::move(writebackScope));
@@ -5045,7 +4852,6 @@
                                          ArgumentSource &selfValue,
                                          bool isSuper,
                                          bool isDirectUse,
-                                         CanFunctionType substAccessorType,
                                          SubstitutionList &substitutions){
   auto *decl = cast<AbstractFunctionDecl>(constant.getDecl());
 
@@ -5055,7 +4861,7 @@
     assert(!isSuper && "super call to protocol method?");
 
     return prepareArchetypeCallee(gen, loc, constant, selfValue,
-                                  substAccessorType, substitutions);
+                                  substitutions);
   }
 
   bool isClassDispatch = false;
@@ -5072,20 +4878,20 @@
 
   // Dispatch in a struct/enum or to a final method is always direct.
   if (!isClassDispatch || decl->isFinal())
-    return Callee::forDirect(gen, constant, substAccessorType, loc);
+    return Callee::forDirect(gen, constant, loc);
 
   // Otherwise, if we have a non-final class dispatch to a normal method,
   // perform a dynamic dispatch.
   auto self = selfValue.forceAndPeekRValue(gen).peekScalarValue();
   if (!isSuper)
-    return Callee::forClassMethod(gen, self, constant, substAccessorType, loc);
+    return Callee::forClassMethod(gen, self, constant, loc);
 
   // If this is a "super." dispatch, we do a dynamic dispatch for objc methods
   // or non-final native Swift methods.
   if (!canUseStaticDispatch(gen, constant))
-    return Callee::forSuperMethod(gen, self, constant, substAccessorType, loc);
+    return Callee::forSuperMethod(gen, self, constant, loc);
 
-  return Callee::forDirect(gen, constant, substAccessorType, loc);
+  return Callee::forDirect(gen, constant, loc);
 }
 
 static Callee
@@ -5097,23 +4903,11 @@
                                    bool isSuper,
                                    bool isDirectUse)
 {
-  SILConstantInfo constantInfo = gen.getConstantInfo(constant);
-
-  // Apply substitutions to the callee type.
-  CanFunctionType substAccessorType;
-  if (!substitutions.empty()) {
-    auto genericFn = cast<GenericFunctionType>(constantInfo.FormalInterfaceType);
-    auto substFn = genericFn->substGenericArgs(substitutions);
-    substAccessorType = cast<FunctionType>(substFn->getCanonicalType());
-  } else {
-    substAccessorType = cast<FunctionType>(constantInfo.FormalInterfaceType);
-  }
-
   // Get the accessor function. The type will be a polymorphic function if
   // the Self type is generic.
   Callee callee = getBaseAccessorFunctionRef(gen, loc, constant, selfValue,
                                              isSuper, isDirectUse,
-                                             substAccessorType, substitutions);
+                                             substitutions);
   
   // Collect captures if the accessor has them.
   auto accessorFn = cast<AbstractFunctionDecl>(constant.getDecl());
@@ -5126,10 +4920,8 @@
   }
 
   // If there are substitutions, specialize the generic accessor.
-  // FIXME: Generic subscript operator could add another layer of
-  // substitutions.
   if (!substitutions.empty()) {
-    callee.setSubstitutions(gen, loc, substitutions);
+    callee.setSubstitutions(substitutions);
   }
   return callee;
 }
diff --git a/lib/SILGen/SILGenBuilder.cpp b/lib/SILGen/SILGenBuilder.cpp
index b791ed3..954aafa 100644
--- a/lib/SILGen/SILGenBuilder.cpp
+++ b/lib/SILGen/SILGenBuilder.cpp
@@ -511,3 +511,26 @@
   SILBuilder::createCheckedCastBranch(loc, isExact, operand.forward(gen), type,
                                       trueBlock, falseBlock);
 }
+
+ManagedValue SILGenBuilder::createUpcast(SILLocation Loc, ManagedValue Original,
+                                         SILType Type) {
+  bool hadCleanup = Original.hasCleanup();
+  bool isLValue = Original.isLValue();
+
+  SILValue convertedValue =
+      SILBuilder::createUpcast(Loc, Original.forward(gen), Type);
+
+  if (isLValue) {
+    return ManagedValue::forLValue(convertedValue);
+  }
+
+  if (!hadCleanup) {
+    return ManagedValue::forUnmanaged(convertedValue);
+  }
+
+  if (Type.isAddress()) {
+    return gen.emitManagedBufferWithCleanup(convertedValue);
+  }
+
+  return gen.emitManagedRValueWithCleanup(convertedValue);
+}
diff --git a/lib/SILGen/SILGenBuilder.h b/lib/SILGen/SILGenBuilder.h
index 3e4701c..db837d2 100644
--- a/lib/SILGen/SILGenBuilder.h
+++ b/lib/SILGen/SILGenBuilder.h
@@ -226,6 +226,10 @@
                                ManagedValue operand, SILType type,
                                SILBasicBlock *trueBlock,
                                SILBasicBlock *falseBlock);
+
+  using SILBuilder::createUpcast;
+  ManagedValue createUpcast(SILLocation Loc, ManagedValue Original,
+                            SILType Type);
 };
 
 } // namespace Lowering
diff --git a/lib/SILGen/SILGenConvert.cpp b/lib/SILGen/SILGenConvert.cpp
index c160037..77c8103 100644
--- a/lib/SILGen/SILGenConvert.cpp
+++ b/lib/SILGen/SILGenConvert.cpp
@@ -726,8 +726,7 @@
   
   // Convert to an object reference.
   value = B.createObjCMetatypeToObject(loc, value, resultTy);
-
-  return ManagedValue::forUnmanaged(value);
+  return emitManagedRValueWithCleanup(value);
 }
 
 ManagedValue SILGenFunction::emitExistentialMetatypeToObject(SILLocation loc,
@@ -746,7 +745,7 @@
   // Convert to an object reference.
   value = B.createObjCExistentialMetatypeToObject(loc, value, resultTy);
   
-  return ManagedValue::forUnmanaged(value);
+  return emitManagedRValueWithCleanup(value);
 }
 
 ManagedValue SILGenFunction::emitProtocolMetatypeToObject(SILLocation loc,
@@ -763,7 +762,7 @@
   // deallocate itself. It doesn't matter if we ever actually clean up that
   // retain though.
   value = B.createCopyValue(loc, value);
-  return ManagedValue::forUnmanaged(value);
+  return emitManagedRValueWithCleanup(value);
 }
 
 SILGenFunction::OpaqueValueState
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
index cbe0448..8805540 100644
--- a/lib/SILGen/SILGenDecl.cpp
+++ b/lib/SILGen/SILGenDecl.cpp
@@ -1725,56 +1725,23 @@
                     SILWitnessTable::MethodWitness{requirementRef, witnessFn});
   }
 
-  void addAssociatedType(AssociatedTypeDecl *td,
-                         ArrayRef<ProtocolDecl *> protos) {
+  void addAssociatedType(AssociatedTypeDecl *td) {
     // Find the substitution info for the witness type.
     const auto &witness = Conformance->getTypeWitness(td, /*resolver=*/nullptr);
 
     // Emit the record for the type itself.
     Entries.push_back(SILWitnessTable::AssociatedTypeWitness{td,
-                                witness.getReplacement()->getCanonicalType()});
+                                witness.getReplacement()->getCanonicalType()});    
+  }
 
-    // Emit records for the protocol requirements on the type.
-    assert(protos.size() == witness.getConformances().size()
-           && "number of conformances in assoc type substitution do not match "
-              "number of requirements on assoc type");
-    // The conformances should be all abstract or all concrete.
-    assert(witness.getConformances().empty()
-           || (witness.getConformances()[0].isConcrete()
-                 ? std::all_of(witness.getConformances().begin(),
-                               witness.getConformances().end(),
-                               [&](const ProtocolConformanceRef C) -> bool {
-                                 return C.isConcrete();
-                               })
-                 : std::all_of(witness.getConformances().begin(),
-                               witness.getConformances().end(),
-                               [&](const ProtocolConformanceRef C) -> bool {
-                                 return C.isAbstract();
-                               })));
+  void addAssociatedConformance(CanType dependentType, ProtocolDecl *protocol) {
+    auto assocConformance =
+      Conformance->getAssociatedConformance(dependentType, protocol);
 
-    for (auto *protocol : protos) {
-      // Only reference the witness if the protocol requires it.
-      if (!Lowering::TypeConverter::protocolRequiresWitnessTable(protocol))
-        continue;
+    SGM.useConformance(assocConformance);
 
-      ProtocolConformanceRef conformance(protocol);
-      // If the associated type requirement is satisfied by an associated type,
-      // these will all be abstract conformances.
-      if (witness.getConformances()[0].isConcrete()) {
-        auto foundConformance = std::find_if(witness.getConformances().begin(),
-                                        witness.getConformances().end(),
-                                        [&](ProtocolConformanceRef c) {
-                                          return c.getRequirement() == protocol;
-                                        });
-        assert(foundConformance != witness.getConformances().end());
-        conformance = *foundConformance;
-      }
-      SGM.useConformance(conformance);
-
-      Entries.push_back(SILWitnessTable::AssociatedTypeProtocolWitness{
-        td, protocol, conformance
-      });
-    }
+    Entries.push_back(SILWitnessTable::AssociatedTypeProtocolWitness{
+        dependentType, protocol, assocConformance});
   }
 
   void visitAbstractStorageDecl(AbstractStorageDecl *d) {
@@ -2098,18 +2065,13 @@
     DefaultWitnesses.push_back(entry);
   }
 
-  void addAssociatedType(AssociatedTypeDecl *ty,
-                         ArrayRef<ProtocolDecl *> protos) {
-    // Add a dummy entry for the metatype itself, and then for each conformance.
+  void addAssociatedType(AssociatedTypeDecl *ty) {
+    // Add a dummy entry for the metatype itself.
     addMissingDefault();
+  }
 
-    for (auto *protocol : protos) {
-      // Only reference the witness if the protocol requires it.
-      if (!Lowering::TypeConverter::protocolRequiresWitnessTable(protocol))
-        continue;
-
-      addMissingDefault();
-    }
+  void addAssociatedConformance(CanType type, ProtocolDecl *requirement) {
+    addMissingDefault();
   }
 
   void visitAbstractStorageDecl(AbstractStorageDecl *d) {
diff --git a/lib/SILGen/SILGenDestructor.cpp b/lib/SILGen/SILGenDestructor.cpp
index e6c897e..0d373a1 100644
--- a/lib/SILGen/SILGenDestructor.cpp
+++ b/lib/SILGen/SILGenDestructor.cpp
@@ -12,6 +12,7 @@
 
 #include "SILGenFunction.h"
 #include "RValue.h"
+#include "Scope.h"
 #include "swift/AST/AST.h"
 #include "swift/SIL/TypeLowering.h"
 
@@ -49,6 +50,7 @@
   // If we have a superclass, invoke its destructor.
   SILValue resultSelfValue;
   SILType objectPtrTy = SILType::getNativeObjectType(F.getASTContext());
+  SILType classTy = selfValue->getType();
   if (cd->hasSuperclass()) {
     Type superclassTy = dd->mapTypeIntoContext(cd->getSuperclass());
     ClassDecl *superclass = superclassTy->getClassOrBoundGenericClass();
@@ -66,13 +68,33 @@
     resultSelfValue = B.createApply(cleanupLoc, dtorValue.forward(*this),
                                     dtorTy, objectPtrTy, subs, baseSelf);
   } else {
-    resultSelfValue = B.createUncheckedRefCast(cleanupLoc, selfValue,
-                                                 objectPtrTy);
+    resultSelfValue = selfValue;
   }
 
-  // Release our members.
-  emitClassMemberDestruction(selfValue, cd, cleanupLoc);
+  {
+    Scope S(Cleanups, cleanupLoc);
+    ManagedValue borrowedResultSelfValue =
+        emitManagedBeginBorrow(cleanupLoc, resultSelfValue);
+    SILValue borrowedValue = borrowedResultSelfValue.getUnmanagedValue();
+    if (classTy != borrowedValue->getType()) {
+      borrowedValue =
+          B.createUncheckedRefCast(cleanupLoc, borrowedValue, classTy);
+    }
 
+    // Release our members.
+    emitClassMemberDestruction(borrowedValue, cd, cleanupLoc);
+  }
+
+  if (resultSelfValue->getType() != objectPtrTy) {
+    resultSelfValue =
+        B.createUncheckedRefCast(cleanupLoc, resultSelfValue, objectPtrTy);
+  }
+  if (resultSelfValue.getOwnershipKind() != ValueOwnershipKind::Owned) {
+    assert(resultSelfValue.getOwnershipKind() ==
+           ValueOwnershipKind::Guaranteed);
+    resultSelfValue = B.createUncheckedOwnershipConversion(
+        cleanupLoc, resultSelfValue, ValueOwnershipKind::Owned);
+  }
   B.createReturn(returnLoc, resultSelfValue);
 }
 
@@ -84,25 +106,45 @@
   loc.markAutoGenerated();
 
   // Emit the prolog.
-  SILValue selfValue = emitSelfDecl(dd->getImplicitSelfDecl());
+  SILValue initialSelfValue = emitSelfDecl(dd->getImplicitSelfDecl());
 
   // Form a reference to the destroying destructor.
   SILDeclRef dtorConstant(dd, SILDeclRef::Kind::Destroyer);
-  auto classTy = selfValue->getType();
+  auto classTy = initialSelfValue->getType();
   ManagedValue dtorValue;
   SILType dtorTy;
   SubstitutionList subs = classTy.gatherAllSubstitutions(SGM.M);
   std::tie(dtorValue, dtorTy, subs)
-    = emitSiblingMethodRef(loc, selfValue, dtorConstant, subs);
+    = emitSiblingMethodRef(loc, initialSelfValue, dtorConstant, subs);
 
   // Call the destroying destructor.
-  SILType objectPtrTy = SILType::getNativeObjectType(F.getASTContext());
-  selfValue = B.createApply(loc, dtorValue.forward(*this),
-                            dtorTy, objectPtrTy, subs, selfValue);
+  SILValue selfForDealloc;
+  {
+    FullExpr CleanupScope(Cleanups, CleanupLocation::get(loc));
+    ManagedValue borrowedSelf = emitManagedBeginBorrow(loc, initialSelfValue);
+    SILType objectPtrTy = SILType::getNativeObjectType(F.getASTContext());
+    selfForDealloc = B.createApply(loc, dtorValue.forward(*this),
+                                   dtorTy, objectPtrTy, subs, borrowedSelf.getUnmanagedValue());
+  }
+
+  // Balance out the +1 from the self argument using end_lifetime.
+  //
+  // The issue here is that:
+  //
+  // 1. Self is passed into deallocating deinits at +1.
+  // 2. Destroying deinits take in self as a +0 value that is then returned at
+  // +1.
+  //
+  // This means that the lifetime of self can not be modeled statically in a
+  // deallocating deinit without analyzing the body of the destroying deinit
+  // (something that violates semantic sil). Thus we add an artifical destroy of
+  // self before the actual destroy of self so that the verifier can understand
+  // that self is being properly balanced.
+  B.createEndLifetime(loc, initialSelfValue);
 
   // Deallocate the object.
-  selfValue = B.createUncheckedRefCast(loc, selfValue, classTy);
-  B.createDeallocRef(loc, selfValue, false);
+  selfForDealloc = B.createUncheckedRefCast(loc, selfForDealloc, classTy);
+  B.createDeallocRef(loc, selfForDealloc, false);
 
   // Return.
   B.createReturn(loc, emitEmptyTuple(loc));
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
index 7407c7a..ea697f5 100644
--- a/lib/SILGen/SILGenExpr.cpp
+++ b/lib/SILGen/SILGenExpr.cpp
@@ -3619,15 +3619,18 @@
   
   RValue get(SILGenFunction &gen, SILLocation loc,
              ManagedValue base, SGFContext c) && override {
+    FullExpr TightBorrowScope(gen.Cleanups, CleanupLocation::get(loc));
+
     // Load the value at +0.
-    SILValue owned = gen.B.createLoadBorrow(loc, base.getUnmanagedValue());
+    ManagedValue loadedBase = gen.B.createLoadBorrow(loc, base);
 
     // Convert it to unowned.
-    auto refType = owned->getType().getSwiftRValueType();
+    auto refType = loadedBase.getType().getSwiftRValueType();
     auto unownedType = SILType::getPrimitiveObjectType(
                                         CanUnmanagedStorageType::get(refType));
-    SILValue unowned = gen.B.createRefToUnmanaged(loc, owned, unownedType);
-    
+    SILValue unowned = gen.B.createRefToUnmanaged(
+        loc, loadedBase.getUnmanagedValue(), unownedType);
+
     // A reference type should never be exploded.
     return RValue::withPreExplodedElements(ManagedValue::forUnmanaged(unowned),
                                            refType);
diff --git a/lib/SILGen/SILGenMaterializeForSet.cpp b/lib/SILGen/SILGenMaterializeForSet.cpp
index 53326de..e03e999 100644
--- a/lib/SILGen/SILGenMaterializeForSet.cpp
+++ b/lib/SILGen/SILGenMaterializeForSet.cpp
@@ -456,21 +456,17 @@
 
     // Eagerly loading here could cause an unnecessary
     // load+materialize in some cases, but it's not really important.
-    SILValue selfValue = self.getValue();
-    if (selfValue->getType().isAddress()) {
-      // SEMANTIC ARC TODO: We are returning self as a borrowed value. Is this
-      // correct?
-      selfValue = gen.B.createLoadBorrow(loc, selfValue);
+    if (self.getType().isAddress()) {
+      self = gen.B.createLoadBorrow(loc, self);
     }
 
     // Do a derived-to-base conversion if necessary.
     if (witnessSelfType != SubstSelfType) {
       auto selfSILType = gen.getLoweredType(witnessSelfType);
-      selfValue = gen.B.createUpcast(loc, selfValue, selfSILType);
+      self = gen.B.createUpcast(loc, self, selfSILType);
     }
 
     // Recreate as a borrowed value.
-    self = ManagedValue::forUnmanaged(selfValue);
     return LValue::forValue(self, witnessSelfType);
   }
 
diff --git a/lib/SILGen/SILGenPattern.cpp b/lib/SILGen/SILGenPattern.cpp
index c53f642..7da97fb 100644
--- a/lib/SILGen/SILGenPattern.cpp
+++ b/lib/SILGen/SILGenPattern.cpp
@@ -1792,8 +1792,11 @@
       if (elt->isIndirect() || elt->getParentEnum()->isIndirect()) {
         SILValue boxedValue = SGF.B.createProjectBox(loc, origCMV.getValue(), 0);
         eltTL = &SGF.getTypeLowering(boxedValue->getType());
-        if (eltTL->isLoadable())
-          boxedValue = SGF.B.createLoadBorrow(loc, boxedValue);
+        if (eltTL->isLoadable()) {
+          ManagedValue newLoadedBoxValue = SGF.B.createLoadBorrow(
+              loc, ManagedValue::forUnmanaged(boxedValue));
+          boxedValue = newLoadedBoxValue.getUnmanagedValue();
+        }
 
         // The boxed value may be shared, so we always have to copy it.
         eltCMV = getManagedSubobject(SGF, boxedValue, *eltTL,
diff --git a/lib/SILOptimizer/IPO/CapturePropagation.cpp b/lib/SILOptimizer/IPO/CapturePropagation.cpp
index b5c39b8..0a857f9 100644
--- a/lib/SILOptimizer/IPO/CapturePropagation.cpp
+++ b/lib/SILOptimizer/IPO/CapturePropagation.cpp
@@ -248,7 +248,7 @@
                                  SILFunctionType::Representation::Thin);
   SILFunction *NewF = OrigF->getModule().createFunction(
       SILLinkage::Shared, Name, NewFTy,
-      /*contextGenericParams*/ nullptr, OrigF->getLocation(), OrigF->isBare(),
+      OrigF->getGenericEnvironment(), OrigF->getLocation(), OrigF->isBare(),
       OrigF->isTransparent(), Fragile, OrigF->isThunk(),
       OrigF->getClassVisibility(), OrigF->getInlineStrategy(),
       OrigF->getEffectsKind(),
diff --git a/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp b/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp
index 3edb44d..bbba5d6 100644
--- a/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp
+++ b/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp
@@ -22,6 +22,7 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 using namespace swift;
 
diff --git a/lib/SILOptimizer/IPO/EagerSpecializer.cpp b/lib/SILOptimizer/IPO/EagerSpecializer.cpp
index c84965c..40fce0f 100644
--- a/lib/SILOptimizer/IPO/EagerSpecializer.cpp
+++ b/lib/SILOptimizer/IPO/EagerSpecializer.cpp
@@ -337,41 +337,30 @@
   // SubstitutableTypes, skipping DependentTypes.
   auto GenericSig =
     GenericFunc->getLoweredFunctionType()->getGenericSignature();
-  auto SubIt = ReInfo.getClonerParamSubstitutions().begin();
-  auto SubEnd = ReInfo.getClonerParamSubstitutions().end();
-  auto DepTypes = GenericSig->getAllDependentTypes();
-  for (auto DepTy : DepTypes) {
-    assert(SubIt != SubEnd && "Not enough substitutions.");
-    if (auto ParamTy = DepTy->getAs<SubstitutableType>()) {
-      auto Replacement = SubIt->getReplacement();
-      auto GenericEnv = ReInfo.getSpecializedGenericEnvironment();
-      if (!Replacement->hasArchetype()) {
-        if (GenericEnv)
-          Replacement = GenericEnv->mapTypeIntoContext(Replacement);
-        assert(!Replacement->hasTypeParameter());
-        // Dispatch on concrete type.
-        emitTypeCheck(FailedTypeCheckBB, ParamTy, Replacement);
-      } else {
-        // If Replacement has a layout constraint, then dispatch based
-        // on its size and the fact that it is trivial.
-        auto LayoutInfo = Replacement->getLayoutConstraint();
-        if (LayoutInfo && LayoutInfo->isTrivial()) {
-          // Emit a check that it is a trivial type of a certain size.
-          emitTrivialAndSizeCheck(FailedTypeCheckBB, ParamTy,
-                                  GenericEnv->mapTypeIntoContext(Replacement),
-                                  LayoutInfo);
-        } else if (LayoutInfo && LayoutInfo->isRefCountedObject()) {
-          // Emit a check that it is an object of a reference counted type.
-          emitRefCountedObjectCheck(FailedTypeCheckBB, ParamTy,
-                                    GenericEnv->mapTypeIntoContext(Replacement),
-                                    LayoutInfo);
-        }
+  auto SubMap = GenericSig->getSubstitutionMap(
+    ReInfo.getClonerParamSubstitutions());
+  for (auto ParamTy : GenericSig->getSubstitutableParams()) {
+    auto Replacement = Type(ParamTy).subst(SubMap);
+    assert(!Replacement->hasTypeParameter());
+
+    if (!Replacement->hasArchetype()) {
+      // Dispatch on concrete type.
+      emitTypeCheck(FailedTypeCheckBB, ParamTy, Replacement);
+    } else {
+      // If Replacement has a layout constraint, then dispatch based
+      // on its size and the fact that it is trivial.
+      auto LayoutInfo = Replacement->getLayoutConstraint();
+      if (LayoutInfo && LayoutInfo->isTrivial()) {
+        // Emit a check that it is a trivial type of a certain size.
+        emitTrivialAndSizeCheck(FailedTypeCheckBB, ParamTy,
+                                Replacement, LayoutInfo);
+      } else if (LayoutInfo && LayoutInfo->isRefCountedObject()) {
+        // Emit a check that it is an object of a reference counted type.
+        emitRefCountedObjectCheck(FailedTypeCheckBB, ParamTy,
+                                  Replacement, LayoutInfo);
       }
     }
-    ++SubIt;
   }
-  assert(SubIt == SubEnd && "Too many substitutions.");
-  (void) SubEnd;
   static_cast<void>(FailedTypeCheckBB);
 
   if (OldReturnBB == &EntryBB) {
@@ -709,13 +698,9 @@
   DEBUG(auto FT = GenericFunc->getLoweredFunctionType();
         dbgs() << "  Generic Sig:";
         dbgs().indent(2); FT->getGenericSignature()->print(dbgs());
-        dbgs() << "\n  Substituting: <";
-        auto depTypes = FT->getGenericSignature()->getAllDependentTypes();
-        interleave(depTypes.begin(), depTypes.end(),
-                   [&](Type t){
-                     GenericFunc->mapTypeIntoContext(t).print(dbgs()); },
-                   []{ dbgs() << ", "; });
-        dbgs() << "> with ";
+        dbgs() << "  Generic Env:";
+        dbgs().indent(2); GenericFunc->getGenericEnvironment()->dump(dbgs());
+        dbgs() << "  Specialize Attr:";
         SA.print(dbgs()); dbgs() << "\n");
 
   GenericFuncSpecializer
diff --git a/lib/SILOptimizer/IPO/GlobalOpt.cpp b/lib/SILOptimizer/IPO/GlobalOpt.cpp
index 21ce0d6..413bc8c 100644
--- a/lib/SILOptimizer/IPO/GlobalOpt.cpp
+++ b/lib/SILOptimizer/IPO/GlobalOpt.cpp
@@ -240,7 +240,8 @@
   auto LoweredType = SILFunctionType::get(nullptr, EInfo,
       ParameterConvention::Direct_Owned, { }, Results, None,
       Store->getModule().getASTContext());
-  auto *GetterF = Store->getModule().getOrCreateFunction(Store->getLoc(),
+  auto *GetterF = Store->getModule().getOrCreateFunction(
+      Store->getLoc(),
       getterName, SILLinkage::Private, LoweredType,
       IsBare_t::IsBare, IsTransparent_t::IsNotTransparent,
       IsFragile_t::IsFragile);
@@ -493,8 +494,9 @@
   auto LoweredType = SILFunctionType::get(nullptr, EInfo,
       ParameterConvention::Direct_Owned, { }, Results, None,
       InitF->getASTContext());
-  auto *GetterF = InitF->getModule().getOrCreateFunction(InitF->getLocation(),
-     getterName, SILLinkage::Private, LoweredType,
+  auto *GetterF = InitF->getModule().getOrCreateFunction(
+      InitF->getLocation(),
+      getterName, SILLinkage::Private, LoweredType,
       IsBare_t::IsBare, IsTransparent_t::IsNotTransparent,
       IsFragile_t::IsFragile);
   if (InitF->hasUnqualifiedOwnership())
diff --git a/lib/SILOptimizer/Mandatory/AddressLowering.cpp b/lib/SILOptimizer/Mandatory/AddressLowering.cpp
index 4731fe0..fe648ff 100644
--- a/lib/SILOptimizer/Mandatory/AddressLowering.cpp
+++ b/lib/SILOptimizer/Mandatory/AddressLowering.cpp
@@ -92,20 +92,6 @@
 
     return valueVector.back().second;
   }
-
-  // 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");
-    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
 
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
index 3d8f05c..54b99d4 100644
--- a/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
+++ b/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
@@ -692,39 +692,26 @@
   // replaced by a concrete type.
   SmallVector<Substitution, 8> Substitutions;
   for (auto Subst : AI.getSubstitutions()) {
-    auto *A = Subst.getReplacement()->getAs<ArchetypeType>();
-    if (A && A == OpenedArchetype) {
-      auto Conformances = AI.getModule().getASTContext()
-                            .AllocateUninitialized<ProtocolConformanceRef>(1);
-      Conformances[0] = Conformance;
-      Substitution NewSubst(ConcreteType, Conformances);
-      Substitutions.push_back(NewSubst);
-    } else
-      Substitutions.push_back(Subst);
+    auto NewSubst = Subst.subst(
+      AI.getModule().getSwiftModule(),
+      [&](SubstitutableType *type) -> Type {
+        if (type == OpenedArchetype)
+          return ConcreteType;
+        return type;
+      },
+      [&](Type origTy, Type substTy, ProtocolType *protoType)
+        -> Optional<ProtocolConformanceRef> {
+        assert(origTy->isEqual(OpenedArchetype));
+        return Conformance;
+      });
+    Substitutions.push_back(NewSubst);
   }
 
-  SILType SubstCalleeType = AI.getSubstCalleeSILType();
-
-  SILType NewSubstCalleeType;
-
   auto FnTy = AI.getCallee()->getType().castTo<SILFunctionType>();
-  if (FnTy->isPolymorphic()) {
-    // Handle polymorphic functions by properly substituting
-    // their parameter types.
-    CanSILFunctionType SFT = FnTy->substGenericArgs(
-                                        AI.getModule(),
-                                        Substitutions);
-    NewSubstCalleeType = SILType::getPrimitiveObjectType(SFT);
-  } else {
-    NewSubstCalleeType =
-      SubstCalleeType.subst(AI.getModule(),
-                            [&](SubstitutableType *type) -> Type {
-                              if (type == OpenedArchetype)
-                                return ConcreteType;
-                              return type;
-                            },
-                            MakeAbstractConformanceForGenericType());
-  }
+  assert(FnTy->isPolymorphic());
+
+  auto SFT = FnTy->substGenericArgs(AI.getModule(), Substitutions);
+  auto NewSubstCalleeType = SILType::getPrimitiveObjectType(SFT);
 
   FullApplySite NewAI;
   Builder.setCurrentDebugScope(AI.getDebugScope());
@@ -732,14 +719,14 @@
 
   if (auto *TAI = dyn_cast<TryApplyInst>(AI))
     NewAI = Builder.createTryApply(AI.getLoc(), AI.getCallee(),
-                                    NewSubstCalleeType,
-                                    Substitutions, Args,
-                                    TAI->getNormalBB(), TAI->getErrorBB());
+                                   NewSubstCalleeType,
+                                   Substitutions, Args,
+                                   TAI->getNormalBB(), TAI->getErrorBB());
   else
     NewAI = Builder.createApply(AI.getLoc(), AI.getCallee(),
-                                 NewSubstCalleeType,
-                                 AI.getType(), Substitutions, Args,
-                                 cast<ApplyInst>(AI)->isNonThrowing());
+                                NewSubstCalleeType,
+                                AI.getType(), Substitutions, Args,
+                                cast<ApplyInst>(AI)->isNonThrowing());
 
   if (isa<ApplyInst>(NewAI))
     replaceInstUsesWith(*AI.getInstruction(), NewAI.getInstruction());
@@ -886,21 +873,6 @@
   if (WMI->getConformance().isConcrete())
     return nullptr;
 
-  // Don't specialize Apply instructions that return the Self type.
-  // Notice that it is sufficient to compare the return type to the
-  // substituted type because types that depend on the Self type are
-  // not allowed (for example [Self] is not allowed).
-  if (AI.getType().getSwiftRValueType() == WMI->getLookupType())
-    return nullptr;
-
-  // We need to handle the Self return type.
-  // 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().getSwiftRValueType() == WMI->getLookupType())
-      return nullptr;
-  }
-
   // The lookup type is not an opened existential type,
   // thus it cannot be made more concrete.
   if (!WMI->getLookupType()->isOpenedExistential())
@@ -916,10 +888,10 @@
     // Keep around the dependence on the open instruction unless we've
     // actually eliminated the use.
     auto *NewWMI = Builder.createWitnessMethod(WMI->getLoc(),
-                                                ConcreteType,
-                                                Conformance, WMI->getMember(),
-                                                WMI->getType(),
-                                                WMI->isVolatile());
+                                               ConcreteType,
+                                               Conformance, WMI->getMember(),
+                                               WMI->getType(),
+                                               WMI->isVolatile());
     // Replace only uses of the witness_method in the apply that is going to
     // be changed.
     MutableArrayRef<Operand> Operands = AI.getInstruction()->getAllOperands();
@@ -957,15 +929,6 @@
   if (!Self)
     return nullptr;
 
-  // We need to handle the Self return type.
-  // 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().getSwiftRValueType() ==
-        AI.getArguments().back()->getType().getSwiftRValueType())
-      return nullptr;
-  }
-
   // Obtain the protocol whose which should be used by the conformance.
   auto *AFD = dyn_cast<AbstractFunctionDecl>(Callee->getDeclContext());
   if (!AFD)
diff --git a/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp b/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp
index ce6a1d1..73d41fb 100644
--- a/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp
+++ b/lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp
@@ -488,10 +488,11 @@
   DEBUG(llvm::dbgs() << "  -> create specialized function " << Name << "\n");
 
   NewF = M.createFunction(linkage, Name, createOptimizedSILFunctionType(),
-                          nullptr, F->getLocation(), F->isBare(),
-                          F->isTransparent(), F->isFragile(), F->isThunk(),
-                          F->getClassVisibility(), F->getInlineStrategy(),
-                          F->getEffectsKind(), nullptr, F->getDebugScope());
+                          F->getGenericEnvironment(), F->getLocation(),
+                          F->isBare(), F->isTransparent(), F->isFragile(),
+                          F->isThunk(), F->getClassVisibility(),
+                          F->getInlineStrategy(), F->getEffectsKind(), nullptr,
+                          F->getDebugScope());
   if (F->hasUnqualifiedOwnership()) {
     NewF->setUnqualifiedOwnership();
   }
diff --git a/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp b/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp
index 0ec3d33..db045e7 100644
--- a/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp
+++ b/lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp
@@ -64,6 +64,16 @@
     EBI->eraseFromParent();
     return true;
   }
+  bool visitEndLifetimeInst(EndLifetimeInst *ELI) {
+    ELI->eraseFromParent();
+    return true;
+  }
+  bool visitUncheckedOwnershipConversionInst(
+      UncheckedOwnershipConversionInst *UOCI) {
+    UOCI->replaceAllUsesWith(UOCI->getOperand());
+    UOCI->eraseFromParent();
+    return true;
+  }
   bool visitUnmanagedRetainValueInst(UnmanagedRetainValueInst *URVI);
   bool visitUnmanagedReleaseValueInst(UnmanagedReleaseValueInst *URVI);
   bool visitUnmanagedAutoreleaseValueInst(UnmanagedAutoreleaseValueInst *UAVI);
diff --git a/lib/SILOptimizer/Transforms/PerformanceInliner.cpp b/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
index fb14a28..6966f78 100644
--- a/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
+++ b/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
@@ -316,8 +316,7 @@
 // specialization for a given call.
 static bool canSpecializeGeneric(ApplySite AI, SILFunction *F,
                                  SubstitutionList Subs) {
-  ReabstractionInfo ReInfo(AI, F, Subs);
-  return ReInfo.canBeSpecialized();
+  return ReabstractionInfo::canBeSpecialized(AI, F, Subs);
 }
 
 bool SILPerformanceInliner::isProfitableToInline(FullApplySite AI,
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
index 2adfd48..13e8a6f 100644
--- a/lib/SILOptimizer/Utils/Generics.cpp
+++ b/lib/SILOptimizer/Utils/Generics.cpp
@@ -22,6 +22,18 @@
 
 using namespace swift;
 
+/// Set to true to enable the support for partial specialization.
+llvm::cl::opt<bool> EnablePartialSpecialization(
+    "sil-partial-specialization", llvm::cl::init(false),
+    llvm::cl::desc("Enable partial specialization of generics"));
+
+/// If set, then generic specialization tries to specialize using
+/// all substitutions, even if they the replacement types are generic.
+llvm::cl::opt<bool> SpecializeGenericSubstitutions(
+    "sil-partial-specialization-with-generic-substitutions",
+    llvm::cl::init(false),
+    llvm::cl::desc("Enable partial specialization with generic substitutions"));
+
 // Max depth of a bound generic which can be processed by the generic
 // specializer.
 // E.g. the depth of Array<Array<Array<T>>> is 3.
@@ -49,40 +61,54 @@
 // ReabstractionInfo
 // =============================================================================
 
-// Initialize SpecializedType iff the specialization is allowed.
-ReabstractionInfo::ReabstractionInfo(ApplySite Apply, SILFunction *OrigF,
-                                     SubstitutionList ParamSubs) {
-  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;
+static bool shouldNotSpecializeCallee(SILFunction *Callee) {
+  if (!Callee->shouldOptimize()) {
+    DEBUG(llvm::dbgs() << "    Cannot specialize function " << Callee->getName()
+          << " marked to be excluded from optimizations.\n");
+    return true;
   }
 
-  OriginalF = OrigF;
-  OriginalParamSubs = ParamSubs;
-  ClonerParamSubs = ParamSubs;
-  CallerParamSubs = ParamSubs;
-  SpecializedGenericSig = nullptr;
+  if (Callee->hasSemanticsAttr("optimize.sil.specialize.generic.never"))
+    return true;
+
+  return false;
+}
+
+/// Prepares the ReabstractionInfo object for further processing and checks
+/// if the current function can be specialized at all.
+/// Returns false, if the current function cannot be specialized.
+/// Returns true otherwise.
+bool ReabstractionInfo::prepareAndCheck(ApplySite Apply, SILFunction *Callee,
+                                        SubstitutionList ParamSubs) {
+  if (shouldNotSpecializeCallee(Callee))
+    return false;
+
   SpecializedGenericEnv = nullptr;
+  SpecializedGenericSig = nullptr;
+  OriginalParamSubs = ParamSubs;
+  auto CalleeGenericSig = Callee->getLoweredFunctionType()->getGenericSignature();
+  auto CalleeGenericEnv = Callee->getGenericEnvironment();
+
+  OriginalF = Callee;
+  this->Apply = Apply;
 
   SubstitutionMap InterfaceSubs;
-  if (OrigF->getLoweredFunctionType()->getGenericSignature())
-    InterfaceSubs = OrigF->getLoweredFunctionType()->getGenericSignature()
-      ->getSubstitutionMap(ParamSubs);
+
+  // Get the original substitution map.
+  if (CalleeGenericSig)
+    InterfaceSubs = CalleeGenericSig->getSubstitutionMap(ParamSubs);
 
   // We do not support partial specialization.
-  if (InterfaceSubs.hasArchetypes()) {
-    DEBUG(llvm::dbgs() <<
-          "    Cannot specialize with unbound interface substitutions.\n");
-    DEBUG(for (auto Sub : ParamSubs) {
-            Sub.dump();
-          });
-    return;
+  if (!EnablePartialSpecialization && InterfaceSubs.hasArchetypes()) {
+    DEBUG(llvm::dbgs() << "    Partial specialization is not supported.\n");
+    DEBUG(for (auto Sub : ParamSubs) { Sub.dump(); });
+    return false;
   }
+
+  // Perform some checks to see if we need to bail.
   if (InterfaceSubs.hasDynamicSelf()) {
     DEBUG(llvm::dbgs() << "    Cannot specialize with dynamic self.\n");
-    return;
+    return false;
   }
 
   // Check if the substitution contains any generic types that are too deep.
@@ -93,46 +119,175 @@
     if (Replacement.findIf([](Type ty) -> bool {
           return getBoundGenericDepth(ty) >= BoundGenericDepthThreshold;
         })) {
-      return;
+      DEBUG(llvm::dbgs()
+            << "    Cannot specialize because the generic type is too deep.\n");
+      return false;
     }
   }
 
-  SILModule &M = OrigF->getModule();
-  SubstitutedType = OrigF->getLoweredFunctionType()->substGenericArgs(
-    M, InterfaceSubs);
+  // Check if we have substitutions which replace generic type parameters with
+  // concrete types or unbound generic types.
+  bool HasConcreteGenericParams = false;
+  bool HasNonArchetypeGenericParams = false;
+  HasUnboundGenericParams = false;
+  for (auto DT : CalleeGenericSig->getGenericParams()) {
+    // Check only the substitutions for the generic parameters.
+    // Ignore any dependent types, etc.
+    auto Replacement = Type(DT).subst(InterfaceSubs);
+    if (!Replacement->is<ArchetypeType>())
+      HasNonArchetypeGenericParams = true;
 
-  NumFormalIndirectResults = SubstitutedType->getNumIndirectFormalResults();
-  Conversions.resize(NumFormalIndirectResults
-                     + SubstitutedType->getParameters().size());
-  if (SubstitutedType->getNumDirectFormalResults() == 0) {
-    // The original function has no direct result yet. Try to convert the first
-    // indirect result to a direct result.
-    // TODO: We could also convert multiple indirect results by returning a
-    // tuple type and created tuple_extract instructions at the call site.
-    SILFunctionConventions substConv(SubstitutedType, M);
-    unsigned IdxForResult = 0;
-    for (SILResultInfo RI : SubstitutedType->getIndirectFormalResults()) {
-      assert(RI.isFormalIndirect());
-      if (substConv.getSILType(RI).isLoadable(M) && !RI.getType()->isVoid()) {
-        Conversions.set(IdxForResult);
-        break;
+    if (Replacement->hasArchetype()) {
+      HasUnboundGenericParams = true;
+      // Check if the replacement is an archetype which is more specific
+      // than the corresponding archetype in the original generic signature.
+      // If this is the case, then specialization makes sense, because
+      // it would produce something more specific.
+      if (CalleeGenericEnv) {
+        if (auto Archetype = Replacement->getAs<ArchetypeType>()) {
+          auto OrigArchetype =
+              CalleeGenericEnv->mapTypeIntoContext(DT)->castTo<ArchetypeType>();
+          if (Archetype->requiresClass() && !OrigArchetype->requiresClass())
+            HasNonArchetypeGenericParams = true;
+          if (Archetype->getLayoutConstraint() &&
+              !OrigArchetype->getLayoutConstraint())
+            HasNonArchetypeGenericParams = true;
+        }
       }
-      ++IdxForResult;
+      continue;
+    }
+
+    HasConcreteGenericParams = true;
+  }
+
+  if (HasUnboundGenericParams) {
+    if (!HasNonArchetypeGenericParams && !HasConcreteGenericParams) {
+      DEBUG(llvm::dbgs() << "    Partial specialization is not supported if "
+                            "all substitutions are archetypes.\n");
+      DEBUG(for (auto Sub : ParamSubs) {
+          Sub.dump();
+        });
+      return false;
+    }
+
+    // We need a generic environment for the partial specialization.
+    if (!CalleeGenericEnv)
+      return false;
+  }
+
+  return true;
+}
+
+bool ReabstractionInfo::canBeSpecialized(ApplySite Apply, SILFunction *Callee,
+                                         SubstitutionList ParamSubs) {
+  ReabstractionInfo ReInfo;
+  return ReInfo.prepareAndCheck(Apply, Callee, ParamSubs);
+}
+
+ReabstractionInfo::ReabstractionInfo(ApplySite Apply, SILFunction *Callee,
+                                     ArrayRef<Substitution> ParamSubs) {
+  if (!prepareAndCheck(Apply, Callee, ParamSubs))
+    return;
+
+  if (SpecializeGenericSubstitutions) {
+    specializeConcreteAndGenericSubstitutions(Apply, Callee, ParamSubs);
+  } else {
+    specializeConcreteSubstitutions(Apply, Callee, ParamSubs);
+  }
+
+  if (SpecializedGenericSig) {
+    DEBUG(llvm::dbgs() << "\n\nPartially specialized types for function: "
+                       << Callee->getName() << "\n\n";
+          llvm::dbgs() << "Original generic function type:\n"
+                       << Callee->getLoweredFunctionType() << "\n"
+                       << "Partially specialized generic function type:\n"
+                       << SpecializedType << "\n\n");
+  }
+
+  // Some sanity checks.
+  auto SpecializedFnTy = getSpecializedType();
+  auto SpecializedSubstFnTy = SpecializedFnTy;
+
+  if (SpecializedFnTy->isPolymorphic() &&
+      !getCallerParamSubstitutions().empty()) {
+    auto CalleeFnTy = Callee->getLoweredFunctionType();
+    assert(CalleeFnTy->isPolymorphic());
+    auto CalleeSubstFnTy = CalleeFnTy->substGenericArgs(
+        Callee->getModule(), getOriginalParamSubstitutions());
+    assert(!CalleeSubstFnTy->isPolymorphic() &&
+           "Substituted callee type should not be polymorphic");
+    assert(!CalleeSubstFnTy->hasTypeParameter() &&
+           "Substituted callee type should not have type parameters");
+
+    SpecializedSubstFnTy = SpecializedFnTy->substGenericArgs(
+        Callee->getModule(), getCallerParamSubstitutions());
+
+    assert(!SpecializedSubstFnTy->isPolymorphic() &&
+           "Substituted callee type should not be polymorphic");
+    assert(!SpecializedSubstFnTy->hasTypeParameter() &&
+           "Substituted callee type should not have type parameters");
+
+    auto SpecializedCalleeSubstFnTy =
+        createSpecializedType(CalleeSubstFnTy, Callee->getModule());
+
+    if (SpecializedSubstFnTy != SpecializedCalleeSubstFnTy) {
+      llvm::dbgs() << "SpecializedFnTy:\n" << SpecializedFnTy << "\n";
+      llvm::dbgs() << "SpecializedSubstFnTy:\n" << SpecializedSubstFnTy << "\n";
+      for (auto Sub : getCallerParamSubstitutions()) {
+        llvm::dbgs() << "Sub:\n";
+        Sub.dump();
+      }
+      llvm::dbgs() << "\n\n";
+
+      llvm::dbgs() << "CalleeFnTy:\n" << CalleeFnTy << "\n";
+      llvm::dbgs() << "SpecializedCalleeSubstFnTy:\n" << SpecializedCalleeSubstFnTy << "\n";
+      for (auto Sub : ParamSubs) {
+        llvm::dbgs() << "Sub:\n";
+        Sub.dump();
+      }
+      llvm::dbgs() << "\n\n";
+      assert(SpecializedSubstFnTy == SpecializedCalleeSubstFnTy &&
+             "Substituted function types should be the same");
     }
   }
-  // Try to convert indirect incoming parameters to direct parameters.
-  // The Conversions index domain is
-  // [0..<NumFormalIndirectResults + NumParameters]. This is *not* the same as
-  // a SubstitutedType's SIL argument index.
-  unsigned IdxForParam = NumFormalIndirectResults;
-  for (SILParameterInfo PI : SubstitutedType->getParameters()) {
-    if (PI.getSILStorageType().isLoadable(M)
-        && PI.getConvention() == ParameterConvention::Indirect_In) {
-      Conversions.set(IdxForParam);
-    }
-    ++IdxForParam;
+
+  // If the new type is the same, there is nothing to do and
+  // no specialization should be performed.
+  if (getSubstitutedType() == Callee->getLoweredFunctionType()) {
+    DEBUG(llvm::dbgs() << "The new specialized type is the same as "
+                          "the original "
+                          "type. Don't specialize!\n";
+          llvm::dbgs() << "The type is: " << getSubstitutedType() << "\n");
+    SpecializedType = CanSILFunctionType();
+    SubstitutedType = CanSILFunctionType();
+    SpecializedGenericSig = nullptr;
+    return;
   }
-  SpecializedType = createSpecializedType(SubstitutedType, M);
+
+  if (SpecializedGenericSig) {
+    // It is a partial specializaiton.
+    DEBUG(llvm::dbgs() << "Specializing the call:\n";
+          Apply.getInstruction()->dumpInContext();
+          llvm::dbgs() << "\n\nPartially specialized types for function: "
+                       << Callee->getName() << "\n\n";
+          llvm::dbgs() << "Original generic function type:\n"
+                       << Callee->getLoweredFunctionType() << "\n\n";
+          llvm::dbgs() << "\nOriginal call substitution:\n";
+          for (auto Sub : getOriginalParamSubstitutions()) {
+            llvm::dbgs() << "Sub:\n";
+            Sub.dump();
+            llvm::dbgs() << "\n";
+          }
+
+          llvm::dbgs() << "Partially specialized generic function type:\n"
+                       << getSpecializedType() << "\n\n";
+          llvm::dbgs() << "\nSpecialization call substitution:\n";
+          for (auto Sub : getCallerParamSubstitutions()) {
+            llvm::dbgs() << "Sub:\n";
+            Sub.dump();
+            llvm::dbgs() << "\n";
+          });
+  }
 }
 
 bool ReabstractionInfo::canBeSpecialized() const {
@@ -210,11 +365,6 @@
                                          const SubstitutionMap &SubstMap,
                                          bool HasUnboundGenericParams) {
   auto &M = OrigF->getModule();
-  auto OrigFnTy = OrigF->getLoweredFunctionType();
-
-  // First substitute concrete types into the existing function type.
-  auto FnTy = OrigFnTy->substGenericArgs(M, SubstMap);
-
   if ((SpecializedGenericSig &&
        SpecializedGenericSig->areAllParamsConcrete()) ||
       !HasUnboundGenericParams) {
@@ -222,11 +372,24 @@
     SpecializedGenericEnv = nullptr;
   }
 
+  CanGenericSignature CanSpecializedGenericSig;
+  if (SpecializedGenericSig)
+    CanSpecializedGenericSig = SpecializedGenericSig->getCanonicalSignature();
+
+  // First substitute concrete types into the existing function type.
+  CanSILFunctionType FnTy;
+  {
+    Lowering::GenericContextScope GenericScope(M.Types,
+                                               CanSpecializedGenericSig);
+    FnTy = OrigF->getLoweredFunctionType()->substGenericArgs(M, SubstMap);
+  }
+  assert(FnTy);
+
   // Use the new specialized generic signature.
   auto NewFnTy = SILFunctionType::get(
-      SpecializedGenericSig, FnTy->getExtInfo(), FnTy->getCalleeConvention(),
-      FnTy->getParameters(), FnTy->getResults(),
-      FnTy->getOptionalErrorResult(), M.getASTContext());
+      CanSpecializedGenericSig, FnTy->getExtInfo(), FnTy->getCalleeConvention(),
+      FnTy->getParameters(), FnTy->getResults(), FnTy->getOptionalErrorResult(),
+      M.getASTContext());
 
   // This is an interface type. It should not have any archetypes.
   assert(!NewFnTy->hasArchetype());
@@ -280,6 +443,25 @@
                          M.getASTContext());
 }
 
+static std::pair<GenericEnvironment *, GenericSignature *>
+getGenericEnvironmentAndSignature(GenericSignatureBuilder &Builder,
+                                  SILModule &M) {
+  auto *GenericSig =
+      Builder.getGenericSignature()->getCanonicalSignature().getPointer();
+  auto *GenericEnv = GenericSig->createGenericEnvironment(*M.getSwiftModule());
+
+  // FIXME: This is a workaround for the signature minimization bug.
+  GenericSignatureBuilder TmpBuilder(
+      M.getASTContext(), LookUpConformanceInModule(M.getSwiftModule()));
+  TmpBuilder.addGenericSignature(GenericSig);
+  TmpBuilder.finalize(SourceLoc(), GenericSig->getGenericParams());
+  GenericSig =
+      TmpBuilder.getGenericSignature()->getCanonicalSignature().getPointer();
+  GenericEnv = GenericSig->createGenericEnvironment(*M.getSwiftModule());
+
+  return std::make_pair(GenericEnv, GenericSig);
+}
+
 std::pair<GenericEnvironment *, GenericSignature *>
 getSignatureWithRequirements(GenericSignature *OrigGenSig,
                              GenericEnvironment *OrigGenericEnv,
@@ -301,11 +483,7 @@
   }
 
   Builder.finalize(SourceLoc(), OrigGenSig->getGenericParams());
-  auto *GenericSig = Builder.getGenericSignature();
-  // Remember the new generic environment.
-  auto *GenericEnv = GenericSig->createGenericEnvironment(*M.getSwiftModule());
-
-  return std::make_pair(GenericEnv, GenericSig);
+  return getGenericEnvironmentAndSignature(Builder, M);
 }
 
 /// Perform some sanity checks for the requirements
@@ -340,11 +518,8 @@
 
 ReabstractionInfo::ReabstractionInfo(SILFunction *OrigF,
                                      ArrayRef<Requirement> Requirements) {
-  if (!OrigF->shouldOptimize()) {
-    DEBUG(llvm::dbgs() << "    Cannot specialize function " << OrigF->getName()
-                       << " marked to be excluded from optimizations.\n");
+  if (shouldNotSpecializeCallee(OrigF))
     return;
-  }
 
   // Perform some sanity checks for the requirements
   checkSpecializationRequirements(Requirements);
@@ -399,6 +574,138 @@
   createSubstitutedAndSpecializedTypes();
 }
 
+static void verifySubstitutionList(SubstitutionList Subs) {
+  for (auto Sub : Subs) {
+    assert(!Sub.getReplacement()->hasError() &&
+           "There should be no error types in substitutions");
+  }
+}
+
+// Builds a new signature based on the old one and adds same type
+// requirements for those generic type parameters that are concrete
+// according to the partial substitution. This way, the signature
+// has exactly the same generic parameter types, just with more
+// requirements.
+// Current issues:
+// - If Sig2 = GenericSignatureBuilder(Sig2 + Req), then GenericSignatureBuilder(Sig2) != Sig2
+// - The set of requirements is not really minimized.
+// - Some requirements are lost, when you add a same type parameter to the builder.
+
+// Initialize SpecializedType if and only if the specialization is allowed.
+void ReabstractionInfo::specializeConcreteSubstitutions(
+    ApplySite Apply, SILFunction *Callee, ArrayRef<Substitution> ParamSubs) {
+
+  SILModule &M = Callee->getModule();
+  auto &Ctx = M.getASTContext();
+
+  OriginalF = Callee;
+
+  auto OrigGenericSig = Callee->getLoweredFunctionType()->getGenericSignature();
+  auto OrigGenericEnv = Callee->getGenericEnvironment();
+
+  SubstitutionMap InterfaceSubs;
+  // Get the original substitution map.
+  if (Callee->getLoweredFunctionType()->getGenericSignature())
+    InterfaceSubs = Callee->getLoweredFunctionType()->getGenericSignature()
+      ->getSubstitutionMap(ParamSubs);
+
+  // This is a workaround for the rdar://30610428
+  if (!EnablePartialSpecialization) {
+    SubstitutedType =
+        Callee->getLoweredFunctionType()->substGenericArgs(M, InterfaceSubs);
+    ClonerParamSubs = OriginalParamSubs;
+    CallerParamSubs = {};
+    createSubstitutedAndSpecializedTypes();
+    return;
+  }
+
+  // Build a set of requirements.
+  SmallVector<Requirement, 4> Requirements;
+
+  for (auto DP : OrigGenericSig->getGenericParams()) {
+    auto Replacement = Type(DP).subst(InterfaceSubs);
+    if (Replacement->hasArchetype())
+      continue;
+    // Replacemengt is concrete. Add a same type requirement.
+    Requirement Req(RequirementKind::SameType, DP, Replacement);
+    Requirements.push_back(Req);
+  }
+
+  std::tie(SpecializedGenericEnv, SpecializedGenericSig) =
+      getSignatureWithRequirements(OrigGenericSig, OrigGenericEnv,
+                                   Requirements, M);
+  HasUnboundGenericParams = !SpecializedGenericSig->areAllParamsConcrete();
+
+  // No partial specializations!
+  //if (HasUnboundGenericParams)
+  //  return;
+
+  {
+    SmallVector<Substitution, 4> List;
+
+    OrigGenericSig->getSubstitutions(
+      [&](SubstitutableType *type) -> Type {
+        return SpecializedGenericEnv->mapTypeIntoContext(type);
+      },
+      LookUpConformanceInSignature(*SpecializedGenericSig),
+      List);
+    ClonerParamSubs = Ctx.AllocateCopy(List);
+    verifySubstitutionList(ClonerParamSubs);
+  }
+
+  {
+    SmallVector<Substitution, 4> List;
+    SpecializedGenericSig->getSubstitutions(InterfaceSubs, List);
+    CallerParamSubs = Ctx.AllocateCopy(List);
+    verifySubstitutionList(CallerParamSubs);
+  }
+
+  {
+    CallerInterfaceSubs = OrigGenericSig->getSubstitutionMap(
+      [&](SubstitutableType *type) -> Type {
+        return SpecializedGenericEnv->mapTypeOutOfContext(
+          SpecializedGenericEnv->mapTypeIntoContext(type));
+      },
+        //LookUpConformanceInSignature(*SpecializedGenericSig));
+      LookUpConformanceInSignature(*OrigGenericSig));
+  }
+
+  HasUnboundGenericParams = !SpecializedGenericSig->areAllParamsConcrete();
+  createSubstitutedAndSpecializedTypes();
+}
+
+// Builds a new generic and function signatures for a partial specialization.
+// Allows for partial specializations even if substitututions contain
+// type parameters.
+//
+// The new generic signature has the following generic parameters:
+// - For each substitution with a concrete type CT as a replacement for a generic
+// type T, it introduces a generic parameter T' and a requirement T' == CT
+// - For all other substitutions that are considered for partial specialization,
+// it collects first the archetypes used in the replacements. Then for each such
+// archetype A a new generic parameter T' introduced.
+// - If there is a substitution for type T and this substitution is execluded from
+// partial specialization (e.g. because it is impossible or would result in a less
+// efficient code), then a new generic parameter T' is introduced, which does not
+// get any additional, more specific requirements based on the substitutions.
+//
+// After all generic parameters are added accoriding to the rules above,
+// the requirements of the callee's signature are re-mapped by re-formulating them
+// in terms of the newly introduced generic parameters. In case a remapped
+// requirement does not contain any generic types, it can be omitted, because
+// it is fulfilled already.
+
+// Current issues:
+// - If Sig2 = GenericSignatureBuilder(Sig2 + Req), then
+// GenericSignatureBuilder(Sig2) != Sig2
+// - The set of requirements is not really minimized.
+// - Some requirements are lost, when you add a same type parameter to the
+// builder.
+void ReabstractionInfo::specializeConcreteAndGenericSubstitutions(
+    ApplySite Apply, SILFunction *Callee, ArrayRef<Substitution> ParamSubs) {
+  llvm_unreachable("Not implemented yet");
+}
+
 // =============================================================================
 // GenericFuncSpecializer
 // =============================================================================
@@ -505,16 +812,13 @@
   VoidVal->replaceAllUsesWith(NewVoidVal);
 }
 
-// Create a new apply based on an old one, but with a different
-// function being applied.
-static ApplySite replaceWithSpecializedCallee(ApplySite AI,
-                                              SILValue Callee,
-                                              SILBuilder &Builder,
-                                              const ReabstractionInfo &ReInfo) {
-  SILLocation Loc = AI.getLoc();
-  SmallVector<SILValue, 4> Arguments;
-  SILValue StoreResultTo;
+// Prepare call arguments. Perform re-abstraction if required.
+static void prepareCallArguments(ApplySite AI, SILBuilder &Builder,
+                                 const ReabstractionInfo &ReInfo,
+                                 SmallVectorImpl<SILValue> &Arguments,
+                                 SILValue &StoreResultTo) {
   /// SIL function conventions for the original apply site with substitutions.
+  SILLocation Loc = AI.getLoc();
   auto substConv = AI.getSubstCalleeConv();
   unsigned ArgIdx = AI.getCalleeArgIndexOfFirstAppliedArg();
   for (auto &Op : AI.getArgumentOperands()) {
@@ -553,13 +857,58 @@
 
     ++ArgIdx;
   }
+}
+
+/// Return a substituted callee function type.
+static CanSILFunctionType
+getCalleeSubstFunctionType(SILValue Callee, const ReabstractionInfo &ReInfo) {
+  // Create a substituted callee type.
+  auto CanFnTy =
+      dyn_cast<SILFunctionType>(Callee->getType().getSwiftRValueType());
+  auto CalleeSubstFnTy = CanFnTy;
+
+  if (ReInfo.getSpecializedType()->isPolymorphic() &&
+      !ReInfo.getCallerParamSubstitutions().empty()) {
+    CalleeSubstFnTy = CanFnTy->substGenericArgs(
+        ReInfo.getNonSpecializedFunction()->getModule(),
+        ReInfo.getCallerParamSubstitutions());
+    assert(!CalleeSubstFnTy->isPolymorphic() &&
+           "Substituted callee type should not be polymorphic");
+    assert(!CalleeSubstFnTy->hasTypeParameter() &&
+           "Substituted callee type should not have type parameters");
+  }
+
+  return CalleeSubstFnTy;
+}
+
+// Create a new apply based on an old one, but with a different
+// function being applied.
+static ApplySite replaceWithSpecializedCallee(ApplySite AI,
+                                              SILValue Callee,
+                                              SILBuilder &Builder,
+                                              const ReabstractionInfo &ReInfo) {
+  SILLocation Loc = AI.getLoc();
+  SmallVector<SILValue, 4> Arguments;
+  SILValue StoreResultTo;
+
+  prepareCallArguments(AI, Builder, ReInfo, Arguments, StoreResultTo);
+
+  // Create a substituted callee type.
+  ArrayRef<Substitution> Subs;
+  if (ReInfo.getSpecializedType()->isPolymorphic()) {
+    Subs = ReInfo.getCallerParamSubstitutions();
+  }
+
+  auto CalleeSubstFnTy = getCalleeSubstFunctionType(Callee, ReInfo);
+  auto CalleeSILSubstFnTy = SILType::getPrimitiveObjectType(CalleeSubstFnTy);
+  SILFunctionConventions substConv(CalleeSubstFnTy, Builder.getModule());
 
   if (auto *TAI = dyn_cast<TryApplyInst>(AI)) {
     SILBasicBlock *ResultBB = TAI->getNormalBB();
     assert(ResultBB->getSinglePredecessorBlock() == TAI->getParent());
     auto *NewTAI =
-      Builder.createTryApply(Loc, Callee, Callee->getType(), {},
-                             Arguments, ResultBB, TAI->getErrorBB());
+        Builder.createTryApply(Loc, Callee, CalleeSILSubstFnTy, Subs, Arguments,
+                               ResultBB, TAI->getErrorBB());
     if (StoreResultTo) {
       assert(substConv.useLoweredAddresses());
       // The original normal result of the try_apply is an empty tuple.
@@ -577,7 +926,9 @@
     return NewTAI;
   }
   if (auto *A = dyn_cast<ApplyInst>(AI)) {
-    auto *NewAI = Builder.createApply(Loc, Callee, Arguments, A->isNonThrowing());
+    auto *NewAI = Builder.createApply(Loc, Callee, CalleeSILSubstFnTy,
+                                      substConv.getSILResultType(), Subs,
+                                      Arguments, A->isNonThrowing());
     if (StoreResultTo) {
       assert(substConv.useLoweredAddresses());
       // Store the direct result to the original result address.
@@ -589,12 +940,14 @@
     return NewAI;
   }
   if (auto *PAI = dyn_cast<PartialApplyInst>(AI)) {
-    CanSILFunctionType NewPAType =
-      ReInfo.createSpecializedType(PAI->getFunctionType(), Builder.getModule());
-    SILType PTy = SILType::getPrimitiveObjectType(ReInfo.getSpecializedType());
+    CanSILFunctionType NewPAType = ReInfo.createSpecializedType(
+        PAI->getFunctionType(), Builder.getModule());
+    // SILType PTy =
+    // SILType::getPrimitiveObjectType(ReInfo.getSpecializedType());
+    SILType PTy = CalleeSILSubstFnTy;
     auto *NewPAI =
-      Builder.createPartialApply(Loc, Callee, PTy, {}, Arguments,
-                                 SILType::getPrimitiveObjectType(NewPAType));
+        Builder.createPartialApply(Loc, Callee, PTy, Subs, Arguments,
+                                   SILType::getPrimitiveObjectType(NewPAType));
     PAI->replaceAllUsesWith(NewPAI);
     return NewPAI;
   }
@@ -835,6 +1188,9 @@
   if (F->isFragile() && !RefF->hasValidLinkageForFragileInline())
       return;
 
+  if (shouldNotSpecializeCallee(RefF))
+    return;
+
   // If the caller and callee are both fragile, preserve the fragility when
   // cloning the callee. Otherwise, strip it off so that we can optimize
   // the body more.
@@ -851,6 +1207,12 @@
   bool needAdaptUsers = false;
   bool replacePartialApplyWithoutReabstraction = false;
   auto *PAI = dyn_cast<PartialApplyInst>(Apply);
+
+  // TODO: Partial specializations of partial applies are
+  // not supported yet.
+  if (PAI && ReInfo.getSpecializedType()->isPolymorphic())
+    return;
+
   if (PAI && ReInfo.hasConversions()) {
     // If we have a partial_apply and we converted some results/parameters from
     // indirect to direct there are 3 cases:
diff --git a/lib/SILOptimizer/Utils/SILInliner.cpp b/lib/SILOptimizer/Utils/SILInliner.cpp
index a01756c..6d4a293 100644
--- a/lib/SILOptimizer/Utils/SILInliner.cpp
+++ b/lib/SILOptimizer/Utils/SILInliner.cpp
@@ -233,6 +233,8 @@
     case ValueKind::FunctionRefInst:
     case ValueKind::AllocGlobalInst:
     case ValueKind::GlobalAddrInst:
+    case ValueKind::EndLifetimeInst:
+    case ValueKind::UncheckedOwnershipConversionInst:
       return InlineCost::Free;
 
     // Typed GEPs are free.
diff --git a/lib/SILOptimizer/Utils/SpecializationMangler.cpp b/lib/SILOptimizer/Utils/SpecializationMangler.cpp
index 76d4be7..00ef34d 100644
--- a/lib/SILOptimizer/Utils/SpecializationMangler.cpp
+++ b/lib/SILOptimizer/Utils/SpecializationMangler.cpp
@@ -12,6 +12,7 @@
 
 #include "swift/SILOptimizer/Utils/SpecializationMangler.h"
 #include "swift/SIL/SILGlobalVariable.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/Demangler.h"
 #include "swift/Basic/ManglingMacros.h"
 
@@ -60,19 +61,12 @@
   SILFunctionType *FTy = Function->getLoweredFunctionType();
   CanGenericSignature Sig = FTy->getGenericSignature();
 
-  unsigned idx = 0;
+  auto SubMap = Sig->getSubstitutionMap(Subs);
   bool First = true;
-  for (Type DepType : Sig->getAllDependentTypes()) {
-    // It is sufficient to only mangle the substitutions of the "primary"
-    // dependent types. As all other dependent types are just derived from the
-    // primary types, this will give us unique symbol names.
-    if (DepType->is<GenericTypeParamType>()) {
-      appendType(Subs[idx].getReplacement()->getCanonicalType());
-      appendListSeparator(First);
-    }
-    ++idx;
+  for (auto ParamType : Sig->getSubstitutableParams()) {
+    appendType(Type(ParamType).subst(SubMap)->getCanonicalType());
+    appendListSeparator(First);
   }
-  assert(idx == Subs.size() && "subs not parallel to dependent types");
   assert(!First && "no generic substitutions");
   
   appendSpecializationOperator(isReAbstracted ? "Tg" : "TG");
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
index 4f27b76..58a9796 100644
--- a/lib/Sema/CSApply.cpp
+++ b/lib/Sema/CSApply.cpp
@@ -19,6 +19,7 @@
 #include "ConstraintSystem.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/StringExtras.h"
 #include "llvm/ADT/APFloat.h"
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
index f84b7dd..b78d05c 100644
--- a/lib/Sema/CSGen.cpp
+++ b/lib/Sema/CSGen.cpp
@@ -2507,8 +2507,13 @@
       if (!selfDecl->hasType())
         return ErrorType::get(tc.Context);
 
-      Type declaredType = selfDecl->getType()->getRValueInstanceType();
-      Type superclassTy = declaredType->getSuperclass(&tc);
+      // If the method returns 'Self', the type of 'self' is a
+      // DynamicSelfType. Unwrap it before getting the superclass.
+      auto selfTy = selfDecl->getType()->getRValueInstanceType();
+      if (auto *dynamicSelfTy = selfTy->getAs<DynamicSelfType>())
+        selfTy = dynamicSelfTy->getSelfType();
+
+      auto superclassTy = selfTy->getSuperclass(&tc);
 
       if (selfDecl->getType()->is<MetatypeType>())
         superclassTy = MetatypeType::get(superclassTy);
@@ -3367,9 +3372,11 @@
                     llvm::SmallDenseMap<ValueDecl*, ValueDecl*> &DefaultMap) {
   Type BaseTy = PD->getDeclaredInterfaceType();
   DeclContext *DC = PD->getDeclContext();
+  std::unique_ptr<TypeChecker> CreatedTC;
   auto *TC = static_cast<TypeChecker*>(DC->getASTContext().getLazyResolver());
   if (!TC) {
-    TC = new TypeChecker(DC->getASTContext());
+    CreatedTC.reset(new TypeChecker(DC->getASTContext()));
+    TC = CreatedTC.get();
   }
   for (Decl *D : PD->getMembers()) {
     ValueDecl *VD = dyn_cast<ValueDecl>(D);
diff --git a/lib/Sema/CSRanking.cpp b/lib/Sema/CSRanking.cpp
index 02cc31d..d437e0e 100644
--- a/lib/Sema/CSRanking.cpp
+++ b/lib/Sema/CSRanking.cpp
@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "ConstraintSystem.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Compiler.h"
 
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
index d337194..11bae88 100644
--- a/lib/Sema/CSSimplify.cpp
+++ b/lib/Sema/CSSimplify.cpp
@@ -3351,9 +3351,10 @@
                                              Type type2,
                                              TypeMatchOptions flags,
                                              ConstraintLocatorBuilder locator) {
-  // There's no bridging without ObjC interop.
-  if (!TC.Context.LangOpts.EnableObjCInterop)
-    return SolutionKind::Error;
+  // There's no bridging without ObjC interop, so we shouldn't have set up
+  // bridging constraints without it.
+  assert(TC.Context.LangOpts.EnableObjCInterop
+         && "bridging constraint w/o ObjC interop?!");
   
   TypeMatchOptions subflags = getDefaultDecompositionOptions(flags);
 
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
index 2756738..dc02e5e 100644
--- a/lib/Sema/CodeSynthesis.cpp
+++ b/lib/Sema/CodeSynthesis.cpp
@@ -23,6 +23,7 @@
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ParameterList.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/Defer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
diff --git a/lib/Sema/Constraint.cpp b/lib/Sema/Constraint.cpp
index 6dec1cd..23245d9 100644
--- a/lib/Sema/Constraint.cpp
+++ b/lib/Sema/Constraint.cpp
@@ -527,6 +527,10 @@
           kind != ConstraintKind::LiteralConformsTo &&
           kind != ConstraintKind::SelfObjectOfProtocol) ||
          second->is<ProtocolType>());
+  
+  // Bridging constraints require bridging to be enabled.
+  assert(kind != ConstraintKind::BridgingConversion
+         || cs.TC.Context.LangOpts.EnableObjCInterop);
 
   // Create the constraint.
   unsigned size = totalSizeToAlloc<TypeVariableType*>(typeVars.size());
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
index ef5f386..ee4c66c 100644
--- a/lib/Sema/ConstraintSystem.h
+++ b/lib/Sema/ConstraintSystem.h
@@ -29,7 +29,6 @@
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/NameLookup.h"
-#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
 #include "llvm/ADT/ilist.h"
@@ -1047,8 +1046,10 @@
     /// \param scope The scope to associate with current solver state.
     void registerScope(SolverScope *scope) {
       CS.incrementScopeCounter();
-      scopes.insert({ scope, std::make_pair(retiredConstraints.begin(),
-                                            generatedConstraints.size()) });
+      auto scopeInfo =
+        std::make_tuple(scope, retiredConstraints.begin(),
+                        generatedConstraints.size());
+      scopes.push_back(scopeInfo);
     }
 
     /// \brief Check whether there are any retired constraints present.
@@ -1086,22 +1087,15 @@
     ///
     /// \param constraint The constraint to erase.
     void removeGeneratedConstraint(Constraint *constraint) {
-      size_t index = 0;
-      for (auto generated : generatedConstraints) {
+      for (auto *&generated : generatedConstraints) {
+        // When we find the constraint we're erasing, overwrite its
+        // value with the last element in the generated constraints
+        // vector and then pop that element from the vector.
         if (generated == constraint) {
-          unsigned last = generatedConstraints.size() - 1;
-          auto lastConstraint = generatedConstraints[last];
-          if (lastConstraint == generated) {
-            generatedConstraints.pop_back();
-            break;
-          } else {
-            generatedConstraints[index] = lastConstraint;
-            generatedConstraints[last] = constraint;
-            generatedConstraints.pop_back();
-            break;
-          }
+          generated = generatedConstraints.back();
+          generatedConstraints.pop_back();
+          return;
         }
-        index++;
       }
     }
 
@@ -1113,18 +1107,16 @@
     ///
     /// \param scope The solver scope to rollback.
     void rollback(SolverScope *scope) {
-      auto entry = scopes.find(scope);
-      assert(entry != scopes.end() && "Unknown solver scope");
-
-      // Remove given scope from the circulation.
-      scopes.erase(scope);
-
+      SolverScope *savedScope;
       // The position of last retired constraint before given scope.
       ConstraintList::iterator lastRetiredPos;
       // The original number of generated constraints before given scope.
       unsigned numGenerated;
 
-      std::tie(lastRetiredPos, numGenerated) = entry->getSecond();
+      std::tie(savedScope, lastRetiredPos, numGenerated) =
+        scopes.pop_back_val();
+
+      assert(savedScope == scope && "Scope rollback not in LIFO order!");
 
       // Restore all of the retired constraints.
       CS.InactiveConstraints.splice(CS.InactiveConstraints.end(),
@@ -1155,9 +1147,8 @@
     /// constraints generated before registration of given scope,
     /// this helps to rollback all of the constraints retired/generated
     /// each of the registered scopes correct (LIFO) order.
-    llvm::SmallDenseMap<SolverScope *,
-                        std::pair<ConstraintList::iterator, unsigned>>
-        scopes;
+    llvm::SmallVector<
+      std::tuple<SolverScope *, ConstraintList::iterator, unsigned>, 4> scopes;
   };
 
   class CacheExprTypes : public ASTWalker {
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
index acc5e42..10a8190 100644
--- a/lib/Sema/TypeCheckAvailability.cpp
+++ b/lib/Sema/TypeCheckAvailability.cpp
@@ -1186,7 +1186,7 @@
         << OriginalIndent;
   }
 
-  TC.diagnose(ReferenceRange.Start, diag::availability_add_attribute,
+  TC.diagnose(D, diag::availability_add_attribute,
               KindForDiagnostic)
       .fixItInsert(InsertLoc, AttrText);
 }
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
index 11fa677..30e1853 100644
--- a/lib/Sema/TypeCheckConstraints.cpp
+++ b/lib/Sema/TypeCheckConstraints.cpp
@@ -1388,6 +1388,11 @@
   return true;
 }
 
+void GenericRequirementsCheckListener::satisfiedConformance(
+                                          Type depTy, Type replacementTy,
+                                          ProtocolConformanceRef conformance) {
+}
+
 bool TypeChecker::
 solveForExpression(Expr *&expr, DeclContext *dc, Type convertType,
                    FreeTypeVariableBinding allowFreeTypeVariables,
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
index d324496..643db8d 100644
--- a/lib/Sema/TypeCheckDecl.cpp
+++ b/lib/Sema/TypeCheckDecl.cpp
@@ -30,6 +30,7 @@
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/PrettyStackTrace.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ReferencedNameTracker.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/Basic/Statistic.h"
@@ -4047,7 +4048,7 @@
 
       TC.validateDecl(ED);
 
-      TC.ValidatedTypes.remove(ED);
+      TC.TypesToFinalize.remove(ED);
 
       {
         // Check for circular inheritance of the raw type.
@@ -4103,7 +4104,7 @@
       checkUnsupportedNestedType(SD);
 
       TC.validateDecl(SD);
-      TC.ValidatedTypes.remove(SD);
+      TC.TypesToFinalize.remove(SD);
       TC.addImplicitConstructors(SD);
     }
 
@@ -4235,7 +4236,7 @@
       if (!CD->hasValidSignature())
         return;
 
-      TC.ValidatedTypes.remove(CD);
+      TC.TypesToFinalize.remove(CD);
 
       {
         // Check for circular inheritance.
@@ -7090,7 +7091,7 @@
         checkEnumRawValues(*this, ED);
     }
 
-    ValidatedTypes.insert(nominal);
+    TypesToFinalize.insert(nominal);
     break;
   }
 
@@ -7130,7 +7131,7 @@
       markAsObjC(*this, proto, isObjC);
     }
 
-    ValidatedTypes.insert(proto);
+    TypesToFinalize.insert(proto);
     break;
   }
 
@@ -7301,6 +7302,9 @@
         validateDeclForNameLookup(ATD);
       }
     }
+
+    // Make sure the protocol is fully validated by the end of Sema.
+    TypesToFinalize.insert(proto);
     break;
   }
   case DeclKind::AssociatedType: {
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
index a0dc719..3ad9369 100644
--- a/lib/Sema/TypeCheckGeneric.cpp
+++ b/lib/Sema/TypeCheckGeneric.cpp
@@ -20,6 +20,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Defer.h"
+#include "llvm/Support/ErrorHandling.h"
 
 using namespace swift;
 
@@ -399,6 +400,8 @@
     return false;
   }
   }
+
+  llvm_unreachable("Unhandled RequirementKind in switch.");
 }
 
 void
@@ -1124,10 +1127,13 @@
     UnsatisfiedDependency *unsatisfiedDependency,
     ConformanceCheckOptions conformanceOptions,
     GenericRequirementsCheckListener *listener) {
+  bool valid = true;
+
   for (const auto &rawReq : genericSig->getRequirements()) {
     auto req = rawReq.subst(substitutions, conformances);
     if (!req) {
       // Another requirement will fail later; just continue.
+      valid = false;
       continue;
     }
 
@@ -1138,8 +1144,10 @@
     if (kind != RequirementKind::Layout) {
       rawSecondType = rawReq.getSecondType();
       secondType = req->getSecondType().subst(substitutions, conformances);
-      if (!secondType)
+      if (!secondType) {
+        valid = false;
         continue;
+      }
     }
 
     if (listener && !listener->shouldCheck(kind, firstType, secondType))
@@ -1165,6 +1173,12 @@
       if (!result.second)
         return std::make_pair(false, false);
 
+      // Report the conformance.
+      if (listener) {
+        listener->satisfiedConformance(rawReq.getFirstType(), firstType,
+                                       *result.second);
+      }
+      
       continue;
     }
 
@@ -1207,5 +1221,5 @@
     }
   }
 
-  return std::make_pair(false, true);
+  return std::make_pair(false, valid);
 }
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
index ddf4d8a..7a92f22 100644
--- a/lib/Sema/TypeCheckProtocol.cpp
+++ b/lib/Sema/TypeCheckProtocol.cpp
@@ -28,6 +28,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/NameLookup.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ReferencedNameTracker.h"
 #include "swift/AST/TypeMatcher.h"
 #include "swift/AST/TypeWalker.h"
@@ -38,6 +39,9 @@
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/SaveAndRestore.h"
 
+#define DEBUG_TYPE "protocol-conformance-checking"
+#include "llvm/Support/Debug.h"
+
 using namespace swift;
 
 namespace {
@@ -1705,6 +1709,10 @@
     /// Whether we've already complained about problems with this conformance.
     bool AlreadyComplained = false;
 
+    /// Keep track of missing witnesses, either type or value, for later
+    /// diagnosis emits.
+    llvm::SetVector<ValueDecl*> MissingWitnesses;
+
     /// Retrieve the associated types that are referenced by the given
     /// requirement with a base of 'Self'.
     ArrayRef<AssociatedTypeDecl *> getReferencedAssociatedTypes(ValueDecl *req);
@@ -1778,6 +1786,8 @@
                         llvm::SmallPtrSetImpl<ProtocolConformance *> &visited);
     void addUsedConformances(ProtocolConformance *conformance);
 
+    /// Call this to diagnose currently known missing witnesses.
+    void diagnoseMissingWitnesses();
   public:
     /// Emit any diagnostics that have been delayed.
     void emitDelayedDiags();
@@ -2396,50 +2406,77 @@
   return true;
 }
 
-
-/// Generates a note for a protocol requirement for which no witness was found
-/// and provides a fixit to add a stub to the adopter
-static void diagnoseNoWitness(ValueDecl *Requirement, Type RequirementType,
-                              NormalProtocolConformance *Conformance) {
-  // FIXME: Try an ignore-access lookup?
-
-  DeclContext *Adopter = Conformance->getDeclContext();
-
-  SourceLoc FixitLocation;
-  SourceLoc TypeLoc;
-  if (auto Extension = dyn_cast<ExtensionDecl>(Adopter)) {
-    FixitLocation = Extension->getBraces().Start;
-    TypeLoc = Extension->getStartLoc();
-  } else if (auto Nominal = dyn_cast<NominalTypeDecl>(Adopter)) {
-    FixitLocation = Nominal->getBraces().Start;
-    TypeLoc = Nominal->getStartLoc();
-  } else {
-    llvm_unreachable("Unknown adopter kind");
-  }
-
-  ASTContext &Ctx = Requirement->getASTContext();
-  auto &Diags = Ctx.Diags;
-  std::string FixitString;
+/// Print the stubs for an array of witnesses, either type or value, to
+/// FixitString. If for a witness we cannot have stub printed, insert it to
+/// NoStubRequirements.
+static void
+printProtocolStubFixitString(SourceLoc TypeLoc, ProtocolConformance *Conf,
+                             ArrayRef<ValueDecl*> MissingWitnesses,
+                             std::string &FixitString,
+                             llvm::SetVector<ValueDecl*> &NoStubRequirements) {
   llvm::raw_string_ostream FixitStream(FixitString);
+  std::for_each(MissingWitnesses.begin(), MissingWitnesses.end(),
+    [&](ValueDecl* VD) {
+      if (!printRequirementStub(VD, Conf->getDeclContext(), Conf->getType(),
+                                TypeLoc, FixitStream)) {
+        NoStubRequirements.insert(VD);
+      }
+    });
+}
 
-  bool AddFixit = printRequirementStub(Requirement, Adopter,
-                                       Conformance->getType(), TypeLoc,
-                                       FixitStream);
+void ConformanceChecker::diagnoseMissingWitnesses() {
+  if (MissingWitnesses.empty())
+    return;
 
-  if (auto MissingTypeWitness = dyn_cast<AssociatedTypeDecl>(Requirement)) {
-    Diags.diagnose(MissingTypeWitness, diag::no_witnesses_type,
-                   MissingTypeWitness->getName())
-      .fixItInsertAfter(FixitLocation, FixitStream.str());
-  } else {
-    // Point out the requirement that wasn't met.
-    auto diag = Diags.diagnose(Requirement, diag::no_witnesses,
-                               getRequirementKind(Requirement),
-                               Requirement->getFullName(),
-                               RequirementType, AddFixit);
-    if (AddFixit) {
-      diag.fixItInsertAfter(FixitLocation, FixitStream.str());
-    }
-  }
+  // Make sure we clear the missing witness bucket when exiting.
+  SWIFT_DEFER { MissingWitnesses.clear(); };
+  llvm::SetVector<ValueDecl*> MissingWitnesses = this->MissingWitnesses;
+  diagnoseOrDefer(MissingWitnesses[0], true,
+    [MissingWitnesses](NormalProtocolConformance *Conf) {
+      DeclContext *DC = Conf->getDeclContext();
+      // The location where to insert stubs.
+      SourceLoc FixitLocation;
+
+      // The location where the type starts.
+      SourceLoc TypeLoc;
+      if (auto Extension = dyn_cast<ExtensionDecl>(DC)) {
+        FixitLocation = Extension->getBraces().Start;
+        TypeLoc = Extension->getStartLoc();
+      } else if (auto Nominal = dyn_cast<NominalTypeDecl>(DC)) {
+        FixitLocation = Nominal->getBraces().Start;
+        TypeLoc = Nominal->getStartLoc();
+      } else {
+        llvm_unreachable("Unknown adopter kind");
+      }
+      std::string FixIt;
+      llvm::SetVector<ValueDecl*> NoStubRequirements;
+
+      // Print stubs for all known missing witnesses.
+      printProtocolStubFixitString(TypeLoc, Conf,
+                                   MissingWitnesses.getArrayRef(),
+                                   FixIt, NoStubRequirements);
+      auto &Diags = DC->getASTContext().Diags;
+      for (auto VD : MissingWitnesses) {
+        // Whether this VD has a stub printed.
+        bool AddFixit = !NoStubRequirements.count(VD);
+
+        // Issue diagnostics for witness types.
+        if (auto MissingTypeWitness = dyn_cast<AssociatedTypeDecl>(VD)) {
+          Diags.diagnose(MissingTypeWitness, diag::no_witnesses_type,
+                         MissingTypeWitness->getName()).
+          fixItInsertAfter(FixitLocation, FixIt);
+          continue;
+        }
+        // Issue diagnostics for witness values.
+        Type RequirementType =
+          getRequirementTypeForDisplay(DC->getParentModule(), Conf, VD);
+        auto Diag = Diags.diagnose(VD, diag::no_witnesses,
+                                   getRequirementKind(VD), VD->getFullName(),
+                                   RequirementType, AddFixit);
+        if (AddFixit)
+          Diag.fixItInsertAfter(FixitLocation, FixIt);
+      }
+  });
 }
 
 ResolveWitnessResult
@@ -2753,30 +2790,36 @@
     return ResolveWitnessResult::ExplicitFailed;
   }
 
+
+  if (!numViable) {
+    // Save the missing requirement for later diagnosis.
+    MissingWitnesses.insert(requirement);
+    diagnoseOrDefer(requirement, true,
+      [requirement, matches](NormalProtocolConformance *conformance) {
+        auto dc = conformance->getDeclContext();
+        // Diagnose each of the matches.
+        for (const auto &match : matches)
+          diagnoseMatch(dc->getParentModule(), conformance, requirement, match);
+      });
+    return ResolveWitnessResult::ExplicitFailed;
+  }
+
   diagnoseOrDefer(requirement, true,
-    [requirement, matches, ignoringNames, numViable](
+    [requirement, matches, ignoringNames](
       NormalProtocolConformance *conformance) {
       auto dc = conformance->getDeclContext();
-      auto &diags = dc->getASTContext().Diags;
-
       // Determine the type that the requirement is expected to have.
       Type reqType = getRequirementTypeForDisplay(dc->getParentModule(),
                                                   conformance, requirement);
-
-      if (numViable > 0) {
-        auto diagnosticMessage = diag::ambiguous_witnesses;
-        if (ignoringNames) {
-          diagnosticMessage = diag::ambiguous_witnesses_wrong_name;
-        }
-        diags.diagnose(requirement, diagnosticMessage,
-                       getRequirementKind(requirement),
-                       requirement->getFullName(),
-                       reqType);
-      } else {
-        // Generate diagnostics for the missing requirement and a fixit to add
-        // it
-        diagnoseNoWitness(requirement, reqType, conformance);
+      auto &diags = dc->getASTContext().Diags;
+      auto diagnosticMessage = diag::ambiguous_witnesses;
+      if (ignoringNames) {
+        diagnosticMessage = diag::ambiguous_witnesses_wrong_name;
       }
+      diags.diagnose(requirement, diagnosticMessage,
+                     getRequirementKind(requirement),
+                     requirement->getFullName(),
+                     reqType);
 
       // Diagnose each of the matches.
       for (const auto &match : matches)
@@ -2840,21 +2883,8 @@
     recordOptionalWitness(requirement);
     return ResolveWitnessResult::Success;
   }
-
-  diagnoseOrDefer(requirement, true,
-    [requirement](NormalProtocolConformance *conformance) {
-    auto dc = conformance->getDeclContext();
-    auto &diags = dc->getASTContext().Diags;
-    // Determine the type that the requirement is expected to have.
-    Type reqType = getRequirementTypeForDisplay(dc->getParentModule(),
-                                                conformance, requirement);
-
-    // Point out the requirement that wasn't met.
-    diags.diagnose(requirement, diag::no_witnesses,
-                   getRequirementKind(requirement), requirement->getName(),
-                   reqType, false);
-    });
-
+  // Save the missing requirement for later diagnosis.
+  MissingWitnesses.insert(requirement);
   return ResolveWitnessResult::ExplicitFailed;
 }
 
@@ -2948,13 +2978,13 @@
 
     return ResolveWitnessResult::ExplicitFailed;
   }
+  // Save the missing type witness for later diagnosis.
+  MissingWitnesses.insert(assocType);
 
   // None of the candidates were viable.
   diagnoseOrDefer(assocType, true,
-    [assocType, nonViable](NormalProtocolConformance *conformance) {
-      auto &diags = assocType->getASTContext().Diags;
-      diags.diagnose(assocType, diag::no_witnesses_type, assocType->getName());
-
+    [nonViable](NormalProtocolConformance *conformance) {
+      auto &diags = conformance->getDeclContext()->getASTContext().Diags;
       for (auto candidate : nonViable) {
         if (candidate.first->getDeclaredInterfaceType()->hasError())
           continue;
@@ -3037,6 +3067,9 @@
   };
 
   for (auto witness : lookupValueWitnesses(req, /*ignoringNames=*/nullptr)) {
+    DEBUG(llvm::dbgs() << "Inferring associated types from decl:\n";
+          witness->dump(llvm::dbgs()));
+  
     // If the potential witness came from an extension, and our `Self`
     // type can't use it regardless of what associated types we end up
     // inferring, skip the witness.
@@ -3057,18 +3090,27 @@
 }
       auto &result = witnessResult.Inferred[i];
 
+      DEBUG(llvm::dbgs() << "Considering whether " << result.first->getName()
+                         << " can infer to:\n";
+            result.second->dump(llvm::dbgs()));
+
       // Filter out errors.
-      if (result.second->hasError())
+      if (result.second->hasError()) {
+        DEBUG(llvm::dbgs() << "-- has error type\n");
         REJECT;
+      }
 
       // Filter out duplicates.
       if (!known.insert({result.first, result.second->getCanonicalType()})
-                .second)
+                .second) {
+        DEBUG(llvm::dbgs() << "-- duplicate\n");
         REJECT;
+      }
      
       // Filter out circular possibilities, e.g. that
       // AssocType == S.AssocType or
       // AssocType == Foo<S.AssocType>.
+      bool canInferFromOtherAssociatedType = false;
       bool containsTautologicalType =
         result.second.findIf([&](Type t) -> bool {
           auto dmt = t->getAs<DependentMemberType>();
@@ -3080,11 +3122,63 @@
           if (!dmt->getBase()->isEqual(Conformance->getType()))
             return false;
           
+          // If this associated type is same-typed to another associated type
+          // on `Self`, then it may still be an interesting candidate if we find
+          // an answer for that other type.
+          auto witnessContext = witness->getDeclContext();
+          if (witnessContext->getAsProtocolExtensionContext()
+              && witnessContext->getGenericSignatureOfContext()) {
+            auto selfTy = witnessContext->getSelfInterfaceType();
+            auto selfAssocTy = DependentMemberType::get(selfTy,
+                                                        dmt->getAssocType());
+            for (auto &reqt : witnessContext->getGenericSignatureOfContext()
+                                            ->getRequirements()) {
+              switch (reqt.getKind()) {
+              case RequirementKind::Conformance:
+              case RequirementKind::Superclass:
+              case RequirementKind::Layout:
+                break;
+              
+              case RequirementKind::SameType:
+                Type other;
+                if (reqt.getFirstType()->isEqual(selfAssocTy)) {
+                  other = reqt.getSecondType();
+                } else if (reqt.getSecondType()->isEqual(selfAssocTy)) {
+                  other = reqt.getFirstType();
+                } else {
+                  break;
+                }
+                
+                if (auto otherAssoc = other->getAs<DependentMemberType>()) {
+                  if (otherAssoc->getBase()->isEqual(selfTy)) {
+                    auto otherDMT = DependentMemberType::get(dmt->getBase(),
+                                                    otherAssoc->getAssocType());
+                    
+                    // We may be able to infer one associated type from the
+                    // other.
+                    result.second = result.second.transform([&](Type t) -> Type{
+                      if (t->isEqual(dmt))
+                        return otherDMT;
+                      return t;
+                    });
+                    canInferFromOtherAssociatedType = true;
+                    DEBUG(llvm::dbgs() << "++ we can same-type to:\n";
+                          result.second->dump(llvm::dbgs()));
+                    return false;
+                  }
+                }
+                break;
+              }
+            }
+          }
+          
           return true;
         });
       
-      if (containsTautologicalType)
+      if (containsTautologicalType) {
+        DEBUG(llvm::dbgs() << "-- tautological\n");
         REJECT;
+      }
       
       // Check that the type witness doesn't contradict an
       // explicitly-given type witness. If it does contradict, throw out the
@@ -3101,19 +3195,27 @@
         auto newWitness = result.second->getCanonicalType();
         if (!newWitness->hasTypeParameter()
             && !existingWitness->isEqual(newWitness)) {
+          DEBUG(llvm::dbgs() << "** contradicts explicit type witness, "
+                                "rejecting inference from this decl\n");
           goto next_witness;
         }
       }
       
-      // Check that the type witness meets the
-      // requirements on the associated type.
-      if (auto failed = checkTypeWitness(TC, DC, result.first,
-                                         result.second)) {
-        witnessResult.NonViable.push_back(
-                            std::make_tuple(result.first,result.second,failed));
-        REJECT;
+      // If we same-typed to another unresolved associated type, we won't
+      // be able to check conformances yet.
+      if (!canInferFromOtherAssociatedType) {
+        // Check that the type witness meets the
+        // requirements on the associated type.
+        if (auto failed = checkTypeWitness(TC, DC, result.first,
+                                           result.second)) {
+          witnessResult.NonViable.push_back(
+                              std::make_tuple(result.first,result.second,failed));
+          DEBUG(llvm::dbgs() << "-- doesn't fulfill requirements\n");
+          REJECT;
+        }
       }
       
+      DEBUG(llvm::dbgs() << "++ seems legit\n");
       ++i;
     }
 #undef REJECT
@@ -3630,6 +3732,8 @@
 
   // Infer type witnesses from value witnesses.
   auto inferred = inferTypeWitnessesViaValueWitnesses(unresolvedAssocTypes);
+  DEBUG(llvm::dbgs() << "Candidates for inference:\n";
+        dumpInferredAssociatedTypes(inferred));
 
   // Compute the set of solutions.
   SmallVector<std::pair<ValueDecl *, ValueDecl *>, 4> valueWitnesses;
@@ -3820,6 +3924,9 @@
         Type replaced = known->first.transform(foldDependentMemberTypes);
         if (replaced.isNull())
           return true;
+        
+        if (checkTypeWitness(TC, DC, assocType, replaced))
+          return true;
 
         known->first = replaced;
       }
@@ -4223,12 +4330,9 @@
       return;
     }
 
-    for (auto missingTypeWitness : unresolvedAssocTypes) {
-      diagnoseOrDefer(missingTypeWitness, true,
-        [missingTypeWitness](NormalProtocolConformance *conformance) {
-          diagnoseNoWitness(missingTypeWitness, Type(), conformance);
-        });
-    }
+    // Save the missing type witnesses for later diagnosis.
+    MissingWitnesses.insert(unresolvedAssocTypes.begin(),
+                            unresolvedAssocTypes.end());
 
     return;
   }
@@ -4302,6 +4406,8 @@
 
 void ConformanceChecker::resolveSingleTypeWitness(
        AssociatedTypeDecl *assocType) {
+  // Ensure we diagnose if the witness is missing.
+  SWIFT_DEFER { diagnoseMissingWitnesses(); };
   switch (resolveTypeWitnessViaLookup(assocType)) {
   case ResolveWitnessResult::Success:
   case ResolveWitnessResult::ExplicitFailed:
@@ -4458,23 +4564,40 @@
 void ConformanceChecker::ensureRequirementsAreSatisfied() {
   auto proto = Conformance->getProtocol();
   // Some other problem stopped the signature being computed.
-  if (!proto->isRequirementSignatureComputed())
+  if (!proto->isRequirementSignatureComputed()) {
+    Conformance->setInvalid();
     return;
+  }
 
   auto reqSig = proto->getRequirementSignature();
 
   auto substitutions = SubstitutionMap::getProtocolSubstitutions(
       proto, Conformance->getType(), ProtocolConformanceRef(Conformance));
 
+  class GatherConformancesListener : public GenericRequirementsCheckListener {
+  public:
+    SmallVector<ProtocolConformanceRef, 4> conformances;
+
+    void satisfiedConformance(Type depTy, Type replacementTy,
+                              ProtocolConformanceRef conformance) override {
+      conformances.push_back(conformance);
+    }
+  } listener;
+
   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);
+      LookUpConformanceInSubstitutionMap{substitutions}, nullptr,
+      ConformanceCheckFlags::Used, &listener);
 
-  // Errors are emitted inside the checker.
-  (void)result;
+  // If there were no errors, record the conformances.
+  if (result.second) {
+    Conformance->setSignatureConformances(listener.conformances);
+  } else {
+    Conformance->setInvalid();
+  }
 }
 
 #pragma mark Protocol conformance checking
@@ -4492,6 +4615,11 @@
   // Resolve all of the type witnesses.
   resolveTypeWitnesses();
 
+  // Diagnose missing type witnesses for now.
+  diagnoseMissingWitnesses();
+  // Diagnose missing value witnesses later.
+  SWIFT_DEFER { diagnoseMissingWitnesses(); };
+
   // Resolution attempts to have the witnesses be correct by construction, but
   // this isn't guaranteed, so let's double check.
   ensureRequirementsAreSatisfied();
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
index 211b3de..32ad28f 100644
--- a/lib/Sema/TypeCheckStmt.cpp
+++ b/lib/Sema/TypeCheckStmt.cpp
@@ -267,12 +267,46 @@
               return LHS->getNameStr().compare(RHS->getNameStr()) < 0;
             });
 
+  auto printPayloads = [](EnumElementDecl *EE, llvm::raw_ostream &OS) {
+    // If the enum element has no payloads, return.
+    auto TL = EE->getArgumentTypeLoc();
+    if (TL.isNull())
+      return;
+    TypeRepr* TR = EE->getArgumentTypeLoc().getTypeRepr();
+    if (auto *TTR = dyn_cast<TupleTypeRepr>(TR)) {
+      SmallVector<Identifier, 4> NameBuffer;
+      ArrayRef<Identifier> Names;
+      if (TTR->hasElementNames()) {
+        // Get the name from the tuple repr, if exist.
+        Names = TTR->getElementNames();
+      } else {
+        // Create same amount of empty names to the elements.
+        NameBuffer.resize(TTR->getNumElements());
+        Names = llvm::makeArrayRef(NameBuffer);
+      }
+      OS << "(";
+      // Print each element in the pattern match.
+      for (unsigned I = 0, N = Names.size(); I < N; I ++) {
+        auto Id = Names[I];
+        if (Id.empty())
+          OS << "_";
+        else
+          OS << tok::kw_let << " " << Id.str();
+        if (I + 1 != N) {
+          OS << ", ";
+        }
+      }
+      OS << ")";
+    }
+  };
+
   // Print each enum element name.
   std::for_each(SortedElements.begin(), SortedElements.end(),
-                [&](EnumElementDecl *EE) {
-                  OS << tok::kw_case << " ." << EE->getNameStr() << ": " <<
-                  Placeholder << "\n";
-                });
+    [&](EnumElementDecl *EE) {
+      OS << tok::kw_case << " ." << EE->getNameStr();
+      printPayloads(EE, OS);
+      OS <<": " << Placeholder << "\n";
+  });
   Context.Diags.diagnose(EndLoc, Id).fixItInsert(EndLoc, Buffer.str());
 }
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
index e0ee038..1d0bec1 100644
--- a/lib/Sema/TypeCheckType.cpp
+++ b/lib/Sema/TypeCheckType.cpp
@@ -2269,7 +2269,7 @@
 
     params = genericSig->getGenericParams();
     if (repr->getGenericArguments().size()
-          != genericSig->getAllDependentTypes().size()) {
+          != genericSig->getSubstitutionListSize()) {
       TC.diagnose(repr->getLoc(), diag::sil_box_arg_mismatch);
       return ErrorType::get(Context);
     }
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
index e681c7a..d33538c 100644
--- a/lib/Sema/TypeChecker.cpp
+++ b/lib/Sema/TypeChecker.cpp
@@ -410,7 +410,8 @@
   ::bindExtensionDecl(ext, *this);
 }
 
-static bool shouldValidateDeclForLayout(NominalTypeDecl *nominal, ValueDecl *VD) {
+static bool shouldValidateMemberDuringFinalization(NominalTypeDecl *nominal,
+                                                   ValueDecl *VD) {
   // For enums, we only need to validate enum elements to know
   // the layout.
   if (isa<EnumDecl>(nominal) &&
@@ -440,7 +441,7 @@
   return false;
 }
 
-static void validateDeclForLayout(TypeChecker &TC, NominalTypeDecl *nominal) {
+static void finalizeType(TypeChecker &TC, NominalTypeDecl *nominal) {
   Optional<bool> lazyVarsAlreadyHaveImplementation;
 
   for (auto *D : nominal->getMembers()) {
@@ -448,7 +449,7 @@
     if (!VD)
       continue;
 
-    if (!shouldValidateDeclForLayout(nominal, VD))
+    if (!shouldValidateMemberDuringFinalization(nominal, VD))
       continue;
 
     TC.validateDecl(VD);
@@ -489,6 +490,15 @@
     TC.addImplicitConstructors(CD);
     TC.addImplicitDestructor(CD);
   }
+
+  // validateDeclForNameLookup will not trigger an immediate full
+  // validation of protocols, but clients will assume that things
+  // like the requirement signature have been set.
+  if (auto PD = dyn_cast<ProtocolDecl>(nominal)) {
+    if (!PD->isRequirementSignatureComputed()) {
+      TC.validateDecl(PD);
+    }
+  }
 }
 
 static void typeCheckFunctionsAndExternalDecls(TypeChecker &TC) {
@@ -541,12 +551,12 @@
     // Note: if we ever start putting extension members in vtables, we'll need
     // to validate those members too.
     // FIXME: If we're not planning to run SILGen, this is wasted effort.
-    while (!TC.ValidatedTypes.empty()) {
-      auto nominal = TC.ValidatedTypes.pop_back_val();
+    while (!TC.TypesToFinalize.empty()) {
+      auto nominal = TC.TypesToFinalize.pop_back_val();
       if (nominal->isInvalid() || TC.Context.hadError())
         continue;
 
-      validateDeclForLayout(TC, nominal);
+      finalizeType(TC, nominal);
     }
 
     // Complete any conformances that we used.
@@ -559,7 +569,7 @@
 
   } while (currentFunctionIdx < TC.definedFunctions.size() ||
            currentExternalDef < TC.Context.ExternalDefinitions.size() ||
-           !TC.ValidatedTypes.empty() ||
+           !TC.TypesToFinalize.empty() ||
            !TC.UsedConformances.empty());
 
   // FIXME: Horrible hack. Store this somewhere more appropriate.
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
index aa56685..4dd7713 100644
--- a/lib/Sema/TypeChecker.h
+++ b/lib/Sema/TypeChecker.h
@@ -351,6 +351,14 @@
   ///
   /// \returns true if it's ok to validate requirement, false otherwise.
   virtual bool shouldCheck(RequirementKind kind, Type first, Type second);
+
+  /// Callback to report the result of a satisfied conformance requirement.
+  ///
+  /// \param depTy The dependent type, from the signature.
+  /// \param replacementTy The type \c depTy was replaced with.
+  /// \param conformance The conformance itself.
+  virtual void satisfiedConformance(Type depTy, Type replacementTy,
+                                    ProtocolConformanceRef conformance);
 };
 
 /// Flags that describe the context of type checking a pattern or
@@ -543,9 +551,10 @@
   /// completed before type checking is considered complete.
   llvm::SetVector<NormalProtocolConformance *> UsedConformances;
 
-  /// The list of nominal type declarations that have been validated
-  /// during type checking.
-  llvm::SetVector<NominalTypeDecl *> ValidatedTypes;
+  /// The list of nominal type declarations that we've done at least
+  /// partial validation of during type-checking and which will need
+  /// to be finalized before we can hand off to SILGen etc.
+  llvm::SetVector<NominalTypeDecl *> TypesToFinalize;
 
   using TypeAccessScopeCacheMap = llvm::DenseMap<const ValueDecl *, AccessScope>;
 
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
index 65e5ea5..4b091c9 100644
--- a/lib/Serialization/Deserialization.cpp
+++ b/lib/Serialization/Deserialization.cpp
@@ -715,6 +715,15 @@
   dc->getAsNominalTypeOrNominalTypeExtensionContext()
     ->registerProtocolConformance(conformance);
 
+  // Read requirement signature conformances.
+  SmallVector<ProtocolConformanceRef, 4> reqConformances;
+  for (auto req : proto->getRequirementSignature()->getRequirements()) {
+    if (req.getKind() == RequirementKind::Conformance) {
+      auto reqConformance = readConformance(DeclTypeCursor);
+      reqConformances.push_back(reqConformance);
+    }
+  }
+  conformance->setSignatureConformances(reqConformances);
 
   // Read inherited conformances.
   InheritedConformanceMap inheritedConformances;
@@ -4048,7 +4057,7 @@
     
     SmallVector<Substitution, 4> genericArgs;
     if (auto sig = layout->getGenericSignature()) {
-      for (unsigned i : range(sig->getAllDependentTypes().size())) {
+      for (unsigned i : range(sig->getSubstitutionListSize())) {
         (void)i;
         auto sub = maybeReadSubstitution(DeclTypeCursor);
         if (!sub) {
@@ -4336,6 +4345,14 @@
                                               typeCount, inheritedCount,
                                               rawIDs);
 
+  // Skip requirement signature conformances.
+  auto proto = conformance->getProtocol();
+  for (auto req : proto->getRequirementSignature()->getRequirements()) {
+    if (req.getKind() == RequirementKind::Conformance) {
+      (void)readConformance(DeclTypeCursor);
+    }
+  }
+
   // Skip trailing inherited conformances.
   while (inheritedCount--)
     (void)readConformance(DeclTypeCursor);
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
index 25c7df7..da42e5c 100644
--- a/lib/Serialization/DeserializeSIL.cpp
+++ b/lib/Serialization/DeserializeSIL.cpp
@@ -1364,6 +1364,7 @@
   UNARY_INSTRUCTION(Return)
   UNARY_INSTRUCTION(Throw)
   UNARY_INSTRUCTION(FixLifetime)
+  UNARY_INSTRUCTION(EndLifetime)
   UNARY_INSTRUCTION(CopyBlock)
   UNARY_INSTRUCTION(LoadBorrow)
   UNARY_INSTRUCTION(BeginBorrow)
@@ -1379,6 +1380,15 @@
 #undef UNARY_INSTRUCTION
 #undef REFCOUNTING_INSTRUCTION
 
+  case ValueKind::UncheckedOwnershipConversionInst: {
+    auto Ty = MF->getType(TyID);
+    auto ResultKind = ValueOwnershipKind(Attr);
+    ResultVal = Builder.createUncheckedOwnershipConversion(
+        Loc, getLocalValue(ValID, getSILType(Ty, (SILValueCategory)TyCategory)),
+        ResultKind);
+    break;
+  }
+
   case ValueKind::LoadInst: {
     auto Ty = MF->getType(TyID);
     auto Qualifier = LoadOwnershipQualifier(Attr);
@@ -2387,13 +2397,14 @@
         proto, conformance.getConcrete()
       });
     } else if (kind == SIL_WITNESS_ASSOC_PROTOCOL) {
-      DeclID assocId, protoId;
+      TypeID assocId;
+      DeclID protoId;
       WitnessAssocProtocolLayout::readRecord(scratch, assocId, protoId);
+      CanType type = MF->getType(assocId)->getCanonicalType();
       ProtocolDecl *proto = cast<ProtocolDecl>(MF->getDecl(protoId));
       auto conformance = MF->readConformance(SILCursor);
       witnessEntries.push_back(SILWitnessTable::AssociatedTypeProtocolWitness{
-        cast<AssociatedTypeDecl>(MF->getDecl(assocId)), proto,
-        conformance
+        type, proto, conformance
       });
     } else if (kind == SIL_WITNESS_ASSOC_ENTRY) {
       DeclID assocId;
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
index 3a9576d..6a96a2f 100644
--- a/lib/Serialization/SILFormat.h
+++ b/lib/Serialization/SILFormat.h
@@ -200,7 +200,7 @@
 
   using WitnessAssocProtocolLayout = BCRecordLayout<
     SIL_WITNESS_ASSOC_PROTOCOL,
-    DeclIDField, // ID of AssociatedTypeDecl
+    TypeIDField, // ID of associated type
     DeclIDField  // ID of ProtocolDecl
     // Trailed by the conformance itself if appropriate.
   >;
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index 85f57eb..aba6f0f 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -1318,6 +1318,10 @@
                                               numInheritedConformances,
                                               data);
 
+  // Write requirement signature conformances.
+  for (auto reqConformance : conformance->getSignatureConformances())
+    writeConformance(reqConformance, DeclTypeAbbrCodes);
+  
   // Write inherited conformances.
   for (auto inheritedProto : inheritedProtos) {
     writeConformance(conformance->getInheritedConformance(inheritedProto),
@@ -3287,7 +3291,7 @@
 
 #ifndef NDEBUG
     if (auto sig = boxTy->getLayout()->getGenericSignature()) {
-      assert(sig->getAllDependentTypes().size()
+      assert(sig->getSubstitutionListSize()
                == boxTy->getGenericArgs().size());
     }
 #endif
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
index 5e60637..465d0cb 100644
--- a/lib/Serialization/SerializeSIL.cpp
+++ b/lib/Serialization/SerializeSIL.cpp
@@ -1057,6 +1057,7 @@
   case ValueKind::LoadWeakInst:
   case ValueKind::MarkUninitializedInst:
   case ValueKind::FixLifetimeInst:
+  case ValueKind::EndLifetimeInst:
   case ValueKind::CopyBlockInst:
   case ValueKind::StrongPinInst:
   case ValueKind::StrongReleaseInst:
@@ -1068,6 +1069,7 @@
   case ValueKind::IsUniqueInst:
   case ValueKind::IsUniqueOrPinnedInst:
   case ValueKind::ReturnInst:
+  case ValueKind::UncheckedOwnershipConversionInst:
   case ValueKind::ThrowInst: {
     unsigned Attr = 0;
     if (auto *LI = dyn_cast<LoadInst>(&SI))
@@ -1082,6 +1084,9 @@
       Attr = (unsigned)DRI->canAllocOnStack();
     else if (auto *RCI = dyn_cast<RefCountingInst>(&SI))
       Attr = RCI->isNonAtomic();
+    else if (auto *UOCI = dyn_cast<UncheckedOwnershipConversionInst>(&SI)) {
+      Attr = unsigned(SILValue(UOCI).getOwnershipKind());
+    }
     writeOneOperandLayout(SI.getKind(), Attr, SI.getOperand(0));
     break;
   }
@@ -1851,7 +1856,7 @@
       WitnessAssocProtocolLayout::emitRecord(
         Out, ScratchRecord,
         SILAbbrCodes[WitnessAssocProtocolLayout::Code],
-        S.addDeclRef(assoc.Requirement),
+        S.addTypeRef(assoc.Requirement),
         S.addDeclRef(assoc.Protocol));
           
       S.writeConformance(assoc.Witness, SILAbbrCodes);
diff --git a/lib/SwiftDemangle/SwiftDemangle.cpp b/lib/SwiftDemangle/SwiftDemangle.cpp
index 8c53031..c21fe7b 100644
--- a/lib/SwiftDemangle/SwiftDemangle.cpp
+++ b/lib/SwiftDemangle/SwiftDemangle.cpp
@@ -54,6 +54,13 @@
                                                  Length, Opts);
 }
 
+int swift_demangle_hasSwiftCallingConvention(const char *MangledName) {
+  swift::Demangle::Context DCtx;
+  if (DCtx.hasSwiftCallingConvention(llvm::StringRef(MangledName)))
+    return 1;
+  return 0;
+}
+
 size_t fnd_get_demangled_name(const char *MangledName, char *OutputBuffer,
                               size_t Length) {
   return swift_demangle_getDemangledName(MangledName, OutputBuffer, Length);
diff --git a/lib/Syntax/DeclSyntax.cpp b/lib/Syntax/DeclSyntax.cpp
index c26d20e..7160508 100644
--- a/lib/Syntax/DeclSyntax.cpp
+++ b/lib/Syntax/DeclSyntax.cpp
@@ -11,8 +11,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Syntax/DeclSyntax.h"
+#include "swift/Syntax/ExprSyntax.h"
+#include "swift/Syntax/GenericSyntax.h"
 #include "swift/Syntax/RawSyntax.h"
+#include "swift/Syntax/StmtSyntax.h"
 #include "swift/Syntax/SyntaxFactory.h"
+#include "swift/Syntax/TypeSyntax.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -31,6 +35,101 @@
 DeclSyntax::DeclSyntax(const RC<SyntaxData> Root, const DeclSyntaxData *Data)
   : Syntax(Root, Data) {}
 
+#pragma mark - declaration-modifier Data
+
+DeclModifierSyntaxData::
+DeclModifierSyntaxData(const RC<RawSyntax> Raw,
+                       const SyntaxData *Parent,
+                       const CursorIndex IndexInParent)
+  : SyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Kind == SyntaxKind::DeclModifier);
+  assert(Raw->Layout.size() == 4);
+#ifndef NDEBUG
+  auto Name =
+    cast<TokenSyntax>(Raw->getChild(DeclModifierSyntax::Cursor::Name));
+  auto Kind = Name->getTokenKind();
+  assert(Kind == tok::kw_class ||
+         Kind == tok::kw_static ||
+         Kind == tok::identifier ||
+         Kind == tok::kw_public ||
+         Kind == tok::kw_private ||
+         Kind == tok::kw_fileprivate ||
+         Kind == tok::kw_internal);
+#endif
+  syntax_assert_child_token_text(Raw, DeclModifierSyntax::Cursor::LeftParen,
+                                 tok::l_paren, "(");
+  syntax_assert_child_token(Raw, DeclModifierSyntax::Cursor::Argument,
+                           tok::identifier);
+  syntax_assert_child_token_text(Raw, DeclModifierSyntax::Cursor::RightParen,
+                                 tok::r_paren, ")");
+}
+
+RC<DeclModifierSyntaxData>
+DeclModifierSyntaxData::make(const RC<RawSyntax> Raw,
+                             const SyntaxData *Parent,
+                             const CursorIndex IndexInParent) {
+  return RC<DeclModifierSyntaxData>{
+    new DeclModifierSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<DeclModifierSyntaxData> DeclModifierSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::DeclModifier,
+                             {
+                               TokenSyntax::missingToken(tok::identifier, ""),
+                               TokenSyntax::missingToken(tok::l_paren, "("),
+                               TokenSyntax::missingToken(tok::identifier, ""),
+                               TokenSyntax::missingToken(tok::r_paren, ")"),
+                             },
+                             SourcePresence::Present);
+  return make(Raw);
+}
+
+#pragma mark - declaration-modifier API
+
+RC<TokenSyntax> DeclModifierSyntax::getName() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Name));
+}
+
+DeclModifierSyntax DeclModifierSyntax::withName(RC<TokenSyntax> NewName) const {
+  assert(NewName->getTokenKind() == tok::identifier);
+  return Data->replaceChild<DeclModifierSyntax>(NewName, Cursor::Name);
+}
+
+RC<TokenSyntax> DeclModifierSyntax::getLeftParenToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::LeftParen));
+}
+
+DeclModifierSyntax
+DeclModifierSyntax::withLeftParenToken(RC<TokenSyntax> NewLeftParen) const {
+  syntax_assert_token_is(NewLeftParen, tok::l_paren, "(");
+  return Data->replaceChild<DeclModifierSyntax>(NewLeftParen,
+                                                Cursor::LeftParen);
+}
+
+RC<TokenSyntax> DeclModifierSyntax::getArgument() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Argument));
+}
+
+DeclModifierSyntax
+DeclModifierSyntax::withArgument(RC<TokenSyntax> NewArgument) const {
+  assert(NewArgument->getTokenKind() == tok::identifier);
+  return Data->replaceChild<DeclModifierSyntax>(NewArgument, Cursor::Argument);
+}
+
+RC<TokenSyntax> DeclModifierSyntax::getRightParenToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::RightParen));
+}
+
+DeclModifierSyntax
+DeclModifierSyntax::withRightParenToken(RC<TokenSyntax> NewRightParen) const {
+  syntax_assert_token_is(NewRightParen, tok::r_paren, ")");
+  return Data->replaceChild<DeclModifierSyntax>(NewRightParen,
+                                                Cursor::RightParen);
+}
+
 #pragma mark - unknown-statement Data
 
 UnknownDeclSyntaxData::UnknownDeclSyntaxData(RC<RawSyntax> Raw,
@@ -364,3 +463,573 @@
   auto Data = TypeAliasDeclSyntaxData::make(Raw);
   return { Data, Data.get() };
 }
+
+#pragma mark - function-parameter Data
+
+FunctionParameterSyntaxData::FunctionParameterSyntaxData(RC<RawSyntax> Raw,
+                            const SyntaxData *Parent,
+                            CursorIndex IndexInParent)
+  : SyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Layout.size() == 8);
+  syntax_assert_child_token(Raw, FunctionParameterSyntax::Cursor::ExternalName,
+                            tok::identifier);
+  syntax_assert_child_token(Raw, FunctionParameterSyntax::Cursor::LocalName,
+                            tok::identifier);
+  syntax_assert_child_token_text(Raw, FunctionParameterSyntax::Cursor::Colon,
+                                 tok::colon, ":");
+  assert(Raw->getChild(FunctionParameterSyntax::Cursor::Type)->isType());
+  syntax_assert_child_token_text(Raw, FunctionParameterSyntax::Cursor::Ellipsis,
+                                 tok::identifier, "...");
+  syntax_assert_child_token_text(Raw,
+                                 FunctionParameterSyntax::Cursor::DefaultEqual,
+                                 tok::equal, "=");
+  assert(Raw->getChild(
+    FunctionParameterSyntax::Cursor::DefaultExpression)->isExpr());
+  syntax_assert_child_token_text(Raw,
+                                 FunctionParameterSyntax::Cursor::TrailingComma,
+                                 tok::comma, ",");
+}
+
+RC<FunctionParameterSyntaxData>
+FunctionParameterSyntaxData::make(RC<RawSyntax> Raw, const SyntaxData *Parent,
+     CursorIndex IndexInParent) {
+  return RC<FunctionParameterSyntaxData> {
+    new FunctionParameterSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<FunctionParameterSyntaxData> FunctionParameterSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionParameter,
+  {
+    TokenSyntax::missingToken(tok::identifier, ""),
+    TokenSyntax::missingToken(tok::identifier, ""),
+    TokenSyntax::missingToken(tok::colon, ":"),
+    RawSyntax::missing(SyntaxKind::MissingType),
+    TokenSyntax::missingToken(tok::identifier, "..."),
+    TokenSyntax::missingToken(tok::equal, "="),
+    RawSyntax::missing(SyntaxKind::MissingExpr),
+    TokenSyntax::missingToken(tok::comma, ","),
+  },
+  SourcePresence::Present);
+  return make(Raw);
+}
+
+
+#pragma mark - function-parameter API
+
+RC<TokenSyntax> FunctionParameterSyntax::getExternalName() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::ExternalName));
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withExternalName(RC<TokenSyntax> NewExternalName) const {
+  assert(NewExternalName->getTokenKind() == tok::identifier);
+  return Data->replaceChild<FunctionParameterSyntax>(NewExternalName,
+                                                     Cursor::ExternalName);
+}
+
+RC<TokenSyntax> FunctionParameterSyntax::getLocalName() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::LocalName));
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withLocalName(RC<TokenSyntax> NewLocalName) const {
+  assert(NewLocalName->getTokenKind() == tok::identifier);
+  return Data->replaceChild<FunctionParameterSyntax>(NewLocalName,
+                                                     Cursor::LocalName);
+}
+
+RC<TokenSyntax> FunctionParameterSyntax::getColonToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Colon));
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withColonToken(RC<TokenSyntax> NewColonToken) const {
+  syntax_assert_token_is(NewColonToken, tok::colon, ":");
+  return Data->replaceChild<FunctionParameterSyntax>(NewColonToken,
+                                                     Cursor::Colon);
+}
+
+llvm::Optional<TypeSyntax> FunctionParameterSyntax::getTypeSyntax() const {
+  auto RawType = getRaw()->getChild(Cursor::Type);
+  if (RawType->isMissing()) {
+    return llvm::None;
+  }
+
+  auto *MyData = getUnsafeData<FunctionParameterSyntax>();
+
+  if (MyData->CachedTypeSyntax) {
+    return TypeSyntax { Root, MyData->CachedTypeSyntax.get() };
+  }
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedTypeSyntax);
+
+  SyntaxData::realizeSyntaxNode<TypeSyntax>(ChildPtr, RawType, MyData,
+                                            cursorIndex(Cursor::Type));
+
+  return TypeSyntax { Root, MyData->CachedTypeSyntax.get() };
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withTypeSyntax(llvm::Optional<TypeSyntax> NewType) const {
+  if (!NewType.hasValue()) {
+    auto RawType = RawSyntax::missing(SyntaxKind::MissingType);
+    return Data->replaceChild<FunctionParameterSyntax>(RawType, Cursor::Type);
+  }
+
+  return Data->replaceChild<FunctionParameterSyntax>(
+    NewType.getValue().getRaw(), Cursor::Type);
+}
+
+RC<TokenSyntax> FunctionParameterSyntax::getEqualToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::DefaultEqual));
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withEqualToken(RC<TokenSyntax> NewEqualToken) const {
+  assert(NewEqualToken->getTokenKind() == tok::equal);
+  return Data->replaceChild<FunctionParameterSyntax>(NewEqualToken,
+                                                     Cursor::DefaultEqual);
+}
+
+llvm::Optional<ExprSyntax> FunctionParameterSyntax::getDefaultValue() const {
+    auto RawExpr = getRaw()->getChild(Cursor::DefaultExpression);
+    if (RawExpr->isMissing()) {
+      return llvm::None;
+    }
+
+    auto *MyData = getUnsafeData<FunctionParameterSyntax>();
+
+    if (MyData->CachedTypeSyntax) {
+      return ExprSyntax { Root, MyData->CachedDefaultValue.get() };
+    }
+
+    auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+      &MyData->CachedDefaultValue);
+
+    SyntaxData::realizeSyntaxNode<TypeSyntax>(ChildPtr, RawExpr, MyData,
+      cursorIndex(Cursor::DefaultExpression));
+    
+    return ExprSyntax { Root, MyData->CachedDefaultValue.get() };
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withDefaultValue(llvm::Optional<ExprSyntax> NewDefaultValue) const {
+  if (!NewDefaultValue.hasValue()) {
+    auto RawType = RawSyntax::missing(SyntaxKind::MissingExpr);
+    return Data->replaceChild<FunctionParameterSyntax>(RawType,
+      Cursor::DefaultExpression);
+  }
+
+  return Data->replaceChild<FunctionParameterSyntax>(
+    NewDefaultValue.getValue().getRaw(), Cursor::DefaultExpression);
+}
+
+RC<TokenSyntax> FunctionParameterSyntax::getTrailingComma() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::TrailingComma));
+}
+
+FunctionParameterSyntax FunctionParameterSyntax::
+withTrailingComma(RC<TokenSyntax> NewTrailingComma) const {
+  syntax_assert_token_is(NewTrailingComma, tok::comma, ",");
+  return Data->replaceChild<FunctionParameterSyntax>(NewTrailingComma,
+                                                     Cursor::TrailingComma);
+}
+
+#pragma mark - function-signature Data
+
+FunctionSignatureSyntaxData::
+FunctionSignatureSyntaxData(const RC<RawSyntax> Raw,
+                            const SyntaxData *Parent,
+                            const CursorIndex IndexInParent)
+  : SyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Layout.size() == 7);
+  syntax_assert_child_token_text(Raw,
+                                 FunctionSignatureSyntax::Cursor::LeftParen,
+                                 tok::l_paren, "(");
+
+  assert(Raw->getChild(FunctionSignatureSyntax::Cursor::ParameterList)->Kind ==
+         SyntaxKind::FunctionParameterList);
+
+  syntax_assert_child_token_text(Raw,
+                                 FunctionSignatureSyntax::Cursor::RightParen,
+                                 tok::r_paren, ")");
+#ifndef NDEBUG
+  auto ThrowsRethrows = cast<TokenSyntax>(
+    Raw->getChild(FunctionSignatureSyntax::Cursor::ThrowsOrRethrows));
+  assert(cast<TokenSyntax>(ThrowsRethrows)->getTokenKind() == tok::kw_throws ||
+         cast<TokenSyntax>(ThrowsRethrows)->getTokenKind() == tok::kw_rethrows);
+#endif
+  syntax_assert_child_token_text(Raw, FunctionSignatureSyntax::Cursor::Arrow,
+                                 tok::arrow, "->");
+  syntax_assert_child_kind(Raw,
+    FunctionSignatureSyntax::Cursor::ReturnTypeAttributes,
+    SyntaxKind::TypeAttributes);
+  assert(Raw->getChild(FunctionSignatureSyntax::Cursor::ReturnType)->isType());
+}
+
+RC<FunctionSignatureSyntaxData>
+FunctionSignatureSyntaxData::make(RC<RawSyntax> Raw, const SyntaxData *Parent,
+                                  CursorIndex IndexInParent) {
+  return RC<FunctionSignatureSyntaxData> {
+    new FunctionSignatureSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<FunctionSignatureSyntaxData> FunctionSignatureSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionSignature,
+  {
+    TokenSyntax::missingToken(tok::l_paren, "("),
+    RawSyntax::missing(SyntaxKind::FunctionParameterList),
+    TokenSyntax::missingToken(tok::r_paren, ")"),
+    TokenSyntax::missingToken(tok::kw_throws, "throws"),
+    TokenSyntax::missingToken(tok::arrow, "->"),
+    RawSyntax::missing(SyntaxKind::TypeAttributes),
+    RawSyntax::missing(SyntaxKind::MissingType),
+  },
+  SourcePresence::Present);
+  return make(Raw);
+}
+
+#pragma mark - function-signature API
+
+RC<TokenSyntax> FunctionSignatureSyntax::getLeftParenToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::LeftParen));
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withLeftParenToken(RC<TokenSyntax> NewLeftParen) const {
+  syntax_assert_token_is(NewLeftParen, tok::l_paren, "(");
+  return Data->replaceChild<FunctionSignatureSyntax>(NewLeftParen,
+                                                     Cursor::LeftParen);
+}
+
+FunctionParameterListSyntax FunctionSignatureSyntax::getParameterList() const {
+  auto RawList = getRaw()->getChild(Cursor::ParameterList);
+
+  auto *MyData = getUnsafeData<FunctionSignatureSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedParameterList);
+
+  SyntaxData::realizeSyntaxNode<FunctionParameterListSyntax>(ChildPtr, RawList,
+    MyData, cursorIndex(Cursor::ParameterList));
+  
+  return FunctionParameterListSyntax {
+    Root,
+    MyData->CachedParameterList.get()
+  };
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withParameterList(FunctionParameterListSyntax NewParameterList) const {
+  return Data->replaceChild<FunctionSignatureSyntax>(NewParameterList.getRaw(),
+                                                     Cursor::ParameterList);
+}
+
+RC<TokenSyntax> FunctionSignatureSyntax::getRightParenToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::RightParen));
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withRightParenToken(RC<TokenSyntax> NewRightParen) const {
+  syntax_assert_token_is(NewRightParen, tok::r_paren, ")");
+  return Data->replaceChild<FunctionSignatureSyntax>(NewRightParen,
+                                                     Cursor::RightParen);
+}
+
+RC<TokenSyntax> FunctionSignatureSyntax::getThrowsToken() const {
+  auto Throw = cast<TokenSyntax>(getRaw()->getChild(Cursor::ThrowsOrRethrows));
+  if (Throw->getTokenKind() != tok::kw_throws) {
+    return TokenSyntax::missingToken(tok::kw_throws, "throws");
+  }
+  return Throw;
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withThrowsToken(RC<TokenSyntax> NewThrowsToken) const {
+  syntax_assert_token_is(NewThrowsToken, tok::kw_throws, "throws");
+  return Data->replaceChild<FunctionSignatureSyntax>(NewThrowsToken,
+                                                     Cursor::ThrowsOrRethrows);
+}
+
+RC<TokenSyntax> FunctionSignatureSyntax::getRethrowsToken() const {
+  auto Rethrow = cast<TokenSyntax>(
+    getRaw()->getChild(Cursor::ThrowsOrRethrows));
+  if (Rethrow->getTokenKind() != tok::kw_rethrows) {
+    return TokenSyntax::missingToken(tok::kw_rethrows, "rethrows");
+  }
+  return Rethrow;
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withRethrowsToken(RC<TokenSyntax> NewRethrowsToken) const {
+  syntax_assert_token_is(NewRethrowsToken, tok::kw_rethrows, "rethrows");
+  return Data->replaceChild<FunctionSignatureSyntax>(NewRethrowsToken,
+                                                     Cursor::ThrowsOrRethrows);
+}
+
+RC<TokenSyntax> FunctionSignatureSyntax::getArrowToken() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Arrow));
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withArrowToken(RC<TokenSyntax> NewArrowToken) const {
+  syntax_assert_token_is(NewArrowToken, tok::arrow, "->");
+  return Data->replaceChild<FunctionSignatureSyntax>(NewArrowToken,
+                                                     Cursor::Arrow);
+}
+
+TypeAttributesSyntax FunctionSignatureSyntax::getReturnTypeAttributes() const {
+  auto RawAttrs = getRaw()->getChild(Cursor::ReturnTypeAttributes);
+
+  auto *MyData = getUnsafeData<FunctionSignatureSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedReturnTypeAttributes);
+
+  SyntaxData::realizeSyntaxNode<TypeAttributesSyntax>(ChildPtr, RawAttrs,
+    MyData, cursorIndex(Cursor::ReturnTypeAttributes));
+
+  return TypeAttributesSyntax {
+    Root,
+    MyData->CachedReturnTypeAttributes.get()
+  };
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withReturnTypeAttributes(TypeAttributesSyntax NewAttributes) const {
+  return Data->replaceChild<FunctionSignatureSyntax>(NewAttributes.getRaw(),
+    Cursor::ReturnTypeAttributes);
+}
+
+TypeSyntax FunctionSignatureSyntax::getReturnTypeSyntax() const {
+  auto RawType = getRaw()->getChild(Cursor::ReturnType);
+
+  auto *MyData = getUnsafeData<FunctionSignatureSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedReturnTypeSyntax);
+
+  SyntaxData::realizeSyntaxNode<TypeSyntax>(ChildPtr, RawType,
+    MyData, cursorIndex(Cursor::ReturnType));
+
+  return TypeSyntax {
+    Root,
+    MyData->CachedReturnTypeSyntax.get()
+  };
+}
+
+FunctionSignatureSyntax FunctionSignatureSyntax::
+withReturnTypeSyntax(TypeSyntax NewReturnTypeSyntax) const {
+  return Data->replaceChild<FunctionSignatureSyntax>(
+    NewReturnTypeSyntax.getRaw(), Cursor::ReturnType);
+}
+
+#pragma mark - function-declaration-data
+
+FunctionDeclSyntaxData::
+FunctionDeclSyntaxData(const RC<RawSyntax> Raw,
+                       const SyntaxData *Parent,
+                       const CursorIndex IndexInParent)
+  : SyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Kind == SyntaxKind::FunctionDecl);
+  assert(Raw->Layout.size() == 8);
+  syntax_assert_child_kind(Raw, FunctionDeclSyntax::Cursor::Attributes,
+                           SyntaxKind::TypeAttributes);
+  syntax_assert_child_kind(Raw, FunctionDeclSyntax::Cursor::Modifiers,
+                           SyntaxKind::DeclModifierList);
+  syntax_assert_child_token_text(Raw, FunctionDeclSyntax::Cursor::FuncKeyword,
+                                 tok::kw_func, "func");
+  syntax_assert_child_token(Raw, FunctionDeclSyntax::Cursor::Identifier,
+                            tok::identifier);
+  syntax_assert_child_kind(Raw,
+                           FunctionDeclSyntax::Cursor::GenericParameterClause,
+                           SyntaxKind::GenericParameterClause);
+  syntax_assert_child_kind(Raw, FunctionDeclSyntax::Cursor::Signature,
+                           SyntaxKind::FunctionSignature);
+  syntax_assert_child_kind(Raw, FunctionDeclSyntax::Cursor::GenericWhereClause,
+                           SyntaxKind::GenericWhereClause);
+  syntax_assert_child_kind(Raw, FunctionDeclSyntax::Cursor::Body,
+                           SyntaxKind::CodeBlockStmt);
+}
+
+RC<FunctionDeclSyntaxData> FunctionDeclSyntaxData::make(const RC<RawSyntax> Raw,
+                                       const SyntaxData *Parent,
+                                       const CursorIndex IndexInParent) {
+  return RC<FunctionDeclSyntaxData> {
+    new FunctionDeclSyntaxData {
+      Raw, Parent, IndexInParent
+    }
+  };
+}
+
+RC<FunctionDeclSyntaxData> FunctionDeclSyntaxData::makeBlank() {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionDecl,
+    {
+      RawSyntax::missing(SyntaxKind::TypeAttributes),
+      RawSyntax::missing(SyntaxKind::DeclModifierList),
+      TokenSyntax::missingToken(tok::kw_func, "func"),
+      TokenSyntax::missingToken(tok::identifier, ""),
+      RawSyntax::missing(SyntaxKind::GenericParameterClause),
+      RawSyntax::missing(SyntaxKind::FunctionSignature),
+      RawSyntax::missing(SyntaxKind::GenericWhereClause),
+      RawSyntax::missing(SyntaxKind::CodeBlockStmt),
+    },
+    SourcePresence::Present);
+  return make(Raw);
+}
+
+#pragma mark - function-declaration-API
+
+TypeAttributesSyntax FunctionDeclSyntax::getAttributes() const {
+  auto RawAttrs = getRaw()->getChild(Cursor::Attributes);
+
+  auto *MyData = getUnsafeData<FunctionDeclSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedAttributes);
+
+  SyntaxData::realizeSyntaxNode<ExprSyntax>(ChildPtr, RawAttrs, MyData,
+                                            cursorIndex(Cursor::Attributes));
+  
+  return { Root, MyData->CachedAttributes.get() };
+}
+
+FunctionDeclSyntax
+FunctionDeclSyntax::withAttributes(TypeAttributesSyntax NewAttributes) const {
+  return Data->replaceChild<FunctionDeclSyntax>(NewAttributes.getRaw(),
+                                                Cursor::Attributes);
+}
+
+DeclModifierListSyntax FunctionDeclSyntax::getModifiers() const {
+  auto RawModifiers = getRaw()->getChild(Cursor::Attributes);
+
+  auto *MyData = getUnsafeData<FunctionDeclSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedModifiers);
+
+  SyntaxData::realizeSyntaxNode<DeclModifierListSyntax>(ChildPtr, RawModifiers,
+    MyData, cursorIndex(Cursor::Modifiers));
+  
+  return { Root, MyData->CachedModifiers.get() };
+}
+
+FunctionDeclSyntax
+FunctionDeclSyntax::withModifiers(DeclModifierListSyntax NewModifiers) const {
+  return Data->replaceChild<FunctionDeclSyntax>(NewModifiers.getRaw(),
+                                                Cursor::Modifiers);
+}
+
+RC<TokenSyntax> FunctionDeclSyntax::getFuncKeyword() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::FuncKeyword));
+}
+
+FunctionDeclSyntax
+FunctionDeclSyntax::withFuncKeyword(RC<TokenSyntax> NewFuncKeyword) const {
+  syntax_assert_token_is(NewFuncKeyword, tok::kw_func, "func");
+  return Data->replaceChild<FunctionDeclSyntax>(NewFuncKeyword,
+                                                Cursor::FuncKeyword);
+
+}
+
+RC<TokenSyntax> FunctionDeclSyntax::getIdentifier() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::Identifier));
+}
+
+FunctionDeclSyntax
+FunctionDeclSyntax::withIdentifier(RC<TokenSyntax> NewIdentifier) const {
+  assert(NewIdentifier->getTokenKind() == tok::identifier);
+  return Data->replaceChild<FunctionDeclSyntax>(NewIdentifier,
+                                                Cursor::Identifier);
+}
+
+llvm::Optional<GenericParameterClauseSyntax>
+FunctionDeclSyntax::getGenericParameterClause() const {
+  auto RawGenericParams = getRaw()->getChild(Cursor::Attributes);
+  if (RawGenericParams->isMissing()) {
+    return llvm::None;
+  }
+
+  auto *MyData = getUnsafeData<FunctionDeclSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedGenericParams);
+
+  SyntaxData::realizeSyntaxNode<DeclModifierListSyntax>(ChildPtr,
+    RawGenericParams, MyData, cursorIndex(Cursor::GenericParameterClause));
+
+  GenericParameterClauseSyntax Params {
+    Root,
+    MyData->CachedGenericParams.get()
+  };
+  
+  return Params;
+}
+
+FunctionDeclSyntax FunctionDeclSyntax::withGenericParameterClause(
+    llvm::Optional<GenericParameterClauseSyntax> NewGenericParams) const {
+  auto RawParams = NewGenericParams.hasValue()
+    ? NewGenericParams->getRaw()
+    : SyntaxFactory::makeBlankGenericParameterClause().getRaw();
+  return Data->replaceChild<FunctionDeclSyntax>(RawParams,
+                                                Cursor::GenericParameterClause);
+
+}
+
+FunctionSignatureSyntax FunctionDeclSyntax::getSignature() const {
+  auto RawSig = getRaw()->getChild(Cursor::Attributes);
+
+  auto *MyData = getUnsafeData<FunctionDeclSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedSignature);
+
+  SyntaxData::realizeSyntaxNode<FunctionSignatureSyntax>(ChildPtr, RawSig,
+    MyData, cursorIndex(Cursor::Signature));
+
+  return { Root, MyData->CachedSignature.get() };
+}
+
+FunctionDeclSyntax
+FunctionDeclSyntax::withSignature(FunctionSignatureSyntax NewSignature) const {
+  return Data->replaceChild<FunctionDeclSyntax>(NewSignature.getRaw(),
+                                                Cursor::Signature);
+}
+
+llvm::Optional<CodeBlockStmtSyntax> FunctionDeclSyntax::getBody() const {
+  auto RawBody = getRaw()->getChild(Cursor::Body);
+  if (RawBody->isMissing()) {
+    return llvm::None;
+  }
+
+  auto *MyData = getUnsafeData<FunctionDeclSyntax>();
+
+  auto &ChildPtr = *reinterpret_cast<std::atomic<uintptr_t>*>(
+    &MyData->CachedBody);
+
+  SyntaxData::realizeSyntaxNode<CodeBlockStmtSyntax>(ChildPtr,
+    RawBody, MyData, cursorIndex(Cursor::Body));
+  
+  CodeBlockStmtSyntax Body {
+    Root,
+    MyData->CachedBody.get()
+  };
+  
+  return Body;
+}
+
+FunctionDeclSyntax FunctionDeclSyntax::
+withBody(llvm::Optional<CodeBlockStmtSyntax> NewBody) const {
+  auto RawBody = NewBody.hasValue()
+    ? NewBody->getRaw()
+    : SyntaxFactory::makeBlankCodeBlock().getRaw();
+  return Data->replaceChild<FunctionDeclSyntax>(RawBody,
+                                                Cursor::Body);
+}
diff --git a/lib/Syntax/ExprSyntax.cpp b/lib/Syntax/ExprSyntax.cpp
index b7d8be9..9a59dd4 100644
--- a/lib/Syntax/ExprSyntax.cpp
+++ b/lib/Syntax/ExprSyntax.cpp
@@ -301,80 +301,12 @@
     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);
-}
+  : SyntaxCollection(Root, Data) {}
 
 #pragma mark - function-call-expression Data
 
diff --git a/lib/Syntax/GenericSyntax.cpp b/lib/Syntax/GenericSyntax.cpp
index e48e33a..99a72d8 100644
--- a/lib/Syntax/GenericSyntax.cpp
+++ b/lib/Syntax/GenericSyntax.cpp
@@ -27,7 +27,7 @@
 ConformanceRequirementSyntaxData(RC<RawSyntax> Raw,
                                  const SyntaxData *Parent,
                                  CursorIndex IndexInParent)
-  : SyntaxData(Raw, Parent, IndexInParent) {
+  : GenericRequirementSyntaxData(Raw, Parent, IndexInParent) {
   assert(Raw->Kind == SyntaxKind::ConformanceRequirement);
   syntax_assert_child_kind(Raw,
     ConformanceRequirementSyntax::Cursor::LeftTypeIdentifier,
@@ -149,9 +149,9 @@
 }
 
 RC<GenericParameterClauseSyntaxData>
-GenericParameterClauseSyntaxData::make(RC<RawSyntax> Raw,
+GenericParameterClauseSyntaxData::make(const RC<RawSyntax> Raw,
                                        const SyntaxData *Parent,
-                                       CursorIndex IndexInParent) {
+                                       const CursorIndex IndexInParent) {
   return RC<GenericParameterClauseSyntaxData> {
     new GenericParameterClauseSyntaxData {
       Raw, Parent, IndexInParent,
@@ -173,7 +173,7 @@
 #pragma mark - generic-parameter-clause API
 
 GenericParameterClauseSyntax::
-GenericParameterClauseSyntax(RC<SyntaxData> Root,
+GenericParameterClauseSyntax(const RC<SyntaxData> Root,
                              const GenericParameterClauseSyntaxData *Data)
   : Syntax(Root, Data) {}
 
@@ -226,52 +226,24 @@
   return { Data, Data.get() };
 }
 
-#pragma mark - generic-requirement-list Data
-
-GenericRequirementListSyntaxData::
-GenericRequirementListSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent,
-                                 CursorIndex IndexInParent)
-  : SyntaxData(Raw, Parent, IndexInParent) {
-  assert(Raw->Kind == SyntaxKind::GenericRequirementList);
-}
-
-RC<GenericRequirementListSyntaxData>
-GenericRequirementListSyntaxData::make(RC<RawSyntax> Raw,
-                                       const SyntaxData *Parent,
-                                       CursorIndex IndexInParent) {
-  return RC<GenericRequirementListSyntaxData> {
-    new GenericRequirementListSyntaxData {
-      Raw, Parent, IndexInParent
-    }
-  };
-}
-
-RC<GenericRequirementListSyntaxData>
-GenericRequirementListSyntaxData::makeBlank() {
-  auto Raw = RawSyntax::make(SyntaxKind::GenericRequirementList,
-                             {},
-                             SourcePresence::Present);
-  return make(Raw);
-}
-
 #pragma mark - generic-where-clause Data
 
 GenericWhereClauseSyntaxData::
-GenericWhereClauseSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent,
-                             CursorIndex IndexInParent)
+GenericWhereClauseSyntaxData(const RC<RawSyntax> Raw, const SyntaxData *Parent,
+                             const CursorIndex IndexInParent)
   : SyntaxData(Raw, Parent, IndexInParent) {
   assert(Raw->Kind == SyntaxKind::GenericWhereClause);
   syntax_assert_child_token_text(Raw,
-    GenericWhereClauseSyntax::Cursor::WhereToken, tok::kw_where, "where");
+    GenericWhereClauseSyntax::Cursor::WhereKeyword, tok::kw_where, "where");
   syntax_assert_child_kind(Raw,
     GenericWhereClauseSyntax::Cursor::RequirementList,
     SyntaxKind::GenericRequirementList);
 }
 
 RC<GenericWhereClauseSyntaxData>
-GenericWhereClauseSyntaxData::make(RC<RawSyntax> Raw,
+GenericWhereClauseSyntaxData::make(const RC<RawSyntax> Raw,
                                    const SyntaxData *Parent,
-                                   CursorIndex IndexInParent) {
+                                   const CursorIndex IndexInParent) {
   return RC<GenericWhereClauseSyntaxData> {
     new GenericWhereClauseSyntaxData { Raw, Parent, IndexInParent }
   };
@@ -293,20 +265,34 @@
                          const GenericWhereClauseSyntaxData *Data)
   : Syntax(Root, Data) {}
 
+GenericWhereClauseSyntax GenericWhereClauseSyntax::
+withWhereKeyword(RC<TokenSyntax> NewWhereKeyword) const {
+  syntax_assert_token_is(NewWhereKeyword, tok::kw_where, "where");
+  return Data->replaceChild<GenericWhereClauseSyntax>(NewWhereKeyword,
+                                                      Cursor::WhereKeyword);
+}
+
+GenericWhereClauseSyntax GenericWhereClauseSyntax::
+withRequirementList(GenericRequirementListSyntax NewRequirements) const {
+  return Data->replaceChild<GenericWhereClauseSyntax>(NewRequirements.getRaw(),
+                                                      Cursor::RequirementList);
+}
+
 #pragma mark - same-type-requirement Data
 
 SameTypeRequirementSyntaxData::
 SameTypeRequirementSyntaxData(RC<RawSyntax> Raw,
                               const SyntaxData *Parent,
                               CursorIndex IndexInParent)
-  : SyntaxData(Raw, Parent, IndexInParent) {
+  : GenericRequirementSyntaxData(Raw, Parent, IndexInParent) {
   assert(Raw->Kind == SyntaxKind::SameTypeRequirement);
   assert(Raw->Layout.size() == 3);
   syntax_assert_child_kind(Raw,
     SameTypeRequirementSyntax::Cursor::LeftTypeIdentifier,
     SyntaxKind::TypeIdentifier);
   syntax_assert_child_token_text(Raw,
-    SameTypeRequirementSyntax::Cursor::EqualityToken, tok::identifier, "==");
+    SameTypeRequirementSyntax::Cursor::EqualityToken,
+    tok::oper_binary_spaced, "==");
   assert(Raw->getChild(SameTypeRequirementSyntax::Cursor::RightType)->isType());
 }
 
diff --git a/lib/Syntax/LegacyASTTransformer.cpp b/lib/Syntax/LegacyASTTransformer.cpp
index 4356df0..2337447 100644
--- a/lib/Syntax/LegacyASTTransformer.cpp
+++ b/lib/Syntax/LegacyASTTransformer.cpp
@@ -443,11 +443,11 @@
                     BufferID, Tokens)
     : TokenSyntax::missingToken(tok::l_brace, "{");
 
-  StmtListSyntaxBuilder StmtsBuilder;
+  std::vector<StmtSyntax> Stmts;
   for (auto Node : S->getElements()) {
     auto Transformed = transformAST(Node, Sema, SourceMgr, BufferID, Tokens);
     if (Transformed.hasValue()) {
-      StmtsBuilder.addStatement(Transformed.getValue());
+      Stmts.push_back(Transformed.getValue().castTo<StmtSyntax>());
     }
   }
 
@@ -456,8 +456,9 @@
                     BufferID, Tokens)
     : TokenSyntax::missingToken(tok::r_brace, "}");
 
-  return SyntaxFactory::makeCodeBlock(LeftBrace, StmtsBuilder.build(),
-                                      RightBrace).Root;
+  auto StmtList = SyntaxFactory::makeStmtList(Stmts);
+
+  return SyntaxFactory::makeCodeBlock(LeftBrace, StmtList, RightBrace).Root;
 }
 
 RC<SyntaxData>
diff --git a/lib/Syntax/Status.md b/lib/Syntax/Status.md
index 1c8a324..a2ed705 100644
--- a/lib/Syntax/Status.md
+++ b/lib/Syntax/Status.md
@@ -16,6 +16,12 @@
 
 ### Declarations
 
+- declaration-modifiers
+  - `DeclModifierListSyntax`
+
+- declaration-modifier
+  - `DeclModifierSyntax`
+
 - struct-declaration
   - `StructDeclSyntax`
 
@@ -40,6 +46,27 @@
   - `DeclMembersSyntax`
   - `StructDeclSyntax` used for the `{` `}` braces.
 
+- function-declaration
+  - `FunctionDeclSyntax`
+
+- function-body
+  - `CodeBlockSyntax`
+
+- function-result
+  - `TypeSyntax`
+
+- function-signature
+  - `FunctionSignatureSyntax`
+
+- parameter-clause
+  - `FunctionParameterClauseSyntax`
+
+- parameter-list
+  - `FunctionParameterListSyntax`
+
+- parameter
+  - `FunctionParameterSyntax`
+
 ### Statements
 
 - statement
@@ -209,8 +236,6 @@
 - as-pattern
 - case-condition
 - case-label
-- declaration-modifiers
-  - declaration-modifier
 - dynamic-type-expression
 - floating-point-literal
 - forced-value-expression
@@ -317,13 +342,6 @@
     - 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
diff --git a/lib/Syntax/StmtSyntax.cpp b/lib/Syntax/StmtSyntax.cpp
index 89b272c..15890b1 100644
--- a/lib/Syntax/StmtSyntax.cpp
+++ b/lib/Syntax/StmtSyntax.cpp
@@ -380,58 +380,3 @@
 CodeBlockStmtSyntax::CodeBlockStmtSyntax(const RC<SyntaxData> Root,
                                          CodeBlockStmtSyntaxData *Data)
     : StmtSyntax(Root, Data) {}
-
-
-#pragma mark statements Data
-
-StmtListSyntaxData::StmtListSyntaxData(RC<RawSyntax> Raw,
-                                       const SyntaxData *Parent,
-                                       CursorIndex IndexInParent)
-    : StmtSyntaxData(Raw, Parent, IndexInParent) {
-  assert(Raw->Kind == SyntaxKind::StmtList);
-}
-
-RC<StmtListSyntaxData> StmtListSyntaxData::make(RC<RawSyntax> Raw,
-                                                const SyntaxData *Parent,
-                                                CursorIndex IndexInParent) {
-  return RC<StmtListSyntaxData> {
-    new StmtListSyntaxData { Raw, Parent, IndexInParent }
-  };
-}
-
-RC<StmtListSyntaxData> StmtListSyntaxData::makeBlank() {
-  return make(RawSyntax::make(SyntaxKind::StmtList,
-                              {},
-                              SourcePresence::Present));
-}
-
-#pragma mark statements API
-
-StmtListSyntax::StmtListSyntax(const RC<SyntaxData> Root,
-                               const StmtListSyntaxData *Data)
-  : Syntax(Root, Data) {}
-
-StmtListSyntax
-StmtListSyntax::withAddedStatement(Syntax AdditionalStatement) const {
-  auto Layout = getRaw()->Layout;
-  Layout.push_back(AdditionalStatement.getRaw());
-  auto NewRaw = RawSyntax::make(SyntaxKind::StmtList, Layout,
-                                getRaw()->Presence);
-  return Data->replaceSelf<StmtListSyntax>(NewRaw);
-}
-
-#pragma mark statements Builder
-
-StmtListSyntaxBuilder &
-StmtListSyntaxBuilder::addStatement(Syntax Statement) {
-  StmtListLayout.push_back(Statement.getRaw());
-  return *this;
-}
-
-StmtListSyntax StmtListSyntaxBuilder::build() const {
-  auto Raw = RawSyntax::make(SyntaxKind::StmtList, StmtListLayout,
-                             SourcePresence::Present);
-  auto Data = StmtListSyntaxData::make(Raw);
-  return StmtListSyntax { Data, Data.get() };
-}
-
diff --git a/lib/Syntax/SyntaxData.cpp b/lib/Syntax/SyntaxData.cpp
index bc21dbf..06b008a 100644
--- a/lib/Syntax/SyntaxData.cpp
+++ b/lib/Syntax/SyntaxData.cpp
@@ -16,6 +16,7 @@
 #include "swift/Syntax/TypeSyntax.h"
 #include "swift/Syntax/StmtSyntax.h"
 #include "swift/Syntax/UnknownSyntax.h"
+#include "llvm/Support/ErrorHandling.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -44,6 +45,8 @@
   case SyntaxKind::Token:
     llvm_unreachable("Can't make a SyntaxData from a Token!");
   }
+
+  llvm_unreachable("Unhandled SyntaxKind in switch.");
 }
 
 bool SyntaxData::isType() const {
diff --git a/lib/Syntax/SyntaxFactory.cpp b/lib/Syntax/SyntaxFactory.cpp
index cd495f2..0350e4e 100644
--- a/lib/Syntax/SyntaxFactory.cpp
+++ b/lib/Syntax/SyntaxFactory.cpp
@@ -35,6 +35,51 @@
 
 #pragma mark - Declarations
 
+#pragma mark - declaration-modifier
+
+DeclModifierSyntax SyntaxFactory::makeDeclModifier(RC<TokenSyntax> Name,
+                                                   RC<TokenSyntax> LeftParen,
+                                                   RC<TokenSyntax> Argument,
+                                                   RC<TokenSyntax> RightParen) {
+  auto Raw = RawSyntax::make(SyntaxKind::DeclModifier,
+                             {
+                               Name,
+                               LeftParen,
+                               Argument,
+                               RightParen,
+                             },
+                             SourcePresence::Present);
+  auto Data = DeclModifierSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+DeclModifierSyntax SyntaxFactory::makeBlankDeclModifier() {
+  auto Data = DeclModifierSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
+#pragma mark - declaration-modifier-list
+
+DeclModifierListSyntax SyntaxFactory::
+makeDeclModifierList(const std::vector<DeclModifierSyntax> &Modifiers) {
+  RawSyntax::LayoutList Layout;
+  for (auto Modifier : Modifiers) {
+    Layout.push_back(Modifier.getRaw());
+  }
+
+  auto Raw = RawSyntax::make(SyntaxKind::DeclModifierList, Layout,
+                             SourcePresence::Present);
+  auto Data = DeclModifierListSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+DeclModifierListSyntax SyntaxFactory::makeBlankDeclModifierList() {
+  auto Data = DeclModifierListSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
+#pragma mark - struct-declaration
+
 StructDeclSyntax
 SyntaxFactory::makeStructDecl(RC<TokenSyntax> StructToken,
                               RC<TokenSyntax> Identifier,
@@ -66,6 +111,8 @@
   };
 }
 
+#pragma mark - type-alias-declaration
+
 TypeAliasDeclSyntax SyntaxFactory::makeTypealiasDecl(
     RC<TokenSyntax> TypealiasToken, RC<TokenSyntax> Identifier,
     GenericParameterClauseSyntax GenericParams, RC<TokenSyntax> AssignmentToken,
@@ -88,130 +135,128 @@
   return DeclMembersSyntax { Data, Data.get() };
 }
 
-TypeIdentifierSyntax
-SyntaxFactory::makeTypeIdentifier(OwnedString Name,
-                                  const Trivia &LeadingTrivia,
-                                  const Trivia &TrailingTrivia) {
-  auto Raw = RawSyntax::make(
-      SyntaxKind::TypeIdentifier,
-      {
-          SyntaxFactory::makeIdentifier(Name, LeadingTrivia, TrailingTrivia),
-          RawSyntax::missing(SyntaxKind::GenericArgumentClause),
-          TokenSyntax::missingToken(tok::period, "."),
-          RawSyntax::missing(SyntaxKind::TypeIdentifier),
-      },
-      SourcePresence::Present);
-  auto Data = TypeIdentifierSyntaxData::make(Raw);
-  return TypeIdentifierSyntax { Data, Data.get() };
-}
+#pragma mark - function-parameter
 
-TupleTypeElementSyntax
-SyntaxFactory::makeTupleTypeElement(TypeSyntax ElementType) {
-  auto Data = TupleTypeElementSyntaxData::makeBlank();
-  return TupleTypeElementSyntax { Data, Data.get() }
-      .withTypeSyntax(ElementType);
-}
-
-TypeIdentifierSyntax
-SyntaxFactory::makeTypeIdentifier(RC<TokenSyntax> Identifier,
-                                  GenericArgumentClauseSyntax GenericArgs) {
-  auto Raw = RawSyntax::make(SyntaxKind::TypeIdentifier,
+FunctionParameterSyntax SyntaxFactory::
+makeFunctionParameter(RC<TokenSyntax> ExternalName,
+                      RC<TokenSyntax> LocalName,
+                      RC<TokenSyntax> Colon,
+                      llvm::Optional<TypeSyntax> ParameterTypeSyntax,
+                      RC<TokenSyntax> Ellipsis,
+                      RC<TokenSyntax> Equal,
+                      llvm::Optional<ExprSyntax> DefaultValue,
+                      RC<TokenSyntax> TrailingComma) {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionParameter,
                              {
-                                 Identifier, GenericArgs.getRaw(),
-                                 TokenSyntax::missingToken(tok::period, "."),
-                                 RawSyntax::missing(SyntaxKind::TypeIdentifier),
+                               ExternalName,
+                               LocalName,
+                               Colon,
+                               ParameterTypeSyntax.hasValue()
+                                 ? ParameterTypeSyntax.getValue().getRaw()
+                                 : RawSyntax::missing(SyntaxKind::MissingType),
+                               Ellipsis,
+                               Equal,
+                               DefaultValue.hasValue()
+                                 ? DefaultValue.getValue().getRaw()
+                                 : RawSyntax::missing(SyntaxKind::MissingExpr),
+                               TrailingComma,
                              },
                              SourcePresence::Present);
-  auto Data = TypeIdentifierSyntaxData::make(Raw);
-  return TypeIdentifierSyntax { Data, Data.get() };
+  auto Data = FunctionParameterSyntaxData::make(Raw);
+  return { Data, Data.get() };
 }
 
-OptionalTypeSyntax
-SyntaxFactory::makeOptionalType(TypeSyntax BaseType,
-                                const Trivia &TrailingTrivia) {
-  auto Raw = RawSyntax::make(SyntaxKind::OptionalType,
-    {
-     BaseType.getRaw(),
-     SyntaxFactory::makeQuestionPostfixToken(TrailingTrivia),
-    },
-    SourcePresence::Present);
-
-  auto Data = OptionalTypeSyntaxData::make(Raw);
-  return OptionalTypeSyntax { Data, Data.get() };
+FunctionParameterSyntax SyntaxFactory::makeBlankFunctionParameter() {
+  auto Data = FunctionParameterSyntaxData::makeBlank();
+  return { Data, Data.get() };
 }
 
-OptionalTypeSyntax SyntaxFactory::makeBlankOptionalType() {
-  auto Data = OptionalTypeSyntaxData::makeBlank();
-  return OptionalTypeSyntax { Data, Data.get() };
+#pragma mark - function-parameter-list
+
+FunctionParameterListSyntax SyntaxFactory::makeFunctionParameterList(
+    const std::vector<FunctionParameterSyntax> &Parameters) {
+  RawSyntax::LayoutList Layout;
+  for (auto Param : Parameters) {
+    Layout.push_back(Param.getRaw());
+  }
+
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionParameterList, Layout,
+                             SourcePresence::Present);
+  auto Data = FunctionParameterListSyntaxData::make(Raw);
+  return { Data, Data.get() };
 }
 
-ImplicitlyUnwrappedOptionalTypeSyntax
-SyntaxFactory::makeImplicitlyUnwrappedOptionalType(
-    TypeSyntax BaseType, const Trivia &TrailingTrivia) {
-  auto Raw = RawSyntax::make(SyntaxKind::ImplicitlyUnwrappedOptionalType,
-    {
-        BaseType.getRaw(), SyntaxFactory::makeExclaimPostfixToken(
-                           TrailingTrivia),
-    },
-    SourcePresence::Present);
-  auto Data = ImplicitlyUnwrappedOptionalTypeSyntaxData::make(Raw);
-  return ImplicitlyUnwrappedOptionalTypeSyntax { Data, Data.get() };
+FunctionParameterListSyntax SyntaxFactory::makeBlankFunctionParameterList() {
+  auto Data = FunctionParameterListSyntaxData::makeBlank();
+  return { Data, Data.get() };
 }
 
-ImplicitlyUnwrappedOptionalTypeSyntax
-SyntaxFactory::makeBlankImplicitlyUnwrappedOptionalType() {
-  auto Data = ImplicitlyUnwrappedOptionalTypeSyntaxData::makeBlank();
-  return ImplicitlyUnwrappedOptionalTypeSyntax { Data, Data.get() };
-}
+#pragma mark - function-signature
 
-MetatypeTypeSyntax SyntaxFactory::makeMetatypeType(TypeSyntax BaseType,
-                                                   RC<TokenSyntax> DotToken,
-                                                   RC<TokenSyntax> TypeToken) {
-  auto Raw = RawSyntax::make(SyntaxKind::MetatypeType,
-                      {
-                        BaseType.getRaw(),
-                        DotToken,
-                        TypeToken
-                      },
-                      SourcePresence::Present);
-  auto Data = MetatypeTypeSyntaxData::make(Raw);
-  return MetatypeTypeSyntax { Data, Data.get() };
-}
-
-MetatypeTypeSyntax SyntaxFactory::makeBlankMetatypeType() {
-  auto Data = MetatypeTypeSyntaxData::makeBlank();
-  return MetatypeTypeSyntax { Data, Data.get() };
-}
-
-TypeIdentifierSyntax SyntaxFactory::makeAnyTypeIdentifier() {
-  auto Data = TypeIdentifierSyntaxData::makeBlank();
-  return TypeIdentifierSyntax { Data, Data.get() }
-    .withIdentifier(makeIdentifier("Any", {}, {}));
-}
-
-TypeIdentifierSyntax SyntaxFactory::makeSelfTypeIdentifier() {
-  auto Data = TypeIdentifierSyntaxData::makeBlank();
-  return TypeIdentifierSyntax { Data, Data.get() }
-    .withIdentifier(makeIdentifier("Self", {}, {}));
-}
-
-SameTypeRequirementSyntax SyntaxFactory::makeSameTypeRequirement(
-    TypeIdentifierSyntax LeftTypeIdentifier, RC<TokenSyntax> EqualityToken,
-    TypeSyntax RightType) {
-  auto Raw = RawSyntax::make(SyntaxKind::SameTypeRequirement,
+FunctionSignatureSyntax
+SyntaxFactory::makeFunctionSignature(RC<TokenSyntax> LeftParen,
+                                     FunctionParameterListSyntax ParameterList,
+                                     RC<TokenSyntax> RightParen,
+                                     RC<TokenSyntax> ThrowsOrRethrows,
+                                     RC<TokenSyntax> Arrow,
+                                     TypeAttributesSyntax ReturnTypeAttributes,
+                                     TypeSyntax ReturnTypeSyntax) {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionSignature,
                              {
-                               LeftTypeIdentifier.getRaw(),
-                               EqualityToken,
-                               RightType.getRaw()
+                               LeftParen,
+                               ParameterList.getRaw(),
+                               RightParen,
+                               ThrowsOrRethrows,
+                               Arrow,
+                               ReturnTypeAttributes.getRaw(),
+                               ReturnTypeSyntax.getRaw()
                              },
                              SourcePresence::Present);
-  auto Data = SameTypeRequirementSyntaxData::make(Raw);
-  return SameTypeRequirementSyntax { Data, Data.get() };
+  auto Data = FunctionSignatureSyntaxData::make(Raw);
+  return { Data, Data.get() };
 }
 
-SameTypeRequirementSyntax SyntaxFactory::makeBlankSameTypeRequirement() {
-  auto Data = SameTypeRequirementSyntaxData::makeBlank();
-  return SameTypeRequirementSyntax { Data, Data.get() };
+FunctionSignatureSyntax SyntaxFactory::makeBlankFunctionSignature() {
+  auto Data = FunctionSignatureSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
+#pragma mark - function-declaration
+
+FunctionDeclSyntax SyntaxFactory::
+makeFunctionDecl(TypeAttributesSyntax Attributes,
+                 DeclModifierListSyntax Modifiers,
+                 RC<TokenSyntax> FuncKeyword,
+                 RC<TokenSyntax> Identifier,
+                 llvm::Optional<GenericParameterClauseSyntax> GenericParams,
+                 FunctionSignatureSyntax Signature,
+                 llvm::Optional<GenericWhereClauseSyntax> GenericWhereClause,
+                 llvm::Optional<CodeBlockStmtSyntax> Body) {
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionDecl,
+    {
+      Attributes.getRaw(),
+      Modifiers.getRaw(),
+      FuncKeyword,
+      Identifier,
+      GenericParams.hasValue()
+       ? GenericParams.getValue().getRaw()
+       : SyntaxFactory::makeBlankGenericParameterClause().getRaw(),
+      Signature.getRaw(),
+      GenericWhereClause.hasValue()
+        ? GenericWhereClause.getValue().getRaw()
+        : SyntaxFactory::makeBlankGenericWhereClause().getRaw(),
+      Body.hasValue()
+       ? Body.getValue().getRaw()
+       : SyntaxFactory::makeBlankCodeBlock().getRaw()
+    },
+    SourcePresence::Present);
+  auto Data = FunctionDeclSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+FunctionDeclSyntax SyntaxFactory::makeBlankFunctionDecl() {
+  auto Data = FunctionDeclSyntaxData::makeBlank();
+  return { Data, Data.get() };
 }
 
 #pragma mark - Statements
@@ -323,6 +368,27 @@
   return { Data, Data.get() };
 }
 
+/// Make a statement list from a loosely connected list of statements.
+StmtListSyntax
+SyntaxFactory::makeStmtList(const std::vector<StmtSyntax> &Statements) {
+  RawSyntax::LayoutList Layout;
+  for (auto Stmt : Statements) {
+    Layout.push_back(Stmt.getRaw());
+  }
+
+  auto Raw = RawSyntax::make(SyntaxKind::StmtList, Layout,
+                             SourcePresence::Present);
+  auto Data = StmtListSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+/// Make an empty statement list.
+StmtListSyntax SyntaxFactory::makeBlankStmtList() {
+  auto Raw = RawSyntax::make(SyntaxKind::StmtList, {}, SourcePresence::Present);
+  auto Data = StmtListSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
 #pragma mark - Expressions
 
 #pragma mark - integer-literal-expression
@@ -446,10 +512,33 @@
   return { Data, Data.get() };
 }
 
-
 #pragma mark - Tokens
 
 RC<TokenSyntax>
+SyntaxFactory::makeStaticKeyword(const Trivia &LeadingTrivia,
+                                 const Trivia &TrailingTrivia) {
+  return TokenSyntax::make(tok::kw_static, "static",
+                           SourcePresence::Present,
+                           LeadingTrivia, TrailingTrivia);
+}
+
+RC<TokenSyntax>
+SyntaxFactory::makePublicKeyword(const Trivia &LeadingTrivia,
+                                 const Trivia &TrailingTrivia) {
+  return TokenSyntax::make(tok::kw_public, "public",
+                           SourcePresence::Present,
+                           LeadingTrivia, TrailingTrivia);
+}
+
+RC<TokenSyntax>
+SyntaxFactory::makeFuncKeyword(const Trivia &LeadingTrivia,
+                                      const Trivia &TrailingTrivia) {
+  return TokenSyntax::make(tok::kw_func, "func",
+                           SourcePresence::Present,
+                           LeadingTrivia, TrailingTrivia);
+}
+
+RC<TokenSyntax>
 SyntaxFactory::makeFallthroughKeyword(const Trivia &LeadingTrivia,
                                       const Trivia &TrailingTrivia) {
   return TokenSyntax::make(tok::kw_fallthrough, "fallthrough",
@@ -514,6 +603,19 @@
   return TokenSyntax::make(tok::r_paren, ")", SourcePresence::Present,
                            LeadingTrivia, TrailingTrivia);
 }
+RC<TokenSyntax>
+SyntaxFactory::makeLeftBraceToken(const Trivia &LeadingTrivia,
+                                  const Trivia &TrailingTrivia) {
+  return TokenSyntax::make(tok::l_brace, "{", SourcePresence::Present,
+                           LeadingTrivia, TrailingTrivia);
+}
+
+RC<TokenSyntax>
+SyntaxFactory::makeRightBraceToken(const Trivia &LeadingTrivia,
+                                   const Trivia &TrailingTrivia) {
+  return TokenSyntax::make(tok::r_brace, "}", SourcePresence::Present,
+                           LeadingTrivia, TrailingTrivia);
+}
 
 RC<TokenSyntax>
 SyntaxFactory::makeLeftSquareBracketToken(const Trivia &LeadingTrivia,
@@ -731,30 +833,6 @@
   };
 }
 
-TupleTypeSyntax SyntaxFactory::makeVoidTupleType() {
-  auto Raw = RawSyntax::make(SyntaxKind::TupleType,
-    {
-        SyntaxFactory::makeLeftParenToken({}, {}),
-        RawSyntax::missing(SyntaxKind::TypeArgumentList),
-        SyntaxFactory::makeRightParenToken({}, {}),
-    },
-    SourcePresence::Present);
-  auto Data = TupleTypeSyntaxData::make(std::move(Raw));
-  return TupleTypeSyntax {
-    Data, Data.get()
-  };
-}
-
-TupleTypeElementSyntax
-SyntaxFactory::makeTupleTypeElement(RC<TokenSyntax> Name,
-                                    TypeSyntax ElementTypeSyntax) {
-  auto Data = TupleTypeElementSyntaxData::makeBlank();
-  return TupleTypeElementSyntax { Data, Data.get() }
-    .withLabel(Name)
-    .withColonToken(SyntaxFactory::makeColonToken({}, Trivia::spaces(1)))
-    .withTypeSyntax(ElementTypeSyntax);
-}
-
 #pragma mark - Generics
 
 GenericParameterClauseSyntax
@@ -791,48 +869,41 @@
   return GenericParameterSyntax { Data, Data.get() };
 }
 
-ArrayTypeSyntax
-SyntaxFactory::makeArrayType(RC<TokenSyntax> LeftSquareBracket,
-                             TypeSyntax ElementType,
-                             RC<TokenSyntax> RightSquareBracket) {
-  auto Raw = RawSyntax::make(SyntaxKind::ArrayType,
+SameTypeRequirementSyntax SyntaxFactory::
+makeSameTypeRequirement( TypeIdentifierSyntax LeftTypeIdentifier,
+                        RC<TokenSyntax> EqualityToken,
+                        TypeSyntax RightType) {
+  auto Raw = RawSyntax::make(SyntaxKind::SameTypeRequirement,
                              {
-                               LeftSquareBracket,
-                               ElementType.getRaw(),
-                               RightSquareBracket
+                               LeftTypeIdentifier.getRaw(),
+                               EqualityToken,
+                               RightType.getRaw()
                              },
                              SourcePresence::Present);
-  auto Data = ArrayTypeSyntaxData::make(Raw);
-  return ArrayTypeSyntax { Data, Data.get() };
+  auto Data = SameTypeRequirementSyntaxData::make(Raw);
+  return SameTypeRequirementSyntax { Data, Data.get() };
 }
 
-ArrayTypeSyntax SyntaxFactory::makeBlankArrayType() {
-  auto Data = ArrayTypeSyntaxData::makeBlank();
-  return ArrayTypeSyntax { Data, Data.get() };
+SameTypeRequirementSyntax SyntaxFactory::makeBlankSameTypeRequirement() {
+  auto Data = SameTypeRequirementSyntaxData::makeBlank();
+  return SameTypeRequirementSyntax { Data, Data.get() };
 }
 
-DictionaryTypeSyntax
-SyntaxFactory::makeDictionaryType(RC<TokenSyntax> LeftSquareBracket,
-                                  TypeSyntax KeyType,
-                                  RC<TokenSyntax> Colon,
-                                  TypeSyntax ValueType,
-                                  RC<TokenSyntax> RightSquareBracket) {
-  auto Raw = RawSyntax::make(SyntaxKind::DictionaryType,
-                             {
-                               LeftSquareBracket,
-                               KeyType.getRaw(),
-                               Colon,
-                               ValueType.getRaw(),
-                               RightSquareBracket
-                             },
+GenericRequirementListSyntax SyntaxFactory::
+makeGenericRequirementList(std::vector<GenericRequirementSyntax> &Requirements){
+  RawSyntax::LayoutList Layout;
+  for (auto Req : Requirements) {
+    Layout.push_back(Req.getRaw());
+  }
+  auto Raw = RawSyntax::make(SyntaxKind::GenericRequirementList, Layout,
                              SourcePresence::Present);
-  auto Data = DictionaryTypeSyntaxData::make(Raw);
-  return DictionaryTypeSyntax { Data, Data.get() };
+  auto Data = GenericRequirementListSyntaxData::make(Raw);
+  return { Data, Data.get() };
 }
 
-DictionaryTypeSyntax SyntaxFactory::makeBlankDictionaryType() {
-  auto Data = DictionaryTypeSyntaxData::makeBlank();
-  return DictionaryTypeSyntax { Data, Data.get() };
+GenericRequirementListSyntax SyntaxFactory::makeBlankGenericRequirementList() {
+  auto Data = GenericRequirementListSyntaxData::makeBlank();
+  return { Data, Data.get() };
 }
 
 #pragma mark - Operators
@@ -891,6 +962,148 @@
   return BalancedTokensSyntax { Data, Data.get() };
 }
 
+#pragma mark - type-identifier
+
+TypeIdentifierSyntax
+SyntaxFactory::makeTypeIdentifier(OwnedString Name,
+                                  const Trivia &LeadingTrivia,
+                                  const Trivia &TrailingTrivia) {
+  auto Raw = RawSyntax::make(
+                             SyntaxKind::TypeIdentifier,
+                             {
+                               SyntaxFactory::makeIdentifier(Name, LeadingTrivia, TrailingTrivia),
+                               RawSyntax::missing(SyntaxKind::GenericArgumentClause),
+                               TokenSyntax::missingToken(tok::period, "."),
+                               RawSyntax::missing(SyntaxKind::TypeIdentifier),
+                             },
+                             SourcePresence::Present);
+  auto Data = TypeIdentifierSyntaxData::make(Raw);
+  return TypeIdentifierSyntax { Data, Data.get() };
+}
+
+TypeIdentifierSyntax SyntaxFactory::makeAnyTypeIdentifier() {
+  auto Data = TypeIdentifierSyntaxData::makeBlank();
+  return TypeIdentifierSyntax { Data, Data.get() }
+  .withIdentifier(makeIdentifier("Any", {}, {}));
+}
+
+TypeIdentifierSyntax SyntaxFactory::makeSelfTypeIdentifier() {
+  auto Data = TypeIdentifierSyntaxData::makeBlank();
+  return TypeIdentifierSyntax { Data, Data.get() }
+  .withIdentifier(makeIdentifier("Self", {}, {}));
+}
+
+TypeIdentifierSyntax
+SyntaxFactory::makeTypeIdentifier(RC<TokenSyntax> Identifier,
+                                  GenericArgumentClauseSyntax GenericArgs) {
+  auto Raw = RawSyntax::make(SyntaxKind::TypeIdentifier,
+                             {
+                               Identifier, GenericArgs.getRaw(),
+                               TokenSyntax::missingToken(tok::period, "."),
+                               RawSyntax::missing(SyntaxKind::TypeIdentifier),
+                             },
+                             SourcePresence::Present);
+  auto Data = TypeIdentifierSyntaxData::make(Raw);
+  return TypeIdentifierSyntax { Data, Data.get() };
+}
+
+#pragma mark - tuple-type
+
+TupleTypeSyntax SyntaxFactory::makeVoidTupleType() {
+  auto Raw = RawSyntax::make(SyntaxKind::TupleType,
+    {
+      SyntaxFactory::makeLeftParenToken({}, {}),
+      RawSyntax::missing(SyntaxKind::TypeArgumentList),
+      SyntaxFactory::makeRightParenToken({}, {}),
+    },
+    SourcePresence::Present);
+  auto Data = TupleTypeSyntaxData::make(std::move(Raw));
+  return TupleTypeSyntax {
+    Data, Data.get()
+  };
+}
+
+TupleTypeElementSyntax
+SyntaxFactory::makeTupleTypeElement(RC<TokenSyntax> Name,
+                                    TypeSyntax ElementTypeSyntax) {
+  auto Data = TupleTypeElementSyntaxData::makeBlank();
+  return TupleTypeElementSyntax { Data, Data.get() }
+    .withLabel(Name)
+    .withColonToken(SyntaxFactory::makeColonToken({}, Trivia::spaces(1)))
+    .withTypeSyntax(ElementTypeSyntax);
+}
+
+
+TupleTypeElementSyntax
+SyntaxFactory::makeTupleTypeElement(TypeSyntax ElementType) {
+  auto Data = TupleTypeElementSyntaxData::makeBlank();
+  return TupleTypeElementSyntax { Data, Data.get() }
+  .withTypeSyntax(ElementType);
+}
+
+#pragma mark - optional-type
+
+OptionalTypeSyntax
+SyntaxFactory::makeOptionalType(TypeSyntax BaseType,
+                                const Trivia &TrailingTrivia) {
+  auto Raw = RawSyntax::make(SyntaxKind::OptionalType,
+  {
+    BaseType.getRaw(),
+    SyntaxFactory::makeQuestionPostfixToken(TrailingTrivia),
+  },
+  SourcePresence::Present);
+
+  auto Data = OptionalTypeSyntaxData::make(Raw);
+  return OptionalTypeSyntax { Data, Data.get() };
+}
+
+OptionalTypeSyntax SyntaxFactory::makeBlankOptionalType() {
+  auto Data = OptionalTypeSyntaxData::makeBlank();
+  return OptionalTypeSyntax { Data, Data.get() };
+}
+
+#pragma mark - implicitly-unwrapped-optional-type
+
+ImplicitlyUnwrappedOptionalTypeSyntax SyntaxFactory::
+makeImplicitlyUnwrappedOptionalType(TypeSyntax BaseType,
+                                    const Trivia &TrailingTrivia) {
+  auto Raw = RawSyntax::make(SyntaxKind::ImplicitlyUnwrappedOptionalType,
+    {
+      BaseType.getRaw(),
+      SyntaxFactory::makeExclaimPostfixToken(TrailingTrivia),
+    },
+    SourcePresence::Present);
+  auto Data = ImplicitlyUnwrappedOptionalTypeSyntaxData::make(Raw);
+  return ImplicitlyUnwrappedOptionalTypeSyntax { Data, Data.get() };
+}
+
+ImplicitlyUnwrappedOptionalTypeSyntax
+SyntaxFactory::makeBlankImplicitlyUnwrappedOptionalType() {
+  auto Data = ImplicitlyUnwrappedOptionalTypeSyntaxData::makeBlank();
+  return ImplicitlyUnwrappedOptionalTypeSyntax { Data, Data.get() };
+}
+
+#pragma mark - metatype-type
+
+MetatypeTypeSyntax SyntaxFactory::makeMetatypeType(TypeSyntax BaseType,
+                                                   RC<TokenSyntax> DotToken,
+                                                   RC<TokenSyntax> TypeToken) {
+  auto Raw = RawSyntax::make(SyntaxKind::MetatypeType,
+                             {
+                               BaseType.getRaw(),
+                               DotToken,
+                               TypeToken
+                             },
+                             SourcePresence::Present);
+  auto Data = MetatypeTypeSyntaxData::make(Raw);
+  return MetatypeTypeSyntax { Data, Data.get() };
+}
+
+MetatypeTypeSyntax SyntaxFactory::makeBlankMetatypeType() {
+  auto Data = MetatypeTypeSyntaxData::makeBlank();
+  return MetatypeTypeSyntax { Data, Data.get() };
+}
+
 #pragma mark - function-type
 
 FunctionTypeSyntax SyntaxFactory::makeFunctionType(
@@ -919,8 +1132,7 @@
   return FunctionTypeSyntax { Data, Data.get() };
 }
 
-#pragma mark -
-#pragma mark function-type-argument
+#pragma mark - function-type-argument
 
 FunctionTypeArgumentSyntax SyntaxFactory::
 makeFunctionTypeArgument(RC<TokenSyntax> ExternalParameterName,
@@ -986,3 +1198,53 @@
   auto Data =  TypeArgumentListSyntaxData::makeBlank();
   return TypeArgumentListSyntax { Data, Data.get() };
 }
+
+#pragma mark - array-type
+
+ArrayTypeSyntax
+SyntaxFactory::makeArrayType(RC<TokenSyntax> LeftSquareBracket,
+                             TypeSyntax ElementType,
+                             RC<TokenSyntax> RightSquareBracket) {
+  auto Raw = RawSyntax::make(SyntaxKind::ArrayType,
+                             {
+                               LeftSquareBracket,
+                               ElementType.getRaw(),
+                               RightSquareBracket
+                             },
+                             SourcePresence::Present);
+  auto Data = ArrayTypeSyntaxData::make(Raw);
+  return ArrayTypeSyntax { Data, Data.get() };
+}
+
+ArrayTypeSyntax SyntaxFactory::makeBlankArrayType() {
+  auto Data = ArrayTypeSyntaxData::makeBlank();
+  return ArrayTypeSyntax { Data, Data.get() };
+}
+
+#pragma mark - dictionary-type
+
+DictionaryTypeSyntax
+SyntaxFactory::makeDictionaryType(RC<TokenSyntax> LeftSquareBracket,
+                                  TypeSyntax KeyType,
+                                  RC<TokenSyntax> Colon,
+                                  TypeSyntax ValueType,
+                                  RC<TokenSyntax> RightSquareBracket) {
+  auto Raw = RawSyntax::make(SyntaxKind::DictionaryType,
+                             {
+                               LeftSquareBracket,
+                               KeyType.getRaw(),
+                               Colon,
+                               ValueType.getRaw(),
+                               RightSquareBracket
+                             },
+                             SourcePresence::Present);
+  auto Data = DictionaryTypeSyntaxData::make(Raw);
+  return DictionaryTypeSyntax { Data, Data.get() };
+}
+
+DictionaryTypeSyntax SyntaxFactory::makeBlankDictionaryType() {
+  auto Data = DictionaryTypeSyntaxData::makeBlank();
+  return DictionaryTypeSyntax { Data, Data.get() };
+}
+
+
diff --git a/stdlib/CMakeLists.txt b/stdlib/CMakeLists.txt
index 4ad01ab..5c24007 100644
--- a/stdlib/CMakeLists.txt
+++ b/stdlib/CMakeLists.txt
@@ -28,6 +28,14 @@
   append("-fno-sanitize=all" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
+# Do not enforce checks for LLVM's ABI-breaking build settings.
+# The Swift runtime uses some header-only code from LLVM's ADT classes,
+# but we do not want to link libSupport into the runtime. These checks rely
+# on the presence of symbols in libSupport to identify how the code was
+# built and cause link failures for mismatches. Without linking that library,
+# we get link failures regardless, so instead, this just disables the checks.
+append("-DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
 set(SWIFT_STDLIB_LIBRARY_BUILD_TYPES)
 if(SWIFT_BUILD_DYNAMIC_STDLIB)
   list(APPEND SWIFT_STDLIB_LIBRARY_BUILD_TYPES SHARED)
diff --git a/stdlib/public/SwiftShims/HeapObject.h b/stdlib/public/SwiftShims/HeapObject.h
index 4762d02..d9bf257 100644
--- a/stdlib/public/SwiftShims/HeapObject.h
+++ b/stdlib/public/SwiftShims/HeapObject.h
@@ -31,7 +31,7 @@
 // The members of the HeapObject header that are not shared by a
 // standard Objective-C instance
 #define SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS       \
-  InlineRefCounts refCounts;
+  InlineRefCounts refCounts
 
 /// The Swift heap-object header.
 struct HeapObject {
diff --git a/stdlib/public/SwiftShims/LibcShims.h b/stdlib/public/SwiftShims/LibcShims.h
index 4164231..aebd6a2 100644
--- a/stdlib/public/SwiftShims/LibcShims.h
+++ b/stdlib/public/SwiftShims/LibcShims.h
@@ -91,35 +91,35 @@
 _swift_stdlib_cxx11_mt19937_uniform(__swift_uint32_t upper_bound);
 
 // Math library functions
-static inline __attribute__((always_inline))
+static inline SWIFT_ALWAYS_INLINE
 float _swift_stdlib_remainderf(float _self, float _other) {
   return __builtin_remainderf(_self, _other);
 }
   
-static inline __attribute__((always_inline))
+static inline SWIFT_ALWAYS_INLINE
 float _swift_stdlib_squareRootf(float _self) {
   return __builtin_sqrt(_self);
 }
 
-static inline __attribute__((always_inline))
+static inline SWIFT_ALWAYS_INLINE
 double _swift_stdlib_remainder(double _self, double _other) {
   return __builtin_remainder(_self, _other);
 }
 
-static inline __attribute__((always_inline))
+static inline SWIFT_ALWAYS_INLINE
 double _swift_stdlib_squareRoot(double _self) {
   return __builtin_sqrt(_self);
 }
 
 // TODO: Remove horrible workaround when importer does Float80 <-> long double.
 #if (defined __i386__ || defined __x86_64__) && !defined _MSC_VER
-static inline __attribute__((always_inline))
+static inline SWIFT_ALWAYS_INLINE
 void _swift_stdlib_remainderl(void *_self, const void *_other) {
   long double *_f80self = (long double *)_self;
   *_f80self = __builtin_remainderl(*_f80self, *(const long double *)_other);
 }
 
-static inline __attribute__((always_inline))
+static inline SWIFT_ALWAYS_INLINE
 void _swift_stdlib_squareRootl(void *_self) {
   long double *_f80self = (long double *)_self;
   *_f80self = __builtin_sqrtl(*_f80self);
@@ -135,4 +135,3 @@
 #endif
 
 #endif // SWIFT_STDLIB_SHIMS_LIBCSHIMS_H
-
diff --git a/stdlib/public/SwiftShims/RefCount.h b/stdlib/public/SwiftShims/RefCount.h
index 95f102b..0b3b2b7 100644
--- a/stdlib/public/SwiftShims/RefCount.h
+++ b/stdlib/public/SwiftShims/RefCount.h
@@ -12,6 +12,8 @@
 #ifndef SWIFT_STDLIB_SHIMS_REFCOUNT_H
 #define SWIFT_STDLIB_SHIMS_REFCOUNT_H
 
+#include "Visibility.h"
+
 #if !defined(__cplusplus)
 
 // These definitions are placeholders for importing into Swift.
@@ -20,7 +22,7 @@
 #include "SwiftStdint.h"
 
 typedef struct {
-  __swift_uint64_t refCounts __attribute__((__unavailable__));
+  __swift_uint64_t refCounts SWIFT_ATTRIBUTE_UNAVAILABLE;
 } InlineRefCounts;
 
 // not __cplusplus
@@ -191,10 +193,9 @@
 }
 
 // FIXME: HACK: copied from HeapObject.cpp
-extern "C" LLVM_LIBRARY_VISIBILITY void
-_swift_release_dealloc(swift::HeapObject *object)
-  SWIFT_CC(RegisterPreservingCC_IMPL)
-    __attribute__((__noinline__, __used__));
+extern "C" LLVM_LIBRARY_VISIBILITY LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
+void _swift_release_dealloc(swift::HeapObject *object)
+SWIFT_CC(RegisterPreservingCC_IMPL);
 
 namespace swift {
 
diff --git a/stdlib/public/SwiftShims/UnicodeShims.h b/stdlib/public/SwiftShims/UnicodeShims.h
index c8c99d8..93253d9 100644
--- a/stdlib/public/SwiftShims/UnicodeShims.h
+++ b/stdlib/public/SwiftShims/UnicodeShims.h
@@ -63,21 +63,21 @@
 _swift_stdlib_ExtendedGraphemeClusterNoBoundaryRulesMatrix;
 
 SWIFT_RUNTIME_STDLIB_INTERFACE
-__attribute__((__pure__)) __swift_int32_t
+SWIFT_READONLY __swift_int32_t
 _swift_stdlib_unicode_compare_utf16_utf16(const __swift_uint16_t *Left,
                                           __swift_int32_t LeftLength,
                                           const __swift_uint16_t *Right,
                                           __swift_int32_t RightLength);
 
 SWIFT_RUNTIME_STDLIB_INTERFACE
-__attribute__((__pure__)) __swift_int32_t
+SWIFT_READONLY __swift_int32_t
 _swift_stdlib_unicode_compare_utf8_utf16(const unsigned char *Left,
                                          __swift_int32_t LeftLength,
                                          const __swift_uint16_t *Right,
                                          __swift_int32_t RightLength);
 
 SWIFT_RUNTIME_STDLIB_INTERFACE
-__attribute__((__pure__)) __swift_int32_t
+SWIFT_READONLY __swift_int32_t
 _swift_stdlib_unicode_compare_utf8_utf8(const unsigned char *Left,
                                         __swift_int32_t LeftLength,
                                         const unsigned char *Right,
diff --git a/stdlib/public/SwiftShims/Visibility.h b/stdlib/public/SwiftShims/Visibility.h
index 555e369..1d36a44 100644
--- a/stdlib/public/SwiftShims/Visibility.h
+++ b/stdlib/public/SwiftShims/Visibility.h
@@ -56,6 +56,18 @@
 #define SWIFT_READNONE
 #endif
 
+#if __has_attribute(always_inline)
+#define SWIFT_ALWAYS_INLINE __attribute__((always_inline))
+#else
+#define SWIFT_ALWAYS_INLINE
+#endif
+
+#if __has_attribute(unavailable)
+#define SWIFT_ATTRIBUTE_UNAVAILABLE __attribute__((__unavailable__))
+#else
+#define SWIFT_ATTRIBUTE_UNAVAILABLE
+#endif
+
 // TODO: support using shims headers in overlays by parameterizing
 // SWIFT_RUNTIME_EXPORT on the library it's exported from, then setting
 // protected vs. default based on the current value of __SWIFT_CURRENT_DYLIB.
diff --git a/stdlib/public/core/RangeReplaceableCollection.swift.gyb b/stdlib/public/core/RangeReplaceableCollection.swift.gyb
index db2461f..ca34ad5 100644
--- a/stdlib/public/core/RangeReplaceableCollection.swift.gyb
+++ b/stdlib/public/core/RangeReplaceableCollection.swift.gyb
@@ -237,10 +237,10 @@
 /// add an empty initializer and the `replaceSubrange(_:with:)` method to your
 /// custom type. `RangeReplaceableCollection` provides default implementations
 /// of all its other methods using this initializer and method. For example,
-/// the `removeSubrange` method is implemented by calling `replaceRange` with
-/// an empty collection for the `newElements` parameter. You can override any
-/// of the protocol's required methods to provide your own custom
-/// implementation.
+/// the `removeSubrange(_:)` method is implemented by calling 
+/// `replaceSubrange(_:with:)` with an empty collection for the `newElements` 
+/// parameter. You can override any of the protocol's required methods to 
+/// provide your own custom implementation.
 public protocol RangeReplaceableCollection
   : _RangeReplaceableIndexable, Collection
 {
diff --git a/stdlib/public/runtime/MetadataImpl.h b/stdlib/public/runtime/MetadataImpl.h
index a9ca348..1de0899 100644
--- a/stdlib/public/runtime/MetadataImpl.h
+++ b/stdlib/public/runtime/MetadataImpl.h
@@ -881,6 +881,7 @@
 
   static OpaqueValue *projectBuffer(ValueBuffer *buffer, const Metadata *self) {
     auto vwtable = self->getValueWitnesses();
+    (void)vwtable;
     if (!IsKnownAllocated && vwtable->isValueInline()) {
       return reinterpret_cast<OpaqueValue*>(buffer);
     } else {
@@ -900,6 +901,7 @@
                                                        ValueBuffer *src,
                                                        const Metadata *self) {
     auto vwtable = self->getValueWitnesses();
+    (void)vwtable;
     if (!IsKnownAllocated && !vwtable->isValueInline()) {
       return Impl::initializeWithTake(reinterpret_cast<OpaqueValue*>(dest),
                                       reinterpret_cast<OpaqueValue*>(src),
diff --git a/stdlib/public/runtime/Reflection.mm b/stdlib/public/runtime/Reflection.mm
index ebeed8c..0a55a03 100644
--- a/stdlib/public/runtime/Reflection.mm
+++ b/stdlib/public/runtime/Reflection.mm
@@ -233,6 +233,8 @@
     case MetadataKind::ErrorObject:
       return "(ErrorType Object)";
   }
+
+  swift_runtime_unreachable("Unhandled MetadataKind in switch.");
 }
 
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
diff --git a/stdlib/public/stubs/OptionalBridgingHelper.mm b/stdlib/public/stubs/OptionalBridgingHelper.mm
index f0cc56a..8a71e91 100644
--- a/stdlib/public/stubs/OptionalBridgingHelper.mm
+++ b/stdlib/public/stubs/OptionalBridgingHelper.mm
@@ -36,7 +36,7 @@
 
 - (NSString*)description {
   return [NSString stringWithFormat:@"<%@ %p depth = %u>", [self class],
-                                                           self,
+                                                           (void*)self,
                                                            self->depth];
 }
 
diff --git a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h
index c44439f..6a509e5 100644
--- a/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h
+++ b/test/APINotes/Inputs/custom-frameworks/APINotesFrameworkTest.framework/Headers/Types.h
@@ -1,7 +1,7 @@
 #pragma clang assume_nonnull begin
 
 struct __attribute__((swift_name("VeryImportantCStruct"))) SomeCStruct {
-	int field;
+    int field;
 };
 
 #pragma clang assume_nonnull end
diff --git a/test/ClangImporter/objc_factory_method.swift b/test/ClangImporter/objc_factory_method.swift
index b26ff08..fb3bfc5 100644
--- a/test/ClangImporter/objc_factory_method.swift
+++ b/test/ClangImporter/objc_factory_method.swift
@@ -30,6 +30,7 @@
 }
 
 func testFactoryWithLaterIntroducedInit() {
+    // expected-note @-1 4{{add @available attribute to enclosing global function}}
   // Prefer importing more available factory initializer over less
   // less available convenience initializer
   _ = NSHavingConvenienceFactoryAndLaterConvenienceInit(flim:5)
@@ -44,22 +45,19 @@
   // available designated initializer
   _ = NSHavingConvenienceFactoryAndLaterDesignatedInit(flim:5) // expected-error {{'init(flim:)' is only available on OS X 10.52 or newer}} 
     // expected-note @-1 {{add 'if #available' version check}}
-    // expected-note @-2 {{add @available attribute to enclosing global function}}
   
   _ = NSHavingConvenienceFactoryAndLaterDesignatedInit(flam:5) // expected-error {{'init(flam:)' is only available on OS X 10.52 or newer}}
   // expected-note @-1 {{add 'if #available' version check}}  {{3-63=if #available(OSX 10.52, *) {\n      _ = NSHavingConvenienceFactoryAndLaterDesignatedInit(flam:5)\n  \} else {\n      // Fallback on earlier versions\n  \}}}
-  // expected-note @-2 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.52, *)\n}}
 
   
   // Don't prefer more available factory initializer over less
   // available designated initializer
   _ = NSHavingFactoryAndLaterConvenienceInit(flim:5) // expected-error {{'init(flim:)' is only available on OS X 10.52 or newer}} 
   // expected-note @-1 {{add 'if #available' version check}}
-  // expected-note @-2 {{add @available attribute to enclosing global function}}
+  
 
   _ = NSHavingFactoryAndLaterConvenienceInit(flam:5) // expected-error {{'init(flam:)' is only available on OS X 10.52 or newer}} 
   // expected-note @-1 {{add 'if #available' version check}}
-  // expected-note @-2 {{add @available attribute to enclosing global function}}
 
 
   // When both a convenience factory and a convenience initializer have the
diff --git a/test/Constraints/associated_types.swift b/test/Constraints/associated_types.swift
index 2436e92..6dee6f6 100644
--- a/test/Constraints/associated_types.swift
+++ b/test/Constraints/associated_types.swift
@@ -37,3 +37,75 @@
 func spoon<S: Spoon>(_ s: S) {
   let _: S.Runcee?
 }
+
+// SR-4143
+
+protocol SameTypedDefault {
+    associatedtype X
+    associatedtype Y
+    static var x: X { get }
+    static var y: Y { get }
+}
+extension SameTypedDefault where Y == X {
+    static var x: X {
+        return y
+    }
+}
+
+struct UsesSameTypedDefault: SameTypedDefault {
+    static var y: Int {
+        return 0
+    }
+}
+
+protocol XReqt {}
+protocol YReqt {}
+
+protocol SameTypedDefaultWithReqts {
+    associatedtype X: XReqt // expected-note{{}}
+    associatedtype Y: YReqt // expected-note{{}}
+    static var x: X { get }
+    static var y: Y { get }
+}
+extension SameTypedDefaultWithReqts where Y == X {
+    static var x: X {
+        return y
+    }
+}
+
+struct XYType: XReqt, YReqt {}
+struct YType: YReqt {}
+
+struct UsesSameTypedDefaultWithReqts: SameTypedDefaultWithReqts {
+    static var y: XYType { return XYType() }
+}
+
+// expected-error@+1{{does not conform}}
+struct UsesSameTypedDefaultWithoutSatisfyingReqts: SameTypedDefaultWithReqts {
+    static var y: YType { return YType() }
+}
+
+protocol SameTypedDefaultBaseWithReqts {
+    associatedtype X: XReqt // expected-note{{}}
+    static var x: X { get }
+}
+protocol SameTypedDefaultDerivedWithReqts: SameTypedDefaultBaseWithReqts {
+    associatedtype Y: YReqt
+    static var y: Y { get }
+}
+
+extension SameTypedDefaultDerivedWithReqts where Y == X {
+    static var x: X {
+        return y
+    }
+}
+
+struct UsesSameTypedDefaultDerivedWithReqts: SameTypedDefaultDerivedWithReqts {
+    static var y: XYType { return XYType() }
+}
+
+// expected-error@+1{{does not conform}}
+struct UsesSameTypedDefaultDerivedWithoutSatisfyingReqts: SameTypedDefaultDerivedWithReqts {
+    static var y: YType { return YType() }
+}
+
diff --git a/test/DebugInfo/inlined-generics.swift b/test/DebugInfo/inlined-generics.swift
index fc2c84c..3005ee3 100644
--- a/test/DebugInfo/inlined-generics.swift
+++ b/test/DebugInfo/inlined-generics.swift
@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -Xllvm -sil-inline-generics=true %s -O -emit-sil -g -o - -emit-ir | %FileCheck %s
+// RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -Xllvm -sil-inline-generics=true %s -O -g -o - -emit-ir | %FileCheck %s
 public protocol P {
   associatedtype DT1
   func getDT() -> DT1
@@ -18,3 +18,38 @@
   // T.DT1 should get substituted with S.DT1.
   // CHECK: ![[META]] = !DILocalVariable(name: "$swift.type.S.DT1"
 }
+
+
+// More complex example -- we inline an alloc_stack that references a VarDecl
+// with generic type.
+
+public protocol Q : class {
+  associatedtype T : Equatable
+
+  var old: T? { get set }
+  var new: T? { get }
+}
+
+@inline(__always)
+public func update<S : Q>(_ s: S) -> (S.T?, S.T?)? {
+  let oldValue = s.old
+  let newValue = s.new
+
+  if oldValue != newValue {
+    s.old = newValue
+    return (oldValue, newValue)
+  } else {
+    return nil
+  }
+}
+
+public class C : Q {
+  public typealias T = String
+
+  public var old: String? = nil
+  public var new: T? = nil
+}
+
+public func updateC(_ c: C) {
+  update(c)
+}
diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt
index 4edae05..17e8779 100644
--- a/test/Demangle/Inputs/manglings.txt
+++ b/test/Demangle/Inputs/manglings.txt
@@ -77,10 +77,12 @@
 _TF3foog3barSi ---> foo.bar.getter : Swift.Int
 _TF3foos3barSi ---> foo.bar.setter : Swift.Int
 _TFC3foo3bar3basfT3zimCS_3zim_T_ ---> foo.bar.bas (zim : foo.zim) -> ()
-_TToFC3foo3bar3basfT3zimCS_3zim_T_ ---> {T} @objc foo.bar.bas (zim : foo.zim) -> ()
-_TTOFSC3fooFTSdSd_Sd ---> {T} @nonobjc __C.foo (Swift.Double, Swift.Double) -> Swift.Double
-_T03foo3barC3basyAA3zimCAE_tFTo ---> {T} @objc foo.bar.bas (zim : foo.zim) -> ()
-_T0SC3fooSdSd_SdtFTO ---> {T} @nonobjc __C.foo (Swift.Double, Swift.Double) -> Swift.Double
+_TToFC3foo3bar3basfT3zimCS_3zim_T_ ---> {T:_TFC3foo3bar3basfT3zimCS_3zim_T_,C} @objc foo.bar.bas (zim : foo.zim) -> ()
+_TTOFSC3fooFTSdSd_Sd ---> {T:_TFSC3fooFTSdSd_Sd} @nonobjc __C.foo (Swift.Double, Swift.Double) -> Swift.Double
+_T03foo3barC3basyAA3zimCAE_tFTo ---> {T:_T03foo3barC3basyAA3zimCAE_tF,C} @objc foo.bar.bas (zim : foo.zim) -> ()
+_T0SC3fooSdSd_SdtFTO ---> {T:_T0SC3fooSdSd_SdtF} @nonobjc __C.foo (Swift.Double, Swift.Double) -> Swift.Double
+_S3foo3barC3basyAA3zimCAE_tFTo ---> {T:_S3foo3barC3basyAA3zimCAE_tF,C} @objc foo.bar.bas (zim : foo.zim) -> ()
+_SSC3fooSdSd_SdtFTO ---> {T:_SSC3fooSdSd_SdtF} @nonobjc __C.foo (Swift.Double, Swift.Double) -> Swift.Double
 _TTDFC3foo3bar3basfT3zimCS_3zim_T_ ---> dynamic foo.bar.bas (zim : foo.zim) -> ()
 _TFC3foo3bar3basfT3zimCS_3zim_T_ ---> foo.bar.bas (zim : foo.zim) -> ()
 _TF3foooi1pFTCS_3barVS_3bas_OS_3zim ---> foo.+ infix (foo.bar, foo.bas) -> foo.zim
@@ -94,31 +96,31 @@
 _TMmC3foo3bar ---> metaclass for foo.bar
 _TMC3foo3bar ---> type metadata for foo.bar
 _TMfC3foo3bar ---> full type metadata for foo.bar
-_TwalC3foo3bar ---> allocateBuffer value witness for foo.bar
-_TwcaC3foo3bar ---> assignWithCopy value witness for foo.bar
-_TwtaC3foo3bar ---> assignWithTake value witness for foo.bar
-_TwdeC3foo3bar ---> deallocateBuffer value witness for foo.bar
-_TwxxC3foo3bar ---> destroy value witness for foo.bar
-_TwXXC3foo3bar ---> destroyBuffer value witness for foo.bar
-_TwCPC3foo3bar ---> initializeBufferWithCopyOfBuffer value witness for foo.bar
-_TwCpC3foo3bar ---> initializeBufferWithCopy value witness for foo.bar
-_TwcpC3foo3bar ---> initializeWithCopy value witness for foo.bar
-_TwTKC3foo3bar ---> initializeBufferWithTakeOfBuffer value witness for foo.bar
-_TwTkC3foo3bar ---> initializeBufferWithTake value witness for foo.bar
-_TwtkC3foo3bar ---> initializeWithTake value witness for foo.bar
-_TwprC3foo3bar ---> projectBuffer value witness for foo.bar
+_TwalC3foo3bar ---> {C} allocateBuffer value witness for foo.bar
+_TwcaC3foo3bar ---> {C} assignWithCopy value witness for foo.bar
+_TwtaC3foo3bar ---> {C} assignWithTake value witness for foo.bar
+_TwdeC3foo3bar ---> {C} deallocateBuffer value witness for foo.bar
+_TwxxC3foo3bar ---> {C} destroy value witness for foo.bar
+_TwXXC3foo3bar ---> {C} destroyBuffer value witness for foo.bar
+_TwCPC3foo3bar ---> {C} initializeBufferWithCopyOfBuffer value witness for foo.bar
+_TwCpC3foo3bar ---> {C} initializeBufferWithCopy value witness for foo.bar
+_TwcpC3foo3bar ---> {C} initializeWithCopy value witness for foo.bar
+_TwTKC3foo3bar ---> {C} initializeBufferWithTakeOfBuffer value witness for foo.bar
+_TwTkC3foo3bar ---> {C} initializeBufferWithTake value witness for foo.bar
+_TwtkC3foo3bar ---> {C} initializeWithTake value witness for foo.bar
+_TwprC3foo3bar ---> {C} projectBuffer value witness for foo.bar
 _TWVC3foo3bar ---> value witness table for foo.bar
 _TWoFC3foo3bar3basFSiSi ---> witness table offset for foo.bar.bas (Swift.Int) -> Swift.Int
 _TWvdvC3foo3bar3basSi ---> direct field offset for foo.bar.bas : Swift.Int
 _TWvivC3foo3bar3basSi ---> indirect field offset for foo.bar.bas : Swift.Int
 _TWPC3foo3barS_8barrables ---> protocol witness table for foo.bar : foo.barrable in Swift
-_TWaC3foo3barS_8barrableS_ ---> protocol witness table accessor for foo.bar : foo.barrable in foo
-_TWlC3foo3barS0_S_8barrableS_ ---> lazy protocol witness table accessor for type foo.bar and conformance foo.bar : foo.barrable in foo
+_TWaC3foo3barS_8barrableS_ ---> {C} protocol witness table accessor for foo.bar : foo.barrable in foo
+_TWlC3foo3barS0_S_8barrableS_ ---> {C} lazy protocol witness table accessor for type foo.bar and conformance foo.bar : foo.barrable in foo
 _TWLC3foo3barS0_S_8barrableS_ ---> lazy protocol witness table cache variable for type foo.bar and conformance foo.bar : foo.barrable in foo
 _TWGC3foo3barS_8barrableS_ ---> generic protocol witness table for foo.bar : foo.barrable in foo
-_TWIC3foo3barS_8barrableS_ ---> instantiation function for generic protocol witness table for foo.bar : foo.barrable in foo
-_TWtC3foo3barS_8barrableS_4fred ---> associated type metadata accessor for fred in foo.bar : foo.barrable in foo
-_TWTC3foo3barS_8barrableS_4fredS_6thomas ---> associated type witness table accessor for fred : foo.thomas in foo.bar : foo.barrable in foo
+_TWIC3foo3barS_8barrableS_ ---> {C} instantiation function for generic protocol witness table for foo.bar : foo.barrable in foo
+_TWtC3foo3barS_8barrableS_4fred ---> {C} associated type metadata accessor for fred in foo.bar : foo.barrable in foo
+_TWTC3foo3barS_8barrableS_4fredS_6thomas ---> {C} associated type witness table accessor for fred : foo.thomas in foo.bar : foo.barrable in foo
 _TFSCg5greenVSC5Color ---> __C.green.getter : __C.Color
 _TIF1t1fFT1iSi1sSS_T_A_ ---> t.(f (i : Swift.Int, s : Swift.String) -> ()).(default argument 0)
 _TIF1t1fFT1iSi1sSS_T_A0_ ---> t.(f (i : Swift.Int, s : Swift.String) -> ()).(default argument 1)
@@ -141,7 +143,7 @@
 _TWa ---> _TWa
 _Twal ---> _Twal
 _T ---> _T
-_TTo ---> {T} _TTo
+_TTo ---> {T:_T} _TTo
 _TC ---> _TC
 _TM ---> _TM
 _TM ---> _TM
@@ -187,10 +189,10 @@
 _TTSgSi__xyz ---> _TTSgSi__xyz
 _TTSr5Si___TF4test7genericurFxx ---> generic not re-abstracted specialization <Swift.Int> of test.generic <A> (A) -> A
 _TTSrq5Si___TF4test7genericurFxx ---> generic not re-abstracted specialization <preserving fragile attribute, Swift.Int> of test.generic <A> (A) -> A
-_TPA__TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_ ---> {T} partial apply forwarder for reabstraction thunk helper from @callee_owned (@owned Swift.String, @owned Swift.String) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.String, @in Swift.String) -> (@unowned Swift.Bool)
-_TPAo__TTRGrXFo_dGSPx__dGSPx_zoPs5Error__XFo_iGSPx__iGSPx_zoPS___ ---> {T} partial apply ObjC forwarder for reabstraction thunk helper <A> from @callee_owned (@unowned Swift.UnsafePointer<A>) -> (@unowned Swift.UnsafePointer<A>, @error @owned Swift.Error) to @callee_owned (@in Swift.UnsafePointer<A>) -> (@out Swift.UnsafePointer<A>, @error @owned Swift.Error)
-_T0SSSSSbIxxxd_SSSSSbIxiid_TRTA ---> {T} partial apply forwarder for reabstraction thunk helper from @callee_owned (@owned Swift.String, @owned Swift.String) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.String, @in Swift.String) -> (@unowned Swift.Bool)
-_T0SPyxGSPyxGs5Error_pIxydzo_SPyxGSPyxGsAA_pIxirzo_lTRTa ---> {T} partial apply ObjC forwarder for reabstraction thunk helper <A> from @callee_owned (@unowned Swift.UnsafePointer<A>) -> (@unowned Swift.UnsafePointer<A>, @error @owned Swift.Error) to @callee_owned (@in Swift.UnsafePointer<A>) -> (@out Swift.UnsafePointer<A>, @error @owned Swift.Error)
+_TPA__TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_ ---> {T:_TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_} partial apply forwarder for reabstraction thunk helper from @callee_owned (@owned Swift.String, @owned Swift.String) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.String, @in Swift.String) -> (@unowned Swift.Bool)
+_TPAo__TTRGrXFo_dGSPx__dGSPx_zoPs5Error__XFo_iGSPx__iGSPx_zoPS___ ---> {T:_TTRGrXFo_dGSPx__dGSPx_zoPs5Error__XFo_iGSPx__iGSPx_zoPS___} partial apply ObjC forwarder for reabstraction thunk helper <A> from @callee_owned (@unowned Swift.UnsafePointer<A>) -> (@unowned Swift.UnsafePointer<A>, @error @owned Swift.Error) to @callee_owned (@in Swift.UnsafePointer<A>) -> (@out Swift.UnsafePointer<A>, @error @owned Swift.Error)
+_T0SSSSSbIxxxd_SSSSSbIxiid_TRTA ---> {T:_T0SSSSSbIxxxd_SSSSSbIxiid_TR} partial apply forwarder for reabstraction thunk helper from @callee_owned (@owned Swift.String, @owned Swift.String) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.String, @in Swift.String) -> (@unowned Swift.Bool)
+_T0SPyxGSPyxGs5Error_pIxydzo_SPyxGSPyxGsAA_pIxirzo_lTRTa ---> {T:_T0SPyxGSPyxGs5Error_pIxydzo_SPyxGSPyxGsAA_pIxirzo_lTR} partial apply ObjC forwarder for reabstraction thunk helper <A> from @callee_owned (@unowned Swift.UnsafePointer<A>) -> (@unowned Swift.UnsafePointer<A>, @error @owned Swift.Error) to @callee_owned (@in Swift.UnsafePointer<A>) -> (@out Swift.UnsafePointer<A>, @error @owned Swift.Error)
 _TiC4Meow5MyCls9subscriptFT1iSi_Sf ---> Meow.MyCls.subscript (i : Swift.Int) -> Swift.Float
 _TF8manglingX22egbpdajGbuEbxfgehfvwxnFT_T_ ---> mangling.ليهمابتكلموشعربي؟ () -> ()
 _TF8manglingX24ihqwcrbEcvIaIdqgAFGpqjyeFT_T_ ---> mangling.他们为什么不说中文 () -> ()
diff --git a/test/Driver/Dependencies/Inputs/only-skip-once/file1.swift b/test/Driver/Dependencies/Inputs/only-skip-once/file1.swift
new file mode 100644
index 0000000..3ebf6e5
--- /dev/null
+++ b/test/Driver/Dependencies/Inputs/only-skip-once/file1.swift
@@ -0,0 +1,3 @@
+public class Class1 {
+  public var Var1 : Int?
+}
diff --git a/test/Driver/Dependencies/Inputs/only-skip-once/file2.swift b/test/Driver/Dependencies/Inputs/only-skip-once/file2.swift
new file mode 100644
index 0000000..5b579dd
--- /dev/null
+++ b/test/Driver/Dependencies/Inputs/only-skip-once/file2.swift
@@ -0,0 +1,3 @@
+public class Class2 {
+  public var Var2c : Class1?
+}
diff --git a/test/Driver/Dependencies/Inputs/only-skip-once/main.swift b/test/Driver/Dependencies/Inputs/only-skip-once/main.swift
new file mode 100644
index 0000000..214696a
--- /dev/null
+++ b/test/Driver/Dependencies/Inputs/only-skip-once/main.swift
@@ -0,0 +1,2 @@
+var x = Class1()
+var y = Class2()
diff --git a/test/Driver/Dependencies/Inputs/only-skip-once/output-file-map.json b/test/Driver/Dependencies/Inputs/only-skip-once/output-file-map.json
new file mode 100644
index 0000000..32d28d7
--- /dev/null
+++ b/test/Driver/Dependencies/Inputs/only-skip-once/output-file-map.json
@@ -0,0 +1,23 @@
+{
+  "": {
+    "swift-dependencies": "master.swiftdeps"
+  },
+  "main.swift": {
+    "dependencies": "main.d",
+    "object": "main.o",
+    "swiftmodule": "main~partial.swiftmodule",
+    "swift-dependencies": "main.swiftdeps"
+  },
+  "file1.swift": {
+    "dependencies": "file1.d",
+    "object": "file1.o",
+    "swiftmodule": "file1~partial.swiftmodule",
+    "swift-dependencies": "file1.swiftdeps"
+  },
+  "file2.swift": {
+    "dependencies": "file2.d",
+    "object": "file2.o",
+    "swiftmodule": "file2~partial.swiftmodule",
+    "swift-dependencies": "file2.swiftdeps"
+  }
+}
diff --git a/test/Driver/Dependencies/driver-show-incremental-arguments.swift b/test/Driver/Dependencies/driver-show-incremental-arguments.swift
index 19fdb7a..3a4c37f 100644
--- a/test/Driver/Dependencies/driver-show-incremental-arguments.swift
+++ b/test/Driver/Dependencies/driver-show-incremental-arguments.swift
@@ -14,9 +14,9 @@
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-INCREMENTAL %s
 // CHECK-INCREMENTAL-NOT: Incremental compilation has been disabled
-// CHECK-INCREMENTAL: Queuing main.swift (initial)
+// CHECK-INCREMENTAL: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -g -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-ARGS-MISMATCH %s
 // CHECK-ARGS-MISMATCH: Incremental compilation has been disabled{{.*}}different arguments
-// CHECK-ARGS-MISMATCH-NOT: Queuing main.swift (initial)
+// CHECK-ARGS-MISMATCH-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
diff --git a/test/Driver/Dependencies/driver-show-incremental-conflicting-arguments.swift b/test/Driver/Dependencies/driver-show-incremental-conflicting-arguments.swift
index 8d54095..e9b2e93 100644
--- a/test/Driver/Dependencies/driver-show-incremental-conflicting-arguments.swift
+++ b/test/Driver/Dependencies/driver-show-incremental-conflicting-arguments.swift
@@ -14,18 +14,18 @@
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-INCREMENTAL %s
 // CHECK-INCREMENTAL-NOT: Incremental compilation has been disabled
-// CHECK-INCREMENTAL: Queuing main.swift (initial)
+// CHECK-INCREMENTAL: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -whole-module-optimization -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-WMO %s
 // CHECK-WMO: Incremental compilation has been disabled{{.*}}whole module optimization
-// CHECK-WMO-NOT: Queuing main.swift (initial)
+// CHECK-WMO-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -embed-bitcode -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-BITCODE %s
 // CHECK-BITCODE: Incremental compilation has been disabled{{.*}}LLVM IR bitcode
-// CHECK-BITCODE-NOT: Queuing main.swift (initial)
+// CHECK-BITCODE-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -whole-module-optimization -embed-bitcode -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-WMO-AND-BITCODE %s
 // CHECK-WMO-AND-BITCODE: Incremental compilation has been disabled{{.*}}whole module optimization
 // CHECK-WMO-AND-BITCODE-NOT: Incremental compilation has been disabled
-// CHECK-WMO-AND-BITCODE-NOT: Queuing main.swift (initial)
+// CHECK-WMO-AND-BITCODE-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
diff --git a/test/Driver/Dependencies/driver-show-incremental-inputs.swift b/test/Driver/Dependencies/driver-show-incremental-inputs.swift
index 27d3e1b..931eff9 100644
--- a/test/Driver/Dependencies/driver-show-incremental-inputs.swift
+++ b/test/Driver/Dependencies/driver-show-incremental-inputs.swift
@@ -14,10 +14,10 @@
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-INCREMENTAL %s
 // CHECK-INCREMENTAL-NOT: Incremental compilation has been disabled
-// CHECK-INCREMENTAL: Queuing main.swift (initial)
+// CHECK-INCREMENTAL: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-INPUTS-MISMATCH %s
 // CHECK-INPUTS-MISMATCH: Incremental compilation has been disabled{{.*}}inputs
 // CHECK-INPUTS-MISMATCH: ./other.swift
-// CHECK-INPUTS-MISMATCH-NOT: Queuing main.swift (initial)
+// CHECK-INPUTS-MISMATCH-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
diff --git a/test/Driver/Dependencies/driver-show-incremental-malformed.swift b/test/Driver/Dependencies/driver-show-incremental-malformed.swift
index 7885c1b..b3911ae 100644
--- a/test/Driver/Dependencies/driver-show-incremental-malformed.swift
+++ b/test/Driver/Dependencies/driver-show-incremental-malformed.swift
@@ -13,7 +13,7 @@
 // RUN: echo '{version: "'$(%swiftc_driver_plain -version | head -n1)'", inputs: {"./main.swift": [443865900, 0], "./other.swift": [443865900, 0]}}' > %t/main~buildrecord.swiftdeps
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-INCREMENTAL %s
 // CHECK-INCREMENTAL-NOT: Incremental compilation has been disabled
-// CHECK-INCREMENTAL: Queuing main.swift (initial)
+// CHECK-INCREMENTAL: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: rm %t/main~buildrecord.swiftdeps && touch %t/main~buildrecord.swiftdeps
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -g -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-MALFORMED %s
@@ -22,7 +22,7 @@
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -g -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-MALFORMED %s
 
 // CHECK-MALFORMED: Incremental compilation has been disabled{{.*}}malformed build record file
-// CHECK-MALFORMED-NOT: Queuing main.swift (initial)
+// CHECK-MALFORMED-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: echo '{version, inputs: {"./main.swift": [443865900, 0], "./other.swift": [443865900, 0]}}' > %t/main~buildrecord.swiftdeps
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -g -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-MISSING-KEY %s
@@ -31,5 +31,5 @@
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -g -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-MISSING-KEY %s
 
 // CHECK-MISSING-KEY: Incremental compilation has been disabled{{.*}}malformed build record file{{.*}}Malformed value for key
-// CHECK-MISSING-KEY-NOT: Queuing main.swift (initial)
+// CHECK-MISSING-KEY-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
diff --git a/test/Driver/Dependencies/driver-show-incremental-mutual.swift b/test/Driver/Dependencies/driver-show-incremental-mutual.swift
index b9f1765..2b8fd3b 100644
--- a/test/Driver/Dependencies/driver-show-incremental-mutual.swift
+++ b/test/Driver/Dependencies/driver-show-incremental-mutual.swift
@@ -4,14 +4,14 @@
 // RUN: touch -t 201401240005 %t/*
 
 // RUN: cd %t && %swiftc_driver -c -driver-use-frontend-path %S/Inputs/update-dependencies.py -output-file-map %t/output.json -incremental -driver-always-rebuild-dependents ./main.swift ./other.swift -module-name main -j1 -v -driver-show-incremental 2>&1 | %FileCheck -check-prefix=CHECK-FIRST %s
-// CHECK-FIRST: Queuing main.swift (initial)
+// CHECK-FIRST: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: cd %t && %swiftc_driver -c -driver-use-frontend-path %S/Inputs/update-dependencies.py -output-file-map %t/output.json -incremental -driver-always-rebuild-dependents ./main.swift ./other.swift -module-name main -j1 -v -driver-show-incremental 2>&1 | %FileCheck -check-prefix=CHECK-SECOND %s
 // CHECK-SECOND-NOT: Queuing
 
 // RUN: touch -t 201401240006 %t/other.swift
 // RUN: cd %t && %swiftc_driver -c -driver-use-frontend-path %S/Inputs/update-dependencies.py -output-file-map %t/output.json -incremental -driver-always-rebuild-dependents ./main.swift ./other.swift -module-name main -j1 -v -driver-show-incremental 2>&1 | %FileCheck -check-prefix=CHECK-THIRD %s
-// CHECK-THIRD: Queuing other.swift (initial)
-// CHECK-THIRD: Queuing main.swift because of the initial set:
+// CHECK-THIRD: Queuing (initial): {compile: other.o <= other.swift}
+// CHECK-THIRD: Queuing because of the initial set: {compile: main.o <= main.swift}
 // CHECK-THIRD-NEXT: other.swift provides top-level name 'a'
 
diff --git a/test/Driver/Dependencies/driver-show-incremental-swift-version.swift b/test/Driver/Dependencies/driver-show-incremental-swift-version.swift
index 46c401e..79d2d37 100644
--- a/test/Driver/Dependencies/driver-show-incremental-swift-version.swift
+++ b/test/Driver/Dependencies/driver-show-incremental-swift-version.swift
@@ -14,12 +14,12 @@
 // RUN: echo '{version: "'$(%swiftc_driver_plain -version | head -n1)'", inputs: {"./main.swift": [443865900, 0], "./other.swift": [443865900, 0]}}' > %t/main~buildrecord.swiftdeps
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-INCREMENTAL %s
 // CHECK-INCREMENTAL-NOT: Incremental compilation has been disabled
-// CHECK-INCREMENTAL: Queuing main.swift (initial)
+// CHECK-INCREMENTAL: Queuing (initial): {compile: main.o <= main.swift}
 
 // RUN: echo '{version: "bogus", inputs: {"./main.swift": [443865900, 0], "./other.swift": [443865900, 0]}}' > %t/main~buildrecord.swiftdeps
 // RUN: cd %t && %swiftc_driver -driver-use-frontend-path %S/Inputs/update-dependencies.py -c ./main.swift ./other.swift -module-name main -incremental -v -driver-show-incremental -output-file-map %t/output.json | %FileCheck --check-prefix CHECK-VERSION-MISMATCH %s
 // CHECK-VERSION-MISMATCH: Incremental compilation has been disabled{{.*}}compiler version mismatch
 // CHECK-VERSION-MISMATCH: Compiling with:
 // CHECK-VERSION-MISMATCH: Previously compiled with: bogus
-// CHECK-VERSION-MISMATCH-NOT: Queuing main.swift (initial)
+// CHECK-VERSION-MISMATCH-NOT: Queuing (initial): {compile: main.o <= main.swift}
 
diff --git a/test/Driver/Dependencies/only-skip-once.swift b/test/Driver/Dependencies/only-skip-once.swift
new file mode 100644
index 0000000..391e24b
--- /dev/null
+++ b/test/Driver/Dependencies/only-skip-once.swift
@@ -0,0 +1,21 @@
+// XFAIL: linux
+// RUN: rm -rf %t && cp -r %S/Inputs/only-skip-once/ %t
+// RUN: touch -t 201401240005 %t/*
+
+// RUN: cd %t && %swiftc_driver -driver-show-job-lifecycle -output-file-map %t/output-file-map.json -incremental main.swift file1.swift file2.swift -j1 2>&1 | %FileCheck -check-prefix=CHECK-INITIAL %s
+
+// CHECK-INITIAL-NOT: warning
+// CHECK-INITIAL: Job finished: {compile: main.o <= main.swift}
+// CHECK-INITIAL: Job finished: {compile: file1.o <= file1.swift}
+// CHECK-INITIAL: Job finished: {compile: file2.o <= file2.swift}
+// CHECK-INITIAL: Job finished: {link: main <= main.o file1.o file2.o}
+
+// RUN: touch -t 201401240006 %t/file2.swift
+// RUN: cd %t && %swiftc_driver -driver-show-job-lifecycle -output-file-map %t/output-file-map.json -incremental main.swift file1.swift file2.swift -j1 2>&1 | %FileCheck -check-prefix=CHECK-REBUILD %s
+
+// We should skip the main and file1 rebuilds here, but we should only note skipping them _once_
+// CHECK-REBUILD: Job finished: {compile: file2.o <= file2.swift}
+// CHECK-REBUILD: Job skipped: {compile: main.o <= main.swift}
+// CHECK-REBUILD: Job skipped: {compile: file1.o <= file1.swift}
+// CHECK-REBUILD: Job finished: {link: main <= main.o file1.o file2.o}
+// CHECK-REBUILD-NOT: Job skipped:
diff --git a/test/Driver/driver-time-compilation.swift b/test/Driver/driver-time-compilation.swift
index 198ff9b..78a7555 100644
--- a/test/Driver/driver-time-compilation.swift
+++ b/test/Driver/driver-time-compilation.swift
@@ -5,6 +5,6 @@
 // CHECK: Total Execution Time: {{[0-9]+}}.{{[0-9]+}} seconds ({{[0-9]+}}.{{[0-9]+}} wall clock)
 // CHECK: ---Wall Time---
 // CHECK: --- Name ---
-// CHECK: compile {{.*}}driver-time-compilation.swift
-// CHECK-MULTIPLE: compile {{.*}}empty.swift
+// CHECK: {compile: {{.*}}driver-time-compilation.swift}
+// CHECK-MULTIPLE: {compile: {{.*}}empty.swift}
 // CHECK: {{[0-9]+}}.{{[0-9]+}} (100.0%)  Total
diff --git a/test/Driver/swift-version-default.swift b/test/Driver/swift-version-default.swift
index 6a9ec1f..029496a 100644
--- a/test/Driver/swift-version-default.swift
+++ b/test/Driver/swift-version-default.swift
@@ -11,8 +11,26 @@
 jkl
 #endif
 
+#if swift(>=3.1)
+asdf // expected-error {{use of unresolved identifier}}
+#else
+jkl
+#endif
+
 #if swift(>=4)
 aoeu
 #else
 htn // expected-error {{use of unresolved identifier}}
 #endif
+
+#if swift(>=4.1)
+aoeu
+#else
+htn // expected-error {{use of unresolved identifier}}
+#endif
+
+#if swift(>=5)
+aoeu
+#else
+htn // expected-error {{use of unresolved identifier}}
+#endif
diff --git a/test/Driver/swift-version.swift b/test/Driver/swift-version.swift
index 06817a0..129a2be 100644
--- a/test/Driver/swift-version.swift
+++ b/test/Driver/swift-version.swift
@@ -1,4 +1,3 @@
-// RUN: %target-swiftc_driver -swift-version 3 %s
 // RUN: not %target-swiftc_driver -swift-version foo %s 2>&1 | %FileCheck --check-prefix BAD %s
 // RUN: not %target-swiftc_driver -swift-version 1 %s 2>&1 | %FileCheck --check-prefix BAD %s
 // RUN: not %target-swiftc_driver -swift-version 2 %s 2>&1 | %FileCheck --check-prefix BAD %s
@@ -9,10 +8,50 @@
 // RUN: not %target-swiftc_driver -swift-version 3.3 %s 2>&1 | %FileCheck --check-prefix FIXIT_3 %s
 // RUN: not %target-swiftc_driver -swift-version 4.3 %s 2>&1 | %FileCheck --check-prefix FIXIT_4 %s
 
+// RUN: not %target-swiftc_driver -swift-version 3 -typecheck %s 2>&1 | %FileCheck --check-prefix ERROR_3 %s
+// RUN: not %target-swiftc_driver -swift-version 4 -typecheck %s 2>&1 | %FileCheck --check-prefix ERROR_4 %s
+
 // BAD: invalid value
 // BAD: note: valid arguments to '-swift-version' are '3', '4'
 
 // FIXIT_3: use major version, as in '-swift-version 3'
 // FIXIT_4: use major version, as in '-swift-version 4'
 
-let x = 1
+
+#if swift(>=3)
+asdf
+// ERROR_3: [[@LINE-1]]:1: error: {{use of unresolved identifier}}
+// ERROR_4: [[@LINE-2]]:1: error: {{use of unresolved identifier}}
+#else
+jkl
+#endif
+
+#if swift(>=3.1)
+asdf
+// ERROR_3: [[@LINE-1]]:1: error: {{use of unresolved identifier}}
+// ERROR_4: [[@LINE-2]]:1: error: {{use of unresolved identifier}}
+#else
+jkl
+#endif
+
+#if swift(>=4)
+asdf // ERROR_4: [[@LINE]]:1: error: {{use of unresolved identifier}}
+#else
+jkl // ERROR_3: [[@LINE]]:1: error: {{use of unresolved identifier}}
+#endif
+
+#if swift(>=4.1)
+asdf
+#else
+jkl
+// ERROR_3: [[@LINE-1]]:1: error: {{use of unresolved identifier}}
+// ERROR_4: [[@LINE-2]]:1: error: {{use of unresolved identifier}}
+#endif
+
+#if swift(>=5)
+asdf
+#else
+jkl
+// ERROR_3: [[@LINE-1]]:1: error: {{use of unresolved identifier}}
+// ERROR_4: [[@LINE-2]]:1: error: {{use of unresolved identifier}}
+#endif
diff --git a/test/FixCode/fixits-switch.swift b/test/FixCode/fixits-switch.swift
index 591d5a5..7309a6a 100644
--- a/test/FixCode/fixits-switch.swift
+++ b/test/FixCode/fixits-switch.swift
@@ -33,6 +33,12 @@
   case e1(a: Int, s: Int)
   case e2(a: Int)
   case e3(a: Int)
+  case e4(_: Int)
+  case e5(_: Int, _: Int)
+  case e6(a : Int, _: Int)
+  case e7
+  case e8(a : Int, Int, Int)
+  case e9(Int, Int, Int)
 }
 
 func foo4(_ e : E2) -> Int {
diff --git a/test/FixCode/fixits-switch.swift.result b/test/FixCode/fixits-switch.swift.result
index 0b0cfcd..0e6a53e 100644
--- a/test/FixCode/fixits-switch.swift.result
+++ b/test/FixCode/fixits-switch.swift.result
@@ -38,14 +38,26 @@
   case e1(a: Int, s: Int)
   case e2(a: Int)
   case e3(a: Int)
+  case e4(_: Int)
+  case e5(_: Int, _: Int)
+  case e6(a : Int, _: Int)
+  case e7
+  case e8(a : Int, Int, Int)
+  case e9(Int, Int, Int)
 }
 
 func foo4(_ e : E2) -> Int {
   switch e {
   case .e2:
     return 1
-  case .e1: <#Code#>
-case .e3: <#Code#>
+  case .e1(let a, let s): <#Code#>
+case .e3(let a): <#Code#>
+case .e4(_): <#Code#>
+case .e5(_, _): <#Code#>
+case .e6(let a, _): <#Code#>
+case .e7: <#Code#>
+case .e8(let a, _, _): <#Code#>
+case .e9(_, _, _): <#Code#>
 }
 }
 
@@ -61,8 +73,14 @@
   switch e {
   case let .e1(x, y):
     return x + y
-  case .e2: <#Code#>
-case .e3: <#Code#>
+  case .e2(let a): <#Code#>
+case .e3(let a): <#Code#>
+case .e4(_): <#Code#>
+case .e5(_, _): <#Code#>
+case .e6(let a, _): <#Code#>
+case .e7: <#Code#>
+case .e8(let a, _, _): <#Code#>
+case .e9(_, _, _): <#Code#>
 }
 }
 
@@ -71,6 +89,11 @@
   case .e2(1): return 0
   case .e1: return 0
   case .e3: return 0
-  default: <#Code#>
+  case .e4(_): <#Code#>
+case .e5(_, _): <#Code#>
+case .e6(let a, _): <#Code#>
+case .e7: <#Code#>
+case .e8(let a, _, _): <#Code#>
+case .e9(_, _, _): <#Code#>
 }
 }
\ No newline at end of file
diff --git a/test/IRGen/Inputs/witness_table_multifile_2.swift b/test/IRGen/Inputs/witness_table_multifile_2.swift
index feaf71f..7730f0b 100644
--- a/test/IRGen/Inputs/witness_table_multifile_2.swift
+++ b/test/IRGen/Inputs/witness_table_multifile_2.swift
@@ -9,3 +9,6 @@
 }
 
 func go() -> P { return X("hello") }
+
+protocol ProtocolOnlyUsedAsAType {
+}
diff --git a/test/IRGen/witness_table_multifile.swift b/test/IRGen/witness_table_multifile.swift
index 95d727e..f5a9b4b 100644
--- a/test/IRGen/witness_table_multifile.swift
+++ b/test/IRGen/witness_table_multifile.swift
@@ -11,3 +11,9 @@
   // CHECK-NEXT: getelementptr inbounds i8*, i8** [[WITNESS_TABLE]], i32 3
   go().foo()
 }
+
+// Ensure that protocols from other files get fully validated even
+// when they're only used as types.
+func useAProtocol() -> ProtocolOnlyUsedAsAType? {
+  return nil
+}
\ No newline at end of file
diff --git a/test/Index/expressions.swift b/test/Index/expressions.swift
new file mode 100644
index 0000000..bf2c1b1
--- /dev/null
+++ b/test/Index/expressions.swift
@@ -0,0 +1,15 @@
+// RUN: %target-swift-ide-test -print-indexed-symbols -source-filename %s | %FileCheck %s
+
+protocol P1 {}
+
+// CHECK: [[@LINE+1]]:8 | struct/Swift | S1 | [[S1_USR:.*]] | Def
+struct S1 : P1 {}
+
+func test(_ o: P1?) {
+  switch o {
+  // CHECK-NOT: [[@LINE+2]]:17 | enumerator/Swift | some |
+  // CHECK: [[@LINE+1]]:17 | struct/Swift | S1 | [[S1_USR]] | Ref
+  case let s as S1:
+    test(s)
+  }
+}
diff --git a/test/Index/kinds.swift b/test/Index/kinds.swift
index 1ddd0bf..55d8d43 100644
--- a/test/Index/kinds.swift
+++ b/test/Index/kinds.swift
@@ -214,3 +214,13 @@
   @GKInspectable var gkString = "gk"
   // CHECK: [[@LINE-1]]:22 | instance-property(GKI)/Swift | gkString |
 }
+
+// CHECK: [[@LINE+1]]:7 | class/Swift | C1 | [[C1_USR:.*]] | Def | rel: 0
+class C1 {}
+// CHECK: [[@LINE+1]]:11 | type-alias/Swift | C1Alias | [[C1Alias_USR:.*]] | Def | rel: 0
+typealias C1Alias = C1
+// CHECK: [[@LINE+4]]:7 | class/Swift | SubC1 | [[SubC1_USR:.*]] | Def | rel: 0
+// CHECK: [[@LINE+3]]:15 | type-alias/Swift | C1Alias | [[C1Alias_USR]] | Ref | rel: 0
+// CHECK: [[@LINE+2]]:15 | class/Swift | C1 | [[C1_USR]] | Ref,Impl,RelBase | rel: 1
+// CHECK-NEXT: RelBase | SubC1 | [[SubC1_USR]]
+class SubC1 : C1Alias {}
diff --git a/test/Index/roles.swift b/test/Index/roles.swift
index 757a19a..be4a21b 100644
--- a/test/Index/roles.swift
+++ b/test/Index/roles.swift
@@ -134,27 +134,18 @@
   }
 }
 
-class AClass {
+class AClass { // used for references only
   var y: AStruct;
   var z: [Int]
-
   init(x: Int) {
     y = AStruct(x: x)
     self.z = [1, 2, 3]
   }
-
   subscript(index: Int) -> Int {
-    get {
-      return z[0]
-    }
-    set {
-      z[0] = newValue
-    }
+    get { return z[0] }
+    set { z[0] = newValue }
   }
-
-  func foo() -> Int {
-    return z[0]
-  }
+  func foo() -> Int { return z[0] }
 }
 
 let _ = AClass.foo
@@ -168,14 +159,29 @@
 // CHECK: [[@LINE-1]]:21 | instance-property/subscript/Swift | subscript(_:) | s:14swift_ide_test6AClassC9subscriptSiSici | Ref,Writ | rel: 0
 // CHECK: [[@LINE-2]]:21 | function/acc-set/Swift | setter:subscript(_:) | s:14swift_ide_test6AClassC9subscriptSiSicfs | Ref,Call,Dyn,Impl,RelRec | rel: 1
 
+// RelationBaseOf, RelationOverrideOf
+
+protocol X {}
+// CHECK: [[@LINE-1]]:10 | protocol/Swift | X | [[X_USR:.*]] | Def | rel: 0
+
+class ImplementsX : X {}
+// CHECK: [[@LINE-1]]:7 | class/Swift | ImplementsX | [[ImplementsX_USR:.*]] | Def | rel: 0
+// CHECK: [[@LINE-2]]:21 | protocol/Swift | X | [[X_USR]] | Ref,RelBase | rel: 1
+// CHECK-NEXT: RelBase | ImplementsX | [[ImplementsX_USR]]
+
 protocol AProtocol {
   // CHECK: [[@LINE-1]]:10 | protocol/Swift | AProtocol | [[AProtocol_USR:.*]] | Def | rel: 0
+
+  associatedtype T : X
+  // CHECK: [[@LINE-1]]:18 | type-alias/associated-type/Swift | T | s:14swift_ide_test9AProtocolP1T | Def,RelChild | rel: 1
+  // CHECK-NEXT: RelChild | AProtocol | [[AProtocol_USR]]
+  // CHECK: [[@LINE-3]]:22 | protocol/Swift | X | [[X_USR]] | Ref | rel: 0
+
   func foo() -> Int
   // CHECK: [[@LINE-1]]:8 | instance-method/Swift | foo() | s:14swift_ide_test9AProtocolP3fooSiyF | Def,RelChild | rel: 1
   // CHECK-NEXT: RelChild | AProtocol | s:14swift_ide_test9AProtocolP
 }
 
-// RelationBaseOf, RelationOverrideOf
 class ASubClass : AClass, AProtocol {
 // CHECK: [[@LINE-1]]:7 | class/Swift | ASubClass | s:14swift_ide_test9ASubClassC | Def | rel: 0
 // CHECK: [[@LINE-2]]:19 | class/Swift | AClass | s:14swift_ide_test6AClassC | Ref,RelBase | rel: 1
@@ -183,6 +189,8 @@
 // CHECK: [[@LINE-4]]:27 | protocol/Swift | AProtocol | s:14swift_ide_test9AProtocolP | Ref,RelBase | rel: 1
 // CHECK-NEXT: RelBase | ASubClass | s:14swift_ide_test9ASubClassC
 
+  typealias T = ImplementsX
+
   override func foo() -> Int {
     // CHECK: [[@LINE-1]]:17 | instance-method/Swift | foo() | s:14swift_ide_test9ASubClassC3fooSiyF | Def,RelChild,RelOver | rel: 3
     // CHECK-NEXT: RelOver | foo() | s:14swift_ide_test6AClassC3fooSiyF
@@ -216,7 +224,9 @@
   // CHECK: [[@LINE-4]]:27 | protocol/Swift | AProtocol | [[AProtocol_USR]] | Ref,RelBase | rel: 1
   // CHECK-NEXT: RelBase | InnerS | [[EXT_INNERS_USR]]
   // CHECK: [[@LINE-6]]:11 | struct/Swift | OuterS | [[OUTERS_USR]] | Ref | rel: 0
-  func foo() {}
+
+  typealias T = ImplementsX
+  func foo() -> Int { return 1 }
 }
 
 var anInstance = AClass(x: 1)
diff --git a/test/Inputs/clang-importer-sdk/usr/include/dispatch.h b/test/Inputs/clang-importer-sdk/usr/include/dispatch.h
index 63ceaf9..9c0aa3c 100644
--- a/test/Inputs/clang-importer-sdk/usr/include/dispatch.h
+++ b/test/Inputs/clang-importer-sdk/usr/include/dispatch.h
@@ -2,15 +2,21 @@
 
 @protocol OS_dispatch_object <NSObject>
 @end
-typedef NSObject <OS_dispatch_object> *dispatch_object_t;
+@interface OS_dispatch_object: NSObject <OS_dispatch_object>
+@end
+typedef OS_dispatch_object *dispatch_object_t;
 
 @protocol OS_dispatch_queue <OS_dispatch_object>
 @end
-typedef NSObject <OS_dispatch_queue> *dispatch_queue_t;
+@interface OS_dispatch_queue: OS_dispatch_object <OS_dispatch_object>
+@end
+typedef OS_dispatch_queue *dispatch_queue_t;
 
 @protocol OS_dispatch_source <OS_dispatch_object>
 @end
-typedef NSObject <OS_dispatch_source> *dispatch_source_t;
+@interface OS_dispatch_source: OS_dispatch_object <OS_dispatch_object>
+@end
+typedef OS_dispatch_source *dispatch_source_t;
 
 typedef void (^dispatch_block_t)(void);
 
diff --git a/test/SIL/Parser/basic.sil b/test/SIL/Parser/basic.sil
index ad8b308..4d141b8 100644
--- a/test/SIL/Parser/basic.sil
+++ b/test/SIL/Parser/basic.sil
@@ -1574,6 +1574,22 @@
   return %28 : $()
 }
 
+// CHECK-LABEL: sil @test_end_lifetime : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK: end_lifetime {{%.*}} : $Builtin.NativeObject
+sil @test_end_lifetime : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : $Builtin.NativeObject):
+  end_lifetime %0 : $Builtin.NativeObject
+  return undef : $()
+}
+
+// CHECK-LABEL: sil @test_unchecked_ownership_conversion : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
+// CHECK: unchecked_ownership_conversion {{%.*}} : $Builtin.NativeObject, @guaranteed to @owned
+sil @test_unchecked_ownership_conversion : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $Builtin.NativeObject):
+  %1 = unchecked_ownership_conversion %0 : $Builtin.NativeObject, @guaranteed to @owned
+  return undef : $()
+}
+
 // CHECK-LABEL: sil_vtable Foo {
 // CHECK: #Foo.subscript!getter.1: {{.*}} : hidden _TFC3tmp3Foog9subscriptFTVs5Int32S1__S1_
 // CHECK: #Foo.subscript!setter.1: {{.*}} : _TFC3tmp3Foos9subscriptFTVs5Int32S1__S1_
diff --git a/test/SIL/Serialization/basic.sil b/test/SIL/Serialization/basic.sil
new file mode 100644
index 0000000..9ac3d90
--- /dev/null
+++ b/test/SIL/Serialization/basic.sil
@@ -0,0 +1,24 @@
+// First parse this and then emit a *.sib. Then read in the *.sib, then recreate
+// RUN: rm -rfv %t
+// RUN: mkdir %t
+// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name borrow
+// RUN: %target-sil-opt %t/tmp.sib -o %t/tmp.2.sib -module-name borrow
+// RUN: %target-sil-opt %t/tmp.2.sib -module-name borrow | %FileCheck %s
+
+import Builtin
+
+// CHECK-LABEL: sil @test_unchecked_ownership_conversion : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
+// CHECK: unchecked_ownership_conversion {{%.*}} : $Builtin.NativeObject, @guaranteed to @owned
+sil @test_unchecked_ownership_conversion : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $Builtin.NativeObject):
+  unchecked_ownership_conversion %0 : $Builtin.NativeObject, @guaranteed to @owned
+  return undef : $()
+}
+
+// CHECK-LABEL: sil @test_end_lifetime : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK: end_lifetime {{%.*}} : $Builtin.NativeObject
+sil @test_end_lifetime : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : $Builtin.NativeObject):
+  end_lifetime %0 : $Builtin.NativeObject
+  return undef : $()
+}
diff --git a/test/SILGen/dynamic_self.swift b/test/SILGen/dynamic_self.swift
index 85097a1..516d34e 100644
--- a/test/SILGen/dynamic_self.swift
+++ b/test/SILGen/dynamic_self.swift
@@ -249,6 +249,75 @@
   _ = Factory.staticNewInstance
 }
 
+class FactoryFactory {
+
+  // CHECK-LABEL: sil hidden @_T012dynamic_self07FactoryC0C11newInstanceACXDyFZ : $@convention(method) (@thick FactoryFactory.Type) -> @owned FactoryFactory
+  static func newInstance() -> Self {
+    // CHECK: bb0(%0 : $@thick FactoryFactory.Type):
+
+    // CHECK: [[METATYPE:%.*]] = value_metatype $@thick @dynamic_self FactoryFactory.Type.Type, %0 : $@thick FactoryFactory.Type
+    // CHECK: [[ANY:%.*]] = init_existential_metatype [[METATYPE]] : $@thick @dynamic_self FactoryFactory.Type.Type, $@thick Any.Type
+    let _: Any.Type = type(of: self)
+
+    // CHECK: unreachable
+  }
+}
+
+// Super call to a method returning Self
+class Base {
+  required init() {}
+
+  func returnsSelf() -> Self {
+    return self
+  }
+
+  static func returnsSelfStatic() -> Self {
+    return self.init()
+  }
+}
+
+class Derived : Base {
+  // CHECK-LABEL: sil hidden @_T012dynamic_self7DerivedC9superCallyyF : $@convention(method) (@guaranteed Derived) -> ()
+  // CHECK: [[SELF:%.*]] = copy_value %0
+  // CHECK: [[SUPER:%.*]] = upcast [[SELF]] : $Derived to $Base
+  // CHECK: [[METHOD:%.*]] = function_ref @_T012dynamic_self4BaseC11returnsSelfACXDyF
+  // CHECK: apply [[METHOD]]([[SUPER]])
+  // CHECK: return
+  func superCall() {
+    super.returnsSelf()
+  }
+
+  // CHECK-LABEL: sil hidden @_T012dynamic_self7DerivedC15superCallStaticyyFZ : $@convention(method) (@thick Derived.Type) -> ()
+  // CHECK: [[SUPER:%.*]] = upcast %0 : $@thick Derived.Type to $@thick Base.Type
+  // CHECK: [[METHOD:%.*]] = function_ref @_T012dynamic_self4BaseC17returnsSelfStaticACXDyFZ
+  // CHECK: apply [[METHOD]]([[SUPER]])
+  // CHECK: return
+  static func superCallStatic() {
+    super.returnsSelfStatic()
+  }
+
+  // CHECK-LABEL: sil hidden @_T012dynamic_self7DerivedC32superCallFromMethodReturningSelfACXDyF : $@convention(method) (@guaranteed Derived) -> @owned Derived
+  // CHECK: [[SELF:%.*]] = copy_value %0
+  // CHECK: [[SUPER:%.*]] = upcast [[SELF]] : $Derived to $Base
+  // CHECK: [[METHOD:%.*]] = function_ref @_T012dynamic_self4BaseC11returnsSelfACXDyF
+  // CHECK: apply [[METHOD]]([[SUPER]])
+  // CHECK: return
+  func superCallFromMethodReturningSelf() -> Self {
+    super.returnsSelf()
+    return self
+  }
+
+  // CHECK-LABEL: sil hidden @_T012dynamic_self7DerivedC38superCallFromMethodReturningSelfStaticACXDyFZ : $@convention(method) (@thick Derived.Type) -> @owned Derived
+  // CHECK: [[SUPER:%.*]] = upcast %0 : $@thick Derived.Type to $@thick Base.Type
+  // CHECK: [[METHOD:%.*]] = function_ref @_T012dynamic_self4BaseC17returnsSelfStaticACXDyFZ
+  // CHECK: apply [[METHOD]]([[SUPER]])
+  // CHECK: return
+  static func superCallFromMethodReturningSelfStatic() -> Self {
+    super.returnsSelfStatic()
+    return self.init()
+  }
+}
+
 // CHECK-LABEL: sil_witness_table hidden X: P module dynamic_self {
 // CHECK: method #P.f!1: {{.*}} : @_T012dynamic_self1XCAA1PAaaDP1f{{[_0-9a-zA-Z]*}}FTW
 
diff --git a/test/SILGen/lifetime.swift b/test/SILGen/lifetime.swift
index 47cad67..6eff46f 100644
--- a/test/SILGen/lifetime.swift
+++ b/test/SILGen/lifetime.swift
@@ -527,11 +527,17 @@
   // CHECK-LABEL: sil hidden @_T08lifetime3FooCfD : $@convention(method) <T> (@owned Foo<T>) -> ()
   // CHECK: bb0([[SELF:%[0-9]+]] : $Foo<T>):
   // CHECK:   [[DESTROYING_REF:%[0-9]+]] = function_ref @_T08lifetime3FooCfd : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
-  // CHECK-NEXT:   [[RESULT_SELF:%[0-9]+]] = apply [[DESTROYING_REF]]<T>([[SELF]]) : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
+  // CHECK-NEXT:   [[BORROWED_SELF:%.*]] = begin_borrow [[SELF]]
+  // CHECK-NEXT:   [[RESULT_SELF:%[0-9]+]] = apply [[DESTROYING_REF]]<T>([[BORROWED_SELF]]) : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
+  // CHECK-NEXT:   end_borrow [[BORROWED_SELF]] from [[SELF]]
+  // CHECK-NEXT:   end_lifetime [[SELF]]
   // CHECK-NEXT:   [[SELF:%[0-9]+]] = unchecked_ref_cast [[RESULT_SELF]] : $Builtin.NativeObject to $Foo<T>
   // CHECK-NEXT:   dealloc_ref [[SELF]] : $Foo<T>
   // CHECK-NEXT:   [[RESULT:%[0-9]+]] = tuple ()
   // CHECK-NEXT:   return [[RESULT]] : $()
+  // CHECK-NEXT: } // end sil function '_T08lifetime3FooCfD'
+
+  
   // CHECK-LABEL: sil hidden @_T08lifetime3FooCfd : $@convention(method) <T> (@guaranteed Foo<T>) -> @owned Builtin.NativeObject
 
   deinit {
@@ -540,8 +546,6 @@
     // CHECK: function_ref @_T08lifetime3barSiyF
     // CHECK: apply
 
-    // CHECK: [[PTR:%.*]] = unchecked_ref_cast [[THIS]] : ${{.*}} to $Builtin.NativeObject
-
     // -- don't need to destroy_value x because it's trivial
     // CHECK-NOT: ref_element_addr [[THIS]] : {{.*}}, #Foo.x
     // -- destroy_value y
@@ -554,11 +558,32 @@
     // CHECK: [[WADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #Foo.w
     // CHECK: destroy_addr [[WADDR]]
     // -- return back this
-    // CHECK: return [[PTR]]
+    // CHECK: [[PTR:%.*]] = unchecked_ref_cast [[THIS]] : $Foo<T> to $Builtin.NativeObject
+    // CHECK: [[PTR_OWNED:%.*]] = unchecked_ownership_conversion [[PTR]] : $Builtin.NativeObject, @guaranteed to @owned
+    // CHECK: return [[PTR_OWNED]]
+    // CHECK: } // end sil function '_T08lifetime3FooCfd'
   }
 
 }
 
+class FooSubclass<T> : Foo<T> {
+
+  // CHECK-LABEL: sil hidden @_T08lifetime11FooSubclassCfd : $@convention(method) <T> (@guaranteed FooSubclass<T>) -> @owned Builtin.NativeObject
+  // CHECK: bb0([[THIS:%[0-9]+]] : $FooSubclass<T>):
+  // -- base dtor
+  // CHECK: [[BASE:%[0-9]+]] = upcast [[THIS]] : ${{.*}} to $Foo<T>
+  // CHECK: [[BASE_DTOR:%[0-9]+]] = function_ref @_T08lifetime3FooCfd : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
+  // CHECK: [[PTR:%.*]] = apply [[BASE_DTOR]]<T>([[BASE]])
+  // CHECK: [[BORROWED_PTR:%.*]] = begin_borrow [[PTR]]
+  // CHECK: end_borrow [[BORROWED_PTR]] from [[PTR]]
+  // CHECK: return [[PTR]]
+  
+
+  deinit {
+    bar()
+  }
+}
+
 class ImplicitDtor {
   var x:Int
   var y:(Int, Ref)
@@ -586,14 +611,22 @@
     self.z = z
   }
 
+  // CHECK: sil hidden @_T08lifetime19ImplicitDtorDerivedCfd : $@convention(method) <T> (@guaranteed ImplicitDtorDerived<T>) -> @owned Builtin.NativeObject {
   // CHECK: bb0([[THIS:%[0-9]+]] : $ImplicitDtorDerived<T>):
   // -- base dtor
   // CHECK: [[BASE:%[0-9]+]] = upcast [[THIS]] : ${{.*}} to $ImplicitDtor
   // CHECK: [[BASE_DTOR:%[0-9]+]] = function_ref @_T08lifetime12ImplicitDtorCfd
-  // CHECK: apply [[BASE_DTOR]]([[BASE]])
+  // CHECK: [[PTR:%.*]] = apply [[BASE_DTOR]]([[BASE]])
   // -- destroy_value z
-  // CHECK: [[ZADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #ImplicitDtorDerived.z
+  // CHECK: [[BORROWED_PTR:%.*]] = begin_borrow [[PTR]]
+  // CHECK: [[CAST_BORROWED_PTR:%.*]] = unchecked_ref_cast [[BORROWED_PTR]] : $Builtin.NativeObject to $ImplicitDtorDerived<T>
+  // CHECK: [[ZADDR:%[0-9]+]] = ref_element_addr [[CAST_BORROWED_PTR]] : {{.*}}, #ImplicitDtorDerived.z
   // CHECK: destroy_addr [[ZADDR]]
+  // CHECK: end_borrow [[BORROWED_PTR]] from [[PTR]]
+  // -- epilog
+  // CHECK-NOT: unchecked_ref_cast
+  // CHECK-NOT: unchecked_ownership_conversion
+  // CHECK: return [[PTR]]
 }
 
 class ImplicitDtorDerivedFromGeneric<T> : ImplicitDtorDerived<Int> {
diff --git a/test/SILGen/materializeForSet.swift b/test/SILGen/materializeForSet.swift
index 7f3d867..55210ee 100644
--- a/test/SILGen/materializeForSet.swift
+++ b/test/SILGen/materializeForSet.swift
@@ -80,6 +80,7 @@
 // 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: end_borrow [[T0]] from %2
 // CHECK-NEXT: tuple ()
 // CHECK-NEXT: return
 
@@ -100,12 +101,13 @@
 // CHECK-NEXT: store [[T1]] to [init] [[RESULT_ADDR]]
 // CHECK-NEXT: [[RESULT_PTR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_owned () -> @out Int to $Builtin.RawPointer
 // CHECK-NEXT: function_ref
-// CHECK-NEXT: [[T0:%.*]] = function_ref @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14storedFunction6ResultQzycfmytfU_TW
-// CHECK-NEXT: [[T1:%.*]] = thin_function_to_pointer [[T0]]
-// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T1]]
-// CHECK-NEXT: [[T0:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: [[T2:%.*]] = function_ref @_T017materializeForSet7DerivedCAA12AbstractableAaaDP14storedFunction6ResultQzycfmytfU_TW
+// CHECK-NEXT: [[T3:%.*]] = thin_function_to_pointer [[T2]]
+// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T3]]
+// CHECK-NEXT: [[T4:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
 // CHECK-NEXT: dealloc_stack [[TEMP]]
-// CHECK-NEXT: return [[T0]]
+// CHECK-NEXT: end_borrow [[T0]] from %2
+// CHECK-NEXT: return [[T4]]
 
 // CHECK: sil hidden [transparent] @_T017materializeForSet7DerivedCAA12AbstractableAaaDP19finalStoredFunction6ResultQzycfmytfU_TW :
 // CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
@@ -118,6 +120,7 @@
 // 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: end_borrow [[T0]] from %2
 // CHECK-NEXT: tuple ()
 // CHECK-NEXT: return
 
@@ -134,17 +137,18 @@
 // CHECK-NEXT: store [[T1]] to [init] [[RESULT_ADDR]]
 // CHECK-NEXT: [[RESULT_PTR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_owned () -> @out Int to $Builtin.RawPointer
 // CHECK-NEXT: function_ref
-// CHECK-NEXT: [[T0:%.*]] = function_ref @_T017materializeForSet7DerivedCAA12AbstractableAaaDP19finalStoredFunction6ResultQzycfmytfU_TW
-// CHECK-NEXT: [[T1:%.*]] = thin_function_to_pointer [[T0]]
-// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T1]]
-// CHECK-NEXT: [[T0:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
-// CHECK-NEXT: return [[T0]]
+// CHECK-NEXT: [[T2:%.*]] = function_ref @_T017materializeForSet7DerivedCAA12AbstractableAaaDP19finalStoredFunction6ResultQzycfmytfU_TW
+// CHECK-NEXT: [[T3:%.*]] = thin_function_to_pointer [[T2]]
+// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T3]]
+// CHECK-NEXT: [[T4:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: end_borrow [[T0]] from %2
+// CHECK-NEXT: return [[T4]]
 
 // 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: bb0([[ARG1:%.*]] : $Builtin.RawPointer, [[ARG2:%.*]] : $*Builtin.UnsafeValueBuffer, [[ARG3:%.*]] : $*@thick Derived.Type, [[ARG4:%.*]] : $@thick Derived.Type.Type):
+// CHECK-NEXT: [[SELF:%.*]] = load [trivial] [[ARG3]] : $*@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: [[BUFFER:%.*]] = pointer_to_address [[ARG1]] : $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
diff --git a/test/SILGen/objc_properties.swift b/test/SILGen/objc_properties.swift
index a9d0064..f7b7835 100644
--- a/test/SILGen/objc_properties.swift
+++ b/test/SILGen/objc_properties.swift
@@ -4,7 +4,6 @@
 
 import Foundation
 
-
 class A {
   dynamic var prop: Int
   dynamic var computedProp: Int {
@@ -183,6 +182,31 @@
   var ref: Unmanaged<AnyObject>?
 }
 
+@_silgen_name("autoreleasing_user")
+func useAutoreleasingUnsafeMutablePointer(_ a: AutoreleasingUnsafeMutablePointer<NSObject>)
+
+class NonObjCClassWithObjCProperty {
+  var property: NSObject
+
+  init(_ newValue: NSObject) {
+    property = newValue
+  }
+
+  // CHECK-LABEL: sil hidden @_T015objc_properties016NonObjCClassWithD9CPropertyC11usePropertyyyF : $@convention(method) (@guaranteed NonObjCClassWithObjCProperty) -> () {
+  // CHECK: bb0([[ARG:%.*]] : $NonObjCClassWithObjCProperty):
+  // CHECK: [[MATERIALIZE_FOR_SET:%.*]] = class_method [[ARG]] : $NonObjCClassWithObjCProperty, #NonObjCClassWithObjCProperty.property!materializeForSet.1
+  // CHECK: [[TUPLE:%.*]] = apply [[MATERIALIZE_FOR_SET]]({{.*}}, {{.*}}, [[ARG]])
+  // CHECK: [[RAW_POINTER:%.*]] = tuple_extract [[TUPLE]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>), 0
+  // CHECK: [[OBJECT:%.*]] = pointer_to_address [[RAW_POINTER]] : $Builtin.RawPointer to [strict] $*NSObject
+  // CHECK: [[OBJECT_DEP:%.*]] = mark_dependence [[OBJECT]] : $*NSObject on [[ARG]]
+  // CHECK: [[LOADED_OBJECT:%.*]] = load_borrow [[OBJECT_DEP]]
+  // CHECK: [[UNMANAGED_OBJECT:%.*]] = ref_to_unmanaged [[LOADED_OBJECT]] : $NSObject to $@sil_unmanaged NSObject
+  // CHECK: end_borrow [[LOADED_OBJECT]] from [[OBJECT_DEP]]
+  func useProperty() {
+    useAutoreleasingUnsafeMutablePointer(&property)
+  }
+}
+
 
 // <rdar://problem/21544588> crash when overriding non-@objc property with @objc property.
 class NonObjCBaseClass : NSObject {
diff --git a/test/SILOptimizer/devirtualize_existential.swift b/test/SILOptimizer/devirtualize_existential.swift
index 570460b..8072de8 100644
--- a/test/SILOptimizer/devirtualize_existential.swift
+++ b/test/SILOptimizer/devirtualize_existential.swift
@@ -8,12 +8,61 @@
 }
 
 // Everything gets devirtualized, inlined, and promoted to the stack.
-//CHECK: @_T024devirtualize_existential17interesting_stuffyyF
-//CHECK-NOT: init_existential_addr
-//CHECK-NOT: apply
-//CHECK: return
+// CHECK-LABEL: @_T024devirtualize_existential17interesting_stuffyyF
+// CHECK-NOT: init_existential_addr
+// CHECK-NOT: apply
+// CHECK: return
 public func interesting_stuff() {
- var x : Pingable = Foo()
+ var x: Pingable = Foo()
  x.ping(1)
 }
 
+protocol Cloneable {
+  func clone() -> Self
+  func maybeClone() -> Self?
+}
+
+struct Bar : Cloneable {
+  @inline(never)
+  func clone() -> Bar { return self }
+
+  @inline(never)
+  func maybeClone() -> Bar? { return self }
+}
+
+// In this example, we don't eliminate the init_existential_addr, because
+// of the stack allocated existential value used for the return.
+//
+// If the combiner was generalized to replace the opened existential type
+// with the concrete type in all instructions that use it, instead of just
+// special-casing witness_method and apply, we could eliminate the opened
+// existential type completely.
+//
+// However even though IRGen still performs more work at runtime than is
+// necessary here, the call is devirtualized.
+
+// CHECK-LABEL: sil @_T024devirtualize_existential22more_interesting_stuffyyF
+// CHECK: [[EXISTENTIAL:%.*]] = alloc_stack $Cloneable
+// CHECK: [[EXISTENTIAL_ADDR:%.*]] = init_existential_addr [[EXISTENTIAL]]
+// CHECK: [[VALUE:%.*]] = struct $Bar ()
+// CHECK: [[RESULT_ADDR:%.*]] = unchecked_addr_cast [[EXISTENTIAL_ADDR:%.*]]
+// CHECK: [[FN:%.*]] = function_ref @_T024devirtualize_existential3BarV5cloneACyF
+// CHECK: [[RETURN:%.*]] = apply [[FN]]([[VALUE]])
+// CHECK: store [[RETURN]] to [[RESULT_ADDR]]
+
+// CHECK: [[ENUM:%.*]] = alloc_stack $Optional<Cloneable>
+// CHECK: [[ENUM_ADDR:%.*]] = init_enum_data_addr [[ENUM]]
+// CHECK: [[EXISTENTIAL_ADDR:%.*]] = init_existential_addr [[ENUM_ADDR]]
+// CHECK: [[RESULT_ADDR:%.*]] = unchecked_addr_cast [[EXISTENTIAL_ADDR:%.*]]
+// CHECK: [[FN:%.*]] = function_ref @_T024devirtualize_existential3BarV10maybeCloneACSgyF
+// CHECK: [[RETURN:%.*]] = apply [[FN]]([[VALUE]])
+// CHECK: store [[RETURN]] to [[RESULT_ADDR]]
+
+// CHECK: return
+
+public func more_interesting_stuff() {
+  var x: Cloneable = Bar()
+
+  x.clone()
+  x.maybeClone()
+}
diff --git a/test/SILOptimizer/ownership_model_eliminator.sil b/test/SILOptimizer/ownership_model_eliminator.sil
index 70288dd..52ab7b6 100644
--- a/test/SILOptimizer/ownership_model_eliminator.sil
+++ b/test/SILOptimizer/ownership_model_eliminator.sil
@@ -174,3 +174,22 @@
   %9999 = tuple()
   return %9999 : $()
 }
+
+// CHECK-LABEL: sil @end_lifetime_test : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK-NOT: end_lifetime {{%.*}} : $Builtin.NativeObject
+sil @end_lifetime_test : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject):
+  end_lifetime %0 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil @unchecked_ownership_conversion_test : $@convention(thin) (@guaranteed Builtin.NativeObject) -> @owned Builtin.NativeObject {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Builtin.NativeObject):
+// CHECK: return [[ARG]] : $Builtin.NativeObject
+sil @unchecked_ownership_conversion_test : $@convention(thin) (@guaranteed Builtin.NativeObject) -> @owned Builtin.NativeObject {
+bb0(%0 : @guaranteed $Builtin.NativeObject):
+  %1 = unchecked_ownership_conversion %0 : $Builtin.NativeObject, @guaranteed to @owned
+  return %1 : $Builtin.NativeObject
+}
+
diff --git a/test/Sema/availability_versions.swift b/test/Sema/availability_versions.swift
index 4ef62d5..c5e1294 100644
--- a/test/Sema/availability_versions.swift
+++ b/test/Sema/availability_versions.swift
@@ -28,15 +28,15 @@
 
 // Functions without annotations should reflect the minimum deployment target.
 func functionWithoutAvailability() {
+      // expected-note@-1 2{{add @available attribute to enclosing global function}}
+
   let _: Int = globalFuncAvailableOn10_9()
 
   let _: Int = globalFuncAvailableOn10_51() // expected-error {{'globalFuncAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _: Int = globalFuncAvailableOn10_52() // expected-error {{'globalFuncAvailableOn10_52()' is only available on OS X 10.52 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 // Functions with annotations should refine their bodies.
@@ -123,6 +123,8 @@
 // Unavailable methods
 
 class ClassWithUnavailableMethod {
+    // expected-note@-1 {{add @available attribute to enclosing class}}
+
   @available(OSX, introduced: 10.9)
   func methAvailableOn10_9() {}
   
@@ -133,84 +135,84 @@
   class func classMethAvailableOn10_51() {}
   
   func someOtherMethod() {
+    // expected-note@-1 {{add @available attribute to enclosing instance method}}
+
     methAvailableOn10_9()
     methAvailableOn10_51() // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add @available attribute to enclosing instance method}}
-        // expected-note@-3 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
   }
 }
 
 func callUnavailableMethods(_ o: ClassWithUnavailableMethod) {
+      // expected-note@-1 2{{add @available attribute to enclosing global function}}
+
   let m10_9 = o.methAvailableOn10_9
   m10_9()
   
   let m10_51 = o.methAvailableOn10_51 // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   m10_51()
   
   o.methAvailableOn10_9()
   o.methAvailableOn10_51() // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 func callUnavailableMethodsViaIUO(_ o: ClassWithUnavailableMethod!) {
+      // expected-note@-1 2{{add @available attribute to enclosing global function}}
+
   let m10_9 = o.methAvailableOn10_9
   m10_9()
   
   let m10_51 = o.methAvailableOn10_51 // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
+      
       // expected-note@-2 {{add 'if #available' version check}}
 
   m10_51()
   
   o.methAvailableOn10_9()
   o.methAvailableOn10_51() // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 func callUnavailableClassMethod() {
+      // expected-note@-1 2{{add @available attribute to enclosing global function}}
+
   ClassWithUnavailableMethod.classMethAvailableOn10_51() // expected-error {{'classMethAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   let m10_51 = ClassWithUnavailableMethod.classMethAvailableOn10_51 // expected-error {{'classMethAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   m10_51()
 }
 
 class SubClassWithUnavailableMethod : ClassWithUnavailableMethod {
+        // expected-note@-1 {{add @available attribute to enclosing class}}
   func someMethod() {
+        // expected-note@-1 {{add @available attribute to enclosing instance method}}
+
     methAvailableOn10_9()
     methAvailableOn10_51() // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add @available attribute to enclosing instance method}}
-        // expected-note@-3 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
   }
 }
 
 class SubClassOverridingUnavailableMethod : ClassWithUnavailableMethod {
+        // expected-note@-1 2{{add @available attribute to enclosing class}}
 
   override func methAvailableOn10_51() {
+        // expected-note@-1 2{{add @available attribute to enclosing instance method}}
     methAvailableOn10_9()
     super.methAvailableOn10_51() // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add @available attribute to enclosing instance method}}
-        // expected-note@-3 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
     
     let m10_9 = super.methAvailableOn10_9
     m10_9()
     
     let m10_51 = super.methAvailableOn10_51 // expected-error {{'methAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add @available attribute to enclosing instance method}}
-        // expected-note@-3 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
     m10_51()
   }
   
@@ -230,15 +232,18 @@
 }
 
 func callUnavailableOverloadedMethod(_ o: ClassWithUnavailableOverloadedMethod) {
+      // expected-note@-1 {{add @available attribute to enclosing global function}}
+
   o.overloadedMethod()
   o.overloadedMethod(0) // expected-error {{'overloadedMethod' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 // Initializers
 
 class ClassWithUnavailableInitializer {
+    // expected-note@-1 {{add @available attribute to enclosing class}}
+
   @available(OSX, introduced: 10.9)
   required init() {  }
   
@@ -246,10 +251,10 @@
   required init(_ val: Int) {  }
   
   convenience init(s: String) {
+        // expected-note@-1 {{add @available attribute to enclosing initializer}}
+    
     self.init(5) // expected-error {{'init' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add @available attribute to enclosing initializer}}
-        // expected-note@-3 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
   }
   
   @available(OSX, introduced: 10.51)
@@ -259,16 +264,16 @@
 }
 
 func callUnavailableInitializer() {
+      // expected-note@-1 2{{add @available attribute to enclosing global function}}
+
   _ = ClassWithUnavailableInitializer()
   _ = ClassWithUnavailableInitializer(5) // expected-error {{'init' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   let i = ClassWithUnavailableInitializer.self 
   _ = i.init()
   _ = i.init(5) // expected-error {{'init' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 class SuperWithWithUnavailableInitializer {
@@ -280,11 +285,13 @@
 }
 
 class SubOfClassWithUnavailableInitializer : SuperWithWithUnavailableInitializer {
+    // expected-note@-1 {{add @available attribute to enclosing class}}
+
   override init(_ val: Int) {
+        // expected-note@-1 {{add @available attribute to enclosing initializer}}
+
     super.init(5) // expected-error {{'init' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add @available attribute to enclosing initializer}}
-        // expected-note@-3 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
   }
   
   override init() {
@@ -300,6 +307,7 @@
 // Properties
 
 class ClassWithUnavailableProperties {
+    // expected-note@-1 4{{add @available attribute to enclosing class}}
 
   @available(OSX, introduced: 10.9) // expected-error {{stored properties cannot be marked potentially unavailable with '@available'}}
   var nonLazyAvailableOn10_9Stored: Int = 9
@@ -313,7 +321,6 @@
   // Make sure that we don't emit a Fix-It to mark a stored property as potentially unavailable.
   // We don't support potentially unavailable stored properties yet.
   var storedPropertyOfUnavailableType: ClassAvailableOn10_51? = nil // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing class}}
 
   @available(OSX, introduced: 10.9)
   lazy var availableOn10_9Stored: Int = 9
@@ -325,8 +332,7 @@
   var availableOn10_9Computed: Int {
     get {
       let _: Int = availableOn10_51Stored // expected-error {{'availableOn10_51Stored' is only available on OS X 10.51 or newer}}
-          // expected-note@-1 {{add @available attribute to enclosing class}}
-          // expected-note@-2 {{add 'if #available' version check}}
+          // expected-note@-1 {{add 'if #available' version check}}
       
       if #available(OSX 10.51, *) {
         let _: Int = availableOn10_51Stored
@@ -350,11 +356,10 @@
   }
   
   var propWithSetterOnlyAvailableOn10_51 : Int {
+      // expected-note@-1 {{add @available attribute to enclosing var}}
     get {
       _ = globalFuncAvailableOn10_51() // expected-error {{'globalFuncAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-          // expected-note@-1 {{add @available attribute to enclosing class}}
-          // expected-note@-2 {{add @available attribute to enclosing var}}
-          // expected-note@-3 {{add 'if #available' version check}}
+          // expected-note@-1 {{add 'if #available' version check}}
       return 0
     }
     @available(OSX, introduced: 10.51)
@@ -364,6 +369,7 @@
   }
   
   var propWithGetterOnlyAvailableOn10_51 : Int {
+      // expected-note@-1 {{add @available attribute to enclosing var}}
     @available(OSX, introduced: 10.51)
     get {
       _ = globalFuncAvailableOn10_51()
@@ -371,9 +377,7 @@
     }
     set(newVal) {
       _ = globalFuncAvailableOn10_51() // expected-error {{'globalFuncAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-          // expected-note@-1 {{add @available attribute to enclosing class}}
-          // expected-note@-2 {{add @available attribute to enclosing var}}
-          // expected-note@-3 {{add 'if #available' version check}}
+          // expected-note@-1 {{add 'if #available' version check}}
     }
   }
   
@@ -419,33 +423,29 @@
 }
 
 func accessUnavailableProperties(_ o: ClassWithUnavailableProperties) {
+      // expected-note@-1 17{{add @available attribute to enclosing global function}}
   // Stored properties
   let _: Int = o.availableOn10_9Stored
   let _: Int = o.availableOn10_51Stored // expected-error {{'availableOn10_51Stored' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   o.availableOn10_9Stored = 9
   o.availableOn10_51Stored = 10 // expected-error {{'availableOn10_51Stored' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   // Computed Properties
   let _: Int = o.availableOn10_9Computed
   let _: Int = o.availableOn10_51Computed // expected-error {{'availableOn10_51Computed' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   o.availableOn10_9Computed = 9
   o.availableOn10_51Computed = 10 // expected-error {{'availableOn10_51Computed' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   // Getter allowed on 10.9 but setter is not
   let _: Int = o.propWithSetterOnlyAvailableOn10_51
   o.propWithSetterOnlyAvailableOn10_51 = 5 // expected-error {{setter for 'propWithSetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   if #available(OSX 10.51, *) {
     // Setter is allowed on 10.51 and greater
@@ -455,8 +455,7 @@
   // Setter allowed on 10.9 but getter is not
   o.propWithGetterOnlyAvailableOn10_51 = 5
   let _: Int = o.propWithGetterOnlyAvailableOn10_51 // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   if #available(OSX 10.51, *) {
     // Getter is allowed on 10.51 and greater
@@ -467,18 +466,15 @@
   
   // Both getters are potentially unavailable.
   let _: Int = o.propWithGetterOnlyAvailableOn10_51ForNestedMemberRef.propWithGetterOnlyAvailableOn10_51 // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51ForNestedMemberRef' is only available on OS X 10.51 or newer}} expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 2{{add @available attribute to enclosing global function}}
-      // expected-note@-2 2{{add 'if #available' version check}}
+      // expected-note@-1 2{{add 'if #available' version check}}
 
   // Nested getter is potentially unavailable, outer getter is available
   let _: Int = o.propWithGetterOnlyAvailableOn10_51ForNestedMemberRef.propWithSetterOnlyAvailableOn10_51 // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51ForNestedMemberRef' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   // Nested getter is available, outer getter is potentially unavailable
   let _:Int = o.propWithSetterOnlyAvailableOn10_51ForNestedMemberRef.propWithGetterOnlyAvailableOn10_51 // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   // Both getters are always available.
   let _: Int = o.propWithSetterOnlyAvailableOn10_51ForNestedMemberRef.propWithSetterOnlyAvailableOn10_51
@@ -488,33 +484,27 @@
   var v: Int
   
   v = o.propWithGetterOnlyAvailableOn10_51 // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   v = (o.propWithGetterOnlyAvailableOn10_51) // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   // Inout requires access to both getter and setter
   
   func takesInout(_ i : inout Int) { }
   
   takesInout(&o.propWithGetterOnlyAvailableOn10_51) // expected-error {{cannot pass as inout because getter for 'propWithGetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   takesInout(&o.propWithSetterOnlyAvailableOn10_51) // expected-error {{cannot pass as inout because setter for 'propWithSetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   takesInout(&o.propWithGetterAndSetterOnlyAvailableOn10_51) // expected-error {{cannot pass as inout because getter for 'propWithGetterAndSetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}} expected-error {{cannot pass as inout because setter for 'propWithGetterAndSetterOnlyAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 2{{add @available attribute to enclosing global function}}
-      // expected-note@-2 2{{add 'if #available' version check}}
+      // expected-note@-1 2{{add 'if #available' version check}}
 
   takesInout(&o.availableOn10_9Computed)
   takesInout(&o.propWithGetterOnlyAvailableOn10_51ForNestedMemberRef.availableOn10_9Computed) // expected-error {{getter for 'propWithGetterOnlyAvailableOn10_51ForNestedMemberRef' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 // _silgen_name
@@ -563,17 +553,15 @@
 func functionTakingEnumIntroducedOn10_52(_ e: EnumIntroducedOn10_52) { }
 
 func useEnums() {
+      // expected-note@-1 3{{add @available attribute to enclosing global function}}
   let _: CompassPoint = .North // expected-error {{'CompassPoint' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   if #available(OSX 10.51, *) {
     let _: CompassPoint = .North
 
     let _: CompassPoint = .West // expected-error {{'West' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
-
+        // expected-note@-1 {{add 'if #available' version check}}
   }
 
   if #available(OSX 10.52, *) {
@@ -595,7 +583,7 @@
         // For the moment, we do not incorporate enum element availability into 
         // TRC construction. Perhaps we should?
         functionTakingEnumIntroducedOn10_52(p)  // expected-error {{'functionTakingEnumIntroducedOn10_52' is only available on OS X 10.52 or newer}}
-          // expected-note@-1 {{add @available attribute to enclosing global function}}
+          
           // expected-note@-2 {{add 'if #available' version check}}
     }
   }
@@ -629,20 +617,18 @@
 }
 
 func classAvailability() {
+      // expected-note@-1 3{{add @available attribute to enclosing global function}}
   ClassAvailableOn10_9.someClassMethod()
   ClassAvailableOn10_51.someClassMethod() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   _ = ClassAvailableOn10_9.self
   _ = ClassAvailableOn10_51.self // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   let o10_9 = ClassAvailableOn10_9()
   let o10_51 = ClassAvailableOn10_51() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   o10_9.someMethod()
   o10_51.someMethod()
@@ -652,17 +638,15 @@
 }
 
 func castingUnavailableClass(_ o : AnyObject) {
+      // expected-note@-1 3{{add @available attribute to enclosing global function}}
   let _ = o as! ClassAvailableOn10_51 // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _ = o as? ClassAvailableOn10_51 // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _ = o is ClassAvailableOn10_51 // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 protocol Creatable {
@@ -683,45 +667,39 @@
 class ClassWithTwoGenericTypeParameter<T, S> { }
 
 func classViaTypeParameter() {
+  // expected-note@-1 9{{add @available attribute to enclosing global function}}
   let _ : ClassAvailableOn10_51_Creatable = // expected-error {{'ClassAvailableOn10_51_Creatable' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
       create()
       
   let _ = create() as
       ClassAvailableOn10_51_Creatable // expected-error {{'ClassAvailableOn10_51_Creatable' is only available on OS X 10.51 or newer}}
-          // expected-note@-1 {{add @available attribute to enclosing global function}}
-          // expected-note@-2 {{add 'if #available' version check}}
+          // expected-note@-1 {{add 'if #available' version check}}
 
   let _ = [ClassAvailableOn10_51]() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _: ClassWithGenericTypeParameter<ClassAvailableOn10_51> = ClassWithGenericTypeParameter() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _: ClassWithTwoGenericTypeParameter<ClassAvailableOn10_51, String> = ClassWithTwoGenericTypeParameter() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _: ClassWithTwoGenericTypeParameter<String, ClassAvailableOn10_51> = ClassWithTwoGenericTypeParameter() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _: ClassWithTwoGenericTypeParameter<ClassAvailableOn10_51, ClassAvailableOn10_51> = ClassWithTwoGenericTypeParameter() // expected-error 2{{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 2{{add @available attribute to enclosing global function}}
-      // expected-note@-2 2{{add 'if #available' version check}}
+      // expected-note@-1 2{{add 'if #available' version check}}
 
   let _: ClassAvailableOn10_51? = nil // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
 }
 
 // Unavailable class used in declarations
 
 class ClassWithDeclarationsOfUnavailableClasses {
+      // expected-note@-1 5{{add @available attribute to enclosing class}}
 
   @available(OSX, introduced: 10.51)
   init() {
@@ -730,7 +708,6 @@
   }
 
   var propertyOfUnavailableType: ClassAvailableOn10_51 // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing class}}
 
   @available(OSX, introduced: 10.51)
   lazy var unavailablePropertyOfUnavailableType: ClassAvailableOn10_51 = ClassAvailableOn10_51()
@@ -748,9 +725,7 @@
   static var unavailableStaticPropertyOfOptionalUnavailableType: ClassAvailableOn10_51?
 
   func methodWithUnavailableParameterType(_ o : ClassAvailableOn10_51) { // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing class}}
-      // expected-note@-2 {{add @available attribute to enclosing instance method}}
-
+      // expected-note@-1 {{add @available attribute to enclosing instance method}}
   }
   
   @available(OSX, introduced: 10.51)
@@ -758,13 +733,10 @@
   }
   
   func methodWithUnavailableReturnType() -> ClassAvailableOn10_51 { // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing class}}
-      // expected-note@-2 {{add @available attribute to enclosing instance method}}
+      // expected-note@-1 2{{add @available attribute to enclosing instance method}}
 
     return ClassAvailableOn10_51() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing class}}
-      // expected-note@-2 {{add @available attribute to enclosing instance method}}
-      // expected-note@-3 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   }
   
   @available(OSX, introduced: 10.51)
@@ -773,10 +745,9 @@
   }
 
   func methodWithUnavailableLocalDeclaration() {
+      // expected-note@-1 {{add @available attribute to enclosing instance method}}
     let _ : ClassAvailableOn10_51 = methodWithUnavailableReturnType() // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing class}}
-      // expected-note@-2 {{add @available attribute to enclosing instance method}}
-      // expected-note@-3 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   }
   
   @available(OSX, introduced: 10.51)
@@ -786,14 +757,13 @@
 }
 
 func referToUnavailableStaticProperty() {
-  let _ = ClassWithDeclarationsOfUnavailableClasses.unavailableStaticPropertyOfUnavailableType // expected-error {{'unavailableStaticPropertyOfUnavailableType' is only available on OS X 10.51 or newer}}
       // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+  let _ = ClassWithDeclarationsOfUnavailableClasses.unavailableStaticPropertyOfUnavailableType // expected-error {{'unavailableStaticPropertyOfUnavailableType' is only available on OS X 10.51 or newer}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 class ClassExtendingUnavailableClass : ClassAvailableOn10_51 { // expected-error {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
     // expected-note@-1 {{add @available attribute to enclosing class}}
-
 }
 
 @available(OSX, introduced: 10.51)
@@ -860,11 +830,11 @@
 }
 
 class SubWithLargerMemberAvailability : SuperWithLimitedMemberAvailability {
+        // expected-note@-1 2{{add @available attribute to enclosing class}}
   @available(OSX, introduced: 10.9)
   override func someMethod() {
     super.someMethod() // expected-error {{'someMethod()' is only available on OS X 10.51 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing class}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
     
     if #available(OSX 10.51, *) {
       super.someMethod()
@@ -875,8 +845,7 @@
   override var someProperty: Int {
     get { 
       let _ = super.someProperty // expected-error {{'someProperty' is only available on OS X 10.51 or newer}}
-          // expected-note@-1 {{add @available attribute to enclosing class}}
-          // expected-note@-2 {{add 'if #available' version check}}
+          // expected-note@-1 {{add 'if #available' version check}}
       
       if #available(OSX 10.51, *) {
         let _ = super.someProperty
@@ -916,15 +885,14 @@
 }
 
 func castToUnavailableProtocol() {
+      // expected-note@-1 2{{add @available attribute to enclosing global function}}
   let o: ClassAvailableOn10_9AdoptingProtocolAvailableOn10_51 = ClassAvailableOn10_9AdoptingProtocolAvailableOn10_51()
 
   let _: ProtocolAvailableOn10_51 = o // expected-error {{'ProtocolAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _ = o as ProtocolAvailableOn10_51 // expected-error {{'ProtocolAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 @available(OSX, introduced: 10.9)
@@ -953,10 +921,10 @@
 @available(OSX, introduced: 10.51)
 extension ClassAvailableOn10_51 {
   func m() {
+      // expected-note@-1 {{add @available attribute to enclosing instance method}}
     let _ = globalFuncAvailableOn10_51()
     let _ = globalFuncAvailableOn10_52() // expected-error {{'globalFuncAvailableOn10_52()' is only available on OS X 10.52 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing instance method}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   }
 }
 
@@ -991,19 +959,17 @@
 }
 
 func useUnavailableExtension() {
+      // expected-note@-1 3{{add @available attribute to enclosing global function}}
   let o = ClassToExtend()
 
   o.extensionMethod() // expected-error {{'extensionMethod()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   let _ = ClassToExtend.ExtensionClass() // expected-error {{'ExtensionClass' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   o.extensionMethod10_52() // expected-error {{'extensionMethod10_52()' is only available on OS X 10.52 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 // Useless #available(...) checks
@@ -1136,11 +1102,11 @@
 // Tests for the guard control construct.
 
 func useGuardAvailable() {
+        // expected-note@-1 3{{add @available attribute to enclosing global function}}
   // Guard fallthrough should refine context
   guard #available(OSX 10.51, *) else { // expected-note {{enclosing scope here}}
     let _ = globalFuncAvailableOn10_51() // expected-error {{'globalFuncAvailableOn10_51()' is only available on OS X 10.51 or newer}}
         // expected-note@-1 {{add 'if #available' version check}}
-        // expected-note@-2 {{add @available attribute to enclosing global function}}
     return
   }
 
@@ -1148,7 +1114,6 @@
 
   let _ = globalFuncAvailableOn10_52() // expected-error {{'globalFuncAvailableOn10_52()' is only available on OS X 10.52 or newer}}
         // expected-note@-1 {{add 'if #available' version check}}
-        // expected-note@-2 {{add @available attribute to enclosing global function}}
 
   if #available(OSX 10.51, *) { // expected-warning {{unnecessary check for 'OSX'; enclosing scope ensures guard will always be true}}
   }
@@ -1161,11 +1126,10 @@
 
   let _ = globalFuncAvailableOn10_52() // expected-error {{'globalFuncAvailableOn10_52()' is only available on OS X 10.52 or newer}}
         // expected-note@-1 {{add 'if #available' version check}}
-        // expected-note@-2 {{add @available attribute to enclosing global function}}
-
 }
 
 func twoGuardsInSameBlock(_ p: Int) {
+        // expected-note@-1 {{add @available attribute to enclosing global function}}
   if (p > 0) {
     guard #available(OSX 10.51, *) else { return }
 
@@ -1178,7 +1142,6 @@
 
   let _ = globalFuncAvailableOn10_51() // expected-error {{'globalFuncAvailableOn10_51()' is only available on OS X 10.51 or newer}}
         // expected-note@-1 {{add 'if #available' version check}}
-        // expected-note@-2 {{add @available attribute to enclosing global function}}
 }
 
 // Refining while loops
@@ -1219,134 +1182,125 @@
       // expected-note@-2 {{add 'if #available' version check}} {{1-57=if #available(OSX 10.51, *) {\n    let declForFixitAtTopLevel: ClassAvailableOn10_51? = nil\n} else {\n    // Fallback on earlier versions\n}}}
 
 func fixitForReferenceInGlobalFunction() {
+      // expected-note@-1 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.51, *)\n}}
   functionAvailableOn10_51()
       // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add 'if #available' version check}} {{3-29=if #available(OSX 10.51, *) {\n      functionAvailableOn10_51()\n  } else {\n      // Fallback on earlier versions\n  }}}
-      // expected-note@-3 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.51, *)\n}}
+      
 }
 
 public func fixitForReferenceInGlobalFunctionWithDeclModifier() {
+      // expected-note@-1 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.51, *)\n}}
   functionAvailableOn10_51()
       // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add 'if #available' version check}} {{3-29=if #available(OSX 10.51, *) {\n      functionAvailableOn10_51()\n  } else {\n      // Fallback on earlier versions\n  }}}
-      // expected-note@-3 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.51, *)\n}}
+      
 }
 
 func fixitForReferenceInGlobalFunctionWithAttribute() -> Never {
+    // expected-note@-1 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.51, *)\n}}
   functionAvailableOn10_51()
     // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
     // expected-note@-2 {{add 'if #available' version check}} {{3-29=if #available(OSX 10.51, *) {\n      functionAvailableOn10_51()\n  } else {\n      // Fallback on earlier versions\n  }}}
-    // expected-note@-3 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.51, *)\n}}
+    
 }
 
 func takesAutoclosure(_ c : @autoclosure () -> ()) {
 }
 
 class ClassForFixit {
+        // expected-note@-1 12{{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
   func fixitForReferenceInMethod() {
+        // expected-note@-1 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
     functionAvailableOn10_51()
         // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
         // expected-note@-2 {{add 'if #available' version check}} {{5-31=if #available(OSX 10.51, *) {\n        functionAvailableOn10_51()\n    } else {\n        // Fallback on earlier versions\n    }}}
-        // expected-note@-3 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
-        // expected-note@-4 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
   }
 
   func fixitForReferenceNestedInMethod() {
+          // expected-note@-1 3{{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
     func inner() {
       functionAvailableOn10_51()
           // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
           // expected-note@-2 {{add 'if #available' version check}} {{7-33=if #available(OSX 10.51, *) {\n          functionAvailableOn10_51()\n      } else {\n          // Fallback on earlier versions\n      }}}
-          // expected-note@-3 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
-          // expected-note@-4 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
     }
 
     let _: () -> () = { () in
       functionAvailableOn10_51()
           // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
           // expected-note@-2 {{add 'if #available' version check}} {{7-33=if #available(OSX 10.51, *) {\n          functionAvailableOn10_51()\n      } else {\n          // Fallback on earlier versions\n      }}}
-          // expected-note@-3 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
-          // expected-note@-4 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
     }
 
     takesAutoclosure(functionAvailableOn10_51())
           // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
           // expected-note@-2 {{add 'if #available' version check}} {{5-49=if #available(OSX 10.51, *) {\n        takesAutoclosure(functionAvailableOn10_51())\n    } else {\n        // Fallback on earlier versions\n    }}}
-          // expected-note@-3 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
-          // expected-note@-4 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
+          
   }
 
   var fixitForReferenceInPropertyAccessor: Int {
+        // expected-note@-1 {{add @available attribute to enclosing var}} {{3-3=@available(OSX 10.51, *)\n  }}
     get {
       functionAvailableOn10_51()
         // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
         // expected-note@-2 {{add 'if #available' version check}} {{7-33=if #available(OSX 10.51, *) {\n          functionAvailableOn10_51()\n      } else {\n          // Fallback on earlier versions\n      }}}
-        // expected-note@-3 {{add @available attribute to enclosing var}} {{3-3=@available(OSX 10.51, *)\n  }}
-        // expected-note@-4 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
-
+        
       return 5
     }
   }
 
   var fixitForReferenceInPropertyType: ClassAvailableOn10_51? = nil
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-2 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
 
   lazy var fixitForReferenceInLazyPropertyType: ClassAvailableOn10_51? = nil
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add @available attribute to enclosing var}} {{3-3=@available(OSX 10.51, *)\n  }}
-      // expected-note@-3 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
 
   private lazy var fixitForReferenceInPrivateLazyPropertyType: ClassAvailableOn10_51? = nil
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add @available attribute to enclosing var}} {{3-3=@available(OSX 10.51, *)\n  }}
-      // expected-note@-3 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
 
   lazy private var fixitForReferenceInLazyPrivatePropertyType: ClassAvailableOn10_51? = nil
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add @available attribute to enclosing var}} {{3-3=@available(OSX 10.51, *)\n  }}
-      // expected-note@-3 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
 
   static var fixitForReferenceInStaticPropertyType: ClassAvailableOn10_51? = nil
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add @available attribute to enclosing static var}} {{3-3=@available(OSX 10.51, *)\n  }}
-      // expected-note@-3 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
 
   var fixitForReferenceInPropertyTypeMultiple: ClassAvailableOn10_51? = nil, other: Int = 7
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-2 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
 
   func fixitForRefInGuardOfIf() {
+        // expected-note@-1 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
     if (globalFuncAvailableOn10_51() > 1066) {
       let _ = 5
       let _ = 6
     }
         // expected-error@-4 {{'globalFuncAvailableOn10_51()' is only available on OS X 10.51 or newer}}
         // expected-note@-5 {{add 'if #available' version check}} {{5-6=if #available(OSX 10.51, *) {\n        if (globalFuncAvailableOn10_51() > 1066) {\n          let _ = 5\n          let _ = 6\n        }\n    } else {\n        // Fallback on earlier versions\n    }}}
-        // expected-note@-6 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
-        // expected-note@-7 {{add @available attribute to enclosing class}} {{1-1=@available(OSX 10.51, *)\n}}
   }
 }
 
 extension ClassToExtend {
+        // expected-note@-1 {{add @available attribute to enclosing extension}}
   func fixitForReferenceInExtensionMethod() {
+        // expected-note@-1 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
     functionAvailableOn10_51()
         // expected-error@-1 {{'functionAvailableOn10_51()' is only available on OS X 10.51 or newer}}
         // expected-note@-2 {{add 'if #available' version check}} {{5-31=if #available(OSX 10.51, *) {\n        functionAvailableOn10_51()\n    } else {\n        // Fallback on earlier versions\n    }}}
-        // expected-note@-3 {{add @available attribute to enclosing instance method}} {{3-3=@available(OSX 10.51, *)\n  }}
-        // expected-note@-4 {{add @available attribute to enclosing extension}} {{1-1=@available(OSX 10.51, *)\n}}
   }
 }
 
 enum EnumForFixit {
+      // expected-note@-1 2{{add @available attribute to enclosing enum}} {{1-1=@available(OSX 10.51, *)\n}}
   case CaseWithUnavailablePayload(p: ClassAvailableOn10_51)
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add @available attribute to enclosing case}} {{3-3=@available(OSX 10.51, *)\n  }}
-      // expected-note@-3 {{add @available attribute to enclosing enum}} {{1-1=@available(OSX 10.51, *)\n}}
 
   case CaseWithUnavailablePayload2(p: ClassAvailableOn10_51), WithoutPayload
       // expected-error@-1 {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-2 {{add @available attribute to enclosing case}} {{3-3=@available(OSX 10.51, *)\n  }}
-      // expected-note@-3 {{add @available attribute to enclosing enum}} {{1-1=@available(OSX 10.51, *)\n}}
+      
 }
 
 @objc
@@ -1360,31 +1314,31 @@
 }
 
 func testForFixitWithNestedMemberRefExpr() {
+    // expected-note@-1 2{{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.52, *)\n}}
   let x = X()
 
   x.y.z = globalFuncAvailableOn10_52()
       // expected-error@-1 {{'globalFuncAvailableOn10_52()' is only available on OS X 10.52 or newer}}
       // expected-note@-2 {{add 'if #available' version check}} {{3-39=if #available(OSX 10.52, *) {\n      x.y.z = globalFuncAvailableOn10_52()\n  } else {\n      // Fallback on earlier versions\n  }}}
-      // expected-note@-3 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.52, *)\n}}
 
   // Access via dynamic member reference
   let anyX: AnyObject = x
   anyX.y?.z = globalFuncAvailableOn10_52()
       // expected-error@-1 {{'globalFuncAvailableOn10_52()' is only available on OS X 10.52 or newer}}
       // expected-note@-2 {{add 'if #available' version check}} {{3-43=if #available(OSX 10.52, *) {\n      anyX.y?.z = globalFuncAvailableOn10_52()\n  } else {\n      // Fallback on earlier versions\n  }}}
-      // expected-note@-3 {{add @available attribute to enclosing global function}} {{1-1=@available(OSX 10.52, *)\n}}
+      
 }
 
 // Protocol Conformances
 
 protocol ProtocolWithRequirementMentioningUnavailable {
+      // expected-note@-1 6{{add @available attribute to enclosing protocol}}
   func hasUnavailableParameter(_ p: ClassAvailableOn10_51) // expected-error * {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-1 * {{add @available attribute to enclosing instance method}}
-      // expected-note@-2 * {{add @available attribute to enclosing protocol}}
+      
 
   func hasUnavailableReturn() -> ClassAvailableOn10_51 // expected-error * {{'ClassAvailableOn10_51' is only available on OS X 10.51 or newer}}
       // expected-note@-1 * {{add @available attribute to enclosing instance method}}
-      // expected-note@-2 * {{add @available attribute to enclosing protocol}}
 
   @available(OSX 10.51, *)
   func hasUnavailableWithAnnotation(_ p: ClassAvailableOn10_51) -> ClassAvailableOn10_51
@@ -1530,15 +1484,15 @@
 }
 
 func useUnavailableProtocolMethod(_ h: HasUnavailableMethodF) {
-  h.f("Foo") // expected-error {{'f' is only available on OS X 10.51 or newer}}
       // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+  h.f("Foo") // expected-error {{'f' is only available on OS X 10.51 or newer}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 func useUnavailableProtocolMethod<H : HasUnavailableMethodF> (_ h: H) {
-  h.f("Foo") // expected-error {{'f' is only available on OS X 10.51 or newer}}
       // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+  h.f("Foo") // expected-error {{'f' is only available on OS X 10.51 or newer}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 
@@ -1569,9 +1523,9 @@
 
 @available(iOS 14.0, *)
 func funcWithShortFormAvailableOniOS14() {
+  // expected-note@-1 {{add @available attribute to enclosing global function}}
   let _ = ClassWithShortFormAvailableOn10_51() // expected-error {{'ClassWithShortFormAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 @available(iOS 14.0, OSX 10.53, *)
@@ -1601,25 +1555,23 @@
 func unavailableWins() { } // expected-note {{'unavailableWins()' has been explicitly marked unavailable here}}
 
 func useShortFormAvailable() {
+  // expected-note@-1 4{{add @available attribute to enclosing global function}}
+
   funcWithShortFormAvailableOn10_9()
 
   funcWithShortFormAvailableOn10_51() // expected-error {{'funcWithShortFormAvailableOn10_51()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   funcWithShortFormAvailableOniOS14()
 
   funcWithShortFormAvailableOniOS14AndOSX10_53() // expected-error {{'funcWithShortFormAvailableOniOS14AndOSX10_53()' is only available on OS X 10.53 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   funcWithMultipleShortFormAnnotationsForDifferentPlatforms() // expected-error {{'funcWithMultipleShortFormAnnotationsForDifferentPlatforms()' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   funcWithMultipleShortFormAnnotationsForTheSamePlatform() // expected-error {{'funcWithMultipleShortFormAnnotationsForTheSamePlatform()' is only available on OS X 10.53 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   unavailableWins() // expected-error {{'unavailableWins()' is unavailable}}
-}
+}
\ No newline at end of file
diff --git a/test/Sema/availability_versions_objc_api.swift b/test/Sema/availability_versions_objc_api.swift
index 265e943..8eb9821 100644
--- a/test/Sema/availability_versions_objc_api.swift
+++ b/test/Sema/availability_versions_objc_api.swift
@@ -8,9 +8,9 @@
 
 // Tests for uses of version-based potential unavailability imported from ObjC APIs.
 func callUnavailableObjC() {
+      // expected-note@-1 5{{add @available attribute to enclosing global function}}
   _ = NSAvailableOn10_51() // expected-error {{'NSAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
   
   
   if #available(OSX 10.51, *) {
@@ -18,23 +18,19 @@
     
     // Properties
     _ = o.propertyOn10_52 // expected-error {{'propertyOn10_52' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
 
     o.propertyOn10_52 = 22 // expected-error {{'propertyOn10_52' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
     
     // Methods
     o.methodAvailableOn10_52() // expected-error {{'methodAvailableOn10_52()' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
     
     // Initializers
     
     _ = NSAvailableOn10_51(stringOn10_52:"Hi") // expected-error {{'init(stringOn10_52:)' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
   }
 }
 
@@ -74,50 +70,43 @@
 // Differing availability on getters and setters imported from ObjC.
 
 func gettersAndSettersFromObjC(o: NSAvailableOn10_9) {
+      // expected-note@-1 6{{add @available attribute to enclosing global function}}
   let _: Int = o.propertyOn10_51WithSetterOn10_52After  // expected-error {{'propertyOn10_51WithSetterOn10_52After' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   if #available(OSX 10.51, *) {
     // Properties with unavailable accessors declared before property in Objective-C header
     o.propertyOn10_51WithSetterOn10_52Before = 5 // expected-error {{setter for 'propertyOn10_51WithSetterOn10_52Before' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
 
     let _: Int = o.propertyOn10_51WithGetterOn10_52Before // expected-error {{getter for 'propertyOn10_51WithGetterOn10_52Before' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
 
     // Properties with unavailable accessors declared after property in Objective-C header
     o.propertyOn10_51WithSetterOn10_52After = 5 // expected-error {{setter for 'propertyOn10_51WithSetterOn10_52After' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
 
     let _: Int = o.propertyOn10_51WithGetterOn10_52After // expected-error {{getter for 'propertyOn10_51WithGetterOn10_52After' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
 
     // Property with unavailable setter redeclared in Objective-C category
     o.readOnlyRedeclaredWithSetterInCategory = 5 // expected-error {{setter for 'readOnlyRedeclaredWithSetterInCategory' is only available on OS X 10.52 or newer}}
-        // expected-note@-1 {{add @available attribute to enclosing global function}}
-        // expected-note@-2 {{add 'if #available' version check}}
+        // expected-note@-1 {{add 'if #available' version check}}
   }
 }
 
 // Globals from Objective-C
 
 func useGlobalsFromObjectiveC() {
+      // expected-note@-1 3{{add @available attribute to enclosing global function}}
   _ = globalStringAvailableOn10_51 // expected-error {{'globalStringAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   _ = globalStringAvailableOn10_52 // expected-error {{'globalStringAvailableOn10_52' is only available on OS X 10.52 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   _ = globalClassInstanceAvailableOn10_51 // expected-error {{'globalClassInstanceAvailableOn10_51' is only available on OS X 10.51 or newer}}
-      // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+      // expected-note@-1 {{add 'if #available' version check}}
 
   if #available(OSX 10.51, *) {
     _ = globalStringAvailableOn10_51
@@ -177,9 +166,9 @@
 }
 
 func callViaUnannotatedFrameworkProtocol(p: UnannotatedFrameworkProtocol) {
-  let _ = p.returnSomething() // expected-error {{'returnSomething()' is only available on OS X 10.51 or newer}}
       // expected-note@-1 {{add @available attribute to enclosing global function}}
-      // expected-note@-2 {{add 'if #available' version check}}
+  let _ = p.returnSomething() // expected-error {{'returnSomething()' is only available on OS X 10.51 or newer}}
+      // expected-note@-1 {{add 'if #available' version check}}
 }
 
 func callViaAnnotatedFrameworkProtocol(p: AnnotatedFrameworkProtocol) {
diff --git a/test/Serialization/Inputs/def_objc_conforming.swift b/test/Serialization/Inputs/def_objc_conforming.swift
new file mode 100644
index 0000000..c229fa7
--- /dev/null
+++ b/test/Serialization/Inputs/def_objc_conforming.swift
@@ -0,0 +1,9 @@
+import Foundation
+
+@objc public protocol Proto {
+  @objc optional func badness()
+}
+
+public class Foo: Proto {
+  public var badness: Int = 0 // unrelated
+}
diff --git a/test/Serialization/objc_optional_reqs.swift b/test/Serialization/objc_optional_reqs.swift
new file mode 100644
index 0000000..998c062
--- /dev/null
+++ b/test/Serialization/objc_optional_reqs.swift
@@ -0,0 +1,16 @@
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+
+// FIXME: BEGIN -enable-source-import hackaround
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t %clang-importer-sdk-path/swift-modules/Foundation.swift
+// FIXME: END -enable-source-import hackaround
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-module -o %t %S/Inputs/def_objc_conforming.swift
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -typecheck %s -verify
+
+// REQUIRES: objc_interop
+
+// SR-3917
+import def_objc_conforming
+
+func test(x: Foo) { _ = x.badness }
diff --git a/test/SourceKit/CursorInfo/cursor_info_expressions.swift b/test/SourceKit/CursorInfo/cursor_info_expressions.swift
new file mode 100644
index 0000000..56f1ee3
--- /dev/null
+++ b/test/SourceKit/CursorInfo/cursor_info_expressions.swift
@@ -0,0 +1,14 @@
+protocol P1 {}
+
+struct S1 : P1 {}
+
+func test(_ o: P1?) {
+  switch o {
+  case let s as S1:
+    test(s)
+  }
+}
+
+// RUN: %sourcekitd-test -req=cursor -pos=7:17 %s -- %s | %FileCheck -check-prefix=CHECK1 %s
+// CHECK1: source.lang.swift.ref.struct (3:8-3:10)
+// CHECK1: S1
diff --git a/test/api-digester/Outputs/Cake.txt b/test/api-digester/Outputs/Cake.txt
index 3a7fdcd..b12cbeb 100644
--- a/test/api-digester/Outputs/Cake.txt
+++ b/test/api-digester/Outputs/Cake.txt
@@ -7,8 +7,8 @@
 Func S1.foo5(x:y:) has been renamed to Func S1.foo5(x:y:z:)
 
 /* Type Changes */
-Constructor S1.init(_:) has 1st parameter type change from Int to Double
-Func C1.foo2(_:) has 1st parameter type change from Int to () -> ()
+Constructor S1.init(_:) has parameter 0 type change from Int to Double
+Func C1.foo2(_:) has parameter 0 type change from Int to () -> ()
 
 /* Decl Attribute changes */
 Var C1.CIIns1 changes from weak to strong
diff --git a/test/api-digester/source-stability.swift.expected b/test/api-digester/source-stability.swift.expected
index 89f7ef7..113fda8 100644
--- a/test/api-digester/source-stability.swift.expected
+++ b/test/api-digester/source-stability.swift.expected
@@ -26,20 +26,20 @@
 Var Dictionary.startIndex has declared type change from DictionaryIndex<Key, Value> to Dictionary<Key, Value>.Index
 Var Set.endIndex has declared type change from SetIndex<Element> to Set<Element>.Index
 Var Set.startIndex has declared type change from SetIndex<Element> to Set<Element>.Index
-Constructor AnyIterator.init(_:) has 1st parameter type change from () -> Element? to () -> AnyIterator.Element?
-Constructor BidirectionalSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<BidirectionalSlice.Index>
-Constructor MutableBidirectionalSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<MutableBidirectionalSlice.Index>
-Constructor MutableRandomAccessSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<MutableRandomAccessSlice.Index>
-Constructor MutableRangeReplaceableBidirectionalSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableBidirectionalSlice.Index>
-Constructor MutableRangeReplaceableRandomAccessSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableRandomAccessSlice.Index>
-Constructor MutableRangeReplaceableSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableSlice.Index>
-Constructor MutableSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<MutableSlice.Index>
-Constructor RandomAccessSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<RandomAccessSlice.Index>
-Constructor RangeReplaceableBidirectionalSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<RangeReplaceableBidirectionalSlice.Index>
-Constructor RangeReplaceableRandomAccessSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<RangeReplaceableRandomAccessSlice.Index>
-Constructor RangeReplaceableSlice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<RangeReplaceableSlice.Index>
-Constructor Slice.init(base:bounds:) has 2nd parameter type change from Range<Base.Index> to Range<Slice.Index>
-Constructor String.init(stringInterpolationSegment:) has 1st parameter type change from String to T
+Constructor AnyIterator.init(_:) has parameter 0 type change from () -> Element? to () -> AnyIterator.Element?
+Constructor BidirectionalSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<BidirectionalSlice.Index>
+Constructor MutableBidirectionalSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<MutableBidirectionalSlice.Index>
+Constructor MutableRandomAccessSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<MutableRandomAccessSlice.Index>
+Constructor MutableRangeReplaceableBidirectionalSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<MutableRangeReplaceableBidirectionalSlice.Index>
+Constructor MutableRangeReplaceableRandomAccessSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<MutableRangeReplaceableRandomAccessSlice.Index>
+Constructor MutableRangeReplaceableSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<MutableRangeReplaceableSlice.Index>
+Constructor MutableSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<MutableSlice.Index>
+Constructor RandomAccessSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<RandomAccessSlice.Index>
+Constructor RangeReplaceableBidirectionalSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<RangeReplaceableBidirectionalSlice.Index>
+Constructor RangeReplaceableRandomAccessSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<RangeReplaceableRandomAccessSlice.Index>
+Constructor RangeReplaceableSlice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<RangeReplaceableSlice.Index>
+Constructor Slice.init(base:bounds:) has parameter 1 type change from Range<Base.Index> to Range<Slice.Index>
+Constructor String.init(stringInterpolationSegment:) has parameter 0 type change from String to T
 Func AnyBidirectionalCollection.makeIterator() has return type change from AnyIterator<Element> to AnyBidirectionalCollection.Iterator
 Func AnyCollection.makeIterator() has return type change from AnyIterator<Element> to AnyCollection.Iterator
 Func AnyRandomAccessCollection.makeIterator() has return type change from AnyIterator<Element> to AnyRandomAccessCollection.Iterator
@@ -73,30 +73,30 @@
 Func FlattenBidirectionalCollection.index(after:) has return type change from FlattenBidirectionalCollectionIndex<Base> to FlattenBidirectionalCollection.Index
 Func FlattenBidirectionalCollection.index(before:) has return type change from FlattenBidirectionalCollectionIndex<Base> to FlattenBidirectionalCollection.Index
 Func FlattenCollection.index(after:) has return type change from FlattenCollectionIndex<Base> to FlattenCollection.Index
-Func LazyBidirectionalCollection.distance(from:to:) has 1st parameter type change from Base.Index to LazyBidirectionalCollection.Index
+Func LazyBidirectionalCollection.distance(from:to:) has parameter 0 type change from Base.Index to LazyBidirectionalCollection.Index
 Func LazyBidirectionalCollection.index(_:offsetBy:) has return type change from Base.Index to LazyBidirectionalCollection.Index
 Func LazyBidirectionalCollection.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to LazyBidirectionalCollection.Index?
-Func LazyCollection.distance(from:to:) has 1st parameter type change from Base.Index to LazyCollection.Index
+Func LazyCollection.distance(from:to:) has parameter 0 type change from Base.Index to LazyCollection.Index
 Func LazyCollection.index(_:offsetBy:) has return type change from Base.Index to LazyCollection.Index
 Func LazyCollection.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to LazyCollection.Index?
 Func LazyFilterBidirectionalCollection.index(after:) has return type change from LazyFilterIndex<Base> to LazyFilterBidirectionalCollection.Index
 Func LazyFilterBidirectionalCollection.index(before:) has return type change from LazyFilterIndex<Base> to LazyFilterBidirectionalCollection.Index
 Func LazyFilterCollection.index(after:) has return type change from LazyFilterIndex<Base> to LazyFilterCollection.Index
-Func LazyMapBidirectionalCollection.distance(from:to:) has 1st parameter type change from Base.Index to LazyMapBidirectionalCollection.Index
+Func LazyMapBidirectionalCollection.distance(from:to:) has parameter 0 type change from Base.Index to LazyMapBidirectionalCollection.Index
 Func LazyMapBidirectionalCollection.index(_:offsetBy:) has return type change from Base.Index to LazyMapBidirectionalCollection.Index
 Func LazyMapBidirectionalCollection.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to LazyMapBidirectionalCollection.Index?
 Func LazyMapBidirectionalCollection.index(after:) has return type change from Base.Index to LazyMapBidirectionalCollection.Index
 Func LazyMapBidirectionalCollection.index(before:) has return type change from Base.Index to LazyMapBidirectionalCollection.Index
-Func LazyMapCollection.distance(from:to:) has 1st parameter type change from Base.Index to LazyMapCollection.Index
+Func LazyMapCollection.distance(from:to:) has parameter 0 type change from Base.Index to LazyMapCollection.Index
 Func LazyMapCollection.index(_:offsetBy:) has return type change from Base.Index to LazyMapCollection.Index
 Func LazyMapCollection.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to LazyMapCollection.Index?
 Func LazyMapCollection.index(after:) has return type change from Base.Index to LazyMapCollection.Index
-Func LazyMapRandomAccessCollection.distance(from:to:) has 1st parameter type change from Base.Index to LazyMapRandomAccessCollection.Index
+Func LazyMapRandomAccessCollection.distance(from:to:) has parameter 0 type change from Base.Index to LazyMapRandomAccessCollection.Index
 Func LazyMapRandomAccessCollection.index(_:offsetBy:) has return type change from Base.Index to LazyMapRandomAccessCollection.Index
 Func LazyMapRandomAccessCollection.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to LazyMapRandomAccessCollection.Index?
 Func LazyMapRandomAccessCollection.index(after:) has return type change from Base.Index to LazyMapRandomAccessCollection.Index
 Func LazyMapRandomAccessCollection.index(before:) has return type change from Base.Index to LazyMapRandomAccessCollection.Index
-Func LazyRandomAccessCollection.distance(from:to:) has 1st parameter type change from Base.Index to LazyRandomAccessCollection.Index
+Func LazyRandomAccessCollection.distance(from:to:) has parameter 0 type change from Base.Index to LazyRandomAccessCollection.Index
 Func LazyRandomAccessCollection.index(_:offsetBy:) has return type change from Base.Index to LazyRandomAccessCollection.Index
 Func LazyRandomAccessCollection.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to LazyRandomAccessCollection.Index?
 Func MutableBidirectionalSlice.distance(from:to:) has return type change from Base.IndexDistance to MutableBidirectionalSlice.IndexDistance
@@ -114,30 +114,30 @@
 Func MutableRangeReplaceableBidirectionalSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to MutableRangeReplaceableBidirectionalSlice.Index?
 Func MutableRangeReplaceableBidirectionalSlice.index(after:) has return type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
 Func MutableRangeReplaceableBidirectionalSlice.index(before:) has return type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
-Func MutableRangeReplaceableBidirectionalSlice.insert(_:at:) has 2nd parameter type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
-Func MutableRangeReplaceableBidirectionalSlice.insert(contentsOf:at:) has 2nd parameter type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
-Func MutableRangeReplaceableBidirectionalSlice.remove(at:) has 1st parameter type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
-Func MutableRangeReplaceableBidirectionalSlice.removeSubrange(_:) has 1st parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableBidirectionalSlice.Index>
-Func MutableRangeReplaceableBidirectionalSlice.replaceSubrange(_:with:) has 1st parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableBidirectionalSlice.Index>
+Func MutableRangeReplaceableBidirectionalSlice.insert(_:at:) has parameter 1 type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
+Func MutableRangeReplaceableBidirectionalSlice.insert(contentsOf:at:) has parameter 1 type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
+Func MutableRangeReplaceableBidirectionalSlice.remove(at:) has parameter 0 type change from Base.Index to MutableRangeReplaceableBidirectionalSlice.Index
+Func MutableRangeReplaceableBidirectionalSlice.removeSubrange(_:) has parameter 0 type change from Range<Base.Index> to Range<MutableRangeReplaceableBidirectionalSlice.Index>
+Func MutableRangeReplaceableBidirectionalSlice.replaceSubrange(_:with:) has parameter 0 type change from Range<Base.Index> to Range<MutableRangeReplaceableBidirectionalSlice.Index>
 Func MutableRangeReplaceableRandomAccessSlice.distance(from:to:) has return type change from Base.IndexDistance to MutableRangeReplaceableRandomAccessSlice.IndexDistance
 Func MutableRangeReplaceableRandomAccessSlice.index(_:offsetBy:) has return type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
 Func MutableRangeReplaceableRandomAccessSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to MutableRangeReplaceableRandomAccessSlice.Index?
 Func MutableRangeReplaceableRandomAccessSlice.index(after:) has return type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
 Func MutableRangeReplaceableRandomAccessSlice.index(before:) has return type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
-Func MutableRangeReplaceableRandomAccessSlice.insert(_:at:) has 2nd parameter type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
-Func MutableRangeReplaceableRandomAccessSlice.insert(contentsOf:at:) has 2nd parameter type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
-Func MutableRangeReplaceableRandomAccessSlice.remove(at:) has 1st parameter type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
-Func MutableRangeReplaceableRandomAccessSlice.removeSubrange(_:) has 1st parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableRandomAccessSlice.Index>
-Func MutableRangeReplaceableRandomAccessSlice.replaceSubrange(_:with:) has 1st parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableRandomAccessSlice.Index>
+Func MutableRangeReplaceableRandomAccessSlice.insert(_:at:) has parameter 1 type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
+Func MutableRangeReplaceableRandomAccessSlice.insert(contentsOf:at:) has parameter 1 type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
+Func MutableRangeReplaceableRandomAccessSlice.remove(at:) has parameter 0 type change from Base.Index to MutableRangeReplaceableRandomAccessSlice.Index
+Func MutableRangeReplaceableRandomAccessSlice.removeSubrange(_:) has parameter 0 type change from Range<Base.Index> to Range<MutableRangeReplaceableRandomAccessSlice.Index>
+Func MutableRangeReplaceableRandomAccessSlice.replaceSubrange(_:with:) has parameter 0 type change from Range<Base.Index> to Range<MutableRangeReplaceableRandomAccessSlice.Index>
 Func MutableRangeReplaceableSlice.distance(from:to:) has return type change from Base.IndexDistance to MutableRangeReplaceableSlice.IndexDistance
 Func MutableRangeReplaceableSlice.index(_:offsetBy:) has return type change from Base.Index to MutableRangeReplaceableSlice.Index
 Func MutableRangeReplaceableSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to MutableRangeReplaceableSlice.Index?
 Func MutableRangeReplaceableSlice.index(after:) has return type change from Base.Index to MutableRangeReplaceableSlice.Index
-Func MutableRangeReplaceableSlice.insert(_:at:) has 2nd parameter type change from Base.Index to MutableRangeReplaceableSlice.Index
-Func MutableRangeReplaceableSlice.insert(contentsOf:at:) has 2nd parameter type change from Base.Index to MutableRangeReplaceableSlice.Index
-Func MutableRangeReplaceableSlice.remove(at:) has 1st parameter type change from Base.Index to MutableRangeReplaceableSlice.Index
-Func MutableRangeReplaceableSlice.removeSubrange(_:) has 1st parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableSlice.Index>
-Func MutableRangeReplaceableSlice.replaceSubrange(_:with:) has 1st parameter type change from Range<Base.Index> to Range<MutableRangeReplaceableSlice.Index>
+Func MutableRangeReplaceableSlice.insert(_:at:) has parameter 1 type change from Base.Index to MutableRangeReplaceableSlice.Index
+Func MutableRangeReplaceableSlice.insert(contentsOf:at:) has parameter 1 type change from Base.Index to MutableRangeReplaceableSlice.Index
+Func MutableRangeReplaceableSlice.remove(at:) has parameter 0 type change from Base.Index to MutableRangeReplaceableSlice.Index
+Func MutableRangeReplaceableSlice.removeSubrange(_:) has parameter 0 type change from Range<Base.Index> to Range<MutableRangeReplaceableSlice.Index>
+Func MutableRangeReplaceableSlice.replaceSubrange(_:with:) has parameter 0 type change from Range<Base.Index> to Range<MutableRangeReplaceableSlice.Index>
 Func MutableSlice.distance(from:to:) has return type change from Base.IndexDistance to MutableSlice.IndexDistance
 Func MutableSlice.index(_:offsetBy:) has return type change from Base.Index to MutableSlice.Index
 Func MutableSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to MutableSlice.Index?
@@ -146,7 +146,7 @@
 Func OptionSet.remove(_:) has return type change from Self? to Self.Element?
 Func OptionSet.update(with:) has return type change from Self? to Self.Element?
 Func RandomAccessCollection.distance(from:to:) has return type change from Self.IndexDistance to Self.Index.Stride
-Func RandomAccessCollection.index(_:offsetBy:) has 2nd parameter type change from Self.IndexDistance to Self.Index.Stride
+Func RandomAccessCollection.index(_:offsetBy:) has parameter 1 type change from Self.IndexDistance to Self.Index.Stride
 Func RandomAccessSlice.distance(from:to:) has return type change from Base.IndexDistance to RandomAccessSlice.IndexDistance
 Func RandomAccessSlice.index(_:offsetBy:) has return type change from Base.Index to RandomAccessSlice.Index
 Func RandomAccessSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to RandomAccessSlice.Index?
@@ -157,30 +157,30 @@
 Func RangeReplaceableBidirectionalSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to RangeReplaceableBidirectionalSlice.Index?
 Func RangeReplaceableBidirectionalSlice.index(after:) has return type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
 Func RangeReplaceableBidirectionalSlice.index(before:) has return type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
-Func RangeReplaceableBidirectionalSlice.insert(_:at:) has 2nd parameter type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
-Func RangeReplaceableBidirectionalSlice.insert(contentsOf:at:) has 2nd parameter type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
-Func RangeReplaceableBidirectionalSlice.remove(at:) has 1st parameter type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
-Func RangeReplaceableBidirectionalSlice.removeSubrange(_:) has 1st parameter type change from Range<Base.Index> to Range<RangeReplaceableBidirectionalSlice.Index>
-Func RangeReplaceableBidirectionalSlice.replaceSubrange(_:with:) has 1st parameter type change from Range<Base.Index> to Range<RangeReplaceableBidirectionalSlice.Index>
+Func RangeReplaceableBidirectionalSlice.insert(_:at:) has parameter 1 type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
+Func RangeReplaceableBidirectionalSlice.insert(contentsOf:at:) has parameter 1 type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
+Func RangeReplaceableBidirectionalSlice.remove(at:) has parameter 0 type change from Base.Index to RangeReplaceableBidirectionalSlice.Index
+Func RangeReplaceableBidirectionalSlice.removeSubrange(_:) has parameter 0 type change from Range<Base.Index> to Range<RangeReplaceableBidirectionalSlice.Index>
+Func RangeReplaceableBidirectionalSlice.replaceSubrange(_:with:) has parameter 0 type change from Range<Base.Index> to Range<RangeReplaceableBidirectionalSlice.Index>
 Func RangeReplaceableRandomAccessSlice.distance(from:to:) has return type change from Base.IndexDistance to RangeReplaceableRandomAccessSlice.IndexDistance
 Func RangeReplaceableRandomAccessSlice.index(_:offsetBy:) has return type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
 Func RangeReplaceableRandomAccessSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to RangeReplaceableRandomAccessSlice.Index?
 Func RangeReplaceableRandomAccessSlice.index(after:) has return type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
 Func RangeReplaceableRandomAccessSlice.index(before:) has return type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
-Func RangeReplaceableRandomAccessSlice.insert(_:at:) has 2nd parameter type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
-Func RangeReplaceableRandomAccessSlice.insert(contentsOf:at:) has 2nd parameter type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
-Func RangeReplaceableRandomAccessSlice.remove(at:) has 1st parameter type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
-Func RangeReplaceableRandomAccessSlice.removeSubrange(_:) has 1st parameter type change from Range<Base.Index> to Range<RangeReplaceableRandomAccessSlice.Index>
-Func RangeReplaceableRandomAccessSlice.replaceSubrange(_:with:) has 1st parameter type change from Range<Base.Index> to Range<RangeReplaceableRandomAccessSlice.Index>
+Func RangeReplaceableRandomAccessSlice.insert(_:at:) has parameter 1 type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
+Func RangeReplaceableRandomAccessSlice.insert(contentsOf:at:) has parameter 1 type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
+Func RangeReplaceableRandomAccessSlice.remove(at:) has parameter 0 type change from Base.Index to RangeReplaceableRandomAccessSlice.Index
+Func RangeReplaceableRandomAccessSlice.removeSubrange(_:) has parameter 0 type change from Range<Base.Index> to Range<RangeReplaceableRandomAccessSlice.Index>
+Func RangeReplaceableRandomAccessSlice.replaceSubrange(_:with:) has parameter 0 type change from Range<Base.Index> to Range<RangeReplaceableRandomAccessSlice.Index>
 Func RangeReplaceableSlice.distance(from:to:) has return type change from Base.IndexDistance to RangeReplaceableSlice.IndexDistance
 Func RangeReplaceableSlice.index(_:offsetBy:) has return type change from Base.Index to RangeReplaceableSlice.Index
 Func RangeReplaceableSlice.index(_:offsetBy:limitedBy:) has return type change from Base.Index? to RangeReplaceableSlice.Index?
 Func RangeReplaceableSlice.index(after:) has return type change from Base.Index to RangeReplaceableSlice.Index
-Func RangeReplaceableSlice.insert(_:at:) has 2nd parameter type change from Base.Index to RangeReplaceableSlice.Index
-Func RangeReplaceableSlice.insert(contentsOf:at:) has 2nd parameter type change from Base.Index to RangeReplaceableSlice.Index
-Func RangeReplaceableSlice.remove(at:) has 1st parameter type change from Base.Index to RangeReplaceableSlice.Index
-Func RangeReplaceableSlice.removeSubrange(_:) has 1st parameter type change from Range<Base.Index> to Range<RangeReplaceableSlice.Index>
-Func RangeReplaceableSlice.replaceSubrange(_:with:) has 1st parameter type change from Range<Base.Index> to Range<RangeReplaceableSlice.Index>
+Func RangeReplaceableSlice.insert(_:at:) has parameter 1 type change from Base.Index to RangeReplaceableSlice.Index
+Func RangeReplaceableSlice.insert(contentsOf:at:) has parameter 1 type change from Base.Index to RangeReplaceableSlice.Index
+Func RangeReplaceableSlice.remove(at:) has parameter 0 type change from Base.Index to RangeReplaceableSlice.Index
+Func RangeReplaceableSlice.removeSubrange(_:) has parameter 0 type change from Range<Base.Index> to Range<RangeReplaceableSlice.Index>
+Func RangeReplaceableSlice.replaceSubrange(_:with:) has parameter 0 type change from Range<Base.Index> to Range<RangeReplaceableSlice.Index>
 Func ReversedCollection.distance(from:to:) has return type change from Base.IndexDistance to ReversedCollection.IndexDistance
 Func ReversedCollection.index(_:offsetBy:) has return type change from ReversedIndex<Base> to ReversedCollection.Index
 Func ReversedCollection.index(_:offsetBy:limitedBy:) has return type change from ReversedIndex<Base>? to ReversedCollection.Index?
@@ -191,19 +191,19 @@
 Func ReversedRandomAccessCollection.index(_:offsetBy:limitedBy:) has return type change from ReversedRandomAccessIndex<Base>? to ReversedRandomAccessCollection.Index?
 Func ReversedRandomAccessCollection.index(after:) has return type change from ReversedRandomAccessIndex<Base> to ReversedRandomAccessCollection.Index
 Func ReversedRandomAccessCollection.index(before:) has return type change from ReversedRandomAccessIndex<Base> to ReversedRandomAccessCollection.Index
-Func Set.formSymmetricDifference(_:) has 1st parameter type change from Set<Element> to Set<Set.Element>
+Func Set.formSymmetricDifference(_:) has parameter 0 type change from Set<Element> to Set<Set.Element>
 Func Set.index(after:) has return type change from SetIndex<Element> to Set<Element>.Index
 Func Set.index(of:) has return type change from SetIndex<Element>? to Set<Element>.Index?
 Func Set.intersection(_:) has return type change from Set<Element> to Set<Set.Element>
-Func Set.isDisjoint(with:) has 1st parameter type change from Set<Element> to Set<Set.Element>
-Func Set.isStrictSubset(of:) has 1st parameter type change from Set<Element> to Set<Set.Element>
-Func Set.isStrictSuperset(of:) has 1st parameter type change from Set<Element> to Set<Set.Element>
-Func Set.isSubset(of:) has 1st parameter type change from Set<Element> to Set<Set.Element>
-Func Set.isSuperset(of:) has 1st parameter type change from Set<Element> to Set<Set.Element>
+Func Set.isDisjoint(with:) has parameter 0 type change from Set<Element> to Set<Set.Element>
+Func Set.isStrictSubset(of:) has parameter 0 type change from Set<Element> to Set<Set.Element>
+Func Set.isStrictSuperset(of:) has parameter 0 type change from Set<Element> to Set<Set.Element>
+Func Set.isSubset(of:) has parameter 0 type change from Set<Element> to Set<Set.Element>
+Func Set.isSuperset(of:) has parameter 0 type change from Set<Element> to Set<Set.Element>
 Func Set.popFirst() has return type change from Element? to Set.Element?
-Func Set.remove(at:) has 1st parameter type change from SetIndex<Element> to Set<Element>.Index
+Func Set.remove(at:) has parameter 0 type change from SetIndex<Element> to Set<Element>.Index
 Func Set.removeFirst() has return type change from Element to Set.Element
-Func Set.subtract(_:) has 1st parameter type change from Set<Element> to Set<Set.Element>
+Func Set.subtract(_:) has parameter 0 type change from Set<Element> to Set<Set.Element>
 Func Set.subtracting(_:) has return type change from Set<Element> to Set<Set.Element>
 Func Set.symmetricDifference(_:) has return type change from Set<Element> to Set<Set.Element>
 Func Set.union(_:) has return type change from Set<Element> to Set<Set.Element>
@@ -213,7 +213,7 @@
 Func Slice.index(after:) has return type change from Base.Index to Slice.Index
 
 /* Function type change */
-Func UnsafePointer.withMemoryRebound(to:capacity:_:) has 3rd parameter type change from (UnsafeMutablePointer<T>) throws -> Result to (UnsafePointer<T>) throws -> Result
+Func UnsafePointer.withMemoryRebound(to:capacity:_:) has parameter 2 type change from (UnsafeMutablePointer<T>) throws -> Result to (UnsafePointer<T>) throws -> Result
 
 /* FIXME: Bogus */
 Func Zip2Iterator.next() has return type change from (Iterator1.Element, Iterator2.Element)? to Zip2Iterator.Element?
diff --git a/test/attr/attr_availability_narrow.swift b/test/attr/attr_availability_narrow.swift
index 1dee604..836c504 100644
--- a/test/attr/attr_availability_narrow.swift
+++ b/test/attr/attr_availability_narrow.swift
@@ -32,10 +32,10 @@
 }
 
 func useFooWayOff() {
+    // expected-note@-1{{add @available attribute to enclosing global function}}
   if #available(OSX 10.10, *) {
     foo() // expected-error {{'foo()' is only available on OS X 10.12.2 or newer}}
-    // expected-note@-1{{add @available attribute to enclosing global function}}
-    // expected-note@-2{{add 'if #available' version check}}
+    // expected-note@-1{{add 'if #available' version check}}
   }
 }
 
diff --git a/test/decl/protocol/conforms/fixit_stub.swift b/test/decl/protocol/conforms/fixit_stub.swift
index 6fd9a29..95b82c0 100644
--- a/test/decl/protocol/conforms/fixit_stub.swift
+++ b/test/decl/protocol/conforms/fixit_stub.swift
@@ -1,14 +1,14 @@
 // RUN: %target-typecheck-verify-swift
 
 protocol Protocol1 {
-  func foo(arg1: Int, arg2: String) -> String // expected-note{{protocol requires function 'foo(arg1:arg2:)' with type '(Int, String) -> String'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n}}
-  func bar() throws -> String // expected-note{{protocol requires function 'bar()' with type '() throws -> String'; do you want to add a stub?}} {{27-27=\n    func bar() throws -> String {\n        <#code#>\n    \}\n}}
-  func generic<T>(t: T) // expected-note{{protocol requires function 'generic(t:)' with type '<T> (t: T) -> ()'; do you want to add a stub?}} {{27-27=\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n}}
-  init(arg: Int) // expected-note{{protocol requires initializer 'init(arg:)' with type '(arg: Int)'; do you want to add a stub?}} {{27-27=\n    required init(arg: Int) {\n        <#code#>\n    \}\n}}
-  var baz: Int { get } // expected-note{{protocol requires property 'baz' with type 'Int'; do you want to add a stub?}} {{27-27=\n    var baz: Int\n}}
-  var baz2: Int { get set } // expected-note{{protocol requires property 'baz2' with type 'Int'; do you want to add a stub?}} {{27-27=\n    var baz2: Int\n}}
-  subscript(arg: Int) -> String { get } //expected-note{{rotocol requires subscript with type '(Int) -> String'; do you want to add a stub?}} {{27-27=\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n}}
-  subscript(arg1: Int, arg2: Int) -> String { get set } //expected-note{{protocol requires subscript with type '(Int, Int) -> String'; do you want to add a stub?}} {{27-27=\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  func foo(arg1: Int, arg2: String) -> String // expected-note{{protocol requires function 'foo(arg1:arg2:)' with type '(Int, String) -> String'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  func bar() throws -> String // expected-note{{protocol requires function 'bar()' with type '() throws -> String'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  func generic<T>(t: T) // expected-note{{protocol requires function 'generic(t:)' with type '<T> (t: T) -> ()'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  init(arg: Int) // expected-note{{protocol requires initializer 'init(arg:)' with type '(arg: Int)'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  var baz: Int { get } // expected-note{{protocol requires property 'baz' with type 'Int'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  var baz2: Int { get set } // expected-note{{protocol requires property 'baz2' with type 'Int'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  subscript(arg: Int) -> String { get } //expected-note{{rotocol requires subscript with type '(Int) -> String'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  subscript(arg1: Int, arg2: Int) -> String { get set } //expected-note{{protocol requires subscript with type '(Int, Int) -> String'; do you want to add a stub?}} {{27-27=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    func generic<T>(t: T) {\n        <#code#>\n    \}\n\n    required init(arg: Int) {\n        <#code#>\n    \}\n\n    var baz: Int\n\n    var baz2: Int\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
 }
 
 class Adopter: Protocol1 { // expected-error{{type 'Adopter' does not conform to protocol 'Protocol1'}} expected-note{{candidate has non-matching type '()'}}
@@ -17,13 +17,13 @@
 
 
 protocol Protocol2 {
-  func foo(arg1: Int, arg2: String) -> String // expected-note{{protocol requires function 'foo(arg1:arg2:)' with type '(Int, String) -> String'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n}}
-  func bar() throws -> String // expected-note{{protocol requires function 'bar()' with type '() throws -> String'; do you want to add a stub?}} {{32-32=\n    func bar() throws -> String {\n        <#code#>\n    \}\n}}
+  func foo(arg1: Int, arg2: String) -> String // expected-note{{protocol requires function 'foo(arg1:arg2:)' with type '(Int, String) -> String'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    var baz: Int {\n        <#code#>\n    \}\n\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  func bar() throws -> String // expected-note{{protocol requires function 'bar()' with type '() throws -> String'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    var baz: Int {\n        <#code#>\n    \}\n\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
   init(arg: Int) // expected-note{{protocol requires initializer 'init(arg:)' with type '(arg: Int)'}} {{none}}
-  var baz: Int { get } // expected-note{{protocol requires property 'baz' with type 'Int'; do you want to add a stub?}} {{32-32=\n    var baz: Int {\n        <#code#>\n    \}\n}}
-  var baz2: Int { get set } // expected-note{{protocol requires property 'baz2' with type 'Int'; do you want to add a stub?}} {{32-32=\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
-  subscript(arg: Int) -> String { get } //expected-note{{rotocol requires subscript with type '(Int) -> String'; do you want to add a stub?}} {{32-32=\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n}}
-  subscript(arg1: Int, arg2: Int) -> String { get set } //expected-note{{protocol requires subscript with type '(Int, Int) -> String'; do you want to add a stub?}} {{32-32=\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  var baz: Int { get } // expected-note{{protocol requires property 'baz' with type 'Int'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    var baz: Int {\n        <#code#>\n    \}\n\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  var baz2: Int { get set } // expected-note{{protocol requires property 'baz2' with type 'Int'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    var baz: Int {\n        <#code#>\n    \}\n\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  subscript(arg: Int) -> String { get } //expected-note{{rotocol requires subscript with type '(Int) -> String'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    var baz: Int {\n        <#code#>\n    \}\n\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
+  subscript(arg1: Int, arg2: Int) -> String { get set } //expected-note{{protocol requires subscript with type '(Int, Int) -> String'; do you want to add a stub?}} {{32-32=\n    func foo(arg1: Int, arg2: String) -> String {\n        <#code#>\n    \}\n\n    func bar() throws -> String {\n        <#code#>\n    \}\n\n    var baz: Int {\n        <#code#>\n    \}\n\n    var baz2: Int {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n\n    subscript(arg: Int) -> String {\n        <#code#>\n    \}\n\n    subscript(arg1: Int, arg2: Int) -> String {\n        get {\n            <#code#>\n        \}\n        set {\n            <#code#>\n        \}\n    \}\n}}
 }
 
 class Adopter2 {} //  expected-note{{candidate has non-matching type '()'}}
@@ -55,8 +55,8 @@
 
 
 protocol ProtocolWithSelfRequirement {
-  func foo() -> Self // expected-note{{protocol requires function 'foo()' with type '() -> Adopter5'; do you want to add a stub?}} {{47-47=\n    func foo() -> Adopter5 {\n        <#code#>\n    \}\n}}
-  func foo(lhs: Self, rhs: Self) -> Self //expected-note{{protocol requires function 'foo(lhs:rhs:)' with type '(Adopter5, Adopter5) -> Adopter5'; do you want to add a stub?}} {{47-47=\n    func foo(lhs: Adopter5, rhs: Adopter5) -> Adopter5 {\n        <#code#>\n    \}\n}}
+  func foo() -> Self // expected-note{{protocol requires function 'foo()' with type '() -> Adopter5'; do you want to add a stub?}} {{47-47=\n    func foo() -> Adopter5 {\n        <#code#>\n    \}\n\n    func foo(lhs: Adopter5, rhs: Adopter5) -> Adopter5 {\n        <#code#>\n    \}\n}}
+  func foo(lhs: Self, rhs: Self) -> Self //expected-note{{protocol requires function 'foo(lhs:rhs:)' with type '(Adopter5, Adopter5) -> Adopter5'; do you want to add a stub?}} {{47-47=\n    func foo() -> Adopter5 {\n        <#code#>\n    \}\n\n    func foo(lhs: Adopter5, rhs: Adopter5) -> Adopter5 {\n        <#code#>\n    \}\n}}
 }
 
 struct Adopter5: ProtocolWithSelfRequirement { //expected-error{{type 'Adopter5' does not conform to protocol 'ProtocolWithSelfRequirement'}}
@@ -65,8 +65,8 @@
 
 
 protocol ProtocolWithSelfRequirement2 {
-  func foo() -> Self // expected-note{{protocol requires function 'foo()' with type '() -> Adopter6'; do you want to add a stub?}} {{51-51=\n    func foo() -> Adopter6 {\n        <#code#>\n    \}\n}}
-  func foo(lhs: Self, rhs: Self) -> Self //expected-note{{protocol requires function 'foo(lhs:rhs:)' with type '(Adopter6, Adopter6) -> Adopter6'; do you want to add a stub?}} {{51-51=\n    func foo(lhs: Adopter6, rhs: Adopter6) -> Adopter6 {\n        <#code#>\n    \}\n}}
+  func foo() -> Self // expected-note{{protocol requires function 'foo()' with type '() -> Adopter6'; do you want to add a stub?}} {{51-51=\n    func foo() -> Adopter6 {\n        <#code#>\n    \}\n\n    func foo(lhs: Adopter6, rhs: Adopter6) -> Adopter6 {\n        <#code#>\n    \}\n}}
+  func foo(lhs: Self, rhs: Self) -> Self //expected-note{{protocol requires function 'foo(lhs:rhs:)' with type '(Adopter6, Adopter6) -> Adopter6'; do you want to add a stub?}} {{51-51=\n    func foo() -> Adopter6 {\n        <#code#>\n    \}\n\n    func foo(lhs: Adopter6, rhs: Adopter6) -> Adopter6 {\n        <#code#>\n    \}\n}}
 }
 
 struct Adopter6 {}
@@ -76,8 +76,8 @@
 
 
 protocol ProtocolWithSelfRequirement3 {
-  func foo() -> Self // expected-note{{protocol requires function 'foo()' with type '() -> Self'; do you want to add a stub?}} {{47-47=\n    func foo() -> Self {\n        <#code#>\n    \}\n}}
-  func foo(lhs: Self, rhs: Self) -> Self //expected-note{{protocol requires function 'foo(lhs:rhs:)' with type '(Adopter7, Adopter7) -> Self'; do you want to add a stub?}} {{47-47=\n    func foo(lhs: Adopter7, rhs: Adopter7) -> Self {\n        <#code#>\n    \}\n}}
+  func foo() -> Self // expected-note{{protocol requires function 'foo()' with type '() -> Self'; do you want to add a stub?}} {{47-47=\n    func foo() -> Self {\n        <#code#>\n    \}\n\n    func foo(lhs: Adopter7, rhs: Adopter7) -> Self {\n        <#code#>\n    \}\n}}
+  func foo(lhs: Self, rhs: Self) -> Self //expected-note{{protocol requires function 'foo(lhs:rhs:)' with type '(Adopter7, Adopter7) -> Self'; do you want to add a stub?}} {{47-47=\n    func foo() -> Self {\n        <#code#>\n    \}\n\n    func foo(lhs: Adopter7, rhs: Adopter7) -> Self {\n        <#code#>\n    \}\n}}
 }
 
 class Adopter7: ProtocolWithSelfRequirement3 { //expected-error{{type 'Adopter7' does not conform to protocol 'ProtocolWithSelfRequirement3'}}
diff --git a/test/decl/protocol/protocols.swift b/test/decl/protocol/protocols.swift
index f82826b..5a188c7 100644
--- a/test/decl/protocol/protocols.swift
+++ b/test/decl/protocol/protocols.swift
@@ -422,7 +422,7 @@
 struct X3<T : P1> where T.Assoc : P2 {}
 
 struct X4 : P1 { // expected-error{{type 'X4' does not conform to protocol 'P1'}}
-  func getX1() -> X3<X4> { return X3() } // expected-error{{cannot convert return expression of type 'X3<_>' to return type 'X3<X4>'}}
+  func getX1() -> X3<X4> { return X3() }
 }
 
 protocol ShouldntCrash {
diff --git a/test/lit.cfg b/test/lit.cfg
index dd05346..a08a49e 100644
--- a/test/lit.cfg
+++ b/test/lit.cfg
@@ -1079,3 +1079,5 @@
     # finishSwigPythonLLDB.py in the lldb repo
     python_lib_dir = get_python_lib(True, False, config.lldb_build_root)
     config.substitutions.append(('%lldb-python-path', python_lib_dir))
+
+lit_config.note("Available features: " + ", ".join(config.available_features))
diff --git a/tools/swift-api-digester/swift-api-digester.cpp b/tools/swift-api-digester/swift-api-digester.cpp
index 7c22c6f..d51b958 100644
--- a/tools/swift-api-digester/swift-api-digester.cpp
+++ b/tools/swift-api-digester/swift-api-digester.cpp
@@ -737,16 +737,10 @@
                                                       unsigned Index) {
   if (Index == 0) {
     return Ctx.buffer("return");
-  } else if (Index == 1) {
-    return Ctx.buffer("1st parameter");
-  } else if (Index == 2) {
-    return Ctx.buffer("2nd parameter");
-  } else if (Index == 3) {
-    return Ctx.buffer("3rd parameter");
   } else {
     llvm::SmallString<4> Buffer;
-    Buffer += std::to_string(Index);
-    Buffer += "th parameter";
+    Buffer += "parameter ";
+    Buffer += std::to_string(Index - 1);
     return Ctx.buffer(Buffer.str());
   }
 }
@@ -3497,15 +3491,19 @@
   options::ModuleCachePath;
 
   if (!options::SwiftVersion.empty()) {
-    if (auto Version = version::Version::
-        parseVersionString(options::SwiftVersion, SourceLoc(), nullptr)) {
-      if (Version.getValue().isValidEffectiveLanguageVersion())
-        InitInvok.getLangOptions().EffectiveLanguageVersion = Version.getValue();
-      else {
-        llvm::errs() << "Unsupported Swift Version.\n";
-        return 1;
+    using version::Version;
+    bool isValid = false;
+    if (auto Version = Version::parseVersionString(options::SwiftVersion,
+                                                   SourceLoc(), nullptr)) {
+      if (auto Effective = Version.getValue().getEffectiveLanguageVersion()) {
+        InitInvok.getLangOptions().EffectiveLanguageVersion = *Effective;
+        isValid = true;
       }
     }
+    if (!isValid) {
+      llvm::errs() << "Unsupported Swift Version.\n";
+      return 1;
+    }
   }
 
   if (!options::ResourceDir.empty()) {
diff --git a/tools/swift-demangle/swift-demangle.cpp b/tools/swift-demangle/swift-demangle.cpp
index e4b1a3e..596fc88 100644
--- a/tools/swift-demangle/swift-demangle.cpp
+++ b/tools/swift-demangle/swift-demangle.cpp
@@ -99,8 +99,15 @@
       // mangling and demangling tests.
       remangled = name;
     } else {
+      // Also accept the future mangling prefix.
+      // TODO: remove the "_S" as soon as MANGLING_PREFIX_STR gets "_S".
       remangled = swift::Demangle::mangleNode(pointer,
-                          /*NewMangling*/ name.startswith(MANGLING_PREFIX_STR));
+                          /*NewMangling*/ name.startswith(MANGLING_PREFIX_STR)
+                                          || name.startswith("_S"));
+      if (name.startswith("_S")) {
+        assert(remangled.find(MANGLING_PREFIX_STR) == 0);
+        remangled = "_S" + remangled.substr(3);
+      }
       if (name != remangled) {
         llvm::errs() << "\nError: re-mangled name \n  " << remangled
                      << "\ndoes not match original name\n  " << name << '\n';
@@ -130,8 +137,19 @@
       std::string cName = name.str();
       if (!swift::Demangle::isSwiftSymbol(cName.c_str()))
         Classifications += 'N';
-      if (DCtx.isThunkSymbol(name))
-        Classifications += 'T';
+      if (DCtx.isThunkSymbol(name)) {
+        if (!Classifications.empty())
+          Classifications += ',';
+        Classifications += "T:";
+        Classifications += DCtx.getThunkTarget(name);
+      } else {
+        assert(DCtx.getThunkTarget(name).empty());
+      }
+      if (pointer && !DCtx.hasSwiftCallingConvention(name)) {
+        if (!Classifications.empty())
+          Classifications += ',';
+        Classifications += 'C';
+      }
       if (!Classifications.empty())
         llvm::outs() << '{' << Classifications << "} ";
     }
@@ -142,7 +160,9 @@
 
 static int demangleSTDIN(const swift::Demangle::DemangleOptions &options) {
   // This doesn't handle Unicode symbols, but maybe that's okay.
-  llvm::Regex maybeSymbol("(_T|" MANGLING_PREFIX_STR ")[_a-zA-Z0-9$]+");
+  // Also accept the future mangling prefix.
+  // TODO: remove the "_S" as soon as MANGLING_PREFIX_STR gets "_S".
+  llvm::Regex maybeSymbol("(_T|_S|" MANGLING_PREFIX_STR ")[_a-zA-Z0-9$]+");
 
   swift::Demangle::Context DCtx;
   for (std::string mangled; std::getline(std::cin, mangled);) {
diff --git a/tools/swift-ide-test/swift-ide-test.cpp b/tools/swift-ide-test/swift-ide-test.cpp
index 00f11f4..83425c7 100644
--- a/tools/swift-ide-test/swift-ide-test.cpp
+++ b/tools/swift-ide-test/swift-ide-test.cpp
@@ -2957,7 +2957,8 @@
     if (auto swiftVersion =
           version::Version::parseVersionString(options::SwiftVersion,
                                                SourceLoc(), nullptr)) {
-      InitInvok.getLangOptions().EffectiveLanguageVersion = *swiftVersion;
+      if (auto actual = swiftVersion.getValue().getEffectiveLanguageVersion())
+        InitInvok.getLangOptions().EffectiveLanguageVersion = actual.getValue();
     }
   }
   InitInvok.getClangImporterOptions().ModuleCachePath =
diff --git a/unittests/Syntax/CMakeLists.txt b/unittests/Syntax/CMakeLists.txt
index d812d93..1b9f0cf 100644
--- a/unittests/Syntax/CMakeLists.txt
+++ b/unittests/Syntax/CMakeLists.txt
@@ -4,6 +4,7 @@
   GenericSyntaxTests.cpp
   RawSyntaxTests.cpp
   StmtSyntaxTests.cpp
+  SyntaxCollectionTests.cpp
   ThreadSafeCachingTests.cpp
   TriviaTests.cpp
   TypeSyntaxTests.cpp
diff --git a/unittests/Syntax/DeclSyntaxTests.cpp b/unittests/Syntax/DeclSyntaxTests.cpp
index ae6d857..7640dfe 100644
--- a/unittests/Syntax/DeclSyntaxTests.cpp
+++ b/unittests/Syntax/DeclSyntaxTests.cpp
@@ -1,5 +1,7 @@
 #include "swift/Syntax/SyntaxFactory.h"
 #include "swift/Syntax/DeclSyntax.h"
+#include "swift/Syntax/ExprSyntax.h"
+#include "swift/Syntax/StmtSyntax.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
@@ -9,6 +11,63 @@
 using namespace swift;
 using namespace swift::syntax;
 
+#pragma mark - declaration-modifier
+
+DeclModifierSyntax getCannedDeclModifier() {
+  auto Private = SyntaxFactory::makeIdentifier("private", {}, {});
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto Set = SyntaxFactory::makeIdentifier("set", {}, {});
+  auto RParen = SyntaxFactory::makeRightParenToken({}, {});
+  return SyntaxFactory::makeDeclModifier(Private, LParen, Set, RParen);
+}
+
+TEST(DeclSyntaxTests, DeclModifierMakeAPIs) {
+  {
+    SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankDeclModifier().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+    SmallString<24> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    getCannedDeclModifier().print(OS);
+    ASSERT_EQ(OS.str().str(), "private(set)");
+  }
+}
+
+TEST(DeclSyntaxTests, DeclModifierGetAPIs) {
+  auto Private = SyntaxFactory::makeIdentifier("private", {}, {});
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto Set = SyntaxFactory::makeIdentifier("set", {}, {});
+  auto RParen = SyntaxFactory::makeRightParenToken({}, {});
+  auto Mod = SyntaxFactory::makeDeclModifier(Private, LParen, Set, RParen);
+
+  ASSERT_EQ(Private, Mod.getName());
+  ASSERT_EQ(LParen, Mod.getLeftParenToken());
+  ASSERT_EQ(Set, Mod.getArgument());
+  ASSERT_EQ(RParen, Mod.getRightParenToken());
+}
+
+TEST(DeclSyntaxTests, DeclModifierWithAPIs) {
+  auto Private = SyntaxFactory::makeIdentifier("private", {}, {});
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto Set = SyntaxFactory::makeIdentifier("set", {}, {});
+  auto RParen = SyntaxFactory::makeRightParenToken({}, {});
+
+  SmallString<24> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  SyntaxFactory::makeBlankDeclModifier()
+    .withName(Private)
+    .withLeftParenToken(LParen)
+    .withArgument(Set)
+    .withRightParenToken(RParen)
+    .print(OS);
+  ASSERT_EQ(OS.str().str(), "private(set)");
+}
+
+#pragma mark - typealias-decl
+
 TEST(DeclSyntaxTests, TypealiasMakeAPIs) {
   {
     SmallString<1> Scratch;
@@ -25,8 +84,7 @@
     auto ElementParam =
       SyntaxFactory::makeGenericParameter("Element", {}, {});
     auto LeftAngle = SyntaxFactory::makeLeftAngleToken({}, {});
-    auto RightAngle =
-      SyntaxFactory::makeRightAngleToken({}, { Trivia::spaces(1) });
+    auto RightAngle = SyntaxFactory::makeRightAngleToken({}, Trivia::spaces(1));
     auto GenericParams = GenericParameterClauseBuilder()
       .useLeftAngleBracket(LeftAngle)
       .useRightAngleBracket(RightAngle)
@@ -137,3 +195,402 @@
   ASSERT_EQ(OS.str().str(),
             "typealias MyCollection<Element> = Array<Element>");
 }
+
+#pragma mark - parameter
+
+FunctionParameterSyntax getCannedFunctionParameter() {
+  auto ExternalName = SyntaxFactory::makeIdentifier("with", {},
+                                                    Trivia::spaces(1));
+  auto LocalName = SyntaxFactory::makeIdentifier("radius", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {},
+                                               Trivia::spaces(1));
+  auto NoEllipsis = TokenSyntax::missingToken(tok::identifier, "...");
+  auto Equal = SyntaxFactory::makeEqualToken({}, Trivia::spaces(1));
+
+  auto Sign = SyntaxFactory::makePrefixOpereator("-", {});
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(Sign, OneDigits);
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+
+  return SyntaxFactory::makeFunctionParameter(ExternalName, LocalName, Colon,
+                                              Int, NoEllipsis, Equal, One,
+                                              Comma);
+}
+
+TEST(DeclSyntaxTests, FunctionParameterMakeAPIs) {
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    getCannedFunctionParameter().print(OS);
+    ASSERT_EQ(OS.str().str(), "with radius: Int = -1, ");
+  }
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionParameter().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+}
+
+TEST(DeclSyntaxTests, FunctionParameterGetAPIs) {
+  auto ExternalName = SyntaxFactory::makeIdentifier("with", {},
+                                                    Trivia::spaces(1));
+  auto LocalName = SyntaxFactory::makeIdentifier("radius", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken({}, Trivia::spaces(1));
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {},
+                                                  Trivia::spaces(1));
+  auto NoEllipsis = TokenSyntax::missingToken(tok::identifier, "...");
+  auto Equal = SyntaxFactory::makeEqualToken({}, Trivia::spaces(1));
+
+  auto Sign = SyntaxFactory::makePrefixOpereator("-", {});
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(Sign, OneDigits);
+  auto Comma = SyntaxFactory::makeCommaToken({}, {});
+
+  auto Param = SyntaxFactory::makeFunctionParameter(ExternalName, LocalName,
+                                                    Colon, Int, NoEllipsis,
+                                                    Equal, One, Comma);
+
+  ASSERT_EQ(ExternalName, Param.getExternalName());
+  ASSERT_EQ(LocalName, Param.getLocalName());
+  ASSERT_EQ(Colon, Param.getColonToken());
+
+  auto GottenType = Param.getTypeSyntax().getValue();
+  auto GottenType2 = Param.getTypeSyntax().getValue();
+  ASSERT_TRUE(GottenType.hasSameIdentityAs(GottenType2));
+
+  ASSERT_EQ(Equal, Param.getEqualToken());
+
+  auto GottenDefaultValue = Param.getDefaultValue().getValue();
+  auto GottenDefaultValue2 = Param.getDefaultValue().getValue();
+  ASSERT_TRUE(GottenDefaultValue.hasSameIdentityAs(GottenDefaultValue2));
+
+  ASSERT_EQ(Comma, Param.getTrailingComma());
+
+  // Test that llvm::None is returned for non-token missing children:
+  auto Decimated = Param
+    .withTypeSyntax(llvm::None)
+    .withDefaultValue(llvm::None);
+
+  ASSERT_FALSE(Decimated.getTypeSyntax().hasValue());
+  ASSERT_FALSE(Decimated.getDefaultValue().hasValue());
+}
+
+TEST(DeclSyntaxTests, FunctionParameterWithAPIs) {
+  auto ExternalName = SyntaxFactory::makeIdentifier("for", {},
+                                                    Trivia::spaces(1));
+  auto LocalName = SyntaxFactory::makeIdentifier("integer", {}, {});
+  auto Colon = SyntaxFactory::makeColonToken(Trivia::spaces(1),
+                                             Trivia::spaces(1));
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {},
+                                                  Trivia::spaces(1));
+  auto Equal = SyntaxFactory::makeEqualToken({}, Trivia::spaces(1));
+
+  auto NoSign = TokenSyntax::missingToken(tok::oper_prefix, "");
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(NoSign, OneDigits);
+  auto Comma = SyntaxFactory::makeCommaToken({}, {});
+
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    getCannedFunctionParameter()
+      .withExternalName(ExternalName)
+      .withLocalName(LocalName)
+      .withColonToken(Colon)
+      .withTypeSyntax(Int)
+      .withEqualToken(Equal)
+      .withDefaultValue(One)
+      .withTrailingComma(Comma)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "for integer : Int = 1,");
+  }
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    getCannedFunctionParameter()
+      .withTypeSyntax(llvm::None)
+      .withDefaultValue(llvm::None)
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "with radius: = , ");
+  }
+}
+
+#pragma mark - parameter-list
+
+TEST(DeclSyntaxTests, FunctionParameterListMakeAPIs) {
+  {
+    SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionParameterList().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto Param = getCannedFunctionParameter();
+    std::vector<FunctionParameterSyntax> Params { Param, Param, Param };
+    SyntaxFactory::makeFunctionParameterList(Params).print(OS);
+    ASSERT_EQ(OS.str().str(),
+      "with radius: Int = -1, with radius: Int = -1, with radius: Int = -1, ");
+  }
+}
+
+#pragma mark - function-signature
+
+FunctionSignatureSyntax getCannedFunctionSignature() {
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto Param = getCannedFunctionParameter();
+  auto List = SyntaxFactory::makeBlankFunctionParameterList()
+    .appending(Param)
+    .appending(Param)
+    .appending(Param)
+    .castTo<FunctionParameterListSyntax>();
+  auto RParen = SyntaxFactory::makeRightParenToken({}, Trivia::spaces(1));
+  auto Throws = SyntaxFactory::makeThrowsKeyword({}, Trivia::spaces(1));
+  auto Arrow = SyntaxFactory::makeArrow({}, Trivia::spaces(1));
+  auto NoAttributes = SyntaxFactory::makeBlankTypeAttributes();
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {}, Trivia::spaces(1));
+
+  return SyntaxFactory::makeFunctionSignature(LParen, List, RParen, Throws,
+                                              Arrow, NoAttributes, Int);
+}
+
+TEST(DeclSyntaxTests, FunctionSignatureMakeAPIs) {
+  {
+    SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionSignature().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    getCannedFunctionSignature().print(OS);
+    ASSERT_EQ(OS.str().str(),
+      "(with radius: Int = -1, "
+      "with radius: Int = -1, "
+      "with radius: Int = -1, ) throws -> Int ");
+  }
+}
+
+TEST(DeclSyntaxTests, FunctionSignatureGetAPIs) {
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto Param = getCannedFunctionParameter();
+  auto List = SyntaxFactory::makeBlankFunctionParameterList()
+    .appending(Param)
+    .appending(Param)
+    .appending(Param)
+    .castTo<FunctionParameterListSyntax>();
+  auto RParen = SyntaxFactory::makeRightParenToken({}, Trivia::spaces(1));
+  auto Throws = SyntaxFactory::makeThrowsKeyword({}, Trivia::spaces(1));
+  auto Arrow = SyntaxFactory::makeArrow({}, Trivia::spaces(1));
+  auto NoAttributes = SyntaxFactory::makeBlankTypeAttributes();
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {}, {});
+
+  auto Sig = SyntaxFactory::makeFunctionSignature(LParen, List, RParen, Throws,
+                                                  Arrow, NoAttributes, Int);
+
+  ASSERT_EQ(LParen, Sig.getLeftParenToken());
+
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto GottenList1 = Sig.getParameterList();
+    auto GottenList2 = Sig.getParameterList();
+    ASSERT_TRUE(GottenList1.hasSameIdentityAs(GottenList2));
+    GottenList1.print(OS);
+    ASSERT_EQ(OS.str().str(),
+              "with radius: Int = -1, "
+              "with radius: Int = -1, "
+              "with radius: Int = -1, ");
+  }
+
+  ASSERT_EQ(RParen, Sig.getRightParenToken());
+  ASSERT_EQ(Throws, Sig.getThrowsToken());
+  ASSERT_TRUE(Sig.getRethrowsToken()->isMissing());
+  ASSERT_EQ(Arrow, Sig.getArrowToken());
+
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto GottenAttrs1 = Sig.getReturnTypeAttributes();
+    auto GottenAttrs2 = Sig.getReturnTypeAttributes();
+    ASSERT_TRUE(GottenAttrs1.hasSameIdentityAs(GottenAttrs2));
+    ASSERT_EQ(OS.str().str(), "");
+  }
+
+  {
+    SmallString<3> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto GottenReturnType1 = Sig.getReturnTypeSyntax();
+    auto GottenReturnType2 = Sig.getReturnTypeSyntax();
+    ASSERT_TRUE(GottenReturnType1.hasSameIdentityAs(GottenReturnType2));
+    GottenReturnType1.print(OS);
+    ASSERT_EQ(OS.str().str(), "Int");
+  }
+}
+
+TEST(DeclSyntaxTests, FunctionSignatureWithAPIs) {
+  auto LParen = SyntaxFactory::makeLeftParenToken({}, {});
+  auto Param = getCannedFunctionParameter();
+  auto List = SyntaxFactory::makeBlankFunctionParameterList()
+    .appending(Param)
+    .appending(Param)
+    .appending(Param)
+    .castTo<FunctionParameterListSyntax>();
+  auto RParen = SyntaxFactory::makeRightParenToken({}, Trivia::spaces(1));
+  auto Throws = SyntaxFactory::makeThrowsKeyword({}, Trivia::spaces(1));
+  auto Arrow = SyntaxFactory::makeArrow({}, Trivia::spaces(1));
+  auto NoAttributes = SyntaxFactory::makeBlankTypeAttributes();
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {}, {});
+
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  SyntaxFactory::makeBlankFunctionSignature()
+    .withLeftParenToken(LParen)
+    .withParameterList(List)
+    .withRightParenToken(RParen)
+    .withThrowsToken(Throws)
+    .withReturnTypeAttributes(NoAttributes)
+    .withArrowToken(Arrow)
+    .withReturnTypeSyntax(Int)
+    .print(OS);
+  ASSERT_EQ(OS.str().str(),
+            "(with radius: Int = -1, "
+            "with radius: Int = -1, "
+            "with radius: Int = -1, ) throws -> Int");
+}
+
+#pragma mark - function-declaration
+
+DeclModifierListSyntax getCannedModifiers() {
+  auto PublicID = SyntaxFactory::makePublicKeyword({}, Trivia::spaces(1));
+  auto NoLParen = TokenSyntax::missingToken(tok::l_paren, "(");
+  auto NoArgument = TokenSyntax::missingToken(tok::identifier, "");
+  auto NoRParen = TokenSyntax::missingToken(tok::r_paren, ")");
+  auto Public = SyntaxFactory::makeDeclModifier(PublicID, NoLParen, NoArgument,
+                                                NoRParen);
+
+  auto StaticKW = SyntaxFactory::makeStaticKeyword({}, Trivia::spaces(1));
+  auto Static = SyntaxFactory::makeDeclModifier(StaticKW, NoLParen, NoArgument,
+                                                NoRParen);
+
+  return SyntaxFactory::makeBlankDeclModifierList()
+    .appending(Public)
+    .appending(Static)
+    .castTo<DeclModifierListSyntax>();
+}
+
+GenericParameterClauseSyntax getCannedGenericParams() {
+  GenericParameterClauseBuilder GB;
+
+  auto LAngle = SyntaxFactory::makeLeftAngleToken({}, {});
+  auto RAngle = SyntaxFactory::makeRightAngleToken({}, {});
+
+  auto T = SyntaxFactory::makeGenericParameter("T", {}, {});
+  auto U = SyntaxFactory::makeGenericParameter("U", {}, {});
+
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
+
+  GB.addParameter(llvm::None, T);
+  GB.addParameter(Comma, U);
+  GB.useLeftAngleBracket(LAngle);
+  GB.useRightAngleBracket(RAngle);
+
+  return GB.build();
+}
+
+CodeBlockStmtSyntax getCannedBody() {
+  auto NoSign = TokenSyntax::missingToken(tok::oper_prefix, "-");
+  auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
+  auto One = SyntaxFactory::makeIntegerLiteralExpr(NoSign, OneDigits);
+  auto ReturnKW =
+    SyntaxFactory::makeReturnKeyword(Trivia::newlines(1) + Trivia::spaces(2),
+                                     {});
+  auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, One);
+
+  auto Stmts = SyntaxFactory::makeBlankStmtList()
+    .appending(Return)
+    .castTo<StmtListSyntax>();
+
+  auto LBrace = SyntaxFactory::makeLeftBraceToken({}, {});
+  auto RBrace = SyntaxFactory::makeRightBraceToken(Trivia::newlines(1), {});
+
+  return SyntaxFactory::makeCodeBlock(LBrace, Stmts, RBrace);
+}
+
+GenericWhereClauseSyntax getCannedWhereClause() {
+  auto WhereKW = SyntaxFactory::makeWhereKeyword({}, Trivia::spaces(1));
+  auto T = SyntaxFactory::makeTypeIdentifier("T", {}, Trivia::spaces(1));
+  auto EqualEqual = SyntaxFactory::makeEqualityOperator({}, Trivia::spaces(1));
+  auto Int = SyntaxFactory::makeTypeIdentifier("Int", {}, Trivia::spaces(1));
+  auto SameType = SyntaxFactory::makeSameTypeRequirement(T, EqualEqual, Int);
+
+  auto Requirements = SyntaxFactory::makeBlankGenericRequirementList()
+    .appending(SameType.castTo<GenericRequirementSyntax>())
+    .castTo<GenericRequirementListSyntax>();
+
+  return SyntaxFactory::makeBlankGenericWhereClause()
+    .withWhereKeyword(WhereKW)
+    .withRequirementList(Requirements);
+}
+
+FunctionDeclSyntax getCannedFunctionDecl() {
+  auto NoAttributes = SyntaxFactory::makeBlankTypeAttributes();
+  auto Foo = SyntaxFactory::makeIdentifier("foo", {}, {});
+  auto FuncKW = SyntaxFactory::makeFuncKeyword({}, Trivia::spaces(1));
+  auto Modifiers = getCannedModifiers();
+  auto GenericParams = getCannedGenericParams();
+  auto GenericWhere = getCannedWhereClause();
+  auto Signature = getCannedFunctionSignature();
+  auto Body = getCannedBody();
+
+  return SyntaxFactory::makeFunctionDecl(NoAttributes, Modifiers, FuncKW, Foo,
+                                         GenericParams, Signature, GenericWhere,
+                                         Body);
+}
+
+TEST(DeclSyntaxTests, FunctionDeclMakeAPIs) {
+  {
+    SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionDecl().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+    SmallString<64> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    getCannedFunctionDecl().print(OS);
+    ASSERT_EQ(OS.str().str(),
+              "public static func foo<T, U>"
+              "(with radius: Int = -1, "
+              "with radius: Int = -1, "
+              "with radius: Int = -1, ) "
+              "throws -> Int "
+              "where T == Int {\n"
+              "  return1\n"
+              "}");
+  }
+}
+
+TEST(DeclSyntaxTests, FunctionDeclGetAPIs) {
+  {
+    SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionDecl().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+
+  }
+}
+
+TEST(DeclSyntaxTests, FunctionDeclWithAPIs) {
+
+}
+
+TEST(DeclSyntaxTests, FunctionDeclBuilderAPIs) {
+
+}
diff --git a/unittests/Syntax/ExprSyntaxTests.cpp b/unittests/Syntax/ExprSyntaxTests.cpp
index ae95b65..52254fe 100644
--- a/unittests/Syntax/ExprSyntaxTests.cpp
+++ b/unittests/Syntax/ExprSyntaxTests.cpp
@@ -209,9 +209,10 @@
                                                      Comma);
 
   return SyntaxFactory::makeBlankFunctionCallArgumentList()
-    .withAdditionalArgument(Arg)
-    .withAdditionalArgument(Arg.withLabel(Y))
-    .withAdditionalArgument(Arg.withLabel(Z).withTrailingComma(NoComma));
+    .appending(Arg)
+    .appending(Arg.withLabel(Y))
+    .appending(Arg.withLabel(Z).withTrailingComma(NoComma))
+    .castTo<FunctionCallArgumentListSyntax>();
 }
 
 FunctionCallArgumentListSyntax getLabellessArgumentList() {
@@ -235,9 +236,10 @@
                                                           Three, NoComma);
 
   return SyntaxFactory::makeBlankFunctionCallArgumentList()
-    .withAdditionalArgument(OneArg)
-    .withAdditionalArgument(TwoArg)
-    .withAdditionalArgument(ThreeArg);
+    .appending(OneArg)
+    .appending(TwoArg)
+    .appending(ThreeArg)
+    .castTo<FunctionCallArgumentListSyntax>();
 }
 }
 
@@ -255,17 +257,18 @@
                                                      Comma);
 
   auto ArgList = SyntaxFactory::makeBlankFunctionCallArgumentList()
-    .withAdditionalArgument(Arg)
-    .withAdditionalArgument(Arg.withLabel(Y))
-    .withAdditionalArgument(Arg.withLabel(Z).withTrailingComma(NoComma));
+    .appending(Arg)
+    .appending(Arg.withLabel(Y))
+    .appending(Arg.withLabel(Z).withTrailingComma(NoComma))
+    .castTo<FunctionCallArgumentListSyntax>();
 
-  ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+  ASSERT_EQ(ArgList.size(), size_t(3));
 
   {
     llvm::SmallString<16> Scratch;
     llvm::raw_svector_ostream OS(Scratch);
-    auto GottenArg1 = ArgList.getArgument(0);
-    auto GottenArg1_2 = ArgList.getArgument(0);
+    auto GottenArg1 = ArgList[0];
+    auto GottenArg1_2 = ArgList[0];
     ASSERT_TRUE(GottenArg1.hasSameIdentityAs(GottenArg1_2));
     GottenArg1.print(OS);
     ASSERT_EQ(OS.str().str(), "x: foo, ");
@@ -274,8 +277,8 @@
   {
     llvm::SmallString<16> Scratch;
     llvm::raw_svector_ostream OS(Scratch);
-    auto GottenArg2 = ArgList.getArgument(1);
-    auto GottenArg2_2 = ArgList.getArgument(1);
+    auto GottenArg2 = ArgList[1];
+    auto GottenArg2_2 = ArgList[1];
     ASSERT_TRUE(GottenArg2.hasSameIdentityAs(GottenArg2_2));
     GottenArg2.print(OS);
     ASSERT_EQ(OS.str().str(), "y: foo, ");
@@ -284,8 +287,8 @@
   {
     llvm::SmallString<16> Scratch;
     llvm::raw_svector_ostream OS(Scratch);
-    auto GottenArg3 = ArgList.getArgument(2);
-    auto GottenArg3_2 = ArgList.getArgument(2);
+    auto GottenArg3 = ArgList[2];
+    auto GottenArg3_2 = ArgList[2];
     ASSERT_TRUE(GottenArg3.hasSameIdentityAs(GottenArg3_2));
     GottenArg3.print(OS);
     ASSERT_EQ(OS.str().str(), "z: foo");
@@ -321,7 +324,7 @@
     llvm::raw_svector_ostream OS(Scratch);
     auto ArgList = SyntaxFactory::makeFunctionCallArgumentList(Args);
     ArgList.print(OS);
-    ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+    ASSERT_EQ(ArgList.size(), size_t(3));
     ASSERT_EQ(OS.str().str(), "x: foo, y: foo, z: foo");
   }
 }
@@ -330,9 +333,9 @@
   auto ArgList = getFullArgumentList();
   llvm::SmallString<64> Scratch;
   llvm::raw_svector_ostream OS(Scratch);
-  ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+  ASSERT_EQ(ArgList.size(), size_t(3));
   ArgList.print(OS);
-  ASSERT_EQ(ArgList.getNumArguments(), size_t(3));
+  ASSERT_EQ(ArgList.size(), size_t(3));
   ASSERT_EQ(OS.str().str(), "x: foo, y: foo, z: foo");
 }
 
diff --git a/unittests/Syntax/SyntaxCollectionTests.cpp b/unittests/Syntax/SyntaxCollectionTests.cpp
new file mode 100644
index 0000000..656c44d
--- /dev/null
+++ b/unittests/Syntax/SyntaxCollectionTests.cpp
@@ -0,0 +1,260 @@
+#include "swift/Syntax/ExprSyntax.h"
+#include "swift/Syntax/SyntaxFactory.h"
+#include "llvm/ADT/SmallString.h"
+#include "gtest/gtest.h"
+
+using llvm::None;
+using llvm::SmallString;
+
+using namespace swift;
+using namespace swift::syntax;
+
+FunctionCallArgumentSyntax getCannedArgument() {
+  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 NoComma = TokenSyntax::missingToken(tok::comma, ",");
+
+  return SyntaxFactory::makeFunctionCallArgument(X, Colon, SymbolicRef, Comma);
+}
+
+TEST(SyntaxCollectionTests, empty) {
+  auto Empty = SyntaxFactory::makeBlankFunctionCallArgumentList();
+  ASSERT_TRUE(Empty.empty());
+  ASSERT_FALSE(Empty.appending(getCannedArgument()).empty());
+}
+
+TEST(SyntaxCollectionTests, size) {
+  auto Empty = SyntaxFactory::makeBlankFunctionCallArgumentList();
+  ASSERT_EQ(Empty.size(), size_t(0));
+  ASSERT_EQ(Empty.appending(getCannedArgument()).size(), size_t(1));
+}
+
+TEST(SyntaxCollectionTests, subscript) {
+  auto Empty = SyntaxFactory::makeBlankFunctionCallArgumentList();
+#ifndef NDEBUG
+  ASSERT_DEATH({ Empty[0]; }, "");
+#endif
+
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  auto Arg = getCannedArgument();
+  Arg.print(OS);
+
+  auto List = Empty.appending(Arg);
+
+  SmallString<48> GottenScratch;
+  llvm::raw_svector_ostream GottenOS(Scratch);
+  List[0].print(GottenOS);
+
+  ASSERT_EQ(OS.str().str(), GottenOS.str().str());
+
+  auto GottenArg1 = List[0];
+  auto GottenArg2 = List[0];
+  ASSERT_TRUE(GottenArg1.hasSameIdentityAs(GottenArg2));
+}
+
+TEST(SyntaxCollectionTests, appending) {
+  auto Arg = getCannedArgument();
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+  auto List = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .appending(Arg)
+    .appending(Arg)
+    .appending(Arg.withTrailingComma(NoComma));
+
+  ASSERT_EQ(List.size(), size_t(3));
+
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  List.print(OS);
+
+  ASSERT_EQ(OS.str().str(), "x: foo, x: foo, x: foo");
+
+  auto GottenArg0_1 = List[0];
+  auto GottenArg0_2 = List[0];
+  ASSERT_TRUE(GottenArg0_1.hasSameIdentityAs(GottenArg0_2));
+
+  auto GottenArg1_1 = List[1];
+  auto GottenArg1_2 = List[1];
+  ASSERT_TRUE(GottenArg1_1.hasSameIdentityAs(GottenArg1_2));
+
+  auto GottenArg2_1 = List[2];
+  auto GottenArg2_2 = List[2];
+  ASSERT_TRUE(GottenArg2_1.hasSameIdentityAs(GottenArg2_2));
+}
+
+TEST(SyntaxCollectionTests, removingLast) {
+  ASSERT_DEATH({
+    SyntaxFactory::makeBlankFunctionCallArgumentList().removingLast();
+  }, "");
+  auto Arg = getCannedArgument();
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+  auto List = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .appending(Arg)
+    .appending(Arg)
+    .appending(Arg.withTrailingComma(NoComma))
+    .removingLast();
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  List.print(OS);
+  ASSERT_EQ(OS.str().str(), "x: foo, x: foo, ");
+}
+
+TEST(SyntaxCollectionTests, prepending) {
+  auto Arg = getCannedArgument();
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+  auto List = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .prepending(Arg.withTrailingComma(NoComma))
+    .prepending(Arg
+                  .withLabel(SyntaxFactory::makeIdentifier("schwifty", {}, {})))
+    .prepending(Arg);
+
+  ASSERT_EQ(List.size(), size_t(3));
+
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  List.print(OS);
+
+  ASSERT_EQ(OS.str().str(), "x: foo, schwifty: foo, x: foo");
+
+  auto GottenArg0_1 = List[0];
+  auto GottenArg0_2 = List[0];
+  ASSERT_TRUE(GottenArg0_1.hasSameIdentityAs(GottenArg0_2));
+
+  auto GottenArg1_1 = List[1];
+  auto GottenArg1_2 = List[1];
+  ASSERT_TRUE(GottenArg1_1.hasSameIdentityAs(GottenArg1_2));
+
+  auto GottenArg2_1 = List[2];
+  auto GottenArg2_2 = List[2];
+  ASSERT_TRUE(GottenArg2_1.hasSameIdentityAs(GottenArg2_2));
+}
+
+TEST(SyntaxCollectionTests, removingFirst) {
+  ASSERT_DEATH({
+    SyntaxFactory::makeBlankFunctionCallArgumentList().removingFirst();
+  }, "");
+  auto Arg = getCannedArgument();
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+  auto List = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .appending(Arg
+                 .withLabel(SyntaxFactory::makeIdentifier("schwifty", {}, {})))
+    .appending(Arg)
+    .appending(Arg.withTrailingComma(NoComma))
+    .removingFirst();
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  List.print(OS);
+  ASSERT_EQ(OS.str().str(), "x: foo, x: foo");
+}
+
+TEST(SyntaxCollectionTests, inserting) {
+  auto Arg = getCannedArgument();
+  auto NoComma = TokenSyntax::missingToken(tok::comma, ",");
+#ifndef NDEBUG
+  ASSERT_DEATH({
+    SyntaxFactory::makeBlankFunctionCallArgumentList().inserting(1, Arg);
+  }, "");
+#endif
+
+  {
+    SmallString<48> InsertedScratch;
+    llvm::raw_svector_ostream InsertedOS(InsertedScratch);
+    SyntaxFactory::makeBlankFunctionCallArgumentList()
+      .inserting(0, Arg)
+      .inserting(0, Arg)
+      .inserting(0, Arg)
+      .print(InsertedOS);
+
+    SmallString<48> PrependedScratch;
+    llvm::raw_svector_ostream PrependedOS(PrependedScratch);
+    SyntaxFactory::makeBlankFunctionCallArgumentList()
+      .prepending(Arg)
+      .prepending(Arg)
+      .prepending(Arg)
+      .print(PrependedOS);
+    ASSERT_EQ(InsertedOS.str().str(), PrependedOS.str().str());
+  }
+
+  {
+    SmallString<48> InsertedScratch;
+    llvm::raw_svector_ostream InsertedOS(InsertedScratch);
+    SyntaxFactory::makeBlankFunctionCallArgumentList()
+      .inserting(0, Arg)
+      .inserting(1, Arg)
+      .inserting(2, Arg)
+      .print(InsertedOS);
+
+    SmallString<48> AppendedScratch;
+    llvm::raw_svector_ostream AppendedOS(AppendedScratch);
+    SyntaxFactory::makeBlankFunctionCallArgumentList()
+      .appending(Arg)
+      .appending(Arg)
+      .appending(Arg)
+      .print(AppendedOS);
+    ASSERT_EQ(InsertedOS.str().str(), AppendedOS.str().str());
+  }
+
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionCallArgumentList()
+      .appending(Arg)
+      .appending(Arg)
+      .inserting(1,
+                 Arg.withLabel(SyntaxFactory::makeIdentifier("schwifty",
+                                                             {}, {})))
+      .print(OS);
+    ASSERT_EQ(OS.str().str(), "x: foo, schwifty: foo, x: foo, ");
+  }
+}
+
+TEST(SyntaxCollectionTests, cleared) {
+  auto Arg = getCannedArgument();
+  SmallString<1> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  auto List = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .appending(Arg)
+    .appending(Arg)
+    .appending(Arg)
+    .cleared();
+
+  List.print(OS);
+  ASSERT_EQ(OS.str().str(), "");
+  ASSERT_TRUE(List.empty());
+  ASSERT_EQ(List.size(), size_t(0));
+}
+
+TEST(SyntaxCollectionTests, Iteration) {
+  auto Arg = getCannedArgument();
+  auto List = SyntaxFactory::makeBlankFunctionCallArgumentList()
+    .appending(Arg)
+    .appending(Arg)
+    .appending(Arg);
+
+  auto Element0 = List[0];
+  auto Element1 = List[1];
+  auto Element2 = List[2];
+
+  SmallString<48> IteratedScratch;
+  llvm::raw_svector_ostream IteratedOS(IteratedScratch);
+  for (auto Element : List) {
+    Element.print(IteratedOS);
+  }
+  ASSERT_EQ(IteratedOS.str().str(), "x: foo, x: foo, x: foo, ");
+
+  auto IteratedElement0 = List[0];
+  auto IteratedElement1 = List[1];
+  auto IteratedElement2 = List[2];
+
+  ASSERT_TRUE(Element0.hasSameIdentityAs(IteratedElement0));
+  ASSERT_TRUE(Element1.hasSameIdentityAs(IteratedElement1));
+  ASSERT_TRUE(Element2.hasSameIdentityAs(IteratedElement2));
+
+  SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+  List.print(OS);
+  ASSERT_EQ(OS.str().str(), IteratedOS.str().str());
+}
diff --git a/unittests/runtime/Refcounting.cpp b/unittests/runtime/Refcounting.cpp
index d01b279..2ac88d0 100644
--- a/unittests/runtime/Refcounting.cpp
+++ b/unittests/runtime/Refcounting.cpp
@@ -180,7 +180,7 @@
   // RC big, unpinned
   EXPECT_FALSE(swift_isUniquelyReferencedOrPinned_nonNull_native(object));
 
-  auto pinResult = swift_tryPin(object);
+  swift_tryPin(object);
   // RC big, pinned
   EXPECT_TRUE(swift_isUniquelyReferencedOrPinned_nonNull_native(object));
 
diff --git a/unittests/runtime/weak.mm b/unittests/runtime/weak.mm
index 4d55479..80137fa 100644
--- a/unittests/runtime/weak.mm
+++ b/unittests/runtime/weak.mm
@@ -14,7 +14,6 @@
 #include <objc/runtime.h>
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
-#include "swift/Runtime/Metadata.h"
 #include "gtest/gtest.h"
 
 using namespace swift;
diff --git a/utils/build-presets.ini b/utils/build-presets.ini
index 2d5b62e..980335c 100644
--- a/utils/build-presets.ini
+++ b/utils/build-presets.ini
@@ -1002,6 +1002,16 @@
 
 assertions
 
+[preset: LLDB_Swift_DebugAssert_with_devices]
+mixin-preset=
+    LLDB_Swift_DebugAssert
+
+ios
+tvos
+watchos
+build-swift-static-stdlib
+build-swift-static-sdk-overlay
+
 [preset: LLDB_Swift_ReleaseAssert]
 mixin-preset=
     LLDB_Nested
@@ -1009,6 +1019,16 @@
 release-debuginfo
 assertions
 
+[preset: LLDB_Swift_ReleaseAssert_with_devices]
+mixin-preset=
+    LLDB_Swift_ReleaseAssert
+
+ios
+tvos
+watchos
+build-swift-static-stdlib
+build-swift-static-sdk-overlay
+
 #===------------------------------------------------------------------------===#
 # Test all platforms on OS X builder
 #===------------------------------------------------------------------------===#
@@ -1475,3 +1495,23 @@
 swift-stdlib-build-type=RelWithDebInfo
 swift-stdlib-enable-assertions=true
 build-serialized-stdlib-unittest
+
+#===------------------------------------------------------------------------===#
+# Swift Coverage Preset
+#===------------------------------------------------------------------------===#
+
+[preset: buildbot_incremental,tools=RDA,stdlib=RDA,coverage]
+build-subdir=buildbot_incremental_coverage
+release-debuginfo
+assertions
+swift-analyze-code-coverage=not-merged
+test
+validation-test
+skip-test-ios
+skip-test-tvos
+skip-test-watchos
+skip-build-benchmark
+verbose-build
+lit-args=-v
+reconfigure
+build-ninja
diff --git a/utils/build-script-impl b/utils/build-script-impl
index c1e12b2..4779e4a 100755
--- a/utils/build-script-impl
+++ b/utils/build-script-impl
@@ -725,7 +725,6 @@
     llvm_cmake_options+=(
         -DLLVM_TOOL_COMPILER_RT_BUILD:BOOL="$(false_true ${SKIP_BUILD_COMPILER_RT})"
         -DLLVM_BUILD_EXTERNAL_COMPILER_RT:BOOL="$(false_true ${SKIP_BUILD_COMPILER_RT})"
-        -DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING:BOOL=TRUE
     )
 
     # If we are asked to not generate test targets for LLVM and or Swift,
diff --git a/utils/coverage/coverage-generate-data b/utils/coverage/coverage-generate-data
index ca1bf34..35943e8 100755
--- a/utils/coverage/coverage-generate-data
+++ b/utils/coverage/coverage-generate-data
@@ -194,8 +194,6 @@
     parser = argparse.ArgumentParser(
         description='Generate, parse test run profdata')
     parser.add_argument('swift_dir', metavar='swift-dir')
-    parser.add_argument('--build-dir')
-    parser.add_argument('--build-subdir', default='coverage')
     parser.add_argument('--log',
                         help='the level of information to log (default: info)',
                         metavar='LEVEL',
@@ -208,36 +206,17 @@
     logging.debug(args)
 
     swift_dir = os.path.realpath(os.path.abspath(args.swift_dir))
-    if args.build_dir:
-        build_dir = os.path.realpath(os.path.abspath(args.build_dir))
-    else:
-        build_dir = os.path.realpath(os.path.join(os.path.dirname(swift_dir),
-                                                  'build'))
-    build_subdir = os.path.join(build_dir, args.build_subdir)
+    build_dir = os.path.realpath(os.path.join(os.path.dirname(swift_dir),
+                                              'build'))
+    build_subdir = os.path.join(build_dir, 'buildbot_incremental_coverage')
 
     global_build_subdir = build_subdir
 
     build_script_cmd = [
         os.path.join(swift_dir, 'utils/build-script'),
-        '--release',
-        '--no-assertions',
-        '--swift-analyze-code-coverage', 'not-merged',
-        '--test',
-        '--validation-test',
-        '--skip-test-ios',
-        '--skip-test-tvos',
-        '--skip-test-watchos',
-        '--skip-build-benchmark',
-        '--verbose-build',
-        '--lit-args=-v',
-        '--reconfigure',
-        '--build-ninja',
-        '--build-subdir', build_subdir
+        '--preset=buildbot_incremental,tools=RDA,stdlib=RDA,coverage',
     ]
 
-    if args.build_dir:
-        build_script_cmd += ['--build-dir', build_dir]
-
     call(build_script_cmd)
 
     assert global_build_subdir
diff --git a/utils/sil-mode.el b/utils/sil-mode.el
index 6d390d0..b13b3e4 100644
--- a/utils/sil-mode.el
+++ b/utils/sil-mode.el
@@ -76,6 +76,9 @@
    `(,(regexp-opt '("load_borrow" "begin_borrow" "store_borrow" "end_borrow_argument") 'words) . font-lock-keyword-face)
    '("\\(end_borrow\\) %[[:alnum:]] \\(from\\)" (1 font-lock-keyword-face) (2 font-lock-keyword-face))
 
+   ;; SIL Instructions - ownership
+   `(,(regexp-opt '("unchecked_ownership_conversion") 'words) . font-lock-keyword-face)
+
    ;; SIL Instructions - Reference Counting.
    `(,(regexp-opt '("strong_retain"
                     "strong_release" "strong_retain_unowned"
@@ -83,6 +86,7 @@
                     "load_weak" "store_weak"
                     "load_unowned" "store_unowned"
                     "fix_lifetime" "mark_dependence"
+                    "end_lifetime"
                     "is_unique" "is_unique_or_pinned"
                     "copy_block"
                     "strong_unpin" "strong_pin" "is_unique" "is_unique_or_pinned")
diff --git a/utils/swift_build_support/swift_build_support/targets.py b/utils/swift_build_support/swift_build_support/targets.py
index 5cd6a67..ab3e6dc 100644
--- a/utils/swift_build_support/swift_build_support/targets.py
+++ b/utils/swift_build_support/swift_build_support/targets.py
@@ -126,6 +126,8 @@
 
     Android = Platform("android", archs=["armv7"])
 
+    Windows = Platform("windows", archs=["x86_64"])
+
     # The list of known platforms.
     known_platforms = [
         OSX,
@@ -135,7 +137,8 @@
         Linux,
         FreeBSD,
         Cygwin,
-        Android]
+        Android,
+        Windows]
 
     # Cache of targets by name.
     _targets_by_name = dict((target.name, target)
@@ -181,6 +184,10 @@
             if machine == 'x86_64':
                 return StdlibDeploymentTarget.Cygwin.x86_64
 
+        elif system == 'Windows':
+            if machine == "AMD64":
+                return StdlibDeploymentTarget.Windows.x86_64
+
         raise NotImplementedError('System "%s" with architecture "%s" is not '
                                   'supported' % (system, machine))
 
diff --git a/utils/swift_build_support/swift_build_support/toolchain.py b/utils/swift_build_support/swift_build_support/toolchain.py
index 061d224..367384d 100644
--- a/utils/swift_build_support/swift_build_support/toolchain.py
+++ b/utils/swift_build_support/swift_build_support/toolchain.py
@@ -45,8 +45,13 @@
     setattr(Toolchain, name, cache_util.reify(_getter))
 
 
-_register("cc", "clang")
-_register("cxx", "clang++")
+if platform.system() == 'Windows':
+    _register("cc", "clang-cl")
+    _register("cxx", "clang-cl")
+else:
+    _register("cc", "clang")
+    _register("cxx", "clang++")
+
 _register("ninja", "ninja", "ninja-build")
 _register("cmake", "cmake")
 _register("distcc", "distcc")
@@ -173,6 +178,15 @@
     pass
 
 
+class Windows(Toolchain):
+    def find_tool(self, *names):
+        for name in names:
+            found = which(name)
+            if found is not None:
+                return found
+        return None
+
+
 def host_toolchain(**kwargs):
     sys = platform.system()
     if sys == 'Darwin':
@@ -183,6 +197,8 @@
         return FreeBSD()
     elif sys.startswith('CYGWIN'):
         return Cygwin()
+    elif sys == 'Windows':
+        return Windows()
     else:
         raise NotImplementedError('The platform "%s" does not have a defined '
                                   'toolchain.' % sys)
diff --git a/validation-test/compiler_crashers/28700-isactuallycanonicalornull-forming-a-cantype-out-of-a-non-canonical-type.swift b/validation-test/compiler_crashers/28700-isactuallycanonicalornull-forming-a-cantype-out-of-a-non-canonical-type.swift
index 4cba9a3..3894ba7 100644
--- a/validation-test/compiler_crashers/28700-isactuallycanonicalornull-forming-a-cantype-out-of-a-non-canonical-type.swift
+++ b/validation-test/compiler_crashers/28700-isactuallycanonicalornull-forming-a-cantype-out-of-a-non-canonical-type.swift
@@ -6,5 +6,6 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // REQUIRES: asserts
+// REQUIRES: deterministic-behavior
 // RUN: not --crash %target-swift-frontend %s -emit-ir
 { struct c{func ulntatin(UInt=1 + 1 as?Int){a{a
diff --git a/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift b/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift
index 479b7b8..e628c7d 100644
--- a/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift
+++ b/validation-test/compiler_crashers/28702-swift-typebase-getcanonicaltype.swift
@@ -5,5 +5,6 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
+// REQUIRES: deterministic-behavior
 // 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/28706-conformance-failed-to-find-pas-conformance-to-known-protocol.swift b/validation-test/compiler_crashers/28706-conformance-failed-to-find-pas-conformance-to-known-protocol.swift
new file mode 100644
index 0000000..8df4f0e
--- /dev/null
+++ b/validation-test/compiler_crashers/28706-conformance-failed-to-find-pas-conformance-to-known-protocol.swift
@@ -0,0 +1,10 @@
+// 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
+
+// REQUIRES: asserts
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+protocol P{let c{}typealias e:RangeReplaceableCollection}extension P{typealias e:a
diff --git a/validation-test/compiler_crashers/28707-false-encountered-error-in-diagnostic-text.swift b/validation-test/compiler_crashers/28707-false-encountered-error-in-diagnostic-text.swift
new file mode 100644
index 0000000..96aad26
--- /dev/null
+++ b/validation-test/compiler_crashers/28707-false-encountered-error-in-diagnostic-text.swift
@@ -0,0 +1,12 @@
+// 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
+
+// REQUIRES: asserts
+// RUN: not --crash %target-swift-frontend %s -emit-ir
+class a{@_versioned
+public
+protocol r
diff --git a/validation-test/compiler_crashers/28709-unreachable-executed-at-swift-lib-ast-type-cpp-1005.swift b/validation-test/compiler_crashers/28709-unreachable-executed-at-swift-lib-ast-type-cpp-1005.swift
new file mode 100644
index 0000000..4eb8150
--- /dev/null
+++ b/validation-test/compiler_crashers/28709-unreachable-executed-at-swift-lib-ast-type-cpp-1005.swift
@@ -0,0 +1,12 @@
+// 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
+{
+class C{func o(UInt=1 + 1 + 1 + 1 + 1 as?Int){{
+{r
+p
diff --git a/validation-test/compiler_crashers_2_fixed/0079-rdar30702721.swift b/validation-test/compiler_crashers_2_fixed/0079-rdar30702721.swift
new file mode 100644
index 0000000..5965987
--- /dev/null
+++ b/validation-test/compiler_crashers_2_fixed/0079-rdar30702721.swift
@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend %s -emit-ir
+
+extension Sequence {
+	typealias Element = Iterator.Element
+}
+
+func f<C: Sequence>(c: C) where C.Iterator == C {
+  c.makeIterator()
+}