Add type inference for break and continue statements.

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 91 matching lines @@
   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);
 
+  void breakStatementEnter(BreakStatement statement) =>
+      debugStatementEnter('breakStatement', statement);
+
+  void breakStatementExit(BreakStatement statement) =>
+      debugStatementExit('breakStatement', statement);
+
   bool cascadeExpressionEnter(Let expression, DartType typeContext) =>
       debugExpressionEnter("cascade", expression, typeContext);
 
   void cascadeExpressionExit(Let expression, DartType inferredType) =>
       debugExpressionExit("cascade", expression, inferredType);
 
   bool conditionalExpressionEnter(
           ConditionalExpression expression, DartType typeContext) =>
       debugExpressionEnter("conditionalExpression", expression, typeContext);
 
   void conditionalExpressionExit(
           ConditionalExpression expression, DartType inferredType) =>
       debugExpressionExit("conditionalExpression", expression, inferredType);
 
   bool constructorInvocationEnter(
           InvocationExpression expression, DartType typeContext) =>
       debugExpressionEnter("constructorInvocation", expression, typeContext);
 
   void constructorInvocationExit(
           InvocationExpression expression, DartType inferredType) =>
       debugExpressionExit("constructorInvocation", expression, inferredType);
 
+  void continueSwitchStatementEnter(ContinueSwitchStatement statement) =>
+      debugStatementEnter('continueSwitchStatement', statement);
+
+  void continueSwitchStatementExit(ContinueSwitchStatement statement) =>
+      debugStatementExit('continueSwitchStatement', statement);
+
   void doStatementEnter(DoStatement statement) =>
       debugStatementEnter("doStatement", statement);
 
   void doStatementExit(DoStatement statement) =>
       debugStatementExit("doStatement", statement);
 
   bool doubleLiteralEnter(DoubleLiteral expression, DartType typeContext) =>
       debugExpressionEnter("doubleLiteral", expression, typeContext);
 
   void doubleLiteralExit(DoubleLiteral expression, DartType inferredType) =>
@@ skipping 243 matching lines @@
 
   void whileStatementExit(WhileStatement statement) =>
       debugStatementExit("whileStatement", statement);
 
   void yieldStatementEnter(YieldStatement statement) =>
       debugStatementEnter('yieldStatement', statement);
 
   void yieldStatementExit(YieldStatement statement) =>
       debugStatementExit('yieldStatement', statement);
 }