anchor.diff:    }
   
     /**
  +   * Populate [referenceInfos] with the correct information for the current
  +   * compilation unit.
  +   */
  +  void populateReferenceInfos() {
  +    int numLinkedReferences = linkedUnit.references.length;
  +    int numUnlinkedReferences = unlinkedUnit.references.length;
  +    referenceInfos = new List<_ReferenceInfo>(numLinkedReferences);
  +    for (int i = 0; i < numLinkedReferences; i++) {
  +      LinkedReference linkedReference = linkedUnit.references[i];
  +      String name;
  +      if (i < numUnlinkedReferences) {
  +        name = unlinkedUnit.references[i].name;
  +      } else {
  +        name = linkedUnit.references[i].name;
  +      }
  +      ElementHandle element;
  +      DartType type;
  +      if (linkedReference.kind == ReferenceKind.unresolved) {
  +        type = summaryResynthesizer.typeProvider.undefinedType;
  +      } else if (name == 'dynamic') {
  +        type = summaryResynthesizer.typeProvider.dynamicType;
  +      } else if (name == 'void') {
  +        type = VoidTypeImpl.instance;
  +      } else {
  +        ElementLocation location;
  +        if (linkedReference.dependency != 0) {
  +          location = getReferencedLocation(
  +              linkedLibrary.dependencies[linkedReference.dependency],
  +              linkedReference.unit,
  +              name);
  +        } else {
  +          String referencedLibraryUri = librarySource.uri.toString();
  +          String partUri;
  +          if (linkedReference.unit != 0) {
  +            String uri = unlinkedUnits[0].publicNamespace.parts[
  +                linkedReference.unit - 1];
  +            Source partSource = summaryResynthesizer.sourceFactory
  +                .resolveUri(librarySource, uri);
  +            partUri = partSource.uri.toString();
  +          } else {
  +            partUri = referencedLibraryUri;
  +          }
  +          location = new ElementLocationImpl.con3(
  +              <String>[referencedLibraryUri, partUri, name]);
  +        }
  +        switch (linkedReference.kind) {
  +          case ReferenceKind.classOrEnum:
  +            element = new ClassElementHandle(summaryResynthesizer, location);
  +            break;
  +          case ReferenceKind.typedef:
  +            element = new FunctionTypeAliasElementHandle(
  +                summaryResynthesizer, location);
  +            break;
  +          default:
  +            // This is an element that doesn't (yet) need to be referred to
  +            // directly, so don't bother populating an element for it.
  +            // TODO(paulberry): add support for more kinds, as needed.
  +            break;
  +        }
  +      }
  +      referenceInfos[i] = new _ReferenceInfo(
  +          name, element, type, linkedReference.numTypeParameters);
  +    }
  +  }
  +
  +  /**
      * Populate a [CompilationUnitElement] by deserializing all the elements
      * contained in it.
      */
  
positive.code:     for (EntityRef t in linkedUnit.types) {
        linkedTypeMap[t.slot] = t;
      }
      unitHolder = new ElementHolder();
      unlinkedUnit.classes.forEach(buildClass);
      unlinkedUnit.enums.forEach(buildEnum);
  
negative.code:    * List of constant variables to compute values for.
     */
    List<_ConstVariable> constVariables = <_ConstVariable>[];
  
    /**
     * List of [_ReferenceInfo] objects describing the references in the current
     * compilation unit.
     */
    List<_ReferenceInfo> referenceInfos;
  
    _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
        this.unlinkedUnits, this.librarySource) {
  