NFC: Code clean up, in large part combining methods that only have single callers/callees and simplifying.

Author: gregomni

lib/SILGen/SILGenPattern.cpp

@@ -451,25 +451,17 @@ class PatternMatchEmission {
 
   void bindRefutablePatterns(const ClauseRow &row, ArgArray args,
                              const FailureHandler &failure);
-  void bindRefutablePattern(Pattern *pattern, ConsumableManagedValue v,
-                            const FailureHandler &failure);
-  void bindExprPattern(ExprPattern *pattern, ConsumableManagedValue v,
-                       const FailureHandler &failure);
   void emitGuardBranch(SILLocation loc, Expr *guard,
                        const FailureHandler &failure,
                        Pattern *usingImplicitVariablesFromPattern,
                        CaseStmt *usingImplicitVariablesFromStmt);
 
   void bindIrrefutablePatterns(const ClauseRow &row, ArgArray args,
                                bool forIrrefutableRow, bool hasMultipleItems);
-  void bindIrrefutablePattern(Pattern *pattern, ConsumableManagedValue v,
-                              bool forIrrefutableRow, bool hasMultipleItems);
-  void bindNamedPattern(NamedPattern *pattern, ConsumableManagedValue v,
-                        bool forIrrefutableRow, bool hasMultipleItems);
 
-  void bindVariable(SILLocation loc, VarDecl *var,
-                    ConsumableManagedValue value, CanType formalValueType,
-                    bool isIrrefutable, bool hasMultipleItems);
+  void bindVariable(Pattern *pattern, VarDecl *var,
+                    ConsumableManagedValue value, bool isIrrefutable,
+                    bool hasMultipleItems);
 
   void emitSpecializedDispatch(ClauseMatrix &matrix, ArgArray args,
                                unsigned &lastRow, unsigned column,
@@ -1104,63 +1096,38 @@ void PatternMatchEmission::emitWildcardDispatch(ClauseMatrix &clauses,
   assert(!SGF.B.hasValidInsertionPoint());
 }
 
-/// Bind all the irrefutable patterns in the given row, which is
-/// nothing but wildcard patterns.
+/// Bind all the refutable patterns in the given row.
 void PatternMatchEmission::
 bindRefutablePatterns(const ClauseRow &row, ArgArray args,
                       const FailureHandler &failure) {
   assert(row.columns() == args.size());
   for (unsigned i = 0, e = args.size(); i != e; ++i) {
-    bindRefutablePattern(row[i], args[i], failure);
-  }
-}
-
-/// Bind a refutable wildcard pattern to a given value.
-void PatternMatchEmission::bindRefutablePattern(Pattern *pattern,
-                                                ConsumableManagedValue value,
-                                                const FailureHandler &failure) {
-  // We use null patterns to mean artificial AnyPatterns.
-  if (!pattern) return;
-
-  pattern = pattern->getSemanticsProvidingPattern();
-  switch (pattern->getKind()) {
-  // Non-wildcard patterns.
-  case PatternKind::Tuple:
-  case PatternKind::EnumElement:
-  case PatternKind::OptionalSome:
-  case PatternKind::Bool:
-  case PatternKind::Is:
-    llvm_unreachable("didn't specialize specializable pattern?");
-
-  // Non-semantic patterns.
-  case PatternKind::Paren:
-  case PatternKind::Typed:
-  case PatternKind::Var:
-    llvm_unreachable("should have skipped non-semantic pattern");
+    if (!row[i]) // We use null patterns to mean artificial AnyPatterns
+      continue;
 
-  // Refutable patterns that we'll handle in a later pass.
-  case PatternKind::Any:
-  case PatternKind::Named:
-    return;
+    Pattern *pattern = row[i]->getSemanticsProvidingPattern();
+    switch (pattern->getKind()) {
+    // Irrefutable patterns that we'll handle in a later pass.
+    case PatternKind::Any:
+      break;
+    case PatternKind::Named:
+      break;
 
-  case PatternKind::Expr:
-    bindExprPattern(cast<ExprPattern>(pattern), value, failure);
-    return;
+    case PatternKind::Expr: {
+      ExprPattern *exprPattern = cast<ExprPattern>(pattern);
+      DebugLocOverrideRAII LocOverride{SGF.B,
+                                       getSubjectLocationOverride(pattern)};
+      FullExpr scope(SGF.Cleanups, CleanupLocation(pattern));
+      bindVariable(pattern, exprPattern->getMatchVar(), args[i],
+                   /*isForSuccess*/ false, /* hasMultipleItems */ false);
+      emitGuardBranch(pattern, exprPattern->getMatchExpr(), failure, nullptr,
+                      nullptr);
+      break;
+    }
+    default:
+      llvm_unreachable("bad pattern kind");
+    }
   }
-  llvm_unreachable("bad pattern kind");
-}
-
-/// Check whether an expression pattern is satisfied.
-void PatternMatchEmission::bindExprPattern(ExprPattern *pattern,
-                                           ConsumableManagedValue value,
-                                           const FailureHandler &failure) {
-  DebugLocOverrideRAII LocOverride{SGF.B, getSubjectLocationOverride(pattern)};
-  FullExpr scope(SGF.Cleanups, CleanupLocation(pattern));
-  bindVariable(pattern, pattern->getMatchVar(), value,
-               pattern->getType()->getCanonicalType(),
-               /*isForSuccess*/ false, /* hasMultipleItems */ false);
-  emitGuardBranch(pattern, pattern->getMatchExpr(), failure,
-                  nullptr, nullptr);
 }
 
 /// Bind all the irrefutable patterns in the given row, which is nothing
@@ -1174,59 +1141,26 @@ void PatternMatchEmission::bindIrrefutablePatterns(const ClauseRow &row,
                                                    bool hasMultipleItems) {
   assert(row.columns() == args.size());
   for (unsigned i = 0, e = args.size(); i != e; ++i) {
-    bindIrrefutablePattern(row[i], args[i], forIrrefutableRow, hasMultipleItems);
-  }
-}
+    if (!row[i]) // We use null patterns to mean artificial AnyPatterns
+      continue;
 
-/// Bind an irrefutable wildcard pattern to a given value.
-void PatternMatchEmission::bindIrrefutablePattern(Pattern *pattern,
-                                                  ConsumableManagedValue value,
-                                                  bool forIrrefutableRow,
-                                                  bool hasMultipleItems) {
-  // We use null patterns to mean artificial AnyPatterns.
-  if (!pattern) return;
-
-  pattern = pattern->getSemanticsProvidingPattern();
-  switch (pattern->getKind()) {
-  // Non-wildcard patterns.
-  case PatternKind::Tuple:
-  case PatternKind::EnumElement:
-  case PatternKind::OptionalSome:
-  case PatternKind::Bool:
-  case PatternKind::Is:
-    llvm_unreachable("didn't specialize specializable pattern?");
-
-  // Non-semantic patterns.
-  case PatternKind::Paren:
-  case PatternKind::Typed:
-  case PatternKind::Var:
-    llvm_unreachable("should have skipped non-semantic pattern");
-
-  // We can just drop Any values.
-  case PatternKind::Any:
-    return;
-
-  // Ignore expression patterns, which we should have bound in an
-  // earlier pass.
-  case PatternKind::Expr:
-    return;
-
-  case PatternKind::Named:
-    bindNamedPattern(cast<NamedPattern>(pattern), value,
-                     forIrrefutableRow, hasMultipleItems);
-    return;
+    Pattern *pattern = row[i]->getSemanticsProvidingPattern();
+    switch (pattern->getKind()) {
+    case PatternKind::Any: // We can just drop Any values.
+      break;
+    case PatternKind::Expr: // Ignore expression patterns, which we should have
+                            // bound in an earlier pass.
+      break;
+    case PatternKind::Named: {
+      NamedPattern *named = cast<NamedPattern>(pattern);
+      bindVariable(pattern, named->getDecl(), args[i], forIrrefutableRow,
+                   hasMultipleItems);
+      break;
+    }
+    default:
+      llvm_unreachable("bad pattern kind");
+    }
   }
-  llvm_unreachable("bad pattern kind");
-}
-
-/// Bind a named pattern to a given value.
-void PatternMatchEmission::bindNamedPattern(NamedPattern *pattern,
-                                            ConsumableManagedValue value,
-                                            bool forIrrefutableRow,
-                                            bool hasMultipleItems) {
-  bindVariable(pattern, pattern->getDecl(), value,
-               pattern->getType()->getCanonicalType(), forIrrefutableRow,
-               hasMultipleItems);
 }
 
 /// Should we take control of the mang
@@ -1240,26 +1174,23 @@ static bool shouldTake(ConsumableManagedValue value, bool isIrrefutable) {
 }
 
 /// Bind a variable into the current scope.
-void PatternMatchEmission::bindVariable(SILLocation loc, VarDecl *var,
+void PatternMatchEmission::bindVariable(Pattern *pattern, VarDecl *var,
                                         ConsumableManagedValue value,
-                                        CanType formalValueType,
                                         bool isIrrefutable,
                                         bool hasMultipleItems) {
   // If this binding is one of multiple patterns, each individual binding
   // will just be let, and then the chosen value will get forwarded into
   // a var box in the final shared case block.
-  bool forcedLet = var->isLet();
-  if (hasMultipleItems && !var->isLet())
-    forcedLet = true;
-  
-  // Initialize the variable value.
-  InitializationPtr init = SGF.emitInitializationForVarDecl(var, forcedLet);
+  bool immutable = var->isLet() || hasMultipleItems;
 
-  RValue rv(SGF, loc, formalValueType, value.getFinalManagedValue());
+  // Initialize the variable value.
+  InitializationPtr init = SGF.emitInitializationForVarDecl(var, immutable);
+  CanType formalValueType = pattern->getType()->getCanonicalType();
+  RValue rv(SGF, pattern, formalValueType, value.getFinalManagedValue());
   if (shouldTake(value, isIrrefutable)) {
-    std::move(rv).forwardInto(SGF, loc, init.get());
+    std::move(rv).forwardInto(SGF, pattern, init.get());
   } else {
-    std::move(rv).copyInto(SGF, loc, init.get());
+    std::move(rv).copyInto(SGF, pattern, init.get());
   }
 }