An AnalysisTarget is a priority one if its Source is in prioritySources.

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/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
@@ skipping 26 matching lines @@
   CachePartition partition = new UniversalCachePartition(context);
   return new AnalysisCache(<CachePartition>[partition]);
 }
 
 class AbstractCacheTest {
   InternalAnalysisContext context;
   AnalysisCache cache;
 
   void setUp() {
     context = new _InternalAnalysisContextMock();
-    when(context.priorityTargets).thenReturn([]);
+    when(context.prioritySources).thenReturn([]);
     cache = createCache(context: context);
     when(context.analysisCache).thenReturn(cache);
   }
 }
 
 @reflectiveTest
 class AnalysisCacheTest extends AbstractCacheTest {
   void test_creation() {
     expect(cache, isNotNull);
   }
@@ skipping 706 matching lines @@
       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');
+    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);
+    CacheEntry entry2 = new CacheEntry(target2);
+    CacheEntry entry3 = new CacheEntry(target3);
+    cache.put(entry1);
+    cache.put(entry2);
+    cache.put(entry3);
+
+    // Set two results.
+    entry1.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
+    entry2.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST);
+    expect(entry1.getState(descriptor1), CacheState.VALID);
+    expect(entry2.getState(descriptor2), CacheState.VALID);
+
+    // Make source1 priority, so result2 is flushed instead.
+    when(context.prioritySources).thenReturn([source1]);
+    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);
     // 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);
@@ skipping 475 matching lines @@
   DeltaResult validate(InternalAnalysisContext context, AnalysisTarget target,
       ResultDescriptor descriptor, Object value) {
     if (descriptor == keepDescriptor) {
       return DeltaResult.KEEP_CONTINUE;
     }
     return DeltaResult.INVALIDATE;
   }
 }
 
 class _TestAnalysisTarget implements AnalysisTarget {
-  @override
-  Source get librarySource => null;
-
-  @override
-  Source get source => null;
+  final Source librarySource;
+  final Source source;
+  _TestAnalysisTarget({this.librarySource, this.source});
 }