Linter analyzer plumbing.

pkg/analyzer/lib/src/generated/incremental_resolver.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.
 
 library engine.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'ast.dart';
@@ skipping 779 matching lines @@
   final int _updateEndNew;
 
   int _updateDelta;
 
   RecordingErrorListener errorListener = new RecordingErrorListener();
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
+  List<AnalysisError> _lints = AnalysisError.NO_ERRORS;
 
   /**
    * The elements that should be resolved because of API changes.
    */
   HashSet<Element> _resolutionQueue = new HashSet<Element>();
 
   /**
    * Initialize a newly created incremental resolver to resolve a node in the
    * given source in the given library.
    */
@@ skipping 23 matching lines @@
       _updateElementNameOffsets();
       _buildElements(rootNode);
       if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
       _generateHints(rootNode);
+      _generateLints(rootNode);
       // update entry errors
       _updateEntry();
       // resolve queue in response of API changes
       _resolveQueue();
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
@@ skipping 107 matching lines @@
       AnalysisContext analysisContext = _definingLibrary.context;
       HintGenerator hintGenerator =
           new HintGenerator(<CompilationUnit>[unit], analysisContext, errorListener);
       hintGenerator.generateForLibrary();
       _hints = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('generate hints');
     }
   }
 
+  void _generateLints(AstNode node) {
+    LoggingTimer timer = logger.startTimer();
+    try {
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      CompilationUnit unit = node.getAncestor((n) => n is CompilationUnit);
+      LintGenerator lintGenerator =
+          new LintGenerator(<CompilationUnit>[unit], errorListener);
+      lintGenerator.generate();
+      _lints = errorListener.getErrorsForSource(_source);
+    } finally {
+      timer.stop('generate hints');

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

hint -> lint

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

Done.

+    }
+  }
+
   /**
    * Return the element defined by [node], or `null` if the node does not
    * define an element.
    */
   Element _getElement(AstNode node) {
     if (node is Declaration) {
       return node.element;
     } else if (node is CompilationUnit) {
       return node.element;
     }
@@ skipping 22 matching lines @@
       logger.enter('resolve $element');
       try {
         AstNode node = element.node;
         CompilationUnitElement unit =
             element.getAncestor((e) => e is CompilationUnitElement);
         IncrementalResolver resolver =
             new IncrementalResolver(unit, node.offset, node.end, node.end);
         resolver._resolveReferences(node);
         resolver._verify(node);
         resolver._generateHints(node);
+        resolver._generateLints(node);
         resolver._updateEntry();
       } finally {
         logger.exit();
       }
     }
   }
 
   _resolveReferences(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
@@ skipping 42 matching lines @@
       _resolveErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('resolve references');
     }
   }
 
   void _shiftEntryErrors() {
     _shiftErrors(DartEntry.RESOLUTION_ERRORS);
     _shiftErrors(DartEntry.VERIFICATION_ERRORS);
     _shiftErrors(DartEntry.HINTS);
+    _shiftErrors(DartEntry.LINTS);
   }
 
   void _shiftErrors(DataDescriptor<List<AnalysisError>> descriptor) {
     Source librarySource = _definingLibrary.source;
     List<AnalysisError> errors =
         entry.getValueInLibrary(descriptor, librarySource);
     for (AnalysisError error in errors) {
       int errorOffset = error.offset;
       if (errorOffset > _updateOffset) {
         error.offset += _updateDelta;
@@ skipping 25 matching lines @@
     {
       List<AnalysisError> oldErrors =
           entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _verifyErrors);
       entry.setValueInLibrary(
           DartEntry.VERIFICATION_ERRORS,
           librarySource,
           errors);
     }
     entry.setValueInLibrary(DartEntry.HINTS, librarySource, _hints);
+    entry.setValueInLibrary(DartEntry.LINTS, librarySource, _lints);
   }
 
   List<AnalysisError> _updateErrors(List<AnalysisError> oldErrors,
       List<AnalysisError> newErrors) {
     List<AnalysisError> errors = new List<AnalysisError>();
     // add updated old errors
     for (AnalysisError error in oldErrors) {
       int errorOffset = error.offset;
       if (errorOffset < _updateOffset) {
         errors.add(error);
@@ skipping 678 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }