Remove generic parameters from type inference classes.

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

Index: pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
index 55cf1bd0e2b6a9d6521d9e7280b65f7cf41c0042..7d0f1c99fc13569c190baf5acf0bbfdf91af224a 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
@@ -4,6 +4,7 @@
 
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/dependency_walker.dart' as dependencyWalker;
+import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart';
@@ -17,12 +18,12 @@ import 'package:kernel/core_types.dart';
 /// TODO(paulberry): see if it's possible to make this class more lightweight
 /// by changing the API so that the walker is passed to computeDependencies().
 /// (This should allow us to drop the _typeInferenceEngine field).
-class FieldNode<F> extends dependencyWalker.Node<FieldNode<F>> {
+class FieldNode extends dependencyWalker.Node<FieldNode> {
   final TypeInferenceEngineImpl _typeInferenceEngine;
 
-  final F _field;
+  final KernelField _field;
 
-  final dependencies = <FieldNode<F>>[];
+  final dependencies = <FieldNode>[];
 
   FieldNode(this._typeInferenceEngine, this._field);
 
@@ -30,7 +31,7 @@ class FieldNode<F> extends dependencyWalker.Node<FieldNode<F>> {
   bool get isEvaluated => _typeInferenceEngine.isFieldInferred(_field);
 
   @override
-  List<FieldNode<F>> computeDependencies() {
+  List<FieldNode> computeDependencies() {
     return dependencies;
   }
 }
@@ -38,30 +39,22 @@ class FieldNode<F> extends dependencyWalker.Node<FieldNode<F>> {
 /// Keeps track of the global state for the type inference that occurs outside
 /// of method bodies and initalizers.
 ///
-/// This class abstracts away the representation of the underlying AST using
-/// generic parameters.  TODO(paulberry): would it make more sense to abstract
-/// away the representation of types as well?
-///
-/// Derived classes should set F to the class they use to represent field
-/// declarations.
-///
 /// This class describes the interface for use by clients of type inference
 /// (e.g. DietListener).  Derived classes should derive from
 /// [TypeInferenceEngineImpl].
-abstract class TypeInferenceEngine<F> {
+abstract class TypeInferenceEngine {
   ClassHierarchy get classHierarchy;
 
   CoreTypes get coreTypes;
 
   /// Creates a type inferrer for use inside of a method body declared in a file
   /// with the given [uri].
-  TypeInferrer<dynamic, dynamic, dynamic, F> createLocalTypeInferrer(
-      Uri uri, TypeInferenceListener listener);
+  TypeInferrer createLocalTypeInferrer(Uri uri, TypeInferenceListener listener);
 
   /// Creates a [TypeInferrer] object which is ready to perform type inference
   /// on the given [field].
-  TypeInferrer<dynamic, dynamic, dynamic, F> createTopLevelTypeInferrer(
-      F field, TypeInferenceListener listener);
+  TypeInferrer createTopLevelTypeInferrer(
+      KernelField field, TypeInferenceListener listener);
 
   /// Performs the second phase of top level initializer inference, which is to
   /// visit all fields and top level variables that were passed to [recordField]
@@ -70,14 +63,14 @@ abstract class TypeInferenceEngine<F> {
 
   /// Gets the list of top level type inference dependencies of the given
   /// [field].
-  List<FieldNode<F>> getFieldDependencies(F field);
+  List<FieldNode> getFieldDependencies(KernelField field);
 
   /// Gets ready to do top level type inference for the program having the given
   /// [hierarchy], using the given [coreTypes].
   void prepareTopLevel(CoreTypes coreTypes, ClassHierarchy hierarchy);
 
   /// Records that the given [field] will need top level type inference.
-  void recordField(F field);
+  void recordField(KernelField field);
 }
 
 /// Derived class containing generic implementations of
@@ -86,12 +79,12 @@ abstract class TypeInferenceEngine<F> {
 /// This class contains as much of the implementation of type inference as
 /// possible without knowing the identity of the type parameter.  It defers to
 /// abstract methods for everything else.
-abstract class TypeInferenceEngineImpl<F> extends TypeInferenceEngine<F> {
+abstract class TypeInferenceEngineImpl extends TypeInferenceEngine {
   final Instrumentation instrumentation;
 
   final bool strongMode;
 
-  final fieldNodes = <FieldNode<F>>[];
+  final fieldNodes = <FieldNode>[];
 
   @override
   CoreTypes coreTypes;
@@ -104,40 +97,40 @@ abstract class TypeInferenceEngineImpl<F> extends TypeInferenceEngine<F> {
   TypeInferenceEngineImpl(this.instrumentation, this.strongMode);
 
   /// Clears the initializer of [field].
-  void clearFieldInitializer(F field);
+  void clearFieldInitializer(KernelField field);
 
   /// Creates a [FieldNode] to track dependencies of the given [field].
-  FieldNode<F> createFieldNode(F field);
+  FieldNode createFieldNode(KernelField field);
 
   /// Queries whether the given [field] has an initializer.
-  bool fieldHasInitializer(F field);
+  bool fieldHasInitializer(KernelField field);
 
   @override
   void finishTopLevel() {
     for (var fieldNode in fieldNodes) {
       if (fieldNode.isEvaluated) continue;
-      new _FieldWalker<F>().walk(fieldNode);
+      new _FieldWalker().walk(fieldNode);
     }
   }
 
   /// Gets the declared type of the given [field], or `null` if the type is
   /// implicit.
-  DartType getFieldDeclaredType(F field);
+  DartType getFieldDeclaredType(KernelField field);
 
   /// Gets the character offset of the declaration of [field] within its
   /// compilation unit.
-  int getFieldOffset(F field);
+  int getFieldOffset(KernelField field);
 
   /// Retrieve the [TypeInferrer] for the given [field], which was created by
   /// a previous call to [createTopLevelTypeInferrer].
-  TypeInferrerImpl<dynamic, dynamic, dynamic, F> getFieldTypeInferrer(F field);
+  TypeInferrerImpl getFieldTypeInferrer(KernelField field);
 
   /// Gets the URI of the compilation unit the [field] is declared in.
   /// TODO(paulberry): can we remove this?
-  String getFieldUri(F field);
+  String getFieldUri(KernelField field);
 
   /// Performs type inference on the given [field].
-  void inferField(F field) {
+  void inferField(KernelField field) {
     if (fieldHasInitializer(field)) {
       var typeInferrer = getFieldTypeInferrer(field);
       var type = getFieldDeclaredType(field);
@@ -162,7 +155,7 @@ abstract class TypeInferenceEngineImpl<F> extends TypeInferenceEngine<F> {
 
   /// Makes a note that the given [field] is part of a circularity, so its type
   /// can't be inferred.
-  void inferFieldCircular(F field) {
+  void inferFieldCircular(KernelField field) {
     // TODO(paulberry): report the appropriate error.
     if (getFieldDeclaredType(field) == null) {
       var uri = getFieldTypeInferrer(field).uri;
@@ -173,7 +166,7 @@ abstract class TypeInferenceEngineImpl<F> extends TypeInferenceEngine<F> {
   }
 
   /// Determines if top level type inference has been completed for [field].
-  bool isFieldInferred(F field);
+  bool isFieldInferred(KernelField field);
 
   @override
   void prepareTopLevel(CoreTypes coreTypes, ClassHierarchy hierarchy) {
@@ -184,26 +177,26 @@ abstract class TypeInferenceEngineImpl<F> extends TypeInferenceEngine<F> {
   }
 
   @override
-  void recordField(F field) {
+  void recordField(KernelField field) {
     fieldNodes.add(createFieldNode(field));
   }
 
   /// Stores [inferredType] as the inferred type of [field].
-  void setFieldInferredType(F field, DartType inferredType);
+  void setFieldInferredType(KernelField field, DartType inferredType);
 }
 
 /// Subtype of [dependencyWalker.DependencyWalker] which is specialized to
 /// perform top level type inference.
-class _FieldWalker<F> extends dependencyWalker.DependencyWalker<FieldNode<F>> {
+class _FieldWalker extends dependencyWalker.DependencyWalker<FieldNode> {
   _FieldWalker();
 
   @override
-  void evaluate(FieldNode<F> f) {
+  void evaluate(FieldNode f) {
     f._typeInferenceEngine.inferField(f._field);
   }
 
   @override
-  void evaluateScc(List<FieldNode<F>> scc) {
+  void evaluateScc(List<FieldNode> scc) {
     for (var f in scc) {
       f._typeInferenceEngine.inferFieldCircular(f._field);
     }