Invalidate both hints and lints on incremental resolution.

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 'package:analyzer/src/context/cache.dart'
@@ skipping 881 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> _lints = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created incremental resolver to resolve a node in the
    * given source in the given library.
    */
   IncrementalResolver(this.oldEntry, this.newSourceEntry, this.newUnitEntry,
       this._definingUnit, this._updateOffset, this._updateEndOld,
       this._updateEndNew) {
     _updateDelta = _updateEndNew - _updateEndOld;
     _definingLibrary = _definingUnit.library;
@@ skipping 21 matching lines @@
       if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       _computeConstants(rootNode);
       _resolveErrors = errorListener.getErrorsForSource(_source);
       // verify
       _verify(rootNode);
       _context.invalidateLibraryHints(_librarySource);
-      _generateLints(rootNode);
       // update entry errors
       _updateEntry();
       // notify unit
       _definingUnit.afterIncrementalResolution();
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
@@ skipping 91 matching lines @@
   AstNode _findResolutionRoot(AstNode node) {
     while (node != null) {
       if (_canBeResolved(node)) {
         return node;
       }
       node = node.parent;
     }
     throw new AnalysisException("Cannot resolve node: no resolvable node");
   }
 
-  void _generateLints(AstNode node) {
-    LoggingTimer timer = logger.startTimer();
-    try {
-      if (_context.analysisOptions.lint) {
-        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);
-      } else {
-        _lints = AnalysisError.NO_ERRORS;
-      }
-    } finally {
-      timer.stop('generate lints');
-    }
-  }
-
   /**
    * 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 110 matching lines @@
     _updateErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS, []);
     _updateErrors_NEW(VARIABLE_REFERENCE_ERRORS, []);
     _updateErrors_NEW(VERIFY_ERRORS, _verifyErrors);
     // invalidate results we don't update incrementally
     newUnitEntry.setState(USED_IMPORTED_ELEMENTS, CacheState.INVALID);
     newUnitEntry.setState(USED_LOCAL_ELEMENTS, CacheState.INVALID);
     newUnitEntry.setState(HINTS, CacheState.INVALID);
   }
 
   void _updateEntry_OLD() {
-    {
-      List<AnalysisError> oldErrors = oldEntry.getValueInLibrary(
-          DartEntry.RESOLUTION_ERRORS, _librarySource);
-      List<AnalysisError> errors = _updateErrors(oldErrors, _resolveErrors);
-      oldEntry.setValueInLibrary(
-          DartEntry.RESOLUTION_ERRORS, _librarySource, errors);
-    }
-    {
-      List<AnalysisError> oldErrors = oldEntry.getValueInLibrary(
-          DartEntry.VERIFICATION_ERRORS, _librarySource);
-      List<AnalysisError> errors = _updateErrors(oldErrors, _verifyErrors);
-      oldEntry.setValueInLibrary(
-          DartEntry.VERIFICATION_ERRORS, _librarySource, errors);
-    }
-    oldEntry.setValueInLibrary(DartEntry.LINTS, _librarySource, _lints);
+    _updateErrors_OLD(DartEntry.RESOLUTION_ERRORS, _resolveErrors);
+    _updateErrors_OLD(DartEntry.VERIFICATION_ERRORS, _verifyErrors);
   }
 
   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 13 matching lines @@
     return errors;
   }
 
   void _updateErrors_NEW(ResultDescriptor<List<AnalysisError>> descriptor,
       List<AnalysisError> newErrors) {
     List<AnalysisError> oldErrors = newUnitEntry.getValue(descriptor);
     List<AnalysisError> errors = _updateErrors(oldErrors, newErrors);
     newUnitEntry.setValueIncremental(descriptor, errors);
   }
 
+  void _updateErrors_OLD(DataDescriptor<List<AnalysisError>> descriptor,
+      List<AnalysisError> newErrors) {
+    List<AnalysisError> oldErrors =
+        oldEntry.getValueInLibrary(descriptor, _librarySource);
+    List<AnalysisError> errors = _updateErrors(oldErrors, newErrors);
+    oldEntry.setValueInLibrary(descriptor, _librarySource, errors);
+  }
+
   void _verify(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter,
           _definingLibrary, _typeProvider,
           new InheritanceManager(_definingLibrary));
       if (_resolutionContext.enclosingClassDeclaration != null) {
         errorVerifier.visitClassDeclarationIncrementally(
@@ skipping 741 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }