anchor.diff:    /// If the concrete class has this getter return true, then when
     /// [forEachExpectedCompletion] is called, the [List] of
     /// [CompletionSuggestion]s will be passed.
  -  bool get doComputeCompletionsFromAnalysisServer;
  -
  -  /// The current [ResolvedUnitResult].
  -  ResolvedUnitResult get resolvedUnitResult => _resolvedUnitResult;
  +  bool get doComputeCompletionsFromAnalysisServer => true;
   
     /// The analysis root path that this CompletionMetrics class will be computed.
     String get rootPath => _rootPath;
   
  -  void compute({bool corpus = false}) async {
  +  Future<int> compute({bool corpus = false}) async {
  +    resultCode = 0;
       print('Analyzing root: \"$_rootPath\"');
   
       if (!io.Directory(_rootPath).existsSync()) {
         print('\tError: No such directory exists on this machine.\n');
  -      return;
  +      return 1;
       }
   
       var roots = _computeRootPaths(_rootPath, corpus);
  
positive.code:         var declarationsTracker = DeclarationsTracker(
              MemoryByteStore(), PhysicalResourceProvider.INSTANCE);
          declarationsTracker.addContext(context);
          if (doComputeCompletionsFromAnalysisServer) {
            while (declarationsTracker.hasWork) {
              declarationsTracker.doWork();
            }
          }
  
          // Loop through each file, resolve the file and call
  
negative.code:             } catch (e) {
                print('Exception caught analyzing: $filePath');
                print(e.toString());
                resultCode = 1;
              }
            }
          }
        }
      }
      printAndClearComputers();
      return resultCode;
    }
  
    void forEachExpectedCompletion(ExpectedCompletion expectedCompletion,
        List<CompletionSuggestion> suggestions) {
      assert(suggestions != null);
  
      var place = placementInSuggestionList(suggestions, expectedCompletion);
  
      mRRComputer.addRank(place.rank);
  
      if (place.denominator != 0) {
        includedCount++;
      } else {
        notIncludedCount++;
  
        completionMissedTokenCounter.count(expectedCompletion.completion);
        completionKindCounter.count(expectedCompletion.kind.toString());
        completionElementKindCounter
            .count(expectedCompletion.elementKind.toString());
  
        // The format "/file/path/foo.dart:3:4" makes for easier input
        // with the Files dialog in IntelliJ
        print(
            '$currentFilePath:${expectedCompletion.lineNumber}:${expectedCompletion.columnNumber}');
        print(
            '\tdid not include the expected completion: \"${expectedCompletion.completion}\", completion kind: ${expectedCompletion.kind.toString()}, element kind: ${expectedCompletion.elementKind.toString()}');
        print('');
      }
    }
  
    void printAndClearComputers() {
      final totalCompletionCount = includedCount + notIncludedCount;
      final percentIncluded = includedCount / totalCompletionCount;
      final percentNotIncluded = 1 - percentIncluded;
  
      completionMissedTokenCounter.printCounterValues();
      print('');
  
      completionKindCounter.printCounterValues();
      print('');
  
      completionElementKindCounter.printCounterValues();
      print('');
  
      mRRComputer.printMean();
      print('');
  
      print('Summary for $_rootPath:');
      print('Total number of completion tests   = $totalCompletionCount');
      print(
          'Number of successful completions   = $includedCount (${printPercentage(percentIncluded)})');
      print(
          'Number of unsuccessful completions = $notIncludedCount (${printPercentage(percentNotIncluded)})');
  
      includedCount = 0;
      notIncludedCount = 0;
      completionMissedTokenCounter.clear();
      completionKindCounter.clear();
      completionElementKindCounter.clear();
      mRRComputer.clear();
    }
  
    Future<List<CompletionSuggestion>> _computeCompletionSuggestions(
        ResolvedUnitResult resolvedUnitResult, int offset,
  