anchor.diff:        // for missing files. Maybe add this feature to SummaryDataStore?
       }
       // Compute the content hash.
  -    List<int> textBytes = UTF8.encode(_content);
  +    List<int> textBytes = UTF8.encode(content);
       List<int> hashBytes = md5.convert(textBytes).bytes;
  -    _contentHash = hex.encode(hashBytes);
  +    String contentHash = hex.encode(hashBytes);
  +    driver._fileContentHashMap[path] = contentHash;
  +    // Parse the unit.
  +    CompilationUnit unit = _parse(driver, source, content);
  +    // Prepare the unlinked bundle.
  +    PackageBundle unlinked;
  +    {
  +      String key = '$contentHash.unlinked';
  +      List<int> bytes = driver._byteStore.get(key);
  +      if (bytes == null) {
  +        driver._logger.run('Create unlinked for $path', () {
  +          UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
  +          PackageBundleAssembler assembler = new PackageBundleAssembler();
  +          assembler.addUnlinkedUnitWithHash(
  +              source.uri.toString(), unlinkedUnit, contentHash);
  +          bytes = assembler.assemble().toBuffer();
  +          driver._byteStore.put(key, bytes);
  +        });
  +      }
  +      unlinked = new PackageBundle.fromBuffer(bytes);
  +      driver._fileApiSignatureMap[path] = unlinked.apiSignature;
  +    }
       // Update the current file state.
  -    driver._fileContentHashMap[path] = _contentHash;
  +    return new _File._(driver, source, content, contentHash, unlinked, unit);
  +  }
  +
  +  _File._(this.driver, this.source, this.content, this.contentHash,
  +      this.unlinked, this.unit);
  +
  +  String get path => source.fullName;
  +
  +  Uri get uri => source.uri;
  +
  +  /**
  +   * Return the [_File] for the [uri] referenced in this file.
  +   *
  +   * This [_File] can be used only for linking.
  +   */
  +  _File resolveUri(String uri) {
  +    // TODO(scheglov) Consider removing this caching after implementing other
  +    // optimizations, e.g. changeFile() optimization.
  +    Source uriSource = driver._uriResolutionCache
  +        .putIfAbsent(this.uri, () => <String, Source>{})
  +        .putIfAbsent(uri, () => driver._sourceFactory.resolveUri(source, uri));
  +    return new _File.forLinking(driver, uriSource);
  +  }
  +
  +  @override
  +  String toString() => path;
  +
  +  /**
  +   * Return the parsed unresolved [CompilationUnit] for the given [content].
  +   */
  +  static CompilationUnit _parse(
  +      AnalysisDriver driver, Source source, String content) {
  +    AnalysisErrorListener errorListener = AnalysisErrorListener.NULL_LISTENER;
  +
  +    CharSequenceReader reader = new CharSequenceReader(content);
  +    Scanner scanner = new Scanner(source, reader, errorListener);
  +    scanner.scanGenericMethodComments = driver._analysisOptions.strongMode;
  +    Token token = scanner.tokenize();
  +    LineInfo lineInfo = new LineInfo(scanner.lineStarts);
  +
  +    Parser parser = new Parser(source, errorListener);
  +    parser.parseGenericMethodComments = driver._analysisOptions.strongMode;
  +    CompilationUnit unit = parser.parseCompilationUnit(token);
  +    unit.lineInfo = lineInfo;
  +    return unit;
     }
   }
   
  
positive.code:   final _fileContentHashMap = <String, String>{};
  
    /**
     * Mapping from library URIs to the dependency signature of the library.
     */
    final _dependencySignatureMap = <Uri, String>{};
  
negative.code:    */
    final Source source;
  
    /**
     * The [source] content, or `null` if this file is for linking.
     */
    final String content;
  
    /**
     * The [source] content hash, not `null` even if [content] is `null`.
     */
    final String contentHash;
  
    /**
     * The unlinked bundle, not `null`.
     */
    final PackageBundle unlinked;
  
    /**
     * The unresolved unit, not `null` if this file is for resolution.
     */
    final CompilationUnit unit;
  
    factory _File.forLinking(AnalysisDriver driver, Source source) {
      // If we have enough cached information, use it.
      String contentHash = driver._fileContentHashMap[source.fullName];
      if (contentHash != null) {
        String key = '$contentHash.unlinked';
        List<int> bytes = driver._byteStore.get(key);
        if (bytes != null) {
          PackageBundle unlinked = new PackageBundle.fromBuffer(bytes);
          return new _File._(driver, source, null, contentHash, unlinked, null);
        }
      }
      // Otherwise, read the source, parse and build a new unlinked bundle.
      return new _File.forResolution(driver, source);
    }
  
    factory _File.forResolution(AnalysisDriver driver, Source source) {
      String path = source.fullName;
      // Read the content.
      String content;
      try {
        content = driver._contentCache.getContents(source);
        content ??= source.contents.data;
      } catch (_) {
        content = '';
        // TODO(scheglov) We fail to report URI_DOES_NOT_EXIST.
        // On one hand we need to provide an unlinked bundle to prevent
        // analysis context from reading the file (we want it to work
  