diff --git a/lib/Sema/TypeCheckSwitchStmt.cpp b/lib/Sema/TypeCheckSwitchStmt.cpp
index 4940d1e..fdd5280 100644
--- a/lib/Sema/TypeCheckSwitchStmt.cpp
+++ b/lib/Sema/TypeCheckSwitchStmt.cpp
@@ -134,11 +134,11 @@
       }
       
     public:
-      explicit
-      Space(Type T)
+      explicit Space(Type T)
         : Kind(SpaceKind::Type), TypeAndVal(T, false), Head(Identifier()),
           Spaces({}){}
-      explicit Space(Type T, Identifier H, bool downgrade, SmallVectorImpl<Space> &SP)
+      explicit Space(Type T, Identifier H, bool downgrade,
+                     SmallVectorImpl<Space> &SP)
         : Kind(SpaceKind::Constructor), TypeAndVal(T, downgrade), Head(H),
           Spaces(SP.begin(), SP.end()) {}
       explicit Space(Type T, Identifier H, bool downgrade,
@@ -399,145 +399,145 @@
         };
 
         switch (PairSwitch(getKind(), other.getKind())) {
-          PAIRCASE (SpaceKind::Empty, SpaceKind::Disjunct):
-          PAIRCASE (SpaceKind::Type, SpaceKind::Disjunct):
-          PAIRCASE (SpaceKind::Constructor, SpaceKind::Disjunct):
-          PAIRCASE (SpaceKind::Disjunct, SpaceKind::Disjunct):
-          PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Disjunct): {
-            // S & (S1 || ... || Sn) iff (S & S1) && ... && (S & Sn)
-            SmallVector<Space, 4> intersectedCases;
-            std::transform(other.getSpaces().begin(), other.getSpaces().end(),
-                           std::back_inserter(intersectedCases),
-                           [&](const Space &s) {
-              return this->intersect(s, TC);
-            });
-            // Optimization: Remove all empty spaces.
-            SmallVector<Space, 4> filteredCases;
-            std::copy_if(intersectedCases.begin(), intersectedCases.end(),
-                         std::back_inserter(filteredCases),
+        PAIRCASE (SpaceKind::Empty, SpaceKind::Disjunct):
+        PAIRCASE (SpaceKind::Type, SpaceKind::Disjunct):
+        PAIRCASE (SpaceKind::Constructor, SpaceKind::Disjunct):
+        PAIRCASE (SpaceKind::Disjunct, SpaceKind::Disjunct):
+        PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Disjunct): {
+          // S & (S1 || ... || Sn) iff (S & S1) && ... && (S & Sn)
+          SmallVector<Space, 4> intersectedCases;
+          std::transform(other.getSpaces().begin(), other.getSpaces().end(),
+                         std::back_inserter(intersectedCases),
                          [&](const Space &s) {
-              return !s.isEmpty();
-            });
-            return examineDecomp(filteredCases);
-          }
+            return this->intersect(s, TC);
+          });
+          // Optimization: Remove all empty spaces.
+          SmallVector<Space, 4> filteredCases;
+          std::copy_if(intersectedCases.begin(), intersectedCases.end(),
+                       std::back_inserter(filteredCases),
+                       [&](const Space &s) {
+            return !s.isEmpty();
+          });
+          return examineDecomp(filteredCases);
+        }
 
-          PAIRCASE (SpaceKind::Disjunct, SpaceKind::Empty):
-          PAIRCASE (SpaceKind::Disjunct, SpaceKind::Type):
-          PAIRCASE (SpaceKind::Disjunct, SpaceKind::Constructor):
-          PAIRCASE (SpaceKind::Disjunct, SpaceKind::BooleanConstant): {
-            // (S1 || ... || Sn) & S iff (S & S1) && ... && (S & Sn)
-            SmallVector<Space, 4> intersectedCases;
-            std::transform(this->getSpaces().begin(), this->getSpaces().end(),
-                           std::back_inserter(intersectedCases),
-                           [&](const Space &s) {
-              return s.intersect(other, TC);
-            });
-            // Optimization: Remove all empty spaces.
-            SmallVector<Space, 4> filteredCases;
-            std::copy_if(intersectedCases.begin(), intersectedCases.end(),
-                         std::back_inserter(filteredCases),
+        PAIRCASE (SpaceKind::Disjunct, SpaceKind::Empty):
+        PAIRCASE (SpaceKind::Disjunct, SpaceKind::Type):
+        PAIRCASE (SpaceKind::Disjunct, SpaceKind::Constructor):
+        PAIRCASE (SpaceKind::Disjunct, SpaceKind::BooleanConstant): {
+          // (S1 || ... || Sn) & S iff (S & S1) && ... && (S & Sn)
+          SmallVector<Space, 4> intersectedCases;
+          std::transform(this->getSpaces().begin(), this->getSpaces().end(),
+                         std::back_inserter(intersectedCases),
                          [&](const Space &s) {
-              return !s.isEmpty();
-            });
-            return examineDecomp(filteredCases);
+            return s.intersect(other, TC);
+          });
+          // Optimization: Remove all empty spaces.
+          SmallVector<Space, 4> filteredCases;
+          std::copy_if(intersectedCases.begin(), intersectedCases.end(),
+                       std::back_inserter(filteredCases),
+                       [&](const Space &s) {
+            return !s.isEmpty();
+          });
+          return examineDecomp(filteredCases);
+        }
+        PAIRCASE (SpaceKind::Type, SpaceKind::Type): {
+          // Optimization: The intersection of equal types is that type.
+          if (this->getType()->isEqual(other.getType())) {
+            return other;
+          } else if (canDecompose(this->getType())) {
+            SmallVector<Space, 4> spaces;
+            decompose(TC, this->getType(), spaces);
+            auto decomposition = examineDecomp(spaces);
+            return decomposition.intersect(other, TC);
+          } else if (canDecompose(other.getType())) {
+            SmallVector<Space, 4> spaces;
+            decompose(TC, other.getType(), spaces);
+            auto disjunctSp = examineDecomp(spaces);
+            return this->intersect(disjunctSp, TC);
+          } else {
+            return other;
           }
-          PAIRCASE (SpaceKind::Type, SpaceKind::Type): {
-            // Optimization: The intersection of equal types is that type.
-            if (this->getType()->isEqual(other.getType())) {
-              return other;
-            } else if (canDecompose(this->getType())) {
-              SmallVector<Space, 4> spaces;
-              decompose(TC, this->getType(), spaces);
-              auto decomposition = examineDecomp(spaces);
-              return decomposition.intersect(other, TC);
-            } else if (canDecompose(other.getType())) {
-              SmallVector<Space, 4> spaces;
-              decompose(TC, other.getType(), spaces);
-              auto disjunctSp = examineDecomp(spaces);
-              return this->intersect(disjunctSp, TC);
-            } else {
-              return other;
-            }
+        }
+        PAIRCASE (SpaceKind::Type, SpaceKind::Constructor): {
+          if (canDecompose(this->getType())) {
+            SmallVector<Space, 4> spaces;
+            decompose(TC, this->getType(), spaces);
+            auto decomposition = examineDecomp(spaces);
+            return decomposition.intersect(other, TC);
+          } else {
+            return other;
           }
-          PAIRCASE (SpaceKind::Type, SpaceKind::Constructor): {
-            if (canDecompose(this->getType())) {
-              SmallVector<Space, 4> spaces;
-              decompose(TC, this->getType(), spaces);
-              auto decomposition = examineDecomp(spaces);
-              return decomposition.intersect(other, TC);
-            } else {
-              return other;
-            }
-          }
-          PAIRCASE (SpaceKind::Constructor, SpaceKind::Type):
-            return *this;
+        }
+        PAIRCASE (SpaceKind::Constructor, SpaceKind::Type):
+          return *this;
             
-          PAIRCASE (SpaceKind::Constructor, SpaceKind::Constructor): {
-            // Optimization: If the heads don't match, the intersection of
-            // the constructor spaces is empty.
-            if (this->getHead().compare(other.Head) != 0) {
+        PAIRCASE (SpaceKind::Constructor, SpaceKind::Constructor): {
+          // Optimization: If the heads don't match, the intersection of
+          // the constructor spaces is empty.
+          if (this->getHead().compare(other.Head) != 0) {
+            return Space();
+          }
+
+          // Special Case: A constructor pattern may include the head but not
+          // the payload patterns.  In that case, the intersection is the
+          // whole original space.
+          if (other.getSpaces().empty()) {
+            return *this;
+          }
+
+          SmallVector<Space, 4> paramSpace;
+          auto i = this->getSpaces().begin();
+          auto j = other.getSpaces().begin();
+          for (; i != this->getSpaces().end() && j != other.getSpaces().end();
+               ++i, ++j) {
+            auto intersection = (*i).intersect(*j, TC);
+            if (intersection.simplify(TC).isEmpty()) {
               return Space();
             }
-
-            // Special Case: A constructor pattern may include the head but not
-            // the payload patterns.  In that case, the intersection is the
-            // whole original space.
-            if (other.getSpaces().empty()) {
-              return *this;
-            }
-
-            SmallVector<Space, 4> paramSpace;
-            auto i = this->getSpaces().begin();
-            auto j = other.getSpaces().begin();
-            for (; i != this->getSpaces().end() && j != other.getSpaces().end();
-                 ++i, ++j) {
-              auto intersection = (*i).intersect(*j, TC);
-              if (intersection.simplify(TC).isEmpty()) {
-                return Space();
-              }
-              paramSpace.push_back(intersection);
-            }
-
-            return examineDecomp(paramSpace);
+            paramSpace.push_back(intersection);
           }
 
-          PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::BooleanConstant):
-            return this->getBoolValue() == other.getBoolValue() ? *this : Space();
+          return examineDecomp(paramSpace);
+        }
 
-          PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Type): {
-            if (other.getType()->isBool()) {
-              return this->getKind() == SpaceKind::BooleanConstant ? *this : Space();
-            }
+        PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::BooleanConstant):
+          return this->getBoolValue() == other.getBoolValue() ? *this : Space();
 
-            if (canDecompose(other.getType())) {
-              SmallVector<Space, 4> spaces;
-              decompose(TC, other.getType(), spaces);
-              auto disjunctSp = examineDecomp(spaces);
-              return this->intersect(disjunctSp, TC);
-            }
-            return Space();
-          }
-          PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Empty):
-          PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Constructor):
-            return Space();
-
-          PAIRCASE (SpaceKind::Type, SpaceKind::BooleanConstant): {
-            if (canDecompose(this->getType())) {
-              SmallVector<Space, 4> spaces;
-              decompose(TC, this->getType(), spaces);
-              auto disjunctSp = examineDecomp(spaces);
-              return disjunctSp.intersect(other, TC);
-            } else {
-              return Space();
-            }
+        PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Type): {
+          if (other.getType()->isBool()) {
+            return this->getKind() == SpaceKind::BooleanConstant ? *this : Space();
           }
 
-          PAIRCASE (SpaceKind::Empty, SpaceKind::BooleanConstant):
-          PAIRCASE (SpaceKind::Constructor, SpaceKind::BooleanConstant):
-            return Space();
+          if (canDecompose(other.getType())) {
+            SmallVector<Space, 4> spaces;
+            decompose(TC, other.getType(), spaces);
+            auto disjunctSp = examineDecomp(spaces);
+            return this->intersect(disjunctSp, TC);
+          }
+          return Space();
+        }
+        PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Empty):
+        PAIRCASE (SpaceKind::BooleanConstant, SpaceKind::Constructor):
+          return Space();
 
-          default:
-            llvm_unreachable("Uncovered pair found while computing intersect?");
+        PAIRCASE (SpaceKind::Type, SpaceKind::BooleanConstant): {
+          if (canDecompose(this->getType())) {
+            SmallVector<Space, 4> spaces;
+            decompose(TC, this->getType(), spaces);
+            auto disjunctSp = examineDecomp(spaces);
+            return disjunctSp.intersect(other, TC);
+          } else {
+            return Space();
+          }
+        }
+
+        PAIRCASE (SpaceKind::Empty, SpaceKind::BooleanConstant):
+        PAIRCASE (SpaceKind::Constructor, SpaceKind::BooleanConstant):
+          return Space();
+
+        default:
+          llvm_unreachable("Uncovered pair found while computing intersect?");
         }
       }
 
@@ -923,10 +923,11 @@
     void checkExhaustiveness(bool limitedChecking) {
       if (limitedChecking) {
         // Reject switch statements with empty blocks.
-        if (Switch->getCases().empty())
+        if (Switch->getCases().empty()) {
           SpaceEngine::diagnoseMissingCases(TC, Switch,
                                             /*justNeedsDefault*/true,
                                             SpaceEngine::Space());
+        }
         return;
       }
 
@@ -1013,27 +1014,27 @@
     // @_downgrade_exhaustivity_check.
     static bool shouldDowngradeToWarning(const Space &masterSpace) {
       switch (masterSpace.getKind()) {
-        case SpaceKind::Type:
-        case SpaceKind::BooleanConstant:
-        case SpaceKind::Empty:
-          return false;
-        // Traverse the constructor and its subspaces.
-        case SpaceKind::Constructor:
-          return masterSpace.canDowngrade()
-              || std::accumulate(masterSpace.getSpaces().begin(),
-                                 masterSpace.getSpaces().end(),
-                                false,
-                                [](bool acc, const Space &space) {
-            return acc || shouldDowngradeToWarning(space);
-          });
-        case SpaceKind::Disjunct:
-          // Traverse the disjunct's subspaces.
-          return std::accumulate(masterSpace.getSpaces().begin(),
-                                 masterSpace.getSpaces().end(),
-                                 false,
-                                 [](bool acc, const Space &space) {
-                                   return acc || shouldDowngradeToWarning(space);
-                                 });
+      case SpaceKind::Type:
+      case SpaceKind::BooleanConstant:
+      case SpaceKind::Empty:
+        return false;
+      // Traverse the constructor and its subspaces.
+      case SpaceKind::Constructor:
+        return masterSpace.canDowngrade()
+            || std::accumulate(masterSpace.getSpaces().begin(),
+                               masterSpace.getSpaces().end(),
+                              false,
+                              [](bool acc, const Space &space) {
+          return acc || shouldDowngradeToWarning(space);
+        });
+      case SpaceKind::Disjunct:
+        // Traverse the disjunct's subspaces.
+        return std::accumulate(masterSpace.getSpaces().begin(),
+                               masterSpace.getSpaces().end(),
+                               false,
+                               [](bool acc, const Space &space) {
+                                 return acc || shouldDowngradeToWarning(space);
+                               });
       }
     }
 
@@ -1109,7 +1110,6 @@
         TC.diagnose(startLoc, diag::non_exhaustive_switch);
         TC.diagnose(startLoc, diag::missing_several_cases, false)
           .fixItInsert(endLoc, buffer.str());
-
       } else {
         TC.Context.Diags.diagnose(startLoc, mainDiagType);
 
@@ -1238,8 +1238,7 @@
       case PatternKind::Named:
         return Space(item->getType());
       case PatternKind::Bool: {
-        auto *BP = cast<BoolPattern>(item);
-        return Space(BP->getValue());
+        return Space(cast<BoolPattern>(item)->getValue());
       }
       case PatternKind::Is: {
         auto *IP = cast<IsPattern>(item);
@@ -1272,7 +1271,8 @@
       }
       case PatternKind::OptionalSome: {
         auto *OSP = cast<OptionalSomePattern>(item);
-        auto subSpace = projectPattern(TC, OSP->getSubPattern(), sawDowngradablePattern);
+        auto subSpace = projectPattern(TC, OSP->getSubPattern(),
+                                       sawDowngradablePattern);
         // To match patterns like (_, _, ...)?, we must rewrite the underlying
         // tuple pattern to .some(_, _, ...) first.
         if (subSpace.getKind() == SpaceKind::Constructor
@@ -1283,8 +1283,8 @@
         SmallVector<Space, 1> payload = {
           projectPattern(TC, OSP->getSubPattern(), sawDowngradablePattern)
         };
-        return Space(item->getType(), TC.Context.getIdentifier("some"), /*canDowngrade*/false,
-                     payload);
+        return Space(item->getType(), TC.Context.getIdentifier("some"),
+                     /*canDowngrade*/false, payload);
       }
       case PatternKind::EnumElement: {
         auto *VP = cast<EnumElementPattern>(item);