anchor.diff:      return _classes;
     }
   
  +  Map<Symbol, MethodMirror> _functions;
     Map<Symbol, MethodMirror> get functions {
       if (_functions == null) {
  -      _functions = _filterMap(members,
  -                              (key, value) => (value is MethodMirror));
  +      _functions = _filterMap(members, (key, value) => (value is MethodMirror));
       }
       return _functions;
     }
   
  +  Map<Symbol, MethodMirror> _getters;
     Map<Symbol, MethodMirror> get getters {
       if (_getters == null) {
  -      _getters = _filterMap(functions,
  -                            (key, value) => (value.isGetter));
  +      _getters = _filterMap(functions, (key, value) => (value.isGetter));
       }
       return _getters;
     }
   
  +  Map<Symbol, MethodMirror> _setters;
     Map<Symbol, MethodMirror> get setters {
       if (_setters == null) {
  -      _setters = _filterMap(functions,
  -                            (key, value) => (value.isSetter));
  +      _setters = _filterMap(functions, (key, value) => (value.isSetter));
       }
       return _setters;
     }
   
  +  Map<Symbol, VariableMirror> _variables;
     Map<Symbol, VariableMirror> get variables {
       if (_variables == null) {
         _variables = _filterMap(members,
  
positive.code:     return _owner;
    }
  
    bool get isPrivate => false;
  
    final bool isTopLevel = true;
  
    SourceLocation get location {
      throw new UnimplementedError(
          'TypedefMirror.location is not implemented');
    }
  
    TypeMirror _referent = null;
  
negative.code:   }
  
    Map<Symbol, TypeVariableMirror> _typeVariables = null;
    Map<Symbol, TypeVariableMirror> get typeVariables {
      if (_typeVariables == null) {
        List params = _ClassMirror_type_variables(_reflectee);
  