Set CacheEntry.target in the contructor.

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 44 matching lines @@
   void test_getContextFor() {
     AnalysisContext context = new TestAnalysisContext();
     AnalysisCache cache = createCache(context: context);
     AnalysisTarget target = new TestSource();
     expect(cache.getContextFor(target), context);
   }
 
   void test_iterator() {
     AnalysisCache cache = createCache();
     AnalysisTarget target = new TestSource();
-    CacheEntry entry = new CacheEntry();
-    cache.put(target, entry);
+    CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     MapIterator<AnalysisTarget, CacheEntry> iterator = cache.iterator();
     expect(iterator.moveNext(), isTrue);
     expect(iterator.key, same(target));
     expect(iterator.value, same(entry));
     expect(iterator.moveNext(), isFalse);
   }
 
   void test_put() {
     AnalysisCache cache = createCache();
     AnalysisTarget target = new TestSource();
-    CacheEntry entry = new CacheEntry();
+    CacheEntry entry = new CacheEntry(target);
     expect(cache.get(target), isNull);
-    cache.put(target, entry);
+    cache.put(entry);
     expect(cache.get(target), entry);
   }
 
   void test_remove() {
     AnalysisCache cache = createCache();
     AnalysisTarget target = new TestSource();
     cache.remove(target);
   }
 
   void test_size() {
     AnalysisCache cache = createCache();
     int size = 4;
     for (int i = 0; i < size; i++) {
       AnalysisTarget target = new TestSource("/test$i.dart");
-      cache.put(target, new CacheEntry());
+      cache.put(new CacheEntry(target));
     }
     expect(cache.size(), size);
   }
 }
 
 @reflectiveTest
 class CacheEntryTest extends EngineTestCase {
   InternalAnalysisContext context;
   AnalysisCache cache;
 
   void setUp() {
     context = new _InternalAnalysisContextMock();
     when(context.priorityTargets).thenReturn([]);
     cache = createCache(context: context);
     when(context.analysisCache).thenReturn(cache);
   }
 
   test_explicitlyAdded() {
-    CacheEntry entry = new CacheEntry();
+    AnalysisTarget target = new TestSource();
+    CacheEntry entry = new CacheEntry(target);
     expect(entry.explicitlyAdded, false);
     entry.explicitlyAdded = true;
     expect(entry.explicitlyAdded, true);
   }
 
   test_fixExceptionState_error_exception() {
+    AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
     CaughtException exception = new CaughtException(null, null);
-    CacheEntry entry = new CacheEntry();
+    CacheEntry entry = new CacheEntry(target);
     entry.setErrorState(exception, <ResultDescriptor>[result]);
     entry.fixExceptionState();
     expect(entry.getState(result), CacheState.ERROR);
     expect(entry.exception, exception);
   }
 
   test_fixExceptionState_noError_exception() {
+    AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
-    CacheEntry entry = new CacheEntry();
+    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);
     // 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();
+    CacheEntry entry = new CacheEntry(target);
     entry.fixExceptionState();
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.exception, isNull);
   }
 
   test_getMemento_noResult() {
-    String defaultValue = 'value';
-    ResultDescriptor result = new ResultDescriptor('test', defaultValue);
-    CacheEntry entry = new CacheEntry();
+    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();
+    CacheEntry entry = new CacheEntry(target);
     expect(entry.getState(result), CacheState.INVALID);
   }
 
-  test_getValue() {
+  test_getValue_default() {
+    AnalysisTarget target = new TestSource();
     String defaultValue = 'value';
     ResultDescriptor result = new ResultDescriptor('test', defaultValue);
-    CacheEntry entry = new CacheEntry();
+    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();
-    cache.put(target, entry);
+    CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     {
       entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST, null);
       expect(entry.getState(descriptor1), CacheState.VALID);
     }
     {
       entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST, null);
       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);
       expect(entry.getState(descriptor1), CacheState.VALID);
       expect(entry.getState(descriptor2), CacheState.FLUSHED);
       expect(entry.getState(descriptor3), CacheState.VALID);
     }
   }
 
   test_hasErrorState_false() {
-    CacheEntry entry = new CacheEntry();
+    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();
+    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();
+    CacheEntry entry = new CacheEntry(target);
     entry.setValue(result, 'value', TargetedResult.EMPTY_LIST, null);
     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();
+    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);
     // 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();
-    CacheEntry entry2 = new CacheEntry();
-    cache.put(target1, entry1);
-    cache.put(target2, entry2);
+    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);
     expect(entry1.getState(result1), CacheState.VALID);
@@ skipping 14 matching lines @@
     expect(entry2.getState(result4), CacheState.VALID);
     expect(entry1.getValue(result1), -1);
     expect(entry2.getValue(result2), -2);
     expect(entry2.getValue(result3), -3);
     expect(entry2.getValue(result4), 444);
     expect(entry1.exception, exception);
     expect(entry2.exception, exception);
   }
 
   test_setErrorState_noDescriptors() {
+    AnalysisTarget target = new TestSource();
     CaughtException exception = new CaughtException(null, null);
-    CacheEntry entry = new CacheEntry();
+    CacheEntry entry = new CacheEntry(target);
     expect(() {
       entry.setErrorState(exception, <ResultDescriptor>[]);
     }, throwsArgumentError);
   }
 
   test_setErrorState_noException() {
+    AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
-    CacheEntry entry = new CacheEntry();
+    CacheEntry entry = new CacheEntry(target);
     expect(() {
       entry.setErrorState(null, <ResultDescriptor>[result]);
     }, throwsArgumentError);
   }
 
   test_setErrorState_nullDescriptors() {
+    AnalysisTarget target = new TestSource();
     CaughtException exception = new CaughtException(null, null);
-    CacheEntry entry = new CacheEntry();
+    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();
+    CacheEntry entry = new CacheEntry(target);
     entry.setValue(result, 42, TargetedResult.EMPTY_LIST, null);
     // 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();
+    CacheEntry entry = new CacheEntry(target);
     // set VALID
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST, null);
     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();
+    CacheEntry entry = new CacheEntry(target);
     // set VALID
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST, null);
     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();
+    CacheEntry entry = new CacheEntry(target);
     // set VALID
     String memento = 'main() {}';
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST, memento);
     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();
-    cache.put(target, entry);
+    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);
     expect(entry.getState(result1), CacheState.VALID);
@@ skipping 10 matching lines @@
     expect(entry.getState(result2), CacheState.INVALID);
     expect(entry.getState(result3), CacheState.INVALID);
     expect(entry.getState(result4), CacheState.VALID);
     expect(entry.getValue(result1), -1);
     expect(entry.getValue(result2), -2);
     expect(entry.getValue(result3), -3);
     expect(entry.getValue(result4), 444);
   }
 
   test_setState_valid() {
+    AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
-    CacheEntry entry = new CacheEntry();
+    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();
+    CacheEntry entry = new CacheEntry(target);
     entry.setValue(result, value, TargetedResult.EMPTY_LIST, memento);
     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();
-    cache.put(target, entry);
+    CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     Object memento1 = 'aaa';
     {
       entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST, memento1);
       expect(entry.getState(descriptor1), CacheState.VALID);
       expect(entry.getMemento(descriptor1), memento1);
     }
     {
       entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST, null);
       expect(entry.getState(descriptor1), CacheState.VALID);
       expect(entry.getState(descriptor2), CacheState.VALID);
     }
     {
       entry.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST, null);
       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();
-    cache.put(target, entry);
+    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);
     expect(entry.getState(result1), CacheState.VALID);
@@ skipping 12 matching lines @@
     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();
-    CacheEntry entry2 = new CacheEntry();
-    cache.put(target1, entry1);
-    cache.put(target2, entry2);
+    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);
     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);
     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() {
-    CacheEntry entry = new CacheEntry();
+    AnalysisTarget target = new TestSource();
+    CacheEntry entry = new CacheEntry(target);
     expect(entry.toString(), isNotNull);
   }
 
   test_toString_nonEmpty() {
-    String value = 'value';
+    AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
-    CacheEntry entry = new CacheEntry();
-    entry.setValue(result, value, TargetedResult.EMPTY_LIST, null);
+    CacheEntry entry = new CacheEntry(target);
+    entry.setValue(result, 42, TargetedResult.EMPTY_LIST, null);
     expect(entry.toString(), isNotNull);
   }
 }
 
 @reflectiveTest
 class CacheFlushManagerTest {
   CacheFlushManager manager = new CacheFlushManager(
       new SimpleResultCachingPolicy(15, 3), (AnalysisTarget target) => false);
 
   test_madeActive() {
@@ skipping 135 matching lines @@
 abstract class CachePartitionTest extends EngineTestCase {
   CachePartition createPartition();
 
   void test_creation() {
     expect(createPartition(), isNotNull);
   }
 
   void test_entrySet() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
-    CacheEntry entry = new CacheEntry();
-    partition.put(target, entry);
+    CacheEntry entry = new CacheEntry(target);
+    partition.put(entry);
     Map<AnalysisTarget, CacheEntry> entryMap = partition.map;
     expect(entryMap, hasLength(1));
     AnalysisTarget entryKey = entryMap.keys.first;
     expect(entryKey, target);
     expect(entryMap[entryKey], entry);
   }
 
   void test_get() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
     expect(partition.get(target), isNull);
   }
 
   void test_put_alreadyInPartition() {
     CachePartition partition1 = createPartition();
     CachePartition partition2 = createPartition();
     AnalysisTarget target = new TestSource();
-    CacheEntry entry = new CacheEntry();
-    partition1.put(target, entry);
-    expect(() => partition2.put(target, entry), throwsStateError);
+    CacheEntry entry = new CacheEntry(target);
+    partition1.put(entry);
+    expect(() => partition2.put(entry), throwsStateError);
   }
 
   void test_put_noFlush() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
-    CacheEntry entry = new CacheEntry();
-    partition.put(target, entry);
+    CacheEntry entry = new CacheEntry(target);
+    partition.put(entry);
     expect(partition.get(target), entry);
   }
 
   void test_remove() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
-    CacheEntry entry = new CacheEntry();
-    partition.put(target, entry);
+    CacheEntry entry = new CacheEntry(target);
+    partition.put(entry);
     expect(partition.get(target), entry);
     partition.remove(target);
     expect(partition.get(target), isNull);
   }
 }
 
 @reflectiveTest
 class ResultDataTest extends EngineTestCase {
   test_creation() {
     String value = 'value';
@@ skipping 47 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);
 }