anchor.diff:    ReflectorData _dataCache;
     ReflectorData get _data {
       if (_dataCache == null) {
  -      _dataCache = data[reflectable];
  +      _dataCache = data[_reflectable];
       }
       return _dataCache;
     }
   
  -  final ReflectableImpl reflectable;
  +  final ReflectableImpl _reflectable;
   
     final Object reflectee;
   
  -  InstanceMirrorImpl(this.reflectee, this.reflectable) {
  +  InstanceMirrorImpl(this.reflectee, this._reflectable) {
       _type = _data.classMirrorForType(reflectee.runtimeType);
       if (_type == null) {
         throw new NoSuchCapabilityError(
  
positive.code:   }
  
    bool get hasReflectee => true;
    bool operator ==(other) {
      return other is InstanceMirrorImpl &&
          other._data == _data &&
          other.reflectee == reflectee;
    }
  
    int get hashCode => reflectee.hashCode;
  
    delegate(Invocation invocation) => _unsupported();
  
  
negative.code: 
    @override
    List<TypeVariableMirror> get typeVariables => _unsupported();
  
    // Because we take care to only ever create one instance for each
    // type/reflector-combination we can rely on the default `hashCode` and `==`
    // operations.
  }
  
  abstract class TypeVariableMirrorUnimpl extends TypeMirrorUnimpl
  