Validate incremental resolutions results if requested.

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 15 matching lines @@
 import 'incremental_scanner.dart';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'parser.dart' show Parser, IncrementalParser;
 import 'resolver.dart';
 import 'scanner.dart';
 import 'sdk.dart' show DartSdk;
 import 'source.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
+import 'package:analyzer/src/generated/incremental_resolution_validator.dart';
 
 /**
  * Type of callback functions used by PendingFuture.  Functions of this type
  * should perform a computation based on the data in [sourceEntry] and return
  * it.  If the computation can't be performed yet because more analysis is
  * needed, null should be returned.
  *
  * The function may also throw an exception, in which case the corresponding
  * future will be completed with failure.
  *
@@ skipping 988 matching lines @@
    */
   StreamController<SourcesChangedEvent> _onSourcesChangedController;
 
   /**
    * The listeners that are to be notified when various analysis results are produced in this
    * context.
    */
   List<AnalysisListener> _listeners = new List<AnalysisListener>();
 
   /**
+   * The most recently incrementally resolved [Source].
+   * Is null when it was already validated, or the most recent change was
+   * not incrementally resolved.
+   */
+  Source incrementalResolutionValidation_lastUnitSource;
+
+  /**
+   * The most recently incrementally resolved library [Source].
+   * Is null when it was already validated, or the most recent change was
+   * not incrementally resolved.
+   */
+  Source incrementalResolutionValidation_lastLibrarySource;
+
+  /**
+   * The result of incremental resolution result of
+   * [incrementalResolutionValidation_lastSource].
+   */
+  CompilationUnit incrementalResolutionValidation_lastUnit;
+
+  /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _privatePartition = new UniversalCachePartition(
         this,
         AnalysisOptionsImpl.DEFAULT_CACHE_SIZE,
         new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
     _onSourcesChangedController =
@@ skipping 1099 matching lines @@
     if (_TRACE_PERFORM_TASK) {
       print("----------------------------------------");
     }
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
     if (task == null && _validateCacheConsistency()) {
       task = nextAnalysisTask;
     }
     if (task == null) {
+      _validateLastIncrementalResolutionResult();
       return new AnalysisResult(
           _getChangeNotices(true),
           getEnd - getStart,
           null,
           -1);
     }
     String taskDescription = task.toString();
     _notifyAboutToPerformTask(taskDescription);
     if (_TRACE_PERFORM_TASK) {
       print(taskDescription);
@@ skipping 29 matching lines @@
       //      }
       _notifyErrors(source, notice.errors, notice.lineInfo);
     }
     return new AnalysisResult(
         notices,
         getEnd - getStart,
         task.runtimeType.toString(),
         performEnd - performStart);
   }
 
+  void _validateLastIncrementalResolutionResult() {
+    if (incrementalResolutionValidation_lastUnitSource == null ||
+        incrementalResolutionValidation_lastLibrarySource == null ||
+        incrementalResolutionValidation_lastUnit == null) {
+      return;
+    }
+    CompilationUnit fullUnit = getResolvedCompilationUnit2(
+        incrementalResolutionValidation_lastUnitSource,
+        incrementalResolutionValidation_lastLibrarySource);
+    if (fullUnit != null) {
+      try {
+        assertSameResolution(incrementalResolutionValidation_lastUnit, fullUnit);

[danrubel, 2015/01/07 22:32:48]

Should this be asserting valid types?

[scheglov, 2015/01/07 23:24:11]

We should, but we cannot.
See my message about Elements equality.

We can work it around for compering elements themselves, but DartTypes also
compare elements, so it still fails if we try.

+      } on IncrementalResolutionMismatch catch (mismatch, stack) {
+        String failure = mismatch.message;
+        String message = 'Incremental resolution mismatch:\n$failure\nat\n$stack';
+        AnalysisEngine.instance.instrumentationService.logError(message);
+      }
+    }
+    incrementalResolutionValidation_lastUnitSource = null;
+    incrementalResolutionValidation_lastLibrarySource = null;
+    incrementalResolutionValidation_lastUnit = null;
+  }
+
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
     elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         _recordElementData(dartEntry, library, library.source, htmlSource);
@@ skipping 2854 matching lines @@
     }
     _cache.remove(source);
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * TODO(scheglov) A hackish, limited incremental resolution implementation.
    */
   bool _tryPoorMansIncrementalResolution(Source unitSource, String newCode) {
+    incrementalResolutionValidation_lastUnitSource = null;
+    incrementalResolutionValidation_lastLibrarySource = null;
+    incrementalResolutionValidation_lastUnit = null;
+    // prepare the entry
     DartEntry dartEntry = _cache.get(unitSource);
     if (dartEntry == null) {
       return false;
     }
     // prepare the (only) library
     List<Source> librarySources = getLibrariesContaining(unitSource);
     if (librarySources.length != 1) {
       return false;
     }
     // prepare the existing unit
     Source librarySource = librarySources[0];
     CompilationUnit oldUnit =
         getResolvedCompilationUnit2(unitSource, librarySource);
     if (oldUnit == null) {
       return false;
     }
     // do resolution
     PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver(
         typeProvider,
         unitSource,
         dartEntry,
         analysisOptions.incrementalApi);
     bool success = resolver.resolve(oldUnit, newCode);
     if (!success) {
       return false;
     }
+    // if validation, remember the result, but throw it away

[danrubel, 2015/01/07 22:32:48]

Can we switch this around so that it remembers the incremental solution so that
code completion is still fast, but verifies it after all other tasks are
complete?

[scheglov, 2015/01/07 23:24:11]

Unfortunately I don't see how to make it work.
If we don't ignore incremental results, we don't get "full" results from tasks
:-(

+    if (analysisOptions.incrementalValidation) {
+      incrementalResolutionValidation_lastUnitSource = oldUnit.element.source;
+      incrementalResolutionValidation_lastLibrarySource = oldUnit.element.library.source;
+      incrementalResolutionValidation_lastUnit = oldUnit;
+      return false;
+    }
     // prepare notice
     ChangeNoticeImpl notice = _getNotice(unitSource);
     notice.compilationUnit = oldUnit;
     // apply updated errors
     {
       LineInfo lineInfo = getLineInfo(unitSource);
       notice.setErrors(dartEntry.allErrors, lineInfo);
     }
+    // OK
     return true;
   }
 
   /**
    * Check the cache for any invalid entries (entries whose modification time does not match the
    * modification time of the source associated with the entry). Invalid entries will be marked as
    * invalid so that the source will be re-analyzed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
@@ skipping 9311 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }