Add TypeMirror.isSubtypeOf, TypeMirror.isAssignableTo, ClassMirror.isSubclassOf

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.
 
 import "dart:collection";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new _UnmodifiableMapView({});
@@ skipping 90 matching lines @@
     buf.write(']');
   }
   buf.write(') -> ');
   buf.write(_n(returnType.qualifiedName));
   return buf.toString();
 }
 
 List _metadata(reflectee)
     native 'DeclarationMirror_metadata';
 
+bool _subtypeTest(Type a, Type b)
+    native 'TypeMirror_subtypeTest';
+
+bool _moreSpecificTest(Type a, Type b)
+    native 'TypeMirror_moreSpecificTest';
+
 class _LocalMirrorSystem extends MirrorSystem {
   final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
   _LocalMirrorSystem(List<LibraryMirror> libraries, this.isolate)
       : this.libraries = new Map<Uri, LibraryMirror>.fromIterable(
             libraries, key: (e) => e.uri);
 
   TypeMirror _dynamicType = null;
   TypeMirror get dynamicType {
@@ skipping 632 matching lines @@
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee &&
            this._reflectedType == other._reflectedType &&
            this._isGenericDeclaration == other._isGenericDeclaration;
   }
 
   int get hashCode => simpleName.hashCode;
 
+  bool isSubtypeOf(TypeMirror other) {
+    if (other == currentMirrorSystem().dynamicType) return true;
+    if (other == currentMirrorSystem().voidType) return false;
+    return _subtypeTest(_reflectedType, other._reflectedType);
+  }
+
+  bool isAssignableTo(TypeMirror other) {
+    if (other == currentMirrorSystem().dynamicType) return true;
+    if (other == currentMirrorSystem().voidType) return false;
+    return _moreSpecificTest(_reflectedType, other._reflectedType)
+        || _moreSpecificTest(other._reflectedType, _reflectedType);
+  }
+
+  bool isSubclassOf(ClassMirror other) {
+    if (other is! ClassMirror) throw new ArgumentError(other);
+    ClassMirror otherDeclaration = other.originalDeclaration;
+    ClassMirror c = this;
+    while (c != null) {
+      c = c.originalDeclaration;
+      if (c == otherDeclaration) return true;
+      c = c.superclass;
+    }
+    return false;
+  }
+
   static _library(reflectee)
       native "ClassMirror_library";
 
   static _supertype(reflectedType)
       native "ClassMirror_supertype";
 
   static _supertypeInstantiated(reflectedType)
       native "ClassMirror_supertype_instantiated";
 
   static _nativeInterfaces(reflectedType)
@@ skipping 152 matching lines @@
 
   TypeMirror _upperBound = null;
   TypeMirror get upperBound {
     if (_upperBound == null) {
       _upperBound = reflectType(_TypeVariableMirror_upper_bound(_reflectee));
     }
     return _upperBound;
   }
 
   bool get hasReflectedType => false;
-  Type get reflectedType => throw new UnsupportedError() ;
+  Type get reflectedType => throw new UnsupportedError();
+  Type get _reflectedType => _reflectee;
 
   List<TypeVariableMirror> get typeVariables => emptyList;
   List<TypeMirror> get typeArguments => emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 
   operator ==(other) {
     return other is TypeVariableMirror 
         && simpleName == other.simpleName
         && owner == other.owner;
   }
   int get hashCode => simpleName.hashCode;
 
+  bool isSubtypeOf(TypeMirror other) {
+    if (other == currentMirrorSystem().dynamicType) return true;
+    if (other == currentMirrorSystem().voidType) return false;
+    return _subtypeTest(_reflectedType, other._reflectedType);
+  }
+
+  bool isAssignableTo(TypeMirror other) {
+    if (other == currentMirrorSystem().dynamicType) return true;
+    if (other == currentMirrorSystem().voidType) return false;
+    return _moreSpecificTest(_reflectedType, other._reflectedType)
+        || _moreSpecificTest(other._reflectedType, _reflectedType);
+  }
+
   static DeclarationMirror _TypeVariableMirror_owner(reflectee)
       native "TypeVariableMirror_owner";
 
   static Type _TypeVariableMirror_upper_bound(reflectee)
       native "TypeVariableMirror_upper_bound";
 }
 
 
 class _LocalTypedefMirror extends _LocalDeclarationMirror
     implements TypedefMirror {
@@ skipping 67 matching lines @@
       } else {
         _typeArguments = new UnmodifiableListView(
             _LocalClassMirror._computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
+  bool isSubtypeOf(TypeMirror other) {
+    if (other == currentMirrorSystem().dynamicType) return true;
+    if (other == currentMirrorSystem().voidType) return false;
+    return _subtypeTest(_reflectedType, other._reflectedType);
+  }
+
+  bool isAssignableTo(TypeMirror other) {
+    if (other == currentMirrorSystem().dynamicType) return true;
+    if (other == currentMirrorSystem().voidType) return false;
+    return _moreSpecificTest(_reflectedType, other._reflectedType)
+        || _moreSpecificTest(other._reflectedType, _reflectedType);
+  }
+
   static _nativeReferent(reflectedType)
       native "TypedefMirror_referent";
 
   static _nativeDeclaration(reflectedType)
       native "TypedefMirror_declaration";
 }
 
 Symbol _asSetter(Symbol getter, LibraryMirror library) {
   var unwrapped = MirrorSystem.getName(getter);
   return MirrorSystem.getSymbol('${unwrapped}=', library);
@@ skipping 385 matching lines @@
   bool operator ==(other) {
     if (other is! _SpecialTypeMirror) {
       return false;
     }
     return this.simpleName == other.simpleName;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "TypeMirror on '${_n(simpleName)}'";
+
+  bool isSubtypeOf(TypeMirror other) {
+    return this == other ||
+           (other is _SpecialTypeMirror && other.simpleName == #dynamic);
+  }
+
+  bool isAssignableTo(TypeMirror other) {
+    return simpleName == #dynamic || other is _SpecialTypeMirror;
+  }
 }
 
 class _Mirrors {
   static MirrorSystem _currentMirrorSystem = null;
 
   // Creates a new local MirrorSystem.
   static MirrorSystem makeLocalMirrorSystem()
       native 'Mirrors_makeLocalMirrorSystem';
 
   // The MirrorSystem for the current isolate.
@@ skipping 36 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }