Replace uses of FileBasedSource 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';
+import 'dart:io' as io;
 
 import 'package:analyzer/file_system/file_system.dart' as file_system;
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/builder.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/interner.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_general.dart'
     show PerformanceTag;
 import 'package:analyzer/src/services/lint.dart';
+import 'package:analyzer/src/source/source_resource.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart' show SummaryBasedDartSdk;
 import 'package:analyzer/src/task/options.dart';
 import 'package:analyzer_cli/src/analyzer_impl.dart';
 import 'package:analyzer_cli/src/build_mode.dart';
 import 'package:analyzer_cli/src/error_formatter.dart';
 import 'package:analyzer_cli/src/incremental_analyzer.dart';
 import 'package:analyzer_cli/src/options.dart';
 import 'package:analyzer_cli/src/perf_report.dart';
 import 'package:analyzer_cli/starter.dart';
 import 'package:linter/src/plugin/linter_plugin.dart';
 import 'package:package_config/discovery.dart' as pkg_discovery;
 import 'package:package_config/packages.dart' show Packages;
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as path;
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 import 'package:yaml/yaml.dart';
 
 /// Shared IO sink for standard error reporting.
 ///
 /// *Visible for testing.*
-StringSink errorSink = stderr;
+StringSink errorSink = io.stderr;
 
 /// Shared IO sink for standard out reporting.
 ///
 /// *Visible for testing.*
-StringSink outSink = stdout;
+StringSink outSink = io.stdout;
 
 /// Test this option map to see if it specifies lint rules.
 bool containsLintRuleEntry(Map<String, YamlNode> options) {
   var linterNode = options['linter'];
   return linterNode is YamlMap && linterNode.containsKey('rules');
 }
 
 typedef ErrorSeverity _BatchRunnerHandler(List<String> args);
 
 class Driver implements CommandLineStarter {
@@ skipping 53 matching lines @@
     _processPlugins();
 
     // Parse commandline options.
     CommandLineOptions options = CommandLineOptions.parse(args);
 
     // Do analysis.
     if (options.buildMode) {
       ErrorSeverity severity = _buildModeAnalyze(options);
       // In case of error propagate exit code.
       if (severity == ErrorSeverity.ERROR) {
-        exitCode = severity.ordinal;
+        io.exitCode = severity.ordinal;
       }
     } else if (options.shouldBatch) {
       _BatchRunner.runAsBatch(args, (List<String> args) {
         CommandLineOptions options = CommandLineOptions.parse(args);
         return _analyzeAll(options);
       });
     } else {
       ErrorSeverity severity = _analyzeAll(options);
       // In case of error propagate exit code.
       if (severity == ErrorSeverity.ERROR) {
-        exitCode = severity.ordinal;
+        io.exitCode = severity.ordinal;
       }
     }
 
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
     if (options.perfReport != null) {
       String json = makePerfReport(
           startTime, currentTimeMillis(), options, _analyzedFileCount, stats);
-      new File(options.perfReport).writeAsStringSync(json);
+      new io.File(options.perfReport).writeAsStringSync(json);
     }
   }
 
   ErrorSeverity _analyzeAll(CommandLineOptions options) {
     return _analyzeAllTag.makeCurrentWhile(() {
       return _analyzeAllImpl(options);
     });
   }
 
   /// Perform analysis according to the given [options].
@@ skipping 16 matching lines @@
     Set<Source> knownSources = context.sources.toSet();
     List<Source> sourcesToAnalyze = <Source>[];
     ChangeSet changeSet = new ChangeSet();
     for (String sourcePath in options.sourceFiles) {
       sourcePath = sourcePath.trim();
 
       // Collect files for analysis.
       // Note that these files will all be analyzed in the same context.
       // This should be updated when the ContextManager re-work is complete
       // (See: https://github.com/dart-lang/sdk/issues/24133)
-      Iterable<File> files = _collectFiles(sourcePath);
+      Iterable<io.File> files = _collectFiles(sourcePath);
       if (files.isEmpty) {
         errorSink.writeln('No dart files found at: $sourcePath');
-        exitCode = ErrorSeverity.ERROR.ordinal;
+        io.exitCode = ErrorSeverity.ERROR.ordinal;
         return ErrorSeverity.ERROR;
       }
 
-      for (File file in files) {
+      for (io.File file in files) {
         Source source = _computeLibrarySource(file.absolute.path);
         if (!knownSources.contains(source)) {
           changeSet.addedSource(source);
         }
         sourcesToAnalyze.add(source);
       }
     }
     context.applyChanges(changeSet);
 
     // Analyze the libraries.
@@ skipping 16 matching lines @@
     for (Source part in parts) {
       bool found = false;
       for (var lib in context.getLibrariesContaining(part)) {
         if (libUris.contains(lib.uri)) {
           found = true;
         }
       }
       if (!found) {
         errorSink.writeln("${part.fullName} is a part and cannot be analyzed.");
         errorSink.writeln("Please pass in a library that contains this part.");
-        exitCode = ErrorSeverity.ERROR.ordinal;
+        io.exitCode = ErrorSeverity.ERROR.ordinal;
         allResult = allResult.max(ErrorSeverity.ERROR);
       }
     }
 
     if (!options.machineFormat) {
       stats.print(outSink);
     }
 
     return allResult;
   }
@@ skipping 167 matching lines @@
     }
 
     // Finally files.
     resolvers.add(new file_system.ResourceUriResolver(resourceProvider));
 
     return new SourceFactory(resolvers, packageInfo.packages);
   }
 
   /// Collect all analyzable files at [filePath], recursively if it's a
   /// directory, ignoring links.
-  Iterable<File> _collectFiles(String filePath) {
-    List<File> files = <File>[];
-    File file = new File(filePath);
+  Iterable<io.File> _collectFiles(String filePath) {
+    List<io.File> files = <io.File>[];
+    io.File file = new io.File(filePath);
     if (file.existsSync()) {
       files.add(file);
     } else {
-      Directory directory = new Directory(filePath);
+      io.Directory directory = new io.Directory(filePath);
       if (directory.existsSync()) {
-        for (FileSystemEntity entry
+        for (io.FileSystemEntity entry
             in directory.listSync(recursive: true, followLinks: false)) {
           String relative = path.relative(entry.path, from: directory.path);
           if (AnalysisEngine.isDartFileName(entry.path) &&
               !_isInHiddenDir(relative)) {
             files.add(entry);
           }
         }
       }
     }
     return files;
   }
 
   /// Convert the given [sourcePath] (which may be relative to the current
   /// working directory) to a [Source] object that can be fed to the analysis
   /// context.
   Source _computeLibrarySource(String sourcePath) {
     sourcePath = _normalizeSourcePath(sourcePath);
-    JavaFile sourceFile = new JavaFile(sourcePath);
-    Source source = sdk.fromFileUri(sourceFile.toURI());
+    File sourceFile = resourceProvider.getFile(sourcePath);
+    Source source = sdk.fromFileUri(sourceFile.toUri());
     if (source != null) {
       return source;
     }
-    source = new FileBasedSource(sourceFile, sourceFile.toURI());
+    source = new FileSource(sourceFile, sourceFile.toUri());
     Uri uri = _context.sourceFactory.restoreUri(source);
     if (uri == null) {
       return source;
     }
-    return new FileBasedSource(sourceFile, uri);
+    return new FileSource(sourceFile, uri);
   }
 
   /// Create an analysis context that is prepared to analyze sources according
   /// to the given [options], and store it in [_context].
   void _createAnalysisContext(CommandLineOptions options) {
     if (_canContextBeReused(options)) {
       return;
     }
     _previousOptions = options;
 
@@ skipping 58 matching lines @@
       return new _PackageInfo(null, null);
     }
 
     Packages packages;
     Map<String, List<file_system.Folder>> packageMap;
 
     if (options.packageConfigPath != null) {
       String packageConfigPath = options.packageConfigPath;
       Uri fileUri = new Uri.file(packageConfigPath);
       try {
-        File configFile = new File.fromUri(fileUri).absolute;
+        io.File configFile = new io.File.fromUri(fileUri).absolute;
         List<int> bytes = configFile.readAsBytesSync();
         Map<String, Uri> map = pkgfile.parse(bytes, configFile.uri);
         packages = new MapPackages(map);
         packageMap = _getPackageMap(packages);
       } catch (e) {
         printAndFail(
             'Unable to read package config data from $packageConfigPath: $e');
       }
     } else if (options.packageRootPath != null) {
       packageMap = _PackageRootPackageMapBuilder
@@ skipping 50 matching lines @@
     manager.processPlugins(plugins);
   }
 
   /// Analyze a single source.
   ErrorSeverity _runAnalyzer(Source source, CommandLineOptions options) {
     int startTime = currentTimeMillis();
     AnalyzerImpl analyzer = new AnalyzerImpl(
         _context, incrementalSession, source, options, stats, startTime);
     var errorSeverity = analyzer.analyzeSync();
     if (errorSeverity == ErrorSeverity.ERROR) {
-      exitCode = errorSeverity.ordinal;
+      io.exitCode = errorSeverity.ordinal;
     }
     if (options.warningsAreFatal && errorSeverity == ErrorSeverity.WARNING) {
-      exitCode = errorSeverity.ordinal;
+      io.exitCode = errorSeverity.ordinal;
     }
     return errorSeverity;
   }
 
   void _setupSdk(CommandLineOptions options, bool useSummaries) {
     if (sdk == null) {
       if (options.dartSdkSummaryPath != null) {
         sdk = new SummaryBasedDartSdk(
             options.dartSdkSummaryPath, options.strongMode);
       } else {
@@ skipping 88 matching lines @@
       if (!file.exists) {
         filePath = AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
         file = resourceProvider.getFile(filePath);
       }
     }
     return file;
   }
 
   /// Convert [sourcePath] into an absolute path.
   static String _normalizeSourcePath(String sourcePath) =>
-      path.normalize(new File(sourcePath).absolute.path);
+      path.normalize(new io.File(sourcePath).absolute.path);
 
   static void _processAnalysisOptions(
       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 =
@@ skipping 27 matching lines @@
   /// use in unit testing.
   static void runAsBatch(List<String> sharedArgs, _BatchRunnerHandler handler) {
     outSink.writeln('>>> BATCH START');
     Stopwatch stopwatch = new Stopwatch();
     stopwatch.start();
     int testsFailed = 0;
     int totalTests = 0;
     ErrorSeverity batchResult = ErrorSeverity.NONE;
     // Read line from stdin.
     Stream cmdLine =
-        stdin.transform(UTF8.decoder).transform(new LineSplitter());
+        io.stdin.transform(UTF8.decoder).transform(new LineSplitter());
     cmdLine.listen((String line) {
       // Maybe finish.
       if (line.isEmpty) {
         var time = stopwatch.elapsedMilliseconds;
         outSink.writeln(
             '>>> BATCH END (${totalTests - testsFailed}/$totalTests) ${time}ms');
-        exitCode = batchResult.ordinal;
+        io.exitCode = batchResult.ordinal;
       }
       // Prepare arguments.
       var lineArgs = line.split(new RegExp('\\s+'));
       var args = new List<String>();
       args.addAll(sharedArgs);
       args.addAll(lineArgs);
       args.remove('-b');
       args.remove('--batch');
       // Analyze single set of arguments.
       try {
@@ skipping 31 matching lines @@
 }
 
 /// [SdkExtUriResolver] needs a Map from package name to folder. In the case
 /// that the analyzer is invoked with a --package-root option, we need to
 /// manually create this mapping. Given [packageRootPath],
 /// [_PackageRootPackageMapBuilder] creates a simple mapping from package name
 /// to full path on disk (resolving any symbolic links).
 class _PackageRootPackageMapBuilder {
   static Map<String, List<file_system.Folder>> buildPackageMap(
       String packageRootPath) {
-    var packageRoot = new Directory(packageRootPath);
+    var packageRoot = new io.Directory(packageRootPath);
     if (!packageRoot.existsSync()) {
       throw new _DriverError(
           'Package root directory ($packageRootPath) does not exist.');
     }
     var packages = packageRoot.listSync(followLinks: false);
     var result = new Map<String, List<file_system.Folder>>();
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }