diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 7882950..ec7a91b 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -59,6 +59,7 @@
     single-source/DictTest
     single-source/DictTest2
     single-source/DictTest3
+    single-source/DictTest4
     single-source/DictionaryBridge
     single-source/DictionaryGroup
     single-source/DictionaryLiteral
diff --git a/benchmark/single-source/DictTest4.swift b/benchmark/single-source/DictTest4.swift
new file mode 100644
index 0000000..d2849fa
--- /dev/null
+++ b/benchmark/single-source/DictTest4.swift
@@ -0,0 +1,129 @@
+//===--- DictTest4.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+// This benchmark mostly measures lookups in dictionaries with complex keys,
+// exercising the default hash compression function.
+
+public let Dictionary4 = [
+  BenchmarkInfo(name: "Dictionary4", runFunction: run_Dictionary4, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(name: "Dictionary4OfObjects", runFunction: run_Dictionary4OfObjects, tags: [.validation, .api, .Dictionary]),
+]
+
+struct LargeKey: Hashable {
+  let i: Int
+  let j: Int
+  let k: Double
+  let l: UInt32
+  let m: Bool
+  let n: Bool
+  let o: Bool
+  let p: Bool
+  let q: Bool
+
+  init(_ value: Int) {
+    self.i = value
+    self.j = 2 * value
+    self.k = Double(value) / 7
+    self.l = UInt32(truncatingIfNeeded: value)
+    self.m = value & 1 == 0
+    self.n = value & 2 == 0
+    self.o = value & 4 == 0
+    self.p = value & 8 == 0
+    self.q = value & 16 == 0
+  }
+}
+
+@inline(never)
+public func run_Dictionary4(_ N: Int) {
+  let size1 = 100
+  let reps = 20
+  let ref_result = "1 99 \(reps) \(reps * 99)"
+  var hash1 = [LargeKey: Int]()
+  var hash2 = [LargeKey: Int]()
+  var res = ""
+
+  for _ in 1...N {
+    // Test insertions
+    hash1 = [:]
+    for i in 0..<size1 {
+      hash1[LargeKey(i)] = i
+    }
+
+    hash2 = hash1
+
+    // Test lookups & value replacement
+    for _ in 1..<reps {
+      for (k, v) in hash1 {
+        hash2[k] = hash2[k]! + v
+      }
+    }
+
+    res = "\(hash1[LargeKey(1)]!) \(hash1[LargeKey(99)]!)" +
+      " \(hash2[LargeKey(1)]!) \(hash2[LargeKey(99)]!)"
+    if res != ref_result {
+      break
+    }
+  }
+  CheckResults(res == ref_result)
+}
+
+class Box<T : Hashable> : Hashable {
+  var value: T
+
+  init(_ v: T) {
+    value = v
+  }
+
+  var hashValue: Int {
+    return value.hashValue
+  }
+  
+  static func ==(lhs: Box, rhs: Box) -> Bool {
+    return lhs.value == rhs.value
+  }
+}
+
+@inline(never)
+public func run_Dictionary4OfObjects(_ N: Int) {
+  let size1 = 100
+  let reps = 20
+  let ref_result = "1 99 \(reps) \(reps * 99)"
+  var hash1 = [Box<LargeKey>: Int]()
+  var hash2 = [Box<LargeKey>: Int]()
+  var res = ""
+
+  for _ in 1...N {
+    // Test insertions
+    hash1 = [:]
+    for i in 0..<size1 {
+      hash1[Box(LargeKey(i))] = i
+    }
+
+    hash2 = hash1
+
+    // Test lookups & value replacement
+    for _ in 1..<reps {
+      for (k, v) in hash1 {
+        hash2[k] = hash2[k]! + v
+      }
+    }
+
+    res = "\(hash1[Box(LargeKey(1))]!) \(hash1[Box(LargeKey(99))]!)" +
+      " \(hash2[Box(LargeKey(1))]!) \(hash2[Box(LargeKey(99))]!)"
+    if res != ref_result {
+      break
+    }
+  }
+  CheckResults(res == ref_result)
+}
diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift
index f723816..adb28b5 100644
--- a/benchmark/utils/main.swift
+++ b/benchmark/utils/main.swift
@@ -46,6 +46,7 @@
 import DictTest
 import DictTest2
 import DictTest3
+import DictTest4
 import DictionaryBridge
 import DictionaryGroup
 import DictionaryLiteral
@@ -189,6 +190,7 @@
 registerBenchmark(Dictionary)
 registerBenchmark(Dictionary2)
 registerBenchmark(Dictionary3)
+registerBenchmark(Dictionary4)
 registerBenchmark(DictionaryBridge)
 registerBenchmark(DictionaryGroup)
 registerBenchmark(DictionaryLiteral)
diff --git a/include/swift/AST/GenericSignatureBuilder.h b/include/swift/AST/GenericSignatureBuilder.h
index b9c0e8d..dff956a 100644
--- a/include/swift/AST/GenericSignatureBuilder.h
+++ b/include/swift/AST/GenericSignatureBuilder.h
@@ -258,11 +258,13 @@
     Type getTypeInContext(GenericSignatureBuilder &builder,
                           GenericEnvironment *genericEnv);
 
-    /// Dump a debugging representation of this equivalence class.
-    void dump(llvm::raw_ostream &out) const;
+    /// Dump a debugging representation of this equivalence class,
+    void dump(llvm::raw_ostream &out,
+              GenericSignatureBuilder *builder = nullptr) const;
 
-    LLVM_ATTRIBUTE_DEPRECATED(void dump() const,
-                              "only for use in the debugger");
+    LLVM_ATTRIBUTE_DEPRECATED(
+                  void dump(GenericSignatureBuilder *builder = nullptr) const,
+                  "only for use in the debugger");
 
     /// Caches.
 
@@ -271,9 +273,8 @@
       /// The cached anchor itself.
       Type anchor;
 
-      /// The number of members of the equivalence class when the archetype
-      /// anchor was cached.
-      unsigned numMembers;
+      /// The generation at which the anchor was last computed.
+      unsigned lastGeneration;
     } archetypeAnchorCache;
 
     /// Describes a cached nested type.
@@ -444,6 +445,11 @@
   /// Note that we have added the nested type nestedPA
   void addedNestedType(PotentialArchetype *nestedPA);
 
+  /// Add a rewrite rule for a same-type constraint between the given
+  /// types.
+  void addSameTypeRewriteRule(PotentialArchetype *type1,
+                              PotentialArchetype *type2);
+
   /// \brief Add a new conformance requirement specifying that the given
   /// potential archetypes are equivalent.
   ConstraintResult addSameTypeRequirementBetweenArchetypes(
@@ -802,6 +808,12 @@
   /// Determine whether the two given types are in the same equivalence class.
   bool areInSameEquivalenceClass(Type type1, Type type2);
 
+  /// Simplify the given dependent type down to its canonical representation.
+  ///
+  /// \returns null if the type involved dependent member types that
+  /// don't have associated types.
+  Type getCanonicalTypeParameter(Type type);
+
   /// Verify the correctness of the given generic signature.
   ///
   /// This routine will test that the given generic signature is both minimal
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
index 6048734..350a246 100644
--- a/include/swift/AST/Types.h
+++ b/include/swift/AST/Types.h
@@ -573,6 +573,12 @@
   /// whether a type parameter exists at any position.
   bool isTypeParameter();
 
+  /// \brief Determine whether this type can dynamically be an optional type.
+  ///
+  /// \param includeExistential Whether an existential type should be considered
+  /// such a type.
+  bool canDynamicallyBeOptionalType(bool includeExistential);
+
   /// Determine whether this type contains a type parameter somewhere in it.
   bool hasTypeParameter() {
     return getRecursiveProperties().hasTypeParameter();
@@ -4998,6 +5004,14 @@
   return false;
 }
 
+inline bool TypeBase::canDynamicallyBeOptionalType(bool includeExistential) {
+  CanType T = getCanonicalType();
+  auto isArchetypeOrExistential = isa<ArchetypeType>(T) ||
+    (includeExistential && T.isExistentialType());
+
+  return isArchetypeOrExistential && !T.isAnyClassReferenceType();
+}
+
 inline ClassDecl *TypeBase::getClassOrBoundGenericClass() {
   return getCanonicalType().getClassOrBoundGenericClass();
 }
diff --git a/include/swift/SIL/TypeSubstCloner.h b/include/swift/SIL/TypeSubstCloner.h
index 872f3c7..b5b4ae4 100644
--- a/include/swift/SIL/TypeSubstCloner.h
+++ b/include/swift/SIL/TypeSubstCloner.h
@@ -170,7 +170,11 @@
 
 protected:
   SILType remapType(SILType Ty) {
-    return Ty.subst(Original.getModule(), SubsMap);
+    SILType &Sty = TypeCache[Ty];
+    if (!Sty) {
+      Sty = Ty.subst(Original.getModule(), SubsMap);
+    }
+    return Sty;
   }
 
   CanType remapASTType(CanType ty) {
@@ -286,6 +290,8 @@
   ModuleDecl *SwiftMod;
   /// The substitutions list for the specialization.
   SubstitutionMap SubsMap;
+  /// Cache for substituted types.
+  llvm::DenseMap<SILType, SILType> TypeCache;
   /// The original function to specialize.
   SILFunction &Original;
   /// The substitutions used at the call site.
diff --git a/include/swift/Serialization/ModuleFormat.h b/include/swift/Serialization/ModuleFormat.h
index 2a28e95..492d385 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 = 397; // No resilience expansion in SILDeclRef
+const uint16_t VERSION_MINOR = 398; // Private discriminators for type xrefs
 
 using DeclIDField = BCFixed<31>;
 
@@ -1288,6 +1288,7 @@
   using XRefTypePathPieceLayout = BCRecordLayout<
     XREF_TYPE_PATH_PIECE,
     IdentifierIDField, // name
+    IdentifierIDField, // private discriminator
     BCFixed<1>         // restrict to protocol extension
   >;
 
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
index f473456..d657f7c 100644
--- a/lib/AST/GenericSignatureBuilder.cpp
+++ b/lib/AST/GenericSignatureBuilder.cpp
@@ -107,6 +107,190 @@
           "Delayed requirements left unresolved");
 STATISTIC(NumConditionalRequirementsAdded,
           "# of conditional requirements added");
+STATISTIC(NumComponentsCollapsedViaRewriting,
+          "# of same-type components collapsed via term rewriting");
+
+namespace  {
+
+/// A purely-relative rewrite path consisting of a (possibly empty)
+/// sequence of associated type references.
+using RelativeRewritePath = ArrayRef<AssociatedTypeDecl *>;
+
+/// Describes a rewrite path, which contains an optional base (generic
+/// parameter) followed by a sequence of associated type references.
+class RewritePath {
+  Optional<GenericParamKey> base;
+  TinyPtrVector<AssociatedTypeDecl *> path;
+
+public:
+  RewritePath() { }
+
+  enum PathOrder {
+    Forward,
+    Reverse,
+  };
+
+  /// Form a rewrite path given an optional base and a relative rewrite path.
+  RewritePath(Optional<GenericParamKey> base, RelativeRewritePath path,
+              PathOrder order);
+
+  /// Retrieve the base of the given rewrite path.
+  ///
+  /// When present, it indicates that the entire path will be rebased on
+  /// the given base generic parameter. This is required for describing
+  /// rewrites on type parameters themselves, e.g., T == U.
+  Optional<GenericParamKey> getBase() const { return base; }
+
+  /// Retrieve the sequence of associated type references that describes
+  /// the path.
+  ArrayRef<AssociatedTypeDecl *> getPath() const { return path; }
+
+  /// Decompose a type into a path.
+  ///
+  /// \returns the path, or None if it contained unresolved dependent member
+  /// types.
+  Optional<RewritePath> static createPath(Type type);
+
+  /// Decompose a potential archetype into a patch.
+  ///
+  /// \returns the path, or None if it contained potential archetypes
+  /// with concrete declarations.
+  Optional<RewritePath> static createPath(PotentialArchetype *pa);
+
+  /// Compute the common path between this path and \c other, if one exists.
+  Optional<RewritePath> commonPath(const RewritePath &other) const;
+
+  /// Form a canonical, dependent type.
+  ///
+  /// This requires that the rewrite path have a base.
+  CanType formDependentType(ASTContext &ctx) const;
+
+  /// Compare the given rewrite paths.
+  int compare(const RewritePath &other) const;
+
+  /// Print this path.
+  void print(llvm::raw_ostream &out) const;
+
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "only for use within the debugger") {
+    print(llvm::errs());
+  }
+
+  friend bool operator==(const RewritePath &lhs, const RewritePath &rhs) {
+    return lhs.getBase() == rhs.getBase() && lhs.getPath() == rhs.getPath();
+  }
+};
+
+/// A node within the prefix tree that is used to match associated type
+/// references.
+class RewriteTreeNode {
+  /// The associated type that leads to this node.
+  ///
+  /// The bit indicates whether there is a rewrite rule for this particular
+  /// node. If the bit is not set, \c rewrite is invalid.
+  llvm::PointerIntPair<AssociatedTypeDecl *, 1, bool> assocTypeAndHasRewrite;
+
+  /// The sequence of associated types to which a reference to this associated
+  /// type (from the equivalence class root) can be rewritten. This field is
+  /// only valid when the bit of \c assocTypeAndHasRewrite is set.
+  ///
+  /// Consider a requirement "Self.A.B.C == C". This will be encoded as
+  /// a prefix tree starting at the equivalence class for Self with
+  /// the following nodes:
+  ///
+  /// (assocType: A,
+  ///   children: [
+  ///     (assocType: B,
+  ///       children: [
+  ///         (assocType: C, rewrite: [C], children: [])
+  ///       ])
+  ///   ])
+  RewritePath rewrite;
+
+  /// The child nodes, which extend the sequence to be matched.
+  ///
+  /// The child nodes are sorted by the associated type declaration
+  /// pointers, so we can perform binary searches quickly.
+  llvm::TinyPtrVector<RewriteTreeNode *> children;
+
+public:
+  ~RewriteTreeNode();
+
+  RewriteTreeNode(AssociatedTypeDecl *assocType)
+    : assocTypeAndHasRewrite(assocType, false) { }
+
+  /// Retrieve the associated type declaration one must match to use this
+  /// node, which may the
+  AssociatedTypeDecl *getMatch() const {
+    return assocTypeAndHasRewrite.getPointer();
+  }
+
+  /// Determine whether this particular node has a rewrite rule.
+  bool hasRewriteRule() const {
+    return assocTypeAndHasRewrite.getInt();
+  }
+
+  /// Set a new rewrite rule for this particular node. This can only be
+  /// performed once.
+  void setRewriteRule(RewritePath replacementPath) {
+    assert(!hasRewriteRule());
+    assocTypeAndHasRewrite.setInt(true);
+    rewrite = replacementPath;
+  }
+
+  /// Retrieve the path to which this node will be rewritten.
+  const RewritePath &getRewriteRule() const {
+    assert(hasRewriteRule());
+    return rewrite;
+  }
+
+  /// Add a new rewrite rule to this tree node.
+  ///
+  /// \param matchPath The path of associated type declarations that must
+  /// be matched to produce a rewrite.
+  ///
+  /// \param replacementPath The sequence of associated type declarations
+  /// with which a match will be replaced.
+  void addRewriteRule(RelativeRewritePath matchPath,
+                      RewritePath replacementPath);
+
+  /// Enumerate all of the paths to which the given matched path can be
+  /// rewritten.
+  ///
+  /// \param matchPath The path to match.
+  ///
+  /// \param callback A callback that will be invoked with (prefix, rewrite)
+  /// pairs, where \c prefix is the length of the matching prefix of
+  /// \c matchPath that matched and \c rewrite is the path to which it can
+  /// be rewritten.
+  void enumerateRewritePaths(
+                       RelativeRewritePath matchPath,
+                       llvm::function_ref<void(unsigned, RewritePath)> callback,
+                       unsigned depth = 0) const;
+
+  /// Find the best rewrite rule to match the given path.
+  ///
+  /// \param path The path to match.
+  /// \param prefixLength The length of the prefix leading up to \c path.
+  Optional<std::pair<unsigned, RewritePath>>
+  bestMatch(GenericParamKey base, RelativeRewritePath path,
+            unsigned prefixLength);
+
+  /// Merge the given rewrite tree into \c other.
+  void mergeInto(RewriteTreeNode *other);
+
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "only for use within the debugger");
+
+  /// Dump the tree.
+  void dump(llvm::raw_ostream &out, bool lastChild = true) const;
+
+private:
+  /// Merge the given rewrite tree into \c other.
+  void mergeIntoRec(RewriteTreeNode *other,
+                    llvm::SmallVectorImpl<AssociatedTypeDecl *> &matchPath);
+};
+}
 
 struct GenericSignatureBuilder::Implementation {
   /// Allocator.
@@ -131,6 +315,9 @@
   /// Equivalence classes that are not currently being used.
   std::vector<void *> FreeEquivalenceClasses;
 
+  /// The roots of the rewrite tree.
+  DenseMap<const EquivalenceClass *, RewriteTreeNode *> RewriteTreeRoots;
+
   /// The generation number, which is incremented whenever we successfully
   /// introduce a new constraint.
   unsigned Generation = 0;
@@ -141,16 +328,6 @@
   /// Whether we are currently processing delayed requirements.
   bool ProcessingDelayedRequirements = false;
 
-  /// Tear down an implementation.
-  ~Implementation();
-
-  /// Allocate a new equivalence class with the given representative.
-  EquivalenceClass *allocateEquivalenceClass(
-                                       PotentialArchetype *representative);
-
-  /// Deallocate the given equivalence class, returning it to the free list.
-  void deallocateEquivalenceClass(EquivalenceClass *equivClass);
-
   /// Whether there were any errors.
   bool HadAnyError = false;
 
@@ -161,12 +338,35 @@
   /// Whether we've already finalized the builder.
   bool finalized = false;
 #endif
+
+  /// Tear down an implementation.
+  ~Implementation();
+
+  /// Allocate a new equivalence class with the given representative.
+  EquivalenceClass *allocateEquivalenceClass(
+                                       PotentialArchetype *representative);
+
+  /// Deallocate the given equivalence class, returning it to the free list.
+  void deallocateEquivalenceClass(EquivalenceClass *equivClass);
+
+  /// Retrieve the rewrite tree root for the given equivalence class,
+  /// if present.
+  RewriteTreeNode *getRewriteTreeRootIfPresent(
+                                      const EquivalenceClass *equivClass);
+
+  /// Retrieve the rewrite tree root for the given equivalence class,
+  /// creating it if needed.
+  RewriteTreeNode *getOrCreateRewriteTreeRoot(
+                                        const EquivalenceClass *equivClass);
 };
 
 #pragma mark Memory management
 GenericSignatureBuilder::Implementation::~Implementation() {
   for (auto pa : PotentialArchetypes)
     pa->~PotentialArchetype();
+
+  for (const auto &root : RewriteTreeRoots)
+    delete root.second;
 }
 
 EquivalenceClass *
@@ -1915,31 +2115,13 @@
   return populateResult((nestedTypeNameCache[name] = std::move(entry)));
 }
 
-/// Determine whether any part of this potential archetype's path to the
-/// root contains the given equivalence class.
-static bool pathContainsEquivalenceClass(GenericSignatureBuilder &builder,
-                                         PotentialArchetype *pa,
-                                         EquivalenceClass *equivClass) {
-  // Chase the potential archetype up to the root.
-  for (; pa; pa = pa->getParent()) {
-    // Check whether this potential archetype is in the given equivalence
-    // class.
-    if (pa->getOrCreateEquivalenceClass(builder) == equivClass)
-      return true;
-  }
-
-  return false;
-}
-
 Type EquivalenceClass::getAnchor(
                             GenericSignatureBuilder &builder,
                             TypeArrayView<GenericTypeParamType> genericParams) {
-  // Check whether the cache is valid.
-  if (archetypeAnchorCache.anchor &&
-      archetypeAnchorCache.numMembers == members.size()) {
-    ++NumArchetypeAnchorCacheHits;
+  // Substitute into the anchor with the given generic parameters.
+  auto substAnchor = [&] {
+    if (genericParams.empty()) return archetypeAnchorCache.anchor;
 
-    // Reparent the anchor using genericParams.
     return archetypeAnchorCache.anchor.subst(
              [&](SubstitutableType *dependentType) {
                if (auto gp = dyn_cast<GenericTypeParamType>(dependentType)) {
@@ -1951,73 +2133,43 @@
                return Type(dependentType);
              },
              MakeAbstractConformanceForGenericType());
+
+  };
+
+  // Check whether the cache is valid.
+  if (archetypeAnchorCache.anchor &&
+      archetypeAnchorCache.lastGeneration == builder.Impl->Generation) {
+    ++NumArchetypeAnchorCacheHits;
+    return substAnchor();
   }
 
-  // Map the members of this equivalence class to the best associated type
-  // within that equivalence class.
-  llvm::SmallDenseMap<EquivalenceClass *, AssociatedTypeDecl *> nestedTypes;
+  // Check whether we already have an anchor, in which case we
+  // can simplify it further.
+  if (archetypeAnchorCache.anchor) {
+    // Record the cache miss.
+    ++NumArchetypeAnchorCacheMisses;
 
-  Type bestGenericParam;
+    // Update the anchor by simplifying it further.
+    archetypeAnchorCache.anchor =
+      builder.getCanonicalTypeParameter(archetypeAnchorCache.anchor);
+    archetypeAnchorCache.lastGeneration = builder.Impl->Generation;
+    return substAnchor();
+  }
+
+  // Form the anchor.
   for (auto member : members) {
-    // If the member is a generic parameter, keep the best generic parameter.
-    if (member->isGenericParam()) {
-      Type genericParamType = member->getDependentType(genericParams);
-      if (!bestGenericParam ||
-          compareDependentTypes(genericParamType, bestGenericParam) < 0)
-        bestGenericParam = genericParamType;
-      continue;
-    }
+    auto anchorType =
+      builder.getCanonicalTypeParameter(member->getDependentType(genericParams));
+    if (!anchorType) continue;
 
-    // If we saw a generic parameter, ignore any nested types.
-    if (bestGenericParam) continue;
-
-    // If the nested type doesn't have an associated type, skip it.
-    auto assocType = member->getResolvedAssociatedType();
-    if (!assocType) continue;
-
-    // Dig out the equivalence class of the parent.
-    auto parentEquivClass =
-      member->getParent()->getOrCreateEquivalenceClass(builder);
-
-    // If the path from this member to the root contains this equivalence
-    // class, it cannot be part of the anchor.
-    if (pathContainsEquivalenceClass(builder, member->getParent(), this))
-      continue;
-
-    // Take the best associated type for this equivalence class.
-    assocType = assocType->getAssociatedTypeAnchor();
-    auto &bestAssocType = nestedTypes[parentEquivClass];
-    if (!bestAssocType ||
-        compareAssociatedTypes(assocType, bestAssocType) < 0)
-      bestAssocType = assocType;
+    // Record the cache miss and update the cache.
+    ++NumArchetypeAnchorCacheMisses;
+    archetypeAnchorCache.anchor = anchorType;
+    archetypeAnchorCache.lastGeneration = builder.Impl->Generation;
+    return substAnchor();
   }
 
-  // If we found a generic parameter, return that.
-  if (bestGenericParam)
-    return bestGenericParam;
-
-  // Determine the best anchor among the parent equivalence classes.
-  Type bestParentAnchor;
-  AssociatedTypeDecl *bestAssocType = nullptr;
-  std::pair<EquivalenceClass *, Identifier> bestNestedType;
-  for (const auto &nestedType : nestedTypes) {
-    auto parentAnchor = nestedType.first->getAnchor(builder, genericParams);
-    if (!bestParentAnchor ||
-        compareDependentTypes(parentAnchor, bestParentAnchor) < 0) {
-      bestParentAnchor = parentAnchor;
-      bestAssocType = nestedType.second;
-    }
-  }
-
-  // Form the anchor type.
-  Type anchorType = DependentMemberType::get(bestParentAnchor, bestAssocType);
-
-  // Record the cache miss and update the cache.
-  ++NumArchetypeAnchorCacheMisses;
-  archetypeAnchorCache.anchor = anchorType;
-  archetypeAnchorCache.numMembers = members.size();
-
-  return anchorType;
+  llvm_unreachable("Unable to compute anchor");
 }
 
 Type EquivalenceClass::getTypeInContext(GenericSignatureBuilder &builder,
@@ -2138,7 +2290,8 @@
   return archetype;
 }
 
-void EquivalenceClass::dump(llvm::raw_ostream &out) const {
+void EquivalenceClass::dump(llvm::raw_ostream &out,
+                            GenericSignatureBuilder *builder) const {
   out << "Equivalence class represented by "
     << members.front()->getRepresentative()->getDebugName() << ":\n";
   out << "Members: ";
@@ -2183,6 +2336,13 @@
 
   out << "\n";
 
+  if (builder) {
+    if (auto rewriteRoot = builder->Impl->getRewriteTreeRootIfPresent(this)) {
+      out << "---Rewrite tree---\n";
+      rewriteRoot->dump(out);
+    }
+  }
+
   {
     out << "---GraphViz output for same-type constraints---\n";
 
@@ -2215,8 +2375,8 @@
   }
 }
 
-void EquivalenceClass::dump() const {
-  dump(llvm::errs());
+void EquivalenceClass::dump(GenericSignatureBuilder *builder) const {
+  dump(llvm::errs(), builder);
 }
 
 void DelayedRequirement::dump(llvm::raw_ostream &out) const {
@@ -2523,6 +2683,24 @@
   return 0;
 }
 
+/// Compare two dependent paths to determine which is better.
+static int compareDependentPaths(ArrayRef<AssociatedTypeDecl *> path1,
+                                 ArrayRef<AssociatedTypeDecl *> path2) {
+  // Shorter paths win.
+  if (path1.size() != path2.size())
+    return path1.size() < path2.size() ? -1 : 1;
+
+  // The paths are the same length, so order by comparing the associted
+  // types.
+  for (unsigned index : indices(path1)) {
+    if (int result = compareAssociatedTypes(path1[index], path2[index]))
+      return result;
+  }
+
+  // Identical paths.
+  return 0;
+}
+
 namespace {
   /// Function object used to suppress conflict diagnoses when we know we'll
   /// see them again later.
@@ -2883,6 +3061,507 @@
   }
 }
 
+#pragma mark Rewrite tree
+RewritePath::RewritePath(Optional<GenericParamKey> base,
+                         RelativeRewritePath path,
+                         PathOrder order)
+  : base(base)
+{
+  switch (order) {
+  case Forward:
+    this->path.insert(this->path.begin(), path.begin(), path.end());
+    break;
+
+  case Reverse:
+    this->path.insert(this->path.begin(), path.rbegin(), path.rend());
+    break;
+  }
+}
+
+Optional<RewritePath> RewritePath::createPath(PotentialArchetype *pa) {
+  SmallVector<AssociatedTypeDecl *, 4> path;
+  while (auto parent = pa->getParent()) {
+    auto assocType = pa->getResolvedAssociatedType();
+    if (!assocType) return None;
+
+    path.push_back(assocType);
+    pa = parent;
+  }
+
+  return RewritePath(pa->getGenericParamKey(), path, Reverse);
+}
+
+Optional<RewritePath> RewritePath::createPath(Type type) {
+  SmallVector<AssociatedTypeDecl *, 4> path;
+  while (auto depMemTy = type->getAs<DependentMemberType>()) {
+    auto assocType = depMemTy->getAssocType();
+    if (!assocType) return None;
+
+    path.push_back(assocType);
+    type = depMemTy->getBase();
+  }
+
+  auto genericParam = type->getAs<GenericTypeParamType>();
+  if (!genericParam) return None;
+
+  return RewritePath(GenericParamKey(genericParam), path, Reverse);
+}
+
+Optional<RewritePath> RewritePath::commonPath(const RewritePath &other) const {
+  assert(getBase().hasValue() && other.getBase().hasValue());
+
+  if (*getBase() != *other.getBase()) return None;
+
+  // Find the longest common prefix.
+  RelativeRewritePath path1 = getPath();
+  RelativeRewritePath path2 = other.getPath();
+  if (path1.size() > path2.size())
+    std::swap(path1, path2);
+  unsigned prefixLength =
+    std::mismatch(path1.begin(), path1.end(), path2.begin()).first
+      - path1.begin();
+
+  // Form the common path.
+  return RewritePath(getBase(), path1.slice(0, prefixLength), Forward);
+}
+
+/// Form a dependent type with the given generic parameter, then following the
+/// path of associated types.
+static Type formDependentType(GenericTypeParamType *base,
+                              RelativeRewritePath path) {
+  return std::accumulate(path.begin(), path.end(), Type(base),
+                         [](Type type, AssociatedTypeDecl *assocType) -> Type {
+                           return DependentMemberType::get(type, assocType);
+                         });
+}
+
+/// Form a dependent type with the (canonical) generic parameter for the given
+/// parameter key, then following the path of associated types.
+static Type formDependentType(ASTContext &ctx, GenericParamKey genericParam,
+                              RelativeRewritePath path) {
+  return formDependentType(GenericTypeParamType::get(genericParam.Depth,
+                                                     genericParam.Index,
+                                                     ctx),
+                           path);
+}
+
+CanType RewritePath::formDependentType(ASTContext &ctx) const {
+  assert(getBase());
+  return CanType(::formDependentType(ctx, *getBase(), getPath()));
+}
+
+int RewritePath::compare(const RewritePath &other) const {
+  // Prefer relative to absolute paths.
+  if (getBase().hasValue() != other.getBase().hasValue()) {
+    return other.getBase().hasValue() ? -1 : 1;
+  }
+
+  // Order based on the bases.
+  if (getBase() && *getBase() != *other.getBase())
+    return (*getBase() < *other.getBase()) ? -1 : 1;
+
+  // Order based on the path contents.
+  return compareDependentPaths(getPath(), other.getPath());
+}
+
+void RewritePath::print(llvm::raw_ostream &out) const {
+  out << "[";
+
+  if (getBase()) {
+    out << "(" << getBase()->Depth << ", " << getBase()->Index << ")";
+    if (!getPath().empty()) out << " -> ";
+  }
+
+  interleave(getPath().begin(), getPath().end(),
+             [&](AssociatedTypeDecl *assocType) {
+               out.changeColor(raw_ostream::BLUE);
+               out << assocType->getProtocol()->getName() << "."
+               << assocType->getName();
+               out.resetColor();
+             }, [&] {
+               out << " -> ";
+             });
+  out << "]";
+}
+
+RewriteTreeNode::~RewriteTreeNode() {
+  for (auto child : children)
+    delete child;
+}
+
+namespace {
+/// Function object used to order rewrite tree nodes based on the address
+/// of the associated type.
+class OrderTreeRewriteNode {
+  bool compare(AssociatedTypeDecl *lhs, AssociatedTypeDecl *rhs) const {
+    // Make sure null pointers precede everything else.
+    if (static_cast<bool>(lhs) != static_cast<bool>(rhs))
+      return static_cast<bool>(rhs);
+
+    // Use std::less to provide a defined ordering.
+    return std::less<AssociatedTypeDecl *>()(lhs, rhs);
+  }
+
+public:
+  bool operator()(RewriteTreeNode *lhs, AssociatedTypeDecl *rhs) const {
+    return compare(lhs->getMatch(), rhs);
+  }
+
+  bool operator()(AssociatedTypeDecl *lhs, RewriteTreeNode *rhs) const {
+    return compare(lhs, rhs->getMatch());
+  }
+
+  bool operator()(RewriteTreeNode *lhs, RewriteTreeNode *rhs) const {
+    return compare(lhs->getMatch(), rhs->getMatch());
+  }
+};
+}
+
+void RewriteTreeNode::addRewriteRule(RelativeRewritePath matchPath,
+                                     RewritePath replacementPath) {
+  // If the match path is empty, we're adding the rewrite rule to this node.
+  if (matchPath.empty()) {
+    // If we don't already have a rewrite rule, add it.
+    if (!hasRewriteRule()) {
+      setRewriteRule(replacementPath);
+      return;
+    }
+
+    // If we already have this rewrite rule, we're done.
+    if (getRewriteRule() == replacementPath) return;
+
+    // Check whether any of the continuation children matches.
+    auto insertPos = children.begin();
+    while (insertPos != children.end() && !(*insertPos)->getMatch()) {
+      if ((*insertPos)->hasRewriteRule() &&
+          (*insertPos)->getRewriteRule() == replacementPath)
+        return;
+
+      ++insertPos;
+    }
+
+    // We already have a rewrite rule, so add a new child with a
+    // null associated type match to hold the rewrite rule.
+    auto newChild = new RewriteTreeNode(nullptr);
+    newChild->setRewriteRule(replacementPath);
+    children.insert(insertPos, newChild);
+    return;
+  }
+
+  // Find (or create) a child node describing the next step in the match.
+  auto matchFront = matchPath.front();
+  auto childPos =
+    std::lower_bound(children.begin(), children.end(), matchFront,
+                     OrderTreeRewriteNode());
+  if (childPos == children.end() || (*childPos)->getMatch() != matchFront) {
+    childPos = children.insert(childPos, new RewriteTreeNode(matchFront));
+  }
+
+  // Add the rewrite rule to the child.
+  (*childPos)->addRewriteRule(matchPath.slice(1), replacementPath);
+}
+
+void RewriteTreeNode::enumerateRewritePaths(
+                       RelativeRewritePath matchPath,
+                       llvm::function_ref<void(unsigned, RewritePath)> callback,
+                       unsigned depth) const {
+  // Determine whether we know anything about the next step in the path.
+  auto childPos =
+    depth < matchPath.size()
+      ? std::lower_bound(children.begin(), children.end(),
+                         matchPath[depth], OrderTreeRewriteNode())
+      : children.end();
+  if (childPos != children.end() &&
+      (*childPos)->getMatch() == matchPath[depth]) {
+    // Try to match the rest of the path.
+    (*childPos)->enumerateRewritePaths(matchPath, callback, depth + 1);
+  }
+
+  // If we have a rewrite rule at this position, invoke it.
+  if (hasRewriteRule()) {
+    // Invoke the callback with the first result.
+    callback(depth, rewrite);
+  }
+
+  // Walk any children with NULL associated types; they might have more matches.
+  for (auto otherRewrite : children) {
+    if (otherRewrite->getMatch()) break;
+    otherRewrite->enumerateRewritePaths(matchPath, callback, depth);
+  }
+}
+
+Optional<std::pair<unsigned, RewritePath>>
+RewriteTreeNode::bestMatch(GenericParamKey base, RelativeRewritePath path,
+                           unsigned prefixLength) {
+  Optional<std::pair<unsigned, RewritePath>> best;
+  unsigned bestAdjustedLength = 0;
+  enumerateRewritePaths(path,
+                        [&](unsigned length, RewritePath path) {
+    // Determine how much of the original path will be replaced by the rewrite.
+    unsigned adjustedLength = length;
+    if (auto newBase = path.getBase()) {
+      adjustedLength += prefixLength;
+
+      // If the base is unchanged, make sure we're reducing the length.
+      if (*newBase == base && adjustedLength <= path.getPath().size())
+        return;
+    }
+
+    if (adjustedLength == 0) return;
+
+    if (adjustedLength > bestAdjustedLength ||
+        (adjustedLength == bestAdjustedLength &&
+         path.compare(best->second) < 0)) {
+      best = { length, path };
+      bestAdjustedLength = adjustedLength;
+    }
+  });
+
+  return best;
+}
+
+void RewriteTreeNode::mergeInto(RewriteTreeNode *other) {
+  SmallVector<AssociatedTypeDecl *, 4> matchPath;
+  mergeIntoRec(other, matchPath);
+}
+
+void RewriteTreeNode::mergeIntoRec(
+                     RewriteTreeNode *other,
+                     llvm::SmallVectorImpl<AssociatedTypeDecl *> &matchPath) {
+  // FIXME: A destructive version of this operation would be more efficient,
+  // since we generally don't care about \c other after doing this.
+  if (auto assocType = getMatch())
+    matchPath.push_back(assocType);
+
+  // Add this rewrite rule, if there is one.
+  if (hasRewriteRule())
+    other->addRewriteRule(matchPath, rewrite);
+
+  // Recurse into the child nodes.
+  for (auto child : children)
+    child->mergeIntoRec(other, matchPath);
+
+  if (auto assocType = getMatch())
+    matchPath.pop_back();
+}
+
+void RewriteTreeNode::dump() const {
+  dump(llvm::errs());
+}
+
+void RewriteTreeNode::dump(llvm::raw_ostream &out, bool lastChild) const {
+  std::string prefixStr;
+
+  std::function<void(const RewriteTreeNode *, bool lastChild)> print;
+  print = [&](const RewriteTreeNode *node, bool lastChild) {
+    out << prefixStr << " `--";
+
+    // Print the node name.
+    out.changeColor(raw_ostream::GREEN);
+    if (auto assoc = node->getMatch())
+      out << assoc->getProtocol()->getName() << "." << assoc->getName();
+    else
+      out << "(cont'd)";
+    out.resetColor();
+
+    // Print the rewrite, if there is one.
+    if (node->hasRewriteRule()) {
+      out << " --> ";
+      node->rewrite.print(out);
+    }
+
+    out << "\n";
+
+    // Print children.
+    prefixStr += ' ';
+    prefixStr += (lastChild ? ' ' : '|');
+    prefixStr += "  ";
+
+    for (auto child : node->children) {
+      print(child, child == node->children.back());
+    }
+
+    prefixStr.erase(prefixStr.end() - 4, prefixStr.end());
+  };
+
+  print(this, lastChild);
+}
+
+RewriteTreeNode *
+GenericSignatureBuilder::Implementation::getRewriteTreeRootIfPresent(
+                                          const EquivalenceClass *equivClass) {
+  auto known = RewriteTreeRoots.find(equivClass);
+  if (known != RewriteTreeRoots.end()) return known->second;
+
+  return nullptr;
+}
+
+RewriteTreeNode *
+GenericSignatureBuilder::Implementation::getOrCreateRewriteTreeRoot(
+                                          const EquivalenceClass *equivClass) {
+  auto known = RewriteTreeRoots.find(equivClass);
+  if (known != RewriteTreeRoots.end()) return known->second;
+
+  auto root = new RewriteTreeNode(nullptr);
+  RewriteTreeRoots[equivClass] = root;
+  return root;
+}
+
+void GenericSignatureBuilder::addSameTypeRewriteRule(PotentialArchetype *pa1,
+                                                     PotentialArchetype *pa2){
+  auto pathOpt1 = RewritePath::createPath(pa1);
+  if (!pathOpt1) return;
+
+  auto pathOpt2 = RewritePath::createPath(pa2);
+  if (!pathOpt2) return;
+
+  auto path1 = std::move(pathOpt1).getValue();
+  auto path2 = std::move(pathOpt2).getValue();
+
+  // Look for a common path.
+  auto prefix = path1.commonPath(path2);
+
+  // If we didn't find a common path, try harder.
+  Type simplifiedType1;
+  Type simplifiedType2;
+  if (!prefix) {
+    // Simplify both sides in the hope of uncovering a common path.
+    simplifiedType1 = getCanonicalTypeParameter(pa1->getDependentType({ }));
+    simplifiedType2 = getCanonicalTypeParameter(pa2->getDependentType({ }));
+    if (simplifiedType1->isEqual(simplifiedType2)) return;
+
+    // Create new paths from the simplified types.
+    path1 = *RewritePath::createPath(simplifiedType1);
+    path2 = *RewritePath::createPath(simplifiedType2);
+
+    // Find a common path.
+    prefix = path1.commonPath(path2);
+  }
+
+  // When we have a common prefix, form a rewrite rule using relative paths.
+  if (prefix) {
+    // Find the better relative rewrite path.
+    RelativeRewritePath relPath1
+      = path1.getPath().slice(prefix->getPath().size());
+    RelativeRewritePath relPath2
+      = path2.getPath().slice(prefix->getPath().size());
+    // Order the paths so that we go to the more-canonical path.
+    if (compareDependentPaths(relPath1, relPath2) < 0)
+      std::swap(relPath1, relPath2);
+
+    // Find the equivalence class for the prefix.
+    CanType commonType = prefix->formDependentType(getASTContext());
+    auto equivClass =
+      resolveEquivalenceClass(commonType, ArchetypeResolutionKind::WellFormed);
+    assert(equivClass && "Prefix cannot be resolved?");
+
+    // Add the rewrite rule.
+    auto root = Impl->getOrCreateRewriteTreeRoot(equivClass);
+    root->addRewriteRule(relPath1,
+                         RewritePath(None, relPath2, RewritePath::Forward));
+
+    return;
+  }
+
+  // Otherwise, form a rewrite rule with absolute paths.
+
+  // Find the better path and make sure it's in path2.
+  if (compareDependentTypes(simplifiedType1, simplifiedType2) < 0) {
+    std::swap(path1, path2);
+    std::swap(simplifiedType1, simplifiedType2);
+  }
+
+  // Add the rewrite rule.
+  Type firstBase =
+    GenericTypeParamType::get(path1.getBase()->Depth, path1.getBase()->Index,
+                              getASTContext());
+  auto equivClass =
+    resolveEquivalenceClass(firstBase, ArchetypeResolutionKind::WellFormed);
+  assert(equivClass && "Base cannot be resolved?");
+
+  auto root = Impl->getOrCreateRewriteTreeRoot(equivClass);
+  root->addRewriteRule(path1.getPath(), path2);
+}
+
+Type GenericSignatureBuilder::getCanonicalTypeParameter(Type type) {
+  auto initialPath = RewritePath::createPath(type);
+  if (!initialPath) return nullptr;
+
+  auto genericParamType =
+    GenericTypeParamType::get(initialPath->getBase()->Depth,
+                              initialPath->getBase()->Index,
+                              getASTContext());
+  auto initialEquivClass =
+    resolveEquivalenceClass(genericParamType,
+                            ArchetypeResolutionKind::WellFormed);
+  if (!initialEquivClass) return nullptr;
+
+  unsigned startIndex = 0;
+  auto equivClass = initialEquivClass;
+  Type currentType = genericParamType;
+  SmallVector<AssociatedTypeDecl *, 4> path(initialPath->getPath().begin(),
+                                            initialPath->getPath().end());
+  bool simplified = false;
+  do {
+    if (auto rootNode = Impl->getRewriteTreeRootIfPresent(equivClass)) {
+      // Find the best rewrite rule for the path starting at startIndex.
+      auto match =
+        rootNode->bestMatch(genericParamType,
+                            llvm::makeArrayRef(path).slice(startIndex),
+                            startIndex);
+
+      // If we have a match, replace the matched path with the replacement
+      // path.
+      if (match) {
+        // Determine the range in the path which we'll be replacing.
+        unsigned replaceStartIndex = match->second.getBase() ? 0 : startIndex;
+        unsigned replaceEndIndex = startIndex + match->first;
+
+        // Overwrite the beginning of the match.
+        auto replacementPath = match->second.getPath();
+        assert((replaceEndIndex - replaceStartIndex) >= replacementPath.size());
+        auto replacementStartPos = path.begin() + replaceStartIndex;
+        std::copy(replacementPath.begin(), replacementPath.end(),
+                  replacementStartPos);
+
+        // Erase the rest.
+        path.erase(replacementStartPos + replacementPath.size(),
+                   path.begin() + replaceEndIndex);
+
+        // If this is an absolute path, use the new base.
+        if (auto newBase = match->second.getBase()) {
+          genericParamType =
+            GenericTypeParamType::get(newBase->Depth, newBase->Index,
+                                      getASTContext());
+          initialEquivClass =
+            resolveEquivalenceClass(genericParamType,
+                                    ArchetypeResolutionKind::WellFormed);
+          assert(initialEquivClass && "Must have an equivalence class");
+        }
+
+        // Move back to the beginning; we may have opened up other rewrites.
+        simplified = true;
+        startIndex = 0;
+        currentType = genericParamType;
+        equivClass = initialEquivClass;
+        continue;
+      }
+    }
+
+    // If we've hit the end of the path, we're done.
+    if (startIndex >= path.size()) break;
+
+    // FIXME: It would be nice if there were a better way to get the equivalence
+    // class of a named nested type.
+    currentType = DependentMemberType::get(currentType, path[startIndex++]);
+    equivClass =
+      resolveEquivalenceClass(currentType, ArchetypeResolutionKind::WellFormed);
+    if (!equivClass) break;
+  } while (true);
+
+  return formDependentType(genericParamType, path);
+}
+
 #pragma mark Equivalence classes
 EquivalenceClass::EquivalenceClass(PotentialArchetype *representative)
   : recursiveConcreteType(false), invalidConcreteType(false),
@@ -3865,6 +4544,9 @@
        PotentialArchetype *OrigT2,
        const RequirementSource *Source) 
 {
+  // Add a rewrite rule based on the given same-type constraint.
+  addSameTypeRewriteRule(OrigT1, OrigT2);
+
   // Record the same-type constraint, and bail out if it was already known.
   if (!OrigT1->getOrCreateEquivalenceClass(*this)
         ->recordSameTypeConstraint(OrigT1, OrigT2, Source))
@@ -3910,6 +4592,20 @@
                                    equivClass->sameTypeConstraints.end(),
                                    equivClass2->sameTypeConstraints.begin(),
                                    equivClass2->sameTypeConstraints.end());
+
+    // Combine the rewrite rules.
+    if (auto rewriteRoot2 = Impl->getOrCreateRewriteTreeRoot(equivClass2)) {
+      if (auto rewriteRoot1 = Impl->getOrCreateRewriteTreeRoot(equivClass)) {
+        // Merge the second rewrite tree into the first.
+        rewriteRoot2->mergeInto(rewriteRoot1);
+        Impl->RewriteTreeRoots.erase(equivClass2);
+        delete rewriteRoot2;
+      } else {
+        // Take the second rewrite tree and make it the first.
+        Impl->RewriteTreeRoots.erase(equivClass2);
+        (void)Impl->RewriteTreeRoots.insert({equivClass, rewriteRoot2});
+      }
+    }
   }
 
   // Same-type-to-concrete requirements.
@@ -5446,7 +6142,7 @@
       return lhs.constraint < rhs.constraint;
     }
 
-    LLVM_ATTRIBUTE_DEPRECATED(void dump() const,
+    LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
                               "only for use in the debugger");
   };
 }
diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp
index 8fcfcce..e506ae4 100644
--- a/lib/Driver/Driver.cpp
+++ b/lib/Driver/Driver.cpp
@@ -212,23 +212,16 @@
   case llvm::Triple::TvOS:
   case llvm::Triple::WatchOS:
     return llvm::make_unique<toolchains::Darwin>(*this, target);
-    break;
   case llvm::Triple::Linux:
-    if (target.isAndroid()) {
+    if (target.isAndroid())
       return llvm::make_unique<toolchains::Android>(*this, target);
-    } else {
-      return llvm::make_unique<toolchains::GenericUnix>(*this, target);
-    }
-    break;
+    return llvm::make_unique<toolchains::GenericUnix>(*this, target);
   case llvm::Triple::FreeBSD:
     return llvm::make_unique<toolchains::GenericUnix>(*this, target);
-    break;
   case llvm::Triple::Win32:
     return llvm::make_unique<toolchains::Cygwin>(*this, target);
-    break;
   case llvm::Triple::Haiku:
     return llvm::make_unique<toolchains::GenericUnix>(*this, target);
-    break;
   default:
     Diags.diagnose(SourceLoc(), diag::error_unknown_target,
                    ArgList.getLastArg(options::OPT_target)->getValue());
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 222dbc7..382b4ee 100644
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -3905,7 +3905,8 @@
   if (Flags.contains(PD_InProtocol) || isInSILMode()) {
     if (Tok.is(tok::r_brace)) {
       // Give syntax node an empty statement list.
-      SyntaxParsingContext StmtListContext(SyntaxContext, SyntaxKind::StmtList);
+      SyntaxParsingContext StmtListContext(SyntaxContext,
+                                           SyntaxKind::CodeBlockItemList);
     }
     while (Tok.isNot(tok::r_brace)) {
       if (Tok.is(tok::eof))
@@ -3988,7 +3989,8 @@
   // an implicit fallthrough off the end.
   if (Tok.is(tok::r_brace)) {
     // Give syntax node an empty statement list.
-    SyntaxParsingContext StmtListContext(SyntaxContext, SyntaxKind::StmtList);
+    SyntaxParsingContext StmtListContext(SyntaxContext,
+                                         SyntaxKind::CodeBlockItemList);
     diagnose(Tok, diag::computed_property_no_accessors);
     return true;
   }
diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp
index 84d5bc9..5915b16 100644
--- a/lib/Parse/ParseStmt.cpp
+++ b/lib/Parse/ParseStmt.cpp
@@ -89,6 +89,7 @@
 
 ParserStatus Parser::parseExprOrStmt(ASTNode &Result) {
   if (Tok.is(tok::semi)) {
+    SyntaxParsingContext ErrorCtxt(SyntaxContext, SyntaxContextKind::Stmt);
     diagnose(Tok, diag::illegal_semi_stmt)
       .fixItRemove(SourceRange(Tok.getLoc()));
     consumeToken();
@@ -112,6 +113,7 @@
   if (Tok.is(tok::code_complete)) {
     if (CodeCompletion)
       CodeCompletion->completeStmtOrExpr();
+    SyntaxParsingContext ErrorCtxt(SyntaxContext, SyntaxContextKind::Stmt);
     consumeToken(tok::code_complete);
     return makeParserCodeCompletionStatus();
   }
@@ -228,7 +230,8 @@
 ParserStatus Parser::parseBraceItems(SmallVectorImpl<ASTNode> &Entries,
                                      BraceItemListKind Kind,
                                      BraceItemListKind ConditionalBlockKind) {
-  SyntaxParsingContext StmtListContext(SyntaxContext, SyntaxKind::StmtList);
+  SyntaxParsingContext ItemListContext(SyntaxContext,
+                                       SyntaxKind::CodeBlockItemList);
 
   bool IsTopLevel = (Kind == BraceItemListKind::TopLevelCode) ||
                     (Kind == BraceItemListKind::TopLevelLibrary);
@@ -264,9 +267,10 @@
          (isConditionalBlock ||
           !isTerminatorForBraceItemListKind(Kind, Entries))) {
 
-    SyntaxParsingContext StmtContext(SyntaxContext, SyntaxContextKind::Stmt);
+    SyntaxParsingContext NodeContext(SyntaxContext, SyntaxKind::CodeBlockItem);
 
     if (Tok.is(tok::r_brace)) {
+      SyntaxParsingContext ErrContext(SyntaxContext, SyntaxContextKind::Stmt);
       assert(IsTopLevel);
       diagnose(Tok, diag::extra_rbrace)
         .fixItRemove(Tok.getLoc());
@@ -275,8 +279,11 @@
     }
 
     // Eat invalid tokens instead of allowing them to produce downstream errors.
-    if (consumeIf(tok::unknown))
+    if (Tok.is(tok::unknown)) {
+      SyntaxParsingContext ErrContext(SyntaxContext, SyntaxContextKind::Stmt);
+      consumeToken();
       continue;
+    }
            
     bool NeedParseErrorRecovery = false;
     ASTNode Result;
@@ -411,6 +418,11 @@
     }
 
     if (NeedParseErrorRecovery) {
+      SyntaxContext->createNodeInPlace(SyntaxKind::CodeBlockItem);
+      SyntaxContext->setTransparent();
+
+      SyntaxParsingContext ItemCtxt(SyntaxContext, SyntaxKind::CodeBlockItem);
+      SyntaxParsingContext StmtCtxt(SyntaxContext, SyntaxContextKind::Stmt);
       // If we had a parse error, skip to the start of the next stmt, decl or
       // '{'.
       //
diff --git a/lib/Parse/SyntaxParsingContext.cpp b/lib/Parse/SyntaxParsingContext.cpp
index 825e607..c17400e 100644
--- a/lib/Parse/SyntaxParsingContext.cpp
+++ b/lib/Parse/SyntaxParsingContext.cpp
@@ -68,17 +68,10 @@
   if (Parts.size() == 1) {
     auto RawNode = Parts.front();
     switch (Kind) {
-    case SyntaxContextKind::Stmt: {
-      if (RawNode->isStmt())
-        return RawNode;
-      else if (RawNode->isDecl())
-        return createSyntaxAs(SyntaxKind::DeclarationStmt, Parts);
-      else if (RawNode->isExpr())
-        return createSyntaxAs(SyntaxKind::ExpressionStmt, Parts);
-      else
+    case SyntaxContextKind::Stmt:
+      if (!RawNode->isStmt())
         return makeUnknownSyntax(SyntaxKind::UnknownStmt, Parts);
       break;
-    }
     case SyntaxContextKind::Decl:
       if (!RawNode->isDecl())
         return makeUnknownSyntax(SyntaxKind::UnknownDecl, Parts);
@@ -186,6 +179,7 @@
     createNodeInPlace(Kind, Pair.first);
     break;
   }
+  case SyntaxKind::CodeBlockItem:
   case SyntaxKind::IdentifierExpr:
   case SyntaxKind::SpecializeExpr:
   case SyntaxKind::MemberAccessExpr:
@@ -255,8 +249,8 @@
 
   if (SF.hasSyntaxRoot()) {
     auto SourceRaw = SF.getSyntaxRoot().getRaw();
-    auto Decls = SourceRaw->getChild(SourceFileSyntax::Cursor::TopLevelDecls)
-                     ->getLayout();
+    auto Decls =
+        SourceRaw->getChild(SourceFileSyntax::Cursor::Items)->getLayout();
     std::copy(Decls.begin(), Decls.end(), std::back_inserter(AllTopLevel));
     EOFToken = SourceRaw->getChild(SourceFileSyntax::Cursor::EOFToken);
   }
@@ -267,12 +261,13 @@
   }
 
   for (auto RawNode : Parts) {
-    if (RawNode->getKind() != SyntaxKind::StmtList)
+    if (RawNode->getKind() != SyntaxKind::CodeBlockItemList)
       // FIXME: Skip toplevel garbage nodes for now. we shouldn't emit them in
       // the first place.
       continue;
-    AllTopLevel.push_back(
-        SyntaxFactory::createRaw(SyntaxKind::TopLevelCodeDecl, {RawNode}));
+
+    auto Items = RawNode->getLayout();
+    std::copy(Items.begin(), Items.end(), std::back_inserter(AllTopLevel));
   }
 
   if (!EOFToken)
@@ -281,8 +276,10 @@
   auto newRaw = SyntaxFactory::createRaw(
       SyntaxKind::SourceFile,
       {
-          SyntaxFactory::createRaw(SyntaxKind::DeclList, AllTopLevel), EOFToken,
+          SyntaxFactory::createRaw(SyntaxKind::CodeBlockItemList, AllTopLevel),
+          EOFToken,
       });
+  assert(newRaw);
   SF.setSyntaxRoot(make<SourceFileSyntax>(newRaw));
 
   if (SF.getASTContext().LangOpts.VerifySyntaxTree) {
diff --git a/lib/SIL/DynamicCasts.cpp b/lib/SIL/DynamicCasts.cpp
index 4f2c181..2df2022 100644
--- a/lib/SIL/DynamicCasts.cpp
+++ b/lib/SIL/DynamicCasts.cpp
@@ -239,14 +239,13 @@
   return false;
 }
 
-/// Given that a type is not statically known to be an optional type, check whether
-/// it might dynamically be an optional type.
-static bool canDynamicallyBeOptionalType(CanType type) {
+/// Given that a type is not statically known to be an optional type, check
+/// whether it might dynamically be able to store an optional.
+static bool canDynamicallyStoreOptional(CanType type) {
   assert(!type.getOptionalObjectType());
-  return (isa<ArchetypeType>(type) || type.isExistentialType())
-      && !type.isAnyClassReferenceType();
+  return type->canDynamicallyBeOptionalType(/* includeExistential */ true);
 }
-
+  
 /// Given two class types, check whether there's a hierarchy relationship
 /// between them.
 static DynamicCastFeasibility
@@ -326,7 +325,7 @@
     auto result = classifyDynamicCast(M, source, targetObject,
                                       /* isSourceTypeExact */ false,
                                       isWholeModuleOpts);
-    if (canDynamicallyBeOptionalType(source))
+    if (canDynamicallyStoreOptional(source))
       result = atWorst(result, DynamicCastFeasibility::MaySucceed);
     return result;
 
diff --git a/lib/SIL/Projection.cpp b/lib/SIL/Projection.cpp
index 85188ca..fe0371b 100644
--- a/lib/SIL/Projection.cpp
+++ b/lib/SIL/Projection.cpp
@@ -73,8 +73,6 @@
     Value = ValueTy(ProjectionKind::Struct, SEAI->getFieldNo());
     assert(getKind() == ProjectionKind::Struct);
     assert(getIndex() == SEAI->getFieldNo());
-    assert(getType(SEAI->getOperand()->getType(), SEAI->getModule()) ==
-           SEAI->getType());
     break;
   }
   case SILInstructionKind::StructExtractInst: {
@@ -82,8 +80,6 @@
     Value = ValueTy(ProjectionKind::Struct, SEI->getFieldNo());
     assert(getKind() == ProjectionKind::Struct);
     assert(getIndex() == SEI->getFieldNo());
-    assert(getType(SEI->getOperand()->getType(), SEI->getModule()) ==
-           SEI->getType());
     break;
   }
   case SILInstructionKind::RefElementAddrInst: {
@@ -91,8 +87,6 @@
     Value = ValueTy(ProjectionKind::Class, REAI->getFieldNo());
     assert(getKind() == ProjectionKind::Class);
     assert(getIndex() == REAI->getFieldNo());
-    assert(getType(REAI->getOperand()->getType(), REAI->getModule()) ==
-           REAI->getType());
     break;
   }
   case SILInstructionKind::RefTailAddrInst: {
@@ -107,8 +101,6 @@
     Value = ValueTy(ProjectionKind::Box, static_cast<uintptr_t>(0));
     assert(getKind() == ProjectionKind::Box);
     assert(getIndex() == 0);
-    assert(getType(PBI->getOperand()->getType(), PBI->getModule()) ==
-           PBI->getType());
     (void) PBI;
     break;
   }
@@ -117,8 +109,6 @@
     Value = ValueTy(ProjectionKind::Tuple, TEI->getFieldNo());
     assert(getKind() == ProjectionKind::Tuple);
     assert(getIndex() == TEI->getFieldNo());
-    assert(getType(TEI->getOperand()->getType(), TEI->getModule()) ==
-           TEI->getType());
     break;
   }
   case SILInstructionKind::TupleElementAddrInst: {
@@ -126,8 +116,6 @@
     Value = ValueTy(ProjectionKind::Tuple, TEAI->getFieldNo());
     assert(getKind() == ProjectionKind::Tuple);
     assert(getIndex() == TEAI->getFieldNo());
-    assert(getType(TEAI->getOperand()->getType(), TEAI->getModule()) ==
-           TEAI->getType());
     break;
   }
   case SILInstructionKind::UncheckedEnumDataInst: {
@@ -135,8 +123,6 @@
     Value = ValueTy(ProjectionKind::Enum, UEDI->getElementNo());
     assert(getKind() == ProjectionKind::Enum);
     assert(getIndex() == UEDI->getElementNo());
-    assert(getType(UEDI->getOperand()->getType(), UEDI->getModule()) ==
-           UEDI->getType());
     break;
   }
   case SILInstructionKind::UncheckedTakeEnumDataAddrInst: {
@@ -144,8 +130,6 @@
     Value = ValueTy(ProjectionKind::Enum, UTEDAI->getElementNo());
     assert(getKind() == ProjectionKind::Enum);
     assert(getIndex() == UTEDAI->getElementNo());
-    assert(getType(UTEDAI->getOperand()->getType(), UTEDAI->getModule()) ==
-           UTEDAI->getType());
     break;
   }
   case SILInstructionKind::IndexAddrInst: {
@@ -168,8 +152,6 @@
     assert(Ty->isCanonical());
     Value = ValueTy(ProjectionKind::Upcast, Ty);
     assert(getKind() == ProjectionKind::Upcast);
-    assert(getType(I->getOperand(0)->getType(), I->getModule()) ==
-           I->getType());
     break;
   }
   case SILInstructionKind::UncheckedRefCastInst: {
@@ -177,8 +159,6 @@
     assert(Ty->isCanonical());
     Value = ValueTy(ProjectionKind::RefCast, Ty);
     assert(getKind() == ProjectionKind::RefCast);
-    assert(getType(I->getOperand(0)->getType(), I->getModule()) ==
-           I->getType());
     break;
   }
   case SILInstructionKind::UncheckedBitwiseCastInst:
@@ -187,8 +167,6 @@
     assert(Ty->isCanonical());
     Value = ValueTy(ProjectionKind::BitwiseCast, Ty);
     assert(getKind() == ProjectionKind::BitwiseCast);
-    assert(getType(I->getOperand(0)->getType(), I->getModule()) ==
-           I->getType());
     break;
   }
   }
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
index bce425e..112a213 100644
--- a/lib/Sema/CSApply.cpp
+++ b/lib/Sema/CSApply.cpp
@@ -3299,14 +3299,21 @@
       auto destValueType
         = finalResultType->lookThroughAllOptionalTypes(destOptionals);
 
-      // When performing a bridging operation, if the destination value type
-      // is 'AnyObject', leave any extra optionals on the source in place.
-      if (castKind == OptionalBindingsCastKind::Bridged &&
-          srcOptionals.size() > destOptionals.size() &&
-          destValueType->isAnyObject()) {
-        srcType = srcOptionals[destOptionals.size()];
-        srcOptionals.erase(srcOptionals.begin() + destOptionals.size(),
-                           srcOptionals.end());
+      auto isBridgeToAnyObject =
+        castKind == OptionalBindingsCastKind::Bridged &&
+        destValueType->isAnyObject();
+
+      // If the destination value type is 'AnyObject' when performing a
+      // bridging operation, or if the destination value type could dynamically
+      // be an optional type, leave any extra optionals on the source in place.
+      if (isBridgeToAnyObject || destValueType->canDynamicallyBeOptionalType(
+                                              /* includeExistential */ false)) {
+        auto destOptionalsCount = destOptionals.size() - destExtraOptionals;
+        if (srcOptionals.size() > destOptionalsCount) {
+          srcType = srcOptionals[destOptionalsCount];
+          srcOptionals.erase(srcOptionals.begin() + destOptionalsCount,
+                             srcOptionals.end());
+        }
       }
 
       // When performing a bridging operation, if the destination type
@@ -4482,9 +4489,6 @@
     /// Diagnose an optional injection that is probably not what the
     /// user wanted, because it comes from a forced downcast.
     void diagnoseOptionalInjection(InjectIntoOptionalExpr *injection) {
-      // Don't diagnose when we're injecting into 
-      auto toOptionalType = cs.getType(injection);
-
       // Check whether we have a forced downcast.
       auto &tc = cs.getTypeChecker();
       auto *cast = findForcedDowncast(tc.Context, injection->getSubExpr());
@@ -6152,7 +6156,10 @@
       // func bar() -> ((()) -> Void)? { return nil }
       // foo(bar) // This expression should compile in Swift 3 mode
       // ```
-      if (tc.getLangOpts().isSwiftVersion3()) {
+      //
+      // See also: https://bugs.swift.org/browse/SR-6796
+      if (cs.getASTContext().isSwiftVersionAtLeast(3) &&
+          !cs.getASTContext().isSwiftVersionAtLeast(5)) {
         auto obj1 = fromType->getOptionalObjectType();
         auto obj2 = toType->getOptionalObjectType();
 
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
index 802b9b5..7971360 100644
--- a/lib/Sema/CSSimplify.cpp
+++ b/lib/Sema/CSSimplify.cpp
@@ -1168,6 +1168,35 @@
     }
   }
 
+  // https://bugs.swift.org/browse/SR-6796
+  // Add a super-narrow hack to allow:
+  //   (()) -> T to be passed in place of () -> T
+  if (getASTContext().isSwiftVersionAtLeast(4) &&
+      !getASTContext().isSwiftVersionAtLeast(5)) {
+    SmallVector<LocatorPathElt, 4> path;
+    locator.getLocatorParts(path);
+
+    // Find the last path element, skipping GenericArgument elements
+    // so that we allow this exception in cases of optional types, and
+    // skipping OptionalPayload elements so that we allow this
+    // exception in cases of optional injection.
+    auto last = std::find_if(
+        path.rbegin(), path.rend(), [](LocatorPathElt &elt) -> bool {
+          return elt.getKind() != ConstraintLocator::GenericArgument &&
+                 elt.getKind() != ConstraintLocator::OptionalPayload;
+        });
+
+    if (last != path.rend()) {
+      if (last->getKind() == ConstraintLocator::ApplyArgToParam) {
+        if (auto *paren1 = dyn_cast<ParenType>(func1Input.getPointer())) {
+          auto innerTy = paren1->getUnderlyingType();
+          if (func2Input->isVoid() && innerTy->isVoid())
+            func1Input = innerTy;
+        }
+      }
+    }
+  }
+
   // Input types can be contravariant (or equal).
   SmallVector<AnyFunctionType::Param, 4> func1Params;
   SmallVector<AnyFunctionType::Param, 4> func2Params;
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
index 682b604..50a8c09 100644
--- a/lib/Serialization/Deserialization.cpp
+++ b/lib/Serialization/Deserialization.cpp
@@ -1264,18 +1264,22 @@
   case XREF_TYPE_PATH_PIECE:
   case XREF_VALUE_PATH_PIECE: {
     IdentifierID IID;
+    IdentifierID privateDiscriminator = 0;
     TypeID TID = 0;
     bool isType = (recordID == XREF_TYPE_PATH_PIECE);
     bool inProtocolExt = false;
     bool isStatic = false;
     if (isType)
-      XRefTypePathPieceLayout::readRecord(scratch, IID, inProtocolExt);
+      XRefTypePathPieceLayout::readRecord(scratch, IID, privateDiscriminator,
+                                          inProtocolExt);
     else
       XRefValuePathPieceLayout::readRecord(scratch, TID, IID, inProtocolExt,
                                            isStatic);
 
     DeclBaseName name = getDeclBaseName(IID);
     pathTrace.addValue(name);
+    if (privateDiscriminator)
+      pathTrace.addValue(getIdentifier(privateDiscriminator));
 
     Type filterTy;
     if (!isType) {
@@ -1290,9 +1294,14 @@
       pathTrace.addType(filterTy);
     }
 
-    baseModule->lookupQualified(ModuleType::get(baseModule), name,
-                                NL_QualifiedDefault | NL_KnownNoDependency,
-                                /*typeResolver=*/nullptr, values);
+    if (privateDiscriminator) {
+      baseModule->lookupMember(values, baseModule, name,
+                               getIdentifier(privateDiscriminator));
+    } else {
+      baseModule->lookupQualified(ModuleType::get(baseModule), name,
+                                  NL_QualifiedDefault | NL_KnownNoDependency,
+                                  /*typeResolver=*/nullptr, values);
+    }
     filterValues(filterTy, nullptr, nullptr, isType, inProtocolExt, isStatic,
                  None, values);
     break;
@@ -1348,7 +1357,7 @@
       switch (recordID) {
       case XREF_TYPE_PATH_PIECE: {
         IdentifierID IID;
-        XRefTypePathPieceLayout::readRecord(scratch, IID, None);
+        XRefTypePathPieceLayout::readRecord(scratch, IID, None, None);
         result = getIdentifier(IID);
         break;
       }
@@ -1405,8 +1414,13 @@
         // Fast path for nested types that avoids deserializing all
         // members of the parent type.
         IdentifierID IID;
+        IdentifierID privateDiscriminator;
         bool onlyInNominal = false;
-        XRefTypePathPieceLayout::readRecord(scratch, IID, onlyInNominal);
+        XRefTypePathPieceLayout::readRecord(scratch, IID, privateDiscriminator,
+                                            onlyInNominal);
+        if (privateDiscriminator)
+          goto giveUpFastPath;
+
         Identifier memberName = getIdentifier(IID);
         pathTrace.addValue(memberName);
 
@@ -1449,21 +1463,25 @@
 
         pathTrace.removeLast();
       }
+giveUpFastPath:
       LLVM_FALLTHROUGH;
     }
     case XREF_VALUE_PATH_PIECE:
     case XREF_INITIALIZER_PATH_PIECE: {
       TypeID TID = 0;
       DeclBaseName memberName;
+      Identifier privateDiscriminator;
       Optional<swift::CtorInitializerKind> ctorInit;
       bool isType = false;
       bool inProtocolExt = false;
       bool isStatic = false;
       switch (recordID) {
       case XREF_TYPE_PATH_PIECE: {
-        IdentifierID IID;
-        XRefTypePathPieceLayout::readRecord(scratch, IID, inProtocolExt);
+        IdentifierID IID, discriminatorID;
+        XRefTypePathPieceLayout::readRecord(scratch, IID, discriminatorID,
+                                            inProtocolExt);
         memberName = getDeclBaseName(IID);
+        privateDiscriminator = getIdentifier(discriminatorID);
         isType = true;
         break;
       }
@@ -1490,6 +1508,8 @@
       }
 
       pathTrace.addValue(memberName);
+      if (!privateDiscriminator.empty())
+        pathTrace.addPrivateDiscriminator(privateDiscriminator);
 
       Type filterTy;
       if (!isType) {
@@ -1519,8 +1539,17 @@
                                            getXRefDeclNameForError());
       }
 
-      auto members = nominal->lookupDirect(memberName);
-      values.append(members.begin(), members.end());
+      if (!privateDiscriminator.empty()) {
+        ModuleDecl *searchModule = M;
+        if (!searchModule)
+          searchModule = nominal->getModuleContext();
+        searchModule->lookupMember(values, nominal, memberName,
+                                   privateDiscriminator);
+
+      } else {
+        auto members = nominal->lookupDirect(memberName);
+        values.append(members.begin(), members.end());
+      }
       filterValues(filterTy, M, genericSig, isType, inProtocolExt, isStatic,
                    ctorInit, values);
       break;
diff --git a/lib/Serialization/DeserializationErrors.h b/lib/Serialization/DeserializationErrors.h
index b5424c3..0703ea4 100644
--- a/lib/Serialization/DeserializationErrors.h
+++ b/lib/Serialization/DeserializationErrors.h
@@ -37,6 +37,7 @@
       Accessor,
       Extension,
       GenericParam,
+      PrivateDiscriminator,
       Unknown
     };
 
@@ -55,11 +56,12 @@
       : kind(K),
         data(llvm::PointerLikeTypeTraits<T>::getAsVoidPointer(value)) {}
 
-    Identifier getAsIdentifier() const {
+    DeclBaseName getAsBaseName() const {
       switch (kind) {
       case Kind::Value:
       case Kind::Operator:
-        return getDataAs<Identifier>();
+      case Kind::PrivateDiscriminator:
+        return getDataAs<DeclBaseName>();
       case Kind::Type:
       case Kind::OperatorFilter:
       case Kind::Accessor:
@@ -73,7 +75,7 @@
     void print(raw_ostream &os) const {
       switch (kind) {
       case Kind::Value:
-        os << getDataAs<Identifier>();
+        os << getDataAs<DeclBaseName>();
         break;
       case Kind::Type:
         os << "with type " << getDataAs<Type>();
@@ -137,6 +139,9 @@
       case Kind::GenericParam:
         os << "generic param #" << getDataAs<uintptr_t>();
         break;
+      case Kind::PrivateDiscriminator:
+        os << "(in " << getDataAs<Identifier>() << ")";
+        break;
       case Kind::Unknown:
         os << "unknown xref kind " << getDataAs<uintptr_t>();
         break;
@@ -180,17 +185,21 @@
     path.push_back({ PathPiece::Kind::GenericParam, index });
   }
 
+  void addPrivateDiscriminator(Identifier name) {
+    path.push_back({ PathPiece::Kind::PrivateDiscriminator, name });
+  }
+
   void addUnknown(uintptr_t kind) {
     path.push_back({ PathPiece::Kind::Unknown, kind });
   }
 
-  Identifier getLastName() const {
+  DeclBaseName getLastName() const {
     for (auto &piece : reversed(path)) {
-      Identifier result = piece.getAsIdentifier();
+      DeclBaseName result = piece.getAsBaseName();
       if (!result.empty())
         return result;
     }
-    return Identifier();
+    return DeclBaseName();
   }
 
   void removeLast() {
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index 1eca569..a020f9d 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -1868,8 +1868,16 @@
 
     auto generic = cast<GenericTypeDecl>(DC);
     abbrCode = DeclTypeAbbrCodes[XRefTypePathPieceLayout::Code];
+
+    Identifier discriminator;
+    if (generic->isOutermostPrivateOrFilePrivateScope()) {
+      auto *containingFile = cast<FileUnit>(generic->getModuleScopeContext());
+      discriminator = containingFile->getDiscriminatorForPrivateValue(generic);
+    }
+
     XRefTypePathPieceLayout::emitRecord(Out, ScratchRecord, abbrCode,
                                         addDeclBaseNameRef(generic->getName()),
+                                        addDeclBaseNameRef(discriminator),
                                         false);
     break;
   }
@@ -2019,8 +2027,17 @@
   bool isProtocolExt = D->getDeclContext()->getAsProtocolExtensionContext();
   if (auto type = dyn_cast<TypeDecl>(D)) {
     abbrCode = DeclTypeAbbrCodes[XRefTypePathPieceLayout::Code];
+
+    Identifier discriminator;
+    if (type->isOutermostPrivateOrFilePrivateScope()) {
+      auto *containingFile =
+         cast<FileUnit>(type->getDeclContext()->getModuleScopeContext());
+      discriminator = containingFile->getDiscriminatorForPrivateValue(type);
+    }
+
     XRefTypePathPieceLayout::emitRecord(Out, ScratchRecord, abbrCode,
                                         addDeclBaseNameRef(type->getName()),
+                                        addDeclBaseNameRef(discriminator),
                                         isProtocolExt);
     return;
   }
diff --git a/lib/Syntax/RawSyntax.cpp b/lib/Syntax/RawSyntax.cpp
index 14a22ec..0613fec 100644
--- a/lib/Syntax/RawSyntax.cpp
+++ b/lib/Syntax/RawSyntax.cpp
@@ -30,7 +30,7 @@
     return true;
   switch(Kind) {
   case SyntaxKind::SourceFile:
-  case SyntaxKind::TopLevelCodeDecl:
+  case SyntaxKind::CodeBlockItem:
   case SyntaxKind::ExpressionStmt:
   case SyntaxKind::DeclarationStmt:
     return true;
@@ -179,6 +179,8 @@
       Trailer.accumulateAbsolutePosition(Pos);
   } else {
     for (auto &Child : getLayout()) {
+      if (!Child)
+        continue;
       auto Result = Child->accumulateAbsolutePosition(Pos);
       if (!Ret && Result)
         Ret = Result;
@@ -254,6 +256,8 @@
     }
   } else {
     for (auto &Child : getLayout()) {
+      if (!Child)
+        continue;
       OS << "\n";
       Child->dump(OS, Indent + 1);
     }
diff --git a/test/Compatibility/tuple_arguments.swift b/test/Compatibility/tuple_arguments_3.swift
similarity index 98%
rename from test/Compatibility/tuple_arguments.swift
rename to test/Compatibility/tuple_arguments_3.swift
index e5e87d0..ad90c25 100644
--- a/test/Compatibility/tuple_arguments.swift
+++ b/test/Compatibility/tuple_arguments_3.swift
@@ -1,7 +1,8 @@
 // RUN: %target-typecheck-verify-swift -swift-version 3
 
 // Tests for tuple argument behavior in Swift 3, which was broken.
-// The Swift 4 test is in test/Constraints/tuple_arguments.swift.
+// The Swift 4 test is in test/Compatibility/tuple_arguments_4.swift.
+// The test for the most recent version is in test/Constraints/tuple_arguments.swift.
 
 // Key:
 // - "Crashes in actual Swift 3" -- snippets which crashed in Swift 3.0.1.
@@ -1516,3 +1517,20 @@
   takeFn(fn: { (pair: (Int, Int?)) in } )
   takeFn { (pair: (Int, Int?)) in }
 }
+
+// https://bugs.swift.org/browse/SR-6796
+do {
+  func f(a: (() -> Void)? = nil) {}
+  func log<T>() -> ((T) -> Void)? { return nil }
+
+  f(a: log() as ((()) -> Void)?) // Allow ((()) -> Void)? to be passed in place of (() -> Void)?
+
+  func logNoOptional<T>() -> (T) -> Void { }
+  f(a: logNoOptional() as ((()) -> Void)) // Also allow the optional-injected form.
+
+  func g() {}
+  g(())
+
+  func h(_: ()) {}
+  h()
+}
diff --git a/test/Compatibility/tuple_arguments.swift b/test/Compatibility/tuple_arguments_4.swift
similarity index 68%
copy from test/Compatibility/tuple_arguments.swift
copy to test/Compatibility/tuple_arguments_4.swift
index e5e87d0..1432f0c 100644
--- a/test/Compatibility/tuple_arguments.swift
+++ b/test/Compatibility/tuple_arguments_4.swift
@@ -1,26 +1,10 @@
-// RUN: %target-typecheck-verify-swift -swift-version 3
+// RUN: %target-typecheck-verify-swift -swift-version 4
 
-// Tests for tuple argument behavior in Swift 3, which was broken.
-// The Swift 4 test is in test/Constraints/tuple_arguments.swift.
-
-// Key:
-// - "Crashes in actual Swift 3" -- snippets which crashed in Swift 3.0.1.
-//   These don't have well-defined semantics in Swift 3 mode and don't
-//   matter for source compatibility purposes.
-//
-// - "Does not diagnose in Swift 3 mode" -- snippets which failed to typecheck
-//   in Swift 3.0.1, but now typecheck. This is fine.
-//
-// - "Diagnoses in Swift 3 mode" -- snippets which typechecked in Swift 3.0.1,
-//   but now fail to typecheck. These are bugs in Swift 3 mode that should be
-//   fixed.
-//
-// - "Crashes in Swift 3 mode" -- snippets which did not crash Swift 3.0.1,
-//   but now crash. These are bugs in Swift 3 mode that should be fixed.
+// See test/Compatibility/tuple_arguments_3.swift for the Swift 3 behavior.
 
 func concrete(_ x: Int) {}
 func concreteLabeled(x: Int) {}
-func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 3 {{'concreteTwo' declared here}}
+func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 5 {{'concreteTwo' declared here}}
 func concreteTuple(_ x: (Int, Int)) {}
 
 do {
@@ -49,10 +33,10 @@
   concrete(c)
 
   concreteTwo(a, b)
-  concreteTwo((a, b))
-  concreteTwo(d) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  concreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  concreteTwo(d) // expected-error {{missing argument for parameter #2 in call}}
 
-  concreteTuple(a, b)
+  concreteTuple(a, b) // expected-error {{global function 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}}
   concreteTuple((a, b))
   concreteTuple(d)
 }
@@ -83,7 +67,7 @@
 
 do {
   generic(3)
-  generic(3, 4)
+  generic(3, 4) // expected-error {{extra argument in call}}
   generic((3))
   generic((3, 4))
 
@@ -106,7 +90,7 @@
   let d = (a, b)
 
   generic(a)
-  generic(a, b)
+  generic(a, b) // expected-error {{extra argument in call}}
   generic((a))
   generic(c)
   generic((a, b))
@@ -128,7 +112,7 @@
   var d = (a, b)
 
   generic(a)
-  // generic(a, b) // Crashes in actual Swift 3
+  generic(a, b) // expected-error {{extra argument in call}}
   generic((a))
   generic(c)
   generic((a, b))
@@ -144,7 +128,7 @@
 }
 
 var function: (Int) -> ()
-var functionTwo: (Int, Int) -> () // expected-note 3 {{'functionTwo' declared here}}
+var functionTwo: (Int, Int) -> () // expected-note 5 {{'functionTwo' declared here}}
 var functionTuple: ((Int, Int)) -> ()
 
 do {
@@ -169,10 +153,10 @@
   function(c)
 
   functionTwo(a, b)
-  functionTwo((a, b))
-  functionTwo(d) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  functionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  functionTwo(d) // expected-error {{missing argument for parameter #2 in call}}
 
-  functionTuple(a, b)
+  functionTuple(a, b) // expected-error {{var 'functionTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}}
   functionTuple((a, b))
   functionTuple(d)
 }
@@ -200,7 +184,7 @@
 
 extension Concrete {
   func concrete(_ x: Int) {}
-  func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 3 {{'concreteTwo' declared here}}
+  func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 5 {{'concreteTwo' declared here}}
   func concreteTuple(_ x: (Int, Int)) {}
 }
 
@@ -230,10 +214,10 @@
   s.concrete(c)
 
   s.concreteTwo(a, b)
-  s.concreteTwo((a, b))
-  s.concreteTwo(d) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  s.concreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  s.concreteTwo(d) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.concreteTuple(a, b)
+  s.concreteTuple(a, b) // expected-error {{instance method 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{19-19=(}} {{23-23=)}}
   s.concreteTuple((a, b))
   s.concreteTuple(d)
 }
@@ -270,7 +254,7 @@
   let s = Concrete()
 
   s.generic(3)
-  s.generic(3, 4)
+  s.generic(3, 4) // expected-error {{extra argument in call}}
   s.generic((3))
   s.generic((3, 4))
 
@@ -295,7 +279,7 @@
   let d = (a, b)
 
   s.generic(a)
-  s.generic(a, b)
+  s.generic(a, b) // expected-error {{extra argument in call}}
   s.generic((a))
   s.generic((a, b))
   s.generic(d)
@@ -318,7 +302,7 @@
   var d = (a, b)
 
   s.generic(a)
-  // s.generic(a, b) // Crashes in actual Swift 3
+  s.generic(a, b) // expected-error {{extra argument in call}}
   s.generic((a))
   s.generic((a, b))
   s.generic(d)
@@ -334,7 +318,7 @@
 
 extension Concrete {
   mutating func mutatingConcrete(_ x: Int) {}
-  mutating func mutatingConcreteTwo(_ x: Int, _ y: Int) {} // expected-note 3 {{'mutatingConcreteTwo' declared here}}
+  mutating func mutatingConcreteTwo(_ x: Int, _ y: Int) {} // expected-note 5 {{'mutatingConcreteTwo' declared here}}
   mutating func mutatingConcreteTuple(_ x: (Int, Int)) {}
 }
 
@@ -364,10 +348,10 @@
   s.mutatingConcrete(c)
 
   s.mutatingConcreteTwo(a, b)
-  s.mutatingConcreteTwo((a, b))
-  s.mutatingConcreteTwo(d) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  s.mutatingConcreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  s.mutatingConcreteTwo(d) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.mutatingConcreteTuple(a, b)
+  s.mutatingConcreteTuple(a, b) // expected-error {{instance method 'mutatingConcreteTuple' expects a single parameter of type '(Int, Int)'}} {{27-27=(}} {{31-31=)}}
   s.mutatingConcreteTuple((a, b))
   s.mutatingConcreteTuple(d)
 }
@@ -404,7 +388,7 @@
   var s = Concrete()
 
   s.mutatingGeneric(3)
-  s.mutatingGeneric(3, 4)
+  s.mutatingGeneric(3, 4) // expected-error {{extra argument in call}}
   s.mutatingGeneric((3))
   s.mutatingGeneric((3, 4))
 
@@ -429,7 +413,7 @@
   let d = (a, b)
 
   s.mutatingGeneric(a)
-  s.mutatingGeneric(a, b)
+  s.mutatingGeneric(a, b) // expected-error {{extra argument in call}}
   s.mutatingGeneric((a))
   s.mutatingGeneric((a, b))
   s.mutatingGeneric(d)
@@ -452,7 +436,7 @@
   var d = (a, b)
 
   s.mutatingGeneric(a)
-  // s.mutatingGeneric(a, b) // Crashes in actual Swift 3
+  s.mutatingGeneric(a, b) // expected-error {{extra argument in call}}
   s.mutatingGeneric((a))
   s.mutatingGeneric((a, b))
   s.mutatingGeneric(d)
@@ -498,10 +482,11 @@
   s.function(c)
 
   s.functionTwo(a, b)
-  s.functionTwo((a, b))
-  s.functionTwo(d) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  s.functionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  s.functionTwo(d) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.functionTuple(a, b)
+
+  s.functionTuple(a, b) // expected-error {{single parameter of type '(Int, Int)' is expected in call}} {{19-19=(}} {{23-23=)}}
   s.functionTuple((a, b))
   s.functionTuple(d)
 }
@@ -528,7 +513,7 @@
 }
 
 struct InitTwo {
-  init(_ x: Int, _ y: Int) {} // expected-note 3 {{'init' declared here}}
+  init(_ x: Int, _ y: Int) {} // expected-note 5 {{'init' declared here}}
 }
 
 struct InitTuple {
@@ -556,10 +541,10 @@
   let c = (a, b)
 
   _ = InitTwo(a, b)
-  _ = InitTwo((a, b))
-  _ = InitTwo(c) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  _ = InitTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  _ = InitTwo(c) // expected-error {{missing argument for parameter #2 in call}}
 
-  _ = InitTuple(a, b)
+  _ = InitTuple(a, b) // expected-error {{initializer expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}}
   _ = InitTuple((a, b))
   _ = InitTuple(c)
 }
@@ -579,7 +564,7 @@
 }
 
 struct SubscriptTwo {
-  subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 3 {{'subscript' declared here}}
+  subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 5 {{'subscript' declared here}}
 }
 
 struct SubscriptTuple {
@@ -598,10 +583,6 @@
   let s2 = SubscriptTuple()
   _ = s2[3, 4] // expected-error {{subscript expects a single parameter of type '(Int, Int)'}} {{10-10=(}} {{14-14=)}}
   _ = s2[(3, 4)]
-
-  let s3 = SubscriptLabeledTuple()
-  _ = s3[x: 3, 4] // expected-error {{extra argument in call}}
-  _ = s3[x: (3, 4)]
 }
 
 do {
@@ -611,13 +592,17 @@
 
   let s1 = SubscriptTwo()
   _ = s1[a, b]
-  _ = s1[(a, b)]
-  _ = s1[d]
+  _ = s1[(a, b)] // expected-error {{missing argument for parameter #2 in call}}
+  _ = s1[d] // expected-error {{missing argument for parameter #2 in call}}
 
   let s2 = SubscriptTuple()
-  _ = s2[a, b]
+  _ = s2[a, b] // expected-error {{subscript expects a single parameter of type '(Int, Int)'}} {{10-10=(}} {{14-14=)}}
   _ = s2[(a, b)]
   _ = s2[d]
+
+  let s3 = SubscriptLabeledTuple()
+  _ = s3[x: 3, 4] // expected-error {{extra argument in call}}
+  _ = s3[x: (3, 4)]
 }
 
 do {
@@ -638,7 +623,7 @@
 }
 
 enum Enum {
-  case two(Int, Int) // expected-note 3 {{'two' declared here}}
+  case two(Int, Int) // expected-note 6 {{'two' declared here}}
   case tuple((Int, Int))
   case labeledTuple(x: (Int, Int))
 }
@@ -646,6 +631,7 @@
 do {
   _ = Enum.two(3, 4)
   _ = Enum.two((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
+  _ = Enum.two(3 > 4 ? 3 : 4) // expected-error {{missing argument for parameter #2 in call}}
 
   _ = Enum.tuple(3, 4) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{18-18=(}} {{22-22=)}}
   _ = Enum.tuple((3, 4))
@@ -660,10 +646,10 @@
   let c = (a, b)
 
   _ = Enum.two(a, b)
-  _ = Enum.two((a, b))
-  _ = Enum.two(c) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  _ = Enum.two((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  _ = Enum.two(c) // expected-error {{missing argument for parameter #2 in call}}
 
-  _ = Enum.tuple(a, b)
+  _ = Enum.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{18-18=(}} {{22-22=)}}
   _ = Enum.tuple((a, b))
   _ = Enum.tuple(c)
 }
@@ -687,7 +673,7 @@
 extension Generic {
   func generic(_ x: T) {}
   func genericLabeled(x: T) {}
-  func genericTwo(_ x: T, _ y: T) {} // expected-note 2 {{'genericTwo' declared here}}
+  func genericTwo(_ x: T, _ y: T) {} // expected-note 3 {{'genericTwo' declared here}}
   func genericTuple(_ x: (T, T)) {}
 }
 
@@ -728,14 +714,14 @@
   s.generic(c)
 
   s.genericTwo(a, b)
-  s.genericTwo((a, b))
+  s.genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.genericTuple(a, b)
+  s.genericTuple(a, b) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(Double, Double)'}} {{18-18=(}} {{22-22=)}}
   s.genericTuple((a, b))
 
   let sTwo = Generic<(Double, Double)>()
 
-  sTwo.generic(a, b)
+  sTwo.generic(a, b) // expected-error {{instance method 'generic' expects a single parameter of type '(Double, Double)'}} {{16-16=(}} {{20-20=)}}
   sTwo.generic((a, b))
   sTwo.generic(d)
 }
@@ -768,7 +754,7 @@
 extension Generic {
   mutating func mutatingGeneric(_ x: T) {}
   mutating func mutatingGenericLabeled(x: T) {}
-  mutating func mutatingGenericTwo(_ x: T, _ y: T) {} // expected-note 2 {{'mutatingGenericTwo' declared here}}
+  mutating func mutatingGenericTwo(_ x: T, _ y: T) {} // expected-note 3 {{'mutatingGenericTwo' declared here}}
   mutating func mutatingGenericTuple(_ x: (T, T)) {}
 }
 
@@ -809,14 +795,14 @@
   s.mutatingGeneric(c)
 
   s.mutatingGenericTwo(a, b)
-  s.mutatingGenericTwo((a, b))
+  s.mutatingGenericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.mutatingGenericTuple(a, b)
+  s.mutatingGenericTuple(a, b) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(Double, Double)'}} {{26-26=(}} {{30-30=)}}
   s.mutatingGenericTuple((a, b))
 
   var sTwo = Generic<(Double, Double)>()
 
-  sTwo.mutatingGeneric(a, b)
+  sTwo.mutatingGeneric(a, b) // expected-error {{instance method 'mutatingGeneric' expects a single parameter of type '(Double, Double)'}} {{24-24=(}} {{28-28=)}}
   sTwo.mutatingGeneric((a, b))
   sTwo.mutatingGeneric(d)
 }
@@ -866,8 +852,8 @@
 
   let sTwo = Generic<(Double, Double)>()
 
-  sTwo.genericFunction(3.0, 4.0)
-  sTwo.genericFunction((3.0, 4.0)) // Does not diagnose in Swift 3 mode
+  sTwo.genericFunction(3.0, 4.0) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{24-24=(}} {{32-32=)}}
+  sTwo.genericFunction((3.0, 4.0))
 }
 
 do {
@@ -883,16 +869,16 @@
   s.genericFunction(c)
 
   s.genericFunctionTwo(a, b)
-  s.genericFunctionTwo((a, b))
+  s.genericFunctionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.genericFunctionTuple(a, b)
+  s.genericFunctionTuple(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{26-26=(}} {{30-30=)}}
   s.genericFunctionTuple((a, b))
 
   let sTwo = Generic<(Double, Double)>()
 
-  sTwo.genericFunction(a, b)
+  sTwo.genericFunction(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{24-24=(}} {{28-28=)}}
   sTwo.genericFunction((a, b))
-  sTwo.genericFunction(d) // Does not diagnose in Swift 3 mode
+  sTwo.genericFunction(d)
 }
 
 do {
@@ -915,12 +901,12 @@
 
   var sTwo = Generic<(Double, Double)>()
 
-  sTwo.genericFunction(a, b)
-  sTwo.genericFunction((a, b)) // Does not diagnose in Swift 3 mode
-  sTwo.genericFunction(d) // Does not diagnose in Swift 3 mode
+  sTwo.genericFunction(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{24-24=(}} {{28-28=)}}
+  sTwo.genericFunction((a, b))
+  sTwo.genericFunction(d)
 }
 
-struct GenericInit<T> { // expected-note 2 {{'T' declared as parameter to type 'GenericInit'}}
+struct GenericInit<T> {
   init(_ x: T) {}
 }
 
@@ -929,7 +915,7 @@
 }
 
 struct GenericInitTwo<T> {
-  init(_ x: T, _ y: T) {} // expected-note 8 {{'init' declared here}}
+  init(_ x: T, _ y: T) {} // expected-note 10 {{'init' declared here}}
 }
 
 struct GenericInitTuple<T> {
@@ -941,7 +927,7 @@
 }
 
 do {
-  _ = GenericInit(3, 4)
+  _ = GenericInit(3, 4) // expected-error {{extra argument in call}}
   _ = GenericInit((3, 4))
 
   _ = GenericInitLabeled(x: 3, 4) // expected-error {{extra argument in call}}
@@ -958,8 +944,8 @@
 }
 
 do {
-  _ = GenericInit<(Int, Int)>(3, 4)
-  _ = GenericInit<(Int, Int)>((3, 4)) // expected-error {{expression type 'GenericInit<(Int, Int)>' is ambiguous without more context}}
+  _ = GenericInit<(Int, Int)>(3, 4) // expected-error {{extra argument in call}}
+  _ = GenericInit<(Int, Int)>((3, 4))
 
   _ = GenericInitLabeled<(Int, Int)>(x: 3, 4) // expected-error {{extra argument in call}}
   _ = GenericInitLabeled<(Int, Int)>(x: (3, 4))
@@ -979,7 +965,7 @@
   let b = 4
   let c = (a, b)
 
-  _ = GenericInit(a, b)
+  _ = GenericInit(a, b) // expected-error {{extra argument in call}}
   _ = GenericInit((a, b))
   _ = GenericInit(c)
 
@@ -997,15 +983,15 @@
   let b = 4
   let c = (a, b)
 
-  _ = GenericInit<(Int, Int)>(a, b)
+  _ = GenericInit<(Int, Int)>(a, b) // expected-error {{extra argument in call}}
   _ = GenericInit<(Int, Int)>((a, b))
   _ = GenericInit<(Int, Int)>(c)
 
   _ = GenericInitTwo<Int>(a, b)
-  _ = GenericInitTwo<Int>((a, b)) // Does not diagnose in Swift 3 mode
-  _ = GenericInitTwo<Int>(c) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  _ = GenericInitTwo<Int>((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  _ = GenericInitTwo<Int>(c) // expected-error {{missing argument for parameter #2 in call}}
 
-  _ = GenericInitTuple<Int>(a, b) // Does not diagnose in Swift 3 mode
+  _ = GenericInitTuple<Int>(a, b) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{29-29=(}} {{33-33=)}}
   _ = GenericInitTuple<Int>((a, b))
   _ = GenericInitTuple<Int>(c)
 }
@@ -1016,8 +1002,8 @@
   var c = (a, b)
 
   _ = GenericInit(a, b) // expected-error {{extra argument in call}}
-  _ = GenericInit((a, b)) // expected-error {{generic parameter 'T' could not be inferred}} // expected-note {{explicitly specify the generic arguments to fix this issue}}
-  _ = GenericInit(c) // expected-error {{generic parameter 'T' could not be inferred}} // expected-note {{explicitly specify the generic arguments to fix this issue}}
+  _ = GenericInit((a, b))
+  _ = GenericInit(c)
 
   _ = GenericInitTwo(a, b)
   _ = GenericInitTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
@@ -1033,9 +1019,9 @@
   var b = 4 // expected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}}
   var c = (a, b) // expected-warning {{variable 'c' was never mutated; consider changing to 'let' constant}}
 
-  // _ = GenericInit<(Int, Int)>(a, b) // Crashes in Swift 3
-  _ = GenericInit<(Int, Int)>((a, b)) // expected-error {{expression type 'GenericInit<(Int, Int)>' is ambiguous without more context}}
-   _ = GenericInit<(Int, Int)>(c) // expected-error {{expression type 'GenericInit<(Int, Int)>' is ambiguous without more context}}
+  _ = GenericInit<(Int, Int)>(a, b) // expected-error {{extra argument in call}}
+  _ = GenericInit<(Int, Int)>((a, b))
+   _ = GenericInit<(Int, Int)>(c)
 
   _ = GenericInitTwo<Int>(a, b)
   _ = GenericInitTwo<Int>((a, b)) // expected-error {{missing argument for parameter #2 in call}}
@@ -1047,8 +1033,7 @@
 }
 
 struct GenericSubscript<T> {
-  // TODO: Restore regressed diagnostics rdar://problem/31724211
-  subscript(_ x: T) -> Int { get { return 0 } set { } } // expected-note* {{}}
+  subscript(_ x: T) -> Int { get { return 0 } set { } }
 }
 
 struct GenericSubscriptLabeled<T> {
@@ -1056,22 +1041,21 @@
 }
 
 struct GenericSubscriptTwo<T> {
-  subscript(_ x: T, _ y: T) -> Int { get { return 0 } set { } } // expected-note 3 {{'subscript' declared here}}
-}
-
-struct GenericSubscriptTuple<T> {
-  subscript(_ x: (T, T)) -> Int { get { return 0 } set { } }
+  subscript(_ x: T, _ y: T) -> Int { get { return 0 } set { } } // expected-note 5 {{'subscript' declared here}}
 }
 
 struct GenericSubscriptLabeledTuple<T> {
   subscript(x x: (T, T)) -> Int { get { return 0 } set { } }
 }
 
+struct GenericSubscriptTuple<T> {
+  subscript(_ x: (T, T)) -> Int { get { return 0 } set { } }
+}
+
 do {
   let s1 = GenericSubscript<(Double, Double)>()
-  _ = s1[3.0, 4.0]
-  // TODO: Restore regressed diagnostics rdar://problem/31724211
-  _ = s1[(3.0, 4.0)] // expected-error {{}}
+  _ = s1[3.0, 4.0] // expected-error {{extra argument in call}}
+  _ = s1[(3.0, 4.0)]
 
   let s1a  = GenericSubscriptLabeled<(Double, Double)>()
   _ = s1a [x: 3.0, 4.0] // expected-error {{extra argument in call}}
@@ -1096,17 +1080,17 @@
   let d = (a, b)
 
   let s1 = GenericSubscript<(Double, Double)>()
-  _ = s1[a, b]
+  _ = s1[a, b] // expected-error {{extra argument in call}}
   _ = s1[(a, b)]
   _ = s1[d]
 
   let s2 = GenericSubscriptTwo<Double>()
   _ = s2[a, b]
-  _ = s2[(a, b)] // Does not diagnose in Swift 3 mode
-  _ = s2[d] // Does not diagnose in Swift 3 mode
+  _ = s2[(a, b)] // expected-error {{missing argument for parameter #2 in call}}
+  _ = s2[d] // expected-error {{missing argument for parameter #2 in call}}
 
   let s3 = GenericSubscriptTuple<Double>()
-  _ = s3[a, b] // Does not diagnose in Swift 3 mode
+  _ = s3[a, b] // expected-error {{subscript expects a single parameter of type '(T, T)'}} {{10-10=(}} {{14-14=)}}
   _ = s3[(a, b)]
   _ = s3[d]
 }
@@ -1118,11 +1102,9 @@
   var d = (a, b) // e/xpected-warning {{variable 'd' was never mutated; consider changing to 'let' constant}}
 
   var s1 = GenericSubscript<(Double, Double)>()
-  _ = s1[a, b]
-  // TODO: Restore regressed diagnostics rdar://problem/31724211
-  // These two lines give different regressed behavior in S3 and S4 mode
-  // _ = s1[(a, b)] // e/xpected-error {{expression type '@lvalue Int' is ambiguous without more context}}
-  // _ = s1[d] // e/xpected-error {{expression type '@lvalue Int' is ambiguous without more context}}
+  _ = s1[a, b] // expected-error {{extra argument in call}}
+  _ = s1[(a, b)]
+  _ = s1[d]
 
   var s2 = GenericSubscriptTwo<Double>()
   _ = s2[a, b]
@@ -1138,12 +1120,12 @@
 enum GenericEnum<T> {
   case one(T)
   case labeled(x: T)
-  case two(T, T) // expected-note 8 {{'two' declared here}}
+  case two(T, T) // expected-note 10 {{'two' declared here}}
   case tuple((T, T))
 }
 
 do {
-  _ = GenericEnum.one(3, 4)
+  _ = GenericEnum.one(3, 4) // expected-error {{extra argument in call}}
   _ = GenericEnum.one((3, 4))
 
   _ = GenericEnum.labeled(x: 3, 4) // expected-error {{extra argument in call}}
@@ -1159,8 +1141,8 @@
 }
 
 do {
-  _ = GenericEnum<(Int, Int)>.one(3, 4)
-  _ = GenericEnum<(Int, Int)>.one((3, 4)) // Does not diagnose in Swift 3 mode
+  _ = GenericEnum<(Int, Int)>.one(3, 4) // expected-error {{enum element 'one' expects a single parameter of type '(Int, Int)'}} {{35-35=(}} {{39-39=)}}
+  _ = GenericEnum<(Int, Int)>.one((3, 4))
 
   _ = GenericEnum<(Int, Int)>.labeled(x: 3, 4) // expected-error {{extra argument in call}}
   _ = GenericEnum<(Int, Int)>.labeled(x: (3, 4))
@@ -1179,7 +1161,7 @@
   let b = 4
   let c = (a, b)
 
-  _ = GenericEnum.one(a, b)
+  _ = GenericEnum.one(a, b) // expected-error {{extra argument in call}}
   _ = GenericEnum.one((a, b))
   _ = GenericEnum.one(c)
 
@@ -1197,15 +1179,15 @@
   let b = 4
   let c = (a, b)
 
-  _ = GenericEnum<(Int, Int)>.one(a, b)
+  _ = GenericEnum<(Int, Int)>.one(a, b) // expected-error {{enum element 'one' expects a single parameter of type '(Int, Int)'}} {{35-35=(}} {{39-39=)}}
   _ = GenericEnum<(Int, Int)>.one((a, b))
   _ = GenericEnum<(Int, Int)>.one(c)
 
   _ = GenericEnum<Int>.two(a, b)
-  _ = GenericEnum<Int>.two((a, b))
-  _ = GenericEnum<Int>.two(c) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
+  _ = GenericEnum<Int>.two((a, b)) // expected-error {{missing argument for parameter #2 in call}}
+  _ = GenericEnum<Int>.two(c) // expected-error {{missing argument for parameter #2 in call}}
 
-  _ = GenericEnum<Int>.tuple(a, b)
+  _ = GenericEnum<Int>.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{30-30=(}} {{34-34=)}}
   _ = GenericEnum<Int>.tuple((a, b))
   _ = GenericEnum<Int>.tuple(c)
 }
@@ -1215,9 +1197,9 @@
   var b = 4
   var c = (a, b)
 
-  // _ = GenericEnum.one(a, b) // Crashes in actual Swift 3
-  _ = GenericEnum.one((a, b)) // Does not diagnose in Swift 3 mode
-  _ = GenericEnum.one(c) // Does not diagnose in Swift 3 mode
+  _ = GenericEnum.one(a, b) // expected-error {{extra argument in call}}
+  _ = GenericEnum.one((a, b))
+  _ = GenericEnum.one(c)
 
   _ = GenericEnum.two(a, b)
   _ = GenericEnum.two((a, b)) // expected-error {{missing argument for parameter #2 in call}}
@@ -1233,9 +1215,9 @@
   var b = 4
   var c = (a, b)
 
-  // _ = GenericEnum<(Int, Int)>.one(a, b) // Crashes in actual Swift 3
-  _ = GenericEnum<(Int, Int)>.one((a, b)) // Does not diagnose in Swift 3 mode
-  _ = GenericEnum<(Int, Int)>.one(c) // Does not diagnose in Swift 3 mode
+  _ = GenericEnum<(Int, Int)>.one(a, b) // expected-error {{enum element 'one' expects a single parameter of type '(Int, Int)'}} {{35-35=(}} {{39-39=)}}
+  _ = GenericEnum<(Int, Int)>.one((a, b))
+  _ = GenericEnum<(Int, Int)>.one(c)
 
   _ = GenericEnum<Int>.two(a, b)
   _ = GenericEnum<Int>.two((a, b)) // expected-error {{missing argument for parameter #2 in call}}
