dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/type_mask_system.dart

 // Copyright (c) 2015, 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 dart2js.type_mask_system;
 
 import '../common/names.dart' show Selectors, Identifiers;
 import '../compiler.dart' as dart2js show Compiler;
 import '../constants/values.dart';
 import '../dart_types.dart' as types;
@@ skipping 86 matching lines @@
     if (_numStringBoolType == null) {
       // Build the number+string+bool type. To make containment tests more
       // inclusive, we use the num, String, bool types for this, not
       // the JSNumber, JSString, JSBool subclasses.
       TypeMask anyNum =
           new TypeMask.nonNullSubtype(classWorld.numClass, classWorld);
       TypeMask anyString =
           new TypeMask.nonNullSubtype(classWorld.stringClass, classWorld);
       TypeMask anyBool =
           new TypeMask.nonNullSubtype(classWorld.boolClass, classWorld);
-      _numStringBoolType =
-          new TypeMask.unionOf(<TypeMask>[anyNum, anyString, anyBool],
-              classWorld);
+      _numStringBoolType = new TypeMask.unionOf(
+          <TypeMask>[anyNum, anyString, anyBool], classWorld);
     }
     return _numStringBoolType;
   }
 
   @override
   TypeMask get fixedLengthType {
     if (_fixedLengthType == null) {
-      List<TypeMask> fixedLengthTypes =
-          <TypeMask>[stringType, backend.fixedArrayType];
+      List<TypeMask> fixedLengthTypes = <TypeMask>[
+        stringType,
+        backend.fixedArrayType
+      ];
       if (classWorld.isInstantiated(helpers.typedArrayClass)) {
         fixedLengthTypes.add(nonNullSubclass(helpers.typedArrayClass));
       }
       _fixedLengthType = new TypeMask.unionOf(fixedLengthTypes, classWorld);
     }
     return _fixedLengthType;
   }
 
   @override
   TypeMask get interceptorType {
     if (_interceptorType == null) {
       _interceptorType =
-        new TypeMask.nonNullSubtype(helpers.jsInterceptorClass, classWorld);
+          new TypeMask.nonNullSubtype(helpers.jsInterceptorClass, classWorld);
     }
     return _interceptorType;
   }
 
   @override
-  TypeMask get interceptedTypes { // Does not include null.
+  TypeMask get interceptedTypes {
+    // Does not include null.
     if (_interceptedTypes == null) {
       // We redundantly include subtypes of num/string/bool as intercepted
       // types, because the type system does not infer that their
       // implementations are all subclasses of Interceptor.
       _interceptedTypes = new TypeMask.unionOf(
           <TypeMask>[interceptorType, numStringBoolType], classWorld);
     }
     return _interceptedTypes;
   }
 
   TypeMask get _indexableTypeTest {
     if (__indexableTypeTest == null) {
       // Make a TypeMask containing Indexable and (redundantly) subtypes of
       // string because the type inference does not infer that all strings are
       // indexables.
       TypeMask indexable =
           new TypeMask.nonNullSubtype(helpers.jsIndexableClass, classWorld);
       TypeMask anyString =
           new TypeMask.nonNullSubtype(classWorld.stringClass, classWorld);
-      __indexableTypeTest = new TypeMask.unionOf(
-          <TypeMask>[indexable, anyString],
-          classWorld);
+      __indexableTypeTest =
+          new TypeMask.unionOf(<TypeMask>[indexable, anyString], classWorld);
     }
     return __indexableTypeTest;
   }
 
   ClassElement get jsNullClass => helpers.jsNullClass;
 
   BackendHelpers get helpers => backend.helpers;
 
   // TODO(karlklose): remove compiler here.
   TypeMaskSystem(dart2js.Compiler compiler)
       : inferrer = compiler.typesTask,
         classWorld = compiler.world,
-        backend = compiler.backend {
-  }
+        backend = compiler.backend {}
 
   @override
   bool methodIgnoresReceiverArgument(FunctionElement function) {
     assert(backend.isInterceptedMethod(function));
     ClassElement clazz = function.enclosingClass.declaration;
     return !clazz.isSubclassOf(helpers.jsInterceptorClass) &&
-           !classWorld.isUsedAsMixin(clazz);
+        !classWorld.isUsedAsMixin(clazz);
   }
 
   @override
   bool targetIgnoresReceiverArgument(TypeMask type, Selector selector) {
     // Check if any of the possible targets depend on the extra receiver
     // argument. Mixins do this, and tear-offs always needs the extra receiver
     // argument because BoundClosure uses it for equality and hash code.
     // TODO(15933): Make automatically generated property extraction
     // closures work with the dummy receiver optimization.
     bool needsReceiver(Element target) {
       if (target is! FunctionElement) return false;
       FunctionElement function = target;
       return selector.isGetter && !function.isGetter ||
-             !methodIgnoresReceiverArgument(function);
+          !methodIgnoresReceiverArgument(function);
     }
     return !classWorld.allFunctions.filter(selector, type).any(needsReceiver);
   }
 
   @override
   Element locateSingleElement(TypeMask mask, Selector selector) {
     return mask.locateSingleElement(selector, mask, classWorld.compiler);
   }
 
   @override
@@ skipping 59 matching lines @@
     return a.union(b, classWorld);
   }
 
   @override
   TypeMask intersection(TypeMask a, TypeMask b) {
     if (a == null) return b;
     if (b == null) return a;
     return a.intersection(b, classWorld);
   }
 
-  void associateConstantValueWithElement(ConstantValue constant,
-                                         Element element) {
+  void associateConstantValueWithElement(
+      ConstantValue constant, Element element) {
     // TODO(25093): Replace this code with an approach that works for anonymous
     // constants and non-constant literals.
     if (constant is ListConstantValue || constant is MapConstantValue) {
       // Inferred type is usually better (e.g. a ContainerTypeMask) but is
       // occasionally less general.
       TypeMask computed = computeTypeMask(inferrer.compiler, constant);
       TypeMask inferred = inferrer.getGuaranteedTypeOfElement(element);
       TypeMask best = intersection(inferred, computed);
       assert(!best.isEmptyOrNull);
       _constantMasks[constant] = best;
     }
   }
 
   @override
   TypeMask getTypeOf(ConstantValue constant) {
     return _constantMasks[constant] ??
-           computeTypeMask(inferrer.compiler, constant);
+        computeTypeMask(inferrer.compiler, constant);
   }
 
   @override
   ConstantValue getConstantOf(TypeMask mask) {
     if (!mask.isValue) return null;
-    if (mask.isNullable) return null;  // e.g. 'true or null'.
+    if (mask.isNullable) return null; // e.g. 'true or null'.
     ValueTypeMask valueMask = mask;
     if (valueMask.value.isBool) return valueMask.value;
     // TODO(sra): Consider other values. Be careful with large strings.
     return null;
   }
 
   @override
   TypeMask nonNullExact(ClassElement element) {
     // TODO(johnniwinther): I don't think the follow is valid anymore.
     // The class world does not know about classes created by
@@ skipping 104 matching lines @@
 
   @override
   bool isDefinitelyFixedArray(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
     return t.nonNullable().satisfies(helpers.jsFixedArrayClass, classWorld);
   }
 
   @override
   bool isDefinitelyExtendableArray(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
-    return t.nonNullable().satisfies(helpers.jsExtendableArrayClass,
-                                     classWorld);
+    return t
+        .nonNullable()
+        .satisfies(helpers.jsExtendableArrayClass, classWorld);
   }
 
   @override
   bool isDefinitelyIndexable(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
     return _indexableTypeTest.containsMask(t.nonNullable(), classWorld);
   }
 
   @override
   bool isDefinitelyMutableIndexable(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
-    return t.nonNullable().satisfies(helpers.jsMutableIndexableClass,
-        classWorld);
+    return t
+        .nonNullable()
+        .satisfies(helpers.jsMutableIndexableClass, classWorld);
   }
 
   @override
   bool isDefinitelyFixedLengthIndexable(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
     return fixedLengthType.containsMask(t.nonNullable(), classWorld);
   }
 
   @override
   bool isDefinitelyIntercepted(TypeMask t, {bool allowNull}) {
@@ skipping 25 matching lines @@
   @override
   bool areDisjoint(TypeMask leftType, TypeMask rightType) =>
       leftType.isDisjoint(rightType, classWorld);
 
   @override
   bool isMorePreciseOrEqual(TypeMask t1, TypeMask t2) {
     return t2.containsMask(t1, classWorld);
   }
 
   @override
-  AbstractBool isSubtypeOf(TypeMask value,
-                           types.DartType type,
-                           {bool allowNull}) {
+  AbstractBool isSubtypeOf(TypeMask value, types.DartType type,
+      {bool allowNull}) {
     assert(allowNull != null);
     if (type is types.DynamicType) {
       return AbstractBool.True;
     }
     if (type is types.InterfaceType) {
       TypeMask typeAsMask = allowNull
           ? new TypeMask.subtype(type.element, classWorld)
           : new TypeMask.nonNullSubtype(type.element, classWorld);
       if (areDisjoint(value, typeAsMask)) {
         // Disprove the subtype relation based on the class alone.
@@ skipping 40 matching lines @@
       ClassElement element = type.element;
       if (element.isObject) {
         return dynamicType;
       }
       if (element == classWorld.nullClass) {
         return nullType;
       }
       if (element == classWorld.stringClass) {
         return stringType;
       }
-      if (element == classWorld.numClass ||
-          element == classWorld.doubleClass) {
+      if (element == classWorld.numClass || element == classWorld.doubleClass) {
         return numType;
       }
       if (element == classWorld.intClass) {
         return intType;
       }
       if (element == classWorld.boolClass) {
         return boolType;
       }
       return new TypeMask.nonNullSubtype(element, classWorld);
     }
@@ skipping 48 matching lines @@
         TypeMask result = container.typeMap[key];
         if (result != null) return result;
       }
     }
     if (container is ContainerTypeMask) {
       return container.elementType;
     }
     return null;
   }
 }