DeclarationMirror extended with metadata.

sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.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 mirrors_dart2js;
 
 import 'dart:io';
 import 'dart:uri';
 
 import '../../compiler.dart' as diagnostics;
@@ skipping 95 matching lines @@
 
 MethodMirror _convertElementMethodToMethodMirror(Dart2JsContainerMirror library,
                                                  Element element) {
   if (element is FunctionElement) {
     return new Dart2JsMethodMirror(library, element);
   } else {
     return null;
   }
 }
 
+InstanceMirror _convertConstantToInstanceMirror(Dart2JsMirrorSystem mirrors,
+                                                Constant constant) {
+  if (constant is BoolConstant) {
+    return new Dart2JsBoolConstantMirror(mirrors, constant);
+  } else if (constant is NumConstant) {
+    return new Dart2JsNumConstantMirror(mirrors, constant);
+  } else if (constant is StringConstant) {
+    return new Dart2JsStringConstantMirror(mirrors, constant);
+  } else if (constant is ListConstant) {
+    return new Dart2JsListConstantMirror(mirrors, constant);
+  } else if (constant is MapConstant) {
+    return new Dart2JsMapConstantMirror(mirrors, constant);
+  } else if (constant is TypeConstant) {
+    return new Dart2JsTypeConstantMirror(mirrors, constant);
+  } else if (constant is FunctionConstant) {
+    return new Dart2JsConstantMirror(mirrors, constant);
+  } else if (constant is NullConstant) {
+    // TODO(johnniwinther): Introduce a special ClassMirror for the null type?

[ahe, 2012/12/19 15:44:03]

Why?  null is an instance of Null.

[Johnni Winther, 2012/12/20 11:30:35]

Null is currently an internal class in js_helper, but I can see from a TODO on
it that it is intended to be in dart:core.

+    return new Dart2JsNullConstantMirror(mirrors, constant);
+  } else if (constant is ConstructedConstant) {
+    return new Dart2JsConstructedConstantMirror(mirrors, constant);
+  }
+  throw new ArgumentError(

[ahe, 2012/12/19 15:44:03]

This is an internal error as _convertConstantToInstanceMirror is private.

[Johnni Winther, 2012/12/20 11:30:35]

Changed to InternalError (+ some more places).

+      "Unexpected constant $constant");
+}
+
 class Dart2JsMethodKind {
   static const Dart2JsMethodKind REGULAR = const Dart2JsMethodKind("regular");
   static const Dart2JsMethodKind GENERATIVE =
       const Dart2JsMethodKind("generative");
   static const Dart2JsMethodKind REDIRECTING =
       const Dart2JsMethodKind("redirecting");
   static const Dart2JsMethodKind CONST = const Dart2JsMethodKind("const");
   static const Dart2JsMethodKind FACTORY = const Dart2JsMethodKind("factory");
   static const Dart2JsMethodKind GETTER = const Dart2JsMethodKind("getter");
   static const Dart2JsMethodKind SETTER = const Dart2JsMethodKind("setter");
@@ skipping 324 matching lines @@
 
   String get displayName => simpleName;
 
   SourceLocation get location => new Dart2JsSourceLocation(
       _element.getCompilationUnit().script,
       mirrors.compiler.spanFromElement(_element));
 
   String toString() => _element.toString();
 
   int get hashCode => qualifiedName.hashCode;
+
+  List<InstanceMirror> get metadata {
+    var list = <InstanceMirror>[];
+    for (MetadataAnnotation metadata in _element.metadata) {
+      metadata.ensureResolved(mirrors.compiler);
+      list.add(_convertConstantToInstanceMirror(mirrors, metadata.value));
+    }
+    return list;
+  }
 }
 
 abstract class Dart2JsProxyMirror extends Dart2JsDeclarationMirror {
   final Dart2JsMirrorSystem mirrors;
 
   Dart2JsProxyMirror(this.mirrors);
 
   String get displayName => simpleName;
 
   int get hashCode => qualifiedName.hashCode;
@@ skipping 172 matching lines @@
   SourceLocation get location {
     var script = _library.getCompilationUnit().script;
     SourceSpan span;
     if (_library.libraryTag != null) {
       span = mirrors.compiler.spanFromNode(_library.libraryTag, script.uri);
     } else {
       span = new SourceSpan(script.uri, 0, 0);
     }
     return new Dart2JsSourceLocation(script, span);
   }
+
+

[ahe, 2012/12/19 15:44:03]

Remove extra lines.

[Johnni Winther, 2012/12/20 11:30:35]

Done.

 }
 
 class Dart2JsSourceLocation implements SourceLocation {
   final Script _script;
   final SourceSpan _span;
   int _line;
   int _column;
 
   Dart2JsSourceLocation(this._script, this._span);
 
@@ skipping 462 matching lines @@
 
   Map<String, MethodMirror> get methods => const <String, MethodMirror>{};
 
   Map<String, MethodMirror> get getters => const <String, MethodMirror>{};
 
   Map<String, MethodMirror> get setters => const <String, MethodMirror>{};
 
   Map<String, VariableMirror> get variables => const <String, VariableMirror>{};
 
   ClassMirror get defaultFactory => null;
+
+  // TODO(johnniwinther): Should a type show the metadata of its declaration?
+  List<InstanceMirror> get metadata {

[ahe, 2012/12/19 15:44:03]

My personal opinion on style: I don't like getters that compute stuff over and
over.

[Johnni Winther, 2012/12/20 11:30:35]

I don't either. Currently dart2js_mirror generally computes too much repeatedly.
Changed this to use caching.

[Johnni Winther, 2012/12/20 11:30:35]

I don't either. Currently dart2js_mirror generally computes too much repeatedly.
Changed metadata to use caching.

+    var list = <InstanceMirror>[];
+    for (MetadataAnnotation metadata in _type.element.metadata) {
+      metadata.ensureResolved(mirrors.compiler);
+      list.add(_convertConstantToInstanceMirror(mirrors, metadata.value));
+    }
+    return list;
+  }
 }
 
 class Dart2JsInterfaceTypeMirror extends Dart2JsTypeElementMirror
     implements ClassMirror {
   List<TypeMirror> _typeArguments;
 
   Dart2JsInterfaceTypeMirror(Dart2JsMirrorSystem system,
                              InterfaceType interfaceType)
       : super(system, interfaceType);
 
@@ skipping 414 matching lines @@
     var node = _variable.variables.parseNode(_diagnosticListener);
     if (node != null) {
       var span = mirrors.compiler.spanFromNode(node, script.uri);
       return new Dart2JsSourceLocation(script, span);
     } else {
       var span = mirrors.compiler.spanFromElement(_variable);
       return new Dart2JsSourceLocation(script, span);
     }
   }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// Mirrors on constant values used for metadata.

[ahe, 2012/12/19 15:44:03]

Section comments don't work.  A separate file or library does.

[Johnni Winther, 2012/12/20 11:30:35]

Will do a split into multiple files at some point.

+////////////////////////////////////////////////////////////////////////////////
+
+class Dart2JsConstantMirror extends InstanceMirror {
+  final Dart2JsMirrorSystem mirrors;

[ahe, 2012/12/19 15:44:03]

If you store the type in a final, you don't need mirrors.

[Johnni Winther, 2012/12/20 11:30:35]

It is required by the implemented Mirror interface.

[ahe, 2013/01/03 12:03:05]

The Mirror interface needs to be changed, then.  An extra field on each mirror
is a pretty steep price to pay for something that serves no real purpose.

[Johnni Winther, 2013/01/04 09:14:39]

Added a TODO.

[gbracha, 2013/01/04 19:34:30]

This is interesting collateral damage from the change from interfaces to
classes. When the type was an interface, final foo was just a different way of
defining a getter, and implied nothing about storage. Converting to a class
changes that. So the interface should just define a getter.

+  final Constant _constant;
+
+  Dart2JsConstantMirror(this.mirrors, this._constant);
+
+  ClassMirror get type => new Dart2JsClassMirror(

[ahe, 2012/12/19 15:44:03]

If it doesn't fit on one line, my personal preference is to not use the =>
short-hand.

[Johnni Winther, 2012/12/20 11:30:35]

Changed to { }

+      mirrors, _constant.computeType(mirrors.compiler).element);
+
+  bool get hasReflectee => false;
+
+  get reflectee {
+    // TODO(johnniwinther): Which exception/error should be thrown here?
+    throw new UnsupportedError('InstanceMirror does not have a reflectee');
+  }
+
+  Future<InstanceMirror> getField(String fieldName) {
+    throw new NoSuchMethodError(this, fieldName, [], null);

[ahe, 2012/12/19 15:44:03]

Why are you throwing NoSuchMethod?

[Johnni Winther, 2012/12/20 11:30:35]

Changed to UnsupportedError and added a TODO. I'm not sure what the intended
behaviour is.

+  }
+}
+
+class Dart2JsNullConstantMirror extends Dart2JsConstantMirror {
+  Dart2JsNullConstantMirror(Dart2JsMirrorSystem mirrors, NullConstant constant)
+      : super(mirrors, constant);
+
+  NullConstant get _constant => super._constant;
+
+  bool get hasReflectee => true;
+
+  get reflectee => null;
+}
+
+class Dart2JsBoolConstantMirror extends Dart2JsConstantMirror {
+  Dart2JsBoolConstantMirror(Dart2JsMirrorSystem mirrors, BoolConstant constant)
+      : super(mirrors, constant);
+
+  BoolConstant get _constant => super._constant;
+
+  bool get hasReflectee => true;
+
+  get reflectee => _constant is TrueConstant;
+}
+
+class Dart2JsStringConstantMirror extends Dart2JsConstantMirror {
+  Dart2JsStringConstantMirror(Dart2JsMirrorSystem mirrors,
+                            StringConstant constant)

[ahe, 2012/12/19 15:44:03]

Indentation.

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+      : super(mirrors, constant);
+
+  StringConstant get _constant => super._constant;
+
+  bool get hasReflectee => true;
+
+  get reflectee => _constant.value.slowToString();
+}
+
+class Dart2JsNumConstantMirror extends Dart2JsConstantMirror {
+  Dart2JsNumConstantMirror(Dart2JsMirrorSystem mirrors,
+                           NumConstant constant)
+      : super(mirrors, constant);
+
+  NumConstant get _constant => super._constant;
+
+  bool get hasReflectee => true;
+
+  get reflectee => _constant.value;
+}
+
+class Dart2JsListConstantMirror extends Dart2JsConstantMirror
+    implements ListInstanceMirror {
+  Dart2JsListConstantMirror(Dart2JsMirrorSystem mirrors,
+                            ListConstant constant)
+      : super(mirrors, constant);
+
+  ListConstant get _constant => super._constant;
+
+  int get length => _constant.length;
+
+  Future<InstanceMirror> operator[](int index) {
+    if (index < 0) throw new RangeError('Negative index');
+    if (index >= _constant.length) throw new RangeError('Index out of bounds');
+    var completer = new Completer<InstanceMirror>();

[ahe, 2012/12/19 15:44:03]

return new Future.immediate(_convertConstantToInstanceMirror(mirrors,
_constant.entries[index]));

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+    completer.complete(
+        _convertConstantToInstanceMirror(mirrors, _constant.entries[index]));
+    return completer.future;
+  }
+}
+
+class Dart2JsMapConstantMirror extends Dart2JsConstantMirror
+    implements MapInstanceMirror {
+  List<String> _list;
+
+  Dart2JsMapConstantMirror(Dart2JsMirrorSystem mirrors,
+                           MapConstant constant)
+      : super(mirrors, constant);
+
+  MapConstant get _constant => super._constant;
+
+  void _ensureKeyList() {
+    if (_list == null) {
+      _list = new List<String>();

[ahe, 2012/12/19 15:44:03]

Could this be a fixed-size list?

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+      for (StringConstant keyConstant in _constant.keys.entries) {
+        _list.add(keyConstant.value.slowToString());
+      }
+    }
+  }
+
+  int get length => _constant.length;
+
+  Collection<String> get keys {
+    _ensureKeyList();
+    // TODO(johnniwinther): Return an unmodifiable list.
+    return _list;

[ahe, 2012/12/19 15:44:03]

return new List<String>.from(_list)

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+  }
+
+  Future<InstanceMirror> operator[](String key) {
+    _ensureKeyList();
+    int index = _list.indexOf(key);

[ahe, 2012/12/19 15:44:03]

How about using "keys" instead.  Then you don't need to call _ensureKeyList.

[Johnni Winther, 2012/12/20 11:30:35]

I don't want to copy the keys list as is now done in keys.

[ahe, 2013/01/03 12:23:02]

Sounds like you need a todo for updating this code when the library is fixed. My
understanding is that this is one of the things Florian wants to fix in the
collection library.

On a related note: calling _ensureKeyList() before calling _list doesn't seem
elegant. Why don't you integrate _ensureKeyList in a _list getter?

[Johnni Winther, 2013/01/04 09:14:39]

Changed to _ensureKeyList to _getKeyList which returns the ensured list.

+    if (index == -1) return null;
+    var completer = new Completer<InstanceMirror>();

[ahe, 2012/12/19 15:44:03]

Future.immediate

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+    completer.complete(
+        _convertConstantToInstanceMirror(mirrors, _constant.values[index]));
+    return completer.future;
+  }
+}
+
+class Dart2JsTypeConstantMirror extends Dart2JsConstantMirror
+    implements TypeInstanceMirror {
+
+  Dart2JsTypeConstantMirror(Dart2JsMirrorSystem mirrors,
+                            TypeConstant constant)
+      : super(mirrors, constant);
+
+  TypeConstant get _constant => super._constant;
+
+  TypeMirror get representedType => _convertTypeToTypeMirror(
+      mirrors, _constant.representedType, mirrors.compiler.types.dynamicType);
+

[ahe, 2012/12/19 15:44:03]

Extra line.

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+}
+
+class Dart2JsConstructedConstantMirror extends Dart2JsConstantMirror {
+
+  Dart2JsConstructedConstantMirror(Dart2JsMirrorSystem mirrors,
+                                   ConstructedConstant constant)
+      : super(mirrors, constant);
+
+  ConstructedConstant get _constant => super._constant;
+
+  Future<InstanceMirror> getField(String fieldName) {
+    if (identical(_constant.type.element.kind, ElementKind.CLASS)) {
+      ClassElement element = _constant.type.element;
+      var fieldConstant = null;
+      var index = 0;
+      element.forEachInstanceField((_, Element field) {
+        if (field.name.slowToString() == fieldName) {
+          fieldConstant = _constant.fields[index];

[ahe, 2012/12/19 15:44:03]

You need to stop iterating when a match is found:

class Super { int x; }
class Sub extends Super { int x; }

[Johnni Winther, 2012/12/20 11:30:35]

Done.

[Johnni Winther, 2012/12/20 11:30:35]

Changed to compute a field map instead.

+        }
+        index++;
+      }, includeBackendMembers: true, includeSuperMembers: true);
+      if (fieldConstant != null) {
+        var completer = new Completer<InstanceMirror>();

[ahe, 2012/12/19 15:44:03]

Future.immediate.

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+        completer.complete(
+            _convertConstantToInstanceMirror(mirrors, fieldConstant));
+        return completer.future;
+      }
+    }
+    return super.getField(fieldName);
+  }
+

[ahe, 2012/12/19 15:44:03]

Extra line.

[Johnni Winther, 2012/12/20 11:30:35]

Done.

+}