dartfmt pkg/compiler

pkg/compiler/lib/src/constants/values.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.constants.values;
 
 import '../common.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart'
-    show ClassElement,
-         Element,
-         FieldElement,
-         FunctionElement,
-         PrefixElement;
+    show ClassElement, Element, FieldElement, FunctionElement, PrefixElement;
 import '../tree/tree.dart' hide unparse;
 import '../util/util.dart' show Hashing;
 
 abstract class ConstantValueVisitor<R, A> {
   const ConstantValueVisitor();
 
   R visitFunction(FunctionConstantValue constant, A arg);
   R visitNull(NullConstantValue constant, A arg);
   R visitInt(IntConstantValue constant, A arg);
   R visitDouble(DoubleConstantValue constant, A arg);
@@ skipping 56 matching lines @@
   /// For the synthetic constants, [DeferredConstantValue],
   /// [SyntheticConstantValue], [InterceptorConstantValue] the unparse is
   /// descriptive only.
   String unparse();
 
   /// Returns a structured representation of this constant suited for debugging.
   String toStructuredString();
 
   String toString() {
     assertDebugMode("Use Constant.unparse() or Constant.toStructuredString() "
-                    "instead of Constant.toString().");
+        "instead of Constant.toString().");
     return toStructuredString();
   }
 }
 
 class FunctionConstantValue extends ConstantValue {
   FunctionElement element;
 
   FunctionConstantValue(this.element) {
     assert(element.type != null);
   }
 
   bool get isFunction => true;
 
   bool operator ==(var other) {
-    if (other is !FunctionConstantValue) return false;
+    if (other is! FunctionConstantValue) return false;
     return identical(other.element, element);
   }
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   DartString toDartString() {
     return new DartString.literal(element.name);
   }
 
   DartType getType(CoreTypes types) => element.type;
@@ skipping 16 matching lines @@
 }
 
 abstract class PrimitiveConstantValue extends ConstantValue {
   get primitiveValue;
 
   const PrimitiveConstantValue();
 
   bool get isPrimitive => true;
 
   bool operator ==(var other) {
-    if (other is !PrimitiveConstantValue) return false;
+    if (other is! PrimitiveConstantValue) return false;
     PrimitiveConstantValue otherPrimitive = other;
     // We use == instead of 'identical' so that DartStrings compare correctly.
     return primitiveValue == otherPrimitive.primitiveValue;
   }
 
   int get hashCode => throw new UnsupportedError('PrimitiveConstant.hashCode');
 
   // Primitive constants don't have dependencies.
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
@@ skipping 33 matching lines @@
   num get primitiveValue;
 
   bool get isNum => true;
 }
 
 class IntConstantValue extends NumConstantValue {
   final int primitiveValue;
 
   factory IntConstantValue(int value) {
     switch (value) {
-      case 0: return const IntConstantValue._internal(0);
-      case 1: return const IntConstantValue._internal(1);
-      case 2: return const IntConstantValue._internal(2);
-      case 3: return const IntConstantValue._internal(3);
-      case 4: return const IntConstantValue._internal(4);
-      case 5: return const IntConstantValue._internal(5);
-      case 6: return const IntConstantValue._internal(6);
-      case 7: return const IntConstantValue._internal(7);
-      case 8: return const IntConstantValue._internal(8);
-      case 9: return const IntConstantValue._internal(9);
-      case 10: return const IntConstantValue._internal(10);
-      case -1: return const IntConstantValue._internal(-1);
-      case -2: return const IntConstantValue._internal(-2);
-      default: return new IntConstantValue._internal(value);
+      case 0:
+        return const IntConstantValue._internal(0);
+      case 1:
+        return const IntConstantValue._internal(1);
+      case 2:
+        return const IntConstantValue._internal(2);
+      case 3:
+        return const IntConstantValue._internal(3);
+      case 4:
+        return const IntConstantValue._internal(4);
+      case 5:
+        return const IntConstantValue._internal(5);
+      case 6:
+        return const IntConstantValue._internal(6);
+      case 7:
+        return const IntConstantValue._internal(7);
+      case 8:
+        return const IntConstantValue._internal(8);
+      case 9:
+        return const IntConstantValue._internal(9);
+      case 10:
+        return const IntConstantValue._internal(10);
+      case -1:
+        return const IntConstantValue._internal(-1);
+      case -2:
+        return const IntConstantValue._internal(-2);
+      default:
+        return new IntConstantValue._internal(value);
     }
   }
 
   const IntConstantValue._internal(this.primitiveValue);
 
   bool get isInt => true;
 
   bool isUInt31() => primitiveValue >= 0 && primitiveValue < (1 << 31);
 
   bool isUInt32() => primitiveValue >= 0 && primitiveValue < (1 << 32);
 
   bool isPositive() => primitiveValue >= 0;
 
   bool get isZero => primitiveValue == 0;
 
   bool get isOne => primitiveValue == 1;
 
   DartType getType(CoreTypes types) => types.intType;
 
   // We have to override the equality operator so that ints and doubles are
   // treated as separate constants.
   // The is [:!IntConstant:] check at the beginning of the function makes sure
   // that we compare only equal to integer constants.
   bool operator ==(var other) {
-    if (other is !IntConstantValue) return false;
+    if (other is! IntConstantValue) return false;
     IntConstantValue otherInt = other;
     return primitiveValue == otherInt.primitiveValue;
   }
 
   int get hashCode => primitiveValue & Hashing.SMI_MASK;
 
   DartString toDartString() {
     return new DartString.literal(primitiveValue.toString());
   }
 
@@ skipping 34 matching lines @@
 
   bool get isOne => primitiveValue == 1.0;
 
   bool get isPositiveInfinity => primitiveValue == double.INFINITY;
 
   bool get isNegativeInfinity => primitiveValue == -double.INFINITY;
 
   DartType getType(CoreTypes types) => types.doubleType;
 
   bool operator ==(var other) {
-    if (other is !DoubleConstantValue) return false;
+    if (other is! DoubleConstantValue) return false;
     DoubleConstantValue otherDouble = other;
     double otherValue = otherDouble.primitiveValue;
     if (primitiveValue == 0.0 && otherValue == 0.0) {
       return primitiveValue.isNegative == otherValue.isNegative;
     } else if (primitiveValue.isNaN) {
       return otherValue.isNaN;
     } else {
       return primitiveValue == otherValue;
     }
   }
@@ skipping 81 matching lines @@
 
   StringConstantValue.fromString(String value)
       : this(new DartString.literal(value));
 
   bool get isString => true;
 
   DartType getType(CoreTypes types) => types.stringType;
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
-    if (other is !StringConstantValue) return false;
+    if (other is! StringConstantValue) return false;
     StringConstantValue otherString = other;
     return hashCode == otherString.hashCode &&
-           primitiveValue == otherString.primitiveValue;
+        primitiveValue == otherString.primitiveValue;
   }
 
   DartString toDartString() => primitiveValue;
 
   int get length => primitiveValue.length;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitString(this, arg);
 
   // TODO(johnniwinther): Ensure correct escaping.
   String unparse() => '"${primitiveValue.slowToString()}"';
