[silgenpattern] Reduce indentation and clean up code by inverting an if condition and using an early exit.

Author: gottesmm

lib/SILGen/SILGenPattern.cpp

@@ -2405,7 +2405,7 @@ emitAddressOnlyInitialization(VarDecl *dest, SILValue value) {
 
 /// Emit all the shared case statements.
 void PatternMatchEmission::emitSharedCaseBlocks() {
-  for (auto &entry: SharedCases) {
+  for (auto &entry : SharedCases) {
     CaseStmt *caseBlock = entry.first;
     SILBasicBlock *caseBB = entry.second.first;
     bool hasFallthroughTo = entry.second.second;
@@ -2439,64 +2439,73 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
       // Then emit the case body into the caseBB.
       SGF.B.setInsertionPoint(caseBB);
     }
-    
+
+    // Make sure that before/after we emit the case body we have emitted all
+    // cleanups we created within.
     assert(SGF.getCleanupsDepth() == PatternMatchStmtDepth);
+    SWIFT_DEFER { assert(SGF.getCleanupsDepth() == PatternMatchStmtDepth); };
+
+    // If we do not have any bound decls, just emit the case body since we do
+    // not need to setup any var locs.
+    if (!caseBlock->hasBoundDecls()) {
+      emitCaseBody(caseBlock);
+      continue;
+    }
 
     // If we have a shared case with bound decls, then the 0th pattern has the
     // order of variables that are the incoming BB arguments. Setup the VarLocs
-    // to point to the incoming args and setup initialization so any args needing
-    // cleanup will get that as well.
-    if (caseBlock->hasBoundDecls()) {
-      Scope scope(SGF.Cleanups, CleanupLocation(caseBlock));
-      auto pattern = caseBlock->getCaseLabelItems()[0].getPattern();
-      unsigned argIndex = 0;
-      pattern->forEachVariable([&](VarDecl *V) {
-        if (!V->hasName())
-          return;
-
-        SILType ty = SGF.getLoweredType(V->getType());
-
-        // Initialize mv at +1. We always pass values in at +1 for today into
-        // shared blocks.
-        ManagedValue mv;
-        if (ty.isAddressOnly(SGF.F.getModule())) {
-          // There's no basic block argument, since we don't allow basic blocks
-          // to have address arguments.
-          //
-          // Instead, we map the variable to a temporary alloc_stack in
-          // emitAddressOnlyAllocations(), and store into it at each
-          // predecessor block.
-          //
-          // There's nothing to do here, since the value should already have
-          // been initialized on entry.
-          auto found = Temporaries.find(V);
-          assert(found != Temporaries.end());
-          mv = SGF.emitManagedRValueWithCleanup(found->second);
-        } else {
-          SILValue arg = caseBB->getArgument(argIndex++);
-          assert(arg.getOwnershipKind() == ValueOwnershipKind::Owned ||
-                 arg.getOwnershipKind() == ValueOwnershipKind::Any);
-          mv = SGF.emitManagedRValueWithCleanup(arg);
-        }
+    // to point to the incoming args and setup initialization so any args
+    // needing cleanup will get that as well.
+    Scope scope(SGF.Cleanups, CleanupLocation(caseBlock));
+    auto pattern = caseBlock->getCaseLabelItems()[0].getPattern();
+    unsigned argIndex = 0;
+    pattern->forEachVariable([&](VarDecl *V) {
+      if (!V->hasName())
+        return;
 
-        if (V->isLet()) {
-          // Just emit a let and leave the cleanup alone.
-          SGF.VarLocs[V].value = mv.getValue();
-        } else {
-          // The pattern variables were all emitted as lets and one got passed in,
-          // now we finally alloc a box for the var and forward in the chosen value.
-          SGF.VarLocs.erase(V);
-          auto newVar = SGF.emitInitializationForVarDecl(V, V->isLet());
-          newVar->copyOrInitValueInto(SGF, V, mv, /*isInit*/ true);
-          newVar->finishInitialization(SGF);
-        }
-      });
-      emitCaseBody(caseBlock);
-    } else {
-      emitCaseBody(caseBlock);
-    }
-    
-    assert(SGF.getCleanupsDepth() == PatternMatchStmtDepth);
+      SILType ty = SGF.getLoweredType(V->getType());
+
+      // Initialize mv at +1. We always pass values in at +1 for today into
+      // shared blocks.
+      ManagedValue mv;
+      if (ty.isAddressOnly(SGF.F.getModule())) {
+        // There's no basic block argument, since we don't allow basic blocks
+        // to have address arguments.
+        //
+        // Instead, we map the variable to a temporary alloc_stack in
+        // emitAddressOnlyAllocations(), and store into it at each
+        // predecessor block.
+        //
+        // There's nothing to do here, since the value should already have
+        // been initialized on entry.
+        auto found = Temporaries.find(V);
+        assert(found != Temporaries.end());
+        mv = SGF.emitManagedRValueWithCleanup(found->second);
+      } else {
+        SILValue arg = caseBB->getArgument(argIndex++);
+        assert(arg.getOwnershipKind() == ValueOwnershipKind::Owned ||
+               arg.getOwnershipKind() == ValueOwnershipKind::Any);
+        mv = SGF.emitManagedRValueWithCleanup(arg);
+      }
+
+      if (V->isLet()) {
+        // Just emit a let and leave the cleanup alone.
+        SGF.VarLocs[V].value = mv.getValue();
+        return;
+      }
+
+      // Otherwise, the pattern variables were all emitted as lets and one got
+      // passed in. Since we have a var, alloc a box for the var and forward in
+      // the chosen value.
+      SGF.VarLocs.erase(V);
+      auto newVar = SGF.emitInitializationForVarDecl(V, V->isLet());
+      newVar->copyOrInitValueInto(SGF, V, mv, /*isInit*/ true);
+      newVar->finishInitialization(SGF);
+    });
+
+    // Now that we have setup all of the VarLocs correctly, emit the shared case
+    // body.
+    emitCaseBody(caseBlock);
   }
 }