[_fe_analyzer_shared] Use TypeAnalyzerOptions to configure flow analysis.

Previously, flow analysis was configured by passing a set of named
booleans to its constructor, each to enable or disable a separate
language feature.

This change merges the flow analysis configuration with the
`TypeAnalyzerOptions` class (which was already being used for
configuring the shared `TypeAnalyzer` class). This should make it
easier to add language features to the shared code base in the future,
since there will be one common place where all features will be
configured.

To avoid duplicating the logic that creates `TypeAnalyzerOptions`,
I've had to do a bit of minor surgery to the clients:

- In the test harness in `_fe_analyzer_shared`, there is a common
  method (`Harness.computeTypeAnalyzerOptions`) that constructs
  `TypeAnalyzerOptions` based on the harness configuration. It is
  called from a few different tests.

- In `pkg/analyzer`, there is a common method
  (`computeTypeAnalyzerOptions`) that constructs `TypeAnalyzerOptions`
  based on a `FeatureSet`. It is used by
  `LibraryAnalyzer.analyzeForCompletion`,
  `LibraryAnalyzer._resolveFile`, and the late variable
  `AstResolver._typeAnalyzerOptions`.

- In `pkg/front_end`, I've moved computation of `TypeAnalyzerOptions`
  from the `InferenceVisitorImpl` constructor to the
  `TypeInferrerImpl` constructor; the options are then passed to the
  `InferenceVisitorImpl` by `_createInferenceVisitor`.

I'm doing this work now as preparation for adding support for sound
flow analysis (#60438), so that
I can add the logic to enable it in a clean way.

Bug: #60438
Change-Id: Ib845194adb404b4c0a3feeff17a14ae641d515eb
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/419940
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -5,6 +5,7 @@
 /// @docImport 'package:_fe_analyzer_shared/src/type_inference/null_shorting.dart';
 library;
 
+import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart';
 import 'package:_fe_analyzer_shared/src/types/shared_type.dart';
 import 'package:meta/meta.dart';
 
@@ -195,18 +196,10 @@ abstract class FlowAnalysis<Node extends Object, Statement extends Node,
   factory FlowAnalysis(
     FlowAnalysisOperations<Variable, Type> operations,
     AssignedVariables<Node, Variable> assignedVariables, {
-    required bool respectImplicitlyTypedVarInitializers,
-    required bool fieldPromotionEnabled,
-    required bool inferenceUpdate4Enabled,
+    required TypeAnalyzerOptions typeAnalyzerOptions,
   }) {
-    return new _FlowAnalysisImpl(
-      operations,
-      assignedVariables,
-      respectImplicitlyTypedVarInitializers:
-          respectImplicitlyTypedVarInitializers,
-      fieldPromotionEnabled: fieldPromotionEnabled,
-      inferenceUpdate4Enabled: inferenceUpdate4Enabled,
-    );
+    return new _FlowAnalysisImpl(operations, assignedVariables,
+        typeAnalyzerOptions: typeAnalyzerOptions);
   }
 
   /// Return `true` if the current state is reachable.
@@ -1204,18 +1197,11 @@ class FlowAnalysisDebug<Node extends Object, Statement extends Node,
 
   factory FlowAnalysisDebug(FlowAnalysisOperations<Variable, Type> operations,
       AssignedVariables<Node, Variable> assignedVariables,
-      {required bool respectImplicitlyTypedVarInitializers,
-      required bool fieldPromotionEnabled,
-      required bool inferenceUpdate4Enabled}) {
+      {required TypeAnalyzerOptions typeAnalyzerOptions}) {
     print('FlowAnalysisDebug()');
     return new FlowAnalysisDebug._(new _FlowAnalysisImpl(
-      operations,
-      assignedVariables,
-      respectImplicitlyTypedVarInitializers:
-          respectImplicitlyTypedVarInitializers,
-      fieldPromotionEnabled: fieldPromotionEnabled,
-      inferenceUpdate4Enabled: inferenceUpdate4Enabled,
-    ));
+        operations, assignedVariables,
+        typeAnalyzerOptions: typeAnalyzerOptions));
   }
 
   FlowAnalysisDebug._(this._wrapped);
@@ -4304,6 +4290,9 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
     implements
         FlowAnalysis<Node, Statement, Expression, Variable, Type>,
         _PropertyTargetHelper<Expression, Type> {
+  /// Options affecting the behavior of flow analysis.
+  final TypeAnalyzerOptions typeAnalyzerOptions;
+
   /// The [FlowAnalysisOperations], used to access types, check subtyping, and
   /// query variable types.
   @override
@@ -4387,17 +4376,6 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
 
   final AssignedVariables<Node, Variable> _assignedVariables;
 
-  /// Indicates whether initializers of implicitly typed variables should be
-  /// accounted for by SSA analysis.  (In an ideal world, they always would be,
-  /// but due to https://github.com/dart-lang/language/issues/1785, they weren't
-  /// always, and we need to be able to replicate the old behavior when
-  /// analyzing old language versions).
-  final bool respectImplicitlyTypedVarInitializers;
-
-  final bool fieldPromotionEnabled;
-
-  final bool inferenceUpdate4Enabled;
-
   @override
   final PromotionKeyStore<Variable> promotionKeyStore;
 
@@ -4417,13 +4395,9 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
   @override
   final List<_Reference<Type>> _cascadeTargetStack = [];
 
-  _FlowAnalysisImpl(
-    this.operations,
-    this._assignedVariables, {
-    required this.respectImplicitlyTypedVarInitializers,
-    required this.fieldPromotionEnabled,
-    required this.inferenceUpdate4Enabled,
-  }) : promotionKeyStore = _assignedVariables.promotionKeyStore {
+  _FlowAnalysisImpl(this.operations, this._assignedVariables,
+      {required this.typeAnalyzerOptions})
+      : promotionKeyStore = _assignedVariables.promotionKeyStore {
     if (!_assignedVariables.isFinished) {
       _assignedVariables.finish();
     }
@@ -4994,7 +4968,7 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
 
   @override
   bool isFinal(int variableKey) {
-    if (!inferenceUpdate4Enabled) return false;
+    if (!typeAnalyzerOptions.inferenceUpdate4Enabled) return false;
     Variable? variable = promotionKeyStore.variableForKey(variableKey);
     if (variable != null && operations.isFinal(variable)) return true;
     return false;
@@ -5899,12 +5873,14 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
                 result[type] = whyNotPromotable == null
                     ? new PropertyNotPromotedForNonInherentReason(
                         reference.propertyName, propertyMember,
-                        fieldPromotionEnabled: fieldPromotionEnabled)
+                        fieldPromotionEnabled:
+                            typeAnalyzerOptions.fieldPromotionEnabled)
                     : new PropertyNotPromotedForInherentReason(
                         reference.propertyName,
                         propertyMember,
                         whyNotPromotable,
-                        fieldPromotionEnabled: fieldPromotionEnabled);
+                        fieldPromotionEnabled:
+                            typeAnalyzerOptions.fieldPromotionEnabled);
               }
             }
             return result;
@@ -6032,7 +6008,7 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
     // Find the SSA node for the target of the property access, and figure out
     // whether the property in question is promotable.
     bool isPromotable = propertyMember != null &&
-        fieldPromotionEnabled &&
+        typeAnalyzerOptions.fieldPromotionEnabled &&
         operations.isPropertyPromotable(propertyMember);
     _PropertySsaNode<Type> propertySsaNode =
         targetSsaNode.getOrCreatePropertyNode(propertyName, promotionKeyStore,
@@ -6063,7 +6039,8 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
       // Don't use expression info for late variables, since we don't know when
       // they'll be initialized.
       expressionInfo = null;
-    } else if (isImplicitlyTyped && !respectImplicitlyTypedVarInitializers) {
+    } else if (isImplicitlyTyped &&
+        !typeAnalyzerOptions.respectImplicitlyTypedVarInitializers) {
       // If the language version is too old, SSA analysis has to ignore
       // initializer expressions for implicitly typed variables, in order to
       // preserve the buggy behavior of
@@ -6285,7 +6262,9 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
         unpromotedType: unpromotedType);
 
     // Update the type of the variable for looking up the write expression.
-    if (inferenceUpdate4Enabled && node is Expression && !isPostfixIncDec) {
+    if (typeAnalyzerOptions.inferenceUpdate4Enabled &&
+        node is Expression &&
+        !isPostfixIncDec) {
       _Reference<Type> reference = _variableReference(
         variableKey,
         unpromotedType,

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

@@ -285,7 +285,7 @@ mixin TypeAnalyzer<
       get operations;
 
   /// Options affecting the behavior of [TypeAnalyzer].
-  TypeAnalyzerOptions get options;
+  TypeAnalyzerOptions get typeAnalyzerOptions;
 
   /// Analyzes a non-wildcard variable pattern appearing in an assignment
   /// context.  [node] is the pattern itself, and [variable] is the variable
@@ -425,11 +425,11 @@ mixin TypeAnalyzer<
     SharedTypeView expressionType = analyzeExpression(
         expression, operations.typeToSchema(matchedValueType));
     flow.constantPattern_end(expression, expressionType,
-        patternsEnabled: options.patternsEnabled,
+        patternsEnabled: typeAnalyzerOptions.patternsEnabled,
         matchedValueType: matchedValueType);
     // Stack: (Expression)
     Error? caseExpressionTypeMismatchError;
-    if (!options.patternsEnabled) {
+    if (!typeAnalyzerOptions.patternsEnabled) {
       Expression? switchScrutinee = context.switchScrutinee;
       if (switchScrutinee != null) {
         bool matches = operations.isSubtypeOf(expressionType, matchedValueType);
@@ -1848,7 +1848,7 @@ mixin TypeAnalyzer<
         // Stack: (Expression, (i + 1) * ExpressionCase)
       }
       // If `inferenceUpdate3` is not enabled, then the type of `E` is `T`.
-      if (!this.options.inferenceUpdate3Enabled) {
+      if (!typeAnalyzerOptions.inferenceUpdate3Enabled) {
         staticType = t!;
       } else
       // - If `T <: S`, then the type of `E` is `T`.
@@ -1975,7 +1975,7 @@ mixin TypeAnalyzer<
       //         n * Statement), where n = body.length
       lastCaseTerminates = !flow.switchStatement_afterCase();
       if (caseIndex < numCases - 1 &&
-          !options.patternsEnabled &&
+          !typeAnalyzerOptions.patternsEnabled &&
           !lastCaseTerminates) {
         (switchCaseCompletesNormallyErrors ??= {})[caseIndex] = errors
             .switchCaseCompletesNormally(node: node, caseIndex: caseIndex);
@@ -1990,7 +1990,7 @@ mixin TypeAnalyzer<
     if (hasDefault) {
       isExhaustive = true;
       requiresExhaustivenessValidation = false;
-    } else if (options.patternsEnabled) {
+    } else if (typeAnalyzerOptions.patternsEnabled) {
       requiresExhaustivenessValidation =
           isExhaustive = operations.isAlwaysExhaustiveType(scrutineeType);
     } else {
@@ -2733,6 +2733,22 @@ class TypeAnalyzerOptions {
 
   final bool inferenceUpdate3Enabled;
 
-  TypeAnalyzerOptions(
-      {required this.patternsEnabled, required this.inferenceUpdate3Enabled});
+  /// Indicates whether initializers of implicitly typed variables should be
+  /// accounted for by SSA analysis.  (In an ideal world, they always would be,
+  /// but due to https://github.com/dart-lang/language/issues/1785, they weren't
+  /// always, and we need to be able to replicate the old behavior when
+  /// analyzing old language versions).
+  final bool respectImplicitlyTypedVarInitializers;
+
+  final bool fieldPromotionEnabled;
+
+  final bool inferenceUpdate4Enabled;
+
+  TypeAnalyzerOptions({
+    required this.patternsEnabled,
+    required this.inferenceUpdate3Enabled,
+    required this.respectImplicitlyTypedVarInitializers,
+    required this.fieldPromotionEnabled,
+    required this.inferenceUpdate4Enabled,
+  });
 }

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -637,9 +637,7 @@ main() {
       var s = if_(e, []);
       var flow = FlowAnalysis<Node, Statement, Expression, Var, SharedTypeView>(
           h.typeOperations, AssignedVariables<Node, Var>(),
-          respectImplicitlyTypedVarInitializers: true,
-          fieldPromotionEnabled: true,
-          inferenceUpdate4Enabled: true);
+          typeAnalyzerOptions: h.computeTypeAnalyzerOptions());
       flow.ifStatement_conditionBegin();
       flow.ifStatement_thenBegin(e, s);
       expect(() => flow.finish(), _asserts);

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -1611,11 +1611,8 @@ class Harness {
           isPromotable: false, whyNotPromotable: null)
   };
 
-  late final typeAnalyzer = _MiniAstTypeAnalyzer(
-      this,
-      TypeAnalyzerOptions(
-          patternsEnabled: patternsEnabled,
-          inferenceUpdate3Enabled: inferenceUpdate3Enabled));
+  late final typeAnalyzer =
+      _MiniAstTypeAnalyzer(this, computeTypeAnalyzerOptions());
 
   /// Indicates whether initializers of implicitly typed variables should be
   /// accounted for by SSA analysis.  (In an ideal world, they always would be,
@@ -1704,6 +1701,15 @@ class Harness {
     operations.addSuperInterfaces(className, template);
   }
 
+  shared.TypeAnalyzerOptions computeTypeAnalyzerOptions() =>
+      TypeAnalyzerOptions(
+          patternsEnabled: patternsEnabled,
+          inferenceUpdate3Enabled: inferenceUpdate3Enabled,
+          respectImplicitlyTypedVarInitializers:
+              _respectImplicitlyTypedVarInitializers,
+          fieldPromotionEnabled: _fieldPromotionEnabled,
+          inferenceUpdate4Enabled: inferenceUpdate4Enabled);
+
   void disableFieldPromotion() {
     assert(!_started);
     _fieldPromotionEnabled = false;
@@ -1798,13 +1804,8 @@ class Harness {
       var b = Block._(statements, location: computeLocation());
       b.preVisit(visitor);
       flow = FlowAnalysis<Node, Statement, Expression, Var, SharedTypeView>(
-        operations,
-        visitor._assignedVariables,
-        respectImplicitlyTypedVarInitializers:
-            _respectImplicitlyTypedVarInitializers,
-        fieldPromotionEnabled: _fieldPromotionEnabled,
-        inferenceUpdate4Enabled: inferenceUpdate4Enabled,
-      );
+          operations, visitor._assignedVariables,
+          typeAnalyzerOptions: computeTypeAnalyzerOptions());
       typeAnalyzer.dispatchStatement(b);
       typeAnalyzer.finish();
       expect(typeAnalyzer.errors._accumulatedErrors, expectedErrors);
@@ -5413,7 +5414,7 @@ class _MiniAstTypeAnalyzer
   final _irBuilder = MiniIRBuilder();
 
   @override
-  final TypeAnalyzerOptions options;
+  final TypeAnalyzerOptions typeAnalyzerOptions;
 
   /// The temporary variable used in the IR to represent the target of the
   /// innermost enclosing cascade expression, or `null` if no cascade expression
@@ -5425,7 +5426,7 @@ class _MiniAstTypeAnalyzer
   /// cascade expression is currently being visited.
   SharedTypeView? _currentCascadeTargetType;
 
-  _MiniAstTypeAnalyzer(this._harness, this.options);
+  _MiniAstTypeAnalyzer(this._harness, this.typeAnalyzerOptions);
 
   @override
   FlowAnalysis<Node, Statement, Expression, Var, SharedTypeView> get flow =>

pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart

@@ -26,6 +26,7 @@ import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dart/resolver/resolution_visitor.dart';
+import 'package:analyzer/src/dart/resolver/type_analyzer_options.dart';
 import 'package:analyzer/src/error/best_practices_verifier.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/constructor_fields_verifier.dart';
@@ -196,9 +197,12 @@ class LibraryAnalyzer {
         ),
       );
 
+      var featureSet = _libraryElement.featureSet;
+      var typeAnalyzerOptions = computeTypeAnalyzerOptions(featureSet);
       FlowAnalysisHelper flowAnalysisHelper = FlowAnalysisHelper(
-          _testingData != null, _libraryElement.featureSet,
-          typeSystemOperations: _typeSystemOperations);
+          _testingData != null,
+          typeSystemOperations: _typeSystemOperations,
+          typeAnalyzerOptions: typeAnalyzerOptions);
       _testingData?.recordFlowAnalysisDataForTesting(
           file.uri, flowAnalysisHelper.dataForTesting!);
 
@@ -213,6 +217,7 @@ class LibraryAnalyzer {
         analysisOptions: _library.file.analysisOptions,
         flowAnalysisHelper: flowAnalysisHelper,
         libraryFragment: unitElement,
+        typeAnalyzerOptions: typeAnalyzerOptions,
       );
       _testingData?.recordTypeConstraintGenerationDataForTesting(
           file.uri, resolverVisitor.inferenceHelper.dataForTesting!);
@@ -864,9 +869,11 @@ class LibraryAnalyzer {
     // Nothing for RESOLVED_UNIT9?
     // Nothing for RESOLVED_UNIT10?
 
+    var typeAnalyzerOptions = computeTypeAnalyzerOptions(unit.featureSet);
     FlowAnalysisHelper flowAnalysisHelper = FlowAnalysisHelper(
-        _testingData != null, unit.featureSet,
-        typeSystemOperations: _typeSystemOperations);
+        _testingData != null,
+        typeSystemOperations: _typeSystemOperations,
+        typeAnalyzerOptions: typeAnalyzerOptions);
     _testingData?.recordFlowAnalysisDataForTesting(
         fileAnalysis.file.uri, flowAnalysisHelper.dataForTesting!);
 
@@ -881,6 +888,7 @@ class LibraryAnalyzer {
       featureSet: unit.featureSet,
       flowAnalysisHelper: flowAnalysisHelper,
       libraryFragment: unitElement,
+      typeAnalyzerOptions: typeAnalyzerOptions,
     );
     unit.accept(resolver);
     _testingData?.recordTypeConstraintGenerationDataForTesting(