Added `dynamicReflected..Type`, corrected type expressions.

reflectable/lib/src/reflectable_transformer_based.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 534 matching lines @@
 
   @override
   TypeMirror get originalDeclaration => this;
 
   @override
   bool get hasReflectedType => true;
 
   @override
   Type get reflectedType => _data.types[_classIndex];
 
+  @override
+  bool get hasDynamicReflectedType => true;
+
+  @override
+  Type get dynamicReflectedType => reflectedType;
+
   String toString() => "NonGenericClassMirrorImpl($qualifiedName)";
 }
 
 typedef bool InstanceChecker(Object instance);
 
 class GenericClassMirrorImpl extends ClassMirrorImpl {
   /// Used to enable instance checks. Let O be an instance and let C denote the
   /// generic class modeled by this mirror. The check is then such that the
   /// result is true iff there exists a list of type arguments X1..Xk such that
   /// O is an instance of C<X1..Xk>. We can perform this check by checking that
   /// O is an instance of C<dynamic .. dynamic>, and O is not an instance
   /// of any of Dj<dynamic .. dynamic> for j in {1..n}, where D1..Dn is the
   /// complete set of classes in the current program which are direct
   /// subinterfaces of C (i.e., classes which directly `extends` or `implements`
   /// C). The check is implemented by this function.
   final InstanceChecker _isGenericRuntimeTypeOf;
 
   final List<int> _typeVariableIndices;
 
+  final Type _dynamicReflectedType;
+
   GenericClassMirrorImpl(
       String simpleName,
       String qualifiedName,
       int descriptor,
       int classIndex,
       ReflectableImpl reflector,
       List<int> declarationIndices,
       List<int> instanceMemberIndices,
       List<int> staticMemberIndices,
       int superclassIndex,
       Map<String, _StaticGetter> getters,
       Map<String, _StaticSetter> setters,
       Map<String, Function> constructors,
       int ownerIndex,
       int mixinIndex,
       List<int> superinterfaceIndices,
       List<Object> metadata,
       this._isGenericRuntimeTypeOf,
-      this._typeVariableIndices)
+      this._typeVariableIndices,
+      this._dynamicReflectedType)
       : super(
             simpleName,
             qualifiedName,
             descriptor,
             classIndex,
             reflector,
             declarationIndices,
             instanceMemberIndices,
             staticMemberIndices,
             superclassIndex,
@@ skipping 36 matching lines @@
 
   @override
   bool get hasReflectedType => false;
 
   @override
   Type get reflectedType {
     throw new UnsupportedError("Attempt to obtain `reflectedType` "
         "from generic class '$qualifiedName'.");
   }
 
+  @override
+  bool get hasDynamicReflectedType => true;
+
+  @override
+  Type get dynamicReflectedType => _dynamicReflectedType;
+
   String toString() => "GenericClassMirrorImpl($qualifiedName)";
 }
 
 class InstantiatedGenericClassMirrorImpl extends ClassMirrorImpl {
   final GenericClassMirrorImpl _originalDeclaration;
   final Type _reflectedType;
 
   InstantiatedGenericClassMirrorImpl(
       String simpleName,
       String qualifiedName,
@@ skipping 26 matching lines @@
             getters,
             setters,
             constructors,
             ownerIndex,
             mixinIndex,
             superinterfaceIndices,
             metadata);
 
   // TODO(sigurdm) implement: Implement typeArguments.
   @override
-  List<TypeMirror> get typeArguments => throw unimplementedError("typeArguments");
+  List<TypeMirror> get typeArguments =>
+      throw unimplementedError("typeArguments");
 
   @override
   List<TypeVariableMirror> get typeVariables =>
       originalDeclaration.typeVariables;
 
   @override
   bool get isOriginalDeclaration => false;
 
   @override
   TypeMirror get originalDeclaration => _originalDeclaration;
 
   @override
   bool get hasReflectedType => _reflectedType != null;
 
   @override
   Type get reflectedType {
     if (_reflectedType != null) return _reflectedType;
     throw new UnsupportedError("Cannot provide `reflectedType` of "
         "instance of generic type '$simpleName'.");
   }
 
+  @override
+  bool get hasDynamicReflectedType =>
+      _originalDeclaration.hasDynamicReflectedType;
+
+  @override
+  Type get dynamicReflectedType => _originalDeclaration.dynamicReflectedType;
+
   String toString() => "InstantiatedGenericClassMirrorImpl($qualifiedName)";
 }
 
 InstantiatedGenericClassMirrorImpl _createInstantiatedGenericClass(
     GenericClassMirrorImpl genericClassMirror, Type reflectedType) {
   // TODO(eernst) implement: Pass a representation of type arguments to this
   // method, and create an instantiated generic class which includes that
   // information.
   return new InstantiatedGenericClassMirrorImpl(
       genericClassMirror.simpleName,
@@ skipping 256 matching lines @@
   /// The index of the [ClassMirror] of the owner of this method, respectively
   /// the [LibraryMirror] of the owner of this top-level function,
   final int _ownerIndex;
 
   /// The index of the mirror for the return type of this method.
   final int _returnTypeIndex;
 
   /// The return type of this method.
   final Type _reflectedReturnType;
 
+  /// The return type of this method, erased to have `dynamic` for all
+  /// type arguments; a null value indicates that it is identical to
+  /// `reflectedReturnType` if that value is available they are equal; if
+  /// `reflectedReturnType` is unavailable then so is
+  /// `dynamicReflectedReturnType`.
+  final Type _dynamicReflectedReturnType;
+
   /// 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._returnTypeIndex,
       this._reflectedReturnType,
+      this._dynamicReflectedReturnType,
       this._parameterIndices,
       this._reflector,
       this._metadata);
 
   int get kind => constants.kindFromEncoding(_descriptor);
 
   DeclarationMirror get owner {
     if (_ownerIndex == NO_CAPABILITY_INDEX) {
       throw new NoSuchCapabilityError(
           "Trying to get owner of method '$qualifiedName' "
@@ skipping 110 matching lines @@
   Type get reflectedReturnType {
     if (_reflectedReturnType == null) {
       throw new NoSuchCapabilityError(
           "Requesting reflectedReturnType of method "
           "'$simpleName' without capability");
     }
     return _reflectedReturnType;
   }
 
   @override
+  bool get hasDynamicReflectedReturnType =>
+      _dynamicReflectedReturnType != null || hasReflectedReturnType;
+
+  @override
+  Type get dynamicReflectedReturnType {
+    return _dynamicReflectedReturnType != null
+        ? _dynamicReflectedReturnType
+        : reflectedReturnType;
+  }
+
+  @override
   String get simpleName => isConstructor
       ? (_name == '' ? "${owner.simpleName}" : "${owner.simpleName}.$_name")
       : _name;
 
   @override
   String get source => null;
 
   @override
   String toString() => "MethodMirrorImpl($qualifiedName)";
 }
 
 abstract class ImplicitAccessorMirrorImpl extends _DataCaching
     implements MethodMirror {
   final ReflectableImpl _reflector;
   final int _variableMirrorIndex;
   final Type _reflectedType;
+  final Type _dynamicReflectedType;
 
   /// Index of this [ImplicitAccessorMirrorImpl] in `_data.memberMirrors`.
   final int _selfIndex;
 
   VariableMirrorImpl get _variableMirror =>
       _data.memberMirrors[_variableMirrorIndex];
 
   ImplicitAccessorMirrorImpl(this._reflector, this._variableMirrorIndex,
-      this._reflectedType, this._selfIndex);
+      this._reflectedType, this._dynamicReflectedType, this._selfIndex);
 
   int get kind => constants.kindFromEncoding(_variableMirror._descriptor);
 
   DeclarationMirror get owner => _variableMirror.owner;
 
   @override
   String get constructorName => "";
 
   @override
   bool get isAbstract => false;
@@ skipping 41 matching lines @@
   @override
   TypeMirror get returnType => _variableMirror.type;
 
   @override
   bool get hasReflectedReturnType => _variableMirror.hasReflectedType;
 
   @override
   Type get reflectedReturnType => _variableMirror.reflectedType;
 
   @override
+  bool get hasDynamicReflectedReturnType =>
+      _variableMirror.hasDynamicReflectedType;
+
+  @override
+  Type get dynamicReflectedReturnType => _variableMirror.dynamicReflectedType;
+
+  @override
   String get source => null;
 }
 
 class ImplicitGetterMirrorImpl extends ImplicitAccessorMirrorImpl {
   ImplicitGetterMirrorImpl(ReflectableImpl reflector, int variableMirrorIndex,
-      Type reflectedType, int selfIndex)
-      : super(reflector, variableMirrorIndex, reflectedType, selfIndex);
+      Type reflectedType, Type dynamicReflectedType, int selfIndex)
+      : super(reflector, variableMirrorIndex, reflectedType,
+            dynamicReflectedType, selfIndex);
 
   @override
   bool get isGetter => true;
 
   @override
   bool get isSetter => false;
 
   @override
   List<ParameterMirror> get parameters => <ParameterMirror>[];
 
   @override
   String get qualifiedName => _variableMirror.qualifiedName;
 
   @override
   String get simpleName => _variableMirror.simpleName;
 
   @override
   String toString() => "ImplicitGetterMirrorImpl($qualifiedName)";
 }
 
 class ImplicitSetterMirrorImpl extends ImplicitAccessorMirrorImpl {
   ImplicitSetterMirrorImpl(ReflectableImpl reflector, int variableMirrorIndex,
-      Type reflectedType, int selfIndex)
-      : super(reflector, variableMirrorIndex, reflectedType, selfIndex);
+      Type reflectedType, Type dynamicReflectedType, int selfIndex)
+      : super(reflector, variableMirrorIndex, reflectedType,
+            dynamicReflectedType, selfIndex);
 
   @override
   bool get isGetter => false;
 
   @override
   bool get isSetter => true;
 
   int get _parameterDescriptor {
     int descriptor = constants.parameter;
     if (_variableMirror.isStatic) descriptor |= constants.staticAttribute;
     if (_variableMirror.isPrivate) descriptor |= constants.privateAttribute;
     descriptor |= constants.syntheticAttribute;
     if (_variableMirror._isDynamic) descriptor |= constants.dynamicAttribute;
     if (_variableMirror._isClassType) descriptor |=
         constants.classTypeAttribute;
     return descriptor;
   }
 
   @override
   List<ParameterMirror> get parameters {
     return <ParameterMirror>[
       new ParameterMirrorImpl(
           _variableMirror.simpleName,
           _parameterDescriptor,
           _selfIndex,
           _variableMirror._reflector,
           _variableMirror._classMirrorIndex,
           _variableMirror._reflectedType,
+          _variableMirror._dynamicReflectedType,
           <Object>[],
           null)
     ];
   }
 
   @override
   String get qualifiedName => "${_variableMirror.qualifiedName}=";
 
   @override
   String get simpleName => "${_variableMirror.simpleName}=";
 
   @override
   String toString() => "ImplicitSetterMirrorImpl($qualifiedName)";
 }
 
 abstract class VariableMirrorBase extends _DataCaching
     implements VariableMirror {
   final String _name;
   final int _descriptor;
   final int _ownerIndex;
   final ReflectableImpl _reflector;
   final int _classMirrorIndex;
   final Type _reflectedType;
+  final Type _dynamicReflectedType;
   final List<Object> _metadata;
 
   VariableMirrorBase(
       this._name,
       this._descriptor,
       this._ownerIndex,
       this._reflector,
       this._classMirrorIndex,
       this._reflectedType,
+      this._dynamicReflectedType,
       this._metadata);
 
   int get kind => constants.kindFromEncoding(_descriptor);
 
   @override
   bool get isPrivate => (_descriptor & constants.privateAttribute != 0);
 
   @override
   bool get isTopLevel => (_descriptor & constants.topLevelAttribute != 0);
 
@@ skipping 47 matching lines @@
 
   @override
   Type get reflectedType {
     if (_reflectedType == null) {
       throw new NoSuchCapabilityError(
           "Attempt to get reflectedType without capability (of '$_name')");
     }
     return _reflectedType;
   }
 
+  @override
+  bool get hasDynamicReflectedType =>
+      _dynamicReflectedType != null || hasReflectedType;
+
+  @override
+  Type get dynamicReflectedType =>
+      _dynamicReflectedType != null ? _dynamicReflectedType : reflectedType;
+
   // Note that [operator ==] is redefined slightly differently in the two
   // subtypes of this class, but they share this [hashCode] implementation.
   @override
   int get hashCode => simpleName.hashCode ^ owner.hashCode;
 }
 
 class VariableMirrorImpl extends VariableMirrorBase {
   @override
   DeclarationMirror get owner {
     if (_ownerIndex == NO_CAPABILITY_INDEX) {
@@ skipping 12 matching lines @@
   @override
   bool get isConst => (_descriptor & constants.constAttribute != 0);
 
   VariableMirrorImpl(
       String name,
       int descriptor,
       int ownerIndex,
       ReflectableImpl reflectable,
       int classMirrorIndex,
       Type reflectedType,
+      Type dynamicReflectedType,
       List<Object> metadata)
       : super(name, descriptor, ownerIndex, reflectable, classMirrorIndex,
-            reflectedType, metadata);
+            reflectedType, dynamicReflectedType, metadata);
 
   // Note that the corresponding implementation of [hashCode] is inherited from
   // [VariableMirrorBase].
   @override
   bool operator ==(other) => other is VariableMirrorImpl &&
       other.simpleName == simpleName &&
       other.owner == owner;
 }
 
 class ParameterMirrorImpl extends VariableMirrorBase
@@ skipping 20 matching lines @@
   @override
   MethodMirror get owner => _data.memberMirrors[_ownerIndex];
 
   ParameterMirrorImpl(
       String name,
       int descriptor,
       int ownerIndex,
       ReflectableImpl reflectable,
       int classMirrorIndex,
       Type reflectedType,
+      Type dynamicReflectedType,
       List<Object> metadata,
       this.defaultValue)
       : super(name, descriptor, ownerIndex, reflectable, classMirrorIndex,
-            reflectedType, metadata);
+            reflectedType, dynamicReflectedType, metadata);
 
   // Note that the corresponding implementation of [hashCode] is inherited from
   // [VariableMirrorBase].
   @override
   bool operator ==(other) => other is ParameterMirrorImpl &&
       other.simpleName == simpleName &&
       other.owner == owner;
 }
 
 class DynamicMirrorImpl implements TypeMirror {
@@ skipping 57 matching lines @@
 
   // TODO(eernst) implement: test what 'dart:mirrors' does, then do the same.
   @override
   bool get isOriginalDeclaration => true;
 
   @override
   bool get hasReflectedType => false;
 
   @override
   Type get reflectedType =>
-      throw new UnsupportedError("Attempt to get the reflected type of 'void'");
+      throw new UnsupportedError("Attempt to get the reflected type of `void`");
 
   @override
   String get simpleName => "void";
 
   // TODO(eernst) implement: do as in 'dart:mirrors'.
   @override
   List<TypeVariableMirror> get typeVariables => <TypeVariableMirror>[];
 
   @override
   List<TypeMirror> get typeArguments => <TypeMirror>[];
@@ skipping 112 matching lines @@
   const FakeType(this.description);
 
   final String description;
 
   String toString() => "Type($description)";
 }
 
 bool _isSetterName(String name) => name.endsWith("=");
 
 String _getterNameToSetterName(String name) => name + "=";