anchor.diff:      return member;
     }
   
  -  void populate(data.OutlineClass classModel) {
  -    for (data.OutlineEntry model in classModel.members) {
  -      _create(model);
  +  void populate(model.OutlineClass classData) {
  +    for (model.OutlineEntry data in classData.members) {
  +      _create(data);
       }
     }
   
  -  OutlineItem _create(data.OutlineEntry model) {
  -    if (model is data.OutlineMethod) {
  -      return addMethod(model);
  -    } else if (model is data.OutlineClassVariable) {
  -      return addProperty(model);
  +  OutlineItem _create(model.OutlineEntry data) {
  +    if (data is model.OutlineMethod) {
  +      return addMethod(data);
  +    } else if (data is model.OutlineClassVariable) {
  +      return addProperty(data);
       } else {
         throw new UnimplementedError("Unknown type");
       }
     }
   
  -  OutlineMethod addMethod(data.OutlineMethod model) =>
  -      _addElement(new OutlineMethod(model));
  -  OutlineProperty addProperty(data.OutlineClassVariable model) =>
  -      _addElement(new OutlineProperty(model));
  +  OutlineMethod addMethod(model.OutlineMethod data) =>
  +      _addElement(new OutlineMethod(data));
  +  OutlineProperty addProperty(model.OutlineClassVariable data) =>
  +      _addElement(new OutlineProperty(data));
   }
   
   class OutlineMethod extends OutlineClassMember {
  -  OutlineMethod(data.OutlineMethod model) : super(model);
  +  OutlineMethod(model.OutlineMethod data) : super(data);
   }
   
   abstract class OutlineClassMember extends OutlineItem {
  -  OutlineClassMember(data.OutlineMember model) : super(model);
  +  OutlineClassMember(model.OutlineMember data) : super(data);
   }
   
   class OutlineProperty extends OutlineClassMember {
  -  OutlineProperty(data.OutlineClassVariable model) : super(model);
  +  OutlineProperty(model.OutlineClassVariable data) : super(data);
   }
   
  
positive.code: 
  abstract class OutlineItem {
    html.LIElement _element;
    data.OutlineEntry _model;
  
    OutlineItem(this._model) {
      _element = new html.LIElement();
      _element.text = _model.name;
    }
  }
  
  abstract class OutlineTopLevelItem extends OutlineItem {
    OutlineTopLevelItem(data.OutlineTopLevelEntry model) : super(model);
  }
  
  class OutlineTopLevelVariable extends OutlineTopLevelItem {
    OutlineTopLevelVariable(data.OutlineTopLevelVariable model) : super(model);
  }
  
  class OutlineTopLevelFunction extends OutlineTopLevelItem {
    OutlineTopLevelFunction(data.OutlineTopLevelFunction model) : super(model);
  }
  
  class OutlineClass extends OutlineTopLevelItem {
    var _childrenRootElement = new html.UListElement();
    List<OutlineClassMember> members = [];
  
    OutlineClass(data.OutlineClass model) : super(model) {
      populate(model);
    }
  
    OutlineClassMember _addElement(OutlineClassMember member) {
  
negative.code:     return item;
    }
  
    OutlineTopLevelVariable _addVariable(model.OutlineTopLevelVariable data) =>
        _addItem(new OutlineTopLevelVariable(data));
  
    OutlineTopLevelFunction _addFunction(model.OutlineTopLevelFunction data) =>
        _addItem(new OutlineTopLevelFunction(data));
  
    OutlineClass _addClass(model.OutlineClass data) {
      OutlineClass classItem = new OutlineClass(data);
      _addItem(classItem);
      _rootList.append(classItem._childrenRootElement);
      return classItem;
  