dartfmt pkg/compiler

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

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 89 matching lines @@
   void markAsInlinable(FunctionElement element, {bool insideLoop}) {
     int oldDecision = _cachedDecisions[element];
 
     if (oldDecision == null) {
       oldDecision = _unknown;
     }
 
     if (insideLoop) {
       switch (oldDecision) {
         case _mustNotInline:
-          throw new SpannableAssertionFailure(element,
+          throw new SpannableAssertionFailure(
+              element,
               "Can't mark a function as non-inlinable and inlinable at the "
               "same time.");
 
         case _unknown:
           // We know that it can be inlined in a loop, but don't know about the
           // non-loop case yet.
           _cachedDecisions[element] = _canInlineInLoopMayInlineOutside;
           break;
 
         case _mayInlineInLoopMustNotOutside:
           _cachedDecisions[element] = _canInlineInLoopMustNotOutside;
           break;
 
         case _canInlineInLoopMustNotOutside:
         case _canInlineInLoopMayInlineOutside:
         case _canInline:
         case _mustInline:
           // Do nothing.
           break;
       }
     } else {
       switch (oldDecision) {
         case _mustNotInline:
         case _mayInlineInLoopMustNotOutside:
         case _canInlineInLoopMustNotOutside:
-          throw new SpannableAssertionFailure(element,
+          throw new SpannableAssertionFailure(
+              element,
               "Can't mark a function as non-inlinable and inlinable at the "
               "same time.");
 
         case _unknown:
         case _canInlineInLoopMayInlineOutside:
           _cachedDecisions[element] = _canInline;
           break;
 
         case _canInline:
         case _mustInline:
           // Do nothing.
           break;
-
       }
     }
   }
 
   void markAsNonInlinable(FunctionElement element, {bool insideLoop: true}) {
     int oldDecision = _cachedDecisions[element];
 
     if (oldDecision == null) {
       oldDecision = _unknown;
     }
 
     if (insideLoop) {
       switch (oldDecision) {
         case _canInlineInLoopMustNotOutside:
         case _canInlineInLoopMayInlineOutside:
         case _canInline:
         case _mustInline:
-          throw new SpannableAssertionFailure(element,
+          throw new SpannableAssertionFailure(
+              element,
               "Can't mark a function as non-inlinable and inlinable at the "
               "same time.");
 
         case _mayInlineInLoopMustNotOutside:
         case _unknown:
           _cachedDecisions[element] = _mustNotInline;
           break;
 
         case _mustNotInline:
           // Do nothing.
           break;
       }
     } else {
       switch (oldDecision) {
         case _canInline:
         case _mustInline:
-          throw new SpannableAssertionFailure(element,
+          throw new SpannableAssertionFailure(
+              element,
               "Can't mark a function as non-inlinable and inlinable at the "
               "same time.");
 
         case _unknown:
           // We can't inline outside a loop, but we might still be allowed to do
           // so outside.
           _cachedDecisions[element] = _mayInlineInLoopMustNotOutside;
           break;
 
         case _canInlineInLoopMayInlineOutside:
@@ skipping 13 matching lines @@
   }
 
   void markAsMustInline(FunctionElement element) {
     _cachedDecisions[element] = _mustInline;
   }
 }
 
 enum SyntheticConstantKind {
   DUMMY_INTERCEPTOR,
   EMPTY_VALUE,
-  TYPEVARIABLE_REFERENCE,  // Reference to a type in reflection data.
+  TYPEVARIABLE_REFERENCE, // Reference to a type in reflection data.
   NAME
 }
 
 class JavaScriptBackend extends Backend {
   String get patchVersion => emitter.patchVersion;
 
   bool get supportsReflection => emitter.emitter.supportsReflection;
 
   final Annotations annotations;
 
-
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> get classesRequiredForReflection {
     // TODO(herhut): Clean this up when classes needed for rti are tracked.
     return [helpers.closureClass, helpers.jsIndexableClass];
   }
 
   FunctionCompiler functionCompiler;
 
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
   }
 
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   /// If [true], the compiler will emit code that logs whenever a method is
   /// called. When TRACE_METHOD is 'console' this will be logged
   /// directly in the JavaScript console. When TRACE_METHOD is 'post' the
   /// information will be sent to a server via a POST request.
   static const String TRACE_METHOD = const String.fromEnvironment('traceCalls');
   static const bool TRACE_CALLS =
-    TRACE_METHOD == 'post' || TRACE_METHOD == 'console';
+      TRACE_METHOD == 'post' || TRACE_METHOD == 'console';
   Element traceHelper;
 
   TypeMask get stringType => compiler.typesTask.stringType;
   TypeMask get doubleType => compiler.typesTask.doubleType;
   TypeMask get intType => compiler.typesTask.intType;
   TypeMask get uint32Type => compiler.typesTask.uint32Type;
   TypeMask get uint31Type => compiler.typesTask.uint31Type;
   TypeMask get positiveIntType => compiler.typesTask.positiveIntType;
   TypeMask get numType => compiler.typesTask.numType;
   TypeMask get boolType => compiler.typesTask.boolType;
   TypeMask get dynamicType => compiler.typesTask.dynamicType;
   TypeMask get nullType => compiler.typesTask.nullType;
   TypeMask get emptyType => const TypeMask.nonNullEmpty();
 
   TypeMask _indexablePrimitiveTypeCache;
   TypeMask get indexablePrimitiveType {
     if (_indexablePrimitiveTypeCache == null) {
-      _indexablePrimitiveTypeCache = new TypeMask.nonNullSubtype(
-          helpers.jsIndexableClass, compiler.world);
+      _indexablePrimitiveTypeCache =
+          new TypeMask.nonNullSubtype(helpers.jsIndexableClass, compiler.world);
     }
     return _indexablePrimitiveTypeCache;
   }
 
   TypeMask _readableArrayTypeCache;
   TypeMask get readableArrayType {
     if (_readableArrayTypeCache == null) {
-      _readableArrayTypeCache = new TypeMask.nonNullSubclass(
-          helpers.jsArrayClass, compiler.world);
+      _readableArrayTypeCache =
+          new TypeMask.nonNullSubclass(helpers.jsArrayClass, compiler.world);
     }
     return _readableArrayTypeCache;
   }
 
   TypeMask _mutableArrayTypeCache;
   TypeMask get mutableArrayType {
     if (_mutableArrayTypeCache == null) {
       _mutableArrayTypeCache = new TypeMask.nonNullSubclass(
           helpers.jsMutableArrayClass, compiler.world);
     }
     return _mutableArrayTypeCache;
   }
 
   TypeMask _fixedArrayTypeCache;
   TypeMask get fixedArrayType {
     if (_fixedArrayTypeCache == null) {
-      _fixedArrayTypeCache = new TypeMask.nonNullExact(
-          helpers.jsFixedArrayClass, compiler.world);
+      _fixedArrayTypeCache =
+          new TypeMask.nonNullExact(helpers.jsFixedArrayClass, compiler.world);
     }
     return _fixedArrayTypeCache;
   }
 
   TypeMask _extendableArrayTypeCache;
   TypeMask get extendableArrayType {
     if (_extendableArrayTypeCache == null) {
       _extendableArrayTypeCache = new TypeMask.nonNullExact(
           helpers.jsExtendableArrayClass, compiler.world);
     }
     return _extendableArrayTypeCache;
   }
 
   TypeMask _unmodifiableArrayTypeCache;
   TypeMask get unmodifiableArrayType {
     if (_unmodifiableArrayTypeCache == null) {
       _unmodifiableArrayTypeCache = new TypeMask.nonNullExact(
           helpers.jsUnmodifiableArrayClass, compiler.world);
     }
     return _fixedArrayTypeCache;
   }
 
   TypeMask _nonNullTypeCache;
   TypeMask get nonNullType {
     if (_nonNullTypeCache == null) {
-      _nonNullTypeCache =
-          compiler.typesTask.dynamicType.nonNullable();
+      _nonNullTypeCache = compiler.typesTask.dynamicType.nonNullable();
     }
     return _nonNullTypeCache;
   }
 
   /// Maps special classes to their implementation (JSXxx) class.
   Map<ClassElement, ClassElement> implementationClasses;
 
   bool needToInitializeIsolateAffinityTag = false;
   bool needToInitializeDispatchProperty = false;
 
@@ skipping 125 matching lines @@
   final Set<String> symbolsUsed = new Set<String>();
 
   /// List of elements that the backend may use.
   final Set<Element> helpersUsed = new Set<Element>();
 
   /// All the checked mode helpers.
   static const checkedModeHelpers = CheckedModeHelper.helpers;
 
   // Checked mode helpers indexed by name.
   Map<String, CheckedModeHelper> checkedModeHelperByName =
-      new Map<String, CheckedModeHelper>.fromIterable(
-          checkedModeHelpers,
+      new Map<String, CheckedModeHelper>.fromIterable(checkedModeHelpers,
           key: (helper) => helper.name);
 
   TypeVariableHandler typeVariableHandler;
 
   /// Number of methods compiled before considering reflection.
   int preMirrorsMethodCount = 0;
 
   /// Resolution and codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsAnalysis customElementsAnalysis;
@@ skipping 18 matching lines @@
   SourceInformationStrategy sourceInformationStrategy;
 
   JavaScriptBackendSerialization serialization;
 
   final NativeData nativeData = new NativeData();
 
   final BackendHelpers helpers;
   final BackendImpacts impacts;
 
   JavaScriptBackend(Compiler compiler,
-                    {bool generateSourceMap: true,
-                     bool useStartupEmitter: false,
-                     bool useNewSourceInfo: false})
+      {bool generateSourceMap: true,
+      bool useStartupEmitter: false,
+      bool useNewSourceInfo: false})
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<jsAst.Name, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new _RuntimeTypes(compiler),
         rtiEncoder = new _RuntimeTypesEncoder(compiler),
         specializedGetInterceptors = new Map<jsAst.Name, Set<ClassElement>>(),
         annotations = new Annotations(compiler),
-        this.sourceInformationStrategy =
-            generateSourceMap
-                ? (useNewSourceInfo
-                     ? new PositionSourceInformationStrategy()
-                     : const StartEndSourceInformationStrategy())
-                : const JavaScriptSourceInformationStrategy(),
+        this.sourceInformationStrategy = generateSourceMap
+            ? (useNewSourceInfo
+                ? new PositionSourceInformationStrategy()
+                : const StartEndSourceInformationStrategy())
+            : const JavaScriptSourceInformationStrategy(),
         helpers = new BackendHelpers(compiler),
         impacts = new BackendImpacts(compiler),
         super(compiler) {
     emitter = new CodeEmitterTask(
         compiler, namer, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     jsInteropAnalysis = new JsInteropAnalysis(this);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = compiler.options.useCpsIr
-         ? new CpsFunctionCompiler(
-             compiler, this, sourceInformationStrategy)
-         : new SsaFunctionCompiler(this, sourceInformationStrategy);
+        ? new CpsFunctionCompiler(compiler, this, sourceInformationStrategy)
+        : new SsaFunctionCompiler(this, sourceInformationStrategy);
     serialization = new JavaScriptBackendSerialization(this);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
   Resolution get resolution => compiler.resolution;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   MethodElement resolveExternalFunction(MethodElement element) {
     if (isForeign(element)) {
       return element;
     }
-    if (isJsInterop(element))  {
+    if (isJsInterop(element)) {
       if (element.memberName == const PublicName('[]') ||
           element.memberName == const PublicName('[]=')) {
-        reporter.reportErrorMessage(element,
-            MessageKind.JS_INTEROP_INDEX_NOT_SUPPORTED);
+        reporter.reportErrorMessage(
+            element, MessageKind.JS_INTEROP_INDEX_NOT_SUPPORTED);
       }
       return element;
     }
     return patchResolverTask.measure(() {
       return patchResolverTask.resolveExternalFunction(element);
     });
   }
 
   bool isForeign(Element element) => element.library == helpers.foreignLibrary;
 
   bool isBackendLibrary(LibraryElement library) {
     return library == helpers.interceptorsLibrary ||
-           library == helpers.jsHelperLibrary;
+        library == helpers.jsHelperLibrary;
   }
 
   static Namer determineNamer(Compiler compiler) {
-    return compiler.options.enableMinification ?
-        compiler.options.useFrequencyNamer ?
-            new FrequencyBasedNamer(compiler) :
-            new MinifyNamer(compiler) :
-        new Namer(compiler);
+    return compiler.options.enableMinification
+        ? compiler.options.useFrequencyNamer
+            ? new FrequencyBasedNamer(compiler)
+            : new MinifyNamer(compiler)
+        : new Namer(compiler);
   }
 
   /// The backend must *always* call this method when enqueuing an
   /// element. Calls done by the backend are not seen by global
   /// optimizations, so they would make these optimizations unsound.
   /// Therefore we need to collect the list of helpers the backend may
   /// use.
   // TODO(johnniwinther): Replace this with a more precise modelling; type
   // inference of these elements is disabled.
   Element registerBackendUse(Element element) {
     if (element == null) return null;
     assert(invariant(element, _isValidBackendUse(element),
         message: "Backend use of $element is not allowed."));
     helpersUsed.add(element.declaration);
     if (element.isClass && element.isPatched) {
       // Both declaration and implementation may declare fields, so we
       // add both to the list of helpers.
       helpersUsed.add(element.implementation);
     }
     return element;
   }
 
   bool _isValidBackendUse(Element element) {
-    assert(invariant(element, element.isDeclaration,
-        message: ""));
+    assert(invariant(element, element.isDeclaration, message: ""));
     if (element == helpers.streamIteratorConstructor ||
         element == helpers.compiler.symbolConstructor ||
         element == helpers.compiler.symbolValidatedConstructor ||
         element == helpers.syncCompleterConstructor ||
         element == coreClasses.symbolClass ||
         element == helpers.objectNoSuchMethod) {
       // TODO(johnniwinther): These are valid but we could be more precise.
       return true;
     } else if (element.implementationLibrary.isPatch ||
-               // Needed to detect deserialized injected elements, that is
-               // element declared in patch files.
-               (element.library.isPlatformLibrary &&
-                element.sourcePosition.uri.path.contains(
-                    '_internal/js_runtime/lib/')) ||
-               element.library == helpers.jsHelperLibrary ||
-               element.library == helpers.interceptorsLibrary ||
-               element.library == helpers.isolateHelperLibrary) {
+        // Needed to detect deserialized injected elements, that is
+        // element declared in patch files.
+        (element.library.isPlatformLibrary &&
+            element.sourcePosition.uri.path
+                .contains('_internal/js_runtime/lib/')) ||
+        element.library == helpers.jsHelperLibrary ||
+        element.library == helpers.interceptorsLibrary ||
+        element.library == helpers.isolateHelperLibrary) {
       // TODO(johnniwinther): We should be more precise about these.
       return true;
     } else if (element == coreClasses.listClass ||
-               element == helpers.mapLiteralClass ||
-               element == coreClasses.functionClass ||
-               element == coreClasses.stringClass) {
+        element == helpers.mapLiteralClass ||
+        element == coreClasses.functionClass ||
+        element == coreClasses.stringClass) {
       // TODO(johnniwinther): Avoid these.
       return true;
     }
     return false;
   }
 
   bool usedByBackend(Element element) {
-    if (element.isParameter
-        || element.isInitializingFormal
-        || element.isField) {
+    if (element.isParameter ||
+        element.isInitializingFormal ||
+        element.isField) {
       if (usedByBackend(element.enclosingElement)) return true;
     }
     return helpersUsed.contains(element.declaration);
   }
 
   bool invokedReflectively(Element element) {
     if (element.isParameter || element.isInitializingFormal) {
       ParameterElement parameter = element;
       if (invokedReflectively(parameter.functionDeclaration)) return true;
     }
 
     if (element.isField) {
-      if (Elements.isStaticOrTopLevel(element)
-          && (element.isFinal || element.isConst)) {
+      if (Elements.isStaticOrTopLevel(element) &&
+          (element.isFinal || element.isConst)) {
         return false;
       }
     }
 
     return isAccessibleByReflection(element.declaration);
   }
 
   bool canBeUsedForGlobalOptimizations(Element element) {
     return !usedByBackend(element) && !invokedReflectively(element);
   }
@@ skipping 88 matching lines @@
   bool isInterceptedSelector(Selector selector) {
     return interceptedElements[selector.name] != null;
   }
 
   /**
    * Returns `true` iff [selector] matches an element defined in a class mixed
    * into an intercepted class.  These selectors are not eligible for the 'dummy
    * explicit receiver' optimization.
    */
   bool isInterceptedMixinSelector(Selector selector, TypeMask mask) {
-    Set<Element> elements = interceptedMixinElements.putIfAbsent(
-        selector.name,
-        () {
-          Set<Element> elements = interceptedElements[selector.name];
-          if (elements == null) return null;
-          return elements
-              .where((element) =>
-                  classesMixedIntoInterceptedClasses.contains(
-                      element.enclosingClass))
-              .toSet();
-        });
+    Set<Element> elements =
+        interceptedMixinElements.putIfAbsent(selector.name, () {
+      Set<Element> elements = interceptedElements[selector.name];
+      if (elements == null) return null;
+      return elements
+          .where((element) => classesMixedIntoInterceptedClasses
+              .contains(element.enclosingClass))
+          .toSet();
+    });
 
     if (elements == null) return false;
     if (elements.isEmpty) return false;
     return elements.any((element) {
       return selector.applies(element, compiler.world) &&
-             (mask == null || mask.canHit(element, selector, compiler.world));
+          (mask == null || mask.canHit(element, selector, compiler.world));
     });
   }
 
   /// True if the given class is an internal class used for type inference
   /// and never exists at runtime.
   bool isCompileTimeOnlyClass(ClassElement class_) {
     return class_ == helpers.jsPositiveIntClass ||
-           class_ == helpers.jsUInt32Class ||
-           class_ == helpers.jsUInt31Class ||
-           class_ == helpers.jsFixedArrayClass ||
-           class_ == helpers.jsUnmodifiableArrayClass ||
-           class_ == helpers.jsMutableArrayClass ||
-           class_ == helpers.jsExtendableArrayClass;
+        class_ == helpers.jsUInt32Class ||
+        class_ == helpers.jsUInt31Class ||
+        class_ == helpers.jsFixedArrayClass ||
+        class_ == helpers.jsUnmodifiableArrayClass ||
+        class_ == helpers.jsMutableArrayClass ||
+        class_ == helpers.jsExtendableArrayClass;
   }
 
   /// Maps compile-time classes to their runtime class.  The runtime class is
   /// always a superclass or the class itself.
   ClassElement getRuntimeClass(ClassElement class_) {
     if (class_.isSubclassOf(helpers.jsIntClass)) return helpers.jsIntClass;
     if (class_.isSubclassOf(helpers.jsArrayClass)) return helpers.jsArrayClass;
     return class_;
   }
 
   final Map<String, Set<ClassElement>> interceptedClassesCache =
       new Map<String, Set<ClassElement>>();
   final Set<ClassElement> _noClasses = new Set<ClassElement>();
 
   /// Returns a set of interceptor classes that contain a member named [name]
   ///
   /// Returns an empty set if there is no class. Do not modify the returned set.
   Set<ClassElement> getInterceptedClassesOn(String name) {
     Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return _noClasses;
     return interceptedClassesCache.putIfAbsent(name, () {
       // Populate the cache by running through all the elements and
       // determine if the given selector applies to them.
       Set<ClassElement> result = new Set<ClassElement>();
       for (Element element in intercepted) {
         ClassElement classElement = element.enclosingClass;
         if (isCompileTimeOnlyClass(classElement)) continue;
-        if (isNativeOrExtendsNative(classElement)
-            || interceptedClasses.contains(classElement)) {
+        if (isNativeOrExtendsNative(classElement) ||
+            interceptedClasses.contains(classElement)) {
           result.add(classElement);
         }
         if (classesMixedIntoInterceptedClasses.contains(classElement)) {
           Set<ClassElement> nativeSubclasses =
               nativeSubclassesOfMixin(classElement);
           if (nativeSubclasses != null) result.addAll(nativeSubclasses);
         }
       }
       return result;
     });
   }
 
   Set<ClassElement> nativeSubclassesOfMixin(ClassElement mixin) {
     ClassWorld classWorld = compiler.world;
     Iterable<MixinApplicationElement> uses = classWorld.mixinUsesOf(mixin);
     Set<ClassElement> result = null;
     for (MixinApplicationElement use in uses) {
       classWorld.forEachStrictSubclassOf(use, (ClassElement subclass) {
         if (isNativeOrExtendsNative(subclass)) {
           if (result == null) result = new Set<ClassElement>();
           result.add(subclass);
         }
       });
     }
     return result;
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
-    return specialOperatorEqClasses.contains(
-        operatorEqfunction.enclosingClass);
+    return specialOperatorEqClasses.contains(operatorEqfunction.enclosingClass);
   }
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(resolution);
     coreClasses.objectClass.forEachMember((_, Element member) {
       if (member.isGenerativeConstructor) return;
       Element interceptorMember = interceptorClass.lookupMember(member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
-      assert(invariant(
-          interceptorMember,
+      assert(invariant(interceptorMember,
           interceptorMember.enclosingClass == interceptorClass,
           message:
-            "Member ${member.name} not overridden in ${interceptorClass}. "
-            "Found $interceptorMember from "
-            "${interceptorMember.enclosingClass}."));
+              "Member ${member.name} not overridden in ${interceptorClass}. "
+              "Found $interceptorMember from "
+              "${interceptorMember.enclosingClass}."));
     });
   }
 
   void addInterceptorsForNativeClassMembers(
       ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Identifiers.call) {
           reporter.reportErrorMessage(
-              member,
-              MessageKind.CALL_NOT_SUPPORTED_ON_NATIVE_CLASS);
+              member, MessageKind.CALL_NOT_SUPPORTED_ON_NATIVE_CLASS);
           return;
         }
         if (member.isSynthesized) return;
         // All methods on [Object] are shadowed by [Interceptor].
         if (classElement == coreClasses.objectClass) return;
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
-      },
-      includeSuperAndInjectedMembers: true);
+      }, includeSuperAndInjectedMembers: true);
 
       // Walk superclass chain to find mixins.
       for (; cls != null; cls = cls.superclass) {
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
           classesMixedIntoInterceptedClasses.add(mixinApplication.mixin);
         }
       }
     }
   }
 
-  void addInterceptors(ClassElement cls,
-                       Enqueuer enqueuer,
-                       Registry registry) {
+  void addInterceptors(ClassElement cls, Enqueuer enqueuer, Registry registry) {
     if (enqueuer.isResolutionQueue) {
       _interceptedClasses.add(helpers.jsInterceptorClass);
       _interceptedClasses.add(cls);
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
-          // All methods on [Object] are shadowed by [Interceptor].
-          if (classElement == coreClasses.objectClass) return;
-          Set<Element> set = interceptedElements.putIfAbsent(
-              member.name, () => new Set<Element>());
-          set.add(member);
-        },
-        includeSuperAndInjectedMembers: true);
+        // All methods on [Object] are shadowed by [Interceptor].
+        if (classElement == coreClasses.objectClass) return;
+        Set<Element> set = interceptedElements.putIfAbsent(
+            member.name, () => new Set<Element>());
+        set.add(member);
+      }, includeSuperAndInjectedMembers: true);
     }
     enqueueClass(enqueuer, cls, registry);
   }
 
   Set<ClassElement> get interceptedClasses {
     assert(compiler.enqueuer.resolution.queueIsClosed);
     return _interceptedClasses;
   }
 
   void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
     jsAst.Name name = namer.nameForGetInterceptor(classes);
     if (classes.contains(helpers.jsInterceptorClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
       specializedGetInterceptors[name] = interceptedClasses;
     } else {
       specializedGetInterceptors[name] = classes;
     }
   }
 
   void registerCompileTimeConstant(ConstantValue constant, Registry registry) {
     registerCompileTimeConstantInternal(constant, registry);
 
-    if (!registry.isForResolution &&
-        lookupMapAnalysis.isLookupMap(constant)) {
+    if (!registry.isForResolution && lookupMapAnalysis.isLookupMap(constant)) {
       // Note: internally, this registration will temporarily remove the
       // constant dependencies and add them later on-demand.
       lookupMapAnalysis.registerLookupMapReference(constant);
     }
 
     for (ConstantValue dependency in constant.getDependencies()) {
       registerCompileTimeConstant(dependency, registry);
     }
   }
 
   void addCompileTimeConstantForEmission(ConstantValue constant) {
     constants.addCompileTimeConstantForEmission(constant);
   }
 
-  void registerCompileTimeConstantInternal(ConstantValue constant,
-                                           Registry registry) {
+  void registerCompileTimeConstantInternal(
+      ConstantValue constant, Registry registry) {
     DartType type = constant.getType(compiler.coreTypes);
     registerInstantiatedConstantType(type, registry);
 
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
       registry.registerStaticUse(new StaticUse.staticTearOff(function.element));
     } else if (constant.isInterceptor) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstantValue interceptor = constant;
       registerInstantiatedConstantType(interceptor.dispatchedType, registry);
     } else if (constant.isType) {
       enqueueInResolution(helpers.createRuntimeType, registry);
       registry.registerInstantiation(typeImplementation.rawType);
     }
     lookupMapAnalysis.registerConstantKey(constant);
   }
 
   void registerInstantiatedConstantType(DartType type, Registry registry) {
     DartType instantiatedType =
         type.isFunctionType ? coreTypes.functionType : type;
     if (type is InterfaceType) {
       registry.registerInstantiation(instantiatedType);
       if (!type.treatAsRaw && classNeedsRti(type.element)) {
-        registry.registerStaticUse(
-            new StaticUse.staticInvoke(
-                // TODO(johnniwinther): Find the right [CallStructure].
-                helpers.setRuntimeTypeInfo, null));
+        registry.registerStaticUse(new StaticUse.staticInvoke(
+            // TODO(johnniwinther): Find the right [CallStructure].
+            helpers.setRuntimeTypeInfo,
+            null));
       }
       if (type.element == typeImplementation) {
         // If we use a type literal in a constant, the compile time
         // constant emitter will generate a call to the createRuntimeType
         // helper so we register a use of that.
-        registry.registerStaticUse(
-            new StaticUse.staticInvoke(
-                // TODO(johnniwinther): Find the right [CallStructure].
+        registry.registerStaticUse(new StaticUse.staticInvoke(
+            // TODO(johnniwinther): Find the right [CallStructure].
 
-                helpers.createRuntimeType, null));
+            helpers.createRuntimeType,
+            null));
       }
     }
   }
 
   void registerMetadataConstant(MetadataAnnotation metadata,
-                                Element annotatedElement,
-                                Registry registry) {
+      Element annotatedElement, Registry registry) {
     assert(registry.isForResolution);
     ConstantValue constant = constants.getConstantValueForMetadata(metadata);
     registerCompileTimeConstant(constant, registry);
     metadataConstants.add(new Dependency(constant, annotatedElement));
   }
 
-  void registerInstantiatedClass(ClassElement cls,
-                                 Enqueuer enqueuer,
-                                 Registry registry) {
+  void registerInstantiatedClass(
+      ClassElement cls, Enqueuer enqueuer, Registry registry) {
     _processClass(cls, enqueuer, registry);
   }
 
-  void registerImplementedClass(ClassElement cls,
-                                Enqueuer enqueuer,
-                                Registry registry) {
+  void registerImplementedClass(
+      ClassElement cls, Enqueuer enqueuer, Registry registry) {
     _processClass(cls, enqueuer, registry);
   }
 
-  void _processClass(ClassElement cls,
-                     Enqueuer enqueuer,
-                     Registry registry) {
+  void _processClass(ClassElement cls, Enqueuer enqueuer, Registry registry) {
     if (!cls.typeVariables.isEmpty) {
-      typeVariableHandler.registerClassWithTypeVariables(cls, enqueuer,
-                                                         registry);
+      typeVariableHandler.registerClassWithTypeVariables(
+          cls, enqueuer, registry);
     }
 
     // Register any helper that will be needed by the backend.
     if (enqueuer.isResolutionQueue) {
       if (cls == coreClasses.intClass ||
           cls == coreClasses.doubleClass ||
           cls == coreClasses.numClass) {
         // The backend will try to optimize number operations and use the
         // `iae` helper directly.
         enqueue(enqueuer, helpers.throwIllegalArgumentException, registry);
       } else if (cls == coreClasses.listClass ||
-                 cls == coreClasses.stringClass) {
+          cls == coreClasses.stringClass) {
         // The backend will try to optimize array and string access and use the
         // `ioore` and `iae` helpers directly.
         enqueue(enqueuer, helpers.throwIndexOutOfRangeException, registry);
         enqueue(enqueuer, helpers.throwIllegalArgumentException, registry);
       } else if (cls == coreClasses.functionClass) {
         enqueueClass(enqueuer, helpers.closureClass, registry);
       } else if (cls == coreClasses.mapClass) {
         // The backend will use a literal list to initialize the entries
         // of the map.
         enqueueClass(enqueuer, coreClasses.listClass, registry);
         enqueueClass(enqueuer, helpers.mapLiteralClass, registry);
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         rti.registerRtiDependency(helpers.mapLiteralClass, cls);
       } else if (cls == helpers.boundClosureClass) {
         // TODO(johnniwinther): Is this a noop?
         enqueueClass(enqueuer, helpers.boundClosureClass, registry);
       } else if (isNativeOrExtendsNative(cls)) {
         enqueue(enqueuer, helpers.getNativeInterceptorMethod, registry);
-        enqueueClass(enqueuer, helpers.jsInterceptorClass,
-            compiler.globalDependencies);
+        enqueueClass(
+            enqueuer, helpers.jsInterceptorClass, compiler.globalDependencies);
         enqueueClass(enqueuer, helpers.jsJavaScriptObjectClass, registry);
         enqueueClass(enqueuer, helpers.jsPlainJavaScriptObjectClass, registry);
         enqueueClass(enqueuer, helpers.jsJavaScriptFunctionClass, registry);
       } else if (cls == helpers.mapLiteralClass) {
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         Element getFactory(String name, int arity) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
           ClassElement implementation = cls.implementation;
           ConstructorElement ctor = implementation.lookupConstructor(name);
           if (ctor == null ||
               (Name.isPrivateName(name) &&
-               ctor.library != helpers.mapLiteralClass.library)) {
+                  ctor.library != helpers.mapLiteralClass.library)) {
             reporter.internalError(
                 helpers.mapLiteralClass,
                 "Map literal class ${helpers.mapLiteralClass} missing "
                 "'$name' constructor"
                 "  ${helpers.mapLiteralClass.constructors}");
           }
           return ctor;
         }
         Element getMember(String name) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
           ClassElement implementation = cls.implementation;
           Element element = implementation.lookupLocalMember(name);
           if (element == null || !element.isFunction || !element.isStatic) {
-            reporter.internalError(helpers.mapLiteralClass,
+            reporter.internalError(
+                helpers.mapLiteralClass,
                 "Map literal class ${helpers.mapLiteralClass} missing "
                 "'$name' static member function");
           }
           return element;
         }
         helpers.mapLiteralConstructor = getFactory('_literal', 1);
         helpers.mapLiteralConstructorEmpty = getFactory('_empty', 0);
         enqueueInResolution(helpers.mapLiteralConstructor, registry);
         enqueueInResolution(helpers.mapLiteralConstructorEmpty, registry);
 
         helpers.mapLiteralUntypedMaker = getMember('_makeLiteral');
         helpers.mapLiteralUntypedEmptyMaker = getMember('_makeEmpty');
         enqueueInResolution(helpers.mapLiteralUntypedMaker, registry);
         enqueueInResolution(helpers.mapLiteralUntypedEmptyMaker, registry);
       }
     }
     if (cls == helpers.closureClass) {
       enqueue(enqueuer, helpers.closureFromTearOff, registry);
     }
-    if (cls == coreClasses.stringClass ||
-        cls == helpers.jsStringClass) {
+    if (cls == coreClasses.stringClass || cls == helpers.jsStringClass) {
       addInterceptors(helpers.jsStringClass, enqueuer, registry);
     } else if (cls == coreClasses.listClass ||
-               cls == helpers.jsArrayClass ||
-               cls == helpers.jsFixedArrayClass ||
-               cls == helpers.jsExtendableArrayClass ||
-               cls == helpers.jsUnmodifiableArrayClass) {
+        cls == helpers.jsArrayClass ||
+        cls == helpers.jsFixedArrayClass ||
+        cls == helpers.jsExtendableArrayClass ||
+        cls == helpers.jsUnmodifiableArrayClass) {
       addInterceptors(helpers.jsArrayClass, enqueuer, registry);
       addInterceptors(helpers.jsMutableArrayClass, enqueuer, registry);
       addInterceptors(helpers.jsFixedArrayClass, enqueuer, registry);
       addInterceptors(helpers.jsExtendableArrayClass, enqueuer, registry);
       addInterceptors(helpers.jsUnmodifiableArrayClass, enqueuer, registry);
       // Literal lists can be translated into calls to these functions:
       enqueueInResolution(helpers.jsArrayTypedConstructor, registry);
       enqueueInResolution(helpers.setRuntimeTypeInfo, registry);
       enqueueInResolution(helpers.getTypeArgumentByIndex, registry);
-    } else if (cls == coreClasses.intClass ||
-               cls == helpers.jsIntClass) {
+    } else if (cls == coreClasses.intClass || cls == helpers.jsIntClass) {
       addInterceptors(helpers.jsIntClass, enqueuer, registry);
       addInterceptors(helpers.jsPositiveIntClass, enqueuer, registry);
       addInterceptors(helpers.jsUInt32Class, enqueuer, registry);
       addInterceptors(helpers.jsUInt31Class, enqueuer, registry);
       addInterceptors(helpers.jsNumberClass, enqueuer, registry);
-    } else if (cls == coreClasses.doubleClass ||
-               cls == helpers.jsDoubleClass) {
+    } else if (cls == coreClasses.doubleClass || cls == helpers.jsDoubleClass) {
       addInterceptors(helpers.jsDoubleClass, enqueuer, registry);
       addInterceptors(helpers.jsNumberClass, enqueuer, registry);
-    } else if (cls == coreClasses.boolClass ||
-               cls == helpers.jsBoolClass) {
+    } else if (cls == coreClasses.boolClass || cls == helpers.jsBoolClass) {
       addInterceptors(helpers.jsBoolClass, enqueuer, registry);
-    } else if (cls == coreClasses.nullClass ||
-               cls == helpers.jsNullClass) {
+    } else if (cls == coreClasses.nullClass || cls == helpers.jsNullClass) {
       addInterceptors(helpers.jsNullClass, enqueuer, registry);
-    } else if (cls == coreClasses.numClass ||
-               cls == helpers.jsNumberClass) {
+    } else if (cls == coreClasses.numClass || cls == helpers.jsNumberClass) {
       addInterceptors(helpers.jsIntClass, enqueuer, registry);
       addInterceptors(helpers.jsPositiveIntClass, enqueuer, registry);
       addInterceptors(helpers.jsUInt32Class, enqueuer, registry);
       addInterceptors(helpers.jsUInt31Class, enqueuer, registry);
       addInterceptors(helpers.jsDoubleClass, enqueuer, registry);
       addInterceptors(helpers.jsNumberClass, enqueuer, registry);
     } else if (cls == helpers.jsJavaScriptObjectClass) {
       addInterceptors(helpers.jsJavaScriptObjectClass, enqueuer, registry);
     } else if (cls == helpers.jsPlainJavaScriptObjectClass) {
       addInterceptors(helpers.jsPlainJavaScriptObjectClass, enqueuer, registry);
     } else if (cls == helpers.jsUnknownJavaScriptObjectClass) {
-      addInterceptors(helpers.jsUnknownJavaScriptObjectClass, enqueuer, registry);
+      addInterceptors(
+          helpers.jsUnknownJavaScriptObjectClass, enqueuer, registry);
     } else if (cls == helpers.jsJavaScriptFunctionClass) {
       addInterceptors(helpers.jsJavaScriptFunctionClass, enqueuer, registry);
     } else if (isNativeOrExtendsNative(cls)) {
       addInterceptorsForNativeClassMembers(cls, enqueuer);
     } else if (cls == helpers.jsIndexingBehaviorInterface) {
       // These two helpers are used by the emitter and the codegen.
       // Because we cannot enqueue elements at the time of emission,
       // we make sure they are always generated.
       enqueue(enqueuer, helpers.isJsIndexable, registry);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls, enqueuer);
     if (!enqueuer.isResolutionQueue) {
       lookupMapAnalysis.registerInstantiatedClass(cls);
     }
   }
 
-  void registerInstantiatedType(InterfaceType type,
-                                Enqueuer enqueuer,
-                                Registry registry,
-                                {bool mirrorUsage: false}) {
+  void registerInstantiatedType(
+      InterfaceType type, Enqueuer enqueuer, Registry registry,
+      {bool mirrorUsage: false}) {
     lookupMapAnalysis.registerInstantiatedType(type, registry);
-    super.registerInstantiatedType(
-        type, enqueuer, registry, mirrorUsage: mirrorUsage);
+    super.registerInstantiatedType(type, enqueuer, registry,
+        mirrorUsage: mirrorUsage);
   }
 
   void registerUseInterceptor(Enqueuer enqueuer) {
     assert(!enqueuer.isResolutionQueue);
     if (!enqueuer.nativeEnqueuer.hasInstantiatedNativeClasses()) return;
     Registry registry = compiler.globalDependencies;
     enqueue(enqueuer, helpers.getNativeInterceptorMethod, registry);
     enqueueClass(enqueuer, helpers.jsJavaScriptObjectClass, registry);
     enqueueClass(enqueuer, helpers.jsPlainJavaScriptObjectClass, registry);
     enqueueClass(enqueuer, helpers.jsJavaScriptFunctionClass, registry);
@@ skipping 15 matching lines @@
     if (compiler.options.enableTypeAssertions) {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e = helpers.boolConversionCheck;
       if (e != null) enqueue(world, e, registry);
     }
 
     if (TRACE_CALLS) {
       traceHelper = TRACE_METHOD == 'console'
-          ? helpers.consoleTraceHelper : helpers.postTraceHelper;
+          ? helpers.consoleTraceHelper
+          : helpers.postTraceHelper;
       assert(traceHelper != null);
       enqueueInResolution(traceHelper, registry);
     }
     enqueueInResolution(helpers.assertUnreachableMethod, registry);
     registerCheckedModeHelpers(registry);
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
   void registerGetRuntimeTypeArgument(Registry registry) {
     enqueueImpact(
-        compiler.enqueuer.resolution,
-        impacts.getRuntimeTypeArgument,
-        registry);
+        compiler.enqueuer.resolution, impacts.getRuntimeTypeArgument, registry);
   }
 
   void registerCallMethodWithFreeTypeVariables(
-      Element callMethod,
-      Enqueuer enqueuer,
-      Registry registry) {
+      Element callMethod, Enqueuer enqueuer, Registry registry) {
     if (enqueuer.isResolutionQueue || methodNeedsRti(callMethod)) {
       registerComputeSignature(enqueuer, registry);
     }
   }
 
   void registerClosureWithFreeTypeVariables(
-      Element closure,
-      Enqueuer enqueuer,
-      Registry registry) {
+      Element closure, Enqueuer enqueuer, Registry registry) {
     if (enqueuer.isResolutionQueue || methodNeedsRti(closure)) {
       registerComputeSignature(enqueuer, registry);
     }
     super.registerClosureWithFreeTypeVariables(closure, enqueuer, registry);
   }
 
   void registerBoundClosure(Enqueuer enqueuer) {
     helpers.boundClosureClass.ensureResolved(resolution);
     registerInstantiatedType(
         helpers.boundClosureClass.rawType,
         enqueuer,
         // Precise dependency is not important here.
         compiler.globalDependencies);
   }
 
   void registerGetOfStaticFunction(Enqueuer enqueuer) {
     helpers.closureClass.ensureResolved(resolution);
     registerInstantiatedType(
-        helpers.closureClass.rawType,
-        enqueuer,
-        compiler.globalDependencies);
+        helpers.closureClass.rawType, enqueuer, compiler.globalDependencies);
   }
 
   void registerComputeSignature(Enqueuer enqueuer, Registry registry) {
     // Calls to [:computeSignature:] are generated by the emitter and we
     // therefore need to enqueue the used elements in the codegen enqueuer as
     // well as in the resolution enqueuer.
     enqueueImpact(enqueuer, impacts.computeSignature, registry);
   }
 
   void registerRuntimeType(Enqueuer enqueuer, Registry registry) {
     registerComputeSignature(enqueuer, registry);
     enqueueInResolution(helpers.setRuntimeTypeInfo, registry);
     registerGetRuntimeTypeArgument(registry);
     enqueueInResolution(helpers.getRuntimeTypeInfo, registry);
     enqueueClass(enqueuer, coreClasses.listClass, registry);
   }
 
-  void registerTypeVariableBoundsSubtypeCheck(DartType typeArgument,
-                                              DartType bound) {
+  void registerTypeVariableBoundsSubtypeCheck(
+      DartType typeArgument, DartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
   void registerCheckDeferredIsLoaded(Registry registry) {
     enqueueInResolution(helpers.checkDeferredIsLoaded, registry);
     // Also register the types of the arguments passed to this method.
     enqueueClass(
         compiler.enqueuer.resolution, coreClasses.stringClass, registry);
   }
 
   void registerNoSuchMethod(FunctionElement noSuchMethod) {
     noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
   }
 
   /// Called when resolving a call to a foreign function.
-  void registerForeignCall(Send node,
-                           Element element,
-                           CallStructure callStructure,
-                           ForeignResolver resolver) {
+  void registerForeignCall(Send node, Element element,
+      CallStructure callStructure, ForeignResolver resolver) {
     native.NativeResolutionEnqueuer nativeEnqueuer =
         compiler.enqueuer.resolution.nativeEnqueuer;
     if (element.name == 'JS') {
       nativeEnqueuer.registerJsCall(node, resolver);
     } else if (element.name == 'JS_EMBEDDED_GLOBAL') {
       nativeEnqueuer.registerJsEmbeddedGlobalCall(node, resolver);
     } else if (element.name == 'JS_BUILTIN') {
       nativeEnqueuer.registerJsBuiltinCall(node, resolver);
     } else if (element.name == 'JS_INTERCEPTOR_CONSTANT') {
       // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
       // a class that will be instantiated outside the program by attaching a
       // native class dispatch record referencing the interceptor.
       if (!node.argumentsNode.isEmpty) {
         Node argument = node.argumentsNode.nodes.head;
         ConstantExpression constant = resolver.getConstant(argument);
         if (constant != null && constant.kind == ConstantExpressionKind.TYPE) {
           TypeConstantExpression typeConstant = constant;
           if (typeConstant.type is InterfaceType) {
             resolver.registerInstantiatedType(typeConstant.type);
             return;
           }
         }
       }
       reporter.reportErrorMessage(
-          node,
-          MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
+          node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
   }
 
   void enableNoSuchMethod(Enqueuer world) {
     enqueue(world, helpers.createInvocationMirror, compiler.globalDependencies);
-    world.registerDynamicUse(
-        new DynamicUse(Selectors.noSuchMethod_, null));
+    world.registerDynamicUse(new DynamicUse(Selectors.noSuchMethod_, null));
   }
 
   void enableIsolateSupport(Enqueuer enqueuer) {
     // TODO(floitsch): We should also ensure that the class IsolateMessage is
     // instantiated. Currently, just enabling isolate support works.
     if (compiler.mainFunction != null) {
       // The JavaScript backend implements [Isolate.spawn] by looking up
       // top-level functions by name. So all top-level function tear-off
       // closures have a private name field.
       //
       // The JavaScript backend of [Isolate.spawnUri] uses the same internal
       // implementation as [Isolate.spawn], and fails if it cannot look main up
       // by name.
       enqueuer.registerStaticUse(
           new StaticUse.staticTearOff(compiler.mainFunction));
     }
     if (enqueuer.isResolutionQueue) {
-
       void enqueue(Element element) {
         enqueuer.addToWorkList(element);
         compiler.globalDependencies.registerDependency(element);
         helpersUsed.add(element.declaration);
       }
 
       enqueue(helpers.startRootIsolate);
       enqueue(helpers.currentIsolate);
       enqueue(helpers.callInIsolate);
     } else {
       enqueuer.addToWorkList(helpers.startRootIsolate);
     }
   }
 
   bool classNeedsRti(ClassElement cls) {
     return rti.classesNeedingRti.contains(cls.declaration) ||
         compiler.enabledRuntimeType;
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
-    noSuchMethodRegistry.isComplex(element);
+      noSuchMethodRegistry.isComplex(element);
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
-    return classElement == coreClasses.objectClass
-        || classElement == helpers.jsInterceptorClass
-        || classElement == helpers.jsNullClass;
+    return classElement == coreClasses.objectClass ||
+        classElement == helpers.jsInterceptorClass ||
+        classElement == helpers.jsNullClass;
   }
 
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) ||
-           compiler.enabledRuntimeType;
+        compiler.enabledRuntimeType;
   }
 
   /// Enqueue [e] in [enqueuer].
   ///
   /// This method calls [registerBackendUse].
   void enqueue(Enqueuer enqueuer, Element e, Registry registry) {
     if (e == null) return;
     registerBackendUse(e);
     enqueuer.addToWorkList(e);
     registry.registerDependency(e);
@@ skipping 30 matching lines @@
     ClassElement cls = type.element;
     registerBackendUse(cls);
     helpersUsed.add(cls.declaration);
     if (cls.declaration != cls.implementation) {
       helpersUsed.add(cls.implementation);
     }
     cls.ensureResolved(resolution);
     registerInstantiatedType(type, enqueuer, registry);
   }
 
-  void enqueueImpact(Enqueuer enqueuer,
-                     BackendImpact impact,
-                     Registry registry) {
+  void enqueueImpact(
+      Enqueuer enqueuer, BackendImpact impact, Registry registry) {
     for (Element staticUse in impact.staticUses) {
       enqueue(enqueuer, staticUse, registry);
     }
     for (InterfaceType type in impact.instantiatedTypes) {
       enqueueType(enqueuer, type, registry);
     }
     for (ClassElement cls in impact.instantiatedClasses) {
       enqueueClass(enqueuer, cls, registry);
     }
     for (BackendImpact otherImpact in impact.otherImpacts) {
@@ skipping 20 matching lines @@
     if (kind.category == ElementCategory.VARIABLE) {
       ConstantValue initialValue =
           constants.getConstantValueForVariable(element);
       if (initialValue != null) {
         registerCompileTimeConstant(initialValue, work.registry);
         addCompileTimeConstantForEmission(initialValue);
         // We don't need to generate code for static or top-level
         // variables. For instance variables, we may need to generate
         // the checked setter.
         if (Elements.isStaticOrTopLevel(element)) {
-          return impactTransformer.transformCodegenImpact(
-              work.registry.worldImpact);
+          return impactTransformer
+              .transformCodegenImpact(work.registry.worldImpact);
         }
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
-        compiler.enqueuer.codegen.registerStaticUse(
-            new StaticUse.staticInvoke(
-                helpers.cyclicThrowHelper, CallStructure.ONE_ARG));
+        compiler.enqueuer.codegen.registerStaticUse(new StaticUse.staticInvoke(
+            helpers.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
     }
 
     jsAst.Fun function = functionCompiler.compile(work);
     if (function.sourceInformation == null) {
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
     WorldImpact worldImpact =
         impactTransformer.transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
     if (isJsInterop(element)) {
       return helpers.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
     return isNative(element)
-        ? helpers.jsInterceptorClass : coreClasses.objectClass;
+        ? helpers.jsInterceptorClass
+        : coreClasses.objectClass;
   }
 
   /**
    * Unit test hook that returns code of an element as a String.
    *
    * Invariant: [element] must be a declaration element.
    */
   String getGeneratedCode(Element element) {
     assert(invariant(element, element.isDeclaration));
     return jsAst.prettyPrint(generatedCode[element], compiler);
   }
 
   int assembleProgram() {
     int programSize = emitter.assembleProgram();
     noSuchMethodRegistry.emitDiagnostic();
     int totalMethodCount = generatedCode.length;
     if (totalMethodCount != preMirrorsMethodCount) {
       int mirrorCount = totalMethodCount - preMirrorsMethodCount;
       double percentage = (mirrorCount / totalMethodCount) * 100;
-      DiagnosticMessage hint = reporter.createMessage(
-          compiler.mainApp, MessageKind.MIRROR_BLOAT,
-          {'count': mirrorCount,
-           'total': totalMethodCount,
-           'percentage': percentage.round()});
+      DiagnosticMessage hint =
+          reporter.createMessage(compiler.mainApp, MessageKind.MIRROR_BLOAT, {
+        'count': mirrorCount,
+        'total': totalMethodCount,
+        'percentage': percentage.round()
+      });
 
       List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       for (LibraryElement library in compiler.libraryLoader.libraries) {
         if (library.isInternalLibrary) continue;
         for (ImportElement import in library.imports) {
           LibraryElement importedLibrary = import.importedLibrary;
           if (importedLibrary != compiler.mirrorsLibrary) continue;
           MessageKind kind =
               compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(library)
-              ? MessageKind.MIRROR_IMPORT
-              : MessageKind.MIRROR_IMPORT_NO_USAGE;
+                  ? MessageKind.MIRROR_IMPORT
+                  : MessageKind.MIRROR_IMPORT_NO_USAGE;
           reporter.withCurrentElement(library, () {
             infos.add(reporter.createMessage(import, kind));
           });
         }
       }
       reporter.reportHint(hint, infos);
     }
     return programSize;
   }
 
   Element getDartClass(Element element) {
     for (ClassElement dartClass in implementationClasses.keys) {
       if (element == implementationClasses[dartClass]) {
         return dartClass;
       }
     }
     return element;
   }
 
   /**
    * Returns the checked mode helper that will be needed to do a type check/type
    * cast on [type] at runtime. Note that this method is being called both by
    * the resolver with interface types (int, String, ...), and by the SSA
    * backend with implementation types (JSInt, JSString, ...).
    */
   CheckedModeHelper getCheckedModeHelper(DartType type, {bool typeCast}) {
-    return getCheckedModeHelperInternal(
-        type, typeCast: typeCast, nativeCheckOnly: false);
+    return getCheckedModeHelperInternal(type,
+        typeCast: typeCast, nativeCheckOnly: false);
   }
 
   /**
    * Returns the native checked mode helper that will be needed to do a type
    * check/type cast on [type] at runtime. If no native helper exists for
    * [type], [:null:] is returned.
    */
   CheckedModeHelper getNativeCheckedModeHelper(DartType type, {bool typeCast}) {
-    return getCheckedModeHelperInternal(
-        type, typeCast: typeCast, nativeCheckOnly: true);
+    return getCheckedModeHelperInternal(type,
+        typeCast: typeCast, nativeCheckOnly: true);
   }
 
   /**
    * Returns the checked mode helper for the type check/type cast for [type]. If
    * [nativeCheckOnly] is [:true:], only names for native helpers are returned.
    */
   CheckedModeHelper getCheckedModeHelperInternal(DartType type,
-                                                 {bool typeCast,
-                                                  bool nativeCheckOnly}) {
+      {bool typeCast, bool nativeCheckOnly}) {
     String name = getCheckedModeHelperNameInternal(type,
         typeCast: typeCast, nativeCheckOnly: nativeCheckOnly);
     if (name == null) return null;
     CheckedModeHelper helper = checkedModeHelperByName[name];
     assert(helper != null);
     return helper;
   }
 
   String getCheckedModeHelperNameInternal(DartType type,
-                                          {bool typeCast,
-                                           bool nativeCheckOnly}) {
+      {bool typeCast, bool nativeCheckOnly}) {
     assert(type.kind != TypeKind.TYPEDEF);
     if (type.isMalformed) {
       // The same error is thrown for type test and type cast of a malformed
       // type so we only need one check method.
       return 'checkMalformedType';
     }
     Element element = type.element;
-    bool nativeCheck = nativeCheckOnly ||
-        emitter.nativeEmitter.requiresNativeIsCheck(element);
+    bool nativeCheck =
+        nativeCheckOnly || emitter.nativeEmitter.requiresNativeIsCheck(element);
 
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
     // that it can be optimized by standard interceptor optimizations.
     nativeCheck = true;
 
     if (type.isVoid) {
       assert(!typeCast); // Cannot cast to void.
       if (nativeCheckOnly) return null;
       return 'voidTypeCheck';
     } else if (element == helpers.jsStringClass ||
-               element == coreClasses.stringClass) {
+        element == coreClasses.stringClass) {
       if (nativeCheckOnly) return null;
-      return typeCast
-          ? 'stringTypeCast'
-          : 'stringTypeCheck';
+      return typeCast ? 'stringTypeCast' : 'stringTypeCheck';
     } else if (element == helpers.jsDoubleClass ||
-               element == coreClasses.doubleClass) {
+        element == coreClasses.doubleClass) {
       if (nativeCheckOnly) return null;
-      return typeCast
-          ? 'doubleTypeCast'
-          : 'doubleTypeCheck';
+      return typeCast ? 'doubleTypeCast' : 'doubleTypeCheck';
     } else if (element == helpers.jsNumberClass ||
-               element == coreClasses.numClass) {
+        element == coreClasses.numClass) {
       if (nativeCheckOnly) return null;
-      return typeCast
-          ? 'numTypeCast'
-          : 'numTypeCheck';
+      return typeCast ? 'numTypeCast' : 'numTypeCheck';
     } else if (element == helpers.jsBoolClass ||
-               element == coreClasses.boolClass) {
+        element == coreClasses.boolClass) {
       if (nativeCheckOnly) return null;
-      return typeCast
-          ? 'boolTypeCast'
-          : 'boolTypeCheck';
+      return typeCast ? 'boolTypeCast' : 'boolTypeCheck';
     } else if (element == helpers.jsIntClass ||
-               element == coreClasses.intClass ||
-               element == helpers.jsUInt32Class ||
-               element == helpers.jsUInt31Class ||
-               element == helpers.jsPositiveIntClass) {
+        element == coreClasses.intClass ||
+        element == helpers.jsUInt32Class ||
+        element == helpers.jsUInt31Class ||
+        element == helpers.jsPositiveIntClass) {
       if (nativeCheckOnly) return null;
-      return typeCast
-          ? 'intTypeCast'
-          : 'intTypeCheck';
+      return typeCast ? 'intTypeCast' : 'intTypeCheck';
     } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
       if (nativeCheck) {
         return typeCast
             ? 'numberOrStringSuperNativeTypeCast'
             : 'numberOrStringSuperNativeTypeCheck';
       } else {
         return typeCast
-          ? 'numberOrStringSuperTypeCast'
-          : 'numberOrStringSuperTypeCheck';
+            ? 'numberOrStringSuperTypeCast'
+            : 'numberOrStringSuperTypeCheck';
       }
     } else if (Elements.isStringOnlySupertype(element, compiler)) {
       if (nativeCheck) {
         return typeCast
             ? 'stringSuperNativeTypeCast'
             : 'stringSuperNativeTypeCheck';
       } else {
-        return typeCast
-            ? 'stringSuperTypeCast'
-            : 'stringSuperTypeCheck';
+        return typeCast ? 'stringSuperTypeCast' : 'stringSuperTypeCheck';
       }
     } else if ((element == coreClasses.listClass ||
-                element == helpers.jsArrayClass) &&
-               type.treatAsRaw) {
+            element == helpers.jsArrayClass) &&
+        type.treatAsRaw) {
       if (nativeCheckOnly) return null;
-      return typeCast
-          ? 'listTypeCast'
-          : 'listTypeCheck';
+      return typeCast ? 'listTypeCast' : 'listTypeCheck';
     } else {
       if (Elements.isListSupertype(element, compiler)) {
         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
         } else {
-          return typeCast
-              ? 'listSuperTypeCast'
-              : 'listSuperTypeCheck';
+          return typeCast ? 'listSuperTypeCast' : 'listSuperTypeCheck';
         }
       } else {
         if (type.isInterfaceType && !type.treatAsRaw) {
-          return typeCast
-              ? 'subtypeCast'
-              : 'assertSubtype';
+          return typeCast ? 'subtypeCast' : 'assertSubtype';
         } else if (type.isTypeVariable) {
           return typeCast
               ? 'subtypeOfRuntimeTypeCast'
               : 'assertSubtypeOfRuntimeType';
         } else if (type.isFunctionType) {
           return null;
         } else {
           if (nativeCheck) {
             // TODO(karlklose): can we get rid of this branch when we use
             // interceptors?
-            return typeCast
-                ? 'interceptedTypeCast'
-                : 'interceptedTypeCheck';
+            return typeCast ? 'interceptedTypeCast' : 'interceptedTypeCheck';
           } else {
-            return typeCast
-                ? 'propertyTypeCast'
-                : 'propertyTypeCheck';
+            return typeCast ? 'propertyTypeCast' : 'propertyTypeCheck';
           }
         }
       }
     }
   }
 
   void registerCheckedModeHelpers(Registry registry) {
     // We register all the helpers in the resolution queue.
     // TODO(13155): Find a way to register fewer helpers.
     for (CheckedModeHelper helper in checkedModeHelpers) {
@@ skipping 63 matching lines @@
     } else if (element == helpers.preserveUrisMarker) {
       if (compiler.options.preserveUris) mustPreserveUris = true;
     } else if (element == helpers.preserveLibraryNamesMarker) {
       mustRetainLibraryNames = true;
     } else if (element == helpers.getIsolateAffinityTagMarker) {
       needToInitializeIsolateAffinityTag = true;
     } else if (element.isDeferredLoaderGetter) {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (compiler.loadLibraryFunction == null) {
         compiler.loadLibraryFunction = helpers.loadLibraryWrapper;
-        enqueueInResolution(compiler.loadLibraryFunction,
-                            compiler.globalDependencies);
+        enqueueInResolution(
+            compiler.loadLibraryFunction, compiler.globalDependencies);
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     }
     customElementsAnalysis.registerStaticUse(element, enqueuer);
   }
 
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 
   /// Called when [:new Symbol(...):] is seen.
-  void registerNewSymbol(Registry registry) {
-  }
+  void registerNewSymbol(Registry registry) {}
 
   /// Should [element] (a getter) that would normally not be generated due to
   /// treeshaking be retained for reflection?
   bool shouldRetainGetter(Element element) {
     return isTreeShakingDisabled && isAccessibleByReflection(element);
   }
 
   /// Should [element] (a setter) hat would normally not be generated due to
   /// treeshaking be retained for reflection?
   bool shouldRetainSetter(Element element) {
@@ skipping 59 matching lines @@
     implementationClasses = <ClassElement, ClassElement>{};
     implementationClasses[coreClasses.intClass] = helpers.jsIntClass;
     implementationClasses[coreClasses.boolClass] = helpers.jsBoolClass;
     implementationClasses[coreClasses.numClass] = helpers.jsNumberClass;
     implementationClasses[coreClasses.doubleClass] = helpers.jsDoubleClass;
     implementationClasses[coreClasses.stringClass] = helpers.jsStringClass;
     implementationClasses[coreClasses.listClass] = helpers.jsArrayClass;
     implementationClasses[coreClasses.nullClass] = helpers.jsNullClass;
 
     // These methods are overwritten with generated versions.
-    inlineCache.markAsNonInlinable(
-        helpers.getInterceptorMethod, insideLoop: true);
+    inlineCache.markAsNonInlinable(helpers.getInterceptorMethod,
+        insideLoop: true);
 
     specialOperatorEqClasses
-        ..add(coreClasses.objectClass)
-        ..add(helpers.jsInterceptorClass)
-        ..add(helpers.jsNullClass);
+      ..add(coreClasses.objectClass)
+      ..add(helpers.jsInterceptorClass)
+      ..add(helpers.jsNullClass);
 
     validateInterceptorImplementsAllObjectMethods(helpers.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
     validateInterceptorImplementsAllObjectMethods(helpers.jsNullClass);
 
     return new Future.value();
   }
 
-  void registerMirrorUsage(Set<String> symbols,
-                           Set<Element> targets,
-                           Set<Element> metaTargets) {
+  void registerMirrorUsage(
+      Set<String> symbols, Set<Element> targets, Set<Element> metaTargets) {
     if (symbols == null && targets == null && metaTargets == null) {
       // The user didn't specify anything, or there are imports of
       // 'dart:mirrors' without @MirrorsUsed.
       hasInsufficientMirrorsUsed = true;
       return;
     }
     if (symbols != null) symbolsUsed.addAll(symbols);
     if (targets != null) {
       for (Element target in targets) {
         if (target.isAbstractField) {
@@ skipping 24 matching lines @@
     return membersNeededForReflection.contains(element);
   }
 
   /**
    * Returns true if the element has to be resolved due to a mirrorsUsed
    * annotation. If we have insufficient mirrors used annotations, we only
    * keep additonal elements if treeshaking has been disabled.
    */
   bool requiredByMirrorSystem(Element element) {
     return hasInsufficientMirrorsUsed && isTreeShakingDisabled ||
-           matchesMirrorsMetaTarget(element) ||
-           targetsUsed.contains(element);
+        matchesMirrorsMetaTarget(element) ||
+        targetsUsed.contains(element);
   }
 
   /**
    * Returns true if the element matches a mirrorsUsed annotation. If
    * we have insufficient mirrorsUsed information, this returns true for
    * all elements, as they might all be potentially referenced.
    */
   bool referencedFromMirrorSystem(Element element, [recursive = true]) {
     Element enclosing = recursive ? element.enclosingElement : null;
 
     return hasInsufficientMirrorsUsed ||
-           matchesMirrorsMetaTarget(element) ||
-           targetsUsed.contains(element) ||
-           (enclosing != null && referencedFromMirrorSystem(enclosing));
+        matchesMirrorsMetaTarget(element) ||
+        targetsUsed.contains(element) ||
+        (enclosing != null && referencedFromMirrorSystem(enclosing));
   }
 
   /**
    * Returns `true` if the element is needed because it has an annotation
    * of a type that is used as a meta target for reflection.
    */
   bool matchesMirrorsMetaTarget(Element element) {
     if (metaTargetsUsed.isEmpty) return false;
     for (MetadataAnnotation metadata in element.metadata) {
       // TODO(kasperl): It would be nice if we didn't have to resolve
@@ skipping 152 matching lines @@
   // [computeMembersNeededForReflection].
   void maybeMarkClosureAsNeededForReflection(
       ClosureClassElement globalizedElement,
       FunctionElement callFunction,
       FunctionElement function) {
     if (!_membersNeededForReflection.contains(function)) return;
     _membersNeededForReflection.add(callFunction);
     _membersNeededForReflection.add(globalizedElement);
   }
 
-  jsAst.Call generateIsJsIndexableCall(jsAst.Expression use1,
-                                       jsAst.Expression use2) {
+  jsAst.Call generateIsJsIndexableCall(
+      jsAst.Expression use1, jsAst.Expression use2) {
     String dispatchPropertyName = embeddedNames.DISPATCH_PROPERTY_NAME;
     jsAst.Expression dispatchProperty =
         emitter.generateEmbeddedGlobalAccess(dispatchPropertyName);
 
     // We pass the dispatch property record to the isJsIndexable
     // helper rather than reading it inside the helper to increase the
     // chance of making the dispatch record access monomorphic.
     jsAst.PropertyAccess record =
         new jsAst.PropertyAccess(use2, dispatchProperty);
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[use1, record];
     FunctionElement helper = helpers.isJsIndexable;
     jsAst.Expression helperExpression = emitter.staticFunctionAccess(helper);
     return new jsAst.Call(helperExpression, arguments);
   }
 
   bool isTypedArray(TypeMask mask) {
     // Just checking for [:TypedData:] is not sufficient, as it is an
     // abstract class any user-defined class can implement. So we also
     // check for the interface [JavaScriptIndexingBehavior].
-    return
-        compiler.typedDataClass != null &&
+    return compiler.typedDataClass != null &&
         compiler.world.isInstantiated(compiler.typedDataClass) &&
         mask.satisfies(compiler.typedDataClass, compiler.world) &&
         mask.satisfies(helpers.jsIndexingBehaviorInterface, compiler.world);
   }
 
   bool couldBeTypedArray(TypeMask mask) {
     bool intersects(TypeMask type1, TypeMask type2) =>
         !type1.intersection(type2, compiler.world).isEmpty;
     // TODO(herhut): Maybe cache the TypeMask for typedDataClass and
     //               jsIndexingBehaviourInterface.
-    return
-        compiler.typedDataClass != null &&
+    return compiler.typedDataClass != null &&
         compiler.world.isInstantiated(compiler.typedDataClass) &&
         intersects(mask,
             new TypeMask.subtype(compiler.typedDataClass, compiler.world)) &&
-        intersects(mask,
-            new TypeMask.subtype(helpers.jsIndexingBehaviorInterface, compiler.world));
+        intersects(
+            mask,
+            new TypeMask.subtype(
+                helpers.jsIndexingBehaviorInterface, compiler.world));
   }
 
   /// Returns all static fields that are referenced through [targetsUsed].
   /// If the target is a library or class all nested static fields are
   /// included too.
   Iterable<Element> _findStaticFieldTargets() {
     List staticFields = [];
 
     void addFieldsInContainer(ScopeContainerElement container) {
       container.forEachLocalMember((Element member) {
@@ skipping 19 matching lines @@
   /// Called when [enqueuer] is empty, but before it is closed.
   bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassElement> recentClasses) {
     // Add elements referenced only via custom elements.  Return early if any
     // elements are added to avoid counting the elements as due to mirrors.
     customElementsAnalysis.onQueueEmpty(enqueuer);
     if (!enqueuer.queueIsEmpty) return false;
 
     noSuchMethodRegistry.onQueueEmpty();
     if (!enabledNoSuchMethod &&
         (noSuchMethodRegistry.hasThrowingNoSuchMethod ||
-         noSuchMethodRegistry.hasComplexNoSuchMethod)) {
+            noSuchMethodRegistry.hasComplexNoSuchMethod)) {
       enableNoSuchMethod(enqueuer);
       enabledNoSuchMethod = true;
     }
 
     if (compiler.options.hasIncrementalSupport) {
       // Always enable tear-off closures during incremental compilation.
       Element e = helpers.closureFromTearOff;
       if (e != null && !enqueuer.isProcessed(e)) {
         registerBackendUse(e);
         enqueuer.addToWorkList(e);
@@ skipping 13 matching lines @@
       enqueuer.enqueueReflectiveStaticFields(_findStaticFieldTargets());
     }
 
     if (mustPreserveNames) reporter.log('Preserving names.');
 
     if (mustRetainMetadata) {
       reporter.log('Retaining metadata.');
 
       compiler.libraryLoader.libraries.forEach(retainMetadataOf);
       for (Dependency dependency in metadataConstants) {
-        registerCompileTimeConstant(
-            dependency.constant,
+        registerCompileTimeConstant(dependency.constant,
             new EagerRegistry('EagerRegistry for ${dependency}', enqueuer));
       }
       if (!enqueuer.isResolutionQueue) {
         metadataConstants.clear();
       }
     }
     return true;
   }
 
   void onQueueClosed() {
@@ skipping 27 matching lines @@
       metadata.ensureResolved(resolution);
       ConstantValue constantValue =
           compiler.constants.getConstantValue(metadata.constant);
       if (!constantValue.isConstructedObject) continue;
       ObjectConstantValue value = constantValue;
       ClassElement cls = value.type.element;
       if (cls == helpers.forceInlineClass) {
         hasForceInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
-              element,
-              MessageKind.GENERIC,
-              {'text': "Must inline"});
+              element, MessageKind.GENERIC, {'text': "Must inline"});
         }
         inlineCache.markAsMustInline(element);
       } else if (cls == helpers.noInlineClass) {
         hasNoInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
-              element,
-              MessageKind.GENERIC,
-              {'text': "Cannot inline"});
+              element, MessageKind.GENERIC, {'text': "Cannot inline"});
         }
         inlineCache.markAsNonInlinable(element);
       } else if (cls == helpers.noThrowsClass) {
         hasNoThrows = true;
         if (!Elements.isStaticOrTopLevelFunction(element) &&
             !element.isFactoryConstructor) {
-          reporter.internalError(element,
+          reporter.internalError(
+              element,
               "@NoThrows() is currently limited to top-level"
               " or static functions and factory constructors.");
         }
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
-              element,
-              MessageKind.GENERIC,
-              {'text': "Cannot throw"});
+              element, MessageKind.GENERIC, {'text': "Cannot throw"});
         }
         compiler.world.registerCannotThrow(element);
       } else if (cls == helpers.noSideEffectsClass) {
         hasNoSideEffects = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
-              element,
-              MessageKind.GENERIC,
-              {'text': "Has no side effects"});
+              element, MessageKind.GENERIC, {'text': "Has no side effects"});
         }
         compiler.world.registerSideEffectsFree(element);
       }
     }
     if (hasForceInline && hasNoInline) {
-      reporter.internalError(element,
-          "@ForceInline() must not be used with @NoInline.");
+      reporter.internalError(
+          element, "@ForceInline() must not be used with @NoInline.");
     }
     if (hasNoThrows && !hasNoInline) {
-      reporter.internalError(element,
-          "@NoThrows() should always be combined with @NoInline.");
+      reporter.internalError(
+          element, "@NoThrows() should always be combined with @NoInline.");
     }
     if (hasNoSideEffects && !hasNoInline) {
       reporter.internalError(element,
           "@NoSideEffects() should always be combined with @NoInline.");
     }
     if (element == helpers.invokeOnMethod) {
       compiler.enabledInvokeOn = true;
     }
   }
+
 /*
   CodeBuffer codeOf(Element element) {
     return generatedCode.containsKey(element)
         ? jsAst.prettyPrint(generatedCode[element], compiler)
         : null;
   }
 */
   FunctionElement helperForBadMain() => helpers.badMain;
 
   FunctionElement helperForMissingMain() => helpers.missingMain;
@@ skipping 31 matching lines @@
   @override
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
     registerCheckDeferredIsLoaded(registry);
     return true;
   }
 
   @override
   bool enableCodegenWithErrorsIfSupported(Spannable node) {
     if (compiler.options.useCpsIr) {
       // TODO(25747): Support code generation with compile-time errors.
-      reporter.reportHintMessage(
-          node,
-          MessageKind.GENERIC,
-          {'text': "Generation of code with compile time errors is currently "
-                   "not supported with the CPS IR."});
+      reporter.reportHintMessage(node, MessageKind.GENERIC, {
+        'text': "Generation of code with compile time errors is currently "
+            "not supported with the CPS IR."
+      });
       return false;
     }
     return true;
   }
 
-  jsAst.Expression rewriteAsync(FunctionElement element,
-                                jsAst.Expression code) {
+  jsAst.Expression rewriteAsync(
+      FunctionElement element, jsAst.Expression code) {
     AsyncRewriterBase rewriter = null;
     jsAst.Name name = namer.methodPropertyName(element);
     switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
-        rewriter = new AsyncRewriter(
-            reporter,
-            element,
-            asyncHelper:
-                emitter.staticFunctionAccess(helpers.asyncHelper),
-            wrapBody:
-                emitter.staticFunctionAccess(helpers.wrapBody),
-            newCompleter: emitter.staticFunctionAccess(
-                helpers.syncCompleterConstructor),
+        rewriter = new AsyncRewriter(reporter, element,
+            asyncHelper: emitter.staticFunctionAccess(helpers.asyncHelper),
+            wrapBody: emitter.staticFunctionAccess(helpers.wrapBody),
+            newCompleter:
+                emitter.staticFunctionAccess(helpers.syncCompleterConstructor),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       case AsyncMarker.SYNC_STAR:
-        rewriter = new SyncStarRewriter(
-            reporter,
-            element,
-            endOfIteration: emitter.staticFunctionAccess(
-                helpers.endOfIteration),
-            newIterable: emitter.staticFunctionAccess(
-                helpers.syncStarIterableConstructor),
-            yieldStarExpression: emitter.staticFunctionAccess(
-                helpers.yieldStar),
-            uncaughtErrorExpression: emitter.staticFunctionAccess(
-                helpers.syncStarUncaughtError),
+        rewriter = new SyncStarRewriter(reporter, element,
+            endOfIteration:
+                emitter.staticFunctionAccess(helpers.endOfIteration),
+            newIterable: emitter
+                .staticFunctionAccess(helpers.syncStarIterableConstructor),
+            yieldStarExpression:
+                emitter.staticFunctionAccess(helpers.yieldStar),
+            uncaughtErrorExpression:
+                emitter.staticFunctionAccess(helpers.syncStarUncaughtError),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
-         break;
+        break;
       case AsyncMarker.ASYNC_STAR:
-        rewriter = new AsyncStarRewriter(
-            reporter,
-            element,
-            asyncStarHelper: emitter.staticFunctionAccess(
-                helpers.asyncStarHelper),
-            streamOfController: emitter.staticFunctionAccess(
-                helpers.streamOfController),
-            wrapBody:
-                emitter.staticFunctionAccess(helpers.wrapBody),
-            newController: emitter.staticFunctionAccess(
-                helpers.asyncStarControllerConstructor),
+        rewriter = new AsyncStarRewriter(reporter, element,
+            asyncStarHelper:
+                emitter.staticFunctionAccess(helpers.asyncStarHelper),
+            streamOfController:
+                emitter.staticFunctionAccess(helpers.streamOfController),
+            wrapBody: emitter.staticFunctionAccess(helpers.wrapBody),
+            newController: emitter
+                .staticFunctionAccess(helpers.asyncStarControllerConstructor),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
-            yieldExpression: emitter.staticFunctionAccess(
-                helpers.yieldSingle),
-            yieldStarExpression: emitter.staticFunctionAccess(
-                helpers.yieldStar),
+            yieldExpression: emitter.staticFunctionAccess(helpers.yieldSingle),
+            yieldStarExpression:
+                emitter.staticFunctionAccess(helpers.yieldStar),
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       default:
         assert(element.asyncMarker == AsyncMarker.SYNC);
         return code;
     }
     return rewriter.rewrite(code);
   }
 
   /// The locations of js patch-files relative to the sdk-descriptors.
   static const _patchLocations = const <String, String>{
     "async": "_internal/js_runtime/lib/async_patch.dart",
-    "collection":  "_internal/js_runtime/lib/collection_patch.dart",
+    "collection": "_internal/js_runtime/lib/collection_patch.dart",
     "convert": "_internal/js_runtime/lib/convert_patch.dart",
     "core": "_internal/js_runtime/lib/core_patch.dart",
     "developer": "_internal/js_runtime/lib/developer_patch.dart",
     "io": "_internal/js_runtime/lib/io_patch.dart",
     "isolate": "_internal/js_runtime/lib/isolate_patch.dart",
     "math": "_internal/js_runtime/lib/math_patch.dart",
     "mirrors": "_internal/js_runtime/lib/mirrors_patch.dart",
     "typed_data": "_internal/js_runtime/lib/typed_data_patch.dart",
     "_internal": "_internal/js_runtime/lib/internal_patch.dart"
   };
 
   @override
   Uri resolvePatchUri(String libraryName, Uri platformConfigUri) {
     String patchLocation = _patchLocations[libraryName];
     if (patchLocation == null) return null;
     return platformConfigUri.resolve(patchLocation);
   }
 
   @override
   ImpactStrategy createImpactStrategy(
       {bool supportDeferredLoad: true,
-       bool supportDumpInfo: true,
-       bool supportSerialization: true}) {
-    return new JavaScriptImpactStrategy(
-        resolution,
-        compiler.dumpInfoTask,
+      bool supportDumpInfo: true,
+      bool supportSerialization: true}) {
+    return new JavaScriptImpactStrategy(resolution, compiler.dumpInfoTask,
         supportDeferredLoad: supportDeferredLoad,
         supportDumpInfo: supportDumpInfo,
         supportSerialization: supportSerialization);
   }
 }
 
 /// Handling of special annotations for tests.
 class Annotations {
   static final Uri PACKAGE_EXPECT =
       new Uri(scheme: 'package', path: 'expect/expect.dart');
@@ skipping 189 matching lines @@
           hasTypeLiteral = true;
           break;
       }
     }
 
     if (hasAsCast) {
       registerBackendImpact(transformed, impacts.asCheck);
     }
 
     if (hasTypeLiteral) {
-      transformed.registerTypeUse(new TypeUse.instantiation(
-          backend.compiler.coreTypes.typeType));
+      transformed.registerTypeUse(
+          new TypeUse.instantiation(backend.compiler.coreTypes.typeType));
       registerBackendImpact(transformed, impacts.typeLiteral);
     }
 
     for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
       // TODO(johnniwinther): Use the [isEmpty] property when factory
       // constructors are registered directly.
       if (mapLiteralUse.isConstant) {
         registerBackendImpact(transformed, impacts.constantMapLiteral);
       } else {
-        transformed.registerTypeUse(
-            new TypeUse.instantiation(mapLiteralUse.type));
+        transformed
+            .registerTypeUse(new TypeUse.instantiation(mapLiteralUse.type));
       }
       registerRequiredType(mapLiteralUse.type);
     }
 
     for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) {
       // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when
       // factory constructors are registered directly.
-      transformed.registerTypeUse(
-          new TypeUse.instantiation(listLiteralUse.type));
+      transformed
+          .registerTypeUse(new TypeUse.instantiation(listLiteralUse.type));
       registerRequiredType(listLiteralUse.type);
     }
 
     if (worldImpact.constSymbolNames.isNotEmpty) {
       registerBackendImpact(transformed, impacts.constSymbol);
       for (String constSymbolName in worldImpact.constSymbolNames) {
         backend.registerConstSymbol(constSymbolName);
       }
     }
 
     for (StaticUse staticUse in worldImpact.staticUses) {
       if (staticUse.kind == StaticUseKind.CLOSURE) {
         registerBackendImpact(transformed, impacts.closure);
         LocalFunctionElement closure = staticUse.element;
         if (closure.type.containsTypeVariables) {
           backend.compiler.enqueuer.resolution.universe
-              .closuresWithFreeTypeVariables.add(closure);
+              .closuresWithFreeTypeVariables
+              .add(closure);
           registerBackendImpact(transformed, impacts.computeSignature);
         }
       }
     }
 
     for (ConstantExpression constant in worldImpact.constantLiterals) {
       switch (constant.kind) {
         case ConstantExpressionKind.NULL:
           registerBackendImpact(transformed, impacts.nullLiteral);
           break;
@@ skipping 11 matching lines @@
           break;
         default:
           assert(invariant(NO_LOCATION_SPANNABLE, false,
               message: "Unexpected constant literal: ${constant.kind}."));
       }
     }
 
     return transformed;
   }
 
-  void registerBackendImpact(TransformedWorldImpact worldImpact,
-                             BackendImpact backendImpact) {
+  void registerBackendImpact(
+      TransformedWorldImpact worldImpact, BackendImpact backendImpact) {
     for (Element staticUse in backendImpact.staticUses) {
       assert(staticUse != null);
       backend.registerBackendUse(staticUse);
       worldImpact.registerStaticUse(
           // TODO(johnniwinther): Store the correct use in impacts.
           new StaticUse.foreignUse(staticUse));
     }
     for (InterfaceType instantiatedType in backendImpact.instantiatedTypes) {
       backend.registerBackendUse(instantiatedType.element);
-      worldImpact.registerTypeUse(
-          new TypeUse.instantiation(instantiatedType));
+      worldImpact.registerTypeUse(new TypeUse.instantiation(instantiatedType));
     }
     for (ClassElement cls in backendImpact.instantiatedClasses) {
       cls.ensureResolved(backend.resolution);
       backend.registerBackendUse(cls);
-      worldImpact.registerTypeUse(
-          new TypeUse.instantiation(cls.rawType));
+      worldImpact.registerTypeUse(new TypeUse.instantiation(cls.rawType));
     }
     for (BackendImpact otherImpact in backendImpact.otherImpacts) {
       registerBackendImpact(worldImpact, otherImpact);
     }
   }
 
   /// Register [type] as required for the runtime type information system.
   void registerRequiredType(DartType type) {
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
@@ skipping 21 matching lines @@
       registerBackendImpact(transformed, impacts.malformedTypeCheck);
     }
     if (!type.treatAsRaw || type.containsTypeVariables || type.isFunctionType) {
       registerBackendImpact(transformed, impacts.genericTypeCheck);
       if (inCheckedMode) {
         registerBackendImpact(transformed, impacts.genericCheckedModeTypeCheck);
       }
       if (type.isTypeVariable) {
         registerBackendImpact(transformed, impacts.typeVariableTypeCheck);
         if (inCheckedMode) {
-          registerBackendImpact(transformed,
-              impacts.typeVariableCheckedModeTypeCheck);
+          registerBackendImpact(
+              transformed, impacts.typeVariableCheckedModeTypeCheck);
         }
       }
     }
     if (type is FunctionType) {
       registerBackendImpact(transformed, impacts.functionTypeCheck);
     }
     if (type.element != null && backend.isNative(type.element)) {
       registerBackendImpact(transformed, impacts.nativeTypeCheck);
     }
   }
@@ skipping 53 matching lines @@
           break;
         default:
       }
     }
 
     for (ConstantValue constant in impact.compileTimeConstants) {
       backend.registerCompileTimeConstant(constant, registry);
       backend.addCompileTimeConstantForEmission(constant);
     }
 
-    for (Pair<DartType, DartType> check in
-            impact.typeVariableBoundsSubtypeChecks) {
+    for (Pair<DartType, DartType> check
+        in impact.typeVariableBoundsSubtypeChecks) {
       backend.registerTypeVariableBoundsSubtypeCheck(check.a, check.b);
     }
 
-
     for (StaticUse staticUse in impact.staticUses) {
       if (staticUse.kind == StaticUseKind.CLOSURE) {
         LocalFunctionElement closure = staticUse.element;
         if (backend.methodNeedsRti(closure)) {
-           registerBackendImpact(transformed, impacts.computeSignature);
-         }
+          registerBackendImpact(transformed, impacts.computeSignature);
+        }
       }
     }
 
     for (String name in impact.constSymbols) {
       backend.registerConstSymbol(name);
     }
 
     for (Set<ClassElement> classes in impact.specializedGetInterceptors) {
       backend.registerSpecializedGetInterceptor(classes);
     }
@@ skipping 34 matching lines @@
   const Dependency(this.constant, this.annotatedElement);
 }
 
 class JavaScriptImpactStrategy extends ImpactStrategy {
   final Resolution resolution;
   final DumpInfoTask dumpInfoTask;
   final bool supportDeferredLoad;
   final bool supportDumpInfo;
   final bool supportSerialization;
 
-  JavaScriptImpactStrategy(this.resolution,
-                           this.dumpInfoTask,
-                           {this.supportDeferredLoad,
-                            this.supportDumpInfo,
-                            this.supportSerialization});
+  JavaScriptImpactStrategy(this.resolution, this.dumpInfoTask,
+      {this.supportDeferredLoad,
+      this.supportDumpInfo,
+      this.supportSerialization});
 
   @override
-  void visitImpact(Element element,
-                   WorldImpact impact,
-                   WorldImpactVisitor visitor,
-                   ImpactUseCase impactUse) {
+  void visitImpact(Element element, WorldImpact impact,
+      WorldImpactVisitor visitor, ImpactUseCase impactUse) {
     // TODO(johnniwinther): Compute the application strategy once for each use.
     if (impactUse == ResolutionEnqueuer.IMPACT_USE) {
       if (supportDeferredLoad || supportSerialization) {
         impact.apply(visitor);
       } else {
         impact.apply(visitor);
         resolution.uncacheWorldImpact(element);
       }
     } else if (impactUse == DeferredLoadTask.IMPACT_USE) {
       impact.apply(visitor);
       // Impacts are uncached globally in [onImpactUsed].
     } else if (impactUse == DumpInfoTask.IMPACT_USE) {
       impact.apply(visitor);
       dumpInfoTask.unregisterImpact(element);
     } else {
       impact.apply(visitor);
     }
   }
 
   @override
   void onImpactUsed(ImpactUseCase impactUse) {
-    if (impactUse == DeferredLoadTask.IMPACT_USE &&
-        !supportSerialization) {
+    if (impactUse == DeferredLoadTask.IMPACT_USE && !supportSerialization) {
       // TODO(johnniwinther): Allow emptying when serialization has been
       // performed.
       resolution.emptyCache();
     }
   }
 }