@@ -1253,7 +1235,7 @@
 extension Protocol {
   func requirement(_ x: Element) {}
   func requirementLabeled(x: Element) {}
-  func requirementTwo(_ x: Element, _ y: Element) {} // expected-note 2 {{'requirementTwo' declared here}}
+  func requirementTwo(_ x: Element, _ y: Element) {} // expected-note 3 {{'requirementTwo' declared here}}
   func requirementTuple(_ x: (Element, Element)) {}
 }
 
@@ -1266,7 +1248,7 @@
 
   s.requirement(3.0)
   s.requirement((3.0))
-
+ 
   s.requirementLabeled(x: 3.0)
   s.requirementLabeled(x: (3.0))
 
@@ -1298,14 +1280,14 @@
   s.requirement(c)
 
   s.requirementTwo(a, b)
-  s.requirementTwo((a, b)) // Does not diagnose in Swift 3 mode
+  s.requirementTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}}
 
-  s.requirementTuple(a, b) // Does not diagnose in Swift 3 mode
+  s.requirementTuple(a, b) // expected-error {{instance method 'requirementTuple' expects a single parameter of type '(Double, Double)'}} {{22-22=(}} {{26-26=)}}
   s.requirementTuple((a, b))
 
   let sTwo = GenericConforms<(Double, Double)>()
 
-  sTwo.requirement(a, b)
+  sTwo.requirement(a, b) // expected-error {{instance method 'requirement' expects a single parameter of type '(Double, Double)'}} {{20-20=(}} {{24-24=)}}
   sTwo.requirement((a, b))
   sTwo.requirement(d)
 }
@@ -1347,9 +1329,9 @@
   s.takesClosure({ x in })
   s.takesClosure({ (x: Double) in })
 
-  s.takesClosureTwo({ _ = $0 })
-  s.takesClosureTwo({ x in })
-  s.takesClosureTwo({ (x: (Double, Double)) in })
+  s.takesClosureTwo({ _ = $0 }) // expected-error {{contextual closure type '(Double, Double) -> ()' expects 2 arguments, but 1 was used in closure body}}
+  s.takesClosureTwo({ x in }) // expected-error {{contextual closure type '(Double, Double) -> ()' expects 2 arguments, but 1 was used in closure body}}
+  s.takesClosureTwo({ (x: (Double, Double)) in }) // expected-error {{contextual closure type '(Double, Double) -> ()' expects 2 arguments, but 1 was used in closure body}}
   s.takesClosureTwo({ _ = $0; _ = $1 })
   s.takesClosureTwo({ (x, y) in })
   s.takesClosureTwo({ (x: Double, y:Double) in })
@@ -1375,12 +1357,12 @@
   let _: ((Int, Int)) -> () = { _ = ($0.0, $0.1) }
   let _: ((Int, Int)) -> () = { t in _ = (t.0, t.1) }
 
-  let _: ((Int, Int)) -> () = { _ = ($0, $1) }
-  let _: ((Int, Int)) -> () = { t, u in _ = (t, u) }
+  let _: ((Int, Int)) -> () = { _ = ($0, $1) } // expected-error {{closure tuple parameter '(Int, Int)' does not support destructuring}}
+  let _: ((Int, Int)) -> () = { t, u in _ = (t, u) } // expected-error {{closure tuple parameter '(Int, Int)' does not support destructuring}} {{33-37=(arg)}} {{41-41=let (t, u) = arg; }}
 
-  let _: (Int, Int) -> () = { _ = $0 }
-  let _: (Int, Int) -> () = { _ = ($0.0, $0.1) }
-  let _: (Int, Int) -> () = { t in _ = (t.0, t.1) }
+  let _: (Int, Int) -> () = { _ = $0 } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}}
+  let _: (Int, Int) -> () = { _ = ($0.0, $0.1) } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}}
+  let _: (Int, Int) -> () = { t in _ = (t.0, t.1) } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}}
 
   let _: (Int, Int) -> () = { _ = ($0, $1) }
   let _: (Int, Int) -> () = { t, u in _ = (t, u) }
@@ -1398,19 +1380,17 @@
   let fn: (Any) -> () = { _ in }
 
   fn(123)
-  fn(data: 123)
+  fn(data: 123) // expected-error {{extraneous argument label 'data:' in call}}
 
   takesAny(123)
-  takesAny(data: 123)
+  takesAny(data: 123) // expected-error {{extraneous argument label 'data:' in call}}
 
   _ = HasAnyCase.any(123)
-  _ = HasAnyCase.any(data: 123)
+  _ = HasAnyCase.any(data: 123) // expected-error {{extraneous argument label 'data:' in call}}
 }
 
 // rdar://problem/29739905 - protocol extension methods on Array had
 // ParenType sugar stripped off the element type
-typealias BoolPair = (Bool, Bool)
-
 func processArrayOfFunctions(f1: [((Bool, Bool)) -> ()],
                              f2: [(Bool, Bool) -> ()],
                              c: Bool) {
@@ -1419,24 +1399,27 @@
   f1.forEach { block in
     block(p)
     block((c, c))
-    block(c, c)
+    block(c, c) // expected-error {{parameter 'block' expects a single parameter of type '(Bool, Bool)'}} {{11-11=(}} {{15-15=)}}
   }
 
   f2.forEach { block in
-    block(p) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
-    block((c, c))
+  // expected-note@-1 2{{'block' declared here}}
+    block(p) // expected-error {{missing argument for parameter #2 in call}}
+    block((c, c)) // expected-error {{missing argument for parameter #2 in call}}
     block(c, c)
   }
 
   f2.forEach { (block: ((Bool, Bool)) -> ()) in
+  // expected-error@-1 {{cannot convert value of type '(((Bool, Bool)) -> ()) -> ()' to expected argument type '((Bool, Bool) -> ()) -> Void}}
     block(p)
     block((c, c))
     block(c, c)
   }
 
   f2.forEach { (block: (Bool, Bool) -> ()) in
-    block(p) // expected-error {{passing 2 arguments to a callee as a single tuple value has been removed in Swift 3}}
-    block((c, c))
+  // expected-note@-1 2{{'block' declared here}}
+    block(p) // expected-error {{missing argument for parameter #2 in call}}
+    block((c, c)) // expected-error {{missing argument for parameter #2 in call}}
     block(c, c)
   }
 }
@@ -1449,7 +1432,7 @@
 }
 
 
-// SR-4378 -- FIXME -- this should type check, it used to work in Swift 3.0
+// SR-4378
 
 final public class MutableProperty<Value> {
     public init(_ initialValue: Value) {}
@@ -1460,38 +1443,190 @@
 }
 
 let pages1: MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)> = MutableProperty((
-    // expected-error@-1 {{expression type 'MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)>' is ambiguous without more context}}
     data: .notLoaded,
     totalCount: 0
 ))
 
 
 let pages2: MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)> = MutableProperty((
-    // expected-error@-1 {{cannot convert value of type 'MutableProperty<(data: DataSourcePage<_>, totalCount: Int)>' to specified type 'MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)>'}}
     data: DataSourcePage.notLoaded,
     totalCount: 0
 ))
 
 
 let pages3: MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)> = MutableProperty((
-    // expected-error@-1 {{expression type 'MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)>' is ambiguous without more context}}
     data: DataSourcePage<Int>.notLoaded,
     totalCount: 0
 ))
 
-// rdar://problem/32301091 - Make sure that in Swift 3 mode following expressions still compile just fine
+// SR-4745
+let sr4745 = [1, 2]
+let _ = sr4745.enumerated().map { (count, element) in "\(count): \(element)" }
+
+// SR-4738
+
+let sr4738 = (1, (2, 3))
+[sr4738].map { (x, (y, z)) -> Int in x + y + z } // expected-error {{use of undeclared type 'y'}}
+// expected-error@-1 {{closure tuple parameter does not support destructuring}} {{20-26=arg1}} {{38-38=let (y, z) = arg1; }}
+
+// rdar://problem/31892961
+let r31892961_1 = [1: 1, 2: 2]
+r31892961_1.forEach { (k, v) in print(k + v) }
+
+let r31892961_2 = [1, 2, 3]
+let _: [Int] = r31892961_2.enumerated().map { ((index, val)) in
+  // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{48-60=arg0}} {{3-3=\n  let (index, val) = arg0\n  }}
+  // expected-error@-2 {{use of undeclared type 'index'}}
+  val + 1
+}
+
+let r31892961_3 = (x: 1, y: 42)
+_ = [r31892961_3].map { (x: Int, y: Int) in x + y }
+
+_ = [r31892961_3].map { (x, y: Int) in x + y }
+
+let r31892961_4 = (1, 2)
+_ = [r31892961_4].map { x, y in x + y }
+
+let r31892961_5 = (x: 1, (y: 2, (w: 3, z: 4)))
+[r31892961_5].map { (x: Int, (y: Int, (w: Int, z: Int))) in x + y }
+// expected-error@-1 {{closure tuple parameter does not support destructuring}} {{30-56=arg1}} {{61-61=let (y, (w, z)) = arg1; }}
+
+let r31892961_6 = (x: 1, (y: 2, z: 4))
+[r31892961_6].map { (x: Int, (y: Int, z: Int)) in x + y }
+// expected-error@-1 {{closure tuple parameter does not support destructuring}} {{30-46=arg1}} {{51-51=let (y, z) = arg1; }}
+
+// rdar://problem/32214649 -- these regressed in Swift 4 mode
+// with SE-0110 because of a problem in associated type inference
+
+func r32214649_1<X,Y>(_ a: [X], _ f: (X)->Y) -> [Y] {
+  return a.map(f)
+}
+
+func r32214649_2<X>(_ a: [X], _ f: (X) -> Bool) -> [X] {
+  return a.filter(f)
+}
+
+func r32214649_3<X>(_ a: [X]) -> [X] {
+  return a.filter { _ in return true }
+}
+
+// rdar://problem/32301091 - [SE-0110] causes errors when passing a closure with a single underscore to a block accepting multiple parameters
 
 func rdar32301091_1(_ :((Int, Int) -> ())!) {}
-rdar32301091_1 { _ in } // Ok in Swift 3
+rdar32301091_1 { _ in }
+// expected-error@-1 {{cannot convert value of type '(_) -> ()' to expected argument type '((Int, Int) -> ())?'}}
 
 func rdar32301091_2(_ :(Int, Int) -> ()) {}
-rdar32301091_2 { _ in } // Ok in Swift 3
+rdar32301091_2 { _ in }
+// expected-error@-1 {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} {{19-19=,_ }}
+rdar32301091_2 { x in }
+// expected-error@-1 {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} {{19-19=,<#arg#> }}
 
-// rdar://problem/35198459 - source-compat-suite failure: Moya (toType->hasUnresolvedType() && "Should have handled this above")
+func rdar32875953() {
+  let myDictionary = ["hi":1]
+
+  myDictionary.forEach {
+    print("\($0) -> \($1)")
+  }
+
+  myDictionary.forEach { key, value in
+    print("\(key) -> \(value)")
+  }
+
+  myDictionary.forEach { (key, value) in
+    print("\(key) -> \(value)")
+  }
+
+  let array1 = [1]
+  let array2 = [2]
+
+  _ = zip(array1, array2).map(+)
+}
+
+struct SR_5199 {}
+extension Sequence where Iterator.Element == (key: String, value: String?) {
+  func f() -> [SR_5199] {
+    return self.map { (key, value) in
+        SR_5199() // Ok
+    }
+  }
+}
+
+func rdar33043106(_ records: [(Int)], _ other: [((Int))]) -> [Int] {
+  let x: [Int] = records.map { _ in
+    let i = 1
+    return i
+  }
+  let y: [Int] = other.map { _ in
+    let i = 1
+    return i
+  }
+
+  return x + y
+}
+
+func itsFalse(_: Int) -> Bool? {
+  return false
+}
+
+func rdar33159366(s: AnySequence<Int>) {
+  _ = s.compactMap(itsFalse)
+  let a = Array(s)
+  _ = a.compactMap(itsFalse)
+}
+
+func sr5429<T>(t: T) {
+  _ = AnySequence([t]).first(where: { (t: T) in true })
+}
+
+extension Concrete {
+  typealias T = (Int, Int)
+  typealias F = (T) -> ()
+  func opt1(_ fn: (((Int, Int)) -> ())?) {}
+  func opt2(_ fn: (((Int, Int)) -> ())??) {}
+  func opt3(_ fn: (((Int, Int)) -> ())???) {}
+  func optAliasT(_ fn: ((T) -> ())?) {}
+  func optAliasF(_ fn: F?) {}
+}
+
+extension Generic {
+  typealias F = (T) -> ()
+  func opt1(_ fn: (((Int, Int)) -> ())?) {}
+  func opt2(_ fn: (((Int, Int)) -> ())??) {}
+  func opt3(_ fn: (((Int, Int)) -> ())???) {}
+  func optAliasT(_ fn: ((T) -> ())?) {}
+  func optAliasF(_ fn: F?) {}
+}
+
+func rdar33239714() {
+  Concrete().opt1 { x, y in }
+  Concrete().opt1 { (x, y) in }
+  Concrete().opt2 { x, y in }
+  Concrete().opt2 { (x, y) in }
+  Concrete().opt3 { x, y in }
+  Concrete().opt3 { (x, y) in }
+  Concrete().optAliasT { x, y in }
+  Concrete().optAliasT { (x, y) in }
+  Concrete().optAliasF { x, y in }
+  Concrete().optAliasF { (x, y) in }
+  Generic<(Int, Int)>().opt1 { x, y in }
+  Generic<(Int, Int)>().opt1 { (x, y) in }
+  Generic<(Int, Int)>().opt2 { x, y in }
+  Generic<(Int, Int)>().opt2 { (x, y) in }
+  Generic<(Int, Int)>().opt3 { x, y in }
+  Generic<(Int, Int)>().opt3 { (x, y) in }
+  Generic<(Int, Int)>().optAliasT { x, y in }
+  Generic<(Int, Int)>().optAliasT { (x, y) in }
+  Generic<(Int, Int)>().optAliasF { x, y in }
+  Generic<(Int, Int)>().optAliasF { (x, y) in }
+}
+
+// rdar://problem/35198459 - source-compat-suite failure: Moya (toType->hasUnresolvedType() && "Should have handled this above"
 do {
   func foo(_: (() -> Void)?) {}
   func bar() -> ((()) -> Void)? { return nil }
-  foo(bar()) // OK in Swift 3 mode
+  foo(bar()) // Allow ((()) -> Void)? to be passed in place of (() -> Void)? for -swift-version 4 but not later.
 }
 
 // https://bugs.swift.org/browse/SR-6509
@@ -1506,13 +1641,32 @@
     where Wrapped == (Value) -> Result {
     return value.apply(self)
   }
-} 
+}
 
 // https://bugs.swift.org/browse/SR-6837
 do {
   func takeFn(fn: (_ i: Int, _ j: Int?) -> ()) {}
   func takePair(_ pair: (Int, Int?)) {}
-  takeFn(fn: takePair)
-  takeFn(fn: { (pair: (Int, Int?)) in } )
-  takeFn { (pair: (Int, Int?)) in }
+  takeFn(fn: takePair) // Allow for -swift-version 4, but not later
+  takeFn(fn: { (pair: (Int, Int?)) in } ) // Disallow for -swift-version 4 and later
+  // expected-error@-1 {{contextual closure type '(Int, Int?) -> ()' expects 2 arguments, but 1 was used in closure body}}
+  takeFn { (pair: (Int, Int?)) in } // Disallow for -swift-version 4 and later
+  // expected-error@-1 {{contextual closure type '(Int, Int?) -> ()' expects 2 arguments, but 1 was used in closure body}}
+}
+
+// https://bugs.swift.org/browse/SR-6796
+do {
+  func f(a: (() -> Void)? = nil) {}
+  func log<T>() -> ((T) -> Void)? { return nil }
+
+  f(a: log() as ((()) -> Void)?) // Allow ((()) -> Void)? to be passed in place of (() -> Void)? for -swift-version 4 but not later.
+
+  func logNoOptional<T>() -> (T) -> Void { }
+  f(a: logNoOptional() as ((()) -> Void)) // Also allow the optional-injected form.
+
+  func g() {}
+  g(()) // expected-error {{argument passed to call that takes no arguments}}
+
+  func h(_: ()) {} // expected-note {{'h' declared here}}
+  h() // expected-error {{missing argument for parameter #1 in call}}
 }
diff --git a/test/Constraints/tuple_arguments.swift b/test/Constraints/tuple_arguments.swift
index 61429a7..9db51b7 100644
--- a/test/Constraints/tuple_arguments.swift
+++ b/test/Constraints/tuple_arguments.swift
@@ -1,6 +1,7 @@
-// RUN: %target-typecheck-verify-swift -swift-version 4
+// RUN: %target-typecheck-verify-swift -swift-version 5
 
-// See test/Compatibility/tuple_arguments.swift for the Swift 3 behavior.
+// See test/Compatibility/tuple_arguments_3.swift for the Swift 3 behavior.
+// See test/Compatibility/tuple_arguments_4.swift for the Swift 4 behavior.
 
 func concrete(_ x: Int) {}
 func concreteLabeled(x: Int) {}
@@ -1643,14 +1644,30 @@
   }
 }
 
-
 // https://bugs.swift.org/browse/SR-6837
 do {
   func takeFn(fn: (_ i: Int, _ j: Int?) -> ()) {}
   func takePair(_ pair: (Int, Int?)) {}
-  takeFn(fn: takePair) // Allow for -swift-version 4, but not later
+  takeFn(fn: takePair) // expected-error {{cannot convert value of type '((Int, Int?)) -> ()' to expected argument type '(Int, Int?) -> ()'}}
   takeFn(fn: { (pair: (Int, Int?)) in } ) // Disallow for -swift-version 4 and later
   // expected-error@-1 {{contextual closure type '(Int, Int?) -> ()' expects 2 arguments, but 1 was used in closure body}}
   takeFn { (pair: (Int, Int?)) in } // Disallow for -swift-version 4 and later
   // expected-error@-1 {{contextual closure type '(Int, Int?) -> ()' expects 2 arguments, but 1 was used in closure body}}
 }
+
+// https://bugs.swift.org/browse/SR-6796
+do {
+  func f(a: (() -> Void)? = nil) {}
+  func log<T>() -> ((T) -> Void)? { return nil }
+
+  f(a: log() as ((()) -> Void)?) // expected-error {{cannot convert value of type '((()) -> Void)?' to expected argument type '(() -> Void)?'}}
+
+  func logNoOptional<T>() -> (T) -> Void { }
+  f(a: logNoOptional() as ((()) -> Void)) // expected-error {{cannot convert value of type '(()) -> Void' to expected argument type '(() -> Void)?'}}
+
+  func g() {}
+  g(()) // expected-error {{argument passed to call that takes no arguments}}
+
+  func h(_: ()) {} // expected-note {{'h' declared here}}
+  h() // expected-error {{missing argument for parameter #1 in call}}
+}
diff --git a/test/SILGen/generic_casts.swift b/test/SILGen/generic_casts.swift
index a686c3a..6fe1f40 100644
--- a/test/SILGen/generic_casts.swift
+++ b/test/SILGen/generic_casts.swift
@@ -217,7 +217,74 @@
 }
 
 // CHECK-LABEL: sil hidden @$S13generic_casts27optional_anyobject_to_classyAA1CCSgyXlSgF
-// CHECK:         checked_cast_br {{%.*}} : $AnyObject to $C
 func optional_anyobject_to_class(_ p: AnyObject?) -> C? {
   return p as? C
+  // CHECK: checked_cast_br {{%.*}} : $AnyObject to $C
 }
+
+// The below tests are to ensure we don't dig into an optional operand when
+// casting to a non-class archetype, as it could dynamically be an optional type.
+
+// CHECK-LABEL: sil hidden @$S13generic_casts32optional_any_to_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_to_opaque_archetype<T>(_ x: Any?) -> T {
+  return x as! T
+  // CHECK: bb0([[RET:%.*]] : @trivial $*T, {{%.*}} : @trivial $*Optional<Any>):
+  // CHECK: unconditional_checked_cast_addr Optional<Any> in {{%.*}} : $*Optional<Any> to T in [[RET]] : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts46optional_any_conditionally_to_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_conditionally_to_opaque_archetype<T>(_ x: Any?) -> T? {
+  return x as? T
+  // CHECK: checked_cast_addr_br take_always Optional<Any> in {{%.*}} : $*Optional<Any> to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts32optional_any_is_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_is_opaque_archetype<T>(_ x: Any?, _: T) -> Bool {
+  return x is T
+  // CHECK: checked_cast_addr_br take_always Optional<Any> in {{%.*}} : $*Optional<Any> to T in {{%.*}} : $*T
+}
+
+// But we can dig into at most one layer of the operand if it's
+// an optional archetype...
+
+// CHECK-LABEL: sil hidden @$S13generic_casts016optional_any_to_C17_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_to_optional_opaque_archetype<T>(_ x: Any?) -> T? {
+  return x as! T?
+  // CHECK: unconditional_checked_cast_addr Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts030optional_any_conditionally_to_C17_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_conditionally_to_optional_opaque_archetype<T>(_ x: Any?) -> T?? {
+  return x as? T?
+  // CHECK: checked_cast_addr_br take_always Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts016optional_any_is_C17_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_is_optional_opaque_archetype<T>(_ x: Any?, _: T) -> Bool {
+  return x is T?
+  //   Because the levels of optional are the same, 'is' doesn't transform into an 'as?',
+  //   so we just cast directly without digging into the optional operand.
+  // CHECK: checked_cast_addr_br take_always Optional<Any> in {{%.*}} : $*Optional<Any> to Optional<T> in {{%.*}} : $*Optional<T>
+}
+
+// And we can dig into the operand when casting to a class archetype, as it
+// cannot dynamically be optional...
+
+// CHECK-LABEL: sil hidden @$S13generic_casts31optional_any_to_class_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_to_class_archetype<T : AnyObject>(_ x: Any?) -> T {
+  return x as! T
+  // CHECK: unconditional_checked_cast_addr Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts45optional_any_conditionally_to_class_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_conditionally_to_class_archetype<T : AnyObject>(_ x: Any?) -> T? {
+  return x as? T
+  // CHECK: checked_cast_addr_br take_always Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts31optional_any_is_class_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_is_class_archetype<T : AnyObject>(_ x: Any?, _: T) -> Bool {
+  return x is T
+  // CHECK: checked_cast_addr_br take_always Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
diff --git a/test/Serialization/Inputs/xref-private-type/Lib.swift b/test/Serialization/Inputs/xref-private-type/Lib.swift
new file mode 100644
index 0000000..4292ce3
--- /dev/null
+++ b/test/Serialization/Inputs/xref-private-type/Lib.swift
@@ -0,0 +1,8 @@
+import LibCore
+
+public let lazyFoo = Foo()
+public func testFoo(_: Foo = lazyFoo) {}
+public let lazyBar = Bar()
+public func testBar(_: Bar = lazyBar) {}
+public let lazyBaz = Baz()
+public func testBaz(_: Baz = lazyBaz) {}
diff --git a/test/Serialization/Inputs/xref-private-type/LibCore.swift b/test/Serialization/Inputs/xref-private-type/LibCore.swift
new file mode 100644
index 0000000..032dbdf
--- /dev/null
+++ b/test/Serialization/Inputs/xref-private-type/LibCore.swift
@@ -0,0 +1,24 @@
+private class TopLevelInternalClass {}
+public struct Foo {
+  private var ref: TopLevelInternalClass
+  
+  public init() { self.ref = .init() }
+}
+
+public struct Bar {
+  private class NestedInternalClass {}
+
+  private var ref: NestedInternalClass
+  
+  public init() { self.ref = .init() }
+}
+
+public struct Baz {
+  fileprivate class NestedInternalClass {
+    fileprivate class DoublyNestedInternalClass {}
+  }
+
+  private var ref: NestedInternalClass.DoublyNestedInternalClass
+  
+  public init() { self.ref = .init() }
+}
diff --git a/test/Serialization/xref-private-type.swift b/test/Serialization/xref-private-type.swift
new file mode 100755
index 0000000..2ad6c92
--- /dev/null
+++ b/test/Serialization/xref-private-type.swift
@@ -0,0 +1,51 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -swift-version 4 -O  -force-single-frontend-invocation -emit-module-path %t/LibCore.swiftmodule %S/Inputs/xref-private-type/LibCore.swift
+// RUN: %target-build-swift -swift-version 4 -O -I %t  -force-single-frontend-invocation -emit-module-path %t/Lib.swiftmodule %S/Inputs/xref-private-type/Lib.swift 
+// RUN: %target-build-swift -swift-version 4 -O -I %t -emit-sil %s | %FileCheck %s
+
+import Lib
+
+// CHECK: sil{{.*}} @[[TESTSR6874:[^ ]+10testSR6874[^ ]+]] :
+func testSR6874() {
+  // The important lines in this test are the strong_retains, which refer to
+  // private types defined in LibCore. Normally we shouldn't have references to
+  // non-public declarations in inlinable code, but because SIL passes can break
+  // apart non-resilient structs and enums we can end up in that situation.
+  // Worse, this can happen *across module boundaries.*
+  //
+  // In this test, the addressor for each global defined in Lib ends up
+  // referencing private types defined in LibCore. Using those globals in
+  // default argument position leads to the addressor getting inlined into
+  // calling code in Swift 4 and later. This results in an attempt to not just
+  // reference a private type, but to *resolve a cross-reference to a private
+  // type.*
+  //
+  // This is the situation in SR-6874 (simplified). I'm not sure of a simpler
+  // way to reliably trigger the issue. But if this test breaks, please try to
+  // find one.
+  //
+  // (We may want to revisit this whole thing later, as it violates the model.
+  // But it's also useful for performance in non-resilient code.)
+
+  // CHECK: [[ADDR:%.+]] = global_addr @{{[^ ]+}}3Lib7lazyFoo
+  // CHECK: [[LOADED:%.+]] = load [[ADDR]] : $*Foo
+  // CHECK: [[REF:%.+]] = struct_extract [[LOADED]] : $Foo, #Foo.ref
+  // CHECK: strong_retain [[REF]] : $TopLevelInternalClass
+  // CHECK: apply {{%.+}}([[LOADED]])
+  testFoo()
+
+  // CHECK: [[ADDR:%.+]] = global_addr @{{[^ ]+}}3Lib7lazyBar
+  // CHECK: [[LOADED:%.+]] = load [[ADDR]] : $*Bar
+  // CHECK: [[REF:%.+]] = struct_extract [[LOADED]] : $Bar, #Bar.ref
+  // CHECK: strong_retain [[REF]] : $Bar.NestedInternalClass
+  // CHECK: apply {{%.+}}([[LOADED]])
+  testBar()
+
+  // CHECK: [[ADDR:%.+]] = global_addr @{{[^ ]+}}3Lib7lazyBaz
+  // CHECK: [[LOADED:%.+]] = load [[ADDR]] : $*Baz
+  // CHECK: [[REF:%.+]] = struct_extract [[LOADED]] : $Baz, #Baz.ref
+  // CHECK: strong_retain [[REF]] : $Baz.NestedInternalClass.DoublyNestedInternalClass
+  // CHECK: apply {{%.+}}([[LOADED]])
+  testBaz()
+} // CHECK: end sil function '[[TESTSR6874]]'
+
diff --git a/test/SwiftSyntax/SyntaxChildren.swift b/test/SwiftSyntax/SyntaxChildren.swift
index be5473a..8e4cee9 100644
--- a/test/SwiftSyntax/SyntaxChildren.swift
+++ b/test/SwiftSyntax/SyntaxChildren.swift
@@ -28,25 +28,21 @@
 SyntaxChildrenAPI.test("IterateWithAllPresent") {
   let returnStmt = SyntaxFactory.makeReturnStmt(
     returnKeyword: SyntaxFactory.makeReturnKeyword(),
-    expression: SyntaxFactory.makeBlankUnknownExpr(),
-    semicolon: SyntaxFactory.makeSemicolonToken())
+    expression: SyntaxFactory.makeBlankUnknownExpr())
 
   var iterator = returnStmt.children.makeIterator()
   expectNext(&iterator) { ($0 as? TokenSyntax)?.tokenKind == .returnKeyword }
   expectNext(&iterator) { $0 is ExprSyntax }
-  expectNext(&iterator) { ($0 as? TokenSyntax)?.tokenKind == .semicolon }
   expectNextIsNil(&iterator)
 }
 
 SyntaxChildrenAPI.test("IterateWithSomeMissing") {
   let returnStmt = SyntaxFactory.makeReturnStmt(
     returnKeyword: SyntaxFactory.makeReturnKeyword(),
-    expression: nil,
-    semicolon: SyntaxFactory.makeSemicolonToken())
+    expression: nil)
 
   var iterator = returnStmt.children.makeIterator()
   expectNext(&iterator) { ($0 as? TokenSyntax)?.tokenKind == .returnKeyword }
-  expectNext(&iterator) { ($0 as? TokenSyntax)?.tokenKind == .semicolon }
   expectNextIsNil(&iterator)
 }
 
diff --git a/test/Syntax/Inputs/serialize_multiple_decls.json b/test/Syntax/Inputs/serialize_multiple_decls.json
index 909065d..931ea25 100644
--- a/test/Syntax/Inputs/serialize_multiple_decls.json
+++ b/test/Syntax/Inputs/serialize_multiple_decls.json
@@ -2,193 +2,181 @@
   "kind": "SourceFile",
   "layout": [
     {
-      "kind": "DeclList",
+      "kind": "CodeBlockItemList",
       "layout": [
         {
-          "kind": "TopLevelCodeDecl",
+          "kind": "CodeBlockItem",
           "layout": [
             {
-              "kind": "StmtList",
+              "kind": "StructDecl",
               "layout": [
+                null,
+                null,
                 {
-                  "kind": "DeclarationStmt",
-                  "layout": [
+                  "tokenKind": {
+                    "kind": "kw_struct"
+                  },
+                  "leadingTrivia": [
                     {
-                      "kind": "StructDecl",
-                      "layout": [
-                        null,
-                        null,
-                        {
-                          "tokenKind": {
-                            "kind": "kw_struct"
-                          },
-                          "leadingTrivia": [
-                            {
-                              "kind": "LineComment",
-                              "value": "\/\/ RUN: %swift-syntax-test -input-source-filename %s -serialize-raw-tree > %t"
-                            },
-                            {
-                              "kind": "Newline",
-                              "value": 1
-                            },
-                            {
-                              "kind": "LineComment",
-                              "value": "\/\/ RUN: diff %t %S\/Inputs\/serialize_multiple_decls.json"
-                            },
-                            {
-                              "kind": "Newline",
-                              "value": 2
-                            }
-                          ],
-                          "trailingTrivia": [
-                            {
-                              "kind": "Space",
-                              "value": 1
-                            }
-                          ],
-                          "presence": "Present"
-                        },
-                        {
-                          "tokenKind": {
-                            "kind": "identifier",
-                            "text": "A"
-                          },
-                          "leadingTrivia": [],
-                          "trailingTrivia": [
-                            {
-                              "kind": "Space",
-                              "value": 1
-                            }
-                          ],
-                          "presence": "Present"
-                        },
-                        null,
-                        null,
-                        null,
-                        {
-                          "kind": "MemberDeclBlock",
-                          "layout": [
-                            {
-                              "tokenKind": {
-                                "kind": "l_brace"
-                              },
-                              "leadingTrivia": [],
-                              "trailingTrivia": [],
-                              "presence": "Present"
-                            },
-                            {
-                              "kind": "DeclList",
-                              "layout": [],
-                              "presence": "Present"
-                            },
-                            {
-                              "tokenKind": {
-                                "kind": "r_brace"
-                              },
-                              "leadingTrivia": [
-                                {
-                                  "kind": "Newline",
-                                  "value": 1
-                                }
-                              ],
-                              "trailingTrivia": [],
-                              "presence": "Present"
-                            }
-                          ],
-                          "presence": "Present"
-                        }
-                      ],
-                      "presence": "Present"
+                      "kind": "LineComment",
+                      "value": "\/\/ RUN: %swift-syntax-test -input-source-filename %s -serialize-raw-tree > %t"
                     },
-                    null
+                    {
+                      "kind": "Newline",
+                      "value": 1
+                    },
+                    {
+                      "kind": "LineComment",
+                      "value": "\/\/ RUN: diff %t %S\/Inputs\/serialize_multiple_decls.json"
+                    },
+                    {
+                      "kind": "Newline",
+                      "value": 2
+                    }
+                  ],
+                  "trailingTrivia": [
+                    {
+                      "kind": "Space",
+                      "value": 1
+                    }
                   ],
                   "presence": "Present"
                 },
                 {
-                  "kind": "DeclarationStmt",
+                  "tokenKind": {
+                    "kind": "identifier",
+                    "text": "A"
+                  },
+                  "leadingTrivia": [],
+                  "trailingTrivia": [
+                    {
+                      "kind": "Space",
+                      "value": 1
+                    }
+                  ],
+                  "presence": "Present"
+                },
+                null,
+                null,
+                null,
+                {
+                  "kind": "MemberDeclBlock",
                   "layout": [
                     {
-                      "kind": "StructDecl",
-                      "layout": [
-                        null,
-                        null,
-                        {
-                          "tokenKind": {
-                            "kind": "kw_struct"
-                          },
-                          "leadingTrivia": [
-                            {
-                              "kind": "Newline",
-                              "value": 2
-                            }
-                          ],
-                          "trailingTrivia": [
-                            {
-                              "kind": "Space",
-                              "value": 1
-                            }
-                          ],
-                          "presence": "Present"
-                        },
-                        {
-                          "tokenKind": {
-                            "kind": "identifier",
-                            "text": "B"
-                          },
-                          "leadingTrivia": [],
-                          "trailingTrivia": [
-                            {
-                              "kind": "Space",
-                              "value": 1
-                            }
-                          ],
-                          "presence": "Present"
-                        },
-                        null,
-                        null,
-                        null,
-                        {
-                          "kind": "MemberDeclBlock",
-                          "layout": [
-                            {
-                              "tokenKind": {
-                                "kind": "l_brace"
-                              },
-                              "leadingTrivia": [],
-                              "trailingTrivia": [],
-                              "presence": "Present"
-                            },
-                            {
-                              "kind": "DeclList",
-                              "layout": [],
-                              "presence": "Present"
-                            },
-                            {
-                              "tokenKind": {
-                                "kind": "r_brace"
-                              },
-                              "leadingTrivia": [
-                                {
-                                  "kind": "Newline",
-                                  "value": 1
-                                }
-                              ],
-                              "trailingTrivia": [],
-                              "presence": "Present"
-                            }
-                          ],
-                          "presence": "Present"
-                        }
-                      ],
+                      "tokenKind": {
+                        "kind": "l_brace"
+                      },
+                      "leadingTrivia": [],
+                      "trailingTrivia": [],
                       "presence": "Present"
                     },
-                    null
+                    {
+                      "kind": "DeclList",
+                      "layout": [],
+                      "presence": "Present"
+                    },
+                    {
+                      "tokenKind": {
+                        "kind": "r_brace"
+                      },
+                      "leadingTrivia": [
+                        {
+                          "kind": "Newline",
+                          "value": 1
+                        }
+                      ],
+                      "trailingTrivia": [],
+                      "presence": "Present"
+                    }
                   ],
                   "presence": "Present"
                 }
               ],
               "presence": "Present"
-            }
+            },
+            null
+          ],
+          "presence": "Present"
+        },
+        {
+          "kind": "CodeBlockItem",
+          "layout": [
+            {
+              "kind": "StructDecl",
+              "layout": [
+                null,
+                null,
+                {
+                  "tokenKind": {
+                    "kind": "kw_struct"
+                  },
+                  "leadingTrivia": [
+                    {
+                      "kind": "Newline",
+                      "value": 2
+                    }
+                  ],
+                  "trailingTrivia": [
+                    {
+                      "kind": "Space",
+                      "value": 1
+                    }
+                  ],
+                  "presence": "Present"
+                },
+                {
+                  "tokenKind": {
+                    "kind": "identifier",
+                    "text": "B"
+                  },
+                  "leadingTrivia": [],
+                  "trailingTrivia": [
+                    {
+                      "kind": "Space",
+                      "value": 1
+                    }
+                  ],
+                  "presence": "Present"
+                },
+                null,
+                null,
+                null,
+                {
+                  "kind": "MemberDeclBlock",
+                  "layout": [
+                    {
+                      "tokenKind": {
+                        "kind": "l_brace"
+                      },
+                      "leadingTrivia": [],
+                      "trailingTrivia": [],
+                      "presence": "Present"
+                    },
+                    {
+                      "kind": "DeclList",
+                      "layout": [],
+                      "presence": "Present"
+                    },
+                    {
+                      "tokenKind": {
+                        "kind": "r_brace"
+                      },
+                      "leadingTrivia": [
+                        {
+                          "kind": "Newline",
+                          "value": 1
+                        }
+                      ],
+                      "trailingTrivia": [],
+                      "presence": "Present"
+                    }
+                  ],
+                  "presence": "Present"
+                }
+              ],
+              "presence": "Present"
+            },
+            null
           ],
           "presence": "Present"
         }
diff --git a/test/Syntax/Inputs/serialize_struct_decl.json b/test/Syntax/Inputs/serialize_struct_decl.json
index 033ffeb..14d1da1 100644
--- a/test/Syntax/Inputs/serialize_struct_decl.json
+++ b/test/Syntax/Inputs/serialize_struct_decl.json
@@ -2,354 +2,85 @@
   "kind": "SourceFile",
   "layout": [
     {
-      "kind": "DeclList",
+      "kind": "CodeBlockItemList",
       "layout": [
         {
-          "kind": "TopLevelCodeDecl",
+          "kind": "CodeBlockItem",
           "layout": [
             {
-              "kind": "StmtList",
+              "kind": "StructDecl",
               "layout": [
+                null,
+                null,
                 {
-                  "kind": "DeclarationStmt",
+                  "tokenKind": {
+                    "kind": "kw_struct"
+                  },
+                  "leadingTrivia": [
+                    {
+                      "kind": "LineComment",
+                      "value": "\/\/ RUN: %swift-syntax-test -input-source-filename %s -serialize-raw-tree > %t"
+                    },
+                    {
+                      "kind": "Newline",
+                      "value": 1
+                    },
+                    {
+                      "kind": "LineComment",
+                      "value": "\/\/ RUN: diff %t %S\/Inputs\/serialize_struct_decl.json"
+                    },
+                    {
+                      "kind": "Newline",
+                      "value": 2
+                    }
+                  ],
+                  "trailingTrivia": [
+                    {
+                      "kind": "Space",
+                      "value": 1
+                    }
+                  ],
+                  "presence": "Present"
+                },
+                {
+                  "tokenKind": {
+                    "kind": "identifier",
+                    "text": "Foo"
+                  },
+                  "leadingTrivia": [],
+                  "trailingTrivia": [
+                    {
+                      "kind": "Space",
+                      "value": 1
+                    }
+                  ],
+                  "presence": "Present"
+                },
+                null,
+                null,
+                null,
+                {
+                  "kind": "MemberDeclBlock",
                   "layout": [
                     {
-                      "kind": "StructDecl",
+                      "tokenKind": {
+                        "kind": "l_brace"
+                      },
+                      "leadingTrivia": [],
+                      "trailingTrivia": [],
+                      "presence": "Present"
+                    },
+                    {
+                      "kind": "DeclList",
                       "layout": [
-                        null,
-                        null,
                         {
-                          "tokenKind": {
-                            "kind": "kw_struct"
-                          },
-                          "leadingTrivia": [
-                            {
-                              "kind": "LineComment",
-                              "value": "\/\/ RUN: %swift-syntax-test -input-source-filename %s -serialize-raw-tree > %t"
-                            },
-                            {
-                              "kind": "Newline",
-                              "value": 1
-                            },
-                            {
-                              "kind": "LineComment",
-                              "value": "\/\/ RUN: diff %t %S\/Inputs\/serialize_struct_decl.json"
-                            },
-                            {
-                              "kind": "Newline",
-                              "value": 2
-                            }
-                          ],
-                          "trailingTrivia": [
-                            {
-                              "kind": "Space",
-                              "value": 1
-                            }
-                          ],
-                          "presence": "Present"
-                        },
-                        {
-                          "tokenKind": {
-                            "kind": "identifier",
-                            "text": "Foo"
-                          },
-                          "leadingTrivia": [],
-                          "trailingTrivia": [
-                            {
-                              "kind": "Space",
-                              "value": 1
-                            }
-                          ],
-                          "presence": "Present"
-                        },
-                        null,
-                        null,
-                        null,
-                        {
-                          "kind": "MemberDeclBlock",
+                          "kind": "VariableDecl",
                           "layout": [
+                            null,
+                            null,
                             {
                               "tokenKind": {
-                                "kind": "l_brace"
-                              },
-                              "leadingTrivia": [],
-                              "trailingTrivia": [],
-                              "presence": "Present"
-                            },
-                            {
-                              "kind": "DeclList",
-                              "layout": [
-                                {
-                                  "kind": "VariableDecl",
-                                  "layout": [
-                                    null,
-                                    null,
-                                    {
-                                      "tokenKind": {
-                                        "kind": "kw_let"
-                                      },
-                                      "leadingTrivia": [
-                                        {
-                                          "kind": "Newline",
-                                          "value": 1
-                                        },
-                                        {
-                                          "kind": "Space",
-                                          "value": 2
-                                        }
-                                      ],
-                                      "trailingTrivia": [
-                                        {
-                                          "kind": "Space",
-                                          "value": 3
-                                        }
-                                      ],
-                                      "presence": "Present"
-                                    },
-                                    {
-                                      "kind": "PatternBindingList",
-                                      "layout": [
-                                        {
-                                          "kind": "PatternBinding",
-                                          "layout": [
-                                            {
-                                              "kind": "IdentifierPattern",
-                                              "layout": [
-                                                {
-                                                  "tokenKind": {
-                                                    "kind": "identifier",
-                                                    "text": "bar"
-                                                  },
-                                                  "leadingTrivia": [],
-                                                  "trailingTrivia": [
-                                                    {
-                                                      "kind": "Space",
-                                                      "value": 1
-                                                    }
-                                                  ],
-                                                  "presence": "Present"
-                                                }
-                                              ],
-                                              "presence": "Present"
-                                            },
-                                            {
-                                              "kind": "TypeAnnotation",
-                                              "layout": [
-                                                {
-                                                  "tokenKind": {
-                                                    "kind": "colon"
-                                                  },
-                                                  "leadingTrivia": [],
-                                                  "trailingTrivia": [
-                                                    {
-                                                      "kind": "Space",
-                                                      "value": 1
-                                                    }
-                                                  ],
-                                                  "presence": "Present"
-                                                },
-                                                {
-                                                  "kind": "SimpleTypeIdentifier",
-                                                  "layout": [
-                                                    {
-                                                      "tokenKind": {
-                                                        "kind": "identifier",
-                                                        "text": "Int"
-                                                      },
-                                                      "leadingTrivia": [],
-                                                      "trailingTrivia": [],
-                                                      "presence": "Present"
-                                                    },
-                                                    null
-                                                  ],
-                                                  "presence": "Present"
-                                                }
-                                              ],
-                                              "presence": "Present"
-                                            },
-                                            null,
-                                            null,
-                                            null
-                                          ],
-                                          "presence": "Present"
-                                        }
-                                      ],
-                                      "presence": "Present"
-                                    }
-                                  ],
-                                  "presence": "Present"
-                                },
-                                {
-                                  "kind": "VariableDecl",
-                                  "layout": [
-                                    null,
-                                    null,
-                                    {
-                                      "tokenKind": {
-                                        "kind": "kw_let"
-                                      },
-                                      "leadingTrivia": [
-                                        {
-                                          "kind": "Newline",
-                                          "value": 2
-                                        },
-                                        {
-                                          "kind": "Space",
-                                          "value": 2
-                                        }
-                                      ],
-                                      "trailingTrivia": [
-                                        {
-                                          "kind": "Space",
-                                          "value": 1
-                                        }
-                                      ],
-                                      "presence": "Present"
-                                    },
-                                    {
-                                      "kind": "PatternBindingList",
-                                      "layout": [
-                                        {
-                                          "kind": "PatternBinding",
-                                          "layout": [
-                                            {
-                                              "kind": "IdentifierPattern",
-                                              "layout": [
-                                                {
-                                                  "tokenKind": {
-                                                    "kind": "identifier",
-                                                    "text": "baz"
-                                                  },
-                                                  "leadingTrivia": [],
-                                                  "trailingTrivia": [
-                                                    {
-                                                      "kind": "Space",
-                                                      "value": 1
-                                                    }
-                                                  ],
-                                                  "presence": "Present"
-                                                }
-                                              ],
-                                              "presence": "Present"
-                                            },
-                                            {
-                                              "kind": "TypeAnnotation",
-                                              "layout": [
-                                                {
-                                                  "tokenKind": {
-                                                    "kind": "colon"
-                                                  },
-                                                  "leadingTrivia": [],
-                                                  "trailingTrivia": [
-                                                    {
-                                                      "kind": "Space",
-                                                      "value": 1
-                                                    }
-                                                  ],
-                                                  "presence": "Present"
-                                                },
-                                                {
-                                                  "kind": "SimpleTypeIdentifier",
-                                                  "layout": [
-                                                    {
-                                                      "tokenKind": {
-                                                        "kind": "identifier",
-                                                        "text": "Array"
-                                                      },
-                                                      "leadingTrivia": [],
-                                                      "trailingTrivia": [
-                                                        {
-                                                          "kind": "Space",
-                                                          "value": 1
-                                                        }
-                                                      ],
-                                                      "presence": "Present"
-                                                    },
-                                                    {
-                                                      "kind": "GenericArgumentClause",
-                                                      "layout": [
-                                                        {
-                                                          "tokenKind": {
-                                                            "kind": "l_angle"
-                                                          },
-                                                          "leadingTrivia": [],
-                                                          "trailingTrivia": [
-                                                            {
-                                                              "kind": "Space",
-                                                              "value": 1
-                                                            }
-                                                          ],
-                                                          "presence": "Present"
-                                                        },
-                                                        {
-                                                          "kind": "GenericArgumentList",
-                                                          "layout": [
-                                                            {
-                                                              "kind": "GenericArgument",
-                                                              "layout": [
-                                                                {
-                                                                  "kind": "SimpleTypeIdentifier",
-                                                                  "layout": [
-                                                                    {
-                                                                      "tokenKind": {
-                                                                        "kind": "identifier",
-                                                                        "text": "Int"
-                                                                      },
-                                                                      "leadingTrivia": [],
-                                                                      "trailingTrivia": [
-                                                                        {
-                                                                          "kind": "Space",
-                                                                          "value": 1
-                                                                        }
-                                                                      ],
-                                                                      "presence": "Present"
-                                                                    },
-                                                                    null
-                                                                  ],
-                                                                  "presence": "Present"
-                                                                },
-                                                                null
-                                                              ],
-                                                              "presence": "Present"
-                                                            }
-                                                          ],
-                                                          "presence": "Present"
-                                                        },
-                                                        {
-                                                          "tokenKind": {
-                                                            "kind": "r_angle"
-                                                          },
-                                                          "leadingTrivia": [],
-                                                          "trailingTrivia": [],
-                                                          "presence": "Present"
-                                                        }
-                                                      ],
-                                                      "presence": "Present"
-                                                    }
-                                                  ],
-                                                  "presence": "Present"
-                                                }
-                                              ],
-                                              "presence": "Present"
-                                            },
-                                            null,
-                                            null,
-                                            null
-                                          ],
-                                          "presence": "Present"
-                                        }
-                                      ],
-                                      "presence": "Present"
-                                    }
-                                  ],
-                                  "presence": "Present"
-                                }
-                              ],
-                              "presence": "Present"
-                            },
-                            {
-                              "tokenKind": {
-                                "kind": "r_brace"
+                                "kind": "kw_let"
                               },
                               "leadingTrivia": [
                                 {
@@ -358,10 +89,250 @@
                                 },
                                 {
                                   "kind": "Space",
-                                  "value": 6
+                                  "value": 2
                                 }
                               ],
-                              "trailingTrivia": [],
+                              "trailingTrivia": [
+                                {
+                                  "kind": "Space",
+                                  "value": 3
+                                }
+                              ],
+                              "presence": "Present"
+                            },
+                            {
+                              "kind": "PatternBindingList",
+                              "layout": [
+                                {
+                                  "kind": "PatternBinding",
+                                  "layout": [
+                                    {
+                                      "kind": "IdentifierPattern",
+                                      "layout": [
+                                        {
+                                          "tokenKind": {
+                                            "kind": "identifier",
+                                            "text": "bar"
+                                          },
+                                          "leadingTrivia": [],
+                                          "trailingTrivia": [
+                                            {
+                                              "kind": "Space",
+                                              "value": 1
+                                            }
+                                          ],
+                                          "presence": "Present"
+                                        }
+                                      ],
+                                      "presence": "Present"
+                                    },
+                                    {
+                                      "kind": "TypeAnnotation",
+                                      "layout": [
+                                        {
+                                          "tokenKind": {
+                                            "kind": "colon"
+                                          },
+                                          "leadingTrivia": [],
+                                          "trailingTrivia": [
+                                            {
+                                              "kind": "Space",
+                                              "value": 1
+                                            }
+                                          ],
+                                          "presence": "Present"
+                                        },
+                                        {
+                                          "kind": "SimpleTypeIdentifier",
+                                          "layout": [
+                                            {
+                                              "tokenKind": {
+                                                "kind": "identifier",
+                                                "text": "Int"
+                                              },
+                                              "leadingTrivia": [],
+                                              "trailingTrivia": [],
+                                              "presence": "Present"
+                                            },
+                                            null
+                                          ],
+                                          "presence": "Present"
+                                        }
+                                      ],
+                                      "presence": "Present"
+                                    },
+                                    null,
+                                    null,
+                                    null
+                                  ],
+                                  "presence": "Present"
+                                }
+                              ],
+                              "presence": "Present"
+                            }
+                          ],
+                          "presence": "Present"
+                        },
+                        {
+                          "kind": "VariableDecl",
+                          "layout": [
+                            null,
+                            null,
+                            {
+                              "tokenKind": {
+                                "kind": "kw_let"
+                              },
+                              "leadingTrivia": [
+                                {
+                                  "kind": "Newline",
+                                  "value": 2
+                                },
+                                {
+                                  "kind": "Space",
+                                  "value": 2
+                                }
+                              ],
+                              "trailingTrivia": [
+                                {
+                                  "kind": "Space",
+                                  "value": 1
+                                }
+                              ],
+                              "presence": "Present"
+                            },
+                            {
+                              "kind": "PatternBindingList",
+                              "layout": [
+                                {
+                                  "kind": "PatternBinding",
+                                  "layout": [
+                                    {
+                                      "kind": "IdentifierPattern",
+                                      "layout": [
+                                        {
+                                          "tokenKind": {
+                                            "kind": "identifier",
+                                            "text": "baz"
+                                          },
+                                          "leadingTrivia": [],
+                                          "trailingTrivia": [
+                                            {
+                                              "kind": "Space",
+                                              "value": 1
+                                            }
+                                          ],
+                                          "presence": "Present"
+                                        }
+                                      ],
+                                      "presence": "Present"
+                                    },
+                                    {
+                                      "kind": "TypeAnnotation",
+                                      "layout": [
+                                        {
+                                          "tokenKind": {
+                                            "kind": "colon"
+                                          },
+                                          "leadingTrivia": [],
+                                          "trailingTrivia": [
+                                            {
+                                              "kind": "Space",
+                                              "value": 1
+                                            }
+                                          ],
+                                          "presence": "Present"
+                                        },
+                                        {
+                                          "kind": "SimpleTypeIdentifier",
+                                          "layout": [
+                                            {
+                                              "tokenKind": {
+                                                "kind": "identifier",
+                                                "text": "Array"
+                                              },
+                                              "leadingTrivia": [],
+                                              "trailingTrivia": [
+                                                {
+                                                  "kind": "Space",
+                                                  "value": 1
+                                                }
+                                              ],
+                                              "presence": "Present"
+                                            },
+                                            {
+                                              "kind": "GenericArgumentClause",
+                                              "layout": [
+                                                {
+                                                  "tokenKind": {
+                                                    "kind": "l_angle"
+                                                  },
+                                                  "leadingTrivia": [],
+                                                  "trailingTrivia": [
+                                                    {
+                                                      "kind": "Space",
+                                                      "value": 1
+                                                    }
+                                                  ],
+                                                  "presence": "Present"
+                                                },
+                                                {
+                                                  "kind": "GenericArgumentList",
+                                                  "layout": [
+                                                    {
+                                                      "kind": "GenericArgument",
+                                                      "layout": [
+                                                        {
+                                                          "kind": "SimpleTypeIdentifier",
+                                                          "layout": [
+                                                            {
+                                                              "tokenKind": {
+                                                                "kind": "identifier",
+                                                                "text": "Int"
+                                                              },
+                                                              "leadingTrivia": [],
+                                                              "trailingTrivia": [
+                                                                {
+                                                                  "kind": "Space",
+                                                                  "value": 1
+                                                                }
+                                                              ],
+                                                              "presence": "Present"
+                                                            },
+                                                            null
+                                                          ],
+                                                          "presence": "Present"
+                                                        },
+                                                        null
+                                                      ],
+                                                      "presence": "Present"
+                                                    }
+                                                  ],
+                                                  "presence": "Present"
+                                                },
+                                                {
+                                                  "tokenKind": {
+                                                    "kind": "r_angle"
+                                                  },
+                                                  "leadingTrivia": [],
+                                                  "trailingTrivia": [],
+                                                  "presence": "Present"
+                                                }
+                                              ],
+                                              "presence": "Present"
+                                            }
+                                          ],
+                                          "presence": "Present"
+                                        }
+                                      ],
+                                      "presence": "Present"
+                                    },
+                                    null,
+                                    null,
+                                    null
+                                  ],
+                                  "presence": "Present"
+                                }
+                              ],
                               "presence": "Present"
                             }
                           ],
@@ -370,13 +341,30 @@
                       ],
                       "presence": "Present"
                     },
-                    null
+                    {
+                      "tokenKind": {
+                        "kind": "r_brace"
+                      },
+                      "leadingTrivia": [
+                        {
+                          "kind": "Newline",
+                          "value": 1
+                        },
+                        {
+                          "kind": "Space",
+                          "value": 6
+                        }
+                      ],
+                      "trailingTrivia": [],
+                      "presence": "Present"
+                    }
                   ],
                   "presence": "Present"
                 }
               ],
               "presence": "Present"
-            }
+            },
+            null
           ],
           "presence": "Present"
         }
diff --git a/unittests/Syntax/DeclSyntaxTests.cpp b/unittests/Syntax/DeclSyntaxTests.cpp
index 6eddc66..ea0fc79 100644
--- a/unittests/Syntax/DeclSyntaxTests.cpp
+++ b/unittests/Syntax/DeclSyntaxTests.cpp
@@ -506,10 +506,10 @@
   auto ReturnKW =
     SyntaxFactory::makeReturnKeyword(Trivia::newlines(1) + Trivia::spaces(2),
                                      {});
-  auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, One, None);
+  auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, One);
+  auto ReturnItem = SyntaxFactory::makeCodeBlockItem(Return, None);
 
-  auto Stmts = SyntaxFactory::makeBlankStmtList()
-    .appending(Return);
+  auto Stmts = SyntaxFactory::makeCodeBlockItemList({ReturnItem});
 
   auto LBrace = SyntaxFactory::makeLeftBraceToken({}, {});
   auto RBrace = SyntaxFactory::makeRightBraceToken(Trivia::newlines(1), {});
diff --git a/unittests/Syntax/StmtSyntaxTests.cpp b/unittests/Syntax/StmtSyntaxTests.cpp
index 0deb1e9..7141df5 100644
--- a/unittests/Syntax/StmtSyntaxTests.cpp
+++ b/unittests/Syntax/StmtSyntaxTests.cpp
@@ -41,7 +41,7 @@
     llvm::SmallString<48> Scratch;
     llvm::raw_svector_ostream OS(Scratch);
 
-    SyntaxFactory::makeFallthroughStmt(FallthroughKW, llvm::None).print(OS);
+    SyntaxFactory::makeFallthroughStmt(FallthroughKW).print(OS);
     ASSERT_EQ(OS.str().str(), "fallthrough");
   }
 
@@ -51,7 +51,7 @@
 
     auto NewFallthroughKW = FallthroughKW.withLeadingTrivia(Trivia::spaces(2));
 
-    SyntaxFactory::makeFallthroughStmt(NewFallthroughKW, llvm::None).print(OS);
+    SyntaxFactory::makeFallthroughStmt(NewFallthroughKW).print(OS);
     ASSERT_EQ(OS.str().str(), "  fallthrough");
   }
 
@@ -62,7 +62,7 @@
     auto NewFallthroughKW = FallthroughKW.withLeadingTrivia(Trivia::spaces(2))
                                          .withTrailingTrivia(Trivia::spaces(2));
 
-    SyntaxFactory::makeFallthroughStmt(NewFallthroughKW, llvm::None).print(OS);
+    SyntaxFactory::makeFallthroughStmt(NewFallthroughKW).print(OS);
     ASSERT_EQ(OS.str().str(), "  fallthrough  ");
   }
 
@@ -80,7 +80,7 @@
 TEST(StmtSyntaxTests, BreakStmtGetAPIs) {
   auto BreakKW = SyntaxFactory::makeBreakKeyword({}, Trivia::spaces(1));
   auto Label = SyntaxFactory::makeIdentifier("sometimesYouNeedTo", {}, {});
-  auto Break = SyntaxFactory::makeBreakStmt(BreakKW, Label, llvm::None);
+  auto Break = SyntaxFactory::makeBreakStmt(BreakKW, Label);
 
   /// These should be directly shared through reference-counting.
   ASSERT_EQ(BreakKW.getRaw(), Break.getBreakKeyword().getRaw());
@@ -128,7 +128,7 @@
     llvm::raw_svector_ostream OS(Scratch);
     auto BreakKW = SyntaxFactory::makeBreakKeyword({}, Trivia::spaces(1));
     auto Label = SyntaxFactory::makeIdentifier("theBuild", {}, {});
-    auto Break = SyntaxFactory::makeBreakStmt(BreakKW, Label, llvm::None);
+    auto Break = SyntaxFactory::makeBreakStmt(BreakKW, Label);
     Break.print(OS);
     ASSERT_EQ(OS.str().str(), "break theBuild"); // don't you dare
   }
@@ -145,8 +145,7 @@
 TEST(StmtSyntaxTests, ContinueStmtGetAPIs) {
   auto ContinueKW = SyntaxFactory::makeContinueKeyword({}, Trivia::spaces(1));
   auto Label = SyntaxFactory::makeIdentifier("always", {}, {});
-  auto Continue = SyntaxFactory::makeContinueStmt(ContinueKW, Label,
-                                                  llvm::None);
+  auto Continue = SyntaxFactory::makeContinueStmt(ContinueKW, Label);
 
   /// These should be directly shared through reference-counting.
   ASSERT_EQ(ContinueKW.getRaw(), Continue.getContinueKeyword().getRaw());
@@ -194,8 +193,7 @@
     llvm::raw_svector_ostream OS(Scratch);
     auto ContinueKW = SyntaxFactory::makeContinueKeyword({}, Trivia::spaces(1));
     auto Label = SyntaxFactory::makeIdentifier("toLead", {}, {});
-    auto Continue = SyntaxFactory::makeContinueStmt(ContinueKW, Label,
-                                                    llvm::None);
+    auto Continue = SyntaxFactory::makeContinueStmt(ContinueKW, Label);
     Continue.print(OS);
     ASSERT_EQ(OS.str().str(), "continue toLead"); // by example
   }
@@ -226,7 +224,7 @@
   {
     llvm::SmallString<48> Scratch;
     llvm::raw_svector_ostream OS(Scratch);
-    SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne, None).print(OS);
+    SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne).print(OS);
     ASSERT_EQ(OS.str().str(), "return -1");
   }
 }
