dartfmt pkg/compiler

pkg/compiler/lib/src/universe/function_set.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.function_set;
 
-import '../common/names.dart' show
-    Identifiers,
-    Selectors;
-import '../compiler.dart' show
-    Compiler;
+import '../common/names.dart' show Identifiers, Selectors;
+import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
 import '../types/types.dart';
-import '../util/util.dart' show
-    Hashing,
-    Setlet;
-import '../world.dart' show
-    ClassWorld;
+import '../util/util.dart' show Hashing, Setlet;
+import '../world.dart' show ClassWorld;
 
-import 'selector.dart' show
-    Selector;
-import 'universe.dart' show
-    ReceiverConstraint;
+import 'selector.dart' show Selector;
+import 'universe.dart' show ReceiverConstraint;
 
 // TODO(kasperl): This actually holds getters and setters just fine
 // too and stricly they aren't functions. Maybe this needs a better
 // name -- something like ElementSet seems a bit too generic.
 class FunctionSet {
   final Compiler compiler;
-  final Map<String, FunctionSetNode> nodes =
-      new Map<String, FunctionSetNode>();
+  final Map<String, FunctionSetNode> nodes = new Map<String, FunctionSetNode>();
   FunctionSet(this.compiler);
 
   ClassWorld get classWorld => compiler.world;
 
-  FunctionSetNode newNode(String name)
-      => new FunctionSetNode(name);
+  FunctionSetNode newNode(String name) => new FunctionSetNode(name);
 
   void add(Element element) {
     assert(element.isInstanceMember);
     assert(!element.isAbstract);
     String name = element.name;
     FunctionSetNode node = nodes.putIfAbsent(name, () => newNode(name));
     node.add(element);
   }
 
   void remove(Element element) {
     assert(element.isInstanceMember);
     assert(!element.isAbstract);
     String name = element.name;
     FunctionSetNode node = nodes[name];
     if (node != null) {
       node.remove(element);
     }
   }
 
   bool contains(Element element) {
     assert(element.isInstanceMember);
     assert(!element.isAbstract);
     String name = element.name;
     FunctionSetNode node = nodes[name];
-    return (node != null)
-        ? node.contains(element)
-        : false;
+    return (node != null) ? node.contains(element) : false;
   }
 
   /// Returns an object that allows iterating over all the functions
   /// that may be invoked with the given [selector].
   Iterable<Element> filter(Selector selector, ReceiverConstraint constraint) {
     return query(selector, constraint).functions;
   }
 
   /// Returns the mask for the potential receivers of a dynamic call to
   /// [selector] on [constraint].
@@ skipping 134 matching lines @@
     assert(element.name == name);
     return elements.contains(element);
   }
 
   void forEach(Function action) {
     elements.forEach(action);
   }
 
   /// Returns the set of functions that can be the target of [selectorMask]
   /// including no such method handling where applicable.
-  FunctionSetQuery query(SelectorMask selectorMask,
-                         ClassWorld classWorld,
-                         [FunctionSetNode noSuchMethods,
-                          SelectorMask noSuchMethodMask]) {
+  FunctionSetQuery query(SelectorMask selectorMask, ClassWorld classWorld,
+      [FunctionSetNode noSuchMethods, SelectorMask noSuchMethodMask]) {
     assert(selectorMask.name == name);
     FunctionSetQuery result = cache[selectorMask];
     if (result != null) return result;
 
     Setlet<Element> functions;
     for (Element element in elements) {
       if (selectorMask.applies(element, classWorld)) {
         if (functions == null) {
           // Defer the allocation of the functions set until we are
           // sure we need it. This allows us to return immutable empty
@@ skipping 53 matching lines @@
   final Iterable<Element> functions;
 
   TypeMask _mask;
 
   FullFunctionSetQuery(this.functions);
 
   @override
   TypeMask computeMask(ClassWorld classWorld) {
     assert(classWorld.hasAnyStrictSubclass(classWorld.objectClass));
     if (_mask != null) return _mask;
-    return _mask = new TypeMask.unionOf(functions
-        .expand((element) {
+    return _mask = new TypeMask.unionOf(
+        functions.expand((element) {
           ClassElement cls = element.enclosingClass;
           return [cls]..addAll(classWorld.mixinUsesOf(cls));
-        })
-        .map((cls) {
+        }).map((cls) {
           if (classWorld.backend.isNullImplementation(cls)) {
             return const TypeMask.empty();
           } else if (classWorld.isInstantiated(cls.declaration)) {
             return new TypeMask.nonNullSubclass(cls.declaration, classWorld);
           } else {
             // TODO(johnniwinther): Avoid the need for this case.
             return const TypeMask.empty();
           }
         }),
         classWorld);
   }
 }