anchor.diff:          ..opacity = '0.6';
     }
   
  -  void populate(data.Outline outline) {
  +  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 (data.OutlineTopLevelEntry model in outline.entries) {
  -      _create(model);
  +    for (model.OutlineTopLevelEntry data in outline.entries) {
  +      _create(data);
       }
     }
   
  -  OutlineTopLevelItem _create(data.OutlineTopLevelEntry model) {
  -    if (model is data.OutlineClass) {
  -      return addClass(model);
  -    } else if (model is data.OutlineTopLevelVariable) {
  -      return addVariable(model);
  -    } else if (model is data.OutlineTopLevelFunction) {
  -      return addFunction(model);
  +  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");
       }
  
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:     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;
  