Convert analysis server over to use ContextBuilder

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' hide Resource;
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/file_system/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_resolver.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/options.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';
 
 /**
  * A utility class used to build an analysis context for a given directory.
  *
  * The construction of analysis contexts is as follows:
  *
  * 1. Determine how package: URI's are to be resolved. This follows the lookup
  *    algorithm defined by the [package specification][1].
  *
@@ skipping 81 matching lines @@
    */
   ContextBuilder(this.resourceProvider, this.sdkManager, this.contentCache);
 
   /**
    * Return an analysis context that is configured correctly to analyze code in
    * the directory with the given [path].
    *
    * *Note:* This method is not yet fully implemented and should not be used.
    */
   AnalysisContext buildContext(String path) {
-    // TODO(brianwilkerson) Split getAnalysisOptions so we can capture the
-    // option map and use it to run the options processors.
-    AnalysisOptions options = getAnalysisOptions(path);
     InternalAnalysisContext context =
         AnalysisEngine.instance.createAnalysisContext();
+    AnalysisOptions options = getAnalysisOptions(context, path);
     context.contentCache = contentCache;
     context.sourceFactory = createSourceFactory(path, options);
     context.analysisOptions = options;
     //_processAnalysisOptions(context, optionMap);
     declareVariables(context);
     return context;
   }
 
   Map<String, List<Folder>> convertPackagesToMap(Packages packages) {
     if (packages == null || packages == Packages.noPackages) {
@@ skipping 38 matching lines @@
       return new AnalysisOptionsImpl();
     }
     return new AnalysisOptionsImpl.from(defaultOptions);
   }
 
   Packages createPackageMap(String rootDirectoryPath) {
     if (defaultPackageFilePath != null) {
       File configFile = resourceProvider.getFile(defaultPackageFilePath);
       List<int> bytes = configFile.readAsBytesSync();
       Map<String, Uri> map = parse(bytes, configFile.toUri());
+      resolveSymbolicLinks(map);
       return new MapPackages(map);
     } else if (defaultPackagesDirectoryPath != null) {
       Folder folder = resourceProvider.getFolder(defaultPackagesDirectoryPath);
       return getPackagesFromFolder(folder);
     }
     return findPackagesFromFile(rootDirectoryPath);
   }
 
   SourceFactory createSourceFactory(
       String rootDirectoryPath, AnalysisOptions options) {
@@ skipping 11 matching lines @@
       UriResolver packageResolver = packageResolverProvider(folder());
       if (packageResolver != null) {
         // TODO(brianwilkerson) This doesn't support either embedder files or
         // sdk extensions because we don't have a way to get the package map
         // from the resolver.
         List<UriResolver> resolvers = <UriResolver>[
           new DartUriResolver(findSdk(null, options)),
           packageResolver,
           fileResolver
         ];
-        return new SourceFactory(resolvers);
+        return new SourceFactory(resolvers, null, resourceProvider);
       }
     }
     Packages packages = createPackageMap(rootDirectoryPath);
     Map<String, List<Folder>> packageMap = convertPackagesToMap(packages);
     List<UriResolver> resolvers = <UriResolver>[];
     resolvers.add(new DartUriResolver(findSdk(packageMap, options)));
     if (packageMap != null) {
       // TODO(brianwilkerson) I think that we don't need a PackageUriResolver
       // when we can pass the packages object to the source factory directly.
+      // Actually, I think we're using it to restoreUri, which could lead to
+      // inconsistencies.
       resolvers.add(new PackageMapUriResolver(resourceProvider, packageMap));
     }
     resolvers.add(fileResolver);
