New analyzer snapshot.

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'java_core.dart';
@@ skipping 1703 matching lines @@
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => _getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
   void set analysisOptions(AnalysisOptions options) {
-    bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || this._options.generateSdkErrors != options.generateSdkErrors || this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint) || this._options.preserveComments != options.preserveComments;
+    bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || this._options.generateSdkErrors != options.generateSdkErrors || this._options.enableDeferredLoading != options.enableDeferredLoading || this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint) || this._options.preserveComments != options.preserveComments;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
       //cache.setMaxCacheSize(cacheSize);
       _privatePartition.maxCacheSize = cacheSize;
       //
       // Cap the size of the priority list to being less than the cache size. Failure to do so can
       // result in an infinite loop in performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
         JavaSystem.arraycopy(_priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
         _priorityOrder = newPriorityOrder;
       }
     }
     this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
     this._options.generateSdkErrors = options.generateSdkErrors;
+    this._options.enableDeferredLoading = options.enableDeferredLoading;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.preserveComments = options.preserveComments;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
       _invalidateAllLocalResolutionInformation();
     }
   }
 
@@ skipping 4517 matching lines @@
   int get cacheSize;
 
   /**
    * Return `true` if analysis is to generate dart2js related hint results.
    *
    * @return `true` if analysis is to generate dart2js related hint results
    */
   bool get dart2jsHint;
 
   /**
+   * Return `true` if analysis is to include the new "deferred loading" support.
+   *
+   * @return `true` if analysis is to include the new "deferred loading" support
+   */
+  bool get enableDeferredLoading;
+
+  /**
    * Return `true` if errors, warnings and hints should be generated for sources in the SDK.
    * The default value is `false`.
    *
    * @return `true` if errors, warnings and hints should be generated for the SDK
    */
   bool get generateSdkErrors;
 
   /**
    * Return `true` if analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
@@ skipping 21 matching lines @@
  * Instances of the class `AnalysisOptions` represent a set of analysis options used to
  * control the behavior of an analysis context.
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
   /**
    * The maximum number of sources for which data should be kept in the cache.
    */
   static int DEFAULT_CACHE_SIZE = 64;
 
   /**
-   * The maximum number of sources for which AST structures should be kept in the cache.
+   * The default value for enabling deferred loading.
    */
-  int cacheSize = DEFAULT_CACHE_SIZE;
+  static bool DEFAULT_ENABLE_DEFERRED_LOADING = true;
+
+  /**
+   * A flag indicating whether analysis is to analyze Angular.
+   */
+  bool analyzeAngular = true;
 
   /**
    * A flag indicating whether analysis is to parse and analyze function bodies.
    */
   bool analyzeFunctionBodies = true;
 
   /**
+   * A flag indicating whether analysis is to analyze Polymer.
+   */
+  bool analyzePolymer = true;
+
+  /**
+   * The maximum number of sources for which AST structures should be kept in the cache.
+   */
+  int cacheSize = DEFAULT_CACHE_SIZE;
+
+  /**
    * A flag indicating whether analysis is to generate dart2js related hint results.
    */
   bool dart2jsHint = true;
 
   /**
+   * A flag indicating whether analysis is to enable deferred loading.
+   */
+  bool enableDeferredLoading = DEFAULT_ENABLE_DEFERRED_LOADING;
+
+  /**
    * A flag indicating whether errors, warnings and hints should be generated for sources in the
    * SDK.
    */
   bool _generateSdkErrors = false;
 
   /**
    * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
   bool hint = true;
 
   /**
    * A flag indicating whether incremental analysis should be used.
    */
   bool incremental = false;
 
   /**
    * A flag indicating whether analysis is to parse comments.
    */
   bool preserveComments = true;
 
   /**
-   * A flag indicating whether analysis is to analyze Angular.
-   */
-  bool analyzeAngular = true;
-
-  /**
-   * A flag indicating whether analysis is to analyze Polymer.
-   */
-  bool analyzePolymer = true;
-
-  /**
    * Initialize a newly created set of analysis options to have their default values.
    */
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values as those in the
    * given set of analysis options.
    *
    * @param options the analysis options whose values are being copied
    */
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
+    analyzeAngular = options.analyzeAngular;
+    analyzeFunctionBodies = options.analyzeFunctionBodies;
+    analyzePolymer = options.analyzePolymer;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
+    enableDeferredLoading = options.enableDeferredLoading;
+    _generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
+    preserveComments = options.preserveComments;
   }
 
   @override
   bool get generateSdkErrors => _generateSdkErrors;
 
   /**
    * Set whether errors, warnings and hints should be generated for sources in the SDK to match the
    * given value.
    *
    * @param generate `true` if errors, warnings and hints should be generated for sources in
@@ skipping 4039 matching lines @@
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       TypeProvider typeProvider = context.typeProvider;
       //
       // Validate the directives
       //
       validateDirectives(context, source, _unit, errorListener);
       //
       // Use the ConstantVerifier to verify the use of constants. This needs to happen before using
       // the ErrorVerifier because some error codes need the computed constant values.
       //
-      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
+      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, libraryElement, typeProvider);
       _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, new InheritanceManager(libraryElement));
       _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     } finally {
       timeCounter.stop();
     }
@@ skipping 2397 matching lines @@
 
   @override
   void internalPerform() {
     //
     // Then parse the token stream.
     //
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(source, errorListener);
-      parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
+      AnalysisOptions options = context.analysisOptions;
+      parser.parseFunctionBodies = options.analyzeFunctionBodies;
+      parser.parseDeferredLibraries = options.enableDeferredLoading;
       _unit = parser.parseCompilationUnit(_tokenStream);
       _unit.lineInfo = lineInfo;
       AnalysisContext analysisContext = context;
       for (Directive directive in _unit.directives) {
         if (directive is PartOfDirective) {
           _containsPartOfDirective = true;
         } else {
           _containsNonPartOfDirective = true;
           if (directive is UriBasedDirective) {
             Source referencedSource = resolveDirective(analysisContext, source, directive, errorListener);
@@ skipping 1505 matching lines @@
     ResolverVisitor resolverVisitor = new ResolverVisitor.con2(_libraryElement, source, typeProvider, inheritanceManager, errorListener);
     unit.accept(resolverVisitor);
     //
     // Perform additional error checking.
     //
     TimeCounter_TimeCounterHandle counterHandleErrors = PerformanceStatistics.errors.start();
     try {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, _libraryElement, typeProvider, inheritanceManager);
       unit.accept(errorVerifier);
-      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
+      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider);
       unit.accept(constantVerifier);
     } finally {
       counterHandleErrors.stop();
     }
     //
     // Capture the results.
     //
     _resolvedUnit = unit;
   }
 
@@ skipping 959 matching lines @@
     _index++;
     if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }