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 61 matching lines @@
   } else if (type is FunctionType) {
     return new Dart2JsFunctionTypeMirror(system, type, functionSignature);
   } else if (type is VoidType) {
     return new Dart2JsVoidMirror(system, type);
   } else if (type is TypedefType) {
     return new Dart2JsTypedefMirror(system, type);
   } else if (type is MalformedType) {
     // TODO(johnniwinther): We need a mirror on malformed types.
     return system.dynamicType;
   }
-  throw new ArgumentError("Unexpected type $type of kind ${type.kind}");
+  _diagnosticListener.internalError(
+      "Unexpected type $type of kind ${type.kind}");
+  system.compiler.internalError("Unexpected type $type of kind ${type.kind}");
 }
 
 Collection<Dart2JsMemberMirror> _convertElementMemberToMemberMirrors(
     Dart2JsContainerMirror library, Element element) {
   if (element is SynthesizedConstructorElement) {
     return const <Dart2JsMemberMirror>[];
   } else if (element is VariableElement) {
     return <Dart2JsMemberMirror>[new Dart2JsFieldMirror(library, element)];
   } else if (element is FunctionElement) {
     return <Dart2JsMemberMirror>[new Dart2JsMethodMirror(library, element)];
   } else if (element is AbstractFieldElement) {
     var members = <Dart2JsMemberMirror>[];
     if (element.getter != null) {
       members.add(new Dart2JsMethodMirror(library, element.getter));
     }
     if (element.setter != null) {
       members.add(new Dart2JsMethodMirror(library, element.setter));
     }
     return members;
   }
-  throw new ArgumentError(
+  library.mirrors.compiler.internalError(
       "Unexpected member type $element ${element.kind}");
 }
 
 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) {
+    return new Dart2JsNullConstantMirror(mirrors, constant);
+  } else if (constant is ConstructedConstant) {
+    return new Dart2JsConstructedConstantMirror(mirrors, constant);
+  }
+  mirrors.compiler.internalError("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 307 matching lines @@
 }
 
 abstract class Dart2JsTypeMirror extends Dart2JsDeclarationMirror
     implements TypeMirror {
 
 }
 
 abstract class Dart2JsElementMirror extends Dart2JsDeclarationMirror {
   final Dart2JsMirrorSystem mirrors;
   final Element _element;
+  List<InstanceMirror> _metadata;
 
   Dart2JsElementMirror(this.mirrors, this._element) {
     assert (mirrors != null);
     assert (_element != null);
   }
 
   String get simpleName => _element.name.slowToString();
 
   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 {
+    if (_metadata == null) {
+      _metadata = <InstanceMirror>[];
+      for (MetadataAnnotation metadata in _element.metadata) {
+        metadata.ensureResolved(mirrors.compiler);
+        _metadata.add(
+            _convertConstantToInstanceMirror(mirrors, metadata.value));
+      }
+    }
+    // TODO(johnniwinther): Return an unmodifiable list instead.
+    return new List<InstanceMirror>.from(_metadata);
+  }
 }
 
 abstract class Dart2JsProxyMirror extends Dart2JsDeclarationMirror {
   final Dart2JsMirrorSystem mirrors;
 
   Dart2JsProxyMirror(this.mirrors);
 
   String get displayName => simpleName;
 
   int get hashCode => qualifiedName.hashCode;
@@ skipping 609 matching lines @@
 }
 
 
 //------------------------------------------------------------------------------
 // Types
 //------------------------------------------------------------------------------
 
 abstract class Dart2JsTypeElementMirror extends Dart2JsProxyMirror
     implements Dart2JsTypeMirror {
   final DartType _type;
+  List<InstanceMirror> _metadata;
 
   Dart2JsTypeElementMirror(Dart2JsMirrorSystem system, this._type)
     : super(system);
 
   String get simpleName => _type.name.slowToString();
 
   SourceLocation get location {
     var script = _type.element.getCompilationUnit().script;
     return new Dart2JsSourceLocation(script,
         mirrors.compiler.spanFromElement(_type.element));
@@ skipping 25 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 {
+    if (_metadata == null) {
+      var _metadata = <InstanceMirror>[];
+      for (MetadataAnnotation metadata in _type.element.metadata) {
+        metadata.ensureResolved(mirrors.compiler);
+        _metadata.add(
+            _convertConstantToInstanceMirror(mirrors, metadata.value));
+      }
+    }
+    // TODO(johnniwinther): Return an unmodifiable list instead.
+    return new List<InstanceMirror>.from(_metadata);
+  }
 }
 
 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.
+////////////////////////////////////////////////////////////////////////////////
+
+class Dart2JsConstantMirror extends InstanceMirror {
+  final Dart2JsMirrorSystem mirrors;
+  final Constant _constant;
+
+  Dart2JsConstantMirror(this.mirrors, this._constant);
+
+  ClassMirror get type {
+    return new Dart2JsClassMirror(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) {
+    // TODO(johnniwinther): Which exception/error should be thrown here?
+    throw new UnsupportedError('InstanceMirror does not have a reflectee');
+  }
+}
+
+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)
+      : 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');
+    return new Future<InstanceMirror>.immediate(
+        _convertConstantToInstanceMirror(mirrors, _constant.entries[index]));
+  }
+}
+
+class Dart2JsMapConstantMirror extends Dart2JsConstantMirror
+    implements MapInstanceMirror {
+  List<String> _listCache;
+
+  Dart2JsMapConstantMirror(Dart2JsMirrorSystem mirrors,
+                           MapConstant constant)
+      : super(mirrors, constant);
+
+  MapConstant get _constant => super._constant;
+
+  List<String> get _list {
+    if (_listCache == null) {
+      _listCache = new List<String>(_constant.keys.entries.length);
+      int index = 0;
+      for (StringConstant keyConstant in _constant.keys.entries) {
+        _listCache[index] = keyConstant.value.slowToString();
+        index++;
+      }
+    }
+    return _listCache;
+  }
+
+  int get length => _constant.length;
+
+  Collection<String> get keys {
+    // TODO(johnniwinther): Return an unmodifiable list instead.
+    return new List<String>.from(_list);
+  }
+
+  Future<InstanceMirror> operator[](String key) {
+    int index = _list.indexOf(key);
+    if (index == -1) return null;
+    return new Future<InstanceMirror>.immediate(
+        _convertConstantToInstanceMirror(mirrors, _constant.values[index]));
+  }
+}
+
+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);
+}
+
+class Dart2JsConstructedConstantMirror extends Dart2JsConstantMirror {
+  Map<String,Constant> _fieldMapCache;
+
+  Dart2JsConstructedConstantMirror(Dart2JsMirrorSystem mirrors,
+                                   ConstructedConstant constant)
+      : super(mirrors, constant);
+
+  ConstructedConstant get _constant => super._constant;
+
+  Map<String,Constant> get _fieldMap {
+    if (_fieldMapCache == null) {
+      _fieldMapCache = new LinkedHashMap<String,Constant>();
+      if (identical(_constant.type.element.kind, ElementKind.CLASS)) {
+        var index = 0;
+        ClassElement element = _constant.type.element;
+        element.forEachInstanceField((_, Element field) {
+          String fieldName = field.name.slowToString();
+          _fieldMapCache.putIfAbsent(fieldName, () => _constant.fields[index]);
+          index++;
+        }, includeBackendMembers: true, includeSuperMembers: true);
+      }
+    }
+    return _fieldMapCache;
+  }
+
+  Future<InstanceMirror> getField(String fieldName) {
+    Constant fieldConstant = _fieldMap[fieldName];
+    if (fieldConstant != null) {
+      return new Future<InstanceMirror>.immediate(
+          _convertConstantToInstanceMirror(mirrors, fieldConstant));
+    }
+    return super.getField(fieldName);
+  }
+}