dartfmt pkg/compiler

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.js_backend.helpers;
 
 import '../common.dart';
-import '../common/names.dart' show
-    Identifiers,
-    Uris;
-import '../common/resolution.dart' show
-    Resolution;
-import '../compiler.dart' show
-    Compiler;
-import '../core_types.dart' show
-    CoreClasses;
-import '../elements/elements.dart' show
-    AbstractFieldElement,
-    ClassElement,
-    ConstructorElement,
-    Element,
-    EnumClassElement,
-    FunctionElement,
-    LibraryElement,
-    MethodElement;
-import '../library_loader.dart' show
-    LoadedLibraries;
+import '../common/names.dart' show Identifiers, Uris;
+import '../common/resolution.dart' show Resolution;
+import '../compiler.dart' show Compiler;
+import '../core_types.dart' show CoreClasses;
+import '../elements/elements.dart'
+    show
+        AbstractFieldElement,
+        ClassElement,
+        ConstructorElement,
+        Element,
+        EnumClassElement,
+        FunctionElement,
+        LibraryElement,
+        MethodElement;
+import '../library_loader.dart' show LoadedLibraries;
 
 import 'js_backend.dart';
 
 /// Helper classes and functions for the JavaScript backend.
 class BackendHelpers {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
       new Uri(scheme: 'dart', path: '_js_mirrors');
-  static final Uri DART_JS_NAMES =
-      new Uri(scheme: 'dart', path: '_js_names');
+  static final Uri DART_JS_NAMES = new Uri(scheme: 'dart', path: '_js_names');
   static final Uri DART_EMBEDDED_NAMES =
       new Uri(scheme: 'dart', path: '_js_embedded_names');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
-  static final Uri PACKAGE_JS =
-         new Uri(scheme: 'package', path: 'js/js.dart');
+  static final Uri PACKAGE_JS = new Uri(scheme: 'package', path: 'js/js.dart');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
   final Compiler compiler;
 
   Element cachedCheckConcurrentModificationError;
 
   BackendHelpers(this.compiler);
 
   JavaScriptBackend get backend => compiler.backend;
 
   Resolution get resolution => backend.resolution;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   MethodElement assertTest;
   MethodElement assertThrow;
   MethodElement assertHelper;
 
-
   LibraryElement jsHelperLibrary;
   LibraryElement asyncLibrary;
   LibraryElement interceptorsLibrary;
   LibraryElement foreignLibrary;
   LibraryElement isolateHelperLibrary;
 
   /// Reference to the internal library to lookup functions to always inline.
   LibraryElement internalLibrary;
 
   ClassElement closureClass;
@@ skipping 115 matching lines @@
   }
 
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == DART_JS_HELPER) {
       jsHelperLibrary = library;
     } else if (uri == Uris.dart_async) {
       asyncLibrary = library;
     } else if (uri == Uris.dart__internal) {
       internalLibrary = library;
-    } else if (uri ==  DART_INTERCEPTORS) {
+    } else if (uri == DART_INTERCEPTORS) {
       interceptorsLibrary = library;
-    } else if (uri ==  DART_FOREIGN_HELPER) {
+    } else if (uri == DART_FOREIGN_HELPER) {
       foreignLibrary = library;
     } else if (uri == DART_ISOLATE_HELPER) {
       isolateHelperLibrary = library;
     }
   }
 
   void initializeHelperClasses(DiagnosticReporter reporter) {
     final List missingHelperClasses = [];
     ClassElement lookupHelperClass(String name) {
       ClassElement result = findHelper(name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
       return result;
     }
     jsInvocationMirrorClass = lookupHelperClass('JSInvocationMirror');
     boundClosureClass = lookupHelperClass('BoundClosure');
     closureClass = lookupHelperClass('Closure');
     if (!missingHelperClasses.isEmpty) {
-      reporter.internalError(jsHelperLibrary,
+      reporter.internalError(
+          jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
   }
 
   void onLibraryScanned(LibraryElement library) {
     Uri uri = library.canonicalUri;
 
     FunctionElement findMethod(String name) {
       return find(library, name);
@@ skipping 63 matching lines @@
       jsBuiltinEnum = find(library, 'JsBuiltin');
     } else if (uri == Uris.dart__native_typed_data) {
       typedArrayClass = findClass('NativeTypedArray');
       typedArrayOfIntClass = findClass('NativeTypedArrayOfInt');
     } else if (uri == PACKAGE_JS) {
       jsAnnotationClass = find(library, 'JS');
       jsAnonymousClass = find(library, '_Anonymous');
     }
   }
 
-
   void onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     assert(loadedLibraries.containsLibrary(Uris.dart_core));
     assert(loadedLibraries.containsLibrary(DART_INTERCEPTORS));
     assert(loadedLibraries.containsLibrary(DART_JS_HELPER));
 
     if (jsInvocationMirrorClass != null) {
       jsInvocationMirrorClass.ensureResolved(resolution);
       invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
     }
 
@@ skipping 10 matching lines @@
       jsFixedArrayClass.ensureResolved(resolution);
     }
     if (jsExtendableArrayClass != null) {
       jsExtendableArrayClass.ensureResolved(resolution);
     }
     if (jsUnmodifiableArrayClass != null) {
       jsUnmodifiableArrayClass.ensureResolved(resolution);
     }
 
     jsIndexableClass.ensureResolved(resolution);
-    jsIndexableLength = compiler.lookupElementIn(
-        jsIndexableClass, 'length');
+    jsIndexableLength = compiler.lookupElementIn(jsIndexableClass, 'length');
     if (jsIndexableLength != null && jsIndexableLength.isAbstractField) {
       AbstractFieldElement element = jsIndexableLength;
       jsIndexableLength = element.getter;
     }
 
     jsArrayClass.ensureResolved(resolution);
     jsArrayTypedConstructor = compiler.lookupElementIn(jsArrayClass, 'typed');
     jsArrayRemoveLast = compiler.lookupElementIn(jsArrayClass, 'removeLast');
     jsArrayAdd = compiler.lookupElementIn(jsArrayClass, 'add');
 
@@ skipping 34 matching lines @@
   }
 
   FunctionElement get closureFromTearOff {
     return findHelper('closureFromTearOff');
   }
 
   Element get isJsIndexable {
     return findHelper('isJsIndexable');
   }
 
-
   Element get throwIllegalArgumentException {
     return findHelper('iae');
   }
 
   Element get throwIndexOutOfRangeException {
     return findHelper('ioore');
   }
 
   Element get exceptionUnwrapper {
     return findHelper('unwrapException');
@@ skipping 191 matching lines @@
     return classElement.lookupConstructor("");
   }
 
   Element get syncCompleterConstructor {
     ClassElement classElement = find(compiler.asyncLibrary, "Completer");
     classElement.ensureResolved(resolution);
     return classElement.lookupConstructor("sync");
   }
 
   Element get asyncStarController {
-    ClassElement classElement =
-        findAsyncHelper("_AsyncStarStreamController");
+    ClassElement classElement = findAsyncHelper("_AsyncStarStreamController");
     classElement.ensureResolved(resolution);
     return classElement;
   }
 
   Element get asyncStarControllerConstructor {
     ClassElement classElement = asyncStarController;
     return classElement.lookupConstructor("");
   }
 
   Element get streamIteratorConstructor {
@@ skipping 61 matching lines @@
   MethodElement _objectNoSuchMethod;
 
   MethodElement get objectNoSuchMethod {
     if (_objectNoSuchMethod == null) {
       _objectNoSuchMethod =
           coreClasses.objectClass.lookupLocalMember(Identifiers.noSuchMethod_);
     }
     return _objectNoSuchMethod;
   }
 }