anchor.diff:      if (other is Type) {
         return sameOrSub(new TypeReflection(other));
       } else if (other is TypeReflection) {
  -      return this == other || mirror.isSubtypeOf(other.mirror);
  +      return this == other || _mirror.isSubtypeOf(other._mirror);
       } else {
         return sameOrSub(new TypeReflection.fromInstance(other));
       }
  
positive.code: part of reflective;
  
  class TypeReflection<T> {
    ClassMirror mirror;
    List<TypeReflection> _arguments;
  
    TypeReflection(Type type, [List<Type> arguments]) {
      mirror = reflectClass(type);
      if(arguments != null) {
        _arguments = new List.from(arguments.map((arg) => new TypeReflection(arg)));
      } else {
  
negative.code:   }
  
    TypeReflection.fromInstance(instance) {
      _mirror = reflect(instance).type;
      _getArgumentsFromMirror();
    }
  
    TypeReflection.fromMirror(this._mirror) {
      _getArgumentsFromMirror();
    }
  
    _getArgumentsFromMirror() {
      _arguments = new List.from(_mirror.typeArguments.map((m) => new TypeReflection.fromMirror(m)));
    }
  
    Type get type => _mirror.reflectedType;
  
    String get name => MirrorSystem.getName(_mirror.qualifiedName);
  
    Map<String, FieldReflection> get fields {
      return Maps.index(_mirror.declarations.keys
      .where((key) => _mirror.declarations[key] is VariableMirror)
      .map((key) => new FieldReflection(key, _mirror.declarations[key], _mirror.instanceMembers[key])),
          (field) => field.name);
    }
  
  