anchor.diff:        while (true) {
           // TODO(scheglov) implement state transitioning
           await for (String why in _hasWorkStreamController.stream) {
  +          _verifyUnlinkedSignatureOfChangedFiles();
  +
             // Analyze the first file in the general queue.
             if (_filesToAnalyze.isNotEmpty) {
               _logger.run('Analyze ${_filesToAnalyze.length} files', () {
  
positive.code:    * [changeFile] invocation.
     */
    void changeFile(String path) {
      // TODO(scheglov) Don't clear, schedule API signature validation.
      _fileContentHashMap.clear();
      _dependencySignatureMap.clear();
      _filesToAnalyze.add(path);
      _filesToAnalyze.addAll(_explicitFiles);
      // TODO(scheglov) name?!
      _hasWorkStreamController.add('do it!');
    }
  
  
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();
      });
    }
  }
  
  