[analyzer] Move switch expression resolution into ResolverVisitor.

The analyzer uses two different mechanisms to visit expressions during
resolution:

- `Expression.accept` (which defers to `ResolverVisitor.visit...`
  methods using the standard visitor infrastructure), and

- The abstract method `ExpressionImpl.resolveExpression` (which is
  implemented in every expression type).

The `Expression.accept` approach doesn't support contexts, so it is
only used when the context is the unknown type schema (`_`).

(The reason there are two approaches is largely a historical accident,
and I hope one day to unify them into a single approach. But that's
not the subject of this change.)

Prior to this change, the resolution logic for most expression types
was in the `visit...` method, and the corresponding
`resolveExpression` method did nothing but call `visit...`. But there
was one exception: for switch expressions, the resolution logic was in
`resolveExpression`, and the corresponding `visit...` method called
`analyzeExpression` (which then called `resolveExpression`).

This change moves the resolution logic for switch expressions into the
`visit...` method, and changes the corresponding `resolveExpression`
method to call `visit...`. This makes switch expression resolution
consistent with all other expression types, which should make the
resolution logic easier to reason about.

There should be no functional change.

Change-Id: I209cdb5cd721608f60e6668a4be76fd20a7452de
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/398585
Auto-Submit: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -17111,17 +17111,7 @@ final class SwitchExpressionImpl extends ExpressionImpl
 
   @override
   void resolveExpression(ResolverVisitor resolver, DartType contextType) {
-    inferenceLogWriter?.enterExpression(this, contextType);
-    var previousExhaustiveness = resolver.legacySwitchExhaustiveness;
-    var staticType = resolver
-        .analyzeSwitchExpression(
-            this, expression, cases.length, SharedTypeSchemaView(contextType))
-        .type
-        .unwrapTypeView();
-    recordStaticType(staticType, resolver: resolver);
-    resolver.popRewrite();
-    resolver.legacySwitchExhaustiveness = previousExhaustiveness;
-    inferenceLogWriter?.exitExpression(this);
+    resolver.visitSwitchExpression(this, contextType: contextType);
   }
 
   @override

pkg/analyzer/lib/src/generated/resolver.dart

@@ -3770,8 +3770,16 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     covariant SwitchExpressionImpl node, {
     DartType contextType = UnknownInferredType.instance,
   }) {
-    analyzeExpression(node, SharedTypeSchemaView(contextType));
+    inferenceLogWriter?.enterExpression(node, contextType);
+    var previousExhaustiveness = legacySwitchExhaustiveness;
+    var staticType = analyzeSwitchExpression(node, node.expression,
+            node.cases.length, SharedTypeSchemaView(contextType))
+        .type
+        .unwrapTypeView();
+    node.recordStaticType(staticType, resolver: this);
     popRewrite();
+    legacySwitchExhaustiveness = previousExhaustiveness;
+    inferenceLogWriter?.exitExpression(node);
   }
 
   @override