Remove the fallback exhaustiveness algorithm.

Fixes #51518.

Bug: #51518
Change-Id: Ic925f0ba41555e5077fee1b0433476e8ea28b75e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/290560
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/exhaustiveness/exhaustive.dart

@@ -9,15 +9,6 @@ import 'profile.dart' as profile;
 import 'space.dart';
 import 'witness.dart';
 
-/// Indicates whether the "fallback" exhaustiveness algorithm (based on flow
-/// analysis) should be used instead of full exhaustiveness.  This is a
-/// temporary measure to allow for the possibility of turning on pattern support
-/// before the full exhaustiveness algorithm is complete.
-///
-/// TODO(paulberry): remove this flag (and the implementation of the fallback
-/// exhaustiveness algorithm) when it is no longer needed.
-bool useFallbackExhaustivenessAlgorithm = false;
-
 /// Returns `true` if [caseSpaces] exhaustively covers all possible values of
 /// [valueSpace].
 bool isExhaustive(

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analysis_result.dart

@@ -178,14 +178,10 @@ class SwitchExpressionResult<Type extends Object, Error>
   /// This is `null` if no such guards where present.
   final Map<int, Type>? guardTypes;
 
-  /// Error for when the switch statement was non exhaustive.
-  final Error? nonExhaustiveSwitchError;
-
   SwitchExpressionResult(
       {required super.type,
       required this.nonBooleanGuardErrors,
-      required this.guardTypes,
-      required this.nonExhaustiveSwitchError});
+      required this.guardTypes});
 }
 
 /// Container for the result of running type analysis on an integer literal.
@@ -229,9 +225,6 @@ class SwitchStatementTypeAnalysisResult<Type extends Object, Error> {
   /// This is `null` if no such guards where present.
   final Map<int, Map<int, Type>>? guardTypes;
 
-  /// Error for when the switch statement was non exhaustive.
-  final Error? nonExhaustiveSwitchError;
-
   SwitchStatementTypeAnalysisResult({
     required this.hasDefault,
     required this.isExhaustive,
@@ -241,7 +234,6 @@ class SwitchStatementTypeAnalysisResult<Type extends Object, Error> {
     required this.switchCaseCompletesNormallyErrors,
     required this.nonBooleanGuardErrors,
     required this.guardTypes,
-    required this.nonExhaustiveSwitchError,
   });
 }
 

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -2,7 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import '../exhaustiveness/exhaustive.dart';
 import '../flow_analysis/flow_analysis.dart';
 import 'type_analysis_result.dart';
 import 'type_operations.dart';
@@ -1773,19 +1772,11 @@ mixin TypeAnalyzer<
     }
     lubType ??= dynamicType;
     // Stack: (Expression, numCases * ExpressionCase)
-    Error? nonExhaustiveSwitchError;
-    bool isProvenExhaustive = flow.switchStatement_end(true);
-    if (options.errorOnSwitchExhaustiveness &&
-        !isProvenExhaustive &&
-        !isLegacySwitchExhaustive(node, expressionType)) {
-      nonExhaustiveSwitchError =
-          errors.nonExhaustiveSwitch(node: node, scrutineeType: expressionType);
-    }
+    flow.switchStatement_end(true);
     return new SwitchExpressionResult(
         type: lubType,
         nonBooleanGuardErrors: nonBooleanGuardErrors,
-        guardTypes: guardTypes,
-        nonExhaustiveSwitchError: nonExhaustiveSwitchError);
+        guardTypes: guardTypes);
   }
 
   /// Analyzes a statement of the form `switch (expression) { cases }`.
@@ -1913,15 +1904,7 @@ mixin TypeAnalyzer<
       isExhaustive = isLegacySwitchExhaustive(node, scrutineeType);
       requiresExhaustivenessValidation = false;
     }
-    bool isProvenExhaustive = flow.switchStatement_end(isExhaustive);
-    Error? nonExhaustiveSwitchError;
-    if (options.errorOnSwitchExhaustiveness &&
-        requiresExhaustivenessValidation &&
-        !isProvenExhaustive &&
-        !isLegacySwitchExhaustive(node, scrutineeType)) {
-      nonExhaustiveSwitchError =
-          errors.nonExhaustiveSwitch(node: node, scrutineeType: scrutineeType);
-    }
+    flow.switchStatement_end(isExhaustive);
     return new SwitchStatementTypeAnalysisResult(
       hasDefault: hasDefault,
       isExhaustive: isExhaustive,
@@ -1931,7 +1914,6 @@ mixin TypeAnalyzer<
       switchCaseCompletesNormallyErrors: switchCaseCompletesNormallyErrors,
       nonBooleanGuardErrors: nonBooleanGuardErrors,
       guardTypes: guardTypes,
-      nonExhaustiveSwitchError: nonExhaustiveSwitchError,
     );
   }
 
@@ -2584,15 +2566,6 @@ abstract class TypeAnalyzerErrors<
   /// Called if the static type of a condition is not assignable to `bool`.
   Error nonBooleanCondition({required Expression node});
 
-  /// Called if [TypeAnalyzerOptions.errorOnSwitchExhaustiveness] is `true`, and
-  /// a switch that is required to be exhaustive cannot be proven by flow
-  /// analysis to be exhaustive.
-  ///
-  /// [node] is the offending switch expression or switch statement, and
-  /// [scrutineeType] is the static type of the switch statement's scrutinee
-  /// expression.
-  Error nonExhaustiveSwitch({required Node node, required Type scrutineeType});
-
   /// Called if a pattern is illegally used in a variable declaration statement
   /// that is marked `late`, and that pattern is not allowed in such a
   /// declaration.  The only kind of pattern that may be used in a late variable
@@ -2698,21 +2671,6 @@ class TypeAnalyzerOptions {
 
   final bool patternsEnabled;
 
-  /// If `true`, the type analyzer should generate errors if it encounters a
-  /// switch that is required to be exhaustive, but cannot be proven to be
-  /// exhaustive by flow analysis.
-  ///
-  /// This option is intended as a temporary workaround if we want to ship an
-  /// early beta of the "patterns" feature before exhaustiveness checking is
-  /// sufficiently ready.
-  ///
-  /// TODO(paulberry): remove this option when it is no longer needed.
-  final bool errorOnSwitchExhaustiveness;
-
   TypeAnalyzerOptions(
-      {required this.nullSafetyEnabled,
-      required this.patternsEnabled,
-      bool? errorOnSwitchExhaustiveness})
-      : errorOnSwitchExhaustiveness =
-            errorOnSwitchExhaustiveness ?? useFallbackExhaustivenessAlgorithm;
+      {required this.nullSafetyEnabled, required this.patternsEnabled});
 }

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -380,10 +380,8 @@ Statement switch_(Expression expression, List<_SwitchStatementMember> cases,
             expectRequiresExhaustivenessValidation,
         expectScrutineeType: expectScrutineeType);
 
-Expression switchExpr(Expression expression, List<ExpressionCase> cases,
-        {bool? isLegacyExhaustive}) =>
-    new _SwitchExpression(expression, cases, isLegacyExhaustive,
-        location: computeLocation());
+Expression switchExpr(Expression expression, List<ExpressionCase> cases) =>
+    new _SwitchExpression(expression, cases, location: computeLocation());
 
 _SwitchStatementMember switchStatementMember(
   List<SwitchHead> cases,
@@ -631,8 +629,6 @@ class Harness {
 
   bool? _patternsEnabled;
 
-  bool errorOnSwitchExhaustiveness = false;
-
   Type? _thisType;
 
   late final Map<String, _PropertyElement?> _members = {
@@ -644,8 +640,7 @@ class Harness {
       this,
       TypeAnalyzerOptions(
           nullSafetyEnabled: !_operations.legacy,
-          patternsEnabled: patternsEnabled,
-          errorOnSwitchExhaustiveness: errorOnSwitchExhaustiveness));
+          patternsEnabled: patternsEnabled));
 
   /// Indicates whether initializers of implicitly typed variables should be
   /// accounted for by SSA analysis.  (In an ideal world, they always would be,
@@ -3125,12 +3120,6 @@ class _MiniAstErrors
     _recordError('nonBooleanCondition', {'node': node});
   }
 
-  @override
-  void nonExhaustiveSwitch({required Node node, required Type scrutineeType}) {
-    _recordError(
-        'nonExhaustiveSwitch', {'node': node, 'scrutineeType': scrutineeType});
-  }
-
   @override
   void patternDoesNotAllowLate({required Node pattern}) {
     _recordError('patternDoesNotAllowLate', {'pattern': pattern});
@@ -3872,7 +3861,8 @@ class _MiniAstTypeAnalyzer
       operations.isAlwaysExhaustiveType(type);
 
   @override
-  bool isLegacySwitchExhaustive(covariant _Switch node, Type expressionType) {
+  bool isLegacySwitchExhaustive(
+      covariant _SwitchStatement node, Type expressionType) {
     return node.isLegacyExhaustive!;
   }
 
@@ -4512,20 +4502,12 @@ class _Return extends Statement {
   }
 }
 
-abstract class _Switch implements Node {
-  bool? get isLegacyExhaustive;
-}
-
-class _SwitchExpression extends Expression implements _Switch {
+class _SwitchExpression extends Expression {
   final Expression scrutinee;
 
   final List<ExpressionCase> cases;
 
-  @override
-  final bool? isLegacyExhaustive;
-
-  _SwitchExpression(this.scrutinee, this.cases, this.isLegacyExhaustive,
-      {required super.location});
+  _SwitchExpression(this.scrutinee, this.cases, {required super.location});
 
   @override
   void preVisit(PreVisitor visitor) {
@@ -4537,30 +4519,18 @@ class _SwitchExpression extends Expression implements _Switch {
 
   @override
   String toString() {
-    var isLegacyExhaustive = this.isLegacyExhaustive;
-    var exhaustiveness = isLegacyExhaustive == null
-        ? ''
-        : isLegacyExhaustive
-            ? '<exhaustive>'
-            : '<non-exhaustive>';
     String body;
     if (cases.isEmpty) {
       body = '{}';
     } else {
       var contents = cases.join(' ');
       body = '{ $contents }';
     }
-    return 'switch$exhaustiveness ($scrutinee) $body';
+    return 'switch ($scrutinee) $body';
   }
 
   @override
   ExpressionTypeAnalysisResult<Type> visit(Harness h, Type context) {
-    bool needsLegacyExhaustive = h.errorOnSwitchExhaustiveness;
-    if (!needsLegacyExhaustive && isLegacyExhaustive != null) {
-      fail('isLegacyExhaustive should not be specified at $location');
-    } else if (needsLegacyExhaustive && isLegacyExhaustive == null) {
-      fail('isLegacyExhaustive should be specified at $location');
-    }
     var result = h.typeAnalyzer
         .analyzeSwitchExpression(this, scrutinee, cases.length, context);
     h.irBuilder.apply(
@@ -4582,12 +4552,11 @@ class _SwitchHeadDefault extends SwitchHead {
   _SwitchHeadDefault({required super.location}) : super._();
 }
 
-class _SwitchStatement extends Statement implements _Switch {
+class _SwitchStatement extends Statement {
   final Expression scrutinee;
 
   final List<_SwitchStatementMember> cases;
 
-  @override
   final bool? isLegacyExhaustive;
 
   final bool? expectHasDefault;
@@ -4638,8 +4607,7 @@ class _SwitchStatement extends Statement implements _Switch {
 
   @override
   void visit(Harness h) {
-    bool needsLegacyExhaustive =
-        !h.patternsEnabled || h.errorOnSwitchExhaustiveness;
+    bool needsLegacyExhaustive = !h.patternsEnabled;
     if (!needsLegacyExhaustive && isLegacyExhaustive != null) {
       fail('isLegacyExhaustive should not be specified at $location');
     } else if (needsLegacyExhaustive && isLegacyExhaustive == null) {