dartfmt pkg/compiler

pkg/compiler/lib/src/constants/constant_system.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;
 
 import '../dart_types.dart';
-import '../compiler.dart' show
-    Compiler;
+import '../compiler.dart' show Compiler;
 import '../resolution/operators.dart';
-import '../tree/tree.dart' show
-    DartString;
+import '../tree/tree.dart' show DartString;
 import 'values.dart';
 
 abstract class Operation {
   String get name;
 }
 
 abstract class UnaryOperation extends Operation {
   /** Returns [:null:] if it was unable to fold the operation. */
   ConstantValue fold(ConstantValue constant);
 }
@@ skipping 34 matching lines @@
 
   BinaryOperation get codeUnitAt;
 
   const ConstantSystem();
 
   ConstantValue createInt(int i);
   ConstantValue createDouble(double d);
   ConstantValue createString(DartString string);
   ConstantValue createBool(bool value);
   ConstantValue createNull();
-  ConstantValue createList(InterfaceType type,
-                           List<ConstantValue> values);
+  ConstantValue createList(InterfaceType type, List<ConstantValue> values);
   // TODO(johnniwinther): Remove the need for [compiler].
-  ConstantValue createMap(Compiler compiler,
-                          InterfaceType type,
-                          List<ConstantValue> keys,
-                          List<ConstantValue> values);
+  ConstantValue createMap(Compiler compiler, InterfaceType type,
+      List<ConstantValue> keys, List<ConstantValue> values);
   // TODO(johnniwinther): Remove the need for [compiler].
-  ConstantValue createType(Compiler compiler,
-                           DartType type);
+  ConstantValue createType(Compiler compiler, DartType type);
 
   // We need to special case the subtype check for JavaScript constant
   // system because an int is a double at runtime.
   bool isSubtype(DartTypes types, DartType s, DartType t);
 
   /** Returns true if the [constant] is an integer at runtime. */
   bool isInt(ConstantValue constant);
   /** Returns true if the [constant] is a double at runtime. */
   bool isDouble(ConstantValue constant);
   /** Returns true if the [constant] is a string at runtime. */
   bool isString(ConstantValue constant);
   /** Returns true if the [constant] is a boolean at runtime. */
   bool isBool(ConstantValue constant);
   /** Returns true if the [constant] is null at runtime. */
   bool isNull(ConstantValue constant);
 
   UnaryOperation lookupUnary(UnaryOperator operator) {
     switch (operator.kind) {
-      case UnaryOperatorKind.COMPLEMENT: return bitNot;
-      case UnaryOperatorKind.NEGATE: return negate;
-      case UnaryOperatorKind.NOT: return not;
-      default:  return null;
+      case UnaryOperatorKind.COMPLEMENT:
+        return bitNot;
+      case UnaryOperatorKind.NEGATE:
+        return negate;
+      case UnaryOperatorKind.NOT:
+        return not;
+      default:
+        return null;
     }
   }
 
   BinaryOperation lookupBinary(BinaryOperator operator) {
     switch (operator.kind) {
-      case BinaryOperatorKind.ADD:   return add;
-      case BinaryOperatorKind.SUB:   return subtract;
-      case BinaryOperatorKind.MUL:   return multiply;
-      case BinaryOperatorKind.DIV:   return divide;
-      case BinaryOperatorKind.MOD:   return modulo;
-      case BinaryOperatorKind.IDIV:  return truncatingDivide;
-      case BinaryOperatorKind.OR:   return bitOr;
-      case BinaryOperatorKind.AND:   return bitAnd;
-      case BinaryOperatorKind.XOR:   return bitXor;
-      case BinaryOperatorKind.LOGICAL_OR:  return booleanOr;
-      case BinaryOperatorKind.LOGICAL_AND:  return booleanAnd;
-      case BinaryOperatorKind.SHL:  return shiftLeft;
-      case BinaryOperatorKind.SHR:  return shiftRight;
-      case BinaryOperatorKind.LT:   return less;
-      case BinaryOperatorKind.LTEQ:  return lessEqual;
-      case BinaryOperatorKind.GT:   return greater;
-      case BinaryOperatorKind.GTEQ:  return greaterEqual;
-      case BinaryOperatorKind.EQ:  return equal;
-      case BinaryOperatorKind.IF_NULL: return ifNull;
-      default:    return null;
+      case BinaryOperatorKind.ADD:
+        return add;
+      case BinaryOperatorKind.SUB:
+        return subtract;
+      case BinaryOperatorKind.MUL:
+        return multiply;
+      case BinaryOperatorKind.DIV:
+        return divide;
+      case BinaryOperatorKind.MOD:
+        return modulo;
+      case BinaryOperatorKind.IDIV:
+        return truncatingDivide;
+      case BinaryOperatorKind.OR:
+        return bitOr;
+      case BinaryOperatorKind.AND:
+        return bitAnd;
+      case BinaryOperatorKind.XOR:
+        return bitXor;
+      case BinaryOperatorKind.LOGICAL_OR:
+        return booleanOr;
+      case BinaryOperatorKind.LOGICAL_AND:
+        return booleanAnd;
+      case BinaryOperatorKind.SHL:
+        return shiftLeft;
+      case BinaryOperatorKind.SHR:
+        return shiftRight;
+      case BinaryOperatorKind.LT:
+        return less;
+      case BinaryOperatorKind.LTEQ:
+        return lessEqual;
+      case BinaryOperatorKind.GT:
+        return greater;
+      case BinaryOperatorKind.GTEQ:
+        return greaterEqual;
+      case BinaryOperatorKind.EQ:
+        return equal;
+      case BinaryOperatorKind.IF_NULL:
+        return ifNull;
+      default:
+        return null;
     }
   }
 }