Implements support for reflection on parameters.

reflectable/lib/src/mirrors_unimpl.dart

 // Copyright (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 library reflectable.src.mirrors_unimpl;
 
 import 'dart:collection' show UnmodifiableMapView, UnmodifiableListView;
 
 import '../capability.dart';
 import '../mirrors.dart';
@@ skipping 11 matching lines @@
 // in ways that are not covered by the specified capabilities.
 //
 // Each of these classes implements the corresponding class in
 // `package:reflectable/mirrors.dart`, and they replicate the internal
 // implements `structure in package:reflectable/mirrors.dart` using `extends`
 // and `with` clauses, such that the (un)implementation is inherited rather than
 // replicated wherever possible.
 
 _unsupported() => throw new UnimplementedError();
 
-abstract class DeclarationMirrorUnimpl implements DeclarationMirror {
-  String get simpleName => _unsupported();
-  String get qualifiedName => _unsupported();
-  DeclarationMirror get owner => _unsupported();
-  bool get isPrivate => _unsupported();
-  bool get isTopLevel => _unsupported();
-  SourceLocation get location => _unsupported();
-  List<Object> get metadata => _unsupported();
-}
-
-abstract class ObjectMirrorUnimpl implements ObjectMirror {
-  Object invoke(String memberName, List positionalArguments,
-      [Map<Symbol, dynamic> namedArguments]) => _unsupported();
-  Object invokeGetter(String getterName) => _unsupported();
-  Object invokeSetter(String setterName, Object value) => _unsupported();
-
-  Object getField(String name) {
-    throw new UnsupportedError("Use invokeGetter instead of getField");
-  }
-
-  void setField(String name, Object value) {
-    throw new UnsupportedError("Use invokeSetter instead of setField");
-  }
-}
-
-abstract class InstanceMirrorUnimpl extends ObjectMirrorUnimpl
-    implements InstanceMirror {
-  ClassMirror get type => _unsupported();
-  bool get hasReflectee => _unsupported();
-  get reflectee => _unsupported();
-  bool operator ==(other) => _unsupported();
-  int get hashCode => _unsupported();
-  delegate(Invocation invocation) => _unsupported();
-}
-
 /// Invokes a getter on an object.
-typedef Object InvokerOfGetter(Object instance);
+typedef Object _InvokerOfGetter(Object instance);
 
 /// Invokes a setter on an object.
-typedef Object InvokerOfSetter(Object instance, Object value);
+typedef Object _InvokerOfSetter(Object instance, Object value);
 
 /// Invokes a static getter.
-typedef Object StaticGetter();
+typedef Object _StaticGetter();
 
 /// Invokes a setter on an object.
-typedef Object StaticSetter(Object value);
+typedef Object _StaticSetter(Object value);
 
 /// The data backing a reflector.
 class ReflectorData {
   /// List of class mirrors, one class mirror for each class that is
   /// supported by reflection as specified by the reflector backed up
   /// by this [ReflectorData].
   final List<ClassMirror> classMirrors;
 
   /// Repository of method mirrors used (via indices into this list) by
-  /// the above class mirrors to describe the behavior of the mirrored
+  /// the [classMirrors] to describe the behavior of the mirrored
   /// class and its instances, and of variable mirrors used to describe
   /// their state. From the behavioral point of view there are no fields,
   /// but each of them gives rise to a getter and possibly a setter (whose
   /// `isSynthetic` is true). The implicit getters/setters are not stored
   /// in this list, but they can be reconstructed based on the variable
   /// mirrors describing the fields. From the program structure point of
   /// view (used for `declarations`), the method mirrors and the field
   /// mirrors must both be included directly. Hence, both points of view
   /// require a little bit of processing, but in return we avoid some
   /// redundancy in the stored information.
   final List<DeclarationMirror> memberMirrors;
 
+  /// Repository of parameter mirrors used (via indices into this list) by
+  /// the [memberMirrors] to describe the parameters of methods
+  final List<ParameterMirror> parameterMirrors;
+
   /// List of [Type]s used to select class mirrors: If M is a class
   /// mirror in [classMirrors] at index `i`, the mirrored class (and
   /// hence the runtime type of the mirrored instances) is found in
   /// `types[i]`.
   final List<Type> types;
 
   /// Map from getter names to closures accepting an instance and returning
   /// the result of invoking the getter with that name on that instance.
-  final Map<String, InvokerOfGetter> getters;
+  final Map<String, _InvokerOfGetter> getters;
 
   /// Map from setter names to closures accepting an instance and a new value,
   /// invoking the setter of that name on that instance, and returning its
   /// return value.
-  final Map<String, InvokerOfSetter> setters;
+  final Map<String, _InvokerOfSetter> setters;
 
   Map<Type, ClassMirror> _typeToClassMirrorCache;
 
-  ReflectorData(this.classMirrors, this.memberMirrors, this.types, this.getters,
-      this.setters);
+  ReflectorData(this.classMirrors, this.memberMirrors, this.parameterMirrors,
+      this.types, this.getters, this.setters);
 
   /// Returns a class-mirror for the given [type].
   ///
   /// Returns `null` if the given class is not marked for reflection.
   ClassMirror classMirrorForType(Type type) {
     if (_typeToClassMirrorCache == null) {
       _typeToClassMirrorCache = new Map.fromIterables(types, classMirrors);
     }
     return _typeToClassMirrorCache[type];
   }
 }
 
 /// This mapping contains the mirror-data for each reflector.
 /// It will be initialized in the generated code.
 Map<Reflectable, ReflectorData> data = throw new StateError(
     "Reflectable has not been initialized. "
     "Did you forget to add the main file to the "
     "reflectable transformer's entry_points in pubspec.yaml?");
 
-class InstanceMirrorImpl implements InstanceMirror {
+
+abstract class _DataCaching {
   ReflectorData _dataCache;
+  ReflectableImpl get _reflector;
+
   ReflectorData get _data {
     if (_dataCache == null) {
-      _dataCache = data[_reflectable];
+      _dataCache = data[_reflector];

[floitsch, 2015/08/13 17:33:36]

Why is this lazy? It's just a lookup into a map. That shouldn't be a problem
when the constructing a mirror-object.

If it doesn't need to be lazy, you can remove the class again.

[eernst, 2015/08/14 12:05:34]

We have done that for a while, I just created the class and used it as a mixin
in order to avoid the code duplication. It is concerned with all lookups into
`data`, which means that an application doing a lot of reflection work could
perform that map lookup many times. Whether it is a useful type of caching is
hard to tell. Added a TODO indicating that we should turn it on and off and see
the effect when we have some more substantial pieces of software using it.

[floitsch, 2015/08/17 14:32:23]

Why is it not filled at construction?

[eernst, 2015/08/19 13:41:56]

Could do that, check https://codereview.chromium.org/1284423004

[Since I wrote the above, that experiment showed that it was not easy to make
such a change, so we have abandoned that CL.]

     }
     return _dataCache;
   }
+}
 
-  final ReflectableImpl _reflectable;
-
+class _InstanceMirrorImpl extends _DataCaching implements InstanceMirror  {
+  final ReflectableImpl _reflector;
   final Object reflectee;
 
-  InstanceMirrorImpl(this.reflectee, this._reflectable) {
+  _InstanceMirrorImpl(this.reflectee, this._reflector) {
     _type = _data.classMirrorForType(reflectee.runtimeType);
     if (_type == null) {
       throw new NoSuchCapabilityError(
           "Reflecting on un-marked type ${reflectee.runtimeType}");
     }
   }
 
   ClassMirror _type;
 
   ClassMirror get type => _type;
 
   Object invoke(String methodName, List<Object> positionalArguments,
       [Map<Symbol, Object> namedArguments]) {
     Function methodTearer = _data.getters[methodName];
     if (methodTearer != null) {
       return Function.apply(
           methodTearer(reflectee), positionalArguments, namedArguments);
     }
     throw new NoSuchInvokeCapabilityError(
         reflectee, methodName, positionalArguments, namedArguments);
   }
 
   bool get hasReflectee => true;
 
   bool operator ==(other) {
-    return other is InstanceMirrorImpl &&
-        other._reflectable == _reflectable &&
+    return other is _InstanceMirrorImpl &&
+        other._reflector == _reflector &&
         other.reflectee == reflectee;
   }
 
-  int get hashCode => reflectee.hashCode ^ _reflectable.hashCode;
+  int get hashCode => reflectee.hashCode ^ _reflector.hashCode;
 
   delegate(Invocation invocation) => _unsupported();
 
   @override
   Object invokeGetter(String getterName) {
     Function getter = _data.getters[getterName];
     if (getter != null) {
       return getter(reflectee);
     }
     throw new NoSuchInvokeCapabilityError(reflectee, getterName, [], {});
   }
 
   @override
   Object invokeSetter(String setterName, Object value) {
     if (setterName.substring(setterName.length - 1) != "=") {
       setterName += "=";
     }
     Function setter = _data.setters[setterName];
     if (setter != null) {
       return setter(reflectee, value);
     }
     throw new NoSuchInvokeCapabilityError(reflectee, setterName, [value], {});
   }
 }
 
-abstract class ClosureMirrorUnimpl extends InstanceMirrorUnimpl
-    implements ClosureMirror {
-  MethodMirror get function => _unsupported();
-  InstanceMirror apply(List positionalArguments,
-      [Map<Symbol, dynamic> namedArguments]) => _unsupported();
-}
-
-abstract class LibraryMirrorUnimpl extends DeclarationMirrorUnimpl
-    with ObjectMirrorUnimpl implements LibraryMirror {
-  Uri get uri => _unsupported();
-  Map<String, DeclarationMirror> get declarations => _unsupported();
-  bool operator ==(other) => _unsupported();
-  int get hashCode => _unsupported();
-  List<LibraryDependencyMirror> get libraryDependencies => _unsupported();
-}
-
-class LibraryDependencyMirrorUnimpl implements LibraryDependencyMirror {
-  bool get isImport => _unsupported();
-  bool get isExport => _unsupported();
-  bool get isDeferred => _unsupported();
-  LibraryMirror get sourceLibrary => _unsupported();
-  LibraryMirror get targetLibrary => _unsupported();
-  String get prefix => _unsupported();
-  List<CombinatorMirror> get combinators => _unsupported();
-  SourceLocation get location => _unsupported();
-  List<Object> get metadata => _unsupported();
-}
-
-abstract class CombinatorMirrorUnimpl implements CombinatorMirror {
-  List<String> get identifiers => _unsupported();
-  bool get isShow => _unsupported();
-  bool get isHide => _unsupported();
-}
-
-abstract class TypeMirrorUnimpl extends DeclarationMirrorUnimpl
-    implements TypeMirror {
-  bool get hasReflectedType => _unsupported();
-  Type get reflectedType => _unsupported();
-  List<TypeVariableMirror> get typeVariables => _unsupported();
-  List<TypeMirror> get typeArguments => _unsupported();
-  bool get isOriginalDeclaration => _unsupported();
-  TypeMirror get originalDeclaration => _unsupported();
-  bool isSubtypeOf(TypeMirror other) => _unsupported();
-  bool isAssignableTo(TypeMirror other) => _unsupported();
-}
-
 int _variableToImplicitAccessorAttributes(VariableMirror variableMirror) {
   int attributes = 0;
   if (variableMirror.isPrivate) attributes |= constants.privateAttribute;
   if (variableMirror.isStatic) attributes |= constants.staticAttribute;
   attributes |= constants.syntheticAttribute;
   return attributes;
 }
 
 MethodMirror _variableToGetterMirror(VariableMirrorImpl variableMirror) {
   int descriptor = constants.getter;
   descriptor |= _variableToImplicitAccessorAttributes(variableMirror);
+  // TODO(eernst) clarify: Make sure it is the right `ownerIndex`: Write a test
+  // that compares owners in pre/post-transform code.
   return new MethodMirrorImpl(variableMirror.simpleName, descriptor,
-      variableMirror.ownerIndex, variableMirror.reflectable, []);
+      variableMirror._ownerIndex, [], variableMirror._reflector, []);
 }
 
+// TODO(eernst) implement: Make this method take an `index` parameter which
+// will be the index of the returned `MethodMirror`, such that the enclosed
+// parameter mirror can get the right ownerIndex.
 MethodMirror _variableToSetterMirror(VariableMirrorImpl variableMirror) {
-  int descriptor = constants.setter;
+  int descriptor = constants.setter | constants.syntheticAttribute;
   descriptor |= _variableToImplicitAccessorAttributes(variableMirror);
-  return new MethodMirrorImpl(variableMirror.simpleName + "=", descriptor,
-      variableMirror.ownerIndex, variableMirror.reflectable, []);
+  int parameterDescriptor = constants.parameter | constants.syntheticAttribute;
+  String name = variableMirror.simpleName + "=";
+  return new MethodMirrorImpl(name, descriptor, variableMirror._ownerIndex,
+      [ // TODO(eernst) clarify: Make sure it is the right `ownerIndex`: Write a
+        // test that compares owners in pre/post-transform code.

[floitsch, 2015/08/13 17:33:36]

What's missing to write the test?

[floitsch, 2015/08/17 14:32:23]

?

[eernst, 2015/08/19 13:41:56]

Oops, forgot that. Turned out to require more refactorings than I had expected.
Followup in https://codereview.chromium.org/1297503006.

+        new ParameterMirrorImpl(name, parameterDescriptor,
+            variableMirror._ownerIndex, variableMirror._reflector, [], null, -1)],

[floitsch, 2015/08/13 17:33:36]

long line.

[eernst, 2015/08/14 12:05:34]

Fixed. Btw, doing the usual 'Reformat with Dart style' in IntelliJ creates a 162
line diff (apparently, we hadn't done that to this particular file since the
last update to dartfmt).

Sigurd and I have agreed to isolate this kind of noise in each CL in the sense
that we will generally create a first patch set which is the result of running
dartfmt on all source files at first. This means that the first patch set is
pure auto-reformatting, and then reviewers can quickly verify what is going on
in patch 1 and then check out the diff starting from 2 in order to see the
topic-related updates.

+      variableMirror._reflector, []);
 }
 
-class ClassMirrorImpl implements ClassMirror {
-  ReflectorData _dataCache;
-  ReflectorData get _data {
-    if (_dataCache == null) {
-      _dataCache = data[_reflectable];
-    }
-    return _dataCache;
-  }
-
+class ClassMirrorImpl extends _DataCaching implements ClassMirror   {
   /// The reflector which represents the mirror system that this
   /// mirror belongs to.
-  final ReflectableImpl _reflectable;
+  final ReflectableImpl _reflector;
 
   /// The index of this mirror in the [ReflectorData.classMirrors] table.
   /// Also this is the index of the Type of the reflected class in
   /// [ReflectorData.types].
   final int _classIndex;
 
   /// A list of the indices in [ReflectorData.memberMirrors] of the
   /// declarations of the reflected class. This includes method mirrors
   /// and variable mirrors and it directly corresponds to `declarations`.
   final List<int> _declarationIndices;
 
   /// A list of the indices in [ReflectorData.memberMirrors] of the
   /// instance members of the reflected class, except that it includes
   /// variable mirrors describing fields which must be converted to
   /// implicit getters and possibly implicit setters in order to
   /// obtain the correct result for `instanceMembers`.
   final List<int> _instanceMemberIndices;
 
   /// The index of the mirror of the superclass in the
   /// [ReflectorData.classMirrors] table.
   final int _superclassIndex;
 
   final String simpleName;
   final String qualifiedName;
   final List<Object> _metadata;
-  final Map<String, StaticGetter> getters;
-  final Map<String, StaticSetter> setters;
+  final Map<String, _StaticGetter> getters;
+  final Map<String, _StaticSetter> setters;
   final Map<String, Function> constructors;
 
   ClassMirrorImpl(this.simpleName, this.qualifiedName, this._classIndex,
-      this._reflectable, this._declarationIndices, this._instanceMemberIndices,
+      this._reflector, this._declarationIndices, this._instanceMemberIndices,
       this._superclassIndex, this.getters, this.setters, this.constructors,
       metadata)
       : _metadata = (metadata == null)
           ? null
           : new UnmodifiableListView(metadata);
 
   ClassMirror get superclass {
     if (_superclassIndex == null) return null;
     if (_superclassIndex == -1) {
       throw new NoSuchCapabilityError(
@@ skipping 72 matching lines @@
       return superclass.isSubclassOf(other);
     }
   }
 
   @override
   bool get hasReflectedType => true;
 
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
-    StaticGetter getter = getters[memberName];
+    _StaticGetter getter = getters[memberName];
     if (getter == null) {
       throw new NoSuchInvokeCapabilityError(
           reflectedType, memberName, positionalArguments, namedArguments);
     }
     return Function.apply(
         getters[memberName](), positionalArguments, namedArguments);
   }
 
   @override
   Object invokeGetter(String getterName) {
-    StaticGetter getter = getters[getterName];
+    _StaticGetter getter = getters[getterName];
     if (getter == null) {
       throw new NoSuchInvokeCapabilityError(reflectedType, getterName, [], {});
     }
     return getter();
   }
 
   @override
   Object invokeSetter(String setterName, Object value) {
-    StaticSetter setter = setters[setterName];
+    _StaticSetter setter = setters[setterName];
     if (setter == null) {
       throw new NoSuchInvokeCapabilityError(
           reflectedType, setterName, [value], {});
     }
     return setter(value);
   }
 
   // TODO(eernst) feature: Implement `isAssignableTo`.
   @override
   bool isAssignableTo(TypeMirror other) => _unsupported();
@@ skipping 51 matching lines @@
     return getter;
   }
 
   String toString() => "ClassMirrorImpl($qualifiedName)";
 
   // Because we take care to only ever create one instance for each
   // type/reflector-combination we can rely on the default `hashCode` and `==`
   // operations.
 }
 
-abstract class TypeVariableMirrorUnimpl extends TypeMirrorUnimpl
-    implements TypeVariableMirror {
-  TypeMirror get upperBound => _unsupported();
-  bool get isStatic => _unsupported();
-  bool operator ==(other) => _unsupported();
-  int get hashCode => _unsupported();
-}
-
-abstract class TypedefMirrorUnimpl extends TypeMirrorUnimpl
-    implements TypedefMirror {
-  FunctionTypeMirror get referent => _unsupported();
-}
-
-abstract class MethodMirrorUnimpl extends DeclarationMirrorUnimpl
-    implements MethodMirror {
-  TypeMirror get returnType => _unsupported();
-  String get source => _unsupported();
-  List<ParameterMirror> get parameters => _unsupported();
-  bool get isStatic => _unsupported();
-  bool get isAbstract => _unsupported();
-  bool get isSynthetic => _unsupported();
-  bool get isRegularMethod => _unsupported();
-  bool get isOperator => _unsupported();
-  bool get isGetter => _unsupported();
-  bool get isSetter => _unsupported();
-  bool get isConstructor => _unsupported();
-  String get constructorName => _unsupported();
-  bool get isConstConstructor => _unsupported();
-  bool get isGenerativeConstructor => _unsupported();
-  bool get isRedirectingConstructor => _unsupported();
-  bool get isFactoryConstructor => _unsupported();
-  bool operator ==(other) => _unsupported();
-  int get hashCode => _unsupported();
-}
-
-class MethodMirrorImpl implements MethodMirror {
+class MethodMirrorImpl extends _DataCaching implements MethodMirror   {
   /// An encoding of the attributes and kind of this mirror.
   final int _descriptor;
 
   /// The name of this method. Setters names will end in '='.
   final String _name;
 
   /// The index of the [ClassMirror] of the owner of this method,
   final int _ownerIndex;
 
+  /// The indices of the [ParameterMirror]s describing the formal parameters
+  /// of this method.
+  final List<int> _parameterIndices;
+
   /// The [Reflectable] associated with this mirror.
   final ReflectableImpl _reflector;
 
   /// A cache of the metadata of the mirrored method. The empty list means
   /// no metadata, null means that [_reflector] does not have
   /// [metadataCapability].
   final List<Object> _metadata;
 
   MethodMirrorImpl(this._name, this._descriptor, this._ownerIndex,
-      this._reflector, List<Object> metadata)
+      this._parameterIndices, this._reflector, List<Object> metadata)
       : _metadata = (metadata == null)
           ? null
           : new UnmodifiableListView(metadata);
 
   int get kind => constants.kindFromEncoding(_descriptor);
 
-  ClassMirror get owner => data[_reflector].classMirrors[_ownerIndex];
+  ClassMirror get owner => _data.classMirrors[_ownerIndex];
 
   @override
   String get constructorName => _name;
 
   @override
   bool get isAbstract => 0 != _descriptor & constants.abstractAttribute;
 
   @override
   bool get isConstConstructor => 0 != _descriptor & constants.constAttribute;
 
@@ skipping 28 matching lines @@
 
   @override
   bool get isStatic => 0 != _descriptor & constants.staticAttribute;
 
   @override
   bool get isSynthetic => 0 != _descriptor & constants.syntheticAttribute;
 
   @override
   bool get isTopLevel => owner is LibraryMirror;
 
+  // It is allowed to return null.
   @override
-  SourceLocation get location =>
-      throw new UnsupportedError("Location not supported");
+  SourceLocation get location => null;
 
   @override
   List<Object> get metadata {
     if (_metadata == null) {
       throw new NoSuchCapabilityError(
           "Requesting metadata of method $simpleName without capability");
     }
     return _metadata;
   }
 
-  // TODO(sigurdm) feature: support `parameters`.
   @override
-  List<ParameterMirror> get parameters => throw new UnimplementedError();
+  List<ParameterMirror> get parameters {
+    return _parameterIndices
+        .map((int parameterIndex) => _data.parameterMirrors[parameterIndex])
+        .toList();
+  }
 
   @override
   String get qualifiedName => "${owner.qualifiedName}.$_name";
 
   // TODO(sigurdm) feature: suport `returnType`.
   @override
   TypeMirror get returnType => throw new UnimplementedError();
 
   @override
   String get simpleName => isConstructor
       ? (_name == '' ? "${owner.simpleName}" : "${owner.simpleName}.$_name")
       : _name;
 
   @override
   String get source => null;
 
   @override
   String toString() => "MethodMirror($_name)";
 }
 
-abstract class VariableMirrorUnimpl extends DeclarationMirrorUnimpl
+abstract class VariableMirrorBase extends _DataCaching
     implements VariableMirror {
-  TypeMirror get type => _unsupported();
-  bool get isStatic => _unsupported();
-  bool get isFinal => _unsupported();
-  bool get isConst => _unsupported();
-  bool operator ==(other) => _unsupported();
-  int get hashCode => _unsupported();
-}
-
-class VariableMirrorImpl implements VariableMirror {
-  final int descriptor;
-  final String name;
-  final int ownerIndex;
-  final ReflectableImpl reflectable;
+  final String _name;
+  final int _descriptor;
+  final int _ownerIndex;
+  final ReflectableImpl _reflector;
   final List<Object> _metadata;
 
-  VariableMirrorImpl(this.name, this.descriptor, this.ownerIndex,
-      this.reflectable, List<Object> metadata)
+  VariableMirrorBase(this._name, this._descriptor, this._ownerIndex,
+      this._reflector, List<Object> metadata)
       : _metadata = (metadata == null)
-          ? null
-          : new UnmodifiableListView(metadata);
+          ? null : new UnmodifiableListView(metadata);
 
-  int get kind => constants.kindFromEncoding(descriptor);
-
-  ClassMirror get owner => data[reflectable].classMirrors[ownerIndex];
+  int get kind => constants.kindFromEncoding(_descriptor);
 
   @override
-  String get qualifiedName => "${owner.qualifiedName}.$name";
-
-  @override
-  bool get isPrivate => 0 != descriptor & constants.privateAttribute;
+  bool get isPrivate => 0 != _descriptor & constants.privateAttribute;

[floitsch, 2015/08/13 17:33:36]

parenthesis and put 0 to the right.

[eernst, 2015/08/14 12:05:34]

Done.

Btw, that's a very old C-ish habit: `if (NULL = p)..` is a buggy version of `if
(p == NULL)..` just like `if (p = NULL)..`, but the latter is accepted by the
compiler, so the ordering "<constant> <relation> <variable>" is considered a
good habit. But we don't actually need that. ;)

 
   @override
   bool get isTopLevel => owner is LibraryMirror;
 
   @override
-  SourceLocation get location =>
-      throw new UnsupportedError("Location not supported");
+  bool get isFinal => 0 != _descriptor & constants.finalAttribute;

[floitsch, 2015/08/13 17:33:36]

ditto. (and probably other locations).

[eernst, 2015/08/14 12:05:34]

Done.

+
+  // It is allowed to return null.
+  @override
+  SourceLocation get location => null;
 
   @override
   List<Object> get metadata {
     if (_metadata == null) {
       throw new NoSuchCapabilityError(
           "Requesting metadata of field $simpleName without capability");
     }
     return _metadata;
   }
 
   @override
-  TypeMirror get type => _unsupported();
-
-  @override
-  bool get isStatic => 0 != descriptor & constants.staticAttribute;
-
-  @override
-  bool get isFinal => 0 != descriptor & constants.finalAttribute;
-
-  @override
-  bool get isConst => 0 != descriptor & constants.constAttribute;
-
-  @override
   bool operator ==(other) => _unsupported();
 
   @override
   int get hashCode => _unsupported();
 
   @override
-  String get simpleName => name;
+  String get simpleName => _name;
 }
 
-abstract class ParameterMirrorUnimpl extends VariableMirrorUnimpl
-    implements ParameterMirror {
+class VariableMirrorImpl extends VariableMirrorBase {
+  @override
+  ClassMirror get owner => _data.classMirrors[_ownerIndex];
+
+  @override
+  String get qualifiedName => "${owner.qualifiedName}.$_name";
+
+  @override
   TypeMirror get type => _unsupported();
-  bool get isOptional => _unsupported();
-  bool get isNamed => _unsupported();
-  bool get hasDefaultValue => _unsupported();
-  Object get defaultValue => _unsupported();
+
+  @override
+  bool get isStatic => 0 != _descriptor & constants.staticAttribute;
+
+  @override
+  bool get isConst => 0 != _descriptor & constants.constAttribute;
+
+  VariableMirrorImpl(String name, int descriptor, int ownerIndex,
+      ReflectableImpl reflectable, List<Object> metadata)
+      : super(name, descriptor, ownerIndex, reflectable, metadata);
 }
 
-abstract class SourceLocationUnimpl {
-  int get line => _unsupported();
-  int get column => _unsupported();
-  Uri get sourceUri => _unsupported();
+class ParameterMirrorImpl extends VariableMirrorBase
+    implements ParameterMirror {
+  final _classMirrorIndex;
+
+  @override
+  final defaultValue;
+
+  @override
+  bool get isStatic => 0 != _descriptor & constants.staticAttribute;
+
+  @override
+  bool get isConst => 0 != _descriptor & constants.constAttribute;
+
+  @override
+  bool get hasDefaultValue =>
+      0 != _descriptor & constants.hasDefaultValueAttribute;
+
+  @override
+  bool get isOptional => 0 != _descriptor & constants.optionalAttribute;
+
+  @override
+  bool get isNamed => 0 != _descriptor & constants.namedAttribute;
+
+  bool get _isDynamic => 0 != _descriptor & constants.dynamicAttribute;
+
+  bool get _isClassType => 0 != _descriptor & constants.classTypeAttribute;
+
+  // TODO(eernst) clarify: A parameter cannot be accessed using dot
+  // notation, and hence it has no qualified name. So is the following
+  // behavior correct?
+  @override
+  String get qualifiedName {
+    throw new NoSuchCapabilityError(
+        "Attempting to get the `qualifiedName` of the parameter $_name.");
+  }
+
+  @override
+  MethodMirror get owner => _data.memberMirrors[_ownerIndex];
+
+  @override
+  TypeMirror get type {
+    if (_isDynamic) return new DynamicMirrorImpl();
+    if (_isClassType) {
+      if (_classMirrorIndex == -1) {
+        throw new NoSuchCapabilityError(
+            "Attempting to get a class mirror for an un-marked class (type of $_name)");

[floitsch, 2015/08/13 17:33:36]

long line.

[eernst, 2015/08/14 12:05:34]

Funny, 'Reformat with Dart style' does not output many long lines (we used to
have to search for long lines after every 'Reformat..'), but this one persists.
Done.

+      }
+      return _data.classMirrors[_classMirrorIndex];
+    }
+    return _unsupported();
+  }
+
+  ParameterMirrorImpl(String name, int descriptor, int ownerIndex,
+      ReflectableImpl reflectable, List<Object> metadata, this.defaultValue,
+      this._classMirrorIndex)
+      : super(name, descriptor, ownerIndex, reflectable, metadata);
+}
+
+class DynamicMirrorImpl implements TypeMirror {
+
+  @override
+  bool get isPrivate => false;
+
+  @override
+  bool get isTopLevel => true;
+
+  // TODO(eernst) implement: test what 'dart:mirrors' does, then do the same.
+  @override
+  bool get isOriginalDeclaration => true;
+
+  @override
+  bool get hasReflectedType => true;
+
+  @override
+  Type get reflectedType => dynamic;
+
+  @override
+  String get simpleName => "dynamic";
+
+  // TODO(eernst) implement: do as in 'dart:mirrors'.
+  @override
+  List<TypeVariableMirror> get typeVariables => <TypeVariableMirror>[];
+
+  @override
+  List<TypeMirror> get typeArguments => <TypeMirror>[];
+
+  // TODO(eernst) implement: do as in 'dart:mirrors'.
+  @override
+  TypeMirror get originalDeclaration => null;
+
+  // It is allowed to return null.
+  @override
+  SourceLocation get location => null;
+
+  @override
+  bool isSubtypeOf(TypeMirror other) => true;
+
+  @override
+  bool isAssignableTo(TypeMirror other) => true;
+
+  // TODO(eernst) implement: do as 'dart:mirrors' does.
+  @override
+  DeclarationMirror get owner => null;
+
+  @override
+  String get qualifiedName => simpleName;
+
+  @override
+  List<Object> get metadata => <Object>[];
 }
 
 abstract class ReflectableImpl extends ReflectableBase
     implements ReflectableInterface {
 
   /// Const constructor, to enable usage as metadata, allowing for varargs
   /// style invocation with up to ten arguments.
   const ReflectableImpl([ReflectCapability cap0 = null,
       ReflectCapability cap1 = null, ReflectCapability cap2 = null,
       ReflectCapability cap3 = null, ReflectCapability cap4 = null,
       ReflectCapability cap5 = null, ReflectCapability cap6 = null,
       ReflectCapability cap7 = null, ReflectCapability cap8 = null,
       ReflectCapability cap9 = null])
       : super(cap0, cap1, cap2, cap3, cap4, cap5, cap6, cap7, cap8, cap9);
 
   const ReflectableImpl.fromList(List<ReflectCapability> capabilities)
       : super.fromList(capabilities);
 
   @override
   InstanceMirror reflect(Object reflectee) {
-    return new InstanceMirrorImpl(reflectee, this);
+    return new _InstanceMirrorImpl(reflectee, this);
   }
 
   @override
   bool canReflect(Object reflectee) {
     return data[this].classMirrorForType(reflectee.runtimeType) != null;
   }
 
   @override
   ClassMirror reflectType(Type type) {
     ClassMirror result = data[this].classMirrorForType(type);
@@ skipping 13 matching lines @@
   LibraryMirror findLibrary(String library) => _unsupported();
 
   @override
   Map<Uri, LibraryMirror> get libraries => _unsupported();
 
   @override
   Iterable<ClassMirror> get annotatedClasses {
     return new UnmodifiableListView<ClassMirror>(data[this].classMirrors);
   }
 }