Implement metadata as an internal native. Be honest about which mirrors don't yet support metadata …

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
   return (value == null || value is num || value is String || value is bool);
 }
@@ skipping 52 matching lines @@
 }
 
 Map<Uri, LibraryMirror> _createLibrariesMap(Map<String, LibraryMirror> map) {
     var result = new Map<Uri, LibraryMirror>();
     map.forEach((String url, LibraryMirror mirror) {
       result[Uri.parse(url)] = mirror;
     });
     return result;
 }
 
-List<InstanceMirror> _metadata(mirror) 
-  native 'Mirrors_metadata';
+List _metadata(reflectee)
+  native 'DeclarationMirror_metadata';
 
 // This will verify the argument types, unwrap them, and ensure we have a fixed
 // array.
 List _unwarpAsyncPositionals(wrappedArgs){
   List unwrappedArgs = new List(wrappedArgs.length);
   for(int i = 0; i < wrappedArgs.length; i++){
     var wrappedArg = wrappedArgs[i];
     if(_isSimpleValue(wrappedArg)) {
       unwrappedArgs[i] = wrappedArg;
     } else if(wrappedArg is InstanceMirror) {
@@ skipping 72 matching lines @@
   LibraryMirror get rootLibrary {
     if (_rootLibrary is _LazyLibraryMirror) {
       _rootLibrary = _rootLibrary.resolve(mirrors);
     }
     return _rootLibrary;
   }
 
   String toString() => "IsolateMirror on '$debugName'";
 }
 
-// A VMReference is used to hold a reference to a VM-internal object,
-// which can include things like libraries, classes, etc.
-class VMReference extends NativeFieldWrapperClass1 {
-}
-
-abstract class _LocalVMObjectMirrorImpl extends _LocalMirrorImpl {
-  _LocalVMObjectMirrorImpl(this._reference) {}
-
-  // For now, all VMObjects hold a VMReference.  We could consider
-  // storing the Object reference itself here if the object is a Dart
-  // language objects (except for objects of type VMReference, of
-  // course).
-  VMReference _reference;
-}
-
-abstract class _LocalObjectMirrorImpl extends _LocalVMObjectMirrorImpl
+abstract class _LocalObjectMirrorImpl extends _LocalMirrorImpl
     implements ObjectMirror {
-  _LocalObjectMirrorImpl(this._reflectee, ref) : super(ref) {}
+  _LocalObjectMirrorImpl(this._reflectee);
 
   final _reflectee; // May be a MirrorReference or an ordinary object.
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is not implemented');
     }
@@ skipping 73 matching lines @@
             'positional argument $i ($arg) was not a simple value');
       }
   }
 }
 
 class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
     implements InstanceMirror {
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
-  _LocalInstanceMirrorImpl(ref,
-                           this._type,
-                           reflectee) : super(reflectee, ref) {}
+  _LocalInstanceMirrorImpl(this._type,
+                           reflectee) : super(reflectee) {}
 
   var _type;
   ClassMirror get type {
     if (_type is! Mirror) {
       _type = _type.resolve(mirrors);
     }
     return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
@@ skipping 23 matching lines @@
 
   _invokeGetter(reflectee, getterName)
       native 'InstanceMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'InstanceMirror_invokeSetter';
 }
 
 class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
     implements ClosureMirror {
-  _LocalClosureMirrorImpl(ref,
-                          type,
+  _LocalClosureMirrorImpl(type,
                           reflectee,
-                          this.function) : super(ref, type, reflectee) {}
+                          this.function) : super(type, reflectee) {}
 
   final MethodMirror function;
 
   String get source {
     throw new UnimplementedError(
         'ClosureMirror.source is not implemented');
   }
 
   InstanceMirror apply(List<Object> positionalArguments,
                        [Map<Symbol, Object> namedArguments]) {
@@ skipping 59 matching lines @@
     return resolved;
   }
 
   final String libraryUrl;
   final Symbol typeName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
-                        ref,
                         String simpleName,
                         this.isClass,
                         this._owner,
                         this._superclass,
                         this._superinterfaces,
                         this._defaultFactory,
                         Map<String, Mirror> members,
                         Map<String, Mirror> constructors,
                         Map<String, Mirror> typeVariables)
       : this._simpleName = _s(simpleName),
         this.members = _convertStringToSymbolMap(members),
         this.constructors = _convertStringToSymbolMap(constructors),
         this.typeVariables = _convertStringToSymbolMap(typeVariables),
-        super(reflectee, ref);
+        super(reflectee);
 
   Symbol _simpleName;
   Symbol get simpleName {
     // dynamic, void and the function types have their names set eagerly in the
     // constructor.
     if(_simpleName == null) {
       _simpleName = _s(_name(_reflectee));
     }
     return _simpleName;
   }
@@ skipping 143 matching lines @@
     try {
       var result = _invokeConstructor(_reflectee,
                                       _n(constructorName),
                                       _unwarpAsyncPositionals(positionalArguments));
       return new Future.value(reflect(result)); 
     } on MirroredError catch(e) {
       return new Future.error(e);
     }
   }
 
-  // get the metadata objects, convert them into InstanceMirrors using
-  // reflect() and then make them into a Dart list
-  List<InstanceMirror> get metadata => _metadata(this).map(reflect).toList();
-
+  List<InstanceMirror> get metadata {
+    // get the metadata objects, convert them into InstanceMirrors using
+    // reflect() and then make them into a Dart list
+    return _metadata(_reflectee).map(reflect).toList();
+  }
 
   static _name(reflectee)
       native "ClassMirror_name";
 
   _invoke(reflectee, memberName, positionalArguments)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
@@ skipping 11 matching lines @@
     return mirrors._lookupFunctionTypeMirror(returnType.resolve(mirrors),
                                              parameters);
   }
 
   final returnType;
   final List<ParameterMirror> parameters;
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
-  _LocalFunctionTypeMirrorImpl(ref,
+  _LocalFunctionTypeMirrorImpl(reflectee,
                                simpleName,
                                this._returnType,
                                this.parameters)
-      : super(null,
-              ref,
+      : super(reflectee,
               simpleName,
               true,
               null,
               new _LazyTypeMirror('dart:core', 'Object'),
               [ new _LazyTypeMirror('dart:core', 'Function') ],
               null,
               const {},
               const {},
               const {});
 
@@ skipping 59 matching lines @@
   }
 
   var _upperBound;
   TypeMirror get upperBound {
     if (_upperBound is! Mirror) {
       _upperBound = _upperBound.resolve(mirrors);
     }
     return _upperBound;
   }
 
-  // get the metadata objects, convert them into InstanceMirrors using
-  // reflect() and then make them into a Dart list
-  List<InstanceMirror> get metadata => _metadata(this).map(reflect).toList();
+  List<InstanceMirror> get metadata {
+    throw new UnimplementedError(
+        'TypeVariableMirror.metadata is not implemented');
+  }
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(String simpleName,
                           this._owner,
                           this._referent)
@@ skipping 44 matching lines @@
   LibraryMirror resolve(MirrorSystem mirrors) {
     return mirrors.libraries[Uri.parse(libraryUrl)];
   }
 
   final String libraryUrl;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(reflectee,
-                          ref,
                           String simpleName,
                           String url,
                           Map<String, Mirror> members)
       : this.simpleName = _s(simpleName),
         this.members = _convertStringToSymbolMap(members),
         this.uri = Uri.parse(url),
-        super(reflectee, ref);
+        super(reflectee);
 
   final Symbol simpleName;
 
   // The simple name and the qualified name are the same for a library.
   Symbol get qualifiedName => simpleName;
 
   // Always null for libraries.
   final DeclarationMirror owner = null;
 
   // Always false for libraries.
@@ skipping 49 matching lines @@
   }
 
   Map<Symbol, VariableMirror> get variables {
     if (_variables == null) {
       _variables = _filterMap(members,
                               (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
-  // get the metadata objects, convert them into InstanceMirrors using
-  // reflect() and then make them into a Dart list
-  List<InstanceMirror> get metadata => _metadata(this).map(reflect).toList();
+  List<InstanceMirror> get metadata {
+    // get the metadata objects, convert them into InstanceMirrors using
+    // reflect() and then make them into a Dart list
+    _metadata(_reflectee).map(reflect).toList();
+  }
 
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
 
   _invoke(reflectee, memberName, positionalArguments)
       native 'LibraryMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'LibraryMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
@@ skipping 101 matching lines @@
 
   final bool isConstConstructor;
   final bool isGenerativeConstructor;
   final bool isRedirectingConstructor;
   final bool isFactoryConstructor;
 
   List<InstanceMirror> get metadata {
     owner; // ensure owner is computed
     // get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list
-    return _metadata(this).map(reflect).toList();
+    return _metadata(_reflectee).map(reflect).toList();
   }
 
   String toString() => "MethodMirror on '${_n(simpleName)}'";
 
   static String _MethodMirror_name(reflectee)
       native "MethodMirror_name";
 }
 
 class _LocalVariableMirrorImpl extends _LocalMirrorImpl
     implements VariableMirror {
-  _LocalVariableMirrorImpl(String simpleName,
+  _LocalVariableMirrorImpl(this._reflectee,
+                           String simpleName,
                            this._owner,
                            this._type,
                            this.isStatic,
                            this.isFinal)
       : this.simpleName = _s(simpleName);
 
+  final _MirrorReference _reflectee;
   final Symbol simpleName;
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
@@ skipping 23 matching lines @@
     if (_type is! Mirror) {
       _type = _type.resolve(mirrors);
     }
     return _type;
   }
 
   final bool isStatic;
   final bool isFinal;
 
   List<InstanceMirror> get metadata {
-    owner; // ensure owner is computed
     // get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list
-    return _metadata(this).map(reflect).toList();
+    return _metadata(_reflectee).map(reflect).toList();
   }
 
   String toString() => "VariableMirror on '${_n(simpleName)}'";
 }
 
 class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
     implements ParameterMirror {
   _LocalParameterMirrorImpl(type, this.isOptional)
-      : super('<TODO:unnamed>', null, type, false, false) {}
+      : super(null, '<TODO:unnamed>', null, type, false, false) {}
 
   final bool isOptional;
 
   String get defaultValue {
     throw new UnimplementedError(
         'ParameterMirror.defaultValue is not implemented');
   }
 
   bool get hasDefaultValue {
     throw new UnimplementedError(
         'ParameterMirror.hasDefaultValue is not implemented');
   }
+
+  // TODO(11418): Implement.
+  List<InstanceMirror> get metadata {
+    throw new UnimplementedError(
+        'ParameterMirror.metadata is not implemented');
+  }
 }
 
 class _SpecialTypeMirrorImpl extends _LocalMirrorImpl
     implements TypeMirror, DeclarationMirror {
   _SpecialTypeMirrorImpl(this.simpleName);
 
   final bool isPrivate = false;
   final bool isTopLevel = true;
 
   // Fixed length 0, therefore immutable.
@@ skipping 57 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }