dartfmt pkg/compiler

pkg/compiler/lib/src/native/enqueue.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.
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
-import '../common/backend_api.dart' show
-    ForeignResolver;
-import '../common/registry.dart' show
-    Registry;
-import '../common/resolution.dart' show
-    Parsing,
-    Resolution;
-import '../compiler.dart' show
-    Compiler;
+import '../common/backend_api.dart' show ForeignResolver;
+import '../common/registry.dart' show Registry;
+import '../common/resolution.dart' show Parsing, Resolution;
+import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
-import '../core_types.dart' show
-    CoreTypes;
+import '../core_types.dart' show CoreTypes;
 import '../dart_types.dart';
-import '../enqueue.dart' show
-    Enqueuer,
-    ResolutionEnqueuer;
+import '../enqueue.dart' show Enqueuer, ResolutionEnqueuer;
 import '../elements/elements.dart';
-import '../elements/modelx.dart' show
-    BaseClassElementX,
-    ElementX,
-    FunctionElementX,
-    LibraryElementX;
-import '../js_backend/backend_helpers.dart' show
-    BackendHelpers;
+import '../elements/modelx.dart'
+    show BaseClassElementX, ElementX, FunctionElementX, LibraryElementX;
+import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
-import '../js_emitter/js_emitter.dart' show
-    CodeEmitterTask,
-    NativeEmitter;
-import '../tokens/token.dart' show
-    BeginGroupToken,
-    Token;
-import '../tokens/token_constants.dart' as Tokens show
-    EOF_TOKEN,
-    STRING_TOKEN;
+import '../js_emitter/js_emitter.dart' show CodeEmitterTask, NativeEmitter;
+import '../tokens/token.dart' show BeginGroupToken, Token;
+import '../tokens/token_constants.dart' as Tokens show EOF_TOKEN, STRING_TOKEN;
 import '../tree/tree.dart';
 
 import 'behavior.dart';
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
   /// Initial entry point to native enqueuer.
   void processNativeClasses(Iterable<LibraryElement> libraries) {}
@@ skipping 23 matching lines @@
 
   /// Emits a summary information using the [log] function.
   void logSummary(log(message)) {}
 
   // Do not use annotations in dart2dart.
   ClassElement get annotationCreatesClass => null;
   ClassElement get annotationReturnsClass => null;
   ClassElement get annotationJsNameClass => null;
 }
 
-
 abstract class NativeEnqueuerBase implements NativeEnqueuer {
   static final RegExp _identifier = new RegExp(r'^[a-zA-Z_$][a-zA-Z0-9_$]*$');
 
   /**
    * The set of all native classes.  Each native class is in [nativeClasses] and
    * exactly one of [unusedClasses], [pendingClasses] and [registeredClasses].
    */
   final Set<ClassElement> nativeClasses = new Set<ClassElement>();
 
   final Set<ClassElement> registeredClasses = new Set<ClassElement>();
@@ skipping 85 matching lines @@
     //
     // String "A" has a potential subclass B.
 
     var potentialExtends = new Map<String, Set<ClassElement>>();
 
     libraries.forEach((library) {
       library.implementation.forEachLocalMember((element) {
         if (element.isClass) {
           String extendsName = findExtendsNameOfClass(element);
           if (extendsName != null) {
-            Set<ClassElement> potentialSubclasses =
-                potentialExtends.putIfAbsent(
-                    extendsName,
-                    () => new Set<ClassElement>());
+            Set<ClassElement> potentialSubclasses = potentialExtends
+                .putIfAbsent(extendsName, () => new Set<ClassElement>());
             potentialSubclasses.add(element);
           }
         }
       });
     });
 
     // Resolve all the native classes and any classes that might extend them in
     // [potentialExtends], and then check that the properly resolved class is in
     // fact a subclass of a native class.
 
     ClassElement nativeSuperclassOf(ClassElement classElement) {
       if (backend.isNative(classElement)) return classElement;
       if (classElement.superclass == null) return null;
       return nativeSuperclassOf(classElement.superclass);
     }
 
     void walkPotentialSubclasses(ClassElement element) {
       if (nativeClassesAndSubclasses.contains(element)) return;
       element.ensureResolved(resolution);
       ClassElement nativeSuperclass = nativeSuperclassOf(element);
       if (nativeSuperclass != null) {
         nativeClassesAndSubclasses.add(element);
         if (!backend.isNative(element)) {
-          nonNativeSubclasses.putIfAbsent(nativeSuperclass,
-              () => new Set<ClassElement>())
-            .add(element);
+          nonNativeSubclasses
+              .putIfAbsent(nativeSuperclass, () => new Set<ClassElement>())
+              .add(element);
         }
         Set<ClassElement> potentialSubclasses = potentialExtends[element.name];
         if (potentialSubclasses != null) {
           potentialSubclasses.forEach(walkPotentialSubclasses);
         }
       }
     }
 
     nativeClasses.forEach(walkPotentialSubclasses);
 
@@ skipping 110 matching lines @@
       annotation.ensureResolved(resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(annotation.constant);
       if (!value.isConstructedObject) continue;
       ConstructedConstantValue constructedObject = value;
       if (constructedObject.type.element != annotationClass) continue;
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || fields.single is! StringConstantValue) {
-        reporter.internalError(annotation,
-            'Annotations needs one string: ${annotation.node}');
+        reporter.internalError(
+            annotation, 'Annotations needs one string: ${annotation.node}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       if (name == null) {
         name = specString;
       } else {
-        reporter.internalError(annotation,
-            'Too many JSName annotations: ${annotation.node}');
+        reporter.internalError(
+            annotation, 'Too many JSName annotations: ${annotation.node}');
       }
     }
     return name;
   }
 
   enqueueClass(ClassElement classElement, cause) {
     assert(unusedClasses.contains(classElement));
     unusedClasses.remove(classElement);
     pendingClasses.add(classElement);
-    queue.add(() { processClass(classElement, cause); });
+    queue.add(() {
+      processClass(classElement, cause);
+    });
   }
 
   void flushQueue() {
     if (flushing) return;
     flushing = true;
     while (!queue.isEmpty) {
       (queue.removeFirst())();
     }
     flushing = false;
   }
 
   processClass(ClassElement classElement, cause) {
     // TODO(ahe): Fix this assertion to work in incremental compilation.
     assert(compiler.options.hasIncrementalSupport ||
-           !registeredClasses.contains(classElement));
+        !registeredClasses.contains(classElement));
 
     bool firstTime = registeredClasses.isEmpty;
     pendingClasses.remove(classElement);
     registeredClasses.add(classElement);
 
     // TODO(ahe): Is this really a global dependency?
     classElement.ensureResolved(resolution);
     compiler.backend.registerInstantiatedType(
         classElement.rawType, world, compiler.globalDependencies);
 
@@ skipping 66 matching lines @@
   ///    use the declared @JSName as the expression
   /// 3. If [element] does not have a @JSName annotation, qualify the name of
   ///    the method with the @Native name of the enclosing class.
   void _setNativeNameForStaticMethod(MethodElement element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     if (isIdentifier(name)) {
       List<String> nativeNames =
           backend.nativeData.getNativeTagsOfClassRaw(element.enclosingClass);
       if (nativeNames.length != 1) {
-        reporter.internalError(element,
+        reporter.internalError(
+            element,
             'Unable to determine a native name for the enclosing class, '
             'options: $nativeNames');
       }
-      backend.nativeData.setNativeMemberName(
-          element, '${nativeNames[0]}.$name');
+      backend.nativeData
+          .setNativeMemberName(element, '${nativeNames[0]}.$name');
     } else {
       backend.nativeData.setNativeMemberName(element, name);
     }
   }
 
   bool isIdentifier(String s) => _identifier.hasMatch(s);
 
   bool isNativeMethod(FunctionElementX element) {
     if (!backend.canLibraryUseNative(element.library)) return false;
     // Native method?
@@ skipping 42 matching lines @@
         continue;
       }
       if (type is InterfaceType) {
         if (type == coreTypes.intType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.doubleType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.numType) {
           backend.registerInstantiatedType(
               coreTypes.doubleType, world, registry);
-          backend.registerInstantiatedType(
-              coreTypes.intType, world, registry);
+          backend.registerInstantiatedType(coreTypes.intType, world, registry);
         } else if (type == coreTypes.stringType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.nullType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.boolType) {
           backend.registerInstantiatedType(type, world, registry);
-        } else if (compiler.types.isSubtype(
-                      type, backend.listImplementation.rawType)) {
+        } else if (compiler.types
+            .isSubtype(type, backend.listImplementation.rawType)) {
           backend.registerInstantiatedType(type, world, registry);
         }
       }
       assert(type is DartType);
       enqueueUnusedClassesMatching(
           (nativeClass) => compiler.types.isSubtype(nativeClass.thisType, type),
           cause,
           'subtypeof($type)');
     }
 
     // Give an info so that library developers can compile with -v to find why
     // all the native classes are included.
     if (unusedClasses.isEmpty && !allUsedBefore) {
       reporter.log('All native types marked as used due to $cause.');
     }
   }
 
-  enqueueUnusedClassesMatching(bool predicate(classElement),
-                               cause,
-                               [String reason]) {
+  enqueueUnusedClassesMatching(bool predicate(classElement), cause,
+      [String reason]) {
     Iterable matches = unusedClasses.where(predicate);
     matches.toList().forEach((c) => enqueueClass(c, cause));
   }
 
   onFirstNativeClass() {
     staticUse(name) {
       backend.enqueue(
           world, helpers.findHelper(name), compiler.globalDependencies);
     }
 
     staticUse('defineProperty');
     staticUse('toStringForNativeObject');
     staticUse('hashCodeForNativeObject');
     staticUse('convertDartClosureToJS');
     addNativeExceptions();
   }
 
   addNativeExceptions() {
     enqueueUnusedClassesMatching((classElement) {
-        // TODO(sra): Annotate exception classes in dart:html.
-        String name = classElement.name;
-        if (name.contains('Exception')) return true;
-        if (name.contains('Error')) return true;
-        return false;
-      },
-      'native exception');
+      // TODO(sra): Annotate exception classes in dart:html.
+      String name = classElement.name;
+      if (name.contains('Exception')) return true;
+      if (name.contains('Error')) return true;
+      return false;
+    }, 'native exception');
   }
 }
 
-
 class NativeResolutionEnqueuer extends NativeEnqueuerBase {
-
   Map<String, ClassElement> tagOwner = new Map<String, ClassElement>();
 
   NativeResolutionEnqueuer(Enqueuer world, Compiler compiler)
-    : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
+      : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
 
   void processNativeClass(ClassElement classElement) {
     super.processNativeClass(classElement);
 
     // Js Interop interfaces do not have tags.
     if (backend.isJsInterop(classElement)) return;
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in backend.nativeData.getNativeTagsOfClass(classElement)) {
       ClassElement owner = tagOwner[tag];
@@ skipping 22 matching lines @@
    *     JS('_DOMWindowImpl', 'window')
    *
    */
   void registerJsCall(Send node, ForeignResolver resolver) {
     NativeBehavior behavior = NativeBehavior.ofJsCall(
         node, reporter, compiler.parsing, compiler.coreTypes, resolver);
     registerNativeBehavior(behavior, node);
     nativeBehaviors[node] = behavior;
   }
 
-
   /**
    * Handles JS-embedded global calls, which can be an instantiation point for
    * types.
    *
    * For example, the following code instantiates and returns a String class
    *
    *     JS_EMBEDDED_GLOBAL('String', 'foo')
    *
    */
   void registerJsEmbeddedGlobalCall(Send node, ForeignResolver resolver) {
     NativeBehavior behavior = NativeBehavior.ofJsEmbeddedGlobalCall(
         node, reporter, compiler.parsing, compiler.coreTypes, resolver);
     registerNativeBehavior(behavior, node);
     nativeBehaviors[node] = behavior;
   }
 
-
   /**
    * Handles JS-compiler builtin calls, which can be an instantiation point for
    * types.
    *
    * For example, the following code instantiates and returns a String class
    *
    *     JS_BUILTIN('String', 'int2string', 0)
    *
    */
   void registerJsBuiltinCall(Send node, ForeignResolver resolver) {
     NativeBehavior behavior = NativeBehavior.ofJsBuiltinCall(
         node, reporter, compiler.parsing, compiler.coreTypes, resolver);
     registerNativeBehavior(behavior, node);
     nativeBehaviors[node] = behavior;
   }
 }
 
-
 class NativeCodegenEnqueuer extends NativeEnqueuerBase {
-
   final CodeEmitterTask emitter;
 
   final Set<ClassElement> doneAddSubtypes = new Set<ClassElement>();
 
   NativeCodegenEnqueuer(Enqueuer world, Compiler compiler, this.emitter)
-    : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
+      : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
 
   void processNativeClasses(Iterable<LibraryElement> libraries) {
     super.processNativeClasses(libraries);
 
     // HACK HACK - add all the resolved classes.
     NativeEnqueuerBase enqueuer = compiler.enqueuer.resolution.nativeEnqueuer;
     for (final classElement in enqueuer.registeredClasses) {
       if (unusedClasses.contains(classElement)) {
         enqueueClass(classElement, 'was resolved');
       }
@@ skipping 11 matching lines @@
   void addSubtypes(ClassElement cls, NativeEmitter emitter) {
     if (!backend.isNative(cls)) return;
     if (doneAddSubtypes.contains(cls)) return;
     doneAddSubtypes.add(cls);
 
     // Walk the superclass chain since classes on the superclass chain might not
     // be instantiated (abstract or simply unused).
     addSubtypes(cls.superclass, emitter);
 
     for (DartType type in cls.allSupertypes) {
-      List<Element> subtypes = emitter.subtypes.putIfAbsent(
-          type.element,
-          () => <ClassElement>[]);
+      List<Element> subtypes =
+          emitter.subtypes.putIfAbsent(type.element, () => <ClassElement>[]);
       subtypes.add(cls);
     }
 
     // Skip through all the mixin applications in the super class
     // chain. That way, the direct subtypes set only contain the
     // natives classes.
     ClassElement superclass = cls.superclass;
     while (superclass != null && superclass.isMixinApplication) {
       assert(!backend.isNative(superclass));
       superclass = superclass.superclass;
     }
 
-    List<Element> directSubtypes = emitter.directSubtypes.putIfAbsent(
-        superclass,
-        () => <ClassElement>[]);
+    List<Element> directSubtypes =
+        emitter.directSubtypes.putIfAbsent(superclass, () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }