Flow analysis: Separate variable and type operations.

This change moves the `variableType` method from the class
`TypeOperations` to a new class, `VariableOperations`, which in turn
allows removing the type parameter `Variable` parameter from
`TypeOperations`.  A new class, `Operations`, is introduced to serve
the role served previously by `TypeOperations` for flow analysis
clients (i.e. it is the base class that clients should extend).

This paves the way for a future CL that will remove the type parameter
`Variable` from other classes inside flow analysis.

Bug: dart-lang/language#2020
Change-Id: Ic45d07a0f873b692fda4b6f807c1130ac592b010
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/250108
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

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

@@ -247,9 +247,9 @@ abstract class Expression extends Node {
 }
 
 /// Test harness for creating flow analysis tests.  This class implements all
-/// the [TypeOperations] needed by flow analysis, as well as other methods
-/// needed for testing.
-class Harness extends TypeOperations<Var, Type> {
+/// the [Operations] needed by flow analysis, as well as other methods needed
+/// for testing.
+class Harness extends Operations<Var, Type> {
   static const Map<String, bool> _coreSubtypes = const {
     'bool <: int': false,
     'bool <: Object': true,
@@ -1486,7 +1486,7 @@ class _MiniAstTypeAnalyzer {
     var rightType = analyzeExpression(rhs);
     flow.ifNullExpression_end();
     return leastUpperBound(
-        flow.typeOperations.promoteToNonNull(leftType), rightType);
+        flow.operations.promoteToNonNull(leftType), rightType);
   }
 
   void analyzeIfStatement(Statement node, Expression condition,
@@ -1520,7 +1520,7 @@ class _MiniAstTypeAnalyzer {
   Type analyzeNonNullAssert(Expression node, Expression expression) {
     var type = analyzeExpression(expression);
     flow.nonNullAssert_end(expression);
-    return flow.typeOperations.promoteToNonNull(type);
+    return flow.operations.promoteToNonNull(type);
   }
 
   Type analyzeNullLiteral(Expression node) {

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -59,7 +59,7 @@ class FlowAnalysisDataForTesting {
 /// be extracted.
 class FlowAnalysisHelper {
   /// The reused instance for creating new [FlowAnalysis] instances.
-  final TypeSystemTypeOperations _typeOperations;
+  final TypeSystemOperations _typeOperations;
 
   /// Precomputed sets of potentially assigned variables.
   AssignedVariables<AstNode, PromotableElement>? assignedVariables;
@@ -82,7 +82,7 @@ class FlowAnalysisHelper {
 
   FlowAnalysisHelper(TypeSystemImpl typeSystem, bool retainDataForTesting,
       FeatureSet featureSet)
-      : this._(TypeSystemTypeOperations(typeSystem),
+      : this._(TypeSystemOperations(typeSystem),
             retainDataForTesting ? FlowAnalysisDataForTesting() : null,
             isNonNullableByDefault: featureSet.isEnabled(Feature.non_nullable),
             respectImplicitlyTypedVarInitializers:
@@ -375,11 +375,10 @@ class FlowAnalysisHelperForMigration extends FlowAnalysisHelper {
   }
 }
 
-class TypeSystemTypeOperations
-    extends TypeOperations<PromotableElement, DartType> {
+class TypeSystemOperations extends Operations<PromotableElement, DartType> {
   final TypeSystemImpl typeSystem;
 
-  TypeSystemTypeOperations(this.typeSystem);
+  TypeSystemOperations(this.typeSystem);
 
   @override
   TypeClassification classifyType(DartType type) {

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

@@ -260,10 +260,10 @@ class FlowAnalysisResult {
 }
 
 /// CFE-specific implementation of [TypeOperations].
-class TypeOperationsCfe extends TypeOperations<VariableDeclaration, DartType> {
+class OperationsCfe extends Operations<VariableDeclaration, DartType> {
   final TypeEnvironment typeEnvironment;
 
-  TypeOperationsCfe(this.typeEnvironment);
+  OperationsCfe(this.typeEnvironment);
 
   @override
   TypeClassification classifyType(DartType? type) {

pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart

@@ -228,16 +228,14 @@ class TypeInferrerImpl implements TypeInferrer {
 
   @override
   late final FlowAnalysis<TreeNode, Statement, Expression, VariableDeclaration,
-          DartType> flowAnalysis =
-      libraryBuilder.isNonNullableByDefault
-          ? new FlowAnalysis(
-              new TypeOperationsCfe(engine.typeSchemaEnvironment),
-              assignedVariables,
-              respectImplicitlyTypedVarInitializers:
-                  libraryBuilder.libraryFeatures.constructorTearoffs.isEnabled)
-          : new FlowAnalysis.legacy(
-              new TypeOperationsCfe(engine.typeSchemaEnvironment),
-              assignedVariables);
+      DartType> flowAnalysis = libraryBuilder
+          .isNonNullableByDefault
+      ? new FlowAnalysis(
+          new OperationsCfe(engine.typeSchemaEnvironment), assignedVariables,
+          respectImplicitlyTypedVarInitializers:
+              libraryBuilder.libraryFeatures.constructorTearoffs.isEnabled)
+      : new FlowAnalysis.legacy(
+          new OperationsCfe(engine.typeSchemaEnvironment), assignedVariables);
 
   @override
   final AssignedVariables<TreeNode, VariableDeclaration> assignedVariables;

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart

@@ -11,9 +11,9 @@ import 'package:nnbd_migration/src/edge_origin.dart';
 import 'package:nnbd_migration/src/nullability_node.dart';
 import 'package:nnbd_migration/src/variables.dart';
 
-/// [TypeOperations] that works with [DecoratedType]s.
+/// [Operations] that works with [DecoratedType]s.
 class DecoratedTypeOperations
-    implements TypeOperations<PromotableElement, DecoratedType> {
+    implements Operations<PromotableElement, DecoratedType> {
   final TypeSystem _typeSystem;
   final Variables? _variableRepository;
   final NullabilityGraph _graph;