No errors in third-party packages (issue 22170)

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 941 matching lines @@
    * client has not provided a name.
    */
   String name;
 
   /**
    * The set of analysis options controlling the behavior of this context.
    */
   AnalysisOptionsImpl _options = new AnalysisOptionsImpl();
 
   /**
-   * A flag indicating whether errors related to sources in the SDK should be generated and
-   * reported.
+   * 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.
    */
   bool _generateSdkErrors = true;
 
   /**
    * A flag indicating whether this context is disposed.
    */
   bool _disposed = false;
 
   /**
    * A cache of content used to override the default content of a source.
@@ skipping 134 matching lines @@
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @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;
     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.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.incremental = options.incremental;
     this._options.incrementalApi = options.incrementalApi;
     this._options.incrementalValidation = options.incrementalValidation;
     this._options.lint = options.lint;
     this._options.preserveComments = options.preserveComments;
+    _generateImplicitErrors = options.generateImplicitErrors;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
       _invalidateAllLocalResolutionInformation(false);
     }
   }
 
   @override
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
       _priorityOrder = Source.EMPTY_ARRAY;
@@ skipping 1416 matching lines @@
       if (sourceEntry is DartEntry) {
         // get library-specific values
         List<Source> librarySources = getLibrariesContaining(source);
         for (Source librarySource in librarySources) {
           for (DataDescriptor descriptor in sourceEntry.libraryDescriptors) {
             if (descriptor == DartEntry.BUILT_ELEMENT ||
                 descriptor == DartEntry.BUILT_UNIT) {
               // These values are not currently being computed, so their state
               // is not interesting.
               continue;
+            } else if (!sourceEntry.explicitlyAdded &&
+                !_generateImplicitErrors &&
+                (descriptor == DartEntry.VERIFICATION_ERRORS ||
+                    descriptor == DartEntry.HINTS ||
+                    descriptor == DartEntry.LINTS)) {
+              continue;

[scheglov, 2015/03/05 18:54:04]

Can this code be moved outside of the libraries cycle?

[Brian Wilkerson, 2015/03/05 19:47:58]

I don't think so, although it would be nice. The problem is that
'libraryDescriptors' returns descriptors beyond the three we're checking on
here. Moving the test outside the loop would therefore disable too much.

             } else if (source.isInSystemLibrary &&
                 !_generateSdkErrors &&
                 (descriptor == DartEntry.VERIFICATION_ERRORS ||
                     descriptor == DartEntry.HINTS ||
                     descriptor == DartEntry.LINTS)) {
               continue;
             } else if (!hintsEnabled && descriptor == DartEntry.HINTS) {
               continue;
             } else if (!lintsEnabled && descriptor == DartEntry.LINTS) {
               continue;
@@ skipping 1242 matching lines @@
             //
 //            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
 //            if (libraryElement != null) {
 //              return new ResolveDartUnitTask(this, source, libraryElement);
 //            }
             // Possibly replace with:
 //             return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             return new AnalysisContextImpl_TaskData(
                 new ResolveDartLibraryTask(this, source, librarySource), false);
           }
-          if (_generateSdkErrors || !source.isInSystemLibrary) {
+          if ((!source.isInSystemLibrary || _generateSdkErrors)

[Paul Berry, 2015/03/05 19:16:53]

I had to write out a truth table to determine if this was correct, and I think
it's wrong.  In the case where:
- _generateSdkErrors is true
- source.isInSystemLibrary is true
- dartEntry.explicitlyAdded is false
- _generateImplicitErrors is false
I think we should generate errors for the file (because it is in the SDK, and
the client requested SDK errors).

But the logic above evaluates to false in this case.

Suggestion: rather than trying to invent a clever boolean expression to get the
behavior we want, how about just writing out the logic we want as a sequence of
if tests, e.g.:

bool _shouldErrorsBeAnalyzed(Source source, DartEntry dartEntry) {
  if (source.isInSystemLibrary) {
    return _generateSdkErrors;
  } else if (!dartEntry.explicitlyAdded) {
    return _generateImplicitErrors;
  } else {
    return true;
  }
}

[Brian Wilkerson, 2015/03/05 19:55:41]

Done

+              && (dartEntry.explicitlyAdded || _generateImplicitErrors)) {
             CacheState verificationErrorsState = dartEntry.getStateInLibrary(
                 DartEntry.VERIFICATION_ERRORS, librarySource);
             if (verificationErrorsState == CacheState.INVALID ||
                 (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               return _createGenerateDartErrorsTask(
                   source, dartEntry, librarySource, libraryEntry);
             }
             if (hintsEnabled) {
               CacheState hintsState =
                   dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
@@ skipping 195 matching lines @@
               DartEntry.RESOLVED_UNIT, librarySource);
           if (resolvedUnitState == CacheState.INVALID ||
               (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             LibraryElement libraryElement =
                 libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
               sources.add(source);
               return;
             }
           }
-          if (_generateSdkErrors || !source.isInSystemLibrary) {
+          if ((!source.isInSystemLibrary || _generateSdkErrors)
+              && (dartEntry.explicitlyAdded || _generateImplicitErrors)) {
             CacheState verificationErrorsState = dartEntry.getStateInLibrary(
                 DartEntry.VERIFICATION_ERRORS, librarySource);
             if (verificationErrorsState == CacheState.INVALID ||
                 (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               LibraryElement libraryElement =
                   libraryEntry.getValue(DartEntry.ELEMENT);
               if (libraryElement != null) {
                 sources.add(source);
                 return;
               }
@@ skipping 2212 matching lines @@
 /**
  * Futures returned by [AnalysisContext] for pending analysis results will
  * complete with this error if it is determined that analysis results will
  * never become available (e.g. because the requested source is not subject to
  * analysis, or because the requested source is a part file which is not a part
  * of any known library).
  */
 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.
+ * A set of analysis options used to control the behavior of an analysis
+ * context.
  */
 abstract class AnalysisOptions {
   /**
    * 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.
    *
    * This getter is deprecated; consider using [analyzeFunctionBodiesPredicate]
    * instead.
    */
-  @deprecated
+  @deprecated // Use this.analyzeFunctionBodiesPredicate
   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
+   * 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
    */
   bool get dart2jsHint;
 
   /**
    * Return `true` if analysis is to include the new async support.
    */
-  @deprecated
+  @deprecated // Always true
   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
+  @deprecated // Always true
   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
+  @deprecated // Always true
   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
+   * Return `true` if errors, warnings and hints should be generated for sources
+   * that are implicitly being analyzed. The default value is `true`.
+   */
+  bool get generateImplicitErrors;
+
+  /**
+   * Return `true` if errors, warnings and hints should be generated for sources
+   * in the SDK. The default value is `false`.
    */
   bool get generateSdkErrors;
 
   /**
-   * Return `true` if analysis is to generate hint results (e.g. type inference based
-   * information and pub best practices).
-   *
-   * @return `true` if analysis is to generate hint results
+   * Return `true` if analysis is to generate hint results (e.g. type inference
+   * based information and pub best practices).
    */
   bool get hint;
 
   /**
    * Return `true` if incremental analysis should be used.
-   *
-   * @return `true` if incremental analysis should be used
    */
   bool get incremental;
 
   /**
    * A flag indicating whether incremental analysis should be used for API
    * changes.
    */
   bool get incrementalApi;
 
   /**
    * A flag indicating whether validation should be performed after incremental
    * analysis.
    */
   bool get incrementalValidation;
 
   /**
    * Return `true` if analysis is to generate lint warnings.
-   *
-   * @return `true` if analysis is to generate lint warnings
    */
   bool get lint;
 
   /**
    * Return `true` if analysis is to parse comments.
-   *
-   * @return `true` if analysis is to parse comments
    */
   bool get preserveComments;
 }
 
 /**
- * Instances of the class `AnalysisOptions` represent a set of analysis options used to
- * control the behavior of an analysis context.
+ * 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 const 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 predicate indicating whether analysis is to parse and analyze function
    * bodies.
    */
   AnalyzeFunctionBodiesPredicate _analyzeFunctionBodiesPredicate =
       _analyzeAllFunctionBodies;
 
   /**
-   * The maximum number of sources for which AST structures should be kept in the cache.
+   * 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.
+   * A flag indicating whether analysis is to generate dart2js related hint
+   * results.
    */
   bool dart2jsHint = true;
 
   /**
-   * A flag indicating whether errors, warnings and hints should be generated for sources in the
-   * SDK.
+   * A flag indicating whether errors, warnings and hints should be generated
+   * for sources that are implicitly being analyzed.
    */
-  bool _generateSdkErrors = false;
+  bool generateImplicitErrors = true;
 
   /**
-   * A flag indicating whether analysis is to generate hint results (e.g. type inference based
-   * information and pub best practices).
+   * 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 incremental analysis should be used for API
@@ skipping 11 matching lines @@
    * A flag indicating whether analysis is to generate lint warnings.
    */
   bool lint = false;
 
   /**
    * A flag indicating whether analysis is to parse comments.
    */
   bool preserveComments = true;
 
   /**
-   * Initialize a newly created set of analysis options to have their default values.
+   * 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
+   * Initialize a newly created set of analysis options to have the same values
+   * as those in the given set of analysis [options].
    */
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
-    _generateSdkErrors = options.generateSdkErrors;
+    generateImplicitErrors = options.generateImplicitErrors;
+    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)) {
@@ skipping 45 matching lines @@
 
   @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
-   */
-  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`.
    */
@@ skipping 5571 matching lines @@
   visitElement(Element element) {
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {}