implement default analysis options in bazel

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';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/command_line/arguments.dart'
     show applyAnalysisOptionFlags;
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart'
     show AnalysisDriver, AnalysisDriverScheduler, PerformanceLog;
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/bazel.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/gn.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/workspace.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/pub_summary.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:analyzer/src/task/options.dart';
 import 'package:args/args.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart';
 import 'package:package_config/src/packages_impl.dart';
 import 'package:path/src/context.dart';
 import 'package:yaml/yaml.dart';
@@ skipping 201 matching lines @@
     }
     String directoryPath = builderOptions.defaultPackagesDirectoryPath;
     if (directoryPath != null) {
       Folder folder = resourceProvider.getFolder(directoryPath);
       return getPackagesFromFolder(folder);
     }
     return findPackagesFromFile(rootDirectoryPath);
   }
 
   SourceFactory createSourceFactory(String rootPath, AnalysisOptions options) {
-    BazelWorkspace bazelWorkspace =
-        BazelWorkspace.find(resourceProvider, rootPath);
-    if (bazelWorkspace != null) {
-      List<UriResolver> resolvers = <UriResolver>[
-        new DartUriResolver(findSdk(null, options)),
-        new BazelPackageUriResolver(bazelWorkspace),
-        new BazelFileUriResolver(bazelWorkspace)
-      ];
-      return new SourceFactory(resolvers, null, resourceProvider);
-    }
+    Workspace workspace = createWorkspace(rootPath);
+    DartSdk sdk = findSdk(workspace.packageMap, options);
+    return workspace.createSourceFactory(sdk);
+  }
 
-    GnWorkspace gnWorkspace = GnWorkspace.find(resourceProvider, rootPath);
-    if (gnWorkspace != null) {
-      DartSdk sdk = findSdk(gnWorkspace.packageMap, options);
-      List<UriResolver> resolvers = <UriResolver>[
-        new DartUriResolver(sdk),
-        new GnPackageUriResolver(gnWorkspace),
-        new GnFileUriResolver(gnWorkspace)
-      ];
-      return new SourceFactory(resolvers, null, resourceProvider);
-    }
-
-    Packages packages = createPackageMap(rootPath);
-    Map<String, List<Folder>> packageMap = convertPackagesToMap(packages);
-    List<UriResolver> resolvers = <UriResolver>[
-      new DartUriResolver(findSdk(packageMap, options)),
-      new PackageMapUriResolver(resourceProvider, packageMap),
-      new ResourceUriResolver(resourceProvider)
-    ];
-    return new SourceFactory(resolvers, packages, resourceProvider);
+  Workspace createWorkspace(String rootPath) {
+    Workspace workspace = BazelWorkspace.find(resourceProvider, rootPath);
+    workspace ??= GnWorkspace.find(resourceProvider, rootPath);
+    return workspace ?? _BasicWorkspace.find(resourceProvider, rootPath, this);
   }
 
   /**
    * Add any [declaredVariables] to the list of declared variables used by the
    * given [context].
    */
   void declareVariables(InternalAnalysisContext context) {
     Map<String, String> variables = builderOptions.declaredVariables;
     if (variables != null && variables.isNotEmpty) {
       DeclaredVariables contextVariables = context.declaredVariables;
@@ skipping 109 matching lines @@
       sdk.useSummary = sdkManager.canUseSummaries;
       return sdk;
     });
   }
 
   /**
    * Return the analysis options that should be used to analyze code in the
    * directory with the given [path].
    */
   AnalysisOptions getAnalysisOptions(String path) {
+    // 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) {
-      // TODO(danrubel) restructure so that we don't recalculate the package map
-      // more than once per path.
-      Packages packages = createPackageMap(path);
-      Map<String, List<Folder>> packageMap = convertPackagesToMap(packages);
-      List<UriResolver> resolvers = <UriResolver>[
-        new ResourceUriResolver(resourceProvider),
-        new PackageMapUriResolver(resourceProvider, packageMap),
-      ];
-      SourceFactory sourceFactory =
-          new SourceFactory(resolvers, packages, resourceProvider);
       try {
-        Map<String, YamlNode> optionMap =
-            new AnalysisOptionsProvider(sourceFactory)
-                .getOptionsFromFile(optionsFile);
-        applyToAnalysisOptions(options, optionMap);
+        optionMap = optionsProvider.getOptionsFromFile(optionsFile);
       } catch (_) {
         // Ignore exceptions thrown while trying to load the options file.
       }
+    } else {
+      // Search for the default analysis options
+      Source source;
+      // TODO(danrubel) check for flutter and use default flutter options
+      source =

[Brian Wilkerson, 2017/01/30 14:56:05]

Merge initialization with declaration?

[danrubel, 2017/01/30 19:00:44]

Done.

+          sourceFactory.forUri('package:dart.analysis_options/default.yaml');
+      if (source.exists()) {
+        try {
+          optionMap = optionsProvider.getOptionsFromSource(source);
+        } catch (_) {
+          // Ignore exceptions thrown while trying to load the options file.
+        }
+      }
+    }
+
+    if (optionMap != null) {
+      applyToAnalysisOptions(options, optionMap);
       if (builderOptions.argResults != null) {
         applyAnalysisOptionFlags(options, builderOptions.argResults);
       }
     }
     return options;
   }
 
   /**
    * Return the analysis options file that should be used when analyzing code in
    * the directory with the given [path].
@@ skipping 266 matching lines @@
   String _readEmbedderYaml(Folder libDir) {
     File file = libDir.getChild(EMBEDDER_FILE_NAME);
     try {
       return file.readAsStringSync();
     } on FileSystemException {
       // File can't be read.
       return null;
     }
   }
 }
+
+/**
+ * Information about a default Dart workspace.
+ */
+class _BasicWorkspace extends Workspace {
+  /**
+   * The [ResourceProvider] by which paths are converted into [Resource]s.
+   */
+  final ResourceProvider provider;
+
+  /**
+   * The absolute workspace root path (the directory containing the `.jiri_root`
+   * directory).
+   */
+  final String root;
+
+  final ContextBuilder _builder;
+
+  Map<String, List<Folder>> _packageMap;
+
+  Packages _packages;
+
+  _BasicWorkspace._(this.provider, this.root, this._builder);
+
+  @override
+  Map<String, List<Folder>> get packageMap {
+    _packageMap ??= _builder.convertPackagesToMap(packages);
+    return _packageMap;
+  }
+
+  Packages get packages {
+    _packages ??= _builder.createPackageMap(root);
+    return _packages;
+  }
+
+  @override
+  UriResolver get packageUriResolver =>
+      new PackageMapUriResolver(provider, packageMap);
+
+  @override
+  SourceFactory createSourceFactory(DartSdk sdk) {
+    List<UriResolver> resolvers = <UriResolver>[];
+    if (sdk != null) {
+      resolvers.add(new DartUriResolver(sdk));
+    }
+    resolvers.add(packageUriResolver);
+    resolvers.add(new ResourceUriResolver(provider));
+    return new SourceFactory(resolvers, packages, provider);
+  }
+
+  /**
+   * Find the basic workspace that contains the given [path].
+   */
+  static _BasicWorkspace find(
+      ResourceProvider resourceProvider, String path, ContextBuilder builder) {
+    return new _BasicWorkspace._(resourceProvider, path, builder);
+  }
+}