echo analysis options information if dartanalyzer --verbose is specified

pkg/analyzer/lib/src/context/builder.dart

 // Copyright (c) 2016, 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.src.context.context_builder;
 
 import 'dart:collection';
 import 'dart:core';
 
 import 'package:analyzer/context/declared_variables.dart';
@@ skipping 348 matching lines @@
       FolderBasedDartSdk sdk = new FolderBasedDartSdk(resourceProvider,
           resourceProvider.getFolder(sdkPath), analysisOptions.strongMode);
       sdk.analysisOptions = analysisOptions;
       sdk.useSummary = sdkManager.canUseSummaries;
       return sdk;
     });
   }
 
   /**
    * Return the analysis options that should be used to analyze code in the
-   * directory with the given [path].
+   * directory with the given [path]. Use [verbosePrint] to echo verbose
+   * information about the analysis options selection process.
    */
-  AnalysisOptions getAnalysisOptions(String path) {
+  AnalysisOptions getAnalysisOptions(String path,
+      {void verbosePrint(String text)}) {
+    void verbose(String text) {
+      if (verbosePrint != null) {
+        verbosePrint(text);
+      }
+    }
+
     // TODO(danrubel) restructure so that we don't create a workspace
     // both here and in createSourceFactory
     Workspace workspace = createWorkspace(path);
     SourceFactory sourceFactory = workspace.createSourceFactory(null);
     AnalysisOptionsProvider optionsProvider =
         new AnalysisOptionsProvider(sourceFactory);
 
     AnalysisOptionsImpl options = createDefaultOptions();
     File optionsFile = getOptionsFile(path);
     Map<String, YamlNode> optionMap;
 
     if (optionsFile != null) {
       try {
         optionMap = optionsProvider.getOptionsFromFile(optionsFile);
-      } catch (_) {
+        verbose('Loaded analysis options from ${optionsFile.path}');
+      } catch (e) {
         // Ignore exceptions thrown while trying to load the options file.
+        verbose('Exception: $e\n  when loading ${optionsFile.path}');
       }
     } else {
       // Search for the default analysis options
       Source source;
       // TODO(danrubel) determine if bazel or gn project depends upon flutter
       if (workspace.hasFlutterDependency) {
         source =
             sourceFactory.forUri('package:flutter/analysis_options_user.yaml');
       }
       if (source == null || !source.exists()) {
         source =
             sourceFactory.forUri('package:dart.analysis_options/default.yaml');
       }
       if (source.exists()) {
         try {
           optionMap = optionsProvider.getOptionsFromSource(source);
-        } catch (_) {
+          verbose('Loaded analysis options from ${source.fullName}');
+        } catch (e) {
           // Ignore exceptions thrown while trying to load the options file.
+          verbose('Exception: $e\n  when loading ${source.fullName}');
         }
       }
     }
 
     if (optionMap != null) {
       applyToAnalysisOptions(options, optionMap);
       if (builderOptions.argResults != null) {
-        applyAnalysisOptionFlags(options, builderOptions.argResults);
+        applyAnalysisOptionFlags(options, builderOptions.argResults,
+            verbosePrint: verbosePrint);
         // If lints turned on but none specified, then enable default lints
         if (options.lint && options.lintRules.isEmpty) {
           options.lintRules = Registry.ruleRegistry.defaultRules;
+          verbose('Using default lint rules');
         }
       }
+    } else {
+      verbose('Using default analysis options');
     }
     return options;
   }
 
   /**
    * Return the analysis options file that should be used when analyzing code in
    * the directory with the given [path].
    */
   File getOptionsFile(String path) {
     String filePath = builderOptions.defaultAnalysisOptionsFilePath;
@@ skipping 344 matching lines @@
 
     // Ensure that the path is absolute and normalized.
     if (!context.isAbsolute(path)) {
       throw new ArgumentError('not absolute: $path');
     }
     path = context.normalize(path);
 
     return new _BasicWorkspace._(provider, path, builder);
   }
 }