@@ -237,7 +235,7 @@
   auto OneDigits = SyntaxFactory::makeIntegerLiteral("1", {}, {});
   auto MinusOne = SyntaxFactory::makePrefixOperatorExpr(Minus,
     SyntaxFactory::makeIntegerLiteralExpr(OneDigits));
-  auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne, None);
+  auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne);
 
   ASSERT_EQ(ReturnKW.getRaw(), Return.getReturnKeyword().getRaw());
   auto GottenExpression = Return.getExpression().getValue();
diff --git a/unittests/Syntax/ThreadSafeCachingTests.cpp b/unittests/Syntax/ThreadSafeCachingTests.cpp
index 4d7fad6..184ab09 100644
--- a/unittests/Syntax/ThreadSafeCachingTests.cpp
+++ b/unittests/Syntax/ThreadSafeCachingTests.cpp
@@ -88,7 +88,7 @@
   Pool P;
 
   for (unsigned i = 0; i < 10000; ++i) {
-    auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne, None);
+    auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne);
 
     auto Future1 = P.run(getExpressionFrom, Return);
     auto Future2 = P.run(getExpressionFrom, Return);
diff --git a/utils/gyb_syntax_support/CommonNodes.py b/utils/gyb_syntax_support/CommonNodes.py
index 429ecbf..744db91 100644
--- a/utils/gyb_syntax_support/CommonNodes.py
+++ b/utils/gyb_syntax_support/CommonNodes.py
@@ -1,4 +1,5 @@
-from Node import Node
+from Child import Child
+from Node import Node  # noqa: I201
 
 COMMON_NODES = [
     Node('Decl', kind='Syntax'),
@@ -11,4 +12,29 @@
     Node('UnknownStmt', kind='Stmt'),
     Node('UnknownType', kind='Type'),
     Node('UnknownPattern', kind='Pattern'),
+
+    # code-block-item = (decl | stmt | expr) ';'?
+    Node('CodeBlockItem', kind='Syntax',
+         children=[
+             Child('Item', kind='Syntax',
+                   node_choices=[
+                       Child('Decl', kind='Decl'),
+                       Child('Stmt', kind='Stmt'),
+                       Child('Expr', kind='Expr'),
+                   ]),
+             Child('Semicolon', kind='SemicolonToken',
+                   is_optional=True),
+         ]),
+
+    # code-block-item-list -> code-block-item code-block-item-list?
+    Node('CodeBlockItemList', kind='SyntaxCollection',
+         element='CodeBlockItem'),
+
+    # code-block -> '{' stmt-list '}'
+    Node('CodeBlock', kind='Syntax',
+         children=[
+             Child('OpenBrace', kind='LeftBraceToken'),
+             Child('Statements', kind='CodeBlockItemList'),
+             Child('CloseBrace', kind='RightBraceToken'),
+         ]),
 ]
diff --git a/utils/gyb_syntax_support/DeclNodes.py b/utils/gyb_syntax_support/DeclNodes.py
index 5878ec2..84710fc 100644
--- a/utils/gyb_syntax_support/DeclNodes.py
+++ b/utils/gyb_syntax_support/DeclNodes.py
@@ -88,7 +88,7 @@
          children=[
              Child('PoundElseif', kind='PoundElseifToken'),
              Child('Condition', kind='Expr'),
-             Child('Body', kind='StmtList'),
+             Child('Body', kind='CodeBlockItemList'),
          ]),
 
     # if-config-decl -> '#if' expr stmt-list else-if-directive-clause-list
@@ -97,7 +97,7 @@
          children=[
              Child('PoundIf', kind='PoundIfToken'),
              Child('Condition', kind='Expr'),
-             Child('Body', kind='StmtList'),
+             Child('Body', kind='CodeBlockItemList'),
              Child('ElseifDirectiveClauses', kind='ElseifDirectiveClauseList',
                    is_optional=True),
              Child('ElseClause', kind='ElseDirectiveClause',
@@ -245,19 +245,13 @@
     Node('DeclList', kind='SyntaxCollection',
          element='Decl'),
 
-    # source-file = decl-list eof
+    # source-file = code-block-item-list eof
     Node('SourceFile', kind='Syntax',
          children=[
-             Child('TopLevelDecls', kind='DeclList'),
+             Child('Items', kind='CodeBlockItemList'),
              Child('EOFToken', kind='EOFToken')
          ]),
 
-    # top-level-code-decl = stmt-list
-    Node('TopLevelCodeDecl', kind='Decl',
-         children=[
-             Child('Body', kind='StmtList')
-         ]),
-
     # initializer -> '=' expr
     Node('InitializerClause', kind='Syntax',
          children=[
@@ -408,7 +402,7 @@
     Node('ElseDirectiveClause', kind='Syntax',
          children=[
              Child('PoundElse', kind='PoundElseToken'),
-             Child('Body', kind='StmtList'),
+             Child('Body', kind='CodeBlockItemList'),
          ]),
 
     # access-level-modifier -> 'private' | 'private' '(' 'set' ')'
@@ -476,7 +470,7 @@
              Child('AccessorListOrStmtList', kind='Syntax',
                    node_choices=[
                       Child('Accessors', kind='AccessorList'),
-                      Child('Statements', kind='StmtList')]),
+                      Child('Statements', kind='CodeBlockItemList')]),
              Child('RightBrace', kind='RightBraceToken'),
          ]),
 
diff --git a/utils/gyb_syntax_support/ExprNodes.py b/utils/gyb_syntax_support/ExprNodes.py
index b950756..9e4ee1b 100644
--- a/utils/gyb_syntax_support/ExprNodes.py
+++ b/utils/gyb_syntax_support/ExprNodes.py
@@ -387,7 +387,7 @@
          children=[
              Child('LeftBrace', kind='LeftBraceToken'),
              Child('Signature', kind='ClosureSignature', is_optional=True),
-             Child('Statements', kind='StmtList'),
+             Child('Statements', kind='CodeBlockItemList'),
              Child('RightBrace', kind='RightBraceToken'),
          ]),
 
diff --git a/utils/gyb_syntax_support/StmtNodes.py b/utils/gyb_syntax_support/StmtNodes.py
index 3cfc50e..50c7bfb 100644
--- a/utils/gyb_syntax_support/StmtNodes.py
+++ b/utils/gyb_syntax_support/StmtNodes.py
@@ -8,8 +8,6 @@
              Child('ContinueKeyword', kind='ContinueToken'),
              Child('Label', kind='IdentifierToken',
                    is_optional=True),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # while-stmt -> label? ':'? 'while' condition-list code-block ';'?
@@ -22,8 +20,6 @@
              Child('WhileKeyword', kind='WhileToken'),
              Child('Conditions', kind='ConditionElementList'),
              Child('Body', kind='CodeBlock'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # defer-stmt -> 'defer' code-block ';'?
@@ -31,16 +27,12 @@
          children=[
              Child('DeferKeyword', kind='DeferToken'),
              Child('Body', kind='CodeBlock'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # expr-stmt -> expression ';'?
     Node('ExpressionStmt', kind='Stmt',
          children=[
              Child('Expression', kind='Expr'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # switch-case-list -> switch-case switch-case-list?
@@ -58,8 +50,6 @@
              Child('Body', kind='CodeBlock'),
              Child('WhileKeyword', kind='WhileToken'),
              Child('Condition', kind='Expr'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # guard-stmt -> 'guard' condition-list 'else' code-block ';'?
@@ -69,8 +59,6 @@
              Child('Conditions', kind='ConditionElementList'),
              Child('ElseKeyword', kind='ElseToken'),
              Child('Body', kind='CodeBlock'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     Node('WhereClause', kind='Syntax',
@@ -98,8 +86,6 @@
              Child('WhereClause', kind='WhereClause',
                    is_optional=True),
              Child('Body', kind='CodeBlock'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # switch-stmt -> identifier? ':'? 'switch' expr '{'
@@ -115,8 +101,6 @@
              Child('OpenBrace', kind='LeftBraceToken'),
              Child('Cases', kind='SwitchCaseList'),
              Child('CloseBrace', kind='RightBraceToken'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # catch-clause-list -> catch-clause catch-clause-list?
@@ -134,8 +118,6 @@
              Child('Body', kind='CodeBlock'),
              Child('CatchClauses', kind='CatchClauseList',
                    is_optional=True),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # return-stmt -> 'return' expr? ';'?
@@ -144,16 +126,12 @@
              Child('ReturnKeyword', kind='ReturnToken'),
              Child('Expression', kind='Expr',
                    is_optional=True),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # fallthrough-stmt -> 'fallthrough' ';'?
     Node('FallthroughStmt', kind='Stmt',
          children=[
              Child('FallthroughKeyword', kind='FallthroughToken'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # break-stmt -> 'break' identifier? ';'?
@@ -162,16 +140,6 @@
              Child('BreakKeyword', kind='BreakToken'),
              Child('Label', kind='IdentifierToken',
                    is_optional=True),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
-         ]),
-
-    # code-block -> '{' stmt-list '}'
-    Node('CodeBlock', kind='Syntax',
-         children=[
-             Child('OpenBrace', kind='LeftBraceToken'),
-             Child('Statements', kind='StmtList'),
-             Child('CloseBrace', kind='RightBraceToken'),
          ]),
 
     # case-item-list -> case-item case-item-list?
@@ -231,8 +199,6 @@
     Node('DeclarationStmt', kind='Stmt',
          children=[
              Child('Declaration', kind='Decl'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # throw-stmt -> 'throw' expr ';'?
@@ -240,8 +206,6 @@
          children=[
              Child('ThrowKeyword', kind='ThrowToken'),
              Child('Expression', kind='Expr'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # if-stmt -> identifier? ':'? 'if' condition-list code-block
@@ -263,8 +227,6 @@
                        Child('CodeBlock', kind='CodeBlock'),
                    ],
                    is_optional=True),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
     # else-if-continuation -> label? ':'? 'while' condition-list code-block ';'
@@ -278,20 +240,14 @@
          children=[
              Child('ElseKeyword', kind='ElseToken'),
              Child('Body', kind='CodeBlock'),
-             Child('Semicolon', kind='SemicolonToken',
-                   is_optional=True),
          ]),
 
-    # stmt-list -> stmt stmt-list?
-    Node('StmtList', kind='SyntaxCollection',
-         element='Stmt'),
-
     # switch-case -> switch-case-label stmt-list
     #              | default-label stmt-list
     Node('SwitchCase', kind='Syntax',
          children=[
              Child('Label', kind='Syntax'),
-             Child('Body', kind='StmtList'),
+             Child('Body', kind='CodeBlockItemList'),
          ]),
 
     # switch-default-label -> 'default' ':'