anchor.diff:      return item;
     }
   
  -  OutlineTopLevelVariable addVariable(data.OutlineTopLevelVariable model) =>
  -      _addItem(new OutlineTopLevelVariable(model));
  -  OutlineTopLevelFunction addFunction(data.OutlineTopLevelFunction model) =>
  -      _addItem(new OutlineTopLevelFunction(model));
  +  OutlineTopLevelVariable _addVariable(model.OutlineTopLevelVariable data) =>
  +      _addItem(new OutlineTopLevelVariable(data));
   
  -  OutlineClass addClass(data.OutlineClass model) {
  -    OutlineClass classItem = new OutlineClass(model);
  +  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;
  
positive.code:     return member;
    }
  
    void populate(data.OutlineClass classModel) {
      for (data.OutlineEntry model in classModel.members) {
        _create(model);
      }
    }
  
    OutlineItem _create(data.OutlineEntry model) {
      if (model is data.OutlineMethod) {
        return addMethod(model);
      } else if (model is data.OutlineClassVariable) {
        return addProperty(model);
      } else {
        throw new UnimplementedError("Unknown type");
      }
    }
  
    OutlineMethod addMethod(data.OutlineMethod model) =>
        _addElement(new OutlineMethod(model));
    OutlineProperty addProperty(data.OutlineClassVariable model) =>
        _addElement(new OutlineProperty(model));
  }
  
  class OutlineMethod extends OutlineClassMember {
    OutlineMethod(data.OutlineMethod model) : super(model);
  }
  
  abstract class OutlineClassMember extends OutlineItem {
    OutlineClassMember(data.OutlineMember model) : super(model);
  }
  
  class OutlineProperty extends OutlineClassMember {
    OutlineProperty(data.OutlineClassVariable model) : super(model);
  }
  
  
negative.code:         ..opacity = '0.6';
    }
  
    void populate(model.Outline outline) {
      // TODO(ericarnold): Is there anything else that needs to be done to
      //    emsure there are no memory leaks?
      children = [];
      if (_rootList != null) {
        _rootList.remove();
      }
  
      _rootList = new html.UListElement();
      _outlineDiv.append(_rootList);
  
      for (model.OutlineTopLevelEntry data in outline.entries) {
        _create(data);
      }
    }
  
    OutlineTopLevelItem _create(model.OutlineTopLevelEntry data) {
      if (data is model.OutlineClass) {
        return _addClass(data);
      } else if (data is model.OutlineTopLevelVariable) {
        return _addVariable(data);
      } else if (data is model.OutlineTopLevelFunction) {
        return _addFunction(data);
      } else {
        throw new UnimplementedError("Unknown type");
      }
  