anchor.diff:  /// Create a parser that can be used to parse the command-line arguments.
   ArgParser createArgParser() {
     ArgParser parser = ArgParser();
  -  parser.addFlag(
  -    'corpus',
  -    help: 'Analyze each of the subdirectories separately',
  -    negatable: false,
  -  );
     parser.addOption(
       'help',
       abbr: 'h',
  
positive.code: import 'package:analysis_server/src/services/completion/dart/completion_manager.dart';
  import 'package:analysis_server/src/services/completion/dart/utilities.dart';
  import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
  import 'package:analyzer/dart/analysis/results.dart';
  import 'package:analyzer/diagnostic/diagnostic.dart';
  import 'package:analyzer/error/error.dart' as err;
  
negative.code:     return suggestions;
    }
  
    /// Compute the metrics for the files in the context [root], creating a
    /// separate context collection to prevent accumulating memory. The metrics
    /// should be captured in the [collector].
    Future<void> _computeInContext(ContextRoot root) async {
      // Create a new collection to avoid consuming large quantities of memory.
      // TODO(brianwilkerson) Create an OverlayResourceProvider to allow the
      //  content of the files to be modified before computing suggestions.
      final collection = AnalysisContextCollection(
        includedPaths: root.includedPaths.toList(),
        excludedPaths: root.excludedPaths.toList(),
        resourceProvider: PhysicalResourceProvider.INSTANCE,
      );
      var context = collection.contexts[0];
      // Set the DeclarationsTracker, only call doWork to build up the available
      // suggestions if doComputeCompletionsFromAnalysisServer is true.
      // TODO(brianwilkerson) Add a flag to control whether available suggestions
      //  are to be used.
      var declarationsTracker = DeclarationsTracker(
          MemoryByteStore(), PhysicalResourceProvider.INSTANCE);
      declarationsTracker.addContext(context);
      while (declarationsTracker.hasWork) {
        declarationsTracker.doWork();
      }
  
      // Loop through each file, resolve the file and call
      // forEachExpectedCompletion
      for (var filePath in context.contextRoot.analyzedFiles()) {
        if (AnalysisEngine.isDartFileName(filePath)) {
          _currentFilePath = filePath;
          try {
            _resolvedUnitResult =
                await context.currentSession.getResolvedUnit(filePath);
  
            var analysisError = getFirstErrorOrNull(_resolvedUnitResult);
            if (analysisError != null) {
              print('File $filePath skipped due to errors such as:');
              print('  ${analysisError.toString()}');
              print('');
              resultCode = 1;
              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) {
              // As this point the completion suggestions are computed,
              // and results are collected with varying settings for
              // comparison:
  
              // First we compute the completions useNewRelevance set to
              // false:
              var suggestions = await _computeCompletionSuggestions(
                  _resolvedUnitResult,
                  expectedCompletion.offset,
                  metricsOldMode,
                  declarationsTracker,
                  false);
  
              forEachExpectedCompletion(
                  expectedCompletion, suggestions, metricsOldMode);
  
              // And again here with useNewRelevance set to true:
              suggestions = await _computeCompletionSuggestions(
                  _resolvedUnitResult,
                  expectedCompletion.offset,
                  metricsNewMode,
                  declarationsTracker,
                  true);
  
              forEachExpectedCompletion(
                  expectedCompletion, suggestions, metricsNewMode);
            }
          } catch (e) {
            print('Exception caught analyzing: $filePath');
            print(e.toString());
            resultCode = 1;
          }
        }
      }
    }
  
    /// Given some [ResolvedUnitResult] return the first error of high severity
    /// if such an error exists, `null` otherwise.
    static err.AnalysisError getFirstErrorOrNull(
  