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

reflectable/lib/src/reflectable_mirror_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.
 
 // TODO(sigurdm) doc: Make NoSuchCapability messages streamlined (the same in
 // both `reflectable_mirror_based.dart` and
 // `reflectable_transformer_based.dart`, and explaining as well as possible
 // which capability is missing.)
 
 /// Implementation of the reflectable interface using dart mirrors.
@@ skipping 780 matching lines @@
 
 class ClassMirrorImpl extends _TypeMirrorImpl
     with _ObjectMirrorImplMixin
     implements rm.ClassMirror {
   dm.ClassMirror get _classMirror => _declarationMirror;
 
   ClassMirrorImpl(dm.ClassMirror classMirror, ReflectableImpl reflectable)
       : super(classMirror, reflectable) {}
 
   @override
+  bool get hasDynamicReflectedType => _classMirror.typeVariables.isEmpty;
+
+  @override
+  Type get dynamicReflectedType {
+    if (!hasDynamicReflectedType) {
+      /// We cannot hope to implement this based on 'dart:mirrors' for generic
+      /// classes, because there is no support for obtaining one instantiation
+      /// of a generic class based on a different one (we cannot obtain
+      /// `List<dynamic>` from `List<int>` or any such thing); and when
+      /// `isOriginalDeclaration` is true we do not have a `reflectedType` at
+      /// all.
+      throw new UnsupportedError(
+          "Attempt to get dynamicReflectedType on $_classMirror");
+    }
+    return reflectedType;
+  }
+
+  @override
   List<rm.TypeVariableMirror> get typeVariables {
     if (!reflectableSupportsDeclarations(_reflectable)) {
       throw new NoSuchCapabilityError(
           "Attempt to get typeVariables without `declarationsCapability`");
     }
     return _classMirror.typeVariables.map((v) {
       return new _TypeVariableMirrorImpl(v, _reflectable);
     }).toList();
   }
 
@@ skipping 238 matching lines @@
 
 class _FunctionTypeMirrorImpl extends ClassMirrorImpl
     implements rm.FunctionTypeMirror {
   dm.FunctionTypeMirror get _functionTypeMirror => _classMirror;
 
   _FunctionTypeMirrorImpl(
       dm.FunctionTypeMirror functionTypeMirror, ReflectableImpl reflectable)
       : super(functionTypeMirror, reflectable);
 
   @override
+  bool get hasDynamicReflectedType => false;
+
+  @override
+  Type get dynamicReflectedType => throw unimplementedError(
+      "Attempt to get dynamicReflectedType on a function type mirror");
+
+  @override
   rm.MethodMirror get callMethod {
     return new MethodMirrorImpl(_functionTypeMirror.callMethod, _reflectable);
   }
 
   @override
   List<rm.ParameterMirror> get parameters {
     return _functionTypeMirror.parameters
         .map((dm.ParameterMirror parameterMirror) {
       return new _ParameterMirrorImpl(parameterMirror, _reflectable);
     });
@@ skipping 84 matching lines @@
   @override
   Type get reflectedReturnType {
     if (impliesReflectedType(_reflectable.capabilities)) {
       return _methodMirror.returnType.reflectedType;
     }
     throw new NoSuchCapabilityError(
         "Attempt to get reflectedReturnType without capability");
   }
 
   @override
+  bool get hasDynamicReflectedReturnType {
+    if (impliesReflectedType(_reflectable.capabilities)) {
+      return _methodMirror.returnType.typeVariables.isEmpty &&
+          _methodMirror.returnType.hasReflectedType;
+    }
+    throw new NoSuchCapabilityError("Attempt to get "
+        "hasDynamicReflectedReturnType without `reflectedTypeCapability`");
+  }
+
+  @override
+  Type get dynamicReflectedReturnType {
+    if (impliesReflectedType(_reflectable.capabilities)) {
+      if (_methodMirror.returnType.typeVariables.isEmpty) {
+        return _methodMirror.returnType.reflectedType;
+      } else {
+        // The value returned by `hasDynamicReflectedReturnType` is false, so
+        // even though this is unimplemented and may be implemented if we get
+        // the required runtime support, it is currently an `UnsupportedError`.
+        throw new UnsupportedError("Attempt to obtain the "
+            "dynamicReflectedReturnType of a generic type "
+            "${_methodMirror.returnType}");
+      }
+    }
+    throw new NoSuchCapabilityError("Attempt to get dynamicReflectedReturnType "
+        "without `reflectedTypeCapability`");
+  }
+
+  @override
   String get source => _methodMirror.source;
 
   @override
   List<rm.ParameterMirror> get parameters {
     return _methodMirror.parameters.map((p) {
       return new _ParameterMirrorImpl(p, _reflectable);
     }).toList();
   }
 
   @override
@@ skipping 101 matching lines @@
   @override
   Type get reflectedType {
     if (impliesReflectedType(_reflectable.capabilities)) {
       return _variableMirror.type.reflectedType;
     }
     throw new NoSuchCapabilityError(
         "Attempt to get reflectedType without `reflectedTypeCapability`");
   }
 
   @override
+  bool get hasDynamicReflectedType {
+    if (impliesReflectedType(_reflectable.capabilities)) {
+      return _variableMirror.type.typeVariables.isEmpty &&
+          _variableMirror.type.hasReflectedType;
+    }
+    throw new NoSuchCapabilityError("Attempt to get hasDynamicReflectedType "
+        "without `reflectedTypeCapability`");
+  }
+
+  @override
+  Type get dynamicReflectedType {
+    if (impliesReflectedType(_reflectable.capabilities)) {
+      if (_variableMirror.type.typeVariables.isEmpty) {
+        return _variableMirror.type.reflectedType;
+      } else {
+        // The value returned by `hasDynamicReflectedReturnType` is false, so
+        // even though this is unimplemented and may be implemented if we get
+        // the required runtime support, it is currently an `UnsupportedError`.
+        throw new UnsupportedError("Attempt to obtain the dynamicReflectedType "
+            "of a generic type ${_variableMirror.type}");
+      }
+    }
+    throw new NoSuchCapabilityError("Attempt to get dynamicReflectedType "
+        "without `reflectedTypeCapability`");
+  }
+
+  @override
   bool get isStatic => _variableMirror.isStatic;
 
   @override
   bool get isFinal => _variableMirror.isFinal;
 
   @override
   bool get isConst => _variableMirror.isConst;
 
   @override
   bool operator ==(other) => other is VariableMirrorImpl
@@ skipping 684 matching lines @@
     }
   }
 }
 
 bool _isSetterName(String name) => name.endsWith("=");
 
 String _setterNameToGetterName(String name) {
   assert(_isSetterName(name));
   return name.substring(0, name.length - 1);
 }