Add type inference for break and continue statements.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.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 file.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 153 matching lines @@
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.boolLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.boolClass.rawType : null;
     inferrer.listener.boolLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Concrete shadow object representing a break or continue statement in kernel
+/// form.
+class KernelBreakStatement extends BreakStatement implements KernelStatement {
+  KernelBreakStatement(LabeledStatement target) : super(target);
+
+  @override
+  void _inferStatement(KernelTypeInferrer inferrer) {
+    inferrer.listener.breakStatementEnter(this);
+    // No inference needs to be done.
+    inferrer.listener.breakStatementExit(this);
+  }
+}
+
 /// Concrete shadow object representing a cascade expression.
 ///
 /// A cascade expression of the form `a..b()..c()` is represented as the kernel
 /// expression:
 ///
 ///     let v = a in
 ///         let _ = v.b() in
 ///             let _ = v.c() in
 ///                 v
 ///
@@ skipping 309 matching lines @@
         typeNeeded,
         fileOffset,
         _initialTarget.function.functionType,
         computeConstructorReturnType(_initialTarget),
         arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Concrete shadow object representing a continue statement from a switch
+/// statement, in kernel form.
+class KernelContinueSwitchStatement extends ContinueSwitchStatement
+    implements KernelStatement {
+  KernelContinueSwitchStatement(SwitchCase target) : super(target);
+
+  @override
+  void _inferStatement(KernelTypeInferrer inferrer) {
+    inferrer.listener.continueSwitchStatementEnter(this);
+    // No inference needs to be done.
+    inferrer.listener.continueSwitchStatementExit(this);
+  }
+}
+
 /// Concrete implementation of [DependencyCollector] specialized to work with
 /// kernel objects.
 class KernelDependencyCollector extends DependencyCollectorImpl {
   @override
   void collectDependencies(Expression expression) {
     if (expression is KernelExpression) {
       // Use polymorphic dispatch on [KernelExpression] to perform whatever kind
       // of type inference is correct for this kind of statement.
       // TODO(paulberry): experiment to see if dynamic dispatch would be better,
       // so that the type hierarchy will be simpler (which may speed up "is"
@@ skipping 1819 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }