dartfmt pkg/compiler

pkg/compiler/lib/src/universe/universe.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.
 
 library universe;
 
 import 'dart:collection';
 
 import '../common.dart';
-import '../compiler.dart' show
-    Compiler;
+import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
 import '../dart_types.dart';
 import '../util/util.dart';
-import '../world.dart' show
-    ClassWorld,
-    World;
+import '../world.dart' show ClassWorld, World;
 
-import 'selector.dart' show
-    Selector;
-import 'use.dart' show
-    DynamicUse,
-    DynamicUseKind,
-    StaticUse,
-    StaticUseKind;
+import 'selector.dart' show Selector;
+import 'use.dart' show DynamicUse, DynamicUseKind, StaticUse, StaticUseKind;
 
 /// The known constraint on receiver for a dynamic call site.
 ///
 /// This can for instance be used to constrain this dynamic call to `foo` to
 /// 'receivers of the exact instance `Bar`':
 ///
 ///     class Bar {
 ///        void foo() {}
 ///     }
 ///     main() => new Bar().foo();
@@ skipping 184 matching lines @@
     return _implementedClasses.contains(cls.declaration);
   }
 
   /// Register [type] as (directly) instantiated.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
   void registerTypeInstantiation(InterfaceType type,
-                                 {bool byMirrors: false,
-                                  bool isNative: false,
-                                  void onImplemented(ClassElement cls)}) {
+      {bool byMirrors: false,
+      bool isNative: false,
+      void onImplemented(ClassElement cls)}) {
     _instantiatedTypes.add(type);
     ClassElement cls = type.element;
     if (!cls.isAbstract
         // We can't use the closed-world assumption with native abstract
         // classes; a native abstract class may have non-abstract subclasses
         // not declared to the program.  Instances of these classes are
         // indistinguishable from the abstract class.
-        || isNative
+        ||
+        isNative
         // Likewise, if this registration comes from the mirror system,
         // all bets are off.
         // TODO(herhut): Track classes required by mirrors seperately.
-        || byMirrors) {
+        ||
+        byMirrors) {
       _directlyInstantiatedClasses.add(cls);
     }
 
     // TODO(johnniwinther): Replace this by separate more specific mappings that
     // include the type arguments.
     if (_implementedClasses.add(cls)) {
       onImplemented(cls);
       cls.allSupertypes.forEach((InterfaceType supertype) {
         if (_implementedClasses.add(supertype.element)) {
           onImplemented(supertype.element);
         }
       });
     }
   }
 
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
-                            Element member,
-                            World world) {
+      Element member, World world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
       if (selector.appliesUnnamed(member, world)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
     }
     return false;
@@ skipping 16 matching lines @@
     switch (dynamicUse.kind) {
       case DynamicUseKind.INVOKE:
         return _registerNewSelector(dynamicUse, _invokedNames);
       case DynamicUseKind.GET:
         return _registerNewSelector(dynamicUse, _invokedGetters);
       case DynamicUseKind.SET:
         return _registerNewSelector(dynamicUse, _invokedSetters);
     }
   }
 
-  bool _registerNewSelector(
-      DynamicUse dynamicUse,
+  bool _registerNewSelector(DynamicUse dynamicUse,
       Map<String, Map<Selector, SelectorConstraints>> selectorMap) {
     Selector selector = dynamicUse.selector;
     String name = selector.name;
     ReceiverConstraint mask = dynamicUse.mask;
     Map<Selector, SelectorConstraints> selectors = selectorMap.putIfAbsent(
         name, () => new Maplet<Selector, SelectorConstraints>());
-    UniverseSelectorConstraints constraints = selectors.putIfAbsent(
-        selector, () {
+    UniverseSelectorConstraints constraints =
+        selectors.putIfAbsent(selector, () {
       return selectorConstraintsStrategy.createSelectorConstraints(selector);
     });
     return constraints.addReceiverConstraint(mask);
   }
 
   Map<Selector, SelectorConstraints> _asUnmodifiable(
       Map<Selector, SelectorConstraints> map) {
     if (map == null) return null;
     return new UnmodifiableMapView(map);
   }
@@ skipping 63 matching lines @@
   }
 
   void forgetElement(Element element, Compiler compiler) {
     allClosures.remove(element);
     slowDirectlyNestedClosures(element).forEach(compiler.forgetElement);
     closurizedMembers.remove(element);
     fieldSetters.remove(element);
     fieldGetters.remove(element);
     _directlyInstantiatedClasses.remove(element);
     if (element is ClassElement) {
-      assert(invariant(
-          element, element.thisType.isRaw,
+      assert(invariant(element, element.thisType.isRaw,
           message: 'Generic classes not supported (${element.thisType}).'));
-      _instantiatedTypes
-          ..remove(element.rawType)
-          ..remove(element.thisType);
+      _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
     }
   }
 
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
-          return closure.executableContext == element;
-        }));
+      return closure.executableContext == element;
+    }));
   }
 }