implement LabeledStatement and Break in kernel

pkg/compiler/lib/src/js_backend/mirrors_analysis.dart

 // Copyright (c) 2016, 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.
 
 library dart2js.mirrors_handler;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../diagnostics/diagnostic_listener.dart';
 import '../elements/elements.dart';
@@ skipping 64 matching lines @@
    *
    * During resolution, we have to resort to matching elements against the
    * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
    * yet.
    */
   bool _shouldIncludeElementDueToMirrors(Element element,
       {bool includedEnclosing}) {
     return includedEnclosing || _backend.requiredByMirrorSystem(element);
   }
 
-  /// Enqeue the constructor [ctor] if it is required for reflection.
+  /// Enqueue the constructor [ctor] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveConstructor(ConstructorElement constructor,
       {bool enclosingWasIncluded}) {
     if (_shouldIncludeElementDueToMirrors(constructor,
         includedEnclosing: enclosingWasIncluded)) {
       _logEnqueueReflectiveAction(constructor);
       ClassElement cls = constructor.declaration.enclosingClass;
       impactBuilder
           .registerTypeUse(new TypeUse.mirrorInstantiation(cls.rawType));
       impactBuilder
           .registerStaticUse(new StaticUse.foreignUse(constructor.declaration));
     }
   }
 
-  /// Enqeue the member [element] if it is required for reflection.
+  /// Enqueue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveMember(Element element, bool enclosingWasIncluded) {
     if (_shouldIncludeElementDueToMirrors(element,
         includedEnclosing: enclosingWasIncluded)) {
       _logEnqueueReflectiveAction(element);
       if (element.isTypedef) {
         TypedefElement typedef = element;
         typedef.ensureResolved(_resolution);
@@ skipping 11 matching lines @@
           DynamicUse dynamicUse = new DynamicUse(
               new Selector.setter(
                   new Name(element.name, element.library, isSetter: true)),
               null);
           impactBuilder.registerDynamicUse(dynamicUse);
         }
       }
     }
   }
 
-  /// Enqeue the member [element] if it is required for reflection.
+  /// Enqueue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveElementsInClass(
       ClassElement cls, Iterable<ClassEntity> recents,
       {bool enclosingWasIncluded}) {
     if (cls.library.isInternalLibrary || cls.isInjected) return;
     bool includeClass = _shouldIncludeElementDueToMirrors(cls,
         includedEnclosing: enclosingWasIncluded);
     if (includeClass) {
@@ skipping 11 matching lines @@
       cls.constructors.forEach((Element element) {
         _enqueueReflectiveConstructor(element,
             enclosingWasIncluded: includeClass);
       });
       cls.forEachClassMember((Member member) {
         _enqueueReflectiveMember(member.element, includeClass);
       });
     }
   }
 
-  /// Enqeue special classes that might not be visible by normal means or that
+  /// Enqueue special classes that might not be visible by normal means or that
   /// would not normally be enqueued:
   ///
   /// [Closure] is treated specially as it is the superclass of all closures.
   /// Although it is in an internal library, we mark it as reflectable. Note
   /// that none of its methods are reflectable, unless reflectable by
   /// inheritance.
   void _enqueueReflectiveSpecialClasses() {
     Iterable<ClassElement> classes = _backend.classesRequiredForReflection;
     for (ClassElement cls in classes) {
       if (_backend.referencedFromMirrorSystem(cls)) {
         _logEnqueueReflectiveAction(cls);
         cls.ensureResolved(_resolution);
         impactBuilder
             .registerTypeUse(new TypeUse.mirrorInstantiation(cls.rawType));
       }
     }
   }
 
-  /// Enqeue all local members of the library [lib] if they are required for
+  /// Enqueue all local members of the library [lib] if they are required for
   /// reflection.
   void _enqueueReflectiveElementsInLibrary(
       LibraryElement lib, Iterable<ClassEntity> recents) {
     bool includeLibrary =
         _shouldIncludeElementDueToMirrors(lib, includedEnclosing: false);
     lib.forEachLocalMember((Element member) {
       if (member.isInjected) return;
       if (member.isClass) {
         ClassElement cls = member;
         cls.ensureResolved(_resolution);
@@ skipping 48 matching lines @@
   /// usage through `MirrorsUsed`.
   // TODO(johnniwinther): Compute [WorldImpact] instead of enqueuing directly.
   void enqueueReflectiveStaticFields(Iterable<Element> elements) {
     if (hasEnqueuedReflectiveStaticFields) return;
     hasEnqueuedReflectiveStaticFields = true;
     for (Element element in elements) {
       _enqueueReflectiveMember(element, true);
     }
   }
 }