Remove the old task model

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'
-    show CacheEntry, Delta, DeltaResult;
+import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart' show CONTENT, LINE_INFO;
-import 'package:analyzer/task/model.dart'
-    show AnalysisTarget, ResultDescriptor, TargetedResult, TaskDescriptor;
+import 'package:analyzer/task/model.dart';
 
 import 'ast.dart';
 import 'element.dart';
-import 'engine.dart'
-    show
-        AnalysisContext,
-        AnalysisOptions,
-        CacheState,
-        DartEntry,
-        DataDescriptor,
-        InternalAnalysisContext,
-        RecordingErrorListener,
-        SourceEntry;
+import 'engine.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'incremental_logger.dart' show logger, LoggingTimer;
 import 'java_engine.dart';
 import 'parser.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
 import 'utilities_dart.dart';
 
@@ skipping 923 matching lines @@
    * The type system primitives.
    */
   TypeSystem _typeSystem;
 
   /**
    * The element for the library containing the compilation unit being resolved.
    */
   LibraryElementImpl _definingLibrary;
 
   /**
-   * The [DartEntry] corresponding to the source being resolved.
-   */
-  DartEntry oldEntry;
-
-  /**
    * The [CacheEntry] corresponding to the source being resolved.
    */
   CacheEntry newSourceEntry;
 
   /**
    * The [CacheEntry] corresponding to the [LibrarySpecificUnit] being resolved.
    */
   CacheEntry newUnitEntry;
 
   /**
@@ skipping 35 matching lines @@
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = 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;
     _librarySource = _definingLibrary.source;
     _source = _definingUnit.source;
@@ skipping 191 matching lines @@
         }
         visitor.initForIncrementalResolution();
         node.accept(visitor);
       }
     } finally {
       timer.stop('resolve references');
     }
   }
 
   void _shiftEntryErrors() {
-    if (oldEntry != null) {
-      _shiftEntryErrors_OLD();
-    } else {
-      _shiftEntryErrors_NEW();
-    }
-  }
-
-  void _shiftEntryErrors_NEW() {
     _shiftErrors_NEW(HINTS);
     _shiftErrors_NEW(LINTS);
     _shiftErrors_NEW(LIBRARY_UNIT_ERRORS);
     _shiftErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS);
     _shiftErrors_NEW(RESOLVE_UNIT_ERRORS);
     _shiftErrors_NEW(STRONG_MODE_ERRORS);
     _shiftErrors_NEW(VARIABLE_REFERENCE_ERRORS);
     _shiftErrors_NEW(VERIFY_ERRORS);
   }
 
-  void _shiftEntryErrors_OLD() {
-    _shiftErrors_OLD(DartEntry.RESOLUTION_ERRORS);
-    _shiftErrors_OLD(DartEntry.VERIFICATION_ERRORS);
-    _shiftErrors_OLD(DartEntry.HINTS);
-    _shiftErrors_OLD(DartEntry.LINTS);
-  }
-
   void _shiftErrors(List<AnalysisError> errors) {
     for (AnalysisError error in errors) {
       if (_alreadyShiftedErrors.add(error)) {
         int errorOffset = error.offset;
         if (errorOffset > _updateOffset) {
           error.offset += _updateDelta;
         }
       }
     }
   }
 
   void _shiftErrors_NEW(ResultDescriptor<List<AnalysisError>> descriptor) {
     List<AnalysisError> errors = newUnitEntry.getValue(descriptor);
     _shiftErrors(errors);
   }
 
-  void _shiftErrors_OLD(DataDescriptor<List<AnalysisError>> descriptor) {
-    List<AnalysisError> errors =
-        oldEntry.getValueInLibrary(descriptor, _librarySource);
-    _shiftErrors(errors);
-  }
-
   void _updateCache() {
     if (newSourceEntry != null) {
       LoggingTimer timer = logger.startTimer();
       try {
         newSourceEntry.setState(CONTENT, CacheState.INVALID,
             delta: new IncrementalBodyDelta(_source, _updateOffset,
                 _updateEndOld, _updateEndNew, _updateDelta));
       } finally {
         timer.stop('invalidate cache with delta');
       }
     }
   }
 
   void _updateElementNameOffsets() {
     LoggingTimer timer = logger.startTimer();
     try {
       _definingUnit
           .accept(new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
       _definingUnit.afterIncrementalResolution();
     } finally {
       timer.stop('update element offsets');
     }
   }
 
   void _updateEntry() {
-    if (oldEntry != null) {
-      _updateEntry_OLD();
-    } else {
-      _updateEntry_NEW();
-    }
-  }
-
-  void _updateEntry_NEW() {
     _updateErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS, []);
     _updateErrors_NEW(RESOLVE_UNIT_ERRORS, _resolveErrors);
     _updateErrors_NEW(VARIABLE_REFERENCE_ERRORS, []);
     _updateErrors_NEW(VERIFY_ERRORS, _verifyErrors);
     // invalidate results we don't update incrementally
     newUnitEntry.setState(STRONG_MODE_ERRORS, CacheState.INVALID);
     newUnitEntry.setState(USED_IMPORTED_ELEMENTS, CacheState.INVALID);
     newUnitEntry.setState(USED_LOCAL_ELEMENTS, CacheState.INVALID);
     newUnitEntry.setState(HINTS, CacheState.INVALID);
     newUnitEntry.setState(LINTS, CacheState.INVALID);
   }
 
-  void _updateEntry_OLD() {
-    _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);
       } else if (errorOffset > _updateEndOld) {
         error.offset += _updateDelta;
@@ skipping 11 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, true);
   }
 
-  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),
           _context.analysisOptions.enableSuperMixins,
           _context.analysisOptions.enableAssertMessage);
       if (_resolutionContext.enclosingClassDeclaration != null) {
         errorVerifier.visitClassDeclarationIncrementally(
             _resolutionContext.enclosingClassDeclaration);
       }
       node.accept(errorVerifier);
       _verifyErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('verify');
     }
   }
 }
 
 class PoorMansIncrementalResolver {
   final TypeProvider _typeProvider;
   final Source _unitSource;
 
   /**
-   * The [DartEntry] corresponding to the source being resolved.
-   */
-  DartEntry _oldEntry;
-
-  /**
    * The [CacheEntry] corresponding to the source being resolved.
    */
-  CacheEntry _newSourceEntry;
+  CacheEntry _sourceEntry;
 
   /**
    * The [CacheEntry] corresponding to the [LibrarySpecificUnit] being resolved.
    */
-  CacheEntry _newUnitEntry;
+  CacheEntry _unitEntry;
 
   final CompilationUnit _oldUnit;
   CompilationUnitElement _unitElement;
 
   int _updateOffset;
   int _updateDelta;
   int _updateEndOld;
   int _updateEndNew;
 
   LineInfo _newLineInfo;
   List<AnalysisError> _newScanErrors = <AnalysisError>[];
   List<AnalysisError> _newParseErrors = <AnalysisError>[];
 
   PoorMansIncrementalResolver(
       this._typeProvider,
       this._unitSource,
-      this._oldEntry,
-      this._newSourceEntry,
-      this._newUnitEntry,
+      this._sourceEntry,
+      this._unitEntry,
       this._oldUnit,
       bool resolveApiChanges) {
     _resolveApiChanges = resolveApiChanges;
   }
 
   /**
    * Attempts to update [_oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
    * The [_oldUnit] might be damaged.
    */
@@ skipping 38 matching lines @@
             bool success = _resolveCommentDoc(newUnit, firstPair);
             logger.log('Documentation comment resolved: $success');
             return success;
           }
           // A pure whitespace change.
           if (firstPair.kind == _TokenDifferenceKind.OFFSET) {
             logger.log('Whitespace change.');
             _shiftTokens(firstPair.oldToken);
             {
               IncrementalResolver incrementalResolver = new IncrementalResolver(
-                  _oldEntry,
-                  _newSourceEntry,
-                  _newUnitEntry,
+                  _sourceEntry,
+                  _unitEntry,
                   _unitElement,
                   _updateOffset,
                   _updateEndOld,
                   _updateEndNew);
               incrementalResolver._updateCache();
               incrementalResolver._updateElementNameOffsets();
               incrementalResolver._shiftEntryErrors();
             }
             _updateEntry();
             logger.log('Success.');
@@ skipping 74 matching lines @@
           if (oldBeginToken.previous.type == TokenType.EOF) {
             _oldUnit.beginToken = newBeginToken;
           } else {
             oldBeginToken.previous.setNext(newBeginToken);
           }
           newNode.endToken.setNext(oldNode.endToken.next);
           _shiftTokens(oldNode.endToken.next);
         }
         // perform incremental resolution
         IncrementalResolver incrementalResolver = new IncrementalResolver(
-            _oldEntry,
-            _newSourceEntry,
-            _newUnitEntry,
+            _sourceEntry,
+            _unitEntry,
             _unitElement,
             _updateOffset,
             _updateEndOld,
             _updateEndNew);
         bool success = incrementalResolver.resolve(newNode);
         // check if success
         if (!success) {
           logger.log('Failure: element model changed.');
           return false;
         }
@@ skipping 48 matching lines @@
     logger.log('oldComment.beginToken: ${oldComment.beginToken}');
     logger.log('newComment.beginToken: ${newComment.beginToken}');
     _updateOffset = oldToken.offset - 1;
     // update token references
     _shiftTokens(firstPair.oldToken);
     _setPrecedingComments(oldToken, newComment.tokens.first);
     // replace node
     NodeReplacer.replace(oldComment, newComment);
     // update elements
     IncrementalResolver incrementalResolver = new IncrementalResolver(
-        _oldEntry,
-        _newSourceEntry,
-        _newUnitEntry,
+        _sourceEntry,
+        _unitEntry,
         _unitElement,
         _updateOffset,
         _updateEndOld,
         _updateEndNew);
     incrementalResolver._updateCache();
     incrementalResolver._updateElementNameOffsets();
     incrementalResolver._shiftEntryErrors();
     _updateEntry();
     // resolve references in the comment
     incrementalResolver._resolveReferences(newComment);
@@ skipping 43 matching lines @@
       }
       // next
       if (token.type == TokenType.EOF) {
         break;
       }
       token = token.next;
     }
   }
 
   void _updateEntry() {
-    if (_oldEntry != null) {
-      _updateEntry_OLD();
-    } else {
-      _updateEntry_NEW();
-    }
-  }
-
-  void _updateEntry_NEW() {
     // scan results
-    _newSourceEntry.setValueIncremental(SCAN_ERRORS, _newScanErrors, true);
-    _newSourceEntry.setValueIncremental(LINE_INFO, _newLineInfo, false);
+    _sourceEntry.setValueIncremental(SCAN_ERRORS, _newScanErrors, true);
+    _sourceEntry.setValueIncremental(LINE_INFO, _newLineInfo, false);
     // parse results
-    _newSourceEntry.setValueIncremental(PARSE_ERRORS, _newParseErrors, true);
-    _newSourceEntry.setValueIncremental(PARSED_UNIT, _oldUnit, false);
-  }
-
-  void _updateEntry_OLD() {
-    _oldEntry.setValue(SourceEntry.LINE_INFO, _newLineInfo);
-    _oldEntry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
-    _oldEntry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
+    _sourceEntry.setValueIncremental(PARSE_ERRORS, _newParseErrors, true);
+    _sourceEntry.setValueIncremental(PARSED_UNIT, _oldUnit, false);
   }
 
   /**
    * Checks if [token] has a balanced number of open and closed curly brackets.
    */
   static bool _areCurlyBracketsBalanced(Token token) {
     int numOpen = _getTokenCount(token, TokenType.OPEN_CURLY_BRACKET);
     int numOpen2 =
         _getTokenCount(token, TokenType.STRING_INTERPOLATION_EXPRESSION);
     int numClosed = _getTokenCount(token, TokenType.CLOSE_CURLY_BRACKET);
@@ skipping 390 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }