Clean up use of resource provider in cli

pkg/analyzer_cli/lib/src/driver.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer_cli.src.driver;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ skipping 234 matching lines @@
       stats.print(outSink);
     }
 
     return allResult;
   }
 
   /// Perform analysis in build mode according to the given [options].
   ErrorSeverity _buildModeAnalyze(CommandLineOptions options) {
     return _analyzeAllTag.makeCurrentWhile(() {
       if (options.buildModePersistentWorker) {
-        new AnalyzerWorkerLoop.std(dartSdkPath: options.dartSdkPath).run();
+        new AnalyzerWorkerLoop.std(resourceProvider,
+                dartSdkPath: options.dartSdkPath)
+            .run();
       } else {
-        return new BuildMode(options, stats).analyze();
+        return new BuildMode(resourceProvider, options, stats).analyze();
       }
     });
   }
 
   /// Determine whether the context created during a previous call to
   /// [_analyzeAll] can be re-used in order to analyze using [options].
   bool _canContextBeReused(CommandLineOptions options) {
     // TODO(paulberry): add a command-line option that disables context re-use.
     if (_context == null) {
       return false;
@@ skipping 204 matching lines @@
     // Save stats from previous context before clobbering it.
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
     // Create a context.
     _context = AnalysisEngine.instance.createAnalysisContext();
 
     AnalyzeFunctionBodiesPredicate dietParsingPolicy =
         _chooseDietParsingPolicy(options);
-    setAnalysisContextOptions(_context, options,
+    setAnalysisContextOptions(resourceProvider, _context, options,
         (AnalysisOptionsImpl contextOptions) {
       contextOptions.analyzeFunctionBodiesPredicate = dietParsingPolicy;
     });
 
     // Find package info.
     _PackageInfo packageInfo = _findPackages(options);
 
     // Process embedders.
     Map<file_system.Folder, YamlMap> embedderMap =
         new EmbedderYamlLocator(packageInfo.packageMap).embedderYamls;
@@ skipping 155 matching lines @@
     contextOptions.generateImplicitErrors = options.showPackageWarnings;
     contextOptions.generateSdkErrors = options.showSdkWarnings;
     contextOptions.lint = options.lints;
     contextOptions.strongMode = options.strongMode;
     contextOptions.implicitCasts = options.implicitCasts;
     contextOptions.implicitDynamic = options.implicitDynamic;
     return contextOptions;
   }
 
   static void setAnalysisContextOptions(
+      file_system.ResourceProvider resourceProvider,
       AnalysisContext context,
       CommandLineOptions options,
       void configureContextOptions(AnalysisOptionsImpl contextOptions)) {
     Map<String, String> definedVariables = options.definedVariables;
     if (definedVariables.isNotEmpty) {
       DeclaredVariables declaredVariables = context.declaredVariables;
       definedVariables.forEach((String variableName, String value) {
         declaredVariables.define(variableName, value);
       });
     }
 
     if (options.log) {
       AnalysisEngine.instance.logger = new StdLogger();
     }
 
     // Prepare context options.
     AnalysisOptionsImpl contextOptions =
         createAnalysisOptionsForCommandLineOptions(options);
     configureContextOptions(contextOptions);
 
     // Set context options.
     context.analysisOptions = contextOptions;
 
     // Process analysis options file (and notify all interested parties).
-    _processAnalysisOptions(context, options);
+    _processAnalysisOptions(resourceProvider, context, options);
   }
 
   /// Perform a deep comparison of two string maps.
   static bool _equalMaps(Map<String, String> m1, Map<String, String> m2) {
     if (m1.length != m2.length) {
       return false;
     }
     for (String key in m1.keys) {
       if (!m2.containsKey(key) || m1[key] != m2[key]) {
         return false;
       }
     }
     return true;
   }
 
-  static file_system.File _getOptionsFile(CommandLineOptions options) {
+  static file_system.File _getOptionsFile(
+      file_system.ResourceProvider resourceProvider,
+      CommandLineOptions options) {
     file_system.File file;
     String filePath = options.analysisOptionsFile;
     if (filePath != null) {
-      file = PhysicalResourceProvider.INSTANCE.getFile(filePath);
+      file = resourceProvider.getFile(filePath);
       if (!file.exists) {
         printAndFail('Options file not found: $filePath',
             exitCode: ErrorSeverity.ERROR.ordinal);
       }
     } else {
       filePath = AnalysisEngine.ANALYSIS_OPTIONS_FILE;
-      file = PhysicalResourceProvider.INSTANCE.getFile(filePath);
+      file = resourceProvider.getFile(filePath);
       if (!file.exists) {
         filePath = AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
-        file = PhysicalResourceProvider.INSTANCE.getFile(filePath);
+        file = resourceProvider.getFile(filePath);
       }
     }
     return file;
   }
 
   /// Convert [sourcePath] into an absolute path.
   static String _normalizeSourcePath(String sourcePath) =>
       path.normalize(new File(sourcePath).absolute.path);
 
   static void _processAnalysisOptions(
-      AnalysisContext context, CommandLineOptions options) {
-    file_system.File file = _getOptionsFile(options);
+      file_system.ResourceProvider resourceProvider,
+      AnalysisContext context,
+      CommandLineOptions options) {
+    file_system.File file = _getOptionsFile(resourceProvider, options);
     List<OptionsProcessor> optionsProcessors =
         AnalysisEngine.instance.optionsPlugin.optionsProcessors;
     try {
       AnalysisOptionsProvider analysisOptionsProvider =
           new AnalysisOptionsProvider();
       Map<String, YamlNode> optionMap =
           analysisOptionsProvider.getOptionsFromFile(file);
       optionsProcessors.forEach(
           (OptionsProcessor p) => p.optionsProcessed(context, optionMap));
 
@@ skipping 97 matching lines @@
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }