Avoid unnecessary parsing/resolution when running command line analyzer.

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 20 matching lines @@
 import 'java_engine.dart';
 import 'parser.dart' show Parser, IncrementalParser;
 import 'resolver.dart';
 import 'scanner.dart';
 import 'sdk.dart' show DartSdk;
 import 'source.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 
 /**
+ * Used by [AnalysisOptions] to allow function bodies to be analyzed in some
+ * sources but not others.
+ */
+typedef bool AnalyzeFunctionBodiesPredicate(Source source);
+
+/**
  * Type of callback functions used by PendingFuture.  Functions of this type
  * should perform a computation based on the data in [sourceEntry] and return
  * it.  If the computation can't be performed yet because more analysis is
  * needed, null should be returned.
  *
  * The function may also throw an exception, in which case the corresponding
  * future will be completed with failure.
  *
  * Since this function is called while the state of analysis is being updated,
  * it should be free of side effects so that it doesn't cause reentrant
@@ skipping 1059 matching lines @@
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute =
-        this._options.analyzeFunctionBodies != options.analyzeFunctionBodies ||
+        this._options.analyzeFunctionBodiesPredicate !=
+            options.analyzeFunctionBodiesPredicate ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         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.analyzeFunctionBodiesPredicate =
+        options.analyzeFunctionBodiesPredicate;
     this._options.generateSdkErrors = options.generateSdkErrors;
     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.lint = options.lint;
     this._options.preserveComments = options.preserveComments;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
@@ skipping 5335 matching lines @@
  */
 class AnalysisNotScheduledError implements Exception {
 }
 
 /**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
   /**
-   * Return `true` if analysis is to parse and analyze function bodies.
+   * If analysis is to parse and analyze all function bodies, return `true`.
+   * If analysis is to skip all function bodies, return `false`.  If analysis
+   * is to parse and analyze function bodies in some sources and not in others,
+   * throw an exception.
    *
-   * @return `true` if analysis is to parse and analyzer function bodies
+   * This getter is deprecated; consider using [analyzeFunctionBodiesPredicate]
+   * instead.
    */
+  @deprecated
   bool get analyzeFunctionBodies;
 
   /**
+   * Function that returns `true` if analysis is to parse and analyze function
+   * bodies for a given source.
+   */
+  AnalyzeFunctionBodiesPredicate get analyzeFunctionBodiesPredicate;
+
+  /**
    * Return the maximum number of sources for which AST structures should be kept in the cache.
    *
    * @return the maximum number of sources for which AST structures should be kept in the cache
    */
   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
@@ skipping 88 matching lines @@
   @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 parse and analyze function bodies.
+   * A predicate indicating whether analysis is to parse and analyze function
+   * bodies.
    */
-  bool analyzeFunctionBodies = true;
+  AnalyzeFunctionBodiesPredicate analyzeFunctionBodiesPredicate =

[Brian Wilkerson, 2015/02/27 23:52:05]

For safety, we should have a setter that replaces null with this default value.

[Paul Berry, 2015/03/02 19:09:45]

I don't think there's any benefit in auto-converting null to this default value,
since if that's what the client wants they are better off using the
analyzeFunctionBodies setter.  However, I've added a setter that throws an
ArgumentError in the event that the client passes null.  Does that seem
reasonable to you?

+      _analyzeAllFunctionBodies;
 
   /**
    * 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;
@@ skipping 42 matching lines @@
    */
   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) {
-    analyzeFunctionBodies = options.analyzeFunctionBodies;
+    analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
     _generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
   }
 
+  bool get analyzeFunctionBodies {
+    if (identical(analyzeFunctionBodiesPredicate, _analyzeAllFunctionBodies)) {
+      return true;
+    } else if (identical(
+        analyzeFunctionBodiesPredicate,
+        _analyzeNoFunctionBodies)) {
+      return false;
+    } else {
+      throw new StateError('analyzeFunctionBodiesPredicate in use');
+    }
+  }
+
+  set analyzeFunctionBodies(bool value) {
+    if (value) {
+      analyzeFunctionBodiesPredicate = _analyzeAllFunctionBodies;
+    } else {
+      analyzeFunctionBodiesPredicate = _analyzeNoFunctionBodies;
+    }
+  }
+
   @deprecated
   @override
   bool get enableAsync => true;
 
   @deprecated
   void set enableAsync(bool enable) {
     // Async support cannot be disabled
   }
 
   @deprecated
@@ skipping 20 matching lines @@
   /**
    * 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
    */
   void set generateSdkErrors(bool generate) {
     _generateSdkErrors = generate;
   }
+
+  /**
+   * Predicate used for [analyzeFunctionBodiesPredicate] when
+   * [analyzeFunctionBodies] is set to `true`.
+   */
+  static bool _analyzeAllFunctionBodies(Source _) => true;
+
+  /**
+   * Predicate used for [analyzeFunctionBodiesPredicate] when
+   * [analyzeFunctionBodies] is set to `false`.
+   */
+  static bool _analyzeNoFunctionBodies(Source _) => false;
 }
 
 /**
  * Instances of the class `AnalysisResult`
  */
 class AnalysisResult {
   /**
    * The change notices associated with this result, or `null` if there were no changes and
    * there is no more work to be done.
    */
@@ skipping 3352 matching lines @@
 
   @override
   void internalPerform() {
     //
     // Then parse the token stream.
     //
     PerformanceStatistics.parse.makeCurrentWhile(() {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(source, errorListener);
       AnalysisOptions options = context.analysisOptions;
-      parser.parseFunctionBodies = options.analyzeFunctionBodies;
+      parser.parseFunctionBodies =
+          options.analyzeFunctionBodiesPredicate(source);
       _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 2368 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }