Fix newly introduced errors and warnings

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 analyzer.test.src.context.cache_test;
 
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
@@ skipping 40 matching lines @@
 }
 
 @reflectiveTest
 class AnalysisCacheTest extends AbstractCacheTest {
   void test_creation() {
     expect(cache, isNotNull);
   }
 
   test_flush() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor resultA = new ResultDescriptor('A', null);
-    ResultDescriptor resultB = new ResultDescriptor('B', null);
+    ResultDescriptor<String> resultA = new ResultDescriptor<String>('A', null);

[scheglov, 2016/09/21 00:05:07]

I would just drop the LHS type.

[Jennifer Messerly, 2016/09/21 00:20:30]

yeah +1 to that.

But I do wonder about this one. The old behavior would've inferred
ResultDescriptor<dynamic>. Does that not happen anymore?

[Brian Wilkerson, 2016/09/21 15:00:43]

I expect someone will write a bulk edit tool at some point that will remove type
annotations, so I'm not going to waste my time removing them by hand. :-)

+    ResultDescriptor<String> resultB = new ResultDescriptor<String>('B', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // put values
     entry.setValue(resultA, 'a', TargetedResult.EMPTY_LIST);
     entry.setValue(resultB, 'b', TargetedResult.EMPTY_LIST);
     expect(cache.getState(target, resultA), CacheState.VALID);
     expect(cache.getState(target, resultB), CacheState.VALID);
     expect(cache.getValue(target, resultA), 'a');
     expect(cache.getValue(target, resultB), 'b');
     // flush A
@@ skipping 44 matching lines @@
   void test_getState_hasEntry_flushed() {
     ResultDescriptor result = new ResultDescriptor('result', -1);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     entry.setState(result, CacheState.FLUSHED);
     expect(cache.getState(target, result), CacheState.FLUSHED);
   }
 
   void test_getState_hasEntry_valid() {
-    ResultDescriptor result = new ResultDescriptor('result', -1);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('result', null);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     entry.setValue(result, '', []);
     expect(cache.getState(target, result), CacheState.VALID);
   }
 
   void test_getState_noEntry() {
     ResultDescriptor result = new ResultDescriptor('result', -1);
     AnalysisTarget target = new TestSource();
     expect(cache.getState(target, result), CacheState.INVALID);
   }
 
   void test_getValue_hasEntry_valid() {
-    ResultDescriptor result = new ResultDescriptor('result', -1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('result', -1);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     entry.setValue(result, 111, []);
     expect(cache.getValue(target, result), 111);
   }
 
   void test_getValue_noEntry() {
     ResultDescriptor result = new ResultDescriptor('result', -1);
     AnalysisTarget target = new TestSource();
@@ skipping 22 matching lines @@
   void test_remove() {
     AnalysisTarget target1 = new TestSource('/a.dart');
     AnalysisTarget target2 = new TestSource('/b.dart');
     AnalysisTarget target3 = new TestSource('/c.dart');
     CacheEntry entry1 = new CacheEntry(target1);
     CacheEntry entry2 = new CacheEntry(target2);
     CacheEntry entry3 = new CacheEntry(target3);
     cache.put(entry1);
     cache.put(entry2);
     cache.put(entry3);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
     entry3.setValue(result3, 333, []);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry2.getState(result2), CacheState.VALID);
     expect(entry3.getState(result3), CacheState.VALID);
     expect(entry1.getValue(result1), 111);
     expect(entry2.getValue(result2), 222);
     expect(entry3.getValue(result3), 333);
     // remove entry1, invalidate result2 and remove empty entry2
     expect(cache.remove(target1), entry1);
     expect(cache.get(target1), isNull);
     expect(cache.get(target2), isNull);
     expect(cache.get(target3), entry3);
     expect(entry3.getState(result3), CacheState.VALID);
   }
 
   void test_remove_invalidateResults_sameTarget() {
     AnalysisTarget target = new TestSource('/a.dart');
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getValue(result1), 111);
     expect(entry.getValue(result2), 222);
     // remove target, invalidate result2
     expect(cache.remove(target), entry);
     expect(cache.get(target), isNull);
@@ skipping 29 matching lines @@
     expect(cache.sources, unorderedEquals([source2]));
     // remove source2
     cache.remove(source2);
     expect(cache.sources, isEmpty);
   }
 }
 
 @reflectiveTest
 class CacheEntryTest extends AbstractCacheTest {
   test_dispose() {
-    ResultDescriptor descriptor1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor descriptor2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> descriptor1 =
+        new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> descriptor2 =
+        new ResultDescriptor<int>('result2', -2);
     AnalysisTarget target1 = new TestSource('1.dart');
     AnalysisTarget target2 = new TestSource('2.dart');
     TargetedResult result1 = new TargetedResult(target1, descriptor1);
     TargetedResult result2 = new TargetedResult(target2, descriptor2);
     CacheEntry entry1 = new CacheEntry(target1);
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
     entry1.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
     entry2.setValue(descriptor2, 2, <TargetedResult>[result1]);
@@ skipping 20 matching lines @@
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     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);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // 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);
     // 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_flush() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor resultA = new ResultDescriptor('A', null);
-    ResultDescriptor resultB = new ResultDescriptor('B', null);
+    ResultDescriptor<String> resultA = new ResultDescriptor<String>('A', null);
+    ResultDescriptor<String> resultB = new ResultDescriptor<String>('B', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // put values
     entry.setValue(resultA, 'a', TargetedResult.EMPTY_LIST);
     entry.setValue(resultB, 'b', TargetedResult.EMPTY_LIST);
     expect(entry.getState(resultA), CacheState.VALID);
     expect(entry.getState(resultB), CacheState.VALID);
     expect(entry.getValue(resultA), 'a');
     expect(entry.getValue(resultB), 'b');
     // flush A
@@ skipping 13 matching lines @@
 
   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);
+    ResultCachingPolicy<int> cachingPolicy =
+        new SimpleResultCachingPolicy<int>(2, 2);
+    ResultDescriptor<int> descriptor1 = new ResultDescriptor<int>(
+        'result1', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor2 = new ResultDescriptor<int>(
+        'result2', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor3 = new ResultDescriptor<int>(
+        'result3', null,
+        cachingPolicy: cachingPolicy);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     {
       entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
     }
     {
       entry.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
@@ skipping 20 matching lines @@
     ResultDescriptor result = new ResultDescriptor('test', null);
     CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     entry.setErrorState(exception, <ResultDescriptor>[result]);
     expect(entry.hasErrorState(), true);
   }
 
   test_invalidateAllInformation() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('test', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     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);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('res1', 1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('res2', 2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('res3', 3);
     // prepare some good state
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     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);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
+    ResultDescriptor<int> result4 = new ResultDescriptor<int>('result4', -4);
     // set results, all of them are VALID
     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);
@@ skipping 38 matching lines @@
     AnalysisTarget target = new TestSource();
     CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry(target);
     expect(() {
       entry.setErrorState(exception, null);
     }, throwsArgumentError);
   }
 
   test_setState_error() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     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);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', 1);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // set VALID
     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);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', 1);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // set VALID
     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);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', 1);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // set VALID
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 10);
     // listen, expect "result" invalidation event
     int numberOfEvents = 0;
     cache.onResultInvalidated.listen((event) {
       numberOfEvents++;
       expect(event.entry, same(entry));
       expect(event.descriptor, same(result));
     });
     // set INVALID
     entry.setState(result, CacheState.INVALID);
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.getValue(result), 1);
     expect(numberOfEvents, 1);
   }
 
   test_setState_invalid_dependencyCycle() {
     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 result = new ResultDescriptor('result', -1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('result', -1);
     // Set each result as VALID with a dependency on on the other.
     entry1.setValue(result, 100, [new TargetedResult(target2, result)]);
     entry2.setValue(result, 200, [new TargetedResult(target1, result)]);
     expect(entry1.getState(result), CacheState.VALID);
     expect(entry2.getState(result), CacheState.VALID);
     // Listen, expect entry1.result and entry2.result invalidation events.
     int numberOfEvents = 0;
     bool wasEntry1 = false;
     bool wasEntry2 = false;
     cache.onResultInvalidated.listen((event) {
       numberOfEvents++;
       if (event.entry == entry1) wasEntry1 = true;
       if (event.entry == entry2) wasEntry2 = true;
       expect(event.descriptor, same(result));
     });
     // Invalidate entry1.result; this should cause entry2 to be also
     // cleared without going into an infinite regress.
     entry1.setState(result, CacheState.INVALID);
     expect(cache.get(target1), isNull);
     expect(cache.get(target2), isNull);
     expect(numberOfEvents, 2);
     expect(wasEntry1, isTrue);
     expect(wasEntry2, isTrue);
   }
 
   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);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
+    ResultDescriptor<int> result4 = new ResultDescriptor<int>('result4', -4);
     // set results, all of them are VALID
     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);
@@ skipping 12 matching lines @@
     expect(entry.getValue(result4), 444);
     // result4 is still valid, so the entry is still in the cache
     expect(cache.get(target), entry);
   }
 
   test_setState_invalid_keepEmpty_ifExplicitlyAdded() {
     AnalysisTarget target = new TestSource('/a.dart');
     CacheEntry entry = new CacheEntry(target);
     entry.explicitlyAdded = true;
     cache.put(entry);
-    ResultDescriptor result = new ResultDescriptor('result1', -1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('result1', -1);
     // set results, all of them are VALID
     entry.setValue(result, 111, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 111);
     // invalidate result, keep entry
     entry.setState(result, CacheState.INVALID);
     expect(cache.get(target), isNotNull);
   }
 
   test_setState_invalid_removeEmptyEntry() {
     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<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
     entry2.setValue(result3, 333, [new TargetedResult(target2, result2)]);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry2.getState(result2), CacheState.VALID);
     expect(entry2.getState(result3), CacheState.VALID);
     expect(entry1.getValue(result1), 111);
     expect(entry2.getValue(result2), 222);
     expect(entry2.getValue(result3), 333);
     // invalidate result1, remove entry1 & entry2
     entry1.setState(result1, CacheState.INVALID);
     expect(cache.get(target1), isNull);
     expect(cache.get(target2), isNull);
   }
 
   test_setState_invalid_withDelta_keepDependency() {
     Source target = new TestSource('/test.dart');
     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<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
     entry.setValue(result3, 333, [new TargetedResult(target, result2)]);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getState(result3), CacheState.VALID);
     // result2 depends on result1
     expect(entry.getResultData(result1).dependentResults,
         unorderedEquals([new TargetedResult(target, result2)]));
@@ skipping 24 matching lines @@
 
   test_setState_valid() {
     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);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('test', null);
     String value = 'value';
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     entry.setValue(result, value, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), value);
   }
 
   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);
+    ResultCachingPolicy<int> cachingPolicy =
+        new SimpleResultCachingPolicy<int>(2, 2);
+    ResultDescriptor<int> descriptor1 = new ResultDescriptor<int>(
+        'result1', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor2 = new ResultDescriptor<int>(
+        'result2', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor3 = new ResultDescriptor<int>(
+        'result3', null,
+        cachingPolicy: cachingPolicy);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     {
       entry.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
       expect(entry.getState(descriptor1), CacheState.VALID);
     }
     {
       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);
       expect(entry.getState(descriptor1), CacheState.FLUSHED);
       expect(entry.getState(descriptor2), CacheState.VALID);
       expect(entry.getState(descriptor3), CacheState.VALID);
     }
   }
 
   test_setValue_flushResults_keepForPrioritySources() {
-    ResultCachingPolicy cachingPolicy = new SimpleResultCachingPolicy(2, 2);
-    ResultDescriptor newResult(String name) =>
-        new ResultDescriptor(name, null, cachingPolicy: cachingPolicy);
-    ResultDescriptor descriptor1 = newResult('result1');
-    ResultDescriptor descriptor2 = newResult('result2');
-    ResultDescriptor descriptor3 = newResult('result3');
+    ResultCachingPolicy<int> cachingPolicy =
+        new SimpleResultCachingPolicy<int>(2, 2);
+    ResultDescriptor<int> newResult(String name) =>
+        new ResultDescriptor<int>(name, null, cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor1 = newResult('result1');
+    ResultDescriptor<int> descriptor2 = newResult('result2');
+    ResultDescriptor<int> descriptor3 = newResult('result3');
     TestSource source1 = new TestSource('/a.dart');
     TestSource source2 = new TestSource('/b.dart');
     TestSource source3 = new TestSource('/c.dart');
     AnalysisTarget target1 =
         new _TestAnalysisTarget(librarySource: source1, source: source1);
     AnalysisTarget target2 =
         new _TestAnalysisTarget(librarySource: source2, source: source2);
     AnalysisTarget target3 =
         new _TestAnalysisTarget(librarySource: source3, source: source3);
     CacheEntry entry1 = new CacheEntry(target1);
@@ skipping 14 matching lines @@
     entry3.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST);
     expect(entry1.getState(descriptor1), CacheState.VALID);
     expect(entry2.getState(descriptor2), CacheState.FLUSHED);
     expect(entry3.getState(descriptor3), CacheState.VALID);
   }
 
   test_setValue_keepDependent() {
     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<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getValue(result1), 111);
     expect(entry.getValue(result2), 222);
     // set result1; result2 is intact
     entry.setValue(result1, 1111, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getValue(result1), 1111);
     expect(entry.getValue(result2), 222);
   }
 
   test_setValue_userBeforeProvider_invalidateProvider_alsoUser() {
     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<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
     // set results, all of them are VALID
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry2.getState(result2), CacheState.VALID);
     expect(entry1.getValue(result1), 111);
     expect(entry2.getValue(result2), 222);
     // invalidate result1, should invalidate also result2
     entry1.setState(result1, CacheState.INVALID);
     expect(entry1.getState(result1), CacheState.INVALID);
     expect(entry2.getState(result2), CacheState.INVALID);
   }
 
   test_setValueIncremental() {
     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<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
     entry.setValue(result3, 333, [new TargetedResult(target, result2)]);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getState(result3), CacheState.VALID);
     expect(entry.getValue(result1), 111);
     expect(entry.getValue(result2), 222);
     expect(entry.getValue(result3), 333);
@@ skipping 12 matching lines @@
   }
 
   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);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     entry.setValue(result, 42, TargetedResult.EMPTY_LIST);
     expect(entry.toString(), isNotNull);
   }
 }
 
 @reflectiveTest
 class CacheFlushManagerTest {
   CacheFlushManager manager = new CacheFlushManager(
@@ skipping 335 matching lines @@
   }
 
   test_dispose() {
     InternalAnalysisContext context = new _InternalAnalysisContextMock();
     CachePartition partition1 = new UniversalCachePartition(context);
     CachePartition partition2 = new UniversalCachePartition(context);
     AnalysisCache cache = new AnalysisCache([partition1, partition2]);
     when(context.analysisCache).thenReturn(cache);
     // configure
     // prepare entries
-    ResultDescriptor descriptor1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor descriptor2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> descriptor1 =
+        new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> descriptor2 =
+        new ResultDescriptor<int>('result2', -2);
     AnalysisTarget target1 = new TestSource('1.dart');
     AnalysisTarget target2 = new TestSource('2.dart');
     TargetedResult result1 = new TargetedResult(target1, descriptor1);
     TargetedResult result2 = new TargetedResult(target2, descriptor2);
     CacheEntry entry1 = new CacheEntry(target1);
     CacheEntry entry2 = new CacheEntry(target2);
     partition1.put(entry1);
     partition2.put(entry2);
     entry1.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
     entry2.setValue(descriptor2, 2, <TargetedResult>[result1]);
@@ skipping 41 matching lines @@
     }
     return DeltaResult.INVALIDATE;
   }
 }
 
 class _TestAnalysisTarget implements AnalysisTarget {
   final Source librarySource;
   final Source source;
   _TestAnalysisTarget({this.librarySource, this.source});
 }