Add _embedder.yaml support to analyzer and analysis_server

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, 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 engine;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
+import 'package:analyzer/source/embedder.dart';
 import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/context/cache.dart' as cache;
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/incremental_resolution_validator.dart';
 import 'package:analyzer/src/plugin/command_line_plugin.dart';
 import 'package:analyzer/src/plugin/engine_plugin.dart';
 import 'package:analyzer/src/plugin/options_plugin.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/dart.dart';
@@ skipping 302 matching lines @@
    */
   AnalysisOptions get analysisOptions;
 
   /**
    * Set the set of analysis options controlling the behavior of this context to
    * the given [options]. Clients can safely assume that all necessary analysis
    * results have been invalidated.
    */
   void set analysisOptions(AnalysisOptions options);
 
+  /// Return the [EmbedderYamlLocator] for with this context.
+  EmbedderYamlLocator get embedderYamlLocator;

[pquitslund, 2015/11/12 17:43:09]

I'll defer to Brian as to whether we need this in the legacy `AnalysisContext`,
which is on the brink of disappearing.  Either way, I'd hope we could avoid this
leaking into API.  (That is keep it just in the impl.)

[Brian Wilkerson, 2015/11/13 19:54:18]

So to be clear, AnalysisContext is the public interface for analysis contexts,
and it won't be going away. (The class AnalysisContextImpl in this file will be
going away.)

But I agree, we don't want this in the public API.

It's kind of hard to search for uses in the code review tool, so I can't see
where this getter is being used, but the way we typically handle this is to add
an API like this to InternalAnalysisContext. Most of our code already uses that
interface rather than the public interface, so the getter would likely still be
available where you need it.

[Cutch, 2015/11/14 00:15:17]

Moved to InternalAnalysisContext.

+
   /**
    * Set the order in which sources will be analyzed by [performAnalysisTask] to
    * match the order of the sources in the given list of [sources]. If a source
    * that needs to be analyzed is not contained in the list, then it will be
    * treated as if it were at the end of the list. If the list is empty (or
    * `null`) then no sources will be given priority over other sources.
    *
    * Changes made to the list after this method returns will <b>not</b> be
    * reflected in the priority order.
    */
@@ skipping 614 matching lines @@
    * Configuration data associated with this context.
    */
   final HashMap<ResultDescriptor, Object> _configurationData =
       new HashMap<ResultDescriptor, Object>();
 
   /**
    * The set of analysis options controlling the behavior of this context.
    */
   AnalysisOptionsImpl _options = new AnalysisOptionsImpl();
 
+  /// The embedder yaml locator for this context.
+  EmbedderYamlLocator _embedderYamlLocator = new EmbedderYamlLocator(null);
+
   /**
    * A flag indicating whether errors related to implicitly analyzed sources
    * should be generated and reported.
    */
   bool _generateImplicitErrors = true;
 
   /**
    * A flag indicating whether errors related to sources in the SDK should be
    * generated and reported.
    */
@@ skipping 172 matching lines @@
         new StreamController<ImplicitAnalysisEvent>.broadcast();
   }
 
   @override
   AnalysisCache get analysisCache => _cache;
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
+  EmbedderYamlLocator get embedderYamlLocator => _embedderYamlLocator;
+  
+  @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateImplicitErrors !=
             options.generateImplicitErrors ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         this._options.dart2jsHint != options.dart2jsHint ||
         (this._options.hint && !options.hint) ||
         this._options.preserveComments != options.preserveComments ||
         this._options.strongMode != options.strongMode ||
@@ skipping 10944 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }