updateFileContexts method

Future<bool> updateFileContexts(
  1. Set<String> filePaths
)

Inform the analyzer that the provided filePaths have been updated.

Refreshes the Dart analysis context for the changed files and returns true if the analysis recognizes any of them as (or as having been) future call files, or if the change altered what a future call in another file declares, meaning code generation should run.

Implementation

Future<bool> updateFileContexts(Set<String> filePaths) async {
  // Only consider files within the tracked directory.
  final relevantPaths = filePaths
      .where((f) => p.isWithin(absoluteIncludedPaths, p.absolute(f)))
      .toSet();

  final erroredFilesBefore = _erroredFiles;
  final keysBefore = _fileCache.keys.toSet();
  // Read before analyzing, which records the hashes itself when there are
  // none yet.
  final previousHashes = _definitionHashesAtLastUpdate;

  await analyze(
    collector: CodeGenerationCollector(),
    changedFiles: relevantPaths,
  );

  final erroredFilesAfter = _erroredFiles;
  final keysAfter = _fileCache.keys.toSet();

  // What a future call declares can change without its file changing, through
  // an alias, a base class or a type in a file it imports. Every cached file
  // was just analyzed again and hashed its definitions while it was parsed,
  // so the hashes show it. They are compared with the ones of the previous
  // update, which were parsed the same way, rather than with what generation
  // left in the cache, which validates against models and can differ from
  // this without anything having changed.
  final definitionHashes = _definitionHashes;
  _definitionHashesAtLastUpdate = definitionHashes;
  if (previousHashes != null &&
      definitionHashes.entries.any(
        (entry) => previousHashes[entry.key] != entry.value,
      )) {
    return true;
  }

  // Regenerate when the set of future call files changed, or when any
  // file's error state flipped (an error appearing or clearing changes the
  // parsed definitions). A persistently broken - or not yet fully analyzed
  // (see `hadErrors: !hasModels`) - file, by contrast, must not turn every
  // unrelated change - such as watcher echoes of freshly generated files -
  // into another generation, or generation loops forever while an error
  // exists anywhere in the project.
  if (keysBefore.length != keysAfter.length ||
      keysAfter.difference(keysBefore).isNotEmpty ||
      erroredFilesBefore.length != erroredFilesAfter.length ||
      erroredFilesAfter.difference(erroredFilesBefore).isNotEmpty) {
    return true;
  }

  // The cache only holds files the analysis recognized as future call files.
  // Canonicalized once into a set rather than compared pairwise, so this
  // stays linear in the number of changed files as the project's future
  // call count grows.
  final cachedFutureCallPaths = {
    for (final key in keysAfter) p.canonicalize(key),
  };
  return relevantPaths.any(
    (path) => cachedFutureCallPaths.contains(p.canonicalize(path)),
  );
}