dartfmt pkg/compiler

pkg/compiler/lib/src/mirrors/dart2js_instance_mirrors.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.mirrors;
 
 abstract class ObjectMirrorMixin implements ObjectMirror {
   InstanceMirror getField(Symbol fieldName) {
     throw new UnsupportedError('ObjectMirror.getField unsupported.');
   }
 
   InstanceMirror setField(Symbol fieldName, Object value) {
     throw new UnsupportedError('ObjectMirror.setField unsupported.');
   }
 
-  InstanceMirror invoke(Symbol memberName,
-                        List positionalArguments,
-                        [Map<Symbol, dynamic> namedArguments]) {
+  InstanceMirror invoke(Symbol memberName, List positionalArguments,
+      [Map<Symbol, dynamic> namedArguments]) {
     throw new UnsupportedError('ObjectMirror.invoke unsupported.');
   }
 
   delegate(Invocation invocation) {
     throw new UnsupportedError('ObjectMirror.delegate unsupported');
   }
 }
 
 abstract class InstanceMirrorMixin implements InstanceMirror {
   bool get hasReflectee => false;
 
   get reflectee {
     throw new UnsupportedError('InstanceMirror.reflectee unsupported.');
   }
 }
 
 InstanceMirror _convertConstantToInstanceMirror(
     Dart2JsMirrorSystem mirrorSystem,
     ConstantExpression constant,
     ConstantValue value) {
-
   if (value.isBool) {
     return new Dart2JsBoolConstantMirror(mirrorSystem, constant, value);
   } else if (value.isNum) {
     return new Dart2JsNumConstantMirror(mirrorSystem, constant, value);
   } else if (value.isString) {
     return new Dart2JsStringConstantMirror(mirrorSystem, constant, value);
   } else if (value.isList) {
     return new Dart2JsListConstantMirror(mirrorSystem, constant, value);
   } else if (value.isMap) {
     return new Dart2JsMapConstantMirror(mirrorSystem, constant, value);
   } else if (value.isType) {
     return new Dart2JsTypeConstantMirror(mirrorSystem, constant, value);
   } else if (value.isFunction) {
     return new Dart2JsConstantMirror(mirrorSystem, constant, value);
   } else if (value.isNull) {
     return new Dart2JsNullConstantMirror(mirrorSystem, constant, value);
   } else if (value.isConstructedObject) {
     return new Dart2JsConstructedConstantMirror(mirrorSystem, constant, value);
   }
-  mirrorSystem.compiler.reporter.internalError(NO_LOCATION_SPANNABLE,
-      "Unexpected constant value $value");
+  mirrorSystem.compiler.reporter
+      .internalError(NO_LOCATION_SPANNABLE, "Unexpected constant value $value");
   return null;
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 // Mirrors on constant values used for metadata.
 ////////////////////////////////////////////////////////////////////////////////
 
 class Dart2JsConstantMirror extends Object
     with ObjectMirrorMixin, InstanceMirrorMixin {
   final Dart2JsMirrorSystem mirrorSystem;
   final ConstantExpression _constant;
   final ConstantValue _value;
 
@@ skipping 15 matching lines @@
   int get hashCode => 13 * _constant.hashCode;
 
   bool operator ==(var other) {
     if (other is! Dart2JsConstantMirror) return false;
     return _value == other._value;
   }
 }
 
 class Dart2JsNullConstantMirror extends Dart2JsConstantMirror {
   Dart2JsNullConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                            ConstantExpression constant,
-                            NullConstantValue value)
+      ConstantExpression constant, NullConstantValue value)
       : super(mirrorSystem, constant, value);
 
   NullConstantValue get _value => super._value;
 
   bool get hasReflectee => true;
 
   get reflectee => null;
 }
 
 class Dart2JsBoolConstantMirror extends Dart2JsConstantMirror {
   Dart2JsBoolConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                            ConstantExpression constant,
-                            BoolConstantValue value)
+      ConstantExpression constant, BoolConstantValue value)
       : super(mirrorSystem, constant, value);
 
-  Dart2JsBoolConstantMirror.fromBool(Dart2JsMirrorSystem mirrorSystem,
-                                     bool value)
+  Dart2JsBoolConstantMirror.fromBool(
+      Dart2JsMirrorSystem mirrorSystem, bool value)
       : super(mirrorSystem, null,
-              value ? new TrueConstantValue() : new FalseConstantValue());
+            value ? new TrueConstantValue() : new FalseConstantValue());
 
   BoolConstantValue get _value => super._value;
 
   bool get hasReflectee => true;
 
   get reflectee => _value is TrueConstantValue;
 }
 
 class Dart2JsStringConstantMirror extends Dart2JsConstantMirror {
   Dart2JsStringConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                              ConstantExpression constant,
-                              StringConstantValue value)
+      ConstantExpression constant, StringConstantValue value)
       : super(mirrorSystem, constant, value);
 
-  Dart2JsStringConstantMirror.fromString(Dart2JsMirrorSystem mirrorSystem,
-                                         String text)
+  Dart2JsStringConstantMirror.fromString(
+      Dart2JsMirrorSystem mirrorSystem, String text)
       : super(mirrorSystem, null,
-              new StringConstantValue(new DartString.literal(text)));
+            new StringConstantValue(new DartString.literal(text)));
 
   StringConstantValue get _value => super._value;
 
   bool get hasReflectee => true;
 
   get reflectee => _value.primitiveValue.slowToString();
 }
 
 class Dart2JsNumConstantMirror extends Dart2JsConstantMirror {
   Dart2JsNumConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                           ConstantExpression constant,
-                           NumConstantValue value)
+      ConstantExpression constant, NumConstantValue value)
       : super(mirrorSystem, constant, value);
 
   NumConstantValue get _value => super._value;
 
   bool get hasReflectee => true;
 
   get reflectee => _value.primitiveValue;
 }
 
 class Dart2JsListConstantMirror extends Dart2JsConstantMirror
     implements ListInstanceMirror {
   Dart2JsListConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                            ConstantExpression constant,
-                            ListConstantValue value)
+      ConstantExpression constant, ListConstantValue value)
       : super(mirrorSystem, constant, value);
 
   ListConstantValue get _value => super._value;
 
   int get length => _value.length;
 
   InstanceMirror getElement(int index) {
     if (index < 0) throw new RangeError('Negative index');
     if (index >= _value.length) throw new RangeError('Index out of bounds');
     return _convertConstantToInstanceMirror(
         mirrorSystem, null, _value.entries[index]);
   }
 }
 
 class Dart2JsMapConstantMirror extends Dart2JsConstantMirror
     implements MapInstanceMirror {
   List<String> _listCache;
 
   Dart2JsMapConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                           ConstantExpression constant,
-                           MapConstantValue value)
+      ConstantExpression constant, MapConstantValue value)
       : super(mirrorSystem, constant, value);
 
   MapConstantValue get _value => super._value;
 
   List<String> get _list {
     if (_listCache == null) {
       _listCache = new List<String>(_value.length);
       int index = 0;
       for (StringConstantValue keyConstant in _value.keys) {
         _listCache[index] = keyConstant.primitiveValue.slowToString();
@@ skipping 13 matching lines @@
   InstanceMirror getValue(String key) {
     int index = _list.indexOf(key);
     if (index == -1) return null;
     return _convertConstantToInstanceMirror(
         mirrorSystem, null, _value.values[index]);
   }
 }
 
 class Dart2JsTypeConstantMirror extends Dart2JsConstantMirror
     implements TypeInstanceMirror {
-
   Dart2JsTypeConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                            ConstantExpression constant,
-                            TypeConstantValue value)
+      ConstantExpression constant, TypeConstantValue value)
       : super(mirrorSystem, constant, value);
 
   TypeConstantValue get _value => super._value;
 
   TypeMirror get representedType =>
       mirrorSystem._convertTypeToTypeMirror(_value.representedType);
 }
 
 class Dart2JsConstructedConstantMirror extends Dart2JsConstantMirror {
   Map<String, ConstantValue> _fieldMapCache;
 
   Dart2JsConstructedConstantMirror(Dart2JsMirrorSystem mirrorSystem,
-                                   ConstantExpression constant,
-                                   ConstructedConstantValue value)
+      ConstantExpression constant, ConstructedConstantValue value)
       : super(mirrorSystem, constant, value);
 
   ConstructedConstantValue get _value => super._value;
 
   Map<String, ConstantValue> get _fieldMap {
     if (_fieldMapCache == null) {
       _fieldMapCache = new Map<String, ConstantValue>();
       if (identical(_value.type.element.kind, ElementKind.CLASS)) {
         _value.fields.forEach((FieldElement field, ConstantValue value) {
           _fieldMapCache[field.name] = value;
         });
       }
     }
     return _fieldMapCache;
   }
 
   InstanceMirror getField(Symbol fieldName) {
     String name = MirrorSystem.getName(fieldName);
     ConstantValue fieldConstant = _fieldMap[name];
     if (fieldConstant != null) {
       return _convertConstantToInstanceMirror(
           mirrorSystem, null, fieldConstant);
     }
     return super.getField(fieldName);
   }
 }
 
 class Dart2JsCommentInstanceMirror extends Object
-  with ObjectMirrorMixin, InstanceMirrorMixin
-  implements CommentInstanceMirror {
+    with ObjectMirrorMixin, InstanceMirrorMixin
+    implements CommentInstanceMirror {
   final Dart2JsMirrorSystem mirrorSystem;
   final String text;
   String _trimmedText;
 
   Dart2JsCommentInstanceMirror(this.mirrorSystem, this.text);
 
   ClassMirror get type {
-    return mirrorSystem._getTypeDeclarationMirror(
-        mirrorSystem.compiler.documentClass);
+    return mirrorSystem
+        ._getTypeDeclarationMirror(mirrorSystem.compiler.documentClass);
   }
 
   bool get isDocComment => text.startsWith('/**') || text.startsWith('///');
 
   String get trimmedText {
     if (_trimmedText == null) {
       _trimmedText = stripComment(text);
     }
     return _trimmedText;
   }
 
   InstanceMirror getField(Symbol fieldName) {
     if (fieldName == #isDocComment) {
       return new Dart2JsBoolConstantMirror.fromBool(mirrorSystem, isDocComment);
     } else if (fieldName == #text) {
       return new Dart2JsStringConstantMirror.fromString(mirrorSystem, text);
     } else if (fieldName == #trimmedText) {
-      return new Dart2JsStringConstantMirror.fromString(mirrorSystem,
-                                                        trimmedText);
+      return new Dart2JsStringConstantMirror.fromString(
+          mirrorSystem, trimmedText);
     }
     return super.getField(fieldName);
   }
 }