anchor.diff:    }
   
     /**
  +   * Return the unlinked bundle of [file] for the current file state, or `null`.
  +   */
  +  PackageBundle _getCurrentUnlinked(_File file) {
  +    String key = '${file.currentContentHash}.unlinked';
  +    List<int> bytes = _byteStore.get(key);
  +    return bytes != null ? new PackageBundle.fromBuffer(bytes) : null;
  +  }
  +
  +  /**
      * TODO(scheglov) It would be nice to get URIs of "parts" from unlinked.
      */
     _ReferencedUris _getReferencedUris(_File file) {
  
positive.code:   }
  
    /**
     * Ensure that the [contentHash] is filled.
     *
     * If the hash is already in the current file state, return the current
     * value. Otherwise, read the [content], compute the hash, put it into
     * the current file state, and update the [contentHash] field.
     *
     * The client should not remember values of this property, because its value
     * might change when [content] is read and the hash is recomputed.
     */
    String get contentHash {
      _contentHash ??= driver._fileContentHashMap[path];
      if (_contentHash == null) {
        _readContentAndComputeHash();
      }
      return _contentHash;
    }
  
    String get path => source.fullName;
  
negative.code:   /**
     * Return the unlinked bundle of [file] for the current file state.
     *
     * Return [_getCurrentUnlinked] or read the [file] content is read, compute
     * the content hash and update the current file state accordingly. Parse the
     * content into the [CompilationUnit] and serialize into a new unlinked
     * bundle. The bundle is then put into the [_byteStore] and returned.
     */
    PackageBundle _getUnlinked(_File file) {
      return _getCurrentUnlinked(file) ??
          _logger.run('Create unlinked for $file', () {
            String key = '${file.contentHash}.unlinked';
            UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(file.unit);
            PackageBundleAssembler assembler = new PackageBundleAssembler();
            assembler.addUnlinkedUnitWithHash(
                file.uri.toString(), unlinkedUnit, key);
            List<int> bytes = assembler.assemble().toBuffer();
            _byteStore.put(key, bytes);
            return new PackageBundle.fromBuffer(bytes);
          });
    }
  
    /**
     * Verify the API signatures for the changed files, and decide which linked
     * libraries should be invalidated, and files reanalyzed.
     */
    void _verifyUnlinkedSignatureOfChangedFiles() {
      if (_filesToVerifyUnlinkedSignature.isEmpty) {
        return;
      }
      int numOfFiles = _filesToVerifyUnlinkedSignature.length;
      _logger.run('Verify API signatures of $numOfFiles files', () {
        for (String path in _filesToVerifyUnlinkedSignature) {
          _File file = _fileForPath(path);
          // Get the existing old API signature, maybe null.
          String oldSignature = _getCurrentUnlinked(file)?.apiSignature;
          // Clear the content hash cache, so force the file reading.
          _fileContentHashMap.remove(path);
          // Compute the new API signature.
          String newSignature = _getUnlinked(file).apiSignature;
          // If the signatures are not the same, then potentially every linked
          // library is inconsistent and should be recomputed, and every explicit
          // file has inconsistent analysis results which also should be recomputed.
          if (oldSignature != newSignature) {
            _logger.writeln('API signature mismatch found for $file.');
            _dependencySignatureMap.clear();
            _filesToAnalyze.addAll(_explicitFiles);
            // Stop the verification, and restart analysis.
            break;
          }
        }
        _filesToVerifyUnlinkedSignature.clear();
      });
    }
  }
  
  