Unify Entry and EntryImpl classes

pkg/analyzer/test/generated/engine_test.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.engine_test;
 
 import 'dart:collection';
@@ skipping 60 matching lines @@
     AnalysisCache cache = new AnalysisCache(new List<CachePartition>(0));
     TestSource source = new TestSource();
     JUnitTestCase.assertNull(cache.get(source));
   }
 
   void test_iterator() {
     CachePartition partition =
         new UniversalCachePartition(null, 8, new DefaultRetentionPolicy());
     AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]);
     TestSource source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     cache.put(source, entry);
     MapIterator<Source, SourceEntry> iterator = cache.iterator();
     JUnitTestCase.assertTrue(iterator.moveNext());
     JUnitTestCase.assertSame(source, iterator.key);
     JUnitTestCase.assertSame(entry, iterator.value);
     JUnitTestCase.assertFalse(iterator.moveNext());
   }
 
   void test_put_noFlush() {
     CachePartition partition =
         new UniversalCachePartition(null, 8, new DefaultRetentionPolicy());
     AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]);
     TestSource source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     cache.put(source, entry);
     JUnitTestCase.assertSame(entry, cache.get(source));
   }
 
   void test_setMaxCacheSize() {
     CachePartition partition = new UniversalCachePartition(
         null,
         8,
         new _AnalysisCacheTest_test_setMaxCacheSize());
     AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]);
     int size = 6;
     for (int i = 0; i < size; i++) {
       Source source = new TestSource("/test${i}.dart");
-      DartEntryImpl entry = new DartEntryImpl();
+      DartEntry entry = new DartEntry();
       entry.setValue(DartEntry.PARSED_UNIT, null);
       cache.put(source, entry);
       cache.accessedAst(source);
     }
     _assertNonFlushedCount(size, cache);
     int newSize = size - 2;
     partition.maxCacheSize = newSize;
     _assertNonFlushedCount(newSize, cache);
   }
 
   void test_size() {
     CachePartition partition =
         new UniversalCachePartition(null, 8, new DefaultRetentionPolicy());
     AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]);
     int size = 4;
     for (int i = 0; i < size; i++) {
       Source source = new TestSource("/test${i}.dart");
-      cache.put(source, new DartEntryImpl());
+      cache.put(source, new DartEntry());
       cache.accessedAst(source);
     }
     JUnitTestCase.assertEquals(size, cache.size());
   }
 
   void _assertNonFlushedCount(int expectedCount, AnalysisCache cache) {
     int nonFlushedCount = 0;
     MapIterator<Source, SourceEntry> iterator = cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.value.getState(DartEntry.PARSED_UNIT) !=
@@ skipping 2562 matching lines @@
     throw new AnalysisException("Forced exception");
   }
 }
 
 
 class CompilationUnitMock extends TypedMock implements CompilationUnit {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 
 class DartEntryImplTest extends EngineTestCase {

[scheglov, 2014/10/06 19:30:22]

You could also rename the corresponding Test classes.

[Brian Wilkerson, 2014/10/06 19:43:27]

Done

   void set state2(DataDescriptor descriptor) {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     JUnitTestCase.assertNotSame(CacheState.FLUSHED, entry.getState(descriptor));
     entry.setState(descriptor, CacheState.FLUSHED);
     JUnitTestCase.assertSame(CacheState.FLUSHED, entry.getState(descriptor));
   }
 
   void set state3(DataDescriptor descriptor) {
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     JUnitTestCase.assertNotSame(
         CacheState.FLUSHED,
         entry.getStateInLibrary(descriptor, source));
     entry.setStateInLibrary(descriptor, source, CacheState.FLUSHED);
     JUnitTestCase.assertSame(
         CacheState.FLUSHED,
         entry.getStateInLibrary(descriptor, source));
   }
 
   void test_creation() {
     Source librarySource = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.EXPORTED_LIBRARIES));
     JUnitTestCase.assertSame(
@@ skipping 38 matching lines @@
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource));
   }
 
   void test_getAllErrors() {
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     EngineTestCase.assertLength(0, entry.allErrors);
     entry.setValue(
         DartEntry.SCAN_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(
                 source,
                 ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
                 [])]);
     entry.setValue(
         DartEntry.PARSE_ERRORS,
@@ skipping 16 matching lines @@
                 StaticWarningCode.CASE_BLOCK_NOT_TERMINATED,
                 [])]);
     entry.setValueInLibrary(
         DartEntry.HINTS,
         source,
         <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
     EngineTestCase.assertLength(5, entry.allErrors);
   }
 
   void test_getResolvableCompilationUnit_none() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     JUnitTestCase.assertNull(entry.resolvableCompilationUnit);
   }
 
   void test_getResolvableCompilationUnit_parsed_accessed() {
     String importUri = "f1.dart";
     Source importSource = new TestSource(importUri);
     ImportDirective importDirective =
         AstFactory.importDirective3(importUri, null, []);
     importDirective.source = importSource;
     importDirective.uriContent = importUri;
     String exportUri = "f2.dart";
     Source exportSource = new TestSource(exportUri);
     ExportDirective exportDirective =
         AstFactory.exportDirective2(exportUri, []);
     exportDirective.source = exportSource;
     exportDirective.uriContent = exportUri;
     String partUri = "f3.dart";
     Source partSource = new TestSource(partUri);
     PartDirective partDirective = AstFactory.partDirective2(partUri);
     partDirective.source = partSource;
     partDirective.uriContent = partUri;
     CompilationUnit unit =
         AstFactory.compilationUnit3([importDirective, exportDirective, partDirective]);
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValue(DartEntry.PARSED_UNIT, unit);
     entry.getValue(DartEntry.PARSED_UNIT);
     CompilationUnit result = entry.resolvableCompilationUnit;
     JUnitTestCase.assertNotSame(unit, result);
     NodeList<Directive> directives = result.directives;
     ImportDirective resultImportDirective = directives[0] as ImportDirective;
     JUnitTestCase.assertEquals(importUri, resultImportDirective.uriContent);
     JUnitTestCase.assertSame(importSource, resultImportDirective.source);
     ExportDirective resultExportDirective = directives[1] as ExportDirective;
     JUnitTestCase.assertEquals(exportUri, resultExportDirective.uriContent);
     JUnitTestCase.assertSame(exportSource, resultExportDirective.source);
     PartDirective resultPartDirective = directives[2] as PartDirective;
     JUnitTestCase.assertEquals(partUri, resultPartDirective.uriContent);
     JUnitTestCase.assertSame(partSource, resultPartDirective.source);
   }
 
   void test_getResolvableCompilationUnit_parsed_notAccessed() {
     CompilationUnit unit = AstFactory.compilationUnit();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValue(DartEntry.PARSED_UNIT, unit);
     JUnitTestCase.assertSame(unit, entry.resolvableCompilationUnit);
   }
 
   void test_getResolvableCompilationUnit_resolved() {
     String importUri = "f1.dart";
     Source importSource = new TestSource(importUri);
     ImportDirective importDirective =
         AstFactory.importDirective3(importUri, null, []);
     importDirective.source = importSource;
     importDirective.uriContent = importUri;
     String exportUri = "f2.dart";
     Source exportSource = new TestSource(exportUri);
     ExportDirective exportDirective =
         AstFactory.exportDirective2(exportUri, []);
     exportDirective.source = exportSource;
     exportDirective.uriContent = exportUri;
     String partUri = "f3.dart";
     Source partSource = new TestSource(partUri);
     PartDirective partDirective = AstFactory.partDirective2(partUri);
     partDirective.source = partSource;
     partDirective.uriContent = partUri;
     CompilationUnit unit =
         AstFactory.compilationUnit3([importDirective, exportDirective, partDirective]);
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         new TestSource("lib.dart"),
         unit);
     CompilationUnit result = entry.resolvableCompilationUnit;
     JUnitTestCase.assertNotSame(unit, result);
     NodeList<Directive> directives = result.directives;
     ImportDirective resultImportDirective = directives[0] as ImportDirective;
     JUnitTestCase.assertEquals(importUri, resultImportDirective.uriContent);
     JUnitTestCase.assertSame(importSource, resultImportDirective.source);
     ExportDirective resultExportDirective = directives[1] as ExportDirective;
     JUnitTestCase.assertEquals(exportUri, resultExportDirective.uriContent);
     JUnitTestCase.assertSame(exportSource, resultExportDirective.source);
     PartDirective resultPartDirective = directives[2] as PartDirective;
     JUnitTestCase.assertEquals(partUri, resultPartDirective.uriContent);
     JUnitTestCase.assertSame(partSource, resultPartDirective.source);
   }
 
   void test_getStateInLibrary_invalid_element() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.getStateInLibrary(DartEntry.ELEMENT, new TestSource());
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_getState_invalid_resolutionErrors() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.getState(DartEntry.RESOLUTION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for RESOLUTION_ERRORS");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_getState_invalid_verificationErrors() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.getState(DartEntry.VERIFICATION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for VERIFICATION_ERRORS");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_getValueInLibrary_invalid_element() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.getValueInLibrary(DartEntry.ELEMENT, new TestSource());
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_getValueInLibrary_invalid_resolutionErrors_multiple() {
     Source source1 = new TestSource();
     Source source2 = new TestSource();
     Source source3 = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source1,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source2,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source3,
         AstFactory.compilationUnit());
     try {
       entry.getValueInLibrary(DartEntry.ELEMENT, source3);
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_getValue_containingLibraries() {
     Source testSource = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     List<Source> value = entry.getValue(DartEntry.CONTAINING_LIBRARIES);
     EngineTestCase.assertLength(0, value);
     entry.addContainingLibrary(testSource);
     value = entry.getValue(DartEntry.CONTAINING_LIBRARIES);
     EngineTestCase.assertLength(1, value);
     JUnitTestCase.assertEquals(testSource, value[0]);
     entry.removeContainingLibrary(testSource);
     value = entry.getValue(DartEntry.CONTAINING_LIBRARIES);
     EngineTestCase.assertLength(0, value);
   }
 
   void test_getValue_invalid_resolutionErrors() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.getValue(DartEntry.RESOLUTION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for RESOLUTION_ERRORS");
     } on IllegalArgumentException catch (exception) {
     }
   }
 
   void test_getValue_invalid_verificationErrors() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.getValue(DartEntry.VERIFICATION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for VERIFICATION_ERRORS");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_hasInvalidData_false() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordScanError(new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.ELEMENT));
     JUnitTestCase.assertFalse(
         entry.hasInvalidData(DartEntry.EXPORTED_LIBRARIES));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.HINTS));
     JUnitTestCase.assertFalse(
         entry.hasInvalidData(DartEntry.IMPORTED_LIBRARIES));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.INCLUDED_PARTS));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.IS_CLIENT));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.IS_LAUNCHABLE));
     JUnitTestCase.assertFalse(entry.hasInvalidData(SourceEntry.LINE_INFO));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.PARSE_ERRORS));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.PARSED_UNIT));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.PUBLIC_NAMESPACE));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.SOURCE_KIND));
     JUnitTestCase.assertFalse(
         entry.hasInvalidData(DartEntry.RESOLUTION_ERRORS));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.RESOLVED_UNIT));
     JUnitTestCase.assertFalse(
         entry.hasInvalidData(DartEntry.VERIFICATION_ERRORS));
   }
 
   void test_hasInvalidData_true() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.ELEMENT));
     JUnitTestCase.assertTrue(
         entry.hasInvalidData(DartEntry.EXPORTED_LIBRARIES));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.HINTS));
     JUnitTestCase.assertTrue(
         entry.hasInvalidData(DartEntry.IMPORTED_LIBRARIES));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.INCLUDED_PARTS));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.IS_CLIENT));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.IS_LAUNCHABLE));
     JUnitTestCase.assertTrue(entry.hasInvalidData(SourceEntry.LINE_INFO));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.PARSE_ERRORS));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.PARSED_UNIT));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.PUBLIC_NAMESPACE));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.SOURCE_KIND));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.RESOLUTION_ERRORS));
     JUnitTestCase.assertTrue(entry.hasInvalidData(DartEntry.RESOLVED_UNIT));
     JUnitTestCase.assertTrue(
         entry.hasInvalidData(DartEntry.VERIFICATION_ERRORS));
   }
 
   void test_invalidateAllInformation() {
-    DartEntryImpl entry = _entryWithValidState();
+    DartEntry entry = _entryWithValidState();
     entry.invalidateAllInformation();
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.EXPORTED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IMPORTED_LIBRARIES));
@@ skipping 20 matching lines @@
         entry.getState(DartEntry.PUBLIC_NAMESPACE));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.SCAN_ERRORS));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.TOKEN_STREAM));
   }
 
   void test_invalidateAllResolutionInformation() {
-    DartEntryImpl entry = _entryWithValidState();
+    DartEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(false);
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IS_CLIENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IS_LAUNCHABLE));
@@ skipping 14 matching lines @@
         entry.getState(DartEntry.EXPORTED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.IMPORTED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.INCLUDED_PARTS));
   }
 
   void test_invalidateAllResolutionInformation_includingUris() {
-    DartEntryImpl entry = _entryWithValidState();
+    DartEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(true);
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IS_CLIENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IS_LAUNCHABLE));
@@ skipping 14 matching lines @@
         entry.getState(DartEntry.EXPORTED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IMPORTED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.INCLUDED_PARTS));
   }
 
   void test_isClient() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     // true
     entry.setValue(DartEntry.IS_CLIENT, true);
     JUnitTestCase.assertTrue(entry.getValue(DartEntry.IS_CLIENT));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.IS_CLIENT));
     // invalidate
     entry.setState(DartEntry.IS_CLIENT, CacheState.INVALID);
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IS_CLIENT));
     // false
     entry.setValue(DartEntry.IS_CLIENT, false);
     JUnitTestCase.assertFalse(entry.getValue(DartEntry.IS_CLIENT));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.IS_CLIENT));
   }
 
   void test_isLaunchable() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     // true
     entry.setValue(DartEntry.IS_LAUNCHABLE, true);
     JUnitTestCase.assertTrue(entry.getValue(DartEntry.IS_LAUNCHABLE));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.IS_LAUNCHABLE));
     // invalidate
     entry.setState(DartEntry.IS_LAUNCHABLE, CacheState.INVALID);
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.IS_LAUNCHABLE));
     // false
     entry.setValue(DartEntry.IS_LAUNCHABLE, false);
     JUnitTestCase.assertFalse(entry.getValue(DartEntry.IS_LAUNCHABLE));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.IS_LAUNCHABLE));
   }
 
   void test_recordBuildElementErrorInLibrary() {
     // TODO(brianwilkerson) This test should set the state for two libraries,
     // record an error in one library, then verify that the data for the other
     // library is still valid.
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordBuildElementErrorInLibrary(
         source,
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
@@ skipping 40 matching lines @@
         entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordContentError() {
-    //    Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordContentError(
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
@@ skipping 40 matching lines @@
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordHintErrorInLibrary() {
     // TODO(brianwilkerson) This test should set the state for two libraries,
     // record an error in one library, then verify that the data for the other
     // library is still valid.
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordHintErrorInLibrary(
         source,
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
@@ skipping 40 matching lines @@
         entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordParseError() {
-    //    Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordParseError(new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.EXPORTED_LIBRARIES));
@@ skipping 35 matching lines @@
     // don't know anything about.
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILT_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.HINTS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordParseInProcess() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordParseInProcess();
     JUnitTestCase.assertSame(
         CacheState.IN_PROCESS,
         entry.getState(DartEntry.PARSE_ERRORS));
     JUnitTestCase.assertSame(
         CacheState.IN_PROCESS,
         entry.getState(DartEntry.PARSED_UNIT));
     JUnitTestCase.assertSame(
         CacheState.IN_PROCESS,
         entry.getState(DartEntry.SOURCE_KIND));
   }
 
   void test_recordResolutionError() {
     //    Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordResolutionError(
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
@@ skipping 40 matching lines @@
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordResolutionErrorInLibrary() {
     // TODO(brianwilkerson) This test should set the state for two libraries,
     // record an error in one library, then verify that the data for the other
     // library is still valid.
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordResolutionErrorInLibrary(
         source,
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
@@ skipping 41 matching lines @@
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordScanError() {
     //    Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordScanError(new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getState(DartEntry.EXPORTED_LIBRARIES));
@@ skipping 35 matching lines @@
     // don't know anything about.
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILT_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.HINTS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_recordScanInProcess() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordScanInProcess();
     JUnitTestCase.assertSame(
         CacheState.IN_PROCESS,
         entry.getState(SourceEntry.LINE_INFO));
     JUnitTestCase.assertSame(
         CacheState.IN_PROCESS,
         entry.getState(DartEntry.SCAN_ERRORS));
     JUnitTestCase.assertSame(
         CacheState.IN_PROCESS,
         entry.getState(DartEntry.TOKEN_STREAM));
   }
 
   void test_recordVerificationErrorInLibrary() {
     // TODO(brianwilkerson) This test should set the state for two libraries,
     // record an error in one library, then verify that the data for the other
     // library is still valid.
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.recordVerificationErrorInLibrary(
         source,
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(DartEntry.ELEMENT));
     JUnitTestCase.assertSame(
@@ skipping 43 matching lines @@
         entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
         entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
   void test_removeResolution_multiple_first() {
     Source source1 = new TestSource();
     Source source2 = new TestSource();
     Source source3 = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source1,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source2,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source3,
         AstFactory.compilationUnit());
     entry.removeResolution(source1);
   }
 
   void test_removeResolution_multiple_last() {
     Source source1 = new TestSource();
     Source source2 = new TestSource();
     Source source3 = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source1,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source2,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source3,
         AstFactory.compilationUnit());
     entry.removeResolution(source3);
   }
 
   void test_removeResolution_multiple_middle() {
     Source source1 = new TestSource();
     Source source2 = new TestSource();
     Source source3 = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source1,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source2,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source3,
         AstFactory.compilationUnit());
     entry.removeResolution(source2);
   }
 
   void test_removeResolution_single() {
     Source source1 = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source1,
         AstFactory.compilationUnit());
     entry.removeResolution(source1);
   }
 
   void test_setState_element() {
     state2 = DartEntry.ELEMENT;
   }
 
   void test_setState_exportedLibraries() {
     state2 = DartEntry.EXPORTED_LIBRARIES;
   }
 
   void test_setState_hints() {
     state3 = DartEntry.HINTS;
   }
 
   void test_setState_importedLibraries() {
     state2 = DartEntry.IMPORTED_LIBRARIES;
   }
 
   void test_setState_includedParts() {
     state2 = DartEntry.INCLUDED_PARTS;
   }
 
   void test_setState_invalid_element() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.setStateInLibrary(DartEntry.ELEMENT, null, CacheState.FLUSHED);
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_setState_invalid_resolutionErrors() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.setState(DartEntry.RESOLUTION_ERRORS, CacheState.FLUSHED);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for RESOLUTION_ERRORS");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_setState_invalid_validState() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.setState(SourceEntry.LINE_INFO, CacheState.VALID);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for a state of VALID");
     } on IllegalArgumentException catch (exception) {
     }
   }
 
   void test_setState_invalid_verificationErrors() {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     try {
       entry.setState(DartEntry.VERIFICATION_ERRORS, CacheState.FLUSHED);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for VERIFICATION_ERRORS");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_setState_isClient() {
@@ skipping 129 matching lines @@
     _setValue2(DartEntry.TOKEN_STREAM, new Token(TokenType.LT, 5));
   }
 
   void test_setValue_verificationErrors() {
     _setValue3(
         DartEntry.VERIFICATION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(null, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, [])]);
   }
 
-  DartEntryImpl _entryWithValidState() {
-    DartEntryImpl entry = new DartEntryImpl();
+  DartEntry _entryWithValidState() {
+    DartEntry entry = new DartEntry();
     entry.setValue(DartEntry.ELEMENT, null);
     entry.setValue(DartEntry.EXPORTED_LIBRARIES, null);
     entry.setValue(DartEntry.IMPORTED_LIBRARIES, null);
     entry.setValue(DartEntry.INCLUDED_PARTS, null);
     entry.setValue(DartEntry.IS_CLIENT, true);
     entry.setValue(DartEntry.IS_LAUNCHABLE, true);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(DartEntry.PARSE_ERRORS, null);
     entry.setValue(DartEntry.PARSED_UNIT, null);
     entry.setValue(DartEntry.PUBLIC_NAMESPACE, null);
@@ skipping 24 matching lines @@
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.PARSED_UNIT));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(DartEntry.PUBLIC_NAMESPACE));
     return entry;
   }
 
   void _setValue2(DataDescriptor descriptor, Object newValue) {
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     Object value = entry.getValue(descriptor);
     JUnitTestCase.assertNotSame(value, newValue);
     entry.setValue(descriptor, newValue);
     JUnitTestCase.assertSame(CacheState.VALID, entry.getState(descriptor));
     JUnitTestCase.assertSame(newValue, entry.getValue(descriptor));
   }
 
   void _setValue3(DataDescriptor descriptor, Object newValue) {
     Source source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     Object value = entry.getValueInLibrary(descriptor, source);
     JUnitTestCase.assertNotSame(value, newValue);
     entry.setValueInLibrary(descriptor, source, newValue);
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getStateInLibrary(descriptor, source));
     JUnitTestCase.assertSame(
         newValue,
         entry.getValueInLibrary(descriptor, source));
   }
