[5.5] [Async Refactoring] Better handle non-refutable patterns (#37848)

* Explicitly handle error case in fallback logic

I don't believe this case currently can come up,
but leave it explicitly unhandled for now so we
don't perform an erroneous transform if it ever
comes up in the future.

* Add a couple of getSemanticsProviding calls

* Don't handle refutable patterns in async transform

These aren't currently supported.

* Don't handle unclassified switch cases for now

Previously we would silently add these to the
success block. For now, let's leave them
unhandled.

* Allow SemaAnnotator to handle patterns

Add the necessary walking hooks, and fix
ReferenceCollector to use it.

* Adapt ScopedDeclCollector to track number of references

Use a DenseMap to track the number of references to
a given decl in a scope.

* [AST] Add Pattern::hasAnyMutableBindings

* Generalise addTupleOf

Allow it to iterate over an arbitrary container
type.

* Better handle non-refutable patterns in async transform

Keep track of patterns that bind multiple vars and
print them out when converting an async call. If
the parameter being bound isn't referenced elsewhere,
we'll print the pattern inline as e.g:

```
let ((x, y), z) = await foo()
```

Otherwise, if the parameter is referenced elsewhere
in the block we'll print the pattern out of line,
such as:

```
let (res, z) = await foo()
let (x, y) = res
```

In addition, make sure to print var bindings out
of line if there's also a let binding, e.g:

```
let x = await foo()
var y = x
```

This ensures any mutations to y doesn't affect x.
If there's only a single var binding, we'll print
it inline.

rdar://77802560

* Handle parent vars in async transform

If we're in a case stmt body, any DeclRefExprs
to vars bound by a pattern will actually be to an
implicit var decl that's declared for the body. We
therefore need to walk to its "parent" to get to
the var referenced by the pattern, which will have
the correct entries in the naming and placeholder
maps.

* Strip an unused DiagnosticEngine param

* Add a release/5.5 workaround for a double AST walk

Avoid walking twice for capture lists. On main,
this is fixed in the AST walker.

Author: hamishknight

include/swift/AST/DiagnosticsRefactoring.def

@@ -70,5 +70,7 @@ ERROR(callback_multiple_case_items, none, "cannot refactor switch using a case w
 
 ERROR(callback_where_case_item, none, "cannot refactor switch using a case with where clause", ())
 
+ERROR(unknown_callback_case_item, none, "cannot refactor complex case conditions", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/Pattern.h

@@ -202,6 +202,9 @@ class alignas(8) Pattern {
   /// Does this binding declare something that requires storage?
   bool hasStorage() const;
 
+  /// Does this pattern have any mutable 'var' bindings?
+  bool hasAnyMutableBindings() const;
+
   static bool classof(const Pattern *P) { return true; }
 
   //*** Allocation Routines ************************************************/

include/swift/IDE/SourceEntityWalker.h

@@ -73,6 +73,9 @@ class SourceEntityWalker {
   /// Walks the provided Expr.
   /// \returns true if traversal was aborted, false otherwise.
   bool walk(Expr *E);
+  /// Walks the provided Pattern.
+  /// \returns true if traversal was aborted, false otherwise.
+  bool walk(Pattern *P);
   /// Walks the provided ASTNode.
   /// \returns true if traversal was aborted, false otherwise.
   bool walk(ASTNode N);
@@ -101,6 +104,14 @@ class SourceEntityWalker {
   /// returns false, the remaining traversal is terminated and returns failure.
   virtual bool walkToExprPost(Expr *E) { return true; }
 
+  /// This method is called when first visiting a pattern, before walking
+  /// into its children. If it returns false, the subtree is skipped.
+  virtual bool walkToPatternPre(Pattern *P) { return true; }
+
+  /// This method is called after visiting the children of a pattern. If it
+  /// returns false, the remaining traversal is terminated and returns failure.
+  virtual bool walkToPatternPost(Pattern *P) { return true; }
+
   /// This method is called when a ValueDecl is referenced in source. If it
   /// returns false, the remaining traversal is terminated and returns failure.
   ///

lib/AST/Pattern.cpp

@@ -291,6 +291,15 @@ bool Pattern::hasStorage() const {
   return HasStorage;
 }
 
+bool Pattern::hasAnyMutableBindings() const {
+  auto HasMutable = false;
+  forEachVariable([&](VarDecl *VD) {
+    if (!VD->isLet())
+      HasMutable = true;
+  });
+  return HasMutable;
+}
+
 /// Return true if this is a non-resolved ExprPattern which is syntactically
 /// irrefutable.
 static bool isIrrefutableExprPattern(const ExprPattern *EP) {