-    return new SourceFactory(resolvers);
+    return new SourceFactory(resolvers, packages, resourceProvider);
   }
 
   /**
    * Add any [declaredVariables] to the list of declared variables used by the
    * given [context].
    */
   void declareVariables(InternalAnalysisContext context) {
     if (declaredVariables != null && declaredVariables.isNotEmpty) {
       DeclaredVariables contextVariables = context.declaredVariables;
       declaredVariables.forEach((String variableName, String value) {
@@ skipping 11 matching lines @@
    * directory in the same place. If that also fails, it starts checking parent
    * directories for a `.packages` file, and stops if it finds it. Otherwise it
    * gives up and returns [Packages.noPackages].
    */
   Packages findPackagesFromFile(String path) {
     Resource location = _findPackagesLocation(path);
     if (location is File) {
       List<int> fileBytes = location.readAsBytesSync();
       Map<String, Uri> map =
           parse(fileBytes, resourceProvider.pathContext.toUri(location.path));
+      resolveSymbolicLinks(map);
       return new MapPackages(map);
     } else if (location is Folder) {
       return getPackagesFromFolder(location);
     }
     return Packages.noPackages;
   }
 
   /**
    * Return the SDK that should be used to analyze code. Use the given
    * [packageMap] and [options] to locate the SDK.
@@ skipping 54 matching lines @@
     return sdkManager.getSdk(description, () {
       FolderBasedDartSdk sdk = new FolderBasedDartSdk(
           resourceProvider, resourceProvider.getFolder(sdkPath));
       sdk.analysisOptions = options;
       sdk.useSummary = sdkManager.canUseSummaries;
       return sdk;
     });
   }
 
   /**
-   * Return the analysis options that should be used when analyzing code in the
-   * directory with the given [path].
+   * Return the analysis options that should be used when the given [context] is
+   * used to analyze code in the directory with the given [path].
    */
-  AnalysisOptions getAnalysisOptions(String path) {
+  AnalysisOptions getAnalysisOptions(AnalysisContext context, String path) {
     AnalysisOptionsImpl options = createDefaultOptions();
     File optionsFile = getOptionsFile(path);
     if (optionsFile != null) {
-      Map<String, YamlNode> fileOptions =
-          new AnalysisOptionsProvider().getOptionsFromFile(optionsFile);
-      applyToAnalysisOptions(options, fileOptions);
+      List<OptionsProcessor> optionsProcessors =
+          AnalysisEngine.instance.optionsPlugin.optionsProcessors;
+      try {
+        Map<String, YamlNode> optionMap =
+            new AnalysisOptionsProvider().getOptionsFromFile(optionsFile);
+        optionsProcessors.forEach(
+            (OptionsProcessor p) => p.optionsProcessed(context, optionMap));
+        applyToAnalysisOptions(options, optionMap);
+      } on Exception catch (exception) {
+        optionsProcessors.forEach((OptionsProcessor p) => p.onError(exception));
+      }
     }
     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) {
     if (defaultAnalysisOptionsFilePath != null) {
@@ skipping 15 matching lines @@
     return null;
   }
 
   /**
    * Create a [Packages] object for a 'package' directory ([folder]).
    *
    * Package names are resolved as relative to sub-directories of the package
    * directory.
    */
   Packages getPackagesFromFolder(Folder folder) {
+    Context pathContext = resourceProvider.pathContext;
     Map<String, Uri> map = new HashMap<String, Uri>();
     for (Resource child in folder.getChildren()) {
       if (child is Folder) {
-        String packageName = resourceProvider.pathContext.basename(child.path);
-        // Create a file URI (rather than a directory URI) and add a '.' so that
-        // the URI is suitable for resolving relative URI's against it.
-        //
-        // TODO(brianwilkerson) Decide whether we need to pass in a 'windows:'
-        // argument for testing purposes.
-        map[packageName] = resourceProvider.pathContext.toUri(
-            resourceProvider.pathContext.join(folder.path, packageName, '.'));
+        // Inline resolveSymbolicLinks for performance reasons.
+        String packageName = pathContext.basename(child.path);
+        String folderPath = resolveSymbolicLink(child);
+        String uriPath = pathContext.join(folderPath, '.');
+        map[packageName] = pathContext.toUri(uriPath);
       }
     }
     return new MapPackages(map);
   }
 
   /**
+   * Resolve any symbolic links encoded in the path to the given [folder].
+   */
+  String resolveSymbolicLink(Folder folder) {
+    try {
+      return folder.resolveSymbolicLinksSync().path;
+    } on FileSystemException {
+      return folder.path;
+    }
+  }
+
+  /**
+   * Resolve any symbolic links encoded in the URI's in the given [map] by
+   * replacing the values in the map.
+   */
+  void resolveSymbolicLinks(Map<String, Uri> map) {
+    Context pathContext = resourceProvider.pathContext;
+    for (String packageName in map.keys) {
+      Folder folder =
+          resourceProvider.getFolder(pathContext.fromUri(map[packageName]));
+      String folderPath = resolveSymbolicLink(folder);
+      // Add a '.' so that the URI is suitable for resolving relative URI's
+      // against it.
+      String uriPath = pathContext.join(folderPath, '.');
+      map[packageName] = pathContext.toUri(uriPath);
+    }
+  }
+
+  /**
    * Find the location of the package resolution file/directory for the
    * directory at the given absolute [path].
    *
    * Checks for a `.packages` file in the [path]. If not found,
    * checks for a `packages` directory in the same directory. If still not
    * found, starts checking parent directories for `.packages` until reaching
    * the root directory.
    *
    * Return a [File] object representing a `.packages` file if one is found, a
    * [Folder] object for the `packages/` directory if that is found, or `null`
@@ skipping 122 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;
     }
   }
 }