@@ skipping 22 matching lines @@
 class TypeConstantValue extends ObjectConstantValue {
   /// The user type that this constant represents.
   final DartType representedType;
 
   TypeConstantValue(this.representedType, InterfaceType type) : super(type);
 
   bool get isType => true;
 
   bool operator ==(other) {
     return other is TypeConstantValue &&
-           representedType == other.representedType;
+        representedType == other.representedType;
   }
 
   int get hashCode => representedType.hashCode * 13;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitType(this, arg);
 
   String unparse() => '$representedType';
 
   String toStructuredString() => 'TypeConstant(${representedType})';
 }
 
 class ListConstantValue extends ObjectConstantValue {
   final List<ConstantValue> entries;
   final int hashCode;
 
   ListConstantValue(InterfaceType type, List<ConstantValue> entries)
       : this.entries = entries,
         hashCode = Hashing.listHash(entries, Hashing.objectHash(type)),
         super(type);
 
   bool get isList => true;
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
-    if (other is !ListConstantValue) return false;
+    if (other is! ListConstantValue) return false;
     ListConstantValue otherList = other;
     if (hashCode != otherList.hashCode) return false;
     if (type != otherList.type) return false;
     if (entries.length != otherList.entries.length) return false;
     for (int i = 0; i < entries.length; i++) {
       if (entries[i] != otherList.entries[i]) return false;
     }
     return true;
   }
 
   List<ConstantValue> getDependencies() => entries;
 
   int get length => entries.length;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitList(this, arg);
 
   String unparse() {
     StringBuffer sb = new StringBuffer();
     _unparseTypeArguments(sb);
     sb.write('[');
-    for (int i = 0 ; i < length ; i++) {
+    for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(',');
       sb.write(entries[i].unparse());
     }
     sb.write(']');
     return sb.toString();
   }
 
   String toStructuredString() {
     StringBuffer sb = new StringBuffer();
     sb.write('ListConstant(');
     _unparseTypeArguments(sb);
     sb.write('[');
-    for (int i = 0 ; i < length ; i++) {
+    for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(', ');
       sb.write(entries[i].toStructuredString());
     }
     sb.write('])');
     return sb.toString();
   }
 }
 
 class MapConstantValue extends ObjectConstantValue {
   final List<ConstantValue> keys;
   final List<ConstantValue> values;
   final int hashCode;
   Map<ConstantValue, ConstantValue> _lookupMap;
 
-  MapConstantValue(InterfaceType type,
-                   List<ConstantValue> keys,
-                   List<ConstantValue> values)
+  MapConstantValue(
+      InterfaceType type, List<ConstantValue> keys, List<ConstantValue> values)
       : this.keys = keys,
         this.values = values,
-        this.hashCode = Hashing.listHash(values,
-                            Hashing.listHash(keys,
-                                Hashing.objectHash(type))),
+        this.hashCode = Hashing.listHash(
+            values, Hashing.listHash(keys, Hashing.objectHash(type))),
         super(type) {
     assert(keys.length == values.length);
   }
 
   bool get isMap => true;
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
-    if (other is !MapConstantValue) return false;
+    if (other is! MapConstantValue) return false;
     MapConstantValue otherMap = other;
     if (hashCode != otherMap.hashCode) return false;
     if (type != other.type) return false;
     if (length != other.length) return false;
     for (int i = 0; i < length; i++) {
       if (keys[i] != otherMap.keys[i]) return false;
       if (values[i] != otherMap.values[i]) return false;
     }
     return true;
   }
@@ skipping 12 matching lines @@
         new Map<ConstantValue, ConstantValue>.fromIterables(keys, values);
     return lookupMap[key];
   }
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitMap(this, arg);
 
   String unparse() {
     StringBuffer sb = new StringBuffer();
     _unparseTypeArguments(sb);
     sb.write('{');
-    for (int i = 0 ; i < length ; i++) {
+    for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(',');
       sb.write(keys[i].unparse());
       sb.write(':');
       sb.write(values[i].unparse());
     }
     sb.write('}');
     return sb.toString();
   }
 
   String toStructuredString() {
@@ skipping 15 matching lines @@
 class InterceptorConstantValue extends ConstantValue {
   /// The type for which this interceptor holds the methods.  The constant
   /// is a dispatch table for this type.
   final DartType dispatchedType;
 
   InterceptorConstantValue(this.dispatchedType);
 
   bool get isInterceptor => true;
 
   bool operator ==(other) {
-    return other is InterceptorConstantValue
-        && dispatchedType == other.dispatchedType;
+    return other is InterceptorConstantValue &&
+        dispatchedType == other.dispatchedType;
   }
 
   int get hashCode => dispatchedType.hashCode * 43;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitInterceptor(this, arg);
   }
 
@@ skipping 10 matching lines @@
 
 class SyntheticConstantValue extends ConstantValue {
   final payload;
   final kind;
 
   SyntheticConstantValue(this.kind, this.payload);
 
   bool get isDummy => true;
 
   bool operator ==(other) {
-    return other is SyntheticConstantValue
-        && payload == other.payload;
+    return other is SyntheticConstantValue && payload == other.payload;
   }
 
   get hashCode => payload.hashCode * 17 + kind.hashCode;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitSynthetic(this, arg);
   }
 
   DartType getType(CoreTypes types) => const DynamicType();
 
   String unparse() => 'synthetic($kind, $payload)';
 
   String toStructuredString() => 'SyntheticConstant($kind, $payload)';
 }
 
 class ConstructedConstantValue extends ObjectConstantValue {
   final Map<FieldElement, ConstantValue> fields;
   final int hashCode;
 
-  ConstructedConstantValue(InterfaceType type,
-                           Map<FieldElement, ConstantValue> fields)
-    : this.fields = fields,
-      hashCode = Hashing.mapHash(fields, Hashing.objectHash(type)),
-      super(type) {
+  ConstructedConstantValue(
+      InterfaceType type, Map<FieldElement, ConstantValue> fields)
+      : this.fields = fields,
+        hashCode = Hashing.mapHash(fields, Hashing.objectHash(type)),
+        super(type) {
     assert(type != null);
     assert(!fields.containsValue(null));
   }
 
   bool get isConstructedObject => true;
 
   bool operator ==(var otherVar) {
     if (identical(this, otherVar)) return true;
-    if (otherVar is !ConstructedConstantValue) return false;
+    if (otherVar is! ConstructedConstantValue) return false;
     ConstructedConstantValue other = otherVar;
     if (hashCode != other.hashCode) return false;
     if (type != other.type) return false;
     if (fields.length != other.fields.length) return false;
     for (FieldElement field in fields.keys) {
       if (fields[field] != other.fields[field]) return false;
     }
     return true;
   }
 
@@ skipping 42 matching lines @@
 /// Used for referring to deferred constants.
 class DeferredConstantValue extends ConstantValue {
   DeferredConstantValue(this.referenced, this.prefix);
 
   final ConstantValue referenced;
   final PrefixElement prefix;
 
   bool get isReference => true;
 
   bool operator ==(other) {
-    return other is DeferredConstantValue
-        && referenced == other.referenced
-        && prefix == other.prefix;
+    return other is DeferredConstantValue &&
+        referenced == other.referenced &&
+        prefix == other.prefix;
   }
 
   get hashCode => (referenced.hashCode * 17 + prefix.hashCode) & 0x3fffffff;
 
   List<ConstantValue> getDependencies() => <ConstantValue>[referenced];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDeferred(this, arg);
 
   DartType getType(CoreTypes types) => referenced.getType(types);
 
@@ skipping 18 matching lines @@
 
   @override
   DartType getType(CoreTypes types) => const DynamicType();
 
   @override
   String toStructuredString() => 'NonConstant';
 
   @override
   String unparse() => '>>non-constant<<';
 }