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:     linkedUnit = null;
      unlinkedUnit = null;
      linkedTypeMap = null;
    }
  }
  
negative.code:               currentTypeParameters.length - type.paramReference]
            .type;
      } else {
        DartType getTypeParameter(int i) {
          if (i < type.typeArguments.length) {
            return buildType(type.typeArguments[i]);
          } else {
            return summaryResynthesizer.typeProvider.dynamicType;
          }
        }
        _ReferenceInfo referenceInfo = referenceInfos[type.reference];
        return referenceInfo.buildType(getTypeParameter);
      }
    }
  
  