Linter analyzer plumbing.

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 1174 matching lines @@
   List<Source> get librarySources => _getSources(SourceKind.LIBRARY);
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextAnalysisTask {
     bool hintsEnabled = _options.hint;
+    bool lintsEnabled = _options.lint;
     bool hasBlockedTask = false;
     //
     // Look for incremental analysis
     //
     if (_incrementalAnalysisCache != null &&
         _incrementalAnalysisCache.hasWork) {
       AnalysisTask task =
           new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
       _incrementalAnalysisCache = null;
       return task;
@@ skipping 12 matching lines @@
           if (pendingFutures[i].evaluate(sourceEntry)) {
             pendingFutures.removeAt(i);
           } else {
             i++;
           }
         }
         if (pendingFutures.isEmpty) {
           sourcesToRemove.add(source);
           continue;
         }
-        AnalysisContextImpl_TaskData taskData =
-            _getNextAnalysisTaskForSource(source, sourceEntry, true, hintsEnabled);
+        AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(
+            source,
+            sourceEntry,
+            true,
+            hintsEnabled,
+            lintsEnabled);
         task = taskData.task;
         if (task != null) {
           break;
         } else if (taskData.isBlocked) {
           hasBlockedTask = true;
         } else {
           // There is no more work to do for this task, so forcibly complete
           // all its pending futures.
           for (PendingFuture pendingFuture in pendingFutures) {
             pendingFuture.forciblyComplete();
           }
           sourcesToRemove.add(source);
         }
       }
       for (Source source in sourcesToRemove) {
         _pendingFutureSources.remove(source);
       }
       if (task != null) {
         return task;
       }
     }
     //
     // Look for a priority source that needs to be analyzed.
     //
     int priorityCount = _priorityOrder.length;
     for (int i = 0; i < priorityCount; i++) {
       Source source = _priorityOrder[i];
-      AnalysisContextImpl_TaskData taskData =
-          _getNextAnalysisTaskForSource(source, _cache.get(source), true, hintsEnabled);
+      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(
+          source,
+          _cache.get(source),
+          true,
+          hintsEnabled,
+          lintsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       }
     }
     if (_neededForResolution != null) {
       List<Source> sourcesToRemove = new List<Source>();
       for (Source source in _neededForResolution) {
@@ skipping 22 matching lines @@
       }
     }
     //
     // Look for a non-priority source that needs to be analyzed.
     //
     List<Source> sourcesToRemove = new List<Source>();
     WorkManager_WorkIterator sources = _workManager.iterator();
     try {
       while (sources.hasNext) {
         Source source = sources.next();
-        AnalysisContextImpl_TaskData taskData =
-            _getNextAnalysisTaskForSource(source, _cache.get(source), false, hintsEnabled);
+        AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(
+            source,
+            _cache.get(source),
+            false,
+            hintsEnabled,
+            lintsEnabled);
         AnalysisTask task = taskData.task;
         if (task != null) {
           return task;
         } else if (taskData.isBlocked) {
           hasBlockedTask = true;
         } else {
           sourcesToRemove.add(source);
         }
       }
     } finally {
@@ skipping 63 matching lines @@
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     HashSet<Source> sources = new HashSet<Source>();
     bool hintsEnabled = _options.hint;
+    bool lintsEnabled = _options.lint;
+
     //
     // Look for priority sources that need to be analyzed.
     //
     for (Source source in _priorityOrder) {
       _getSourcesNeedingProcessing(
           source,
           _cache.get(source),
           true,
           hintsEnabled,
+          lintsEnabled,
           sources);
     }
     //
     // Look for non-priority sources that need to be analyzed.
     //
     WorkManager_WorkIterator iterator = _workManager.iterator();
     while (iterator.hasNext) {
       Source source = iterator.next();
       _getSourcesNeedingProcessing(
           source,
           _cache.get(source),
           false,
           hintsEnabled,
+          lintsEnabled,
           sources);
     }
     return new List<Source>.from(sources);
   }
 
   @override
   AnalysisContextStatistics get statistics {
     AnalysisContextStatisticsImpl statistics =
         new AnalysisContextStatisticsImpl();
     visitCacheItems(statistics._internalPutCacheItem);
@@ skipping 166 matching lines @@
         return buffer.toString();
       }
       nameNode = nameNode.parent;
     }
     return null;
   }
 
   @override
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = _options.hint;
+    bool enableLints = _options.lint;
+
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       try {
         DartEntry dartEntry = sourceEntry;
         ListUtilities.addAll(
             errors,
             _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
         dartEntry = _getReadableDartEntry(source);
         ListUtilities.addAll(
@@ skipping 11 matching lines @@
                   source,
                   source,
                   dartEntry,
                   DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
             dartEntry = _getReadableDartEntry(source);
             ListUtilities.addAll(
                 errors,
                 _getDartHintData(source, source, dartEntry, DartEntry.HINTS));
           }
+          if (enableLints) {
+            dartEntry = _getReadableDartEntry(source);
+            ListUtilities.addAll(
+                errors,
+                _getDartLintData(source, source, dartEntry, DartEntry.LINTS));
+          }
         } else {
           List<Source> libraries = getLibrariesContaining(source);
           for (Source librarySource in libraries) {
             ListUtilities.addAll(
                 errors,
                 _getDartResolutionData(
                     source,
                     librarySource,
                     dartEntry,
                     DartEntry.RESOLUTION_ERRORS));
             dartEntry = _getReadableDartEntry(source);
             ListUtilities.addAll(
                 errors,
                 _getDartVerificationData(
                     source,
                     librarySource,
                     dartEntry,
                     DartEntry.VERIFICATION_ERRORS));
             if (enableHints) {
               dartEntry = _getReadableDartEntry(source);
               ListUtilities.addAll(
                   errors,
                   _getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
             }
+            if (enableLints) {
+              dartEntry = _getReadableDartEntry(source);
+              ListUtilities.addAll(
+                  errors,
+                  _getDartLintData(source, librarySource, dartEntry, DartEntry.LINTS));
+            }
           }
         }
       } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
         AnalysisEngine.instance.logger.logInformation(
             "Could not compute errors",
             new CaughtException(exception, stackTrace));
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
@@ skipping 583 matching lines @@
             librarySource,
             CacheState.FLUSHED);
         dartEntry.setValueInLibrary(
             DartEntry.VERIFICATION_ERRORS,
             librarySource,
             AnalysisError.NO_ERRORS);
         dartEntry.setValueInLibrary(
             DartEntry.HINTS,
             librarySource,
             AnalysisError.NO_ERRORS);
+        dartEntry.setValueInLibrary(
+            DartEntry.LINTS,
+            librarySource,
+            AnalysisError.NO_ERRORS);
       }
     });
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   DartEntry
       recordResolveDartLibraryCycleTaskResults(ResolveDartLibraryCycleTask task) {
@@ skipping 206 matching lines @@
     if (_contentsChanged(source, contents)) {
       _onSourcesChangedController.add(
           new SourcesChangedEvent.changedContent(source, contents));
     }
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
     bool hintsEnabled = _options.hint;
+    bool lintsEnabled = _options.lint;
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       for (DataDescriptor descriptor in sourceEntry.descriptors) {
         if (descriptor == DartEntry.SOURCE_KIND) {
           // The source kind is always valid, so the state isn't interesting.
           continue;
         } else if (descriptor == DartEntry.CONTAINING_LIBRARIES) {
           // The list of containing libraries is always valid, so the state
@@ skipping 29 matching lines @@
           for (DataDescriptor descriptor in sourceEntry.libraryDescriptors) {
             if (descriptor == DartEntry.ANGULAR_ERRORS ||
                 descriptor == DartEntry.BUILT_ELEMENT ||
                 descriptor == DartEntry.BUILT_UNIT) {
               // These values are not currently being computed, so their state
               // is not interesting.
               continue;
             } else if (source.isInSystemLibrary &&
                 !_generateSdkErrors &&
                 (descriptor == DartEntry.VERIFICATION_ERRORS ||
-                    descriptor == DartEntry.HINTS)) {
+                    descriptor == DartEntry.HINTS ||
+                    descriptor == DartEntry.LINTS)) {
               continue;
             } else if (!hintsEnabled && descriptor == DartEntry.HINTS) {
               continue;
+            } else if (!lintsEnabled && descriptor == DartEntry.LINTS) {
+              continue;
             }
             callback(
                 librarySource,
                 sourceEntry,
                 descriptor,
                 sourceEntry.getStateInLibrary(descriptor, librarySource));
           }
         }
       }
     }
@@ skipping 86 matching lines @@
       dartEntry = new GenerateDartHintsTask(
           this,
           units,
           getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
+   * Given a source for a Dart file and the library that contains it, return a cache entry in which
+   * the state of the data represented by the given descriptor is either [CacheState.VALID] or
+   * [CacheStateERROR]. This method assumes that the data can be produced by generating hints

[danrubel, 2015/01/07 20:17:57]

hints -> lints

[pquitslund, 2015/01/08 00:29:52]

Done.

+   * for the library if the data is not already cached.
+   *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
+   * @param unitSource the source representing the Dart file
+   * @param librarySource the source representing the library containing the Dart file
+   * @param dartEntry the cache entry associated with the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @return a cache entry containing the required data
+   * @throws AnalysisException if data could not be returned because the source could not be parsed
+   */
+  DartEntry _cacheDartLintData(Source unitSource, Source librarySource,
+      DartEntry dartEntry, DataDescriptor descriptor) {
+    //
+    // Check to see whether we already have the information being requested.
+    //
+    CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
+    while (state != CacheState.ERROR && state != CacheState.VALID) {
+      //
+      // If not, compute the information.
+      // Unless the modification date of the source continues to change,
+      // this loop will eventually terminate.
+      //
+      DartEntry libraryEntry = _getReadableDartEntry(librarySource);
+      libraryEntry = _cacheDartResolutionData(
+          librarySource,
+          librarySource,
+          libraryEntry,
+          DartEntry.ELEMENT);
+      LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+      CompilationUnitElement definingUnit =
+          libraryElement.definingCompilationUnit;
+      List<CompilationUnitElement> parts = libraryElement.parts;
+      List<TimestampedData<CompilationUnit>> units =
+          new List<TimestampedData>(parts.length + 1);
+      units[0] = _getResolvedUnit(definingUnit, librarySource);
+      if (units[0] == null) {
+        Source source = definingUnit.source;
+        units[0] = new TimestampedData<CompilationUnit>(
+            getModificationStamp(source),
+            resolveCompilationUnit(source, libraryElement));
+      }
+      for (int i = 0; i < parts.length; i++) {
+        units[i + 1] = _getResolvedUnit(parts[i], librarySource);
+        if (units[i + 1] == null) {
+          Source source = parts[i].source;
+          units[i +
+              1] = new TimestampedData<CompilationUnit>(
+                  getModificationStamp(source),
+                  resolveCompilationUnit(source, libraryElement));
+        }
+      }
+      dartEntry = new GenerateDartLintsTask(

[Brian Wilkerson, 2015/01/07 23:57:54]

This is fine for now, but unless you're going to have lints that need
information for all of the compilation units in the library at the same time
(hints does because of the dead code analysis) we should rework this to operate
on a single compilation unit at a time. (A TODO might be a good idea so we don't
forget.)

[pquitslund, 2015/01/08 00:29:52]

Konstantin and I chatted about this and thought it wouldn't hurt to have the
context.  That said, you may well be right that we won't need it...  I'll add a
TODO to revisit.

+          this,
+          units,
+          getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
+      state = dartEntry.getStateInLibrary(descriptor, librarySource);
+    }
+    return dartEntry;
+  }
+
+
+  /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
@@ skipping 522 matching lines @@
     dartEntry.setStateInLibrary(
         DartEntry.HINTS,
         librarySource,
         CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new GenerateDartHintsTask(this, units, libraryElement),
         false);
   }
 
   /**
+   * Create a [GenerateDartHintsTask] for the given source, marking the hints as being

[danrubel, 2015/01/07 20:17:57]

hint -> lint in 2 places

[pquitslund, 2015/01/08 00:29:52]

Done.

+   * in-process.
+   *
+   * @param source the source whose content is to be verified
+   * @param dartEntry the entry for the source
+   * @param librarySource the source for the library containing the source
+   * @param libraryEntry the entry for the library
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createGenerateDartLintsTask(Source source,
+      DartEntry dartEntry, Source librarySource, DartEntry libraryEntry) {
+    if (libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
+      return _createResolveDartLibraryTask(librarySource, libraryEntry);
+    }
+    LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+    CompilationUnitElement definingUnit =
+        libraryElement.definingCompilationUnit;
+    List<CompilationUnitElement> parts = libraryElement.parts;
+    List<TimestampedData<CompilationUnit>> units =
+        new List<TimestampedData>(parts.length + 1);
+    units[0] = _getResolvedUnit(definingUnit, librarySource);
+    if (units[0] == null) {
+      // TODO(brianwilkerson) We should return a ResolveDartUnitTask
+      // (unless there are multiple ASTs that need to be resolved).
+      return _createResolveDartLibraryTask(librarySource, libraryEntry);
+    }
+    for (int i = 0; i < parts.length; i++) {
+      units[i + 1] = _getResolvedUnit(parts[i], librarySource);
+      if (units[i + 1] == null) {
+        // TODO(brianwilkerson) We should return a ResolveDartUnitTask
+        // (unless there are multiple ASTs that need to be resolved).
+        return _createResolveDartLibraryTask(librarySource, libraryEntry);
+      }
+    }
+    dartEntry.setStateInLibrary(
+        DartEntry.LINTS,
+        librarySource,
+        CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(
+        new GenerateDartLintsTask(this, units, libraryElement),

[Brian Wilkerson, 2015/01/07 23:57:54]

Ditto

[pquitslund, 2015/01/08 00:29:52]

Done.

+        false);
+  }
+
+
+
+  /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGetContentTask(Source source,
       SourceEntry sourceEntry) {
     sourceEntry.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
@@ skipping 274 matching lines @@
       DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry =
         _cacheDartHintData(unitSource, librarySource, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return dartEntry.getValue(descriptor);
     }
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
+   * Given a source for a Dart file and the library that contains it, return the data represented by
+   * the given descriptor that is associated with that source. This method assumes that the data can
+   * be produced by generating hints for the library if it is not already cached.

[danrubel, 2015/01/07 20:17:57]

hint -> lint

[pquitslund, 2015/01/08 00:29:52]

Done.

+   *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
+   * @param unitSource the source representing the Dart file
+   * @param librarySource the source representing the library containing the Dart file
+   * @param dartEntry the entry representing the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @return the requested data about the given source
+   * @throws AnalysisException if data could not be returned because the source could not be
+   *           resolved
+   */
+  Object _getDartLintData(Source unitSource, Source librarySource,
+      DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry =
+        _cacheDartLintData(unitSource, librarySource, dartEntry, descriptor);
+    if (identical(descriptor, DartEntry.ELEMENT)) {
+      return dartEntry.getValue(descriptor);
+    }
+    return dartEntry.getValueInLibrary(descriptor, librarySource);
+  }
+
+  /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
@@ skipping 257 matching lines @@
    * Look at the given source to see whether a task needs to be performed related to it. Return the
    * task that should be performed, or `null` if there is no more work to be done for the
    * source.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
+   * @param lintsEnabled `true` if lints are currently enabled
    * @return the next task that needs to be performed for the given source
    */
   AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source,
-      SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
+      SourceEntry sourceEntry, bool isPriority, bool hintsEnabled,
+      bool lintsEnabled) {
     // Refuse to generate tasks for html based files that are above 1500 KB
     if (_isTooBigHtmlSourceEntry(source, sourceEntry)) {
       // TODO (jwren) we still need to report an error of some kind back to the
       // client.
       return new AnalysisContextImpl_TaskData(null, false);
     }
     if (sourceEntry == null) {
       return new AnalysisContextImpl_TaskData(null, false);
     }
     CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT);
@@ skipping 89 matching lines @@
                   dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
               if (hintsState == CacheState.INVALID ||
                   (isPriority && hintsState == CacheState.FLUSHED)) {
                 return _createGenerateDartHintsTask(
                     source,
                     dartEntry,
                     librarySource,
                     libraryEntry);
               }
             }
+            if (lintsEnabled) {
+              CacheState lintsState =
+                  dartEntry.getStateInLibrary(DartEntry.LINTS, librarySource);
+              if (lintsState == CacheState.INVALID ||
+                  (isPriority && lintsState == CacheState.FLUSHED)) {
+                return _createGenerateDartLintsTask(
+                    source,
+                    dartEntry,
+                    librarySource,
+                    libraryEntry);
+              }
+            }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS);
       if (parseErrorsState == CacheState.INVALID ||
           (isPriority && parseErrorsState == CacheState.FLUSHED)) {
         return _createParseHtmlTask(source, htmlEntry);
       }
@@ skipping 162 matching lines @@
    * therefore be kept in sync with,
    * [getNextAnalysisTask]. This method is intended to
    * be used for testing purposes only.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
+   * @param lintsEnabled `true` if lints are currently enabled
    * @param sources the set to which sources should be added
    */
   void _getSourcesNeedingProcessing(Source source, SourceEntry sourceEntry,
-      bool isPriority, bool hintsEnabled, HashSet<Source> sources) {
+      bool isPriority, bool hintsEnabled, bool lintsEnabled,
+      HashSet<Source> sources) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (scanErrorsState == CacheState.INVALID ||
           (isPriority && scanErrorsState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (parseErrorsState == CacheState.INVALID ||
@@ skipping 45 matching lines @@
               if (hintsState == CacheState.INVALID ||
                   (isPriority && hintsState == CacheState.FLUSHED)) {
                 LibraryElement libraryElement =
                     libraryEntry.getValue(DartEntry.ELEMENT);
                 if (libraryElement != null) {
                   sources.add(source);
                   return;
                 }
               }
             }
+            if (lintsEnabled) {
+              CacheState lintsState =
+                  dartEntry.getStateInLibrary(DartEntry.LINTS, librarySource);
+              if (lintsState == CacheState.INVALID ||
+                  (isPriority && lintsState == CacheState.FLUSHED)) {
+                LibraryElement libraryElement =
+                    libraryEntry.getValue(DartEntry.ELEMENT);
+                if (libraryElement != null) {
+                  sources.add(source);
+                  return;
+                }
+              }
+            }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
       if (parsedUnitState == CacheState.INVALID ||
           (isPriority && parsedUnitState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
@@ skipping 469 matching lines @@
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return libraryEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
+  DartEntry _recordGenerateDartLintsTask(GenerateDartLintsTask task) {
+    Source librarySource = task.libraryElement.source;
+    CaughtException thrownException = task.exception;
+    DartEntry libraryEntry = null;
+    HashMap<Source, List<AnalysisError>> lintMap = task.lintMap;
+    if (lintMap == null) {
+      // We don't have any information about which sources to mark as invalid
+      // other than the library source.
+      DartEntry libraryEntry = _cache.get(librarySource);
+      if (thrownException == null) {
+        String message =
+            "GenerateDartHintsTask returned a null lint map "

[danrubel, 2015/01/07 20:17:57]

Hint -> Lint

[pquitslund, 2015/01/08 00:29:51]

Done.

+                "without throwing an exception: ${librarySource.fullName}";
+        thrownException =
+            new CaughtException(new AnalysisException(message), null);
+      }
+      libraryEntry.recordLintErrorInLibrary(librarySource, thrownException);
+      throw new AnalysisException('<rethrow>', thrownException);
+    }
+    lintMap.forEach((Source unitSource, List<AnalysisError> lints) {
+      DartEntry dartEntry = _cache.get(unitSource);
+      if (unitSource == librarySource) {
+        libraryEntry = dartEntry;
+      }
+      if (thrownException == null) {
+        dartEntry.setValueInLibrary(DartEntry.LINTS, librarySource, lints);
+        ChangeNoticeImpl notice = _getNotice(unitSource);
+        LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
+        notice.setErrors(dartEntry.allErrors, lineInfo);
+      } else {
+        dartEntry.recordLintErrorInLibrary(librarySource, thrownException);
+      }
+    });
+    if (thrownException != null) {
+      throw new AnalysisException('<rethrow>', thrownException);
+    }
+    return libraryEntry;
+  }
+
+
+  /**
+   * Record the results produced by performing a [task] and return the cache
+   * entry associated with the results.
+   */
   SourceEntry _recordGetContentsTask(GetContentTask task) {
     if (!task.isComplete) {
       return null;
     }
     Source source = task.source;
     SourceEntry sourceEntry = _cache.get(source);
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       sourceEntry.recordContentError(thrownException);
       _workManager.remove(source);
@@ skipping 575 matching lines @@
 
   @override
   DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) =>
       AnalysisContextImpl_this._recordGenerateDartErrorsTask(task);
 
   @override
   DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) =>
       AnalysisContextImpl_this._recordGenerateDartHintsTask(task);
 
   @override
+  DartEntry visitGenerateDartLintsTask(GenerateDartLintsTask task) =>
+      AnalysisContextImpl_this._recordGenerateDartLintsTask(task);
+
+  @override
   SourceEntry visitGetContentTask(GetContentTask task) =>
       AnalysisContextImpl_this._recordGetContentsTask(task);
 
   @override
   DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) =>
       AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task);
 
   @override
   DartEntry visitParseDartTask(ParseDartTask task) =>
       AnalysisContextImpl_this._recordParseDartTaskResults(task);
@@ skipping 65 matching lines @@
       DartEntry dartEntry = sourceEntry;
       if (_astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
     }
     return RetentionPriority.LOW;
   }
 
   bool _astIsNeeded(DartEntry dartEntry) =>
       dartEntry.hasInvalidData(DartEntry.HINTS) ||
+          dartEntry.hasInvalidData(DartEntry.HINTS) ||

[danrubel, 2015/01/07 20:17:57]

HINTS -> LINTS
Plus perhaps a test?

[pquitslund, 2015/01/08 00:29:52]

Great catch.  Thanks!

Tests to follow in the next CL.

           dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) ||
           dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
 }
 
 /**
  * Instances of the class `CycleBuilder` are used to construct a list of the libraries that
  * must be resolved together in order to resolve any one of the libraries.
  */
 class AnalysisContextImpl_CycleBuilder {
   final AnalysisContextImpl AnalysisContextImpl_this;
@@ skipping 1247 matching lines @@
    */
   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.
@@ skipping 81 matching lines @@
    */
   bool incrementalApi = false;
 
   /**
    * A flag indicating whether validation should be performed after incremental
    * analysis.
    */
   bool incrementalValidation = false;
 
   /**
+   * 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.
    */
   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;
     enableEnum = options.enableEnum;
     _generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
+    lint = options.lint;
     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.
    *
@@ skipping 173 matching lines @@
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
   E visitGenerateDartHintsTask(GenerateDartHintsTask task);
 
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
+  E visitGenerateDartLintsTask(GenerateDartLintsTask task);
+
+  /**
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
+   */
   E visitGetContentTask(GetContentTask task);
 
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
   E
       visitIncrementalAnalysisTask(IncrementalAnalysisTask incrementalAnalysisTask);
 
   /**
@@ skipping 1945 matching lines @@
 
   /**
    * The data descriptor representing the launchable flag. This data is only
    * available for Dart files that are the defining compilation unit of a
    * library.
    */
   static final DataDescriptor<bool> IS_LAUNCHABLE =
       new DataDescriptor<bool>("DartEntry.IS_LAUNCHABLE", false);
 
   /**
+   * The data descriptor representing lint warnings resulting from auditing the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> LINTS =
+      new DataDescriptor<List<AnalysisError>>(
+          "DartEntry.LINTS",
+          AnalysisError.NO_ERRORS);
+
+  /**
    * The data descriptor representing the errors resulting from parsing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
           "DartEntry.PARSE_ERRORS",
           AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the parsed AST structure.
@@ skipping 72 matching lines @@
    */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     errors.addAll(getValue(SCAN_ERRORS));
     errors.addAll(getValue(PARSE_ERRORS));
     ResolutionState state = _resolutionState;
     while (state != null) {
       errors.addAll(state.getValue(RESOLUTION_ERRORS));
       errors.addAll(state.getValue(VERIFICATION_ERRORS));
       errors.addAll(state.getValue(HINTS));
+      errors.addAll(state.getValue(LINTS));
       state = state._nextState;
     }
     errors.addAll(getValue(ANGULAR_ERRORS));
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return errors;
   }
 
   /**
@@ skipping 135 matching lines @@
    * be stored in this SourceEntry.
    */
   List<DataDescriptor> get libraryDescriptors {
     return <DataDescriptor>[
         DartEntry.ANGULAR_ERRORS,
         DartEntry.BUILT_ELEMENT,
         DartEntry.BUILT_UNIT,
         DartEntry.RESOLUTION_ERRORS,
         DartEntry.RESOLVED_UNIT,
         DartEntry.VERIFICATION_ERRORS,
-        DartEntry.HINTS];
+        DartEntry.HINTS,
+        DartEntry.LINTS];
   }
 
   /**
    * A compilation unit that has not been accessed by any other client and can
    * therefore safely be modified by the reconciler, or `null` if the source has
    * not been parsed.
    */
   CompilationUnit get resolvableCompilationUnit {
     if (getState(PARSED_UNIT) == CacheState.VALID) {
       CompilationUnit unit = getValue(PARSED_UNIT);
@@ skipping 154 matching lines @@
    * @param exception the exception that shows where the error occurred
    */
   void recordHintErrorInLibrary(Source librarySource,
       CaughtException exception) {
     this.exception = exception;
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordHintError();
   }
 
   /**
+   * Record that an error occurred while attempting to generate lints for the
+   * source represented by this entry. This will set the state of all
+   * verification information as being in error.
+   *
+   * @param librarySource the source of the library in which hints were being generated

[danrubel, 2015/01/07 20:17:57]

hint -> lint

[pquitslund, 2015/01/08 00:29:52]

Done.

+   * @param exception the exception that shows where the error occurred
+   */
+  void recordLintErrorInLibrary(Source librarySource,
+      CaughtException exception) {
+    this.exception = exception;
+    ResolutionState state = _getOrCreateResolutionState(librarySource);
+    state.recordLintError();
+  }
+
+  /**
    * Record that an [exception] occurred while attempting to scan or parse the
    * entry represented by this entry. This will set the state of all information,
    * including any resolution-based information, as being in error.
    */
   void recordParseError(CaughtException exception) {
     setState(SOURCE_KIND, CacheState.ERROR);
     setState(PARSE_ERRORS, CacheState.ERROR);
     setState(PARSED_UNIT, CacheState.ERROR);
     setState(EXPORTED_LIBRARIES, CacheState.ERROR);
     setState(IMPORTED_LIBRARIES, CacheState.ERROR);
@@ skipping 203 matching lines @@
 
   /**
    * Return `true` if the [descriptor] is valid for this entry when the data is
    * relative to a library.
    */
   bool _isValidLibraryDescriptor(DataDescriptor descriptor) {
     return descriptor == ANGULAR_ERRORS ||
         descriptor == BUILT_ELEMENT ||
         descriptor == BUILT_UNIT ||
         descriptor == HINTS ||
+        descriptor == LINTS ||
         descriptor == RESOLUTION_ERRORS ||
         descriptor == RESOLVED_UNIT ||
         descriptor == VERIFICATION_ERRORS;
   }
 
   @override
   bool _writeDiffOn(StringBuffer buffer, SourceEntry oldEntry) {
     bool needsSeparator = super._writeDiffOn(buffer, oldEntry);
     if (oldEntry is! DartEntry) {
       if (needsSeparator) {
@@ skipping 191 matching lines @@
 
   /**
    * Return `true` if there is analysis information in the given entry that needs to be
    * computed, where the computation is dependent on having the AST.
    *
    * @param dartEntry the entry being tested
    * @return `true` if there is analysis information that needs to be computed from the AST
    */
   bool astIsNeeded(DartEntry dartEntry) =>
       dartEntry.hasInvalidData(DartEntry.HINTS) ||
+          dartEntry.hasInvalidData(DartEntry.LINTS) ||
           dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) ||
           dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
 
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       if (astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
@@ skipping 271 matching lines @@
     // Store the results.
     //
     _hintMap = new HashMap<Source, List<AnalysisError>>();
     for (int i = 0; i < unitCount; i++) {
       Source source = _units[i].data.element.source;
       _hintMap[source] = errorListener.getErrorsForSource(source);
     }
   }
 }
 
+/// Generates lint feedback for a single Dart library.
+class GenerateDartLintsTask extends AnalysisTask {
+
+  ///The compilation units that comprise the library, with the defining
+  ///compilation unit appearing first in the array.
+  final List<TimestampedData<CompilationUnit>> _units;
+
+  /// The element model for the library being analyzed.
+  final LibraryElement libraryElement;
+
+  /// Initialize a newly created task to perform lint checking over these
+  /// [_units] belonging to this [libraryElement] within the given [context].
+  GenerateDartLintsTask(context, this._units, this.libraryElement)
+      : super(context);
+
+  /// A mapping of analyzed sources to their associated lint warnings.
+  /// May be [null] if the task has not been performed or if analysis did not
+  /// complete normally.
+  HashMap<Source, List<AnalysisError>> lintMap;
+
+  @override
+  String get taskDescription {
+    Source librarySource = libraryElement.source;
+    return (librarySource == null) ?
+        "generate Dart lints for library without source" :
+        "generate Dart lints for ${librarySource.fullName}";
+  }
+
+  @override
+  accept(AnalysisTaskVisitor visitor) =>
+      visitor.visitGenerateDartLintsTask(this);
+
+  @override
+  void internalPerform() {
+
+    List<CompilationUnit> compilationUnits =
+        _units.map((TimestampedData<CompilationUnit> unit) => unit.data);
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    LintGenerator lintGenerator =
+        new LintGenerator(compilationUnits, errorListener);
+    lintGenerator.generate();
+
+    lintMap = new HashMap<Source, List<AnalysisError>>();
+    compilationUnits.forEach((CompilationUnit unit) {
+      Source source = unit.element.source;
+      lintMap[source] = errorListener.getErrorsForSource(source);
+    });
+  }
+}
+
+
 /**
  * Instances of the class `GetContentTask` get the contents of a source.
  */
 class GetContentTask extends AnalysisTask {
   /**
    * The source to be read.
    */
   final Source source;
 
   /**
@@ skipping 1798 matching lines @@
    * The [TimeCounter] for time spent in error verifier.
    */
   static TimeCounter errors = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in hints generator.
    */
   static TimeCounter hints = new TimeCounter();
 
   /**
+   * The [TimeCounter] for time spent in linting.
+   */
+  static TimeCounter lint = new TimeCounter();
+
+  /**
    * Reset all of the time counters to zero.
    */
   static void reset() {
     io = new TimeCounter();
     scan = new TimeCounter();
     parse = new TimeCounter();
     resolve = new TimeCounter();
     angular = new TimeCounter();
     polymer = new TimeCounter();
     errors = new TimeCounter();
     hints = new TimeCounter();
+    lint = new TimeCounter();
   }
 }
 
 /**
  * Instances of the class `PolymerBuildHtmlTask` build Polymer specific elements.
  */
 class PolymerBuildHtmlTask extends AnalysisTask {
   /**
    * The source to build which Polymer HTML elements for.
    */
@@ skipping 838 matching lines @@
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _nextState = null;
     _librarySource = null;
     setState(DartEntry.BUILT_UNIT, CacheState.INVALID);
     setState(DartEntry.BUILT_ELEMENT, CacheState.INVALID);
     setState(DartEntry.HINTS, CacheState.INVALID);
+    setState(DartEntry.LINTS, CacheState.INVALID);
     setState(DartEntry.RESOLVED_UNIT, CacheState.INVALID);
     setState(DartEntry.RESOLUTION_ERRORS, CacheState.INVALID);
     setState(DartEntry.VERIFICATION_ERRORS, CacheState.INVALID);
   }
 
   /**
    * Record that an exception occurred while attempting to build the element
    * model for the source associated with this state.
    */
   void recordBuildElementError() {
     setState(DartEntry.BUILT_UNIT, CacheState.ERROR);
     setState(DartEntry.BUILT_ELEMENT, CacheState.ERROR);
     recordResolutionError();
   }
 
   /**
    * Record that an exception occurred while attempting to generate hints for
    * the source associated with this entry. This will set the state of all
    * verification information as being in error.
    */
   void recordHintError() {
     setState(DartEntry.HINTS, CacheState.ERROR);
   }
 
   /**
+   * Record that an exception occurred while attempting to generate lints for
+   * the source associated with this entry. This will set the state of all
+   * verification information as being in error.
+   */
+  void recordLintError() {
+    setState(DartEntry.LINTS, CacheState.ERROR);
+  }
+
+  /**
    * Record that an exception occurred while attempting to resolve the source
    * associated with this state.
    */
   void recordResolutionError() {
     setState(DartEntry.RESOLVED_UNIT, CacheState.ERROR);
     setState(DartEntry.RESOLUTION_ERRORS, CacheState.ERROR);
     recordVerificationError();
     setState(DartEntry.ANGULAR_ERRORS, CacheState.ERROR);
   }
 
@@ skipping 88 matching lines @@
         DartEntry.RESOLUTION_ERRORS,
         oldEntry);
     needsSeparator = _writeStateDiffOn(
         buffer,
         needsSeparator,
         "verificationErrors",
         DartEntry.VERIFICATION_ERRORS,
         oldEntry);
     needsSeparator =
         _writeStateDiffOn(buffer, needsSeparator, "hints", DartEntry.HINTS, oldEntry);
+    needsSeparator =
+        _writeStateDiffOn(buffer, needsSeparator, "lints", DartEntry.LINTS, oldEntry);
     return needsSeparator;
   }
 
   /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void _writeOn(StringBuffer buffer) {
     if (_librarySource != null) {
       _writeStateOn(buffer, "builtElement", DartEntry.BUILT_ELEMENT);
       _writeStateOn(buffer, "builtUnit", DartEntry.BUILT_UNIT);
       _writeStateOn(buffer, "resolvedUnit", DartEntry.RESOLVED_UNIT);
       _writeStateOn(buffer, "resolutionErrors", DartEntry.RESOLUTION_ERRORS);
       _writeStateOn(
           buffer,
           "verificationErrors",
           DartEntry.VERIFICATION_ERRORS);
       _writeStateOn(buffer, "hints", DartEntry.HINTS);
+      _writeStateOn(buffer, "lints", DartEntry.LINTS);
       if (_nextState != null) {
         _nextState._writeOn(buffer);
       }
     }
   }
 
   /**
    * Write a textual representation of the difference between the state of the
    * value described by the given [descriptor] between the [oldEntry] and this
    * entry to the given [buffer]. Return `true` if some difference was written.
@@ skipping 1602 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }