dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/constant_system_javascript.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 dart2js.constant_system.js;
 
-import '../compiler.dart' show
-    Compiler;
+import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../constant_system_dart.dart';
-import '../core_types.dart' show
-    CoreTypes;
+import '../core_types.dart' show CoreTypes;
 import '../dart_types.dart';
-import '../elements/elements.dart' show
-    ClassElement;
-import '../tree/tree.dart' show
-    DartString,
-    LiteralDartString;
+import '../elements/elements.dart' show ClassElement;
+import '../tree/tree.dart' show DartString, LiteralDartString;
 import 'js_backend.dart';
 
 const JAVA_SCRIPT_CONSTANT_SYSTEM = const JavaScriptConstantSystem();
 
 class JavaScriptBitNotOperation extends BitNotOperation {
   const JavaScriptBitNotOperation();
 
   ConstantValue fold(ConstantValue constant) {
     if (JAVA_SCRIPT_CONSTANT_SYSTEM.isInt(constant)) {
       // In JavaScript we don't check for -0 and treat it as if it was zero.
       if (constant.isMinusZero) constant = DART_CONSTANT_SYSTEM.createInt(0);
       IntConstantValue intConstant = constant;
       // We convert the result of bit-operations to 32 bit unsigned integers.
-      return
-          JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(~intConstant.primitiveValue);
+      return JAVA_SCRIPT_CONSTANT_SYSTEM
+          .createInt32(~intConstant.primitiveValue);
     }
     return null;
   }
 }
 
 /**
  * In JavaScript we truncate the result to an unsigned 32 bit integer. Also, -0
  * is treated as if it was the integer 0.
  */
 class JavaScriptBinaryBitOperation implements BinaryOperation {
@@ skipping 184 matching lines @@
       }
       // If the integer loses precision with JavaScript numbers, use
       // the floored version JavaScript will use.
       int floorValue = intValue.toDouble().floor().toInt();
       if (floorValue != intValue) {
         return new IntConstantValue(floorValue);
       }
     } else if (constant.isDouble) {
       DoubleConstantValue doubleResult = constant;
       double doubleValue = doubleResult.primitiveValue;
-      if (!doubleValue.isInfinite && !doubleValue.isNaN &&
+      if (!doubleValue.isInfinite &&
+          !doubleValue.isNaN &&
           !constant.isMinusZero) {
         int intValue = doubleValue.truncate();
         if (intValue == doubleValue) {
           return new IntConstantValue(intValue);
         }
       }
     }
     return constant;
   }
 
   @override
   NumConstantValue createInt(int i) {
     return convertToJavaScriptConstant(new IntConstantValue(i));
   }
 
   NumConstantValue createInt32(int i) => new IntConstantValue(i & BITS32);
-  NumConstantValue createDouble(double d)
-      => convertToJavaScriptConstant(new DoubleConstantValue(d));
+  NumConstantValue createDouble(double d) =>
+      convertToJavaScriptConstant(new DoubleConstantValue(d));
   StringConstantValue createString(DartString string) {
     return new StringConstantValue(string);
   }
+
   BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
   NullConstantValue createNull() => new NullConstantValue();
 
   @override
-  ListConstantValue createList(InterfaceType type,
-                               List<ConstantValue> values) {
+  ListConstantValue createList(InterfaceType type, List<ConstantValue> values) {
     return new ListConstantValue(type, values);
   }
 
   @override
   ConstantValue createType(Compiler compiler, DartType type) {
-    return new TypeConstantValue(
-        type,
+    return new TypeConstantValue(type,
         compiler.backend.typeImplementation.computeType(compiler.resolution));
   }
 
   // Integer checks report true for -0.0, INFINITY, and -INFINITY.  At
   // runtime an 'X is int' check is implemented as:
   //
   // typeof(X) === "number" && Math.floor(X) === X
   //
   // We consistently match that runtime semantics at compile time as well.
   bool isInt(ConstantValue constant) {
-    return constant.isInt || constant.isMinusZero ||
+    return constant.isInt ||
+        constant.isMinusZero ||
         constant.isPositiveInfinity ||
         constant.isNegativeInfinity;
   }
-  bool isDouble(ConstantValue constant)
-      => constant.isDouble && !constant.isMinusZero;
+
+  bool isDouble(ConstantValue constant) =>
+      constant.isDouble && !constant.isMinusZero;
   bool isString(ConstantValue constant) => constant.isString;
   bool isBool(ConstantValue constant) => constant.isBool;
   bool isNull(ConstantValue constant) => constant.isNull;
 
   bool isSubtype(DartTypes types, DartType s, DartType t) {
     // At runtime, an integer is both an integer and a double: the
     // integer type check is Math.floor, which will return true only
     // for real integers, and our double type check is 'typeof number'
     // which will return true for both integers and doubles.
     if (s == types.coreTypes.intType && t == types.coreTypes.doubleType) {
       return true;
     }
     return types.isSubtype(s, t);
   }
 
-  MapConstantValue createMap(Compiler compiler,
-                             InterfaceType sourceType,
-                             List<ConstantValue> keys,
-                             List<ConstantValue> values) {
+  MapConstantValue createMap(Compiler compiler, InterfaceType sourceType,
+      List<ConstantValue> keys, List<ConstantValue> values) {
     JavaScriptBackend backend = compiler.backend;
     CoreTypes coreTypes = compiler.coreTypes;
 
     bool onlyStringKeys = true;
     ConstantValue protoValue = null;
-    for (int i = 0; i < keys.length ; i++) {
+    for (int i = 0; i < keys.length; i++) {
       var key = keys[i];
       if (key.isString) {
         if (key.primitiveValue == JavaScriptMapConstant.PROTO_PROPERTY) {
           protoValue = values[i];
         }
       } else {
         onlyStringKeys = false;
         // Don't handle __proto__ values specially in the general map case.
         protoValue = null;
         break;
       }
     }
 
     bool hasProtoKey = (protoValue != null);
     DartType keysType;
     if (sourceType.treatAsRaw) {
       keysType = coreTypes.listType();
     } else {
       keysType = coreTypes.listType(sourceType.typeArguments.first);
     }
     ListConstantValue keysList = new ListConstantValue(keysType, keys);
     String className = onlyStringKeys
-        ? (hasProtoKey ? JavaScriptMapConstant.DART_PROTO_CLASS
-                       : JavaScriptMapConstant.DART_STRING_CLASS)
+        ? (hasProtoKey
+            ? JavaScriptMapConstant.DART_PROTO_CLASS
+            : JavaScriptMapConstant.DART_STRING_CLASS)
         : JavaScriptMapConstant.DART_GENERAL_CLASS;
     ClassElement classElement = backend.helpers.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler.resolution);
     List<DartType> typeArgument = sourceType.typeArguments;
     InterfaceType type;
     if (sourceType.treatAsRaw) {
       type = classElement.rawType;
     } else {
       type = new InterfaceType(classElement, typeArgument);
     }
     return new JavaScriptMapConstant(
         type, keysList, values, protoValue, onlyStringKeys);
-
   }
 }
 
 class JavaScriptMapConstant extends MapConstantValue {
   /**
    * The [PROTO_PROPERTY] must not be used as normal property in any JavaScript
    * object. It would change the prototype chain.
    */
   static const LiteralDartString PROTO_PROPERTY =
       const LiteralDartString("__proto__");
 
   /** The dart class implementing constant map literals. */
   static const String DART_CLASS = "ConstantMap";
   static const String DART_STRING_CLASS = "ConstantStringMap";
   static const String DART_PROTO_CLASS = "ConstantProtoMap";
   static const String DART_GENERAL_CLASS = "GeneralConstantMap";
   static const String LENGTH_NAME = "_length";
   static const String JS_OBJECT_NAME = "_jsObject";
   static const String KEYS_NAME = "_keys";
   static const String PROTO_VALUE = "_protoValue";
   static const String JS_DATA_NAME = "_jsData";
 
   final ListConstantValue keyList;
   final ConstantValue protoValue;
   final bool onlyStringKeys;
 
-  JavaScriptMapConstant(InterfaceType type,
-                        ListConstantValue keyList,
-                        List<ConstantValue> values,
-                        this.protoValue,
-                        this.onlyStringKeys)
+  JavaScriptMapConstant(InterfaceType type, ListConstantValue keyList,
+      List<ConstantValue> values, this.protoValue, this.onlyStringKeys)
       : this.keyList = keyList,
         super(type, keyList.entries, values);
   bool get isMap => true;
 
   List<ConstantValue> getDependencies() {
     List<ConstantValue> result = <ConstantValue>[];
     if (onlyStringKeys) {
       result.add(keyList);
     } else {
       // Add the keys individually to avoid generating an unused list constant
       // for the keys.
       result.addAll(keys);
     }
     result.addAll(values);
     return result;
   }
 }