Implements support for reflection on parameters.

reflectable/lib/src/reflectable_implementation.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.
 
 /// Implementation of the reflectable interface using dart mirrors.
 library reflectable.src.reflectable_implementation;
 
 import 'dart:mirrors' as dm;
 import 'reflectable_base.dart';
 import '../capability.dart';
 import '../mirrors.dart' as rm;
 import '../reflectable.dart';
 
 bool get isTransformed => false;
 
 /// The name of the reflectable library.
 const Symbol reflectableLibrarySymbol = #reflectable.reflectable;
 
 rm.ClassMirror wrapClassMirror(
     dm.ClassMirror classMirror, ReflectableImpl reflectable) {
   if (classMirror is dm.FunctionTypeMirror) {
     return new _FunctionTypeMirrorImpl(classMirror, reflectable);
   } else {
     assert(classMirror is dm.ClassMirror);
-    return new _ClassMirrorImpl(classMirror, reflectable);
+    return new ClassMirrorImpl(classMirror, reflectable);
   }
 }
 
 rm.DeclarationMirror wrapDeclarationMirror(
     dm.DeclarationMirror declarationMirror, ReflectableImpl reflectable) {
   if (declarationMirror is dm.MethodMirror) {
-    return new _MethodMirrorImpl(declarationMirror, reflectable);
+    return new MethodMirrorImpl(declarationMirror, reflectable);
   } else if (declarationMirror is dm.ParameterMirror) {
     return new _ParameterMirrorImpl(declarationMirror, reflectable);
   } else if (declarationMirror is dm.VariableMirror) {
-    return new _VariableMirrorImpl(declarationMirror, reflectable);
+    return new VariableMirrorImpl(declarationMirror, reflectable);
   } else if (declarationMirror is dm.TypeVariableMirror) {
     return new _TypeVariableMirrorImpl(declarationMirror, reflectable);
   } else if (declarationMirror is dm.TypedefMirror) {
     return new _TypedefMirrorImpl(declarationMirror, reflectable);
   } else if (declarationMirror is dm.ClassMirror) {
     // Covers FunctionTypeMirror and ClassMirror.
     return wrapClassMirror(declarationMirror, reflectable);
   } else {
     assert(declarationMirror is dm.LibraryMirror);
     return new _LibraryMirrorImpl(declarationMirror, reflectable);
@@ skipping 21 matching lines @@
     return wrapClassMirror(m, reflectable);
   }
 }
 
 rm.TypeMirror wrapTypeMirror(
     dm.TypeMirror typeMirror, ReflectableImpl reflectable) {
   if (typeMirror is dm.TypeVariableMirror) {
     return new _TypeVariableMirrorImpl(typeMirror, reflectable);
   } else if (typeMirror is dm.TypedefMirror) {
     return new _TypedefMirrorImpl(typeMirror, reflectable);
+  } else if (typeMirror.reflectedType == dynamic) {
+    return new _SpecialTypeMirrorImpl(typeMirror, reflectable);
   } else {
     assert(typeMirror is dm.ClassMirror);
     return wrapClassMirror(typeMirror, reflectable);
   }
 }
 
 rm.CombinatorMirror wrapCombinatorMirror(dm.CombinatorMirror combinatorMirror) {
   return new _CombinatorMirrorImpl(combinatorMirror);
 }
 
 dm.ClassMirror unwrapClassMirror(rm.ClassMirror m) {
-  if (m is _ClassMirrorImpl) {
+  if (m is ClassMirrorImpl) {
     // This also works for _FunctionTypeMirrorImpl
     return m._classMirror;
   } else {
     throw new ArgumentError("Unexpected subtype of ClassMirror");
   }
 }
 
 dm.TypeMirror unwrapTypeMirror(rm.TypeMirror TypeMirror) {
   if (TypeMirror is _TypeMirrorImpl) {
     return TypeMirror._typeMirror;
@@ skipping 68 matching lines @@
             declarationMirror.constructorName == nameSymbol;
       });
       if (constructorMirror == null ||
           !constructorMirror.isConstructor) return false;
       return metadataSupported(constructorMirror.metadata, metadataCapability);
     }
     return false;
   });
 }
 
+bool reflectableSupportsDeclarations(Reflectable reflectable) {
+  return reflectable.capabilities.any(
+      (ReflectCapability capability) => capability == declarationsCapability);
+}
+
 /// Returns [setterName] with final "=" removed.
 /// If the it does not have a final "=" it is returned as is.
 String _setterToGetter(String setterName) {
   if (!setterName.endsWith("=")) {
     return setterName;
   }
   return setterName.substring(0, setterName.length - 1);
 }
 
 /// Returns [getterName] with a final "=" added.
 /// If [getter] already ends with "=" an error is thrown.
 String _getterToSetter(String getterName) {
   if (getterName.endsWith("=")) {
     throw new ArgumentError(
         "$getterName is a setter name (ends with `=`) already.");
   }
   return '$getterName=';
 }
 
+bool _supportsType(List<ReflectCapability> capabilities) {
+  return capabilities.any((ReflectCapability capability) =>
+      capability is TypeCapability || capabilities is TypingCapability);
+}
+
 abstract class _ObjectMirrorImplMixin implements rm.ObjectMirror {
   ReflectableImpl get _reflectable;
 }
 
 class _LibraryMirrorImpl extends _DeclarationMirrorImpl
-    with _ObjectMirrorImplMixin implements rm.LibraryMirror {
+    with _ObjectMirrorImplMixin
+    implements rm.LibraryMirror {
   dm.LibraryMirror get _libraryMirror => _declarationMirror;
 
   _LibraryMirrorImpl(dm.LibraryMirror m, ReflectableImpl reflectable)
       : super(m, reflectable) {}
 
   @override
   Uri get uri => _libraryMirror.uri;
 
   @override
   Map<String, rm.DeclarationMirror> get declarations {
+    if (!reflectableSupportsDeclarations(_reflectable)) {
+      throw new NoSuchCapabilityError(
+          "Attempt to get declarations without capability");
+    }
     Map<Symbol, dm.DeclarationMirror> decls = _libraryMirror.declarations;
     Iterable<Symbol> relevantKeys = decls.keys.where((k) {
       List<dm.InstanceMirror> metadata = decls[k].metadata;
       for (var item in metadata) {
         if (item.hasReflectee && item.reflectee is ReflectableImpl) return true;
       }
       return false;
     });
     return new Map<String, rm.DeclarationMirror>.fromIterable(relevantKeys,
         key: (k) => dm.MirrorSystem.getName(k),
         value: (v) => wrapDeclarationMirror(decls[v], _reflectable));
   }
 
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     if (!reflectableSupportsStaticInvoke(_reflectable, memberName,
         _libraryMirror.declarations[new Symbol(memberName)].metadata)) {
       throw new NoSuchInvokeCapabilityError(
           _receiver, memberName, positionalArguments, namedArguments);
     }
 
-    return _libraryMirror.invoke(
-        new Symbol(memberName), positionalArguments, namedArguments).reflectee;
+    return _libraryMirror
+        .invoke(new Symbol(memberName), positionalArguments, namedArguments)
+        .reflectee;
   }
 
   @override
   Object invokeGetter(String getterName) {
     if (!reflectableSupportsStaticInvoke(_reflectable, getterName,
         _libraryMirror.declarations[new Symbol(getterName)].metadata)) {
       throw new NoSuchInvokeCapabilityError(_receiver, getterName, [], null);
     }
     Symbol getterNameSymbol = new Symbol(getterName);
     return _libraryMirror.getField(getterNameSymbol).reflectee;
@@ skipping 104 matching lines @@
 
   @override
   get reflectee => _instanceMirror.reflectee;
 
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     if (reflectableSupportsInstanceInvoke(
         _reflectable, memberName, _instanceMirror.type)) {
       Symbol memberNameSymbol = new Symbol(memberName);
-      return _instanceMirror.invoke(
-          memberNameSymbol, positionalArguments, namedArguments).reflectee;
+      return _instanceMirror
+          .invoke(memberNameSymbol, positionalArguments, namedArguments)
+          .reflectee;
     }
     throw new NoSuchInvokeCapabilityError(
         _receiver, memberName, positionalArguments, namedArguments);
   }
 
   @override
   Object invokeGetter(String fieldName) {
     if (reflectableSupportsInstanceInvoke(
         _reflectable, fieldName, _instanceMirror.type)) {
       Symbol fieldNameSymbol = new Symbol(fieldName);
@@ skipping 23 matching lines @@
 
   @override
   delegate(Invocation invocation) => _instanceMirror.delegate(invocation);
 
   get _receiver => _instanceMirror.reflectee;
 
   @override
   String toString() => "_InstanceMirrorImpl('${_instanceMirror}')";
 }
 
-class _ClassMirrorImpl extends _TypeMirrorImpl with _ObjectMirrorImplMixin
+class ClassMirrorImpl extends _TypeMirrorImpl
+    with _ObjectMirrorImplMixin
     implements rm.ClassMirror {
   dm.ClassMirror get _classMirror => _declarationMirror;
 
-  _ClassMirrorImpl(dm.ClassMirror cm, ReflectableImpl reflectable)
+  ClassMirrorImpl(dm.ClassMirror cm, ReflectableImpl reflectable)
       : super(cm, reflectable) {}
 
   @override
   List<rm.TypeVariableMirror> get typeVariables {
     return _classMirror.typeVariables.map((v) {
       return new _TypeVariableMirrorImpl(v, _reflectable);
     }).toList();
   }
 
   @override
   List<rm.TypeMirror> get typeArguments => _classMirror.typeArguments.map((a) {
-    return wrapTypeMirror(a, _reflectable);
-  }).toList();
+        return wrapTypeMirror(a, _reflectable);
+      }).toList();
 
   @override
   rm.TypeMirror get superclass {
     dm.ClassMirror sup = _classMirror.superclass;
-    if (sup == null) return null;  // For `Object`, do as `dm`.
+    if (sup == null) return null; // For `Object`, do as `dm`.
     return wrapClassMirror(sup, _reflectable);
   }
 
   @override
   List<rm.TypeMirror> get superinterfaces {
     List<dm.TypeMirror> superinterfaces = _classMirror.superinterfaces;
     return superinterfaces.map((dm.TypeMirror superInterface) {
       return wrapTypeMirror(superInterface, _reflectable);
     }).toList();
   }
 
   @override
   bool get isAbstract => _classMirror.isAbstract;
 
   @override
   Map<String, rm.DeclarationMirror> get declarations {
+    if (!reflectableSupportsDeclarations(_reflectable)) {
+      throw new NoSuchCapabilityError(
+          "Attempt to get declarations without capability");
+    }
     // TODO(sigurdm) future: Possibly cache this.
     Map<String, rm.DeclarationMirror> result =
         new Map<String, rm.DeclarationMirror>();
     _classMirror.declarations
         .forEach((Symbol nameSymbol, dm.DeclarationMirror declarationMirror) {
       String name = dm.MirrorSystem.getName(nameSymbol);
       if (declarationMirror is dm.MethodMirror) {
         bool included = false;
         if (declarationMirror.isConstructor) {
           // Factory constructors are static, others not, so this decision
@@ skipping 51 matching lines @@
     return result;
   }
 
   @override
   Map<String, rm.MethodMirror> get instanceMembers {
     // TODO(sigurdm) implement: Only expose members that are allowed
     // by the capabilities of the reflectable.
     Map<Symbol, dm.MethodMirror> members = _classMirror.instanceMembers;
     return new Map<String, rm.MethodMirror>.fromIterable(members.keys,
         key: (k) => dm.MirrorSystem.getName(k),
-        value: (v) => new _MethodMirrorImpl(members[v], _reflectable));
+        value: (v) => new MethodMirrorImpl(members[v], _reflectable));
   }
 
   @override
   Map<String, rm.MethodMirror> get staticMembers {
     // TODO(sigurdm) implement: Only expose members that are allowed by the
     // capabilities of the reflectable.
     Map<Symbol, dm.MethodMirror> members = _classMirror.staticMembers;
     return new Map<String, rm.MethodMirror>.fromIterable(members.keys,
         key: (k) => dm.MirrorSystem.getName(k),
-        value: (v) => new _MethodMirrorImpl(members[v], _reflectable));
+        value: (v) => new MethodMirrorImpl(members[v], _reflectable));
   }
 
   @override
   rm.TypeMirror get mixin => wrapTypeMirror(_classMirror.mixin, _reflectable);
 
   @override
   Object newInstance(String constructorName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     if (!reflectableSupportsConstructorInvoke(
         _reflectable, _classMirror, constructorName)) {
       throw new NoSuchInvokeCapabilityError(
           _classMirror, constructorName, positionalArguments, namedArguments);
     }
     Symbol constructorNameSymbol = new Symbol(constructorName);
-    return _classMirror.newInstance(
-        constructorNameSymbol, positionalArguments, namedArguments).reflectee;
+    return _classMirror
+        .newInstance(constructorNameSymbol, positionalArguments, namedArguments)
+        .reflectee;
   }
 
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     dm.DeclarationMirror declaration =
         _classMirror.declarations[new Symbol(memberName)];
     List<Object> metadata = declaration == null ? null : declaration.metadata;
     if (reflectableSupportsStaticInvoke(_reflectable, memberName, metadata)) {
       Symbol memberNameSymbol = new Symbol(memberName);
-      return _classMirror.invoke(
-          memberNameSymbol, positionalArguments, namedArguments).reflectee;
+      return _classMirror
+          .invoke(memberNameSymbol, positionalArguments, namedArguments)
+          .reflectee;
     }
     throw new NoSuchInvokeCapabilityError(
         _receiver, memberName, positionalArguments, namedArguments);
   }
 
   @override
   Object invokeGetter(String getterName) {
     if (reflectableSupportsStaticInvoke(_reflectable, getterName,
         _classMirror.declarations[new Symbol(getterName)].metadata)) {
       Symbol getterNameSymbol = new Symbol(getterName);
       return _classMirror.getField(getterNameSymbol).reflectee;
     }
     throw new NoSuchInvokeCapabilityError(_receiver, getterName, [], null);
   }
 
   @override
   Object invokeSetter(String setterName, Object value) {
     if (reflectableSupportsStaticInvoke(_reflectable, setterName,
         _classMirror.declarations[new Symbol(setterName)].metadata)) {
       String getterName = _setterToGetter(setterName);
       Symbol getterNameSymbol = new Symbol(getterName);
       return _classMirror.setField(getterNameSymbol, value).reflectee;
     }
     throw new NoSuchInvokeCapabilityError(_receiver, setterName, [value], null);
   }
 
   @override
   bool operator ==(other) {
-    return other is _ClassMirrorImpl
+    return other is ClassMirrorImpl
         ? _classMirror == other._classMirror
         : false;
   }
 
   @override
   int get hashCode => _classMirror.hashCode;
 
   @override
   bool isSubclassOf(rm.ClassMirror other) {
     return _classMirror.isSubclassOf(unwrapClassMirror(other));
   }
 
   get _receiver => _classMirror.reflectedType;
 
   @override
-  String toString() => "_ClassMirrorImpl('${_classMirror}')";
+  String toString() => "ClassMirrorImpl('${_classMirror}')";
 
   @override
   Function invoker(String memberName) {
     Symbol memberNameSymbol = new Symbol(memberName);
     Function helper(Object o) {
       dm.InstanceMirror receiverMirror = dm.reflect(o);
       dm.InstanceMirror memberMirror =
           receiverMirror.getField(memberNameSymbol);
       return memberMirror.reflectee;
     }
     return helper;
   }
 }
 
-class _FunctionTypeMirrorImpl extends _ClassMirrorImpl
+class _FunctionTypeMirrorImpl extends ClassMirrorImpl
     implements rm.FunctionTypeMirror {
   dm.FunctionTypeMirror get _functionTypeMirror => _classMirror;
 
   _FunctionTypeMirrorImpl(
       dm.FunctionTypeMirror functionTypeMirror, ReflectableImpl reflectable)
       : super(functionTypeMirror, reflectable);
 
   @override
   rm.MethodMirror get callMethod {
-    return new _MethodMirrorImpl(_functionTypeMirror.callMethod, _reflectable);
+    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 40 matching lines @@
   rm.SourceLocation get location {
     return new _SourceLocationImpl(_declarationMirror.location);
   }
 
   @override
   String toString() {
     return "_DeclarationMirrorImpl('${_declarationMirror}')";
   }
 }
 
-class _MethodMirrorImpl extends _DeclarationMirrorImpl
+class MethodMirrorImpl extends _DeclarationMirrorImpl
     implements rm.MethodMirror {
   dm.MethodMirror get _methodMirror => _declarationMirror;
 
-  _MethodMirrorImpl(dm.MethodMirror mm, ReflectableImpl reflectable)
+  MethodMirrorImpl(dm.MethodMirror mm, ReflectableImpl reflectable)
       : super(mm, reflectable);
 
   @override
   rm.TypeMirror get returnType =>
       wrapTypeMirror(_methodMirror.returnType, _reflectable);
 
   @override
   String get source => _methodMirror.source;
 
   @override
@@ skipping 38 matching lines @@
   bool get isGenerativeConstructor => _methodMirror.isGenerativeConstructor;
 
   @override
   bool get isRedirectingConstructor => _methodMirror.isRedirectingConstructor;
 
   @override
   bool get isFactoryConstructor => _methodMirror.isFactoryConstructor;
 
   @override
   bool operator ==(other) {
-    return other is _MethodMirrorImpl
+    return other is MethodMirrorImpl
         ? _methodMirror == other._methodMirror
         : false;
   }
 
   @override
   int get hashCode => _methodMirror.hashCode;
 
   @override
   String toString() => "_MethodMirrorImpl('${_methodMirror}')";
 }
 
 class _ClosureMirrorImpl extends _InstanceMirrorImpl
     implements rm.ClosureMirror {
   dm.ClosureMirror get _closureMirror => _instanceMirror;
 
   _ClosureMirrorImpl(
       dm.ClosureMirror closureMirror, ReflectableImpl reflectable)
       : super(closureMirror, reflectable);
 
   @override
   Object apply(List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     return _closureMirror.apply(positionalArguments, namedArguments).reflectee;
   }
 
   @override
   rm.MethodMirror get function {
-    return new _MethodMirrorImpl(_closureMirror.function, _reflectable);
+    return new MethodMirrorImpl(_closureMirror.function, _reflectable);
   }
 
   @override
   String toString() => "_ClosureMirrorImpl('${_closureMirror}')";
 }
 
-class _VariableMirrorImpl extends _DeclarationMirrorImpl
+class VariableMirrorImpl extends _DeclarationMirrorImpl
     implements rm.VariableMirror {
   dm.VariableMirror get _variableMirror => _declarationMirror;
 
-  _VariableMirrorImpl(dm.VariableMirror vm, ReflectableImpl reflectable)
+  VariableMirrorImpl(dm.VariableMirror vm, ReflectableImpl reflectable)
       : super(vm, reflectable);
 
   @override
-  rm.TypeMirror get type => wrapTypeMirror(_variableMirror.type, _reflectable);
+  rm.TypeMirror get type {
+    if (_supportsType(_reflectable.capabilities)) {
+      return wrapTypeMirror(_variableMirror.type, _reflectable);
+    }
+    throw new NoSuchCapabilityError("Attempt to get a type without capability");
+  }
 
   @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
+  bool operator ==(other) => other is VariableMirrorImpl
       ? _variableMirror == other._variableMirror
       : false;
 
   @override
   int get hashCode => _variableMirror.hashCode;
 
   @override
-  String toString() => "_VariableMirrorImpl('${_variableMirror}')";
+  String toString() => "VariableMirrorImpl('${_variableMirror}')";
 }
 
-class _ParameterMirrorImpl extends _VariableMirrorImpl
+class _ParameterMirrorImpl extends VariableMirrorImpl
     implements rm.ParameterMirror {
   dm.ParameterMirror get _parameterMirror => _declarationMirror;
 
   _ParameterMirrorImpl(dm.ParameterMirror pm, ReflectableImpl reflectable)
       : super(pm, reflectable);
 
   @override
   bool get isOptional => _parameterMirror.isOptional;
 
   @override
@@ skipping 114 matching lines @@
 
   @override
   int get hashCode => _typedefMirror.hashCode;
 
   @override
   String toString() {
     return "_TypedefMirrorImpl('${_typedefMirror}')";
   }
 }
 
+class _SpecialTypeMirrorImpl extends _TypeMirrorImpl {
+  _SpecialTypeMirrorImpl(dm.TypeMirror typeMirror, ReflectableImpl reflectable)
+      : super(typeMirror, reflectable);
+
+  @override operator ==(other) {
+    return other is _SpecialTypeMirrorImpl && other._typeMirror == _typeMirror;
+  }
+
+  @override
+  int get hashCode => _typeMirror.hashCode;
+
+  @override
+  String toString() {
+    return "_SpecialTypeMirrorImpl('${_typeMirror}')";
+  }
+}
+
 class _CombinatorMirrorImpl implements rm.CombinatorMirror {
   dm.CombinatorMirror _combinatorMirror;
 
   _CombinatorMirrorImpl(this._combinatorMirror);
 
   @override
   List<String> get identifiers =>
       _combinatorMirror.identifiers.map(dm.MirrorSystem.getName);
 
   @override
@@ skipping 50 matching lines @@
   // Fields holding capabilities; we use discrete fields rather than a list
   // of fields because this allows us to use a syntax similar to a varargs
   // invocation as the superinitializer (omitting `<ReflectCapability>[]` and
   // directly giving the elements of that list as constructor arguments).
   // This will only work up to a fixed number of arguments (we have chosen
   // to support at most 10 arguments), and with a larger number of arguments
   // the fromList constructor must be used.
 
   /// 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,
+  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);
 
   /// Returns a mirror of the given object [reflectee]
   @override
   rm.InstanceMirror reflect(Object o) {
     dm.InstanceMirror mirror = dm.reflect(o);
@@ skipping 104 matching lines @@
           }
         }
       }
       return result;
     });
   }
 
   static Map<ReflectableImpl, Set<dm.ClassMirror>> _supportedClassesCache =
       new Map<ReflectableImpl, Set<dm.ClassMirror>>();
 }