Use memento in ScanDartTask.

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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 test.src.task.dart_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 1738 matching lines @@
     FunctionElement main = unit.element.functions[0];
     expectMutated(main.parameters[0], isFalse, isFalse);
     expectMutated(main.parameters[1], isFalse, isTrue);
     expectMutated(main.parameters[2], isTrue, isTrue);
     expectMutated(main.parameters[3], isTrue, isTrue);
   }
 }
 
 @reflectiveTest
 class ScanDartTaskTest extends _AbstractDartTaskTest {
+  void assertSameResults(List<ResultDescriptor> descriptors) {
+    descriptors.forEach((descriptor) {
+      var oldResult = oldOutputs[descriptor];
+      var newResult = outputs[descriptor];
+      expect(newResult, same(oldResult));
+    });
+  }
+
   test_buildInputs() {
     Map<String, TaskInput> inputs = ScanDartTask.buildInputs(emptySource);
     expect(inputs, isNotNull);
     expect(inputs.keys, unorderedEquals([ScanDartTask.CONTENT_INPUT_NAME]));
   }
 
   test_constructor() {
     ScanDartTask task = new ScanDartTask(context, emptySource);
     expect(task, isNotNull);
     expect(task.context, context);
@@ skipping 26 matching lines @@
   }
 
   test_perform_noErrors() {
     _performScanTask('class A {}');
     expect(outputs, hasLength(3));
     expect(outputs[LINE_INFO], isNotNull);
     expect(outputs[SCAN_ERRORS], hasLength(0));
     expect(outputs[TOKEN_STREAM], isNotNull);
   }
 
+  test_perform_useMemento() {
+    AnalysisTarget target = newSource('/test.dart', 'main() {}');
+    _computeResult(target, TOKEN_STREAM);
+    // update content
+    context.setContents(target, 'main() {}');
+    // recompute
+    _computeResult(target, TOKEN_STREAM);
+    // values from the mememto are returned
+    assertSameResults([LINE_INFO, SCAN_ERRORS, TOKEN_STREAM]);
+  }
+
   void _performScanTask(String content) {
     AnalysisTarget target = newSource('/test.dart', content);
     _computeResult(target, TOKEN_STREAM);
     expect(task, new isInstanceOf<ScanDartTask>());
   }
 }
 
 @reflectiveTest
 class VerifyUnitTaskTest extends _AbstractDartTaskTest {
   test_perform_verifyError() {
@@ skipping 10 matching lines @@
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 }
 
 class _AbstractDartTaskTest extends AbstractContextTest {
   Source emptySource;
 
+  Map<ResultDescriptor<dynamic>, dynamic> oldOutputs;
   AnalysisTask task;
   Map<ResultDescriptor<dynamic>, dynamic> outputs;
   GatheringErrorListener errorListener = new GatheringErrorListener();
 
   void setUp() {
     super.setUp();
     emptySource = newSource('/test.dart');
   }
 
   void _computeResult(AnalysisTarget target, ResultDescriptor result) {
+    oldOutputs = outputs;
     task = analysisDriver.computeResult(target, result);
     expect(task.caughtException, isNull);
     outputs = task.outputs;
   }
 
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }