anchor.diff:  part of reflective;
   
   class TypeReflection<T> {
  -  ClassMirror mirror;
  +  ClassMirror _mirror;
     List<TypeReflection> _arguments;
   
     TypeReflection(Type type, [List<Type> arguments]) {
  -    mirror = reflectClass(type);
  +    _mirror = reflectClass(type);
       if(arguments != null) {
         _arguments = new List.from(arguments.map((arg) => new TypeReflection(arg)));
       } else {
  
positive.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)));
    }
  
    get type => mirror.reflectedType;
  
    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);
    }
  
  
negative.code:     if (other is Type) {
        return sameOrSuper(new TypeReflection(other));
      } else if (other is TypeReflection) {
        return this == other || other._mirror.isSubtypeOf(_mirror);
      } else {
        return sameOrSuper(new TypeReflection.fromInstance(other));
      }
  