dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/codegen/glue.dart

 // Copyright (c) 2014, 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 code_generator_dependencies;
 
-import '../backend_helpers.dart' show
-    BackendHelpers;
+import '../backend_helpers.dart' show BackendHelpers;
 import '../js_backend.dart';
 
 import '../../common.dart';
-import '../../common/codegen.dart' show
-    CodegenRegistry;
-import '../../compiler.dart' show
-    Compiler;
+import '../../common/codegen.dart' show CodegenRegistry;
+import '../../compiler.dart' show Compiler;
 import '../../constants/values.dart';
-import '../../dart_types.dart' show
-    DartType,
-    TypeVariableType,
-    InterfaceType;
-import '../../enqueue.dart' show
-    CodegenEnqueuer;
+import '../../dart_types.dart' show DartType, TypeVariableType, InterfaceType;
+import '../../enqueue.dart' show CodegenEnqueuer;
 import '../../elements/elements.dart';
 import '../../js_emitter/js_emitter.dart';
 import '../../js/js.dart' as js;
 import '../../native/native.dart' show NativeBehavior;
-import '../../universe/selector.dart' show
-    Selector;
-import '../../world.dart' show
-    ClassWorld;
+import '../../universe/selector.dart' show Selector;
+import '../../world.dart' show ClassWorld;
 import '../../types/types.dart';
 
 /// Encapsulates the dependencies of the function-compiler to the compiler,
 /// backend and emitter.
 // TODO(sigurdm): Should be refactored when we have a better feeling for the
 // interface.
 class Glue {
   final Compiler _compiler;
 
   CodegenEnqueuer get _enqueuer => _compiler.enqueuer.codegen;
@@ skipping 100 matching lines @@
 
   js.Name instanceFieldPropertyName(Element field) {
     return _namer.instanceFieldPropertyName(field);
   }
 
   js.Name instanceMethodName(FunctionElement element) {
     return _namer.instanceMethodName(element);
   }
 
   js.Expression prototypeAccess(ClassElement e,
-                                {bool hasBeenInstantiated: false}) {
+      {bool hasBeenInstantiated: false}) {
     return _emitter.prototypeAccess(e,
         hasBeenInstantiated: hasBeenInstantiated);
   }
 
   js.Name getInterceptorName(Set<ClassElement> interceptedClasses) {
     return _backend.namer.nameForGetInterceptor(interceptedClasses);
   }
 
   js.Expression getInterceptorLibrary() {
     return new js.VariableUse(
@@ skipping 63 matching lines @@
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     ClassWorld classWorld = _compiler.world;
     if (classWorld.isUsedAsMixin(cls)) return true;
 
     return _compiler.world.anyStrictSubclassOf(cls, (ClassElement subclass) {
       return !_backend.rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   js.Expression generateTypeRepresentation(DartType dartType,
-                                           List<js.Expression> arguments,
-                                           CodegenRegistry registry) {
+      List<js.Expression> arguments, CodegenRegistry registry) {
     int variableIndex = 0;
-    js.Expression representation = _backend.rtiEncoder.getTypeRepresentation(
-        dartType,
-        (_) => arguments[variableIndex++]);
+    js.Expression representation = _backend.rtiEncoder
+        .getTypeRepresentation(dartType, (_) => arguments[variableIndex++]);
     assert(variableIndex == arguments.length);
     // Representation contains JavaScript Arrays.
     registry.registerInstantiatedClass(_helpers.jsArrayClass);
     return representation;
   }
 
   js.Name getTypeTestTag(DartType type) {
     return _backend.namer.operatorIsType(type);
   }
 
@@ skipping 46 matching lines @@
   bool mayGenerateInstanceofCheck(DartType type) {
     return _backend.mayGenerateInstanceofCheck(type);
   }
 
   bool methodUsesReceiverArgument(FunctionElement function) {
     assert(isInterceptedMethod(function));
     ClassElement class_ = function.enclosingClass.declaration;
     return isInterceptorClass(class_) || isUsedAsMixin(class_);
   }
 }