Perform type inference on constructor field initializer expressions.

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:front_end/src/fasta/type_inference/type_inference_engine.dart';
 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
@@ skipping 152 matching lines @@
 
   void dryRunExit(Expression expression) =>
       genericExpressionExit("dryRun", expression, null);
 
   void expressionStatementEnter(ExpressionStatement statement) =>
       genericStatementEnter('expressionStatement', statement);
 
   void expressionStatementExit(ExpressionStatement statement) =>
       genericStatementExit('expressionStatement', statement);
 
+  void fieldInitializerEnter(FieldInitializer initializer) =>
+      genericInitializerEnter("fieldInitializer", initializer);
+
+  void fieldInitializerExit(FieldInitializer initializer) =>
+      genericInitializerExit("fieldInitializer", initializer);
+
   void forInStatementEnter(ForInStatement statement) =>
       genericStatementEnter('forInStatement', statement);
 
   void forInStatementExit(ForInStatement statement) =>
       genericStatementExit('forInStatement', statement);
 
   void forStatementEnter(ForStatement statement) =>
       genericStatementEnter('forStatement', statement);
 
   void forStatementExit(ForStatement statement) =>
@@ skipping 68 matching lines @@
   void logicalExpressionExit(
           LogicalExpression expression, DartType inferredType) =>
       genericExpressionExit("logicalExpression", expression, inferredType);
 
   bool mapLiteralEnter(MapLiteral expression, DartType typeContext) =>
       genericExpressionEnter("mapLiteral", expression, typeContext);
 
   void mapLiteralExit(MapLiteral expression, DartType typeContext) =>
       genericExpressionExit("mapLiteral", expression, typeContext);
 
+  void methodInvocationBeforeArgs(Expression expression, bool isImplicitCall) {}
+
   bool methodInvocationEnter(Expression expression, DartType typeContext) =>
       genericExpressionEnter("methodInvocation", expression, typeContext);
 
-  void methodInvocationBeforeArgs(Expression expression, bool isImplicitCall) {}
-
   void methodInvocationExit(Expression expression, Arguments arguments,
           bool isImplicitCall, DartType inferredType) =>
       genericExpressionExit("methodInvocation", expression, inferredType);
 
   bool notEnter(Not expression, DartType typeContext) =>
       genericExpressionEnter("not", expression, typeContext);
 
   void notExit(Not expression, DartType inferredType) =>
       genericExpressionExit("not", expression, inferredType);
 
@@ skipping 147 matching lines @@
 
   void whileStatementExit(WhileStatement statement) =>
       genericStatementExit("whileStatement", statement);
 
   void yieldStatementEnter(YieldStatement statement) =>
       genericStatementEnter('yieldStatement', statement);
 
   void yieldStatementExit(YieldStatement statement) =>
       genericStatementExit('yieldStatement', statement);
 }