Enable enum and deferred import support

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 "dart:math" as math;
@@ skipping 1045 matching lines @@
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute =
         this._options.analyzeAngular != options.analyzeAngular ||
         this._options.analyzeFunctionBodies != options.analyzeFunctionBodies ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
-        this._options.enableDeferredLoading != options.enableDeferredLoading ||
-        this._options.enableEnum != options.enableEnum ||
         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.analyzeAngular = options.analyzeAngular;
     this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
     this._options.generateSdkErrors = options.generateSdkErrors;
-    this._options.enableDeferredLoading = options.enableDeferredLoading;
-    this._options.enableEnum = options.enableEnum;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.incrementalApi = options.incrementalApi;
     this._options.incrementalValidation = options.incrementalValidation;
     this._options.preserveComments = options.preserveComments;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
       _invalidateAllLocalResolutionInformation(false);
     }
@@ skipping 4763 matching lines @@
    */
   List<AnalysisContextStatistics_PartitionData> get partitionData;
 
   /**
    * Return an array containing all of the sources in the cache.
    */
   List<Source> get sources;
 }
 
 /**
- * Information about single piece of data in the cache.
- */
-abstract class AnalysisContextStatistics_CacheRow {
-  /**
-   * List of possible states which can be queried.
-   */
-  static const List<CacheState> STATES = const <CacheState>[
-      CacheState.ERROR,
-      CacheState.FLUSHED,
-      CacheState.IN_PROCESS,
-      CacheState.INVALID,
-      CacheState.VALID];
-
-  /**
-   * Return the number of entries whose state is [CacheState.ERROR].
-   */
-  int get errorCount;
-
-  /**
-   * Return the number of entries whose state is [CacheState.FLUSHED].
-   */
-  int get flushedCount;
-
-  /**
-   * Return the number of entries whose state is [CacheState.IN_PROCESS].
-   */
-  int get inProcessCount;
-
-  /**
-   * Return the number of entries whose state is [CacheState.INVALID].
-   */
-  int get invalidCount;
-
-  /**
-   * Return the name of the data represented by this object.
-   */
-  String get name;
-
-  /**
-   * Return the number of entries whose state is [CacheState.VALID].
-   */
-  int get validCount;
-
-  /**
-   * Return the number of entries whose state is [state].
-   */
-  int getCount(CacheState state);
-}
-
-/**
- * Information about a single partition in the cache.
- */
-abstract class AnalysisContextStatistics_PartitionData {
-  /**
-   * Return the number of entries in the partition that have an AST structure in one state or
-   * another.
-   */
-  int get astCount;
-
-  /**
-   * Return the total number of entries in the partition.
-   */
-  int get totalCount;
-}
-
-/**
  * Implementation of the [AnalysisContextStatistics].
  */
 class AnalysisContextStatisticsImpl implements AnalysisContextStatistics {
   Map<String, AnalysisContextStatistics_CacheRow> _dataMap =
       new HashMap<String, AnalysisContextStatistics_CacheRow>();
 
   List<Source> _sources = new List<Source>();
 
   HashSet<CaughtException> _exceptions = new HashSet<CaughtException>();
 
@@ skipping 96 matching lines @@
     AnalysisContextStatistics_PartitionData {
   final int astCount;
 
   final int totalCount;
 
   AnalysisContextStatisticsImpl_PartitionDataImpl(this.astCount,
       this.totalCount);
 }
 
 /**
+ * Information about single piece of data in the cache.
+ */
+abstract class AnalysisContextStatistics_CacheRow {
+  /**
+   * List of possible states which can be queried.
+   */
+  static const List<CacheState> STATES = const <CacheState>[
+      CacheState.ERROR,
+      CacheState.FLUSHED,
+      CacheState.IN_PROCESS,
+      CacheState.INVALID,
+      CacheState.VALID];
+
+  /**
+   * Return the number of entries whose state is [CacheState.ERROR].
+   */
+  int get errorCount;
+
+  /**
+   * Return the number of entries whose state is [CacheState.FLUSHED].
+   */
+  int get flushedCount;
+
+  /**
+   * Return the number of entries whose state is [CacheState.IN_PROCESS].
+   */
+  int get inProcessCount;
+
+  /**
+   * Return the number of entries whose state is [CacheState.INVALID].
+   */
+  int get invalidCount;
+
+  /**
+   * Return the name of the data represented by this object.
+   */
+  String get name;
+
+  /**
+   * Return the number of entries whose state is [CacheState.VALID].
+   */
+  int get validCount;
+
+  /**
+   * Return the number of entries whose state is [state].
+   */
+  int getCount(CacheState state);
+}
+
+/**
+ * Information about a single partition in the cache.
+ */
+abstract class AnalysisContextStatistics_PartitionData {
+  /**
+   * Return the number of entries in the partition that have an AST structure in one state or
+   * another.
+   */
+  int get astCount;
+
+  /**
+   * Return the total number of entries in the partition.
+   */
+  int get totalCount;
+}
+
+/**
  * Instances of the class `AnalysisDelta` indicate changes to the types of analysis that
  * should be performed.
  */
 class AnalysisDelta {
   /**
    * A mapping from source to what type of analysis should be performed on that source.
    */
   HashMap<Source, AnalysisLevel> _analysisMap =
       new HashMap<Source, AnalysisLevel>();
 
@@ skipping 420 matching lines @@
    * Return `true` if analysis is to include the new async support.
    */
   @deprecated
   bool get enableAsync;
 
   /**
    * Return `true` if analysis is to include the new deferred loading support.
    *
    * @return `true` if analysis is to include the new deferred loading support
    */
+  @deprecated
   bool get enableDeferredLoading;
 
   /**
    * Return `true` if analysis is to include the new enum support.
    *
    * @return `true` if analysis is to include the new enum support
    */
+  @deprecated
   bool get enableEnum;
 
   /**
    * 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;
 
@@ skipping 38 matching lines @@
  */
 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 default value for enabling deferred loading.
    */
+  @deprecated
   static bool DEFAULT_ENABLE_DEFERRED_LOADING = true;
 
   /**
    * The default value for enabling enum support.
    */
+  @deprecated
   static bool DEFAULT_ENABLE_ENUM = false;
 
   /**
    * 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;
 
-  @deprecated
-  @override
-  bool get enableAsync => true;
-
-  @deprecated
-  void set enableAsync(bool enable) {
-    // Async support cannot be disabled
-  }
-
-  /**
-   * A flag indicating whether analysis is to enable deferred loading.
-   */
-  bool enableDeferredLoading = DEFAULT_ENABLE_DEFERRED_LOADING;
-
-  /**
-   * A flag indicating whether analysis is to enable enum support.
-   */
-  bool enableEnum = DEFAULT_ENABLE_ENUM;
-
   /**
    * 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).
    */
@@ skipping 31 matching lines @@
    * 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;
-    enableEnum = options.enableEnum;
     _generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     preserveComments = options.preserveComments;
   }
 
+  @deprecated
+  @override
+  bool get enableAsync => true;
+
+  @deprecated
+  void set enableAsync(bool enable) {
+    // Async support cannot be disabled
+  }
+
+  @deprecated
+  @override
+  bool get enableDeferredLoading => true;
+
+  @deprecated
+  void set enableDeferredLoading(bool enable) {
+    // Deferred loading support cannot be disabled
+  }
+
+  @deprecated
+  @override
+  bool get enableEnum => true;
+
+  @deprecated
+  void set enableEnum(bool enable) {
+    // Enum support cannot be disabled
+  }
+
   @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
    *          the SDK
    */
@@ skipping 1253 matching lines @@
     AstNode node = new NodeLocator.con1(offset).searchWithin(root);
     if (node != null) {
       Element element = ElementLocator.locate(node);
       return new ht.XmlExpression_Reference(element, node.offset, node.length);
     }
     return null;
   }
 }
 
 /**
- * A `CachedResult` is a single analysis result that is stored in a
- * [SourceEntry].
- */
-class CachedResult<E> {
-  /**
-   * The state of the cached value.
-   */
-  CacheState state;
-
-  /**
-   * The value being cached, or `null` if there is no value (for example, when
-   * the [state] is [CacheState.INVALID].
-   */
-  E value;
-
-  /**
-   * Initialize a newly created result holder to represent the value of data
-   * described by the given [descriptor].
-   */
-  CachedResult(DataDescriptor descriptor) {
-    state = CacheState.INVALID;
-    value = descriptor.defaultValue;
-  }
-}
-
-/**
  * Instances of the class `CachePartition` implement a single partition in an LRU cache of
  * information related to analysis.
  */
 abstract class CachePartition {
   /**
    * The context that owns this partition. Multiple contexts can reference a partition, but only one
    * context can own it.
    */
   final InternalAnalysisContext context;
 
@@ skipping 300 matching lines @@
       ERROR,
       FLUSHED,
       IN_PROCESS,
       INVALID,
       VALID];
 
   const CacheState(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
+ * A `CachedResult` is a single analysis result that is stored in a
+ * [SourceEntry].
+ */
+class CachedResult<E> {
+  /**
+   * The state of the cached value.
+   */
+  CacheState state;
+
+  /**
+   * The value being cached, or `null` if there is no value (for example, when
+   * the [state] is [CacheState.INVALID].
+   */
+  E value;
+
+  /**
+   * Initialize a newly created result holder to represent the value of data
+   * described by the given [descriptor].
+   */
+  CachedResult(DataDescriptor descriptor) {
+    state = CacheState.INVALID;
+    value = descriptor.defaultValue;
+  }
+}
+
+/**
  * The interface `ChangeNotice` defines the behavior of objects that represent a change to the
  * analysis results associated with a given source.
  */
 abstract class ChangeNotice implements AnalysisErrorInfo {
   /**
    * Return the fully resolved AST that changed as a result of the analysis, or `null` if the
    * AST was not changed.
    *
    * @return the fully resolved AST that changed as a result of the analysis
    */
@@ skipping 3022 matching lines @@
     //
     // Then parse the token stream.
     //
     TimeCounter_TimeCounterHandle timeCounterParse =
         PerformanceStatistics.parse.start();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(source, errorListener);
       AnalysisOptions options = context.analysisOptions;
       parser.parseFunctionBodies = options.analyzeFunctionBodies;
-      parser.parseDeferredLibraries = options.enableDeferredLoading;
-      parser.parseEnum = options.enableEnum;
       _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 =
@@ skipping 3081 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }