Adapt the existing incremental resolution implementation to the new model.

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:async';
@@ skipping 694 matching lines @@
    */
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource);
 
   /**
    * Return a list of the sources being analyzed in this context whose full path
    * is equal to the given [path].
    */
   List<Source> getSourcesWithFullName(String path);
 
   /**
+   * Invalidates hints in the given [librarySource] and included parts.
+   */
+  void invalidateLibraryHints(Source librarySource);
+
+  /**
    * Return `true` if the given [librarySource] is known to be the defining
    * compilation unit of a library that can be run on a client (references
    * 'dart:html', either directly or indirectly).
    *
    * <b>Note:</b> In addition to the expected case of returning `false` if the
    * source is known to be a library that cannot be run on a client, this method
    * will also return `false` if the source is not known to be a library or if
    * we do not know whether it can be run on a client.
    */
   bool isClientLibrary(Source librarySource);
@@ skipping 1422 matching lines @@
         _sourceChanged(source);
       }
     }
     if (notify && changed) {
       _onSourcesChangedController
           .add(new SourcesChangedEvent.changedContent(source, newContents));
     }
     return changed;
   }
 
-  /**
-   * Invalidates hints in the given [librarySource] and included parts.
-   */
+  @override
   void invalidateLibraryHints(Source librarySource) {
     SourceEntry sourceEntry = _cache.get(librarySource);
     if (sourceEntry is! DartEntry) {
       return;
     }
     DartEntry dartEntry = sourceEntry;
     // Prepare sources to invalidate hints in.
     List<Source> sources = <Source>[librarySource];
     sources.addAll(dartEntry.getValue(DartEntry.INCLUDED_PARTS));
     // Invalidate hints.
@@ skipping 2475 matching lines @@
       }
       // prepare the existing unit
       CompilationUnit oldUnit =
           getResolvedCompilationUnit2(unitSource, librarySource);
       if (oldUnit == null) {
         return false;
       }
       // do resolution
       Stopwatch perfCounter = new Stopwatch()..start();
       PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver(
-          typeProvider, unitSource, dartEntry, oldUnit,
-          analysisOptions.incrementalApi, analysisOptions);
+          typeProvider, unitSource, getReadableSourceEntryOrNull(unitSource),
+          null, null, oldUnit, analysisOptions.incrementalApi, analysisOptions);
       bool success = resolver.resolve(newCode);
       AnalysisEngine.instance.instrumentationService.logPerformance(
           AnalysisPerformanceKind.INCREMENTAL, perfCounter,
           'success=$success,context_id=$_id,code_length=${newCode.length}');
       if (!success) {
         return false;
       }
       // if validation, remember the result, but throw it away
       if (analysisOptions.incrementalValidation) {
         incrementalResolutionValidation_lastUnitSource = oldUnit.element.source;
@@ skipping 4332 matching lines @@
         cache.source, scanner.tokenMap, AnalysisErrorListener.NULL_LISTENER);
     _updatedUnit = parser.reparse(cache.resolvedUnit, scanner.leftToken,
         scanner.rightToken, cache.offset, cache.offset + cache.oldLength);
     // Update the resolution
     TypeProvider typeProvider = this.typeProvider;
     if (_updatedUnit != null && typeProvider != null) {
       CompilationUnitElement element = _updatedUnit.element;
       if (element != null) {
         LibraryElement library = element.library;
         if (library != null) {
-          IncrementalResolver resolver = new IncrementalResolver(
-              element, cache.offset, cache.oldLength, cache.newLength);
+          IncrementalResolver resolver = new IncrementalResolver(null, null,
+              null, element, cache.offset, cache.oldLength, cache.newLength);
           resolver.resolve(parser.updatedNode);
         }
       }
     }
   }
 }
 
 /**
  * Additional behavior for an analysis context that is required by internal
  * users of the context.
@@ skipping 2670 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }