Use memento in ParseDartTask.

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/context/cache.dart';
 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';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:unittest/unittest.dart';
@@ skipping 1489 matching lines @@
     expect(outputs, hasLength(7));
     expect(outputs[EXPORTED_LIBRARIES], hasLength(1));
     _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
     expect(outputs[INCLUDED_PARTS], hasLength(1));
     expect(outputs[PARSE_ERRORS], hasLength(1));
     expect(outputs[PARSED_UNIT], isNotNull);
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
     expect(outputs[UNITS], hasLength(2));
   }
 
+  test_perform_useMemento() {
+    String content = r'''
+library lib;
+import 'lib2.dart';
+export 'lib3.dart';
+part 'part.dart';
+class A {''';
+    AnalysisTarget target = newSource('/test.dart', content);
+    _computeResult(target, PARSED_UNIT);
+    // update content
+    context.setContents(target, content);
+    assertIsInvalid(target, PARSED_UNIT);
+    // recompute
+    _computeResult(target, PARSED_UNIT);
+    assertIsValid(target, PARSED_UNIT);
+    // values from the memento are returned
+    assertSameResults(ParseDartTask.DESCRIPTOR.results);
+  }
+
   void _performParseTask(String content) {
     AnalysisTarget target = newSource('/test.dart', content);
     _computeResult(target, PARSED_UNIT);
     expect(task, new isInstanceOf<ParseDartTask>());
   }
 
   static void _assertHasCore(List<Source> sources, int lenght) {
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
@@ skipping 274 matching lines @@
     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() {}');
+    assertIsInvalid(target, TOKEN_STREAM);
     // recompute
     _computeResult(target, TOKEN_STREAM);
-    // values from the mememto are returned
-    assertSameResults([LINE_INFO, SCAN_ERRORS, TOKEN_STREAM]);
+    assertIsValid(target, TOKEN_STREAM);
+    // values from the memento are returned
+    assertSameResults(ScanDartTask.DESCRIPTOR.results);
   }
 
   void _performScanTask(String content) {
     AnalysisTarget target = newSource('/test.dart', content);
     _computeResult(target, TOKEN_STREAM);
     expect(task, new isInstanceOf<ScanDartTask>());
   }
 }
 
 @reflectiveTest
@@ skipping 17 matching lines @@
 }
 
 class _AbstractDartTaskTest extends AbstractContextTest {
   Source emptySource;
 
   AnalysisTask task;
   Map<ResultDescriptor<dynamic>, dynamic> oldOutputs;
   Map<ResultDescriptor<dynamic>, dynamic> outputs;
   GatheringErrorListener errorListener = new GatheringErrorListener();
 
+  void assertIsInvalid(AnalysisTarget target, ResultDescriptor descriptor) {
+    CacheEntry entry = context.getCacheEntry(target);
+    expect(entry.isInvalid(descriptor), isTrue);
+  }
+
+  void assertIsValid(AnalysisTarget target, ResultDescriptor descriptor) {
+    CacheEntry entry = context.getCacheEntry(target);
+    expect(entry.isValid(descriptor), isTrue);
+  }
+
   void assertSameResults(List<ResultDescriptor> descriptors) {
     descriptors.forEach((descriptor) {
       var oldResult = oldOutputs[descriptor];
       var newResult = outputs[descriptor];
       expect(newResult, same(oldResult), reason: descriptor.name);
     });
   }
 
   void setUp() {
     super.setUp();
@@ skipping 10 matching lines @@
   /**
    * 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);
   }
 }