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:     }
      int numOfFiles = _filesToVerifyUnlinkedSignature.length;
      _logger.run('Verify API signatures of $numOfFiles files', () {
        bool hasMismatch = false;
        for (String path in _filesToVerifyUnlinkedSignature) {
          String oldSignature = _fileApiSignatureMap[path];
          // Compute the new API signature.
          // _File.forResolution() also updates the content hash in the cache.
          _File newFile = _fileForPath(path);
          String newSignature = newFile.unlinked.apiSignature;
          // If the old API signature is not null, then the file was used to
          // compute at least one dependency signature. If the new API signature
          // is different, then potentially all dependency signatures and
          // resolution results are invalid.
          if (oldSignature != null && oldSignature != newSignature) {
            _logger.writeln('API signature mismatch found for $newFile.');
            hasMismatch = true;
          }
        }
        if (hasMismatch) {
          _dependencySignatureMap.clear();
          _filesToAnalyze.addAll(_explicitFiles);
        } else {
          _logger.writeln('All API signatures match.');
        }
        _filesToVerifyUnlinkedSignature.clear();
      });
  