@@ skipping 685 matching lines @@
         context.getModificationStamp(source),
         task.modificationTime);
     JUnitTestCase.assertSame(source, task.source);
     return true;
   }
 }
 
 
 class HtmlEntryImplTest extends EngineTestCase {
   void set state(DataDescriptor descriptor) {
-    HtmlEntryImpl entry = new HtmlEntryImpl();
+    HtmlEntry entry = new HtmlEntry();
     JUnitTestCase.assertNotSame(CacheState.FLUSHED, entry.getState(descriptor));
     entry.setState(descriptor, CacheState.FLUSHED);
     JUnitTestCase.assertSame(CacheState.FLUSHED, entry.getState(descriptor));
   }
 
   void test_creation() {
-    HtmlEntryImpl entry = new HtmlEntryImpl();
+    HtmlEntry entry = new HtmlEntry();
     JUnitTestCase.assertNotNull(entry);
   }
 
   void test_getAllErrors() {
     Source source = new TestSource();
-    HtmlEntryImpl entry = new HtmlEntryImpl();
+    HtmlEntry entry = new HtmlEntry();
     EngineTestCase.assertLength(0, entry.allErrors);
     entry.setValue(
         HtmlEntry.PARSE_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, ParserErrorCode.EXPECTED_TOKEN, [";"])]);
     entry.setValue(
         HtmlEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, HtmlWarningCode.INVALID_URI, ["-"])]);
     entry.setValue(
         HtmlEntry.ANGULAR_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, AngularCode.INVALID_REPEAT_SYNTAX, ["-"])]);
     entry.setValue(
         HtmlEntry.POLYMER_BUILD_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
     entry.setValue(
         HtmlEntry.POLYMER_RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
     entry.setValue(
         HtmlEntry.HINTS,
         <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
     EngineTestCase.assertLength(6, entry.allErrors);
   }
 
   void test_invalidateAllResolutionInformation() {
-    HtmlEntryImpl entry = _entryWithValidState();
+    HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(false);
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.ANGULAR_APPLICATION));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.ANGULAR_COMPONENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(HtmlEntry.ANGULAR_ENTRY));
@@ skipping 23 matching lines @@
         entry.getState(HtmlEntry.PARSED_UNIT));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.REFERENCED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(HtmlEntry.RESOLUTION_ERRORS));
   }
 
   void test_invalidateAllResolutionInformation_includingUris() {
-    HtmlEntryImpl entry = _entryWithValidState();
+    HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(true);
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.ANGULAR_APPLICATION));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.ANGULAR_COMPONENT));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(HtmlEntry.ANGULAR_ENTRY));
@@ skipping 80 matching lines @@
     _setValue(HtmlEntry.ELEMENT, new HtmlElementImpl(null, "test.html"));
   }
 
   void test_setValue_hints() {
     _setValue(
         HtmlEntry.HINTS,
         <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE, [])]);
   }
 
   void test_setValue_illegal() {
-    HtmlEntryImpl entry = new HtmlEntryImpl();
+    HtmlEntry entry = new HtmlEntry();
     try {
       entry.setValue(DartEntry.ELEMENT, null);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for DartEntry.ELEMENT");
     } on IllegalArgumentException catch (exception) {
     }
   }
 
   void test_setValue_lineInfo() {
     _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
@@ skipping 28 matching lines @@
     _setValue(HtmlEntry.REFERENCED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_resolutionErrors() {
     _setValue(
         HtmlEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(null, HtmlWarningCode.INVALID_URI, ["-"])]);
   }
 
-  HtmlEntryImpl _entryWithValidState() {
-    HtmlEntryImpl entry = new HtmlEntryImpl();
+  HtmlEntry _entryWithValidState() {
+    HtmlEntry entry = new HtmlEntry();
     entry.setValue(HtmlEntry.ANGULAR_ERRORS, null);
     entry.setValue(HtmlEntry.ELEMENT, null);
     entry.setValue(HtmlEntry.HINTS, null);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(HtmlEntry.PARSE_ERRORS, null);
     entry.setValue(HtmlEntry.PARSED_UNIT, null);
     entry.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, null);
     entry.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, null);
     entry.setValue(HtmlEntry.REFERENCED_LIBRARIES, null);
     entry.setValue(HtmlEntry.RESOLUTION_ERRORS, null);
@@ skipping 22 matching lines @@
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.REFERENCED_LIBRARIES));
     JUnitTestCase.assertSame(
         CacheState.VALID,
         entry.getState(HtmlEntry.RESOLUTION_ERRORS));
     return entry;
   }
 
   void _setValue(DataDescriptor descriptor, Object newValue) {
-    HtmlEntryImpl entry = new HtmlEntryImpl();
+    HtmlEntry entry = new HtmlEntry();
     Object value = entry.getValue(descriptor);
     JUnitTestCase.assertNotSame(value, newValue);
     entry.setValue(descriptor, newValue);
     JUnitTestCase.assertSame(CacheState.VALID, entry.getState(descriptor));
     JUnitTestCase.assertSame(newValue, entry.getValue(descriptor));
   }
 
   static dartSuite() {
     _ut.group('HtmlEntryImplTest', () {
       _ut.test('test_creation', () {
@@ skipping 98 matching lines @@
         final __test = new HtmlEntryImplTest();
         runJUnitTest(__test, __test.test_setValue_resolutionErrors);
       });
     });
   }
 }
 
 
 class IncrementalAnalysisCacheTest extends JUnitTestCase {
   Source _source = new TestSource();
-  DartEntryImpl _entry = new DartEntryImpl();
+  DartEntry _entry = new DartEntry();
   CompilationUnit _unit = new CompilationUnitMock();
   IncrementalAnalysisCache _result;
   @override
   void setUp() {
     _entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, _unit);
   }
   void test_cacheResult() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
@@ skipping 75 matching lines @@
   void test_update_append() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "hbazxlo",
         4,
         0,
         1,
         newEntry);
     JUnitTestCase.assertNotNull(_result);
@@ skipping 11 matching lines @@
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
     CompilationUnit newUnit = new CompilationUnitMock();
     cache = IncrementalAnalysisCache.cacheResult(cache, newUnit);
     JUnitTestCase.assertNotNull(cache);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "hbazxlo",
         4,
         0,
         1,
         newEntry);
     JUnitTestCase.assertNotNull(_result);
     JUnitTestCase.assertSame(_source, _result.source);
     JUnitTestCase.assertSame(newUnit, _result.resolvedUnit);
     JUnitTestCase.assertEquals("hbazlo", _result.oldContents);
     JUnitTestCase.assertEquals("hbazxlo", _result.newContents);
     JUnitTestCase.assertEquals(4, _result.offset);
     JUnitTestCase.assertEquals(0, _result.oldLength);
     JUnitTestCase.assertEquals(1, _result.newLength);
   }
   void test_update_appendWithNewResolvedUnit() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     CompilationUnit newUnit = new CompilationUnitMock();
     newEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, newUnit);
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "hbazxlo",
         4,
         0,
         1,
@@ skipping 10 matching lines @@
   void test_update_appendWithNoNewResolvedUnit() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "hbazxlo",
         4,
         0,
         1,
         newEntry);
     JUnitTestCase.assertNotNull(_result);
     JUnitTestCase.assertSame(_source, _result.source);
     JUnitTestCase.assertSame(_unit, _result.resolvedUnit);
     JUnitTestCase.assertEquals("hello", _result.oldContents);
     JUnitTestCase.assertEquals("hbazxlo", _result.newContents);
     JUnitTestCase.assertEquals(1, _result.offset);
     JUnitTestCase.assertEquals(2, _result.oldLength);
     JUnitTestCase.assertEquals(4, _result.newLength);
   }
   void test_update_delete() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "hzlo",
         1,
         2,
         0,
         newEntry);
     JUnitTestCase.assertNotNull(_result);
     JUnitTestCase.assertSame(_source, _result.source);
     JUnitTestCase.assertSame(_unit, _result.resolvedUnit);
     JUnitTestCase.assertEquals("hello", _result.oldContents);
     JUnitTestCase.assertEquals("hzlo", _result.newContents);
     JUnitTestCase.assertEquals(1, _result.offset);
     JUnitTestCase.assertEquals(2, _result.oldLength);
     JUnitTestCase.assertEquals(1, _result.newLength);
   }
   void test_update_insert_nonContiguous_after() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "hbazlox",
         6,
         0,
         1,
         newEntry);
     JUnitTestCase.assertNull(_result);
   }
   void test_update_insert_nonContiguous_before() {
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         _source,
         "hello",
         "hbazlo",
         1,
         2,
         3,
         _entry);
-    DartEntryImpl newEntry = new DartEntryImpl();
+    DartEntry newEntry = new DartEntry();
     _result = IncrementalAnalysisCache.update(
         cache,
         _source,
         "hbazlo",
         "xhbazlo",
         0,
         0,
         1,
         newEntry);
     JUnitTestCase.assertNull(_result);
   }
   void test_update_newSource_entry() {
     Source oldSource = new TestSource("blat.dart", "blat");
-    DartEntryImpl oldEntry = new DartEntryImpl();
+    DartEntry oldEntry = new DartEntry();
     CompilationUnit oldUnit = new CompilationUnitMock();
     oldEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, oldUnit);
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         oldSource,
         "hello",
         "hbazlo",
         1,
         2,
         3,
@@ skipping 13 matching lines @@
     JUnitTestCase.assertSame(_source, _result.source);
     JUnitTestCase.assertSame(_unit, _result.resolvedUnit);
     JUnitTestCase.assertEquals("foo", _result.oldContents);
     JUnitTestCase.assertEquals("foobz", _result.newContents);
     JUnitTestCase.assertEquals(3, _result.offset);
     JUnitTestCase.assertEquals(0, _result.oldLength);
     JUnitTestCase.assertEquals(2, _result.newLength);
   }
   void test_update_newSource_noEntry() {
     Source oldSource = new TestSource("blat.dart", "blat");
-    DartEntryImpl oldEntry = new DartEntryImpl();
+    DartEntry oldEntry = new DartEntry();
     CompilationUnit oldUnit = new CompilationUnitMock();
     oldEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, oldUnit);
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         oldSource,
         "hello",
         "hbazlo",
         1,
         2,
         3,
@@ skipping 347 matching lines @@
   }
 
   CompilationUnit _assertTask(String prefix, String removed, String added,
       String suffix) {
     String oldCode =
         EngineTestCase.createSource(["${prefix}${removed}${suffix}"]);
     String newCode =
         EngineTestCase.createSource(["${prefix}${added}${suffix}"]);
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     Source source = new TestSource("/test.dart", oldCode);
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     CompilationUnit oldUnit = context.resolveCompilationUnit2(source, source);
     JUnitTestCase.assertNotNull(oldUnit);
     entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, source, oldUnit);
     IncrementalAnalysisCache cache = IncrementalAnalysisCache.update(
         null,
         source,
         oldCode,
         newCode,
         prefix.length,
         removed.length,
@@ skipping 2922 matching lines @@
     TestSource source = new TestSource();
     JUnitTestCase.assertTrue(partition.contains(source));
   }
   void test_creation() {
     JUnitTestCase.assertNotNull(new UniversalCachePartition(null, 8, null));
   }
   void test_entrySet() {
     UniversalCachePartition partition =
         new UniversalCachePartition(null, 8, null);
     TestSource source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     partition.put(source, entry);
     JavaIterator<MapEntry<Source, SourceEntry>> entries =
         new JavaIterator(getMapEntrySet(partition.map));
     JUnitTestCase.assertTrue(entries.hasNext);
     MapEntry<Source, SourceEntry> mapEntry = entries.next();
     JUnitTestCase.assertSame(source, mapEntry.getKey());
     JUnitTestCase.assertSame(entry, mapEntry.getValue());
     JUnitTestCase.assertFalse(entries.hasNext);
   }
   void test_get() {
     UniversalCachePartition partition =
         new UniversalCachePartition(null, 8, null);
     TestSource source = new TestSource();
     JUnitTestCase.assertNull(partition.get(source));
   }
   void test_put_noFlush() {
     UniversalCachePartition partition =
         new UniversalCachePartition(null, 8, null);
     TestSource source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     partition.put(source, entry);
     JUnitTestCase.assertSame(entry, partition.get(source));
   }
   void test_remove() {
     UniversalCachePartition partition =
         new UniversalCachePartition(null, 8, null);
     TestSource source = new TestSource();
-    DartEntryImpl entry = new DartEntryImpl();
+    DartEntry entry = new DartEntry();
     partition.put(source, entry);
     JUnitTestCase.assertSame(entry, partition.get(source));
     partition.remove(source);
     JUnitTestCase.assertNull(partition.get(source));
   }
   void test_setMaxCacheSize() {
     UniversalCachePartition partition = new UniversalCachePartition(
         null,
         8,
         new _UniversalCachePartitionTest_test_setMaxCacheSize());
     int size = 6;
     for (int i = 0; i < size; i++) {
       Source source = new TestSource("/test${i}.dart");
-      DartEntryImpl entry = new DartEntryImpl();
+      DartEntry entry = new DartEntry();
       entry.setValue(DartEntry.PARSED_UNIT, null);
       partition.put(source, entry);
       partition.accessedAst(source);
     }
     _assertNonFlushedCount(size, partition);
     int newSize = size - 2;
     partition.maxCacheSize = newSize;
     _assertNonFlushedCount(newSize, partition);
   }
   void test_size() {
     UniversalCachePartition partition =
         new UniversalCachePartition(null, 8, null);
     int size = 4;
     for (int i = 0; i < size; i++) {
       Source source = new TestSource("/test${i}.dart");
-      partition.put(source, new DartEntryImpl());
+      partition.put(source, new DartEntry());
       partition.accessedAst(source);
     }
     JUnitTestCase.assertEquals(size, partition.size());
   }
   void _assertNonFlushedCount(int expectedCount,
       UniversalCachePartition partition) {
     int nonFlushedCount = 0;
     JavaIterator<MapEntry<Source, SourceEntry>> entries =
         new JavaIterator(getMapEntrySet(partition.map));
     while (entries.hasNext) {
@@ skipping 164 matching lines @@
   }
 }
 
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize implements
     CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }