dartfmt pkg/compiler

pkg/compiler/lib/src/constant_system_dart.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.dart;
 
-import 'compiler.dart' show
-    Compiler;
+import 'compiler.dart' show Compiler;
 import 'constants/constant_system.dart';
 import 'constants/values.dart';
 import 'dart_types.dart';
-import 'tree/tree.dart' show
-    DartString;
+import 'tree/tree.dart' show DartString;
 
 const DART_CONSTANT_SYSTEM = const DartConstantSystem();
 
 class BitNotOperation implements UnaryOperation {
   final String name = '~';
   const BitNotOperation();
   ConstantValue fold(ConstantValue constant) {
     if (constant.isInt) {
       IntConstantValue intConstant = constant;
       return DART_CONSTANT_SYSTEM.createInt(~intConstant.primitiveValue);
@@ skipping 46 matching lines @@
     }
     return null;
   }
 
   int foldInts(int left, int right);
 }
 
 class BitOrOperation extends BinaryBitOperation {
   final String name = '|';
   const BitOrOperation();
-  int foldInts(int left, int right)  => left | right;
+  int foldInts(int left, int right) => left | right;
   apply(left, right) => left | right;
 }
 
 class BitAndOperation extends BinaryBitOperation {
   final String name = '&';
   const BitAndOperation();
   int foldInts(int left, int right) => left & right;
   apply(left, right) => left & right;
 }
 
 class BitXorOperation extends BinaryBitOperation {
   final String name = '^';
   const BitXorOperation();
   int foldInts(int left, int right) => left ^ right;
   apply(left, right) => left ^ right;
 }
 
 class ShiftLeftOperation extends BinaryBitOperation {
   final String name = '<<';
   const ShiftLeftOperation();
   int foldInts(int left, int right) {
     // TODO(floitsch): find a better way to guard against excessive shifts to
     // the left.
     if (right > 100 || right < 0) return null;
     return left << right;
   }
+
   apply(left, right) => left << right;
 }
 
 class ShiftRightOperation extends BinaryBitOperation {
   final String name = '>>';
   const ShiftRightOperation();
   int foldInts(int left, int right) {
     if (right < 0) return null;
     return left >> right;
   }
+
   apply(left, right) => left >> right;
 }
 
 abstract class BinaryBoolOperation implements BinaryOperation {
   const BinaryBoolOperation();
   ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isBool && right.isBool) {
       BoolConstantValue leftBool = left;
       BoolConstantValue rightBool = right;
       bool resultValue =
@@ skipping 27 matching lines @@
       NumConstantValue leftNum = left;
       NumConstantValue rightNum = right;
       num foldedValue;
       if (left.isInt && right.isInt) {
         foldedValue = foldInts(leftNum.primitiveValue, rightNum.primitiveValue);
       } else {
         foldedValue = foldNums(leftNum.primitiveValue, rightNum.primitiveValue);
       }
       // A division by 0 means that we might not have a folded value.
       if (foldedValue == null) return null;
-      if (left.isInt && right.isInt && !isDivide() ||
-          isTruncatingDivide()) {
+      if (left.isInt && right.isInt && !isDivide() || isTruncatingDivide()) {
         assert(foldedValue is int);
         return DART_CONSTANT_SYSTEM.createInt(foldedValue);
       } else {
         return DART_CONSTANT_SYSTEM.createDouble(foldedValue);
       }
     }
     return null;
   }
 
   bool isDivide() => false;
