dartfmt pkg/compiler

pkg/compiler/lib/src/types/union_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;
 
 class UnionTypeMask implements TypeMask {
   final Iterable<FlatTypeMask> disjointMasks;
 
   static const int MAX_UNION_LENGTH = 4;
 
   // Set this flag to `true` to perform a set-membership based containment check
   // instead of relying on normalized types. This is quite slow but can be
   // helpful in debugging.
   static const bool PERFORM_EXTRA_CONTAINS_CHECK = false;
 
   UnionTypeMask._internal(this.disjointMasks) {
     assert(disjointMasks.length > 1);
     assert(disjointMasks.every((TypeMask mask) => !mask.isUnion));
   }
 
   static TypeMask unionOf(Iterable<TypeMask> masks, ClassWorld classWorld) {
-    assert(masks.every((mask) => TypeMask.assertIsNormalized(mask, classWorld)));
+    assert(
+        masks.every((mask) => TypeMask.assertIsNormalized(mask, classWorld)));
     List<FlatTypeMask> disjoint = <FlatTypeMask>[];
     unionOfHelper(masks, disjoint, classWorld);
     if (disjoint.isEmpty) return new TypeMask.nonNullEmpty();
     if (disjoint.length > MAX_UNION_LENGTH) {
       return flatten(disjoint, classWorld);
     }
     if (disjoint.length == 1) return disjoint[0];
     UnionTypeMask union = new UnionTypeMask._internal(disjoint);
     assert(TypeMask.assertIsNormalized(union, classWorld));
     return union;
   }
 
   static void unionOfHelper(Iterable<TypeMask> masks,
-                            List<FlatTypeMask> disjoint,
-                            ClassWorld classWorld) {
+      List<FlatTypeMask> disjoint, ClassWorld classWorld) {
     // TODO(johnniwinther): Impose an order on the mask to ensure subclass masks
     // are preferred to subtype masks.
     for (TypeMask mask in masks) {
       mask = TypeMask.nonForwardingMask(mask);
       if (mask.isUnion) {
         UnionTypeMask union = mask;
         unionOfHelper(union.disjointMasks, disjoint, classWorld);
       } else if (mask.isEmpty) {
         continue;
       } else {
@@ skipping 47 matching lines @@
 
     List<ClassElement> masksBases = masks.map((mask) => mask.base).toList();
     Iterable<ClassElement> candidates =
         classWorld.commonSupertypesOf(masksBases);
 
     // Compute the best candidate and its kind.
     ClassElement bestElement;
     int bestKind;
     int bestSize;
     for (ClassElement candidate in candidates) {
-      bool isInstantiatedStrictSubclass(cls) => cls != candidate &&
+      bool isInstantiatedStrictSubclass(cls) =>
+          cls != candidate &&
           classWorld.isDirectlyInstantiated(cls) &&
           classWorld.isSubclassOf(cls, candidate);
 
       int size;
       int kind;
       if (useSubclass && masksBases.every(isInstantiatedStrictSubclass)) {
         // If both [this] and [other] are subclasses of the supertype,
         // then we prefer to construct a subclass type mask because it
         // will always be at least as small as the corresponding
         // subtype type mask.
@@ skipping 14 matching lines @@
         bestKind = kind;
       }
     }
     return new TypeMask(bestElement, bestKind, isNullable, classWorld);
   }
 
   TypeMask union(var other, ClassWorld classWorld) {
     other = TypeMask.nonForwardingMask(other);
     if (!other.isUnion && disjointMasks.contains(other)) return this;
 
-    List<FlatTypeMask> newList =
-        new List<FlatTypeMask>.from(disjointMasks);
+    List<FlatTypeMask> newList = new List<FlatTypeMask>.from(disjointMasks);
     if (!other.isUnion) {
       newList.add(other);
     } else {
       assert(other is UnionTypeMask);
       newList.addAll(other.disjointMasks);
     }
     return new TypeMask.unionOf(newList, classWorld);
   }
 
   TypeMask intersection(var other, ClassWorld classWorld) {
@@ skipping 162 matching lines @@
     return disjointMasks.any((e) => e.contains(type, classWorld));
   }
 
   bool containsAll(ClassWorld classWorld) {
     return disjointMasks.any((mask) => mask.containsAll(classWorld));
   }
 
   ClassElement singleClass(ClassWorld classWorld) => null;
 
   bool needsNoSuchMethodHandling(Selector selector, ClassWorld classWorld) {
-    return disjointMasks.any(
-        (e) => e.needsNoSuchMethodHandling(selector, classWorld));
+    return disjointMasks
+        .any((e) => e.needsNoSuchMethodHandling(selector, classWorld));
   }
 
   bool canHit(Element element, Selector selector, ClassWorld classWorld) {
     return disjointMasks.any((e) => e.canHit(element, selector, classWorld));
   }
 
-  Element locateSingleElement(Selector selector,
-                              TypeMask mask,
-                              Compiler compiler) {
+  Element locateSingleElement(
+      Selector selector, TypeMask mask, Compiler compiler) {
     Element candidate;
     for (FlatTypeMask mask in disjointMasks) {
       Element current = mask.locateSingleElement(selector, mask, compiler);
       if (current == null) {
         return null;
       } else if (candidate == null) {
         candidate = current;
       } else if (candidate != current) {
         return null;
       }
     }
     return candidate;
   }
 
   String toString() {
-    String masksString = (disjointMasks.map((TypeMask mask) => mask.toString())
-        .toList()..sort()).join(", ");
+    String masksString =
+        (disjointMasks.map((TypeMask mask) => mask.toString()).toList()..sort())
+            .join(", ");
     return 'Union of [$masksString]';
   }
 
-  bool operator==(other) {
+  bool operator ==(other) {
     if (identical(this, other)) return true;
 
     bool containsAll() {
       return other.disjointMasks.every((e) {
         var map = disjointMasks.map((e) => e.nonNullable());
         return map.contains(e.nonNullable());
       });
     }
 
-    return other is UnionTypeMask
-        && other.isNullable == isNullable
-        && other.disjointMasks.length == disjointMasks.length
-        && containsAll();
+    return other is UnionTypeMask &&
+        other.isNullable == isNullable &&
+        other.disjointMasks.length == disjointMasks.length &&
+        containsAll();
   }
 
   int get hashCode {
     int hashCode = isNullable ? 86 : 43;
     // The order of the masks in [disjointMasks] must not affect the
     // hashCode.
     for (var mask in disjointMasks) {
       hashCode = (hashCode ^ mask.nonNullable().hashCode) & 0x3fffffff;
     }
     return hashCode;
   }
 }