Rework TypeInferenceListener.

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

Index: pkg/front_end/lib/src/fasta/type_inference/type_inference_listener.dart
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inference_listener.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inference_listener.dart
index e617ce2f20c75827c685bd0776ea44d132fa886b..ff368b5840971d79d1ce818edc1b1e74ebe16e4c 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inference_listener.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inference_listener.dart
@@ -2,7 +2,36 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
-import 'package:kernel/ast.dart' show DartType;
+import 'package:kernel/ast.dart';
+
+/// Base class for [TypeInferenceListener] that defines the API for debugging.
+///
+/// By default no debug info is printed.  To enable debug printing, mix in
+/// [TypeInferenceDebugging].
+class TypeInferenceBase {
+  bool debugExpressionEnter(
+      String expressionType, Expression expression, DartType typeContext) {
+    return false;
+  }
+
+  debugExpressionExit(
+      String expressionType, Expression expression, DartType inferredType) {}
+}
+
+/// Mixin which can be applied to [TypeInferenceListener] to cause debug info to
+/// be printed.
+class TypeInferenceDebugging implements TypeInferenceBase {
+  bool debugExpressionEnter(
+      String expressionType, Expression expression, DartType typeContext) {
+    print('Enter $expressionType($expression) (context=$typeContext)');
+    return true;
+  }
+
+  debugExpressionExit(
+      String expressionType, Expression expression, DartType inferredType) {
+    print('Exit $expressionType($expression) (type=$inferredType)');
+  }
+}
 
 /// Callback interface used by [TypeInferrer] to report the results of type
 /// inference to a client.
@@ -16,123 +45,128 @@ import 'package:kernel/ast.dart' show DartType;
 /// final inferred type.
 ///
 /// The default implementation (in this base class) does nothing, however it can
-/// be used to debug type inference by uncommenting the `print` calls in
-/// [debugExpressionEnter] and [debugExpressionExit].
-class TypeInferenceListener {
-  bool asExpressionEnter(DartType typeContext) =>
-      debugExpressionEnter("asExpression", typeContext);
-
-  void asExpressionExit(DartType inferredType) =>
-      debugExpressionExit("asExpression", inferredType);
+/// be used to debug type inference by uncommenting the
+/// "with TypeInferenceDebugging" clause below.
+class TypeInferenceListener
+    extends TypeInferenceBase // with TypeInferenceDebugging
+{
+  bool asExpressionEnter(AsExpression expression, DartType typeContext) =>
+      debugExpressionEnter("asExpression", expression, typeContext);
 
-  bool boolLiteralEnter(DartType typeContext) =>
-      debugExpressionEnter("boolLiteral", typeContext);
+  void asExpressionExit(AsExpression expression, DartType inferredType) =>
+      debugExpressionExit("asExpression", expression, inferredType);
 
-  void boolLiteralExit(DartType inferredType) =>
-      debugExpressionExit("boolLiteral", inferredType);
+  bool boolLiteralEnter(BoolLiteral expression, DartType typeContext) =>
+      debugExpressionEnter("boolLiteral", expression, typeContext);
 
-  bool conditionalExpressionEnter(DartType typeContext) =>
-      debugExpressionEnter("conditionalExpression", typeContext);
+  void boolLiteralExit(BoolLiteral expression, DartType inferredType) =>
+      debugExpressionExit("boolLiteral", expression, inferredType);
 
-  void conditionalExpressionExit(DartType inferredType) =>
-      debugExpressionExit("conditionalExpression", inferredType);
+  bool conditionalExpressionEnter(
+          ConditionalExpression expression, DartType typeContext) =>
+      debugExpressionEnter("conditionalExpression", expression, typeContext);
 
-  bool constructorInvocationEnter(DartType typeContext) =>
-      debugExpressionEnter("constructorInvocation", typeContext);
+  void conditionalExpressionExit(
+          ConditionalExpression expression, DartType inferredType) =>
+      debugExpressionExit("conditionalExpression", expression, inferredType);
 
-  void constructorInvocationExit(DartType inferredType) =>
-      debugExpressionExit("constructorInvocation", inferredType);
+  bool constructorInvocationEnter(
+          ConstructorInvocation expression, DartType typeContext) =>
+      debugExpressionEnter("constructorInvocation", expression, typeContext);
 
-  bool debugExpressionEnter(String expressionType, DartType typeContext) {
-    // print('Enter $expressionType (context=$typeContext)'); return true;
-    return false;
-  }
-
-  debugExpressionExit(String expressionType, DartType inferredType) {
-    // print('Exit $expressionType (type=$inferredType)');
-  }
+  void constructorInvocationExit(
+          ConstructorInvocation expression, DartType inferredType) =>
+      debugExpressionExit("constructorInvocation", expression, inferredType);
 
-  bool doubleLiteralEnter(DartType typeContext) =>
-      debugExpressionEnter("doubleLiteral", typeContext);
+  bool doubleLiteralEnter(DoubleLiteral expression, DartType typeContext) =>
+      debugExpressionEnter("doubleLiteral", expression, typeContext);
 
-  void doubleLiteralExit(DartType inferredType) =>
-      debugExpressionExit("doubleLiteral", inferredType);
+  void doubleLiteralExit(DoubleLiteral expression, DartType inferredType) =>
+      debugExpressionExit("doubleLiteral", expression, inferredType);
 
-  bool functionExpressionEnter(DartType typeContext) =>
-      debugExpressionEnter("functionExpression", typeContext);
+  bool functionExpressionEnter(
+          FunctionExpression expression, DartType typeContext) =>
+      debugExpressionEnter("functionExpression", expression, typeContext);
 
-  void functionExpressionExit(DartType inferredType) =>
-      debugExpressionExit("functionExpression", inferredType);
+  void functionExpressionExit(
+          FunctionExpression expression, DartType inferredType) =>
+      debugExpressionExit("functionExpression", expression, inferredType);
 
-  bool intLiteralEnter(DartType typeContext) =>
-      debugExpressionEnter("intLiteral", typeContext);
+  bool intLiteralEnter(IntLiteral expression, DartType typeContext) =>
+      debugExpressionEnter("intLiteral", expression, typeContext);
 
-  void intLiteralExit(DartType inferredType) =>
-      debugExpressionExit("intLiteral", inferredType);
+  void intLiteralExit(IntLiteral expression, DartType inferredType) =>
+      debugExpressionExit("intLiteral", expression, inferredType);
 
-  bool isExpressionEnter(DartType typeContext) =>
-      debugExpressionEnter("isExpression", typeContext);
+  bool isExpressionEnter(IsExpression expression, DartType typeContext) =>
+      debugExpressionEnter("isExpression", expression, typeContext);
 
-  void isExpressionExit(DartType inferredType) =>
-      debugExpressionExit("isExpression", inferredType);
+  void isExpressionExit(IsExpression expression, DartType inferredType) =>
+      debugExpressionExit("isExpression", expression, inferredType);
 
-  bool isNotExpressionEnter(DartType typeContext) =>
-      debugExpressionEnter("isNotExpression", typeContext);
+  bool isNotExpressionEnter(Not expression, DartType typeContext) =>
+      debugExpressionEnter("isNotExpression", expression, typeContext);
 
-  void isNotExpressionExit(DartType inferredType) =>
-      debugExpressionExit("isNotExpression", inferredType);
+  void isNotExpressionExit(Not expression, DartType inferredType) =>
+      debugExpressionExit("isNotExpression", expression, inferredType);
 
-  bool listLiteralEnter(DartType typeContext) =>
-      debugExpressionEnter("listLiteral", typeContext);
+  bool listLiteralEnter(ListLiteral expression, DartType typeContext) =>
+      debugExpressionEnter("listLiteral", expression, typeContext);
 
-  void listLiteralExit(DartType inferredType) =>
-      debugExpressionExit("listLiteral", inferredType);
+  void listLiteralExit(ListLiteral expression, DartType inferredType) =>
+      debugExpressionExit("listLiteral", expression, inferredType);
 
-  bool methodInvocationEnter(DartType typeContext) =>
-      debugExpressionEnter("methodInvocation", typeContext);
+  bool methodInvocationEnter(
+          MethodInvocation expression, DartType typeContext) =>
+      debugExpressionEnter("methodInvocation", expression, typeContext);
 
-  void methodInvocationExit(DartType inferredType) =>
-      debugExpressionExit("methodInvocation", inferredType);
+  void methodInvocationExit(
+          MethodInvocation expression, DartType inferredType) =>
+      debugExpressionExit("methodInvocation", expression, inferredType);
 
-  bool nullLiteralEnter(DartType typeContext) =>
-      debugExpressionEnter("nullLiteral", typeContext);
+  bool nullLiteralEnter(NullLiteral expression, DartType typeContext) =>
+      debugExpressionEnter("nullLiteral", expression, typeContext);
 
-  void nullLiteralExit(DartType inferredType) =>
-      debugExpressionExit("nullLiteral", inferredType);
+  void nullLiteralExit(NullLiteral expression, DartType inferredType) =>
+      debugExpressionExit("nullLiteral", expression, inferredType);
 
-  bool staticGetEnter(DartType typeContext) =>
-      debugExpressionEnter("staticGet", typeContext);
+  bool staticGetEnter(StaticGet expression, DartType typeContext) =>
+      debugExpressionEnter("staticGet", expression, typeContext);
 
-  void staticGetExit(DartType inferredType) =>
-      debugExpressionExit("staticGet", inferredType);
+  void staticGetExit(StaticGet expression, DartType inferredType) =>
+      debugExpressionExit("staticGet", expression, inferredType);
 
-  bool staticInvocationEnter(DartType typeContext) =>
-      debugExpressionEnter("staticInvocation", typeContext);
+  bool staticInvocationEnter(
+          StaticInvocation expression, DartType typeContext) =>
+      debugExpressionEnter("staticInvocation", expression, typeContext);
 
-  void staticInvocationExit(DartType inferredType) =>
-      debugExpressionExit("staticInvocation", inferredType);
+  void staticInvocationExit(
+          StaticInvocation expression, DartType inferredType) =>
+      debugExpressionExit("staticInvocation", expression, inferredType);
 
-  bool stringConcatenationEnter(DartType typeContext) =>
-      debugExpressionEnter("stringConcatenation", typeContext);
+  bool stringConcatenationEnter(
+          StringConcatenation expression, DartType typeContext) =>
+      debugExpressionEnter("stringConcatenation", expression, typeContext);
 
-  void stringConcatenationExit(DartType inferredType) =>
-      debugExpressionExit("stringConcatenation", inferredType);
+  void stringConcatenationExit(
+          StringConcatenation expression, DartType inferredType) =>
+      debugExpressionExit("stringConcatenation", expression, inferredType);
 
-  bool stringLiteralEnter(DartType typeContext) =>
-      debugExpressionEnter("StringLiteral", typeContext);
+  bool stringLiteralEnter(StringLiteral expression, DartType typeContext) =>
+      debugExpressionEnter("StringLiteral", expression, typeContext);
 
-  void stringLiteralExit(DartType inferredType) =>
-      debugExpressionExit("StringLiteral", inferredType);
+  void stringLiteralExit(StringLiteral expression, DartType inferredType) =>
+      debugExpressionExit("StringLiteral", expression, inferredType);
 
-  bool variableGetEnter(DartType typeContext) =>
-      debugExpressionEnter("variableGet", typeContext);
+  bool variableGetEnter(VariableGet expression, DartType typeContext) =>
+      debugExpressionEnter("variableGet", expression, typeContext);
 
-  void variableGetExit(DartType inferredType) =>
-      debugExpressionExit("variableGet", inferredType);
+  void variableGetExit(VariableGet expression, DartType inferredType) =>
+      debugExpressionExit("variableGet", expression, inferredType);
 
-  bool variableSetEnter(DartType typeContext) =>
-      debugExpressionEnter("variableSet", typeContext);
+  bool variableSetEnter(VariableSet expression, DartType typeContext) =>
+      debugExpressionEnter("variableSet", expression, typeContext);
 
-  void variableSetExit(DartType inferredType) =>
-      debugExpressionExit("variableSet", inferredType);
+  void variableSetExit(VariableSet expression, DartType inferredType) =>
+      debugExpressionExit("variableSet", expression, inferredType);
 }