Add statement hooks to TypeInferenceListener.

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

 // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
 // 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';
 
 /// 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(
+  void debugExpressionExit(
       String expressionType, Expression expression, DartType inferredType) {}
+
+  void debugStatementEnter(String statementType, Statement statement) {}
+
+  void debugStatementExit(String statementType, Statement statement) {}
 }
 
 /// 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(
+  void debugExpressionExit(
       String expressionType, Expression expression, DartType inferredType) {
     print('Exit $expressionType($expression) (type=$inferredType)');
   }
+
+  void debugStatementEnter(String statementType, Statement statement) {
+    print('Enter $statementType($statement)');
+  }
+
+  void debugStatementExit(String statementType, Statement statement) {
+    print('Exit $statementType($statement)');
+  }
 }
 
 /// Callback interface used by [TypeInferrer] to report the results of type
 /// inference to a client.
 ///
 /// The interface is structured as a set of enter/exit methods.  The enter
 /// methods are called as the inferrer recurses down through the AST, and the
 /// exit methods are called on the way back up.  The enter methods take a
 /// [DartType] argument representing the downwards inference context, and return
 /// a bool indicating whether the TypeInferenceListener needs to know the final
 /// inferred type; the exit methods take [DartType] argument representing the
 /// final inferred type.
 ///
 /// The default implementation (in this base class) does nothing, however it can
 /// 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);
 
   void asExpressionExit(AsExpression expression, DartType inferredType) =>
       debugExpressionExit("asExpression", expression, inferredType);
 
+  void blockEnter(Block statement) => debugStatementEnter('block', statement);
+
+  void blockExit(Block statement) => debugStatementExit('block', statement);
+
   bool boolLiteralEnter(BoolLiteral expression, DartType typeContext) =>
       debugExpressionEnter("boolLiteral", expression, typeContext);
 
   void boolLiteralExit(BoolLiteral expression, DartType inferredType) =>
       debugExpressionExit("boolLiteral", expression, inferredType);
 
   bool conditionalExpressionEnter(
           ConditionalExpression expression, DartType typeContext) =>
       debugExpressionEnter("conditionalExpression", expression, typeContext);
 
   void conditionalExpressionExit(
           ConditionalExpression expression, DartType inferredType) =>
       debugExpressionExit("conditionalExpression", expression, inferredType);
 
   bool constructorInvocationEnter(
           ConstructorInvocation expression, DartType typeContext) =>
       debugExpressionEnter("constructorInvocation", expression, typeContext);
 
   void constructorInvocationExit(
           ConstructorInvocation expression, DartType inferredType) =>
       debugExpressionExit("constructorInvocation", expression, inferredType);
 
   bool doubleLiteralEnter(DoubleLiteral expression, DartType typeContext) =>
       debugExpressionEnter("doubleLiteral", expression, typeContext);
 
   void doubleLiteralExit(DoubleLiteral expression, DartType inferredType) =>
       debugExpressionExit("doubleLiteral", expression, inferredType);
 
+  void expressionStatementEnter(ExpressionStatement statement) =>
+      debugStatementEnter('expressionStatement', statement);
+
+  void expressionStatementExit(ExpressionStatement statement) =>
+      debugStatementExit('expressionStatement', statement);
+
+  void functionDeclarationEnter(FunctionDeclaration statement) =>
+      debugStatementEnter('functionDeclaration', statement);
+
+  void functionDeclarationExit(FunctionDeclaration statement) =>
+      debugStatementExit('functionDeclaration', statement);
+
   bool functionExpressionEnter(
           FunctionExpression expression, DartType typeContext) =>
       debugExpressionEnter("functionExpression", expression, typeContext);
 
   void functionExpressionExit(
           FunctionExpression expression, DartType inferredType) =>
       debugExpressionExit("functionExpression", expression, inferredType);
 
+  void ifStatementEnter(IfStatement statement) =>
+      debugStatementEnter('ifStatement', statement);
+
+  void ifStatementExit(IfStatement statement) =>
+      debugStatementExit('ifStatement', statement);
+
   bool intLiteralEnter(IntLiteral expression, DartType typeContext) =>
       debugExpressionEnter("intLiteral", expression, typeContext);
 
   void intLiteralExit(IntLiteral expression, DartType inferredType) =>
       debugExpressionExit("intLiteral", expression, inferredType);
 
   bool isExpressionEnter(IsExpression expression, DartType typeContext) =>
       debugExpressionEnter("isExpression", expression, typeContext);
 
   void isExpressionExit(IsExpression expression, DartType inferredType) =>
@@ skipping 18 matching lines @@
   void methodInvocationExit(
           MethodInvocation expression, DartType inferredType) =>
       debugExpressionExit("methodInvocation", expression, inferredType);
 
   bool nullLiteralEnter(NullLiteral expression, DartType typeContext) =>
       debugExpressionEnter("nullLiteral", expression, typeContext);
 
   void nullLiteralExit(NullLiteral expression, DartType inferredType) =>
       debugExpressionExit("nullLiteral", expression, inferredType);
 
+  void returnStatementEnter(ReturnStatement statement) =>
+      debugStatementEnter('returnStatement', statement);
+
+  void returnStatementExit(ReturnStatement statement) =>
+      debugStatementExit('returnStatement', statement);
+
   bool staticGetEnter(StaticGet expression, DartType typeContext) =>
       debugExpressionEnter("staticGet", expression, typeContext);
 
   void staticGetExit(StaticGet expression, DartType inferredType) =>
       debugExpressionExit("staticGet", expression, inferredType);
 
   bool staticInvocationEnter(
           StaticInvocation expression, DartType typeContext) =>
       debugExpressionEnter("staticInvocation", expression, typeContext);
 
   void staticInvocationExit(
           StaticInvocation expression, DartType inferredType) =>
       debugExpressionExit("staticInvocation", expression, inferredType);
 
   bool stringConcatenationEnter(
           StringConcatenation expression, DartType typeContext) =>
       debugExpressionEnter("stringConcatenation", expression, typeContext);
 
   void stringConcatenationExit(
           StringConcatenation expression, DartType inferredType) =>
       debugExpressionExit("stringConcatenation", expression, inferredType);
 
   bool stringLiteralEnter(StringLiteral expression, DartType typeContext) =>
       debugExpressionEnter("StringLiteral", expression, typeContext);
 
   void stringLiteralExit(StringLiteral expression, DartType inferredType) =>
       debugExpressionExit("StringLiteral", expression, inferredType);
 
+  void variableDeclarationEnter(VariableDeclaration statement) =>
+      debugStatementEnter('variableDeclaration', statement);
+
+  void variableDeclarationExit(VariableDeclaration statement) =>
+      debugStatementExit('variableDeclaration', statement);
+
   bool variableGetEnter(VariableGet expression, DartType typeContext) =>
       debugExpressionEnter("variableGet", expression, typeContext);
 
   void variableGetExit(VariableGet expression, DartType inferredType) =>
       debugExpressionExit("variableGet", expression, inferredType);
 
   bool variableSetEnter(VariableSet expression, DartType typeContext) =>
       debugExpressionEnter("variableSet", expression, typeContext);
 
   void variableSetExit(VariableSet expression, DartType inferredType) =>
       debugExpressionExit("variableSet", expression, inferredType);
 }