anchor.diff:              } catch (e) {
                 print('Exception caught analyzing: $filePath');
                 print(e.toString());
  +              resultCode = 1;
               }
             }
           }
         }
       }
       printAndClearComputers();
  -  }
  -
  -  /// Overridden by each subclass, this method gathers some set of data from
  -  /// each [ExpectedCompletion], and each [CompletionSuggestion] list (if
  -  /// [doComputeCompletionsFromAnalysisServer] is set to true.)
  +    return resultCode;
  +  }
  +
     void forEachExpectedCompletion(ExpectedCompletion expectedCompletion,
  -      List<CompletionSuggestion> suggestions);
  -
  -  /// This method is called to print a summary of the data collected.
  -  void printAndClearComputers();
  +      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,
  
positive.code:               _resolvedUnitResult =
                    await context.currentSession.getResolvedUnit(filePath);
  
                var error = getFirstErrorOrNull(resolvedUnitResult);
                if (error != null) {
                  print('File $filePath skipped due to errors such as:');
                  print('  ${error.toString()}');
                  print('');
                  continue;
                }
  
                // Use the ExpectedCompletionsVisitor to compute the set of expected
                // completions for this CompilationUnit.
                final visitor = ExpectedCompletionsVisitor();
                resolvedUnitResult.unit.accept(visitor);
  
                for (var expectedCompletion in visitor.expectedCompletions) {
                  // Call forEachExpectedCompletion, passing in the computed
                  // suggestions only if doComputeCompletionsFromAnalysisServer is
                  // true:
                  forEachExpectedCompletion(
                      expectedCompletion,
                      doComputeCompletionsFromAnalysisServer
                          ? await _computeCompletionSuggestions(
                              resolvedUnitResult,
                              expectedCompletion.offset,
                              declarationsTracker)
                          : null);
  
negative.code:         var declarationsTracker = DeclarationsTracker(
              MemoryByteStore(), PhysicalResourceProvider.INSTANCE);
          declarationsTracker.addContext(context);
          while (declarationsTracker.hasWork) {
            declarationsTracker.doWork();
          }
  
          // Loop through each file, resolve the file and call
  