CLI cleanup.

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 'package:analyzer/file_system/file_system.dart' as fileSystem;
+import 'package:analyzer/file_system/file_system.dart' as file_system;
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/plugin/embedded_resolver_provider.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/embedder.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';
@@ skipping 12 matching lines @@
 import 'package:analyzer/src/services/lint.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/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 pkgDiscovery;
+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.
 ///
@@ skipping 42 matching lines @@
 
   /// Collected analysis statistics.
   final AnalysisStats stats = new AnalysisStats();
 
   /// This Driver's current analysis context.
   ///
   /// *Visible for testing.*
   AnalysisContext get context => _context;
 
   @override
-  void set userDefinedPlugins(List<Plugin> plugins) {
+  set userDefinedPlugins(List<Plugin> plugins) {

[Brian Wilkerson, 2016/05/18 14:42:19]

Personally, I like having "void" for setters. I know that it's five whole extra
characters, but when you follow the rule that everything should be type
annotated, then "void" visually fills in the space where a type would have been
and I find it easier to visually scan the code.

(I don't expect you to agree with me or change this, but wanted you to know that
I disagree with that rule that says that it should be removed so that you
wouldn't take my lgtm to be approval of this kind of change.)

[pquitslund, 2016/05/18 17:26:40]

Got it.  It should come as no surprise that I tend to prefer eliding the
(gratuitous) void but that hardly matters.  Consistency is far more important. 
Changing back.

     _userDefinedPlugins = plugins ?? <Plugin>[];
   }
 
   @override
   void start(List<String> args) {
     if (_context != null) {
       throw new StateError("start() can only be called once");
     }
     int startTime = new DateTime.now().millisecondsSinceEpoch;
 
@@ skipping 206 matching lines @@
         // diagnostics. (Full parse is still needed for "self" packages.)
         return true;
       }
     };
   }
 
   /// Decide on the appropriate method for resolving URIs based on the given
   /// [options] and [customUrlMappings] settings, and return a
   /// [SourceFactory] that has been configured accordingly.
   SourceFactory _chooseUriResolutionPolicy(CommandLineOptions options,
-      Map<fileSystem.Folder, YamlMap> embedderMap, _PackageInfo packageInfo) {
+      Map<file_system.Folder, YamlMap> embedderMap, _PackageInfo packageInfo) {
     // Create a custom package resolver if one has been specified.
     if (packageResolverProvider != null) {
-      fileSystem.Folder folder =
+      file_system.Folder folder =
           PhysicalResourceProvider.INSTANCE.getResource('.');
       UriResolver resolver = packageResolverProvider(folder);
       if (resolver != null) {
         UriResolver sdkResolver;
 
         // Check for a resolver provider.
         if (embeddedUriResolverProvider != null) {
           EmbedderUriResolver embedderUriResolver =
               embeddedUriResolverProvider(folder);
           if (embedderUriResolver != null && embedderUriResolver.length != 0) {
@@ skipping 18 matching lines @@
 
     if (options.packageRootPath != null) {
       JavaFile packageDirectory = new JavaFile(options.packageRootPath);
       packageUriResolver = new PackageUriResolver([packageDirectory]);
     } else if (options.packageConfigPath == null) {
       // TODO(pq): remove?
       if (packageInfo.packageMap == null) {
         // Fall back to pub list-package-dirs.
         PubPackageMapProvider pubPackageMapProvider =
             new PubPackageMapProvider(PhysicalResourceProvider.INSTANCE, sdk);
-        fileSystem.Resource cwd =
+        file_system.Resource cwd =
             PhysicalResourceProvider.INSTANCE.getResource('.');
         PackageMapInfo packageMapInfo =
             pubPackageMapProvider.computePackageMap(cwd);
-        Map<String, List<fileSystem.Folder>> packageMap =
+        Map<String, List<file_system.Folder>> packageMap =
             packageMapInfo.packageMap;
 
         // Only create a packageUriResolver if pub list-package-dirs succeeded.
         // If it failed, that's not a problem; it simply means we have no way
         // to resolve packages.
         if (packageMapInfo.packageMap != null) {
           packageUriResolver = new PackageMapUriResolver(
               PhysicalResourceProvider.INSTANCE, packageMap);
         }
       }
@@ skipping 94 matching lines @@
         _chooseDietParsingPolicy(options);
     setAnalysisContextOptions(_context, options,
         (AnalysisOptionsImpl contextOptions) {
       contextOptions.analyzeFunctionBodiesPredicate = dietParsingPolicy;
     });
 
     // Find package info.
     _PackageInfo packageInfo = _findPackages(options);
 
     // Process embedders.
-    Map<fileSystem.Folder, YamlMap> embedderMap =
+    Map<file_system.Folder, YamlMap> embedderMap =
         _findEmbedders(packageInfo.packageMap);
 
     // Scan for SDK extenders.
     bool hasSdkExt = _hasSdkExt(packageInfo.packageMap?.values);
 
     // No summaries in the presence of embedders or extenders.
     bool useSummaries = embedderMap.isEmpty && !hasSdkExt;
 
     // Once options and embedders are processed, setup the SDK.
     _setupSdk(options, useSummaries);
 
     // Choose a package resolution policy and a diet parsing policy based on
     // the command-line options.
     SourceFactory sourceFactory =
         _chooseUriResolutionPolicy(options, embedderMap, packageInfo);
 
     _context.sourceFactory = sourceFactory;
   }
 
   /// Return discovered packagespec, or `null` if none is found.
   Packages _discoverPackagespec(Uri root) {
     try {
-      Packages packages = pkgDiscovery.findPackagesFromFile(root);
+      Packages packages = pkg_discovery.findPackagesFromFile(root);
       if (packages != Packages.noPackages) {
         return packages;
       }
     } catch (_) {
       // Ignore and fall through to null.
     }
 
     return null;
   }
 
-  Map<fileSystem.Folder, YamlMap> _findEmbedders(
-      Map<String, List<fileSystem.Folder>> packageMap) {
+  Map<file_system.Folder, YamlMap> _findEmbedders(
+      Map<String, List<file_system.Folder>> packageMap) {
     EmbedderYamlLocator locator =
         (_context as InternalAnalysisContext).embedderYamlLocator;
     locator.refresh(packageMap);
     return locator.embedderYamls;
   }
 
   _PackageInfo _findPackages(CommandLineOptions options) {
     if (packageResolverProvider != null) {
       // The resolver provider will do all the work later.
       return null;
     }
 
     Packages packages;
-    Map<String, List<fileSystem.Folder>> packageMap;
+    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;
         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
           .buildPackageMap(options.packageRootPath);
     } else {
-      fileSystem.Resource cwd =
+      file_system.Resource cwd =
           PhysicalResourceProvider.INSTANCE.getResource('.');
       // Look for .packages.
       packages = _discoverPackagespec(new Uri.directory(cwd.path));
       packageMap = _getPackageMap(packages);
     }
 
     return new _PackageInfo(packages, packageMap);
   }
 
-  Map<String, List<fileSystem.Folder>> _getPackageMap(Packages packages) {
+  Map<String, List<file_system.Folder>> _getPackageMap(Packages packages) {
     if (packages == null) {
       return null;
     }
 
-    Map<String, List<fileSystem.Folder>> folderMap =
-        new Map<String, List<fileSystem.Folder>>();
+    Map<String, List<file_system.Folder>> folderMap =
+        new Map<String, List<file_system.Folder>>();
     packages.asMap().forEach((String packagePath, Uri uri) {
       folderMap[packagePath] = [
         PhysicalResourceProvider.INSTANCE.getFolder(path.fromUri(uri))
       ];
     });
     return folderMap;
   }
 
-  bool _hasSdkExt(Iterable<List<fileSystem.Folder>> folders) {
+  bool _hasSdkExt(Iterable<List<file_system.Folder>> folders) {
     if (folders != null) {
       //TODO: ideally share this traversal with SdkExtUriResolver
-      for (Iterable<fileSystem.Folder> libDirs in folders) {
-        if (libDirs.any((fileSystem.Folder libDir) =>
+      for (Iterable<file_system.Folder> libDirs in folders) {
+        if (libDirs.any((file_system.Folder libDir) =>
             libDir.getChild(SdkExtUriResolver.SDK_EXT_NAME).exists)) {
           return true;
         }
       }
     }
     return false;
   }
 
   /// Returns `true` if this relative path is a hidden directory.
   bool _isInHiddenDir(String relative) =>
@@ skipping 59 matching lines @@
     contextOptions.lint = options.lints;
     contextOptions.strongMode = options.strongMode;
     return contextOptions;
   }
 
   static void setAnalysisContextOptions(
       AnalysisContext context,
       CommandLineOptions options,
       void configureContextOptions(AnalysisOptionsImpl contextOptions)) {
     Map<String, String> definedVariables = options.definedVariables;
-    if (!definedVariables.isEmpty) {
+    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();
     }
 
@@ skipping 15 matching lines @@
       return false;
     }
     for (String key in m1.keys) {
       if (!m2.containsKey(key) || m1[key] != m2[key]) {
         return false;
       }
     }
     return true;
   }
 
-  static fileSystem.File _getOptionsFile(CommandLineOptions options) {
-    fileSystem.File file;
+  static file_system.File _getOptionsFile(CommandLineOptions options) {
+    file_system.File file;
     String filePath = options.analysisOptionsFile;
     if (filePath != null) {
       file = PhysicalResourceProvider.INSTANCE.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);
       if (!file.exists) {
         filePath = AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
         file = PhysicalResourceProvider.INSTANCE.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) {
-    fileSystem.File file = _getOptionsFile(options);
+    file_system.File file = _getOptionsFile(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 71 matching lines @@
   }
 }
 
 class _DriverError implements Exception {
   String msg;
   _DriverError(this.msg);
 }
 
 class _PackageInfo {
   Packages packages;
-  Map<String, List<fileSystem.Folder>> packageMap;
+  Map<String, List<file_system.Folder>> packageMap;
   _PackageInfo(this.packages, this.packageMap);
 }
 
 /// [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<fileSystem.Folder>> buildPackageMap(
+  static Map<String, List<file_system.Folder>> buildPackageMap(
       String packageRootPath) {
     var packageRoot = new 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<fileSystem.Folder>>();
+    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;
   }
 }