@@ skipping 16 matching lines @@
   apply(left, right) => left * right;
 }
 
 class ModuloOperation extends ArithmeticNumOperation {
   final String name = '%';
   const ModuloOperation();
   int foldInts(int left, int right) {
     if (right == 0) return null;
     return left % right;
   }
+
   num foldNums(num left, num right) => left % right;
   apply(left, right) => left % right;
 }
 
 class TruncatingDivideOperation extends ArithmeticNumOperation {
   final String name = '~/';
   const TruncatingDivideOperation();
   int foldInts(int left, int right) {
     if (right == 0) return null;
     return left ~/ right;
   }
+
   num foldNums(num left, num right) {
     num ratio = left / right;
     if (ratio.isNaN || ratio.isInfinite) return null;
     return ratio.truncate().toInt();
   }
+
   apply(left, right) => left ~/ right;
   bool isTruncatingDivide() => true;
 }
 
 class DivideOperation extends ArithmeticNumOperation {
   final String name = '/';
   const DivideOperation();
   num foldNums(num left, num right) => left / right;
   bool isDivide() => true;
   apply(left, right) => left / right;
 }
 
 class AddOperation implements BinaryOperation {
   final String name = '+';
   const AddOperation();
   ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isInt && right.isInt) {
       IntConstantValue leftInt = left;
       IntConstantValue rightInt = right;
       int result = leftInt.primitiveValue + rightInt.primitiveValue;
       return DART_CONSTANT_SYSTEM.createInt(result);
     } else if (left.isNum && right.isNum) {
       NumConstantValue leftNum = left;
       NumConstantValue rightNum = right;
       double result = leftNum.primitiveValue + rightNum.primitiveValue;
       return DART_CONSTANT_SYSTEM.createDouble(result);
     } else if (left.isString && right.isString) {
       StringConstantValue leftString = left;
       StringConstantValue rightString = right;
-      DartString result = new DartString.concat(leftString.primitiveValue,
-                                                rightString.primitiveValue);
+      DartString result = new DartString.concat(
+          leftString.primitiveValue, rightString.primitiveValue);
       return DART_CONSTANT_SYSTEM.createString(result);
     } else {
       return null;
     }
   }
+
   apply(left, right) => left + right;
 }
 
 abstract class RelationalNumOperation implements BinaryOperation {
   const RelationalNumOperation();
   ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (!left.isNum || !right.isNum) return null;
     NumConstantValue leftNum = left;
     NumConstantValue rightNum = right;
     bool foldedValue =
@@ skipping 45 matching lines @@
       bool result = leftNum.primitiveValue == rightNum.primitiveValue;
       return DART_CONSTANT_SYSTEM.createBool(result);
     }
     if (left.isConstructedObject) {
       // Unless we know that the user-defined object does not implement the
       // equality operator we cannot fold here.
       return null;
     }
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
+
   apply(left, right) => left == right;
 }
 
 class IdentityOperation implements BinaryOperation {
   final String name = '===';
   const IdentityOperation();
   BoolConstantValue fold(ConstantValue left, ConstantValue right) {
     // In order to preserve runtime semantics which says that NaN !== NaN don't
     // constant fold NaN === NaN. Otherwise the output depends on inlined
     // variables and other optimizations.
     if (left.isNaN && right.isNaN) return null;
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
+
   apply(left, right) => identical(left, right);
 }
 
 class IfNullOperation implements BinaryOperation {
   final String name = '??';
   const IfNullOperation();
   ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isNull) return right;
     return left;
   }
+
   apply(left, right) => left ?? right;
 }
 
 abstract class CodeUnitAtOperation implements BinaryOperation {
   final String name = 'charCodeAt';
   const CodeUnitAtOperation();
   apply(left, right) => left.codeUnitAt(right);
 }
 
 class CodeUnitAtConstantOperation extends CodeUnitAtOperation {
@@ skipping 48 matching lines @@
   final negate = const NegateOperation();
   final not = const NotOperation();
   final shiftLeft = const ShiftLeftOperation();
   final shiftRight = const ShiftRightOperation();
   final subtract = const SubtractOperation();
   final truncatingDivide = const TruncatingDivideOperation();
   final codeUnitAt = const CodeUnitAtConstantOperation();
 
   const DartConstantSystem();
 
-
   @override
   IntConstantValue createInt(int i) => new IntConstantValue(i);
 
   @override
   DoubleConstantValue createDouble(double d) => new DoubleConstantValue(d);
 
   @override
   StringConstantValue createString(DartString string) {
     return new StringConstantValue(string);
   }
 
   @override
   BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
 
   @override
   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
-  MapConstantValue createMap(Compiler compiler,
-                             InterfaceType type,
-                             List<ConstantValue> keys,
-                             List<ConstantValue> values) {
+  MapConstantValue createMap(Compiler compiler, InterfaceType type,
+      List<ConstantValue> keys, List<ConstantValue> values) {
     return new MapConstantValue(type, keys, values);
   }
 
   @override
   ConstantValue createType(Compiler compiler, DartType type) {
     // TODO(johnniwinther): Change the `Type` type to
     // `compiler.coreTypes.typeType` and check the backend specific value in
     // [checkConstMapKeysDontOverrideEquals] in 'members.dart'.
     return new TypeConstantValue(type,
         compiler.backend.typeImplementation.computeType(compiler.resolution));
   }
 
   bool isInt(ConstantValue constant) => constant.isInt;
   bool isDouble(ConstantValue constant) => constant.isDouble;
   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) {
     return types.isSubtype(s, t);
   }
 }