dartfmt pkg/compiler

pkg/compiler/lib/src/types/type_mask.dart

 // Copyright (c) 2013, 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.
 
 part of types;
 
 /// An implementation of a [UniverseSelectorConstraints] that is consists if an only
 /// increasing set of [TypeMask]s, that is, once a mask is added it cannot be
 /// removed.
 class IncreasingTypeMaskSet extends UniverseSelectorConstraints {
   bool isAll = false;
   Set<TypeMask> _masks;
 
   @override
   bool applies(Element element, Selector selector, ClassWorld world) {
     if (isAll) return true;
     if (_masks == null) return false;
     for (TypeMask mask in _masks) {
       if (mask.canHit(element, selector, world)) return true;
     }
     return false;
   }
 
   @override
   bool needsNoSuchMethodHandling(Selector selector, ClassWorld world) {
     if (isAll) {
-      TypeMask mask =
-          new TypeMask.subclass(world.objectClass, world);
+      TypeMask mask = new TypeMask.subclass(world.objectClass, world);
       return mask.needsNoSuchMethodHandling(selector, world);
     }
     for (TypeMask mask in _masks) {
       if (mask.needsNoSuchMethodHandling(selector, world)) {
         return true;
       }
     }
     return false;
   }
 
@@ skipping 30 matching lines @@
     return new IncreasingTypeMaskSet();
   }
 }
 
 /**
  * A type mask represents a set of contained classes, but the
  * operations on it are not guaranteed to be precise and they may
  * yield conservative answers that contain too many classes.
  */
 abstract class TypeMask implements ReceiverConstraint, AbstractValue {
-  factory TypeMask(ClassElement base,
-                   int kind,
-                   bool isNullable,
-                   ClassWorld classWorld) {
+  factory TypeMask(
+      ClassElement base, int kind, bool isNullable, ClassWorld classWorld) {
     return new FlatTypeMask.normalized(
         base, (kind << 1) | (isNullable ? 1 : 0), classWorld);
   }
 
   const factory TypeMask.empty() = FlatTypeMask.empty;
 
   factory TypeMask.exact(ClassElement base, ClassWorld classWorld) {
     assert(invariant(base, classWorld.isInstantiated(base),
         message: () => "Cannot create exact type mask for uninstantiated "
-                       "class $base.\n${classWorld.dump(base)}"));
+            "class $base.\n${classWorld.dump(base)}"));
     return new FlatTypeMask.exact(base);
   }
 
   factory TypeMask.exactOrEmpty(ClassElement base, ClassWorld classWorld) {
     if (classWorld.isInstantiated(base)) return new FlatTypeMask.exact(base);
     return const TypeMask.empty();
   }
 
   factory TypeMask.subclass(ClassElement base, ClassWorld classWorld) {
     assert(invariant(base, classWorld.isInstantiated(base),
         message: () => "Cannot create subclass type mask for uninstantiated "
-                       "class $base.\n${classWorld.dump(base)}"));
+            "class $base.\n${classWorld.dump(base)}"));
     ClassElement topmost = classWorld.getLubOfInstantiatedSubclasses(base);
     if (topmost == null) {
       return new TypeMask.empty();
     } else if (classWorld.hasAnyStrictSubclass(topmost)) {
       return new FlatTypeMask.subclass(topmost);
     } else {
       return new TypeMask.exact(topmost, classWorld);
     }
   }
 
@@ skipping 10 matching lines @@
     } else {
       return new TypeMask.exact(topmost, classWorld);
     }
   }
 
   const factory TypeMask.nonNullEmpty() = FlatTypeMask.nonNullEmpty;
 
   factory TypeMask.nonNullExact(ClassElement base, ClassWorld classWorld) {
     assert(invariant(base, classWorld.isInstantiated(base),
         message: () => "Cannot create exact type mask for uninstantiated "
-                       "class $base.\n${classWorld.dump(base)}"));
+            "class $base.\n${classWorld.dump(base)}"));
     return new FlatTypeMask.nonNullExact(base);
   }
 
-  factory TypeMask.nonNullExactOrEmpty(ClassElement base,
-      ClassWorld classWorld) {
+  factory TypeMask.nonNullExactOrEmpty(
+      ClassElement base, ClassWorld classWorld) {
     if (classWorld.isInstantiated(base)) {
       return new FlatTypeMask.nonNullExact(base);
     }
     return const TypeMask.nonNullEmpty();
   }
 
   factory TypeMask.nonNullSubclass(ClassElement base, ClassWorld classWorld) {
     assert(invariant(base, classWorld.isInstantiated(base),
         message: () => "Cannot create subclass type mask for uninstantiated "
-                       "class $base.\n${classWorld.dump(base)}"));
+            "class $base.\n${classWorld.dump(base)}"));
     ClassElement topmost = classWorld.getLubOfInstantiatedSubclasses(base);
     if (topmost == null) {
       return new TypeMask.nonNullEmpty();
     } else if (classWorld.hasAnyStrictSubclass(topmost)) {
       return new FlatTypeMask.nonNullSubclass(topmost);
     } else {
       return new TypeMask.nonNullExact(topmost, classWorld);
     }
   }
 
@@ skipping 129 matching lines @@
   bool containsOnlyBool(ClassWorld classWorld);
   bool containsOnlyString(ClassWorld classWorld);
   bool containsOnly(ClassElement element);
 
   /**
    * Compares two [TypeMask] objects for structural equality.
    *
    * Note: This may differ from semantic equality in the set containment sense.
    *   Use [containsMask] and [isInMask] for that, instead.
    */
-  bool operator==(other);
+  bool operator ==(other);
 
   /**
    * If this returns `true`, [other] is guaranteed to be a supertype of this
    * mask, i.e., this mask is in [other]. However, the inverse does not hold.
    * Enable [UnionTypeMask.PERFORM_EXTRA_CONTAINS_CHECK] to be notified of
    * false negatives.
    */
   bool isInMask(TypeMask other, ClassWorld classWorld);
 
   /**
@@ skipping 23 matching lines @@
    * Returns the [ClassElement] if this type represents a single class,
    * otherwise returns `null`.  This method is conservative.
    */
   ClassElement singleClass(ClassWorld classWorld);
 
   /**
    * Returns a type mask representing the union of [this] and [other].
    */
   TypeMask union(TypeMask other, ClassWorld classWorld);
 
-
   /// Returns whether the intersection of this and [other] is empty.
   bool isDisjoint(TypeMask other, ClassWorld classWorld);
 
   /**
    * Returns a type mask representing the intersection of [this] and [other].
    */
   TypeMask intersection(TypeMask other, ClassWorld classWorld);
 
   /**
    * Returns whether [element] is a potential target when being
    * invoked on this type mask. [selector] is used to ensure library
    * privacy is taken into account.
    */
   bool canHit(Element element, Selector selector, ClassWorld classWorld);
 
   /**
    * Returns the [element] that is known to always be hit at runtime
    * on this mask. Returns null if there is none.
    */
   // TODO(johnniwinther): Move this method to [World].
   Element locateSingleElement(
-      Selector selector,
-      TypeMask mask,
-      Compiler compiler);
+      Selector selector, TypeMask mask, Compiler compiler);
 }