Remove memento.

pkg/analyzer/test/src/context/cache_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.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show
         AnalysisContext,
@@ skipping 118 matching lines @@
   }
 
   test_fixExceptionState_noError_exception() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
     // set one result to ERROR
     CaughtException exception = new CaughtException(null, null);
     entry.setErrorState(exception, <ResultDescriptor>[result]);
     // set the same result to VALID
-    entry.setValue(result, 1, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result, 1, TargetedResult.EMPTY_LIST);
     // fix the exception state
     entry.fixExceptionState();
     expect(entry.exception, isNull);
   }
 
   test_fixExceptionState_noError_noException() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
     entry.fixExceptionState();
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.exception, isNull);
   }
 
-  test_getMemento_noResult() {
-    AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
-    CacheEntry entry = new CacheEntry(target);
-    expect(entry.getMemento(result), null);
-  }
-
   test_getState() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
     expect(entry.getState(result), CacheState.INVALID);
   }
 
   test_getValue_default() {
     AnalysisTarget target = new TestSource();
     String defaultValue = 'value';
     ResultDescriptor result = new ResultDescriptor('test', defaultValue);
     CacheEntry entry = new CacheEntry(target);
     expect(entry.getValue(result), defaultValue);
   }
 
   test_getValue_flushResults() {
     ResultCachingPolicy cachingPolicy = new SimpleResultCachingPolicy(2, 2);
     ResultDescriptor descriptor1 =
         new ResultDescriptor('result1', null, cachingPolicy: cachingPolicy);
     ResultDescriptor descriptor2 =
         new ResultDescriptor('result2', null, cachingPolicy: cachingPolicy);
     ResultDescriptor descriptor3 =
         new ResultDescriptor('result3', null, cachingPolicy: cachingPolicy);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     {
-      entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST, null);
+      entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
     }
     {
-      entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST, null);
+      entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
       expect(entry.getState(descriptor2), CacheState.VALID);
     }
     // get descriptor1, so that descriptor2 will be flushed
     entry.getValue(descriptor1);
     {
-      entry.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST, null);
+      entry.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
       expect(entry.getState(descriptor2), CacheState.FLUSHED);
       expect(entry.getState(descriptor3), CacheState.VALID);
     }
   }
 
   test_hasErrorState_false() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     expect(entry.hasErrorState(), false);
   }
 
   test_hasErrorState_true() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry(target);
     entry.setErrorState(exception, <ResultDescriptor>[result]);
     expect(entry.hasErrorState(), true);
   }
 
   test_invalidateAllInformation() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
-    entry.setValue(result, 'value', TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result, 'value', TargetedResult.EMPTY_LIST);
     entry.invalidateAllInformation();
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.getValue(result), isNull);
   }
 
   test_setErrorState() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result1 = new ResultDescriptor('res1', 1);
     ResultDescriptor result2 = new ResultDescriptor('res2', 2);
     ResultDescriptor result3 = new ResultDescriptor('res3', 3);
     // prepare some good state
     CacheEntry entry = new CacheEntry(target);
-    entry.setValue(result1, 10, TargetedResult.EMPTY_LIST, null);
-    entry.setValue(result2, 20, TargetedResult.EMPTY_LIST, null);
-    entry.setValue(result3, 30, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result1, 10, TargetedResult.EMPTY_LIST);
+    entry.setValue(result2, 20, TargetedResult.EMPTY_LIST);
+    entry.setValue(result3, 30, TargetedResult.EMPTY_LIST);
     // set error state
     CaughtException exception = new CaughtException(null, null);
     entry.setErrorState(exception, <ResultDescriptor>[result1, result2]);
     // verify
     expect(entry.exception, exception);
     expect(entry.getState(result1), CacheState.ERROR);
     expect(entry.getState(result2), CacheState.ERROR);
     expect(entry.getState(result3), CacheState.VALID);
     expect(entry.getValue(result1), 1);
     expect(entry.getValue(result2), 2);
     expect(entry.getValue(result3), 30);
   }
 
   test_setErrorState_invalidateDependent() {
     AnalysisTarget target1 = new TestSource('/a.dart');
     AnalysisTarget target2 = new TestSource('/b.dart');
     CacheEntry entry1 = new CacheEntry(target1);
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
     ResultDescriptor result1 = new ResultDescriptor('result1', -1);
     ResultDescriptor result2 = new ResultDescriptor('result2', -2);
     ResultDescriptor result3 = new ResultDescriptor('result3', -3);
     ResultDescriptor result4 = new ResultDescriptor('result4', -4);
     // set results, all of them are VALID
-    entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST, null);
-    entry2.setValue(result2, 222, [new TargetedResult(target1, result1)], null);
-    entry2.setValue(result3, 333, [new TargetedResult(target2, result2)], null);
-    entry2.setValue(result4, 444, [], null);
+    entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
+    entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
+    entry2.setValue(result3, 333, [new TargetedResult(target2, result2)]);
+    entry2.setValue(result4, 444, []);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry2.getState(result2), CacheState.VALID);
     expect(entry2.getState(result3), CacheState.VALID);
     expect(entry2.getState(result4), CacheState.VALID);
     expect(entry1.getValue(result1), 111);
     expect(entry2.getValue(result2), 222);
     expect(entry2.getValue(result3), 333);
     expect(entry2.getValue(result4), 444);
     // set error state
     CaughtException exception = new CaughtException(null, null);
@@ skipping 35 matching lines @@
     CacheEntry entry = new CacheEntry(target);
     expect(() {
       entry.setErrorState(exception, null);
     }, throwsArgumentError);
   }
 
   test_setState_error() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
-    entry.setValue(result, 42, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result, 42, TargetedResult.EMPTY_LIST);
     // an invalid state change
     expect(() {
       entry.setState(result, CacheState.ERROR);
     }, throwsArgumentError);
     // no changes
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 42);
   }
 
   test_setState_flushed() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', 1);
     CacheEntry entry = new CacheEntry(target);
     // set VALID
-    entry.setValue(result, 10, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 10);
     // set FLUSHED
     entry.setState(result, CacheState.FLUSHED);
     expect(entry.getState(result), CacheState.FLUSHED);
     expect(entry.getValue(result), 1);
   }
 
   test_setState_inProcess() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', 1);
     CacheEntry entry = new CacheEntry(target);
     // set VALID
-    entry.setValue(result, 10, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 10);
     // set IN_PROCESS
     entry.setState(result, CacheState.IN_PROCESS);
     expect(entry.getState(result), CacheState.IN_PROCESS);
     expect(entry.getValue(result), 10);
   }
 
   test_setState_invalid() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', 1);
     CacheEntry entry = new CacheEntry(target);
     // set VALID
-    String memento = 'main() {}';
-    entry.setValue(result, 10, TargetedResult.EMPTY_LIST, memento);
+    entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 10);
     // set INVALID
     entry.setState(result, CacheState.INVALID);
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.getValue(result), 1);
-    expect(entry.getMemento(result), memento);
   }
 
   test_setState_invalid_invalidateDependent() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     ResultDescriptor result1 = new ResultDescriptor('result1', -1);
     ResultDescriptor result2 = new ResultDescriptor('result2', -2);
     ResultDescriptor result3 = new ResultDescriptor('result3', -3);
     ResultDescriptor result4 = new ResultDescriptor('result4', -4);
     // set results, all of them are VALID
-    entry.setValue(result1, 111, TargetedResult.EMPTY_LIST, null);
-    entry.setValue(result2, 222, [new TargetedResult(target, result1)], null);
-    entry.setValue(result3, 333, [new TargetedResult(target, result2)], null);
-    entry.setValue(result4, 444, [], null);
+    entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
+    entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
+    entry.setValue(result3, 333, [new TargetedResult(target, result2)]);
+    entry.setValue(result4, 444, []);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getState(result3), CacheState.VALID);
     expect(entry.getState(result4), CacheState.VALID);
     expect(entry.getValue(result1), 111);
     expect(entry.getValue(result2), 222);
     expect(entry.getValue(result3), 333);
     expect(entry.getValue(result4), 444);
     // invalidate result1, invalidates result2 and result3, result4 is intact
     entry.setState(result1, CacheState.INVALID);
@@ skipping 11 matching lines @@
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
     expect(() => entry.setState(result, CacheState.VALID), throwsArgumentError);
   }
 
   test_setValue() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     String value = 'value';
-    String memento = 'main() {}';
     CacheEntry entry = new CacheEntry(target);
-    entry.setValue(result, value, TargetedResult.EMPTY_LIST, memento);
+    entry.setValue(result, value, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), value);
-    expect(entry.getMemento(result), memento);
   }
 
   test_setValue_flushResults() {
     ResultCachingPolicy cachingPolicy = new SimpleResultCachingPolicy(2, 2);
     ResultDescriptor descriptor1 =
         new ResultDescriptor('result1', null, cachingPolicy: cachingPolicy);
     ResultDescriptor descriptor2 =
         new ResultDescriptor('result2', null, cachingPolicy: cachingPolicy);
     ResultDescriptor descriptor3 =
         new ResultDescriptor('result3', null, cachingPolicy: cachingPolicy);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    Object memento1 = 'aaa';
     {
-      entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST, memento1);
+      entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
-      expect(entry.getMemento(descriptor1), memento1);
     }
     {
-      entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST, null);
+      entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
       expect(entry.getState(descriptor2), CacheState.VALID);
     }
     {
-      entry.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST, null);
+      entry.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.FLUSHED);
       expect(entry.getState(descriptor2), CacheState.VALID);
       expect(entry.getState(descriptor3), CacheState.VALID);
-      expect(entry.getMemento(descriptor1), isNull);
     }
   }
 
   test_setValue_invalidateDependent() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     ResultDescriptor result1 = new ResultDescriptor('result1', -1);
     ResultDescriptor result2 = new ResultDescriptor('result2', -2);
     ResultDescriptor result3 = new ResultDescriptor('result3', -3);
     ResultDescriptor result4 = new ResultDescriptor('result4', -4);
     // set results, all of them are VALID
-    entry.setValue(result1, 111, TargetedResult.EMPTY_LIST, null);
-    entry.setValue(result2, 222, [new TargetedResult(target, result1)], null);
-    entry.setValue(result3, 333, [new TargetedResult(target, result2)], null);
-    entry.setValue(result4, 444, [], null);
+    entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
+    entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
+    entry.setValue(result3, 333, [new TargetedResult(target, result2)]);
+    entry.setValue(result4, 444, []);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getState(result3), CacheState.VALID);
     expect(entry.getState(result4), CacheState.VALID);
     expect(entry.getValue(result1), 111);
     expect(entry.getValue(result2), 222);
     expect(entry.getValue(result3), 333);
     expect(entry.getValue(result4), 444);
     // set result1, invalidates result2 and result3, result4 is intact
-    entry.setValue(result1, 1111, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result1, 1111, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.INVALID);
     expect(entry.getState(result3), CacheState.INVALID);
     expect(entry.getState(result4), CacheState.VALID);
     expect(entry.getValue(result1), 1111);
     expect(entry.getValue(result2), -2);
     expect(entry.getValue(result3), -3);
     expect(entry.getValue(result4), 444);
   }
 
   test_setValue_invalidateDependent2() {
     AnalysisTarget target1 = new TestSource('a');
     AnalysisTarget target2 = new TestSource('b');
     CacheEntry entry1 = new CacheEntry(target1);
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
     ResultDescriptor result1 = new ResultDescriptor('result1', -1);
     ResultDescriptor result2 = new ResultDescriptor('result2', -2);
     ResultDescriptor result3 = new ResultDescriptor('result3', -3);
     // set results, all of them are VALID
-    entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST, null);
-    entry1.setValue(result2, 222, [new TargetedResult(target1, result1)], null);
-    entry2.setValue(result3, 333, [new TargetedResult(target1, result2)], null);
+    entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
+    entry1.setValue(result2, 222, [new TargetedResult(target1, result1)]);
+    entry2.setValue(result3, 333, [new TargetedResult(target1, result2)]);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry1.getState(result2), CacheState.VALID);
     expect(entry2.getState(result3), CacheState.VALID);
     expect(entry1.getValue(result1), 111);
     expect(entry1.getValue(result2), 222);
     expect(entry2.getValue(result3), 333);
     // set result1, invalidates result2 and result3
-    entry1.setValue(result1, 1111, TargetedResult.EMPTY_LIST, null);
+    entry1.setValue(result1, 1111, TargetedResult.EMPTY_LIST);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry1.getState(result2), CacheState.INVALID);
     expect(entry2.getState(result3), CacheState.INVALID);
     expect(entry1.getValue(result1), 1111);
     expect(entry1.getValue(result2), -2);
     expect(entry2.getValue(result3), -3);
   }
 
   test_toString_empty() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     expect(entry.toString(), isNotNull);
   }
 
   test_toString_nonEmpty() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry(target);
-    entry.setValue(result, 42, TargetedResult.EMPTY_LIST, null);
+    entry.setValue(result, 42, TargetedResult.EMPTY_LIST);
     expect(entry.toString(), isNotNull);
   }
 }
 
 @reflectiveTest
 class CacheFlushManagerTest {
   CacheFlushManager manager = new CacheFlushManager(
       new SimpleResultCachingPolicy(15, 3), (AnalysisTarget target) => false);
 
   test_madeActive() {
@@ skipping 193 matching lines @@
     expect(data, isNotNull);
     expect(data.state, CacheState.INVALID);
     expect(data.value, value);
   }
 
   test_flush() {
     ResultDescriptor result = new ResultDescriptor('test', -1);
     ResultData data = new ResultData(result);
     data.state = CacheState.VALID;
     data.value = 123;
-    data.memento = 'abc';
     data.flush();
     expect(data.state, CacheState.FLUSHED);
     expect(data.value, -1);
-    expect(data.memento, isNull);
   }
 }
 
 @reflectiveTest
 class SdkCachePartitionTest extends CachePartitionTest {
   CachePartition createPartition() {
     return new SdkCachePartition(null);
   }
 
   void test_contains_false() {
@@ skipping 21 matching lines @@
     UniversalCachePartition partition = new UniversalCachePartition(null);
     TestSource source = new TestSource();
     expect(partition.isResponsibleFor(source), isTrue);
   }
 }
 
 class _InternalAnalysisContextMock extends TypedMock
     implements InternalAnalysisContext {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }