java2dart improvements and new analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/engine.dart

 // 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;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart' show Token, CharBufferScanner, StringScanner;
@@ skipping 1069 matching lines @@
 
   /**
    * Return the state of the data represented by the given descriptor in the context of the given
    * library.
    *
    * @param descriptor the descriptor representing the data whose state is to be returned
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @return the value of the data represented by the given descriptor and library
    */
-  CacheState getState2(DataDescriptor<Object> descriptor, Source librarySource);
+  CacheState getState2(DataDescriptor descriptor, Source librarySource);
 
   /**
    * Return the value of the data represented by the given descriptor in the context of the given
    * library, or `null` if the data represented by the descriptor is not in the cache.
    *
    * @param descriptor the descriptor representing which data is to be returned
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @return the value of the data represented by the given descriptor and library
    */
@@ skipping 202 matching lines @@
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (identical(state._resolvedUnitState, CacheState.VALID)) {
         return state._resolvedUnit.accept(new ASTCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
-  CacheState getState(DataDescriptor<Object> descriptor) {
+  CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return _clientServerState;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       return _launchableState;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return _parseErrorsState;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespaceState;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState;
     } else {
       return super.getState(descriptor);
     }
   }
-  CacheState getState2(DataDescriptor<Object> descriptor, Source librarySource2) {
+  CacheState getState2(DataDescriptor descriptor, Source librarySource2) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource2 == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return _resolutionState._resolutionErrorsState;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return _resolutionState._resolvedUnitState;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return _resolutionState._hintsState;
         } else {
@@ skipping 213 matching lines @@
     if (_parsedUnitState != CacheState.VALID) {
       _parsedUnit = unit;
       _parsedUnitAccessed = false;
       _parsedUnitState = CacheState.VALID;
     }
     if (_parseErrorsState != CacheState.VALID) {
       _parseErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
       _parseErrorsState = CacheState.VALID;
     }
   }
-  void setState(DataDescriptor<Object> descriptor, CacheState state) {
+  void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = updatedValue(state, _exportedLibraries, Source.EMPTY_ARRAY);
       _exportedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = updatedValue(state, _importedLibraries, Source.EMPTY_ARRAY);
       _importedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
@@ skipping 28 matching lines @@
 
   /**
    * Set the state of the data represented by the given descriptor in the context of the given
    * library to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param cacheState the new state of the data represented by the given descriptor
    */
-  void setState2(DataDescriptor<Object> descriptor, Source librarySource, CacheState cacheState) {
+  void setState2(DataDescriptor descriptor, Source librarySource, CacheState cacheState) {
     DartEntryImpl_ResolutionState state = getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = updatedValue(cacheState, state._resolutionErrors, AnalysisError.NO_ERRORS);
       state._resolutionErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = updatedValue(cacheState, state._resolvedUnit, null);
       state._resolvedUnitState = cacheState;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = updatedValue(cacheState, state._hints, AnalysisError.NO_ERRORS);
       state._hintsState = cacheState;
@@ skipping 425 matching lines @@
     }
     for (AnalysisError error in _hints) {
       errors.add(error);
     }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
   SourceKind get kind => SourceKind.HTML;
-  CacheState getState(DataDescriptor<Object> descriptor) {
+  CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibrariesState;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrorsState;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hintsState;
@@ skipping 24 matching lines @@
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
-  void setState(DataDescriptor<Object> descriptor, CacheState state) {
+  void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _parsedUnit = updatedValue(state, _parsedUnit, null);
       _parsedUnitState = state;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = updatedValue(state, _referencedLibraries, Source.EMPTY_ARRAY);
       _referencedLibrariesState = state;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
@@ skipping 83 matching lines @@
    * @return the modification time of this entry
    */
   int get modificationTime;
 
   /**
    * Return the state of the data represented by the given descriptor.
    *
    * @param descriptor the descriptor representing the data whose state is to be returned
    * @return the state of the data represented by the given descriptor
    */
-  CacheState getState(DataDescriptor<Object> descriptor);
+  CacheState getState(DataDescriptor descriptor);
 
   /**
    * Return the value of the data represented by the given descriptor, or `null` if the data
    * represented by the descriptor is not in the cache.
    *
    * @param descriptor the descriptor representing which data is to be returned
    * @return the value of the data represented by the given descriptor
    */
   Object getValue(DataDescriptor descriptor);
 
@@ skipping 23 matching lines @@
    * The state of the cached line information.
    */
   CacheState _lineInfoState = CacheState.INVALID;
 
   /**
    * The line information computed for the source, or `null` if the line information is not
    * currently cached.
    */
   LineInfo _lineInfo;
   int get modificationTime => _modificationTime;
-  CacheState getState(DataDescriptor<Object> descriptor) {
+  CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfoState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfo as Object;
     } else {
@@ skipping 10 matching lines @@
   void set modificationTime(int time) {
     _modificationTime = time;
   }
 
   /**
    * Set the state of the data represented by the given descriptor to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param the new state of the data represented by the given descriptor
    */
-  void setState(DataDescriptor<Object> descriptor, CacheState state) {
+  void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = updatedValue(state, _lineInfo, null);
       _lineInfoState = state;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
    * Set the value of the data represented by the given descriptor to the given value.
@@ skipping 59 matching lines @@
 }
 /**
  * Implementation of the [AnalysisContentStatistics].
  */
 class AnalysisContentStatisticsImpl implements AnalysisContentStatistics {
   Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
   List<AnalysisContentStatistics_CacheRow> get cacheRows {
     Iterable<AnalysisContentStatistics_CacheRow> items = _dataMap.values;
     return new List.from(items);
   }
-  void putCacheItem(DataDescriptor<Object> rowDesc, CacheState state) {
+  void putCacheItem(DataDescriptor rowDesc, CacheState state) {
     String rowName = rowDesc.toString();
     AnalysisContentStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContentStatisticsImpl_CacheRowImpl;
     if (row == null) {
       row = new AnalysisContentStatisticsImpl_CacheRowImpl(rowName);
       _dataMap[rowName] = row;
     }
     row.incState(state);
   }
 }
 class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
@@ skipping 36 matching lines @@
  * Instances of the class `AnalysisContextImpl` implement an [AnalysisContext].
  *
  * @coverage dart.engine
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
 
   /**
    * Helper for [getStatistics], puts the library-specific state into the given statistics
    * object.
    */
-  static void putStatCacheItem(AnalysisContentStatisticsImpl statistics, DartEntry dartEntry, Source librarySource, DataDescriptor<Object> key) {
+  static void putStatCacheItem(AnalysisContentStatisticsImpl statistics, DartEntry dartEntry, Source librarySource, DataDescriptor key) {
     statistics.putCacheItem(key, dartEntry.getState2(key, librarySource));
   }
 
   /**
    * Helper for [getStatistics], puts the library independent state into the given
    * statistics object.
    */
-  static void putStatCacheItem2(AnalysisContentStatisticsImpl statistics, SourceEntry entry, DataDescriptor<Object> key) {
+  static void putStatCacheItem2(AnalysisContentStatisticsImpl statistics, SourceEntry entry, DataDescriptor key) {
     statistics.putCacheItem(key, entry.getState(key));
   }
 
   /**
    * The set of analysis options controlling the behavior of this context.
    */
   AnalysisOptions _options = new AnalysisOptionsImpl();
 
   /**
    * The source factory used to create the sources that can be analyzed in this context.
@@ skipping 173 matching lines @@
     }
     return htmlEntry.getValue(HtmlEntry.ELEMENT);
   }
   List<Source> computeImportedLibraries(Source source) => internalGetDartParseData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
   SourceKind computeKindOf(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     } else if (sourceEntry is DartEntry) {
       try {
-        return internalGetDartParseData(source, (sourceEntry as DartEntry), DartEntry.SOURCE_KIND);
+        return internalGetDartParseData(source, sourceEntry as DartEntry, DartEntry.SOURCE_KIND);
       } on AnalysisException catch (exception) {
         return SourceKind.UNKNOWN;
       }
     }
     return sourceEntry.kind;
   }
   LibraryElement computeLibraryElement(Source source) {
     {
       DartEntry dartEntry = getDartEntry(source);
       if (dartEntry == null) {
@@ skipping 38 matching lines @@
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         CompilationUnit unit = dartCopy.resolvableCompilationUnit;
         if (unit != null) {
           _sourceMap[source] = dartCopy;
           return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
         }
       }
       internalParseDart(source);
     }
   }
-  AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, (AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext));
+  AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
     List<Source> sourcesToRemove = new List<Source>();
     {
       for (MapEntry<Source, SourceEntry> entry in getMapEntrySet(_sourceMap)) {
         Source source = entry.getKey();
         if (container.contains(source)) {
           sourcesToRemove.add(source);
           newContext.addSourceInfo(source, entry.getValue().writableCopy);
         }
       }
@@ skipping 373 matching lines @@
             TypeProvider typeProvider = new TypeProviderImpl(coreElement);
             ResolvableCompilationUnit resolvableUnit = computeResolvableCompilationUnit(unitSource);
             CompilationUnit unitAST = resolvableUnit.compilationUnit;
             new DeclarationResolver().resolve(unitAST, find(libraryElement, unitSource));
             RecordingErrorListener errorListener = new RecordingErrorListener();
             TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor.con2(libraryElement, unitSource, typeProvider, errorListener);
             unitAST.accept(typeResolverVisitor);
             InheritanceManager inheritanceManager = new InheritanceManager(libraryElement);
             ResolverVisitor resolverVisitor = new ResolverVisitor.con2(libraryElement, unitSource, typeProvider, inheritanceManager, errorListener);
             unitAST.accept(resolverVisitor);
+            for (ProxyConditionalAnalysisError conditionalCode in resolverVisitor.proxyConditionalAnalysisErrors) {
+              if (conditionalCode.shouldIncludeErrorCode()) {
+                resolverVisitor.reportError(conditionalCode.analysisError);
+              }
+            }
             ErrorReporter errorReporter = new ErrorReporter(errorListener, unitSource);
             ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, inheritanceManager);
             unitAST.accept(errorVerifier);
             ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
             unitAST.accept(constantVerifier);
             unitAST.resolutionErrors = errorListener.errors;
             DartEntryImpl dartCopy = getDartEntry(unitSource).writableCopy;
             dartCopy.setValue2(DartEntry.RESOLVED_UNIT, librarySource, unitAST);
             _sourceMap[unitSource] = dartCopy;
             unit = unitAST;
@@ skipping 492 matching lines @@
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the given descriptors is available. This method assumes that the data can be produced by
    * parsing the source if it is not already cached.
    *
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    */
-  bool hasHtmlParseDataCached(HtmlEntry htmlEntry, List<DataDescriptor<Object>> descriptors) {
-    for (DataDescriptor<Object> descriptor in descriptors) {
+  bool hasHtmlParseDataCached(HtmlEntry htmlEntry, List<DataDescriptor> descriptors) {
+    for (DataDescriptor descriptor in descriptors) {
       CacheState state = htmlEntry.getState(descriptor);
       if (state != CacheState.VALID && state != CacheState.ERROR) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the data represented by the given
    * descriptor is available. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  DartEntry internalCacheDartParseData(Source source, DartEntry dartEntry, DataDescriptor<Object> descriptor) {
+  DartEntry internalCacheDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       dartEntry = internalParseDart(source);
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * all of the data represented by the given descriptors is available. This method assumes that the
    * data can be produced by resolving the source in the context of the library if it is not already
    * cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  DartEntry internalCacheDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor<Object> descriptor) {
+  DartEntry internalCacheDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     CacheState state = dartEntry.getState2(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       dartEntry = internalResolveDart(unitSource, librarySource);
       state = dartEntry.getState2(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the given descriptors is available. This method assumes that the data can be produced by
    * parsing the source if it is not already cached.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  HtmlEntry internalCacheHtmlParseData(Source source, HtmlEntry htmlEntry, List<DataDescriptor<Object>> descriptors) {
+  HtmlEntry internalCacheHtmlParseData(Source source, HtmlEntry htmlEntry, List<DataDescriptor> descriptors) {
     while (!hasHtmlParseDataCached(htmlEntry, descriptors)) {
       htmlEntry = internalParseHtml(source);
     }
     return htmlEntry;
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
@@ skipping 119 matching lines @@
       CompilationUnit unit = parser.parseCompilationUnit(scanResult._token);
       LineInfo lineInfo = new LineInfo(scanResult._lineStarts);
       List<AnalysisError> errors = errorListener.getErrors2(source);
       bool hasPartOfDirective = false;
       bool hasLibraryDirective = false;
       Set<Source> exportedSources = new Set<Source>();
       Set<Source> importedSources = new Set<Source>();
       Set<Source> includedSources = new Set<Source>();
       for (Directive directive in unit.directives) {
         if (directive is ExportDirective) {
-          Source exportSource = resolveSource(source, (directive as ExportDirective));
+          Source exportSource = resolveSource(source, directive as ExportDirective);
           if (exportSource != null) {
             javaSetAdd(exportedSources, exportSource);
           }
         } else if (directive is ImportDirective) {
-          Source importSource = resolveSource(source, (directive as ImportDirective));
+          Source importSource = resolveSource(source, directive as ImportDirective);
           if (importSource != null) {
             javaSetAdd(importedSources, importSource);
           }
         } else if (directive is LibraryDirective) {
           hasLibraryDirective = true;
         } else if (directive is PartDirective) {
-          Source partSource = resolveSource(source, (directive as PartDirective));
+          Source partSource = resolveSource(source, directive as PartDirective);
           if (partSource != null) {
             javaSetAdd(includedSources, partSource);
           }
         } else if (directive is PartOfDirective) {
           hasPartOfDirective = true;
         }
       }
       unit.parsingErrors = errors;
       unit.lineInfo = lineInfo;
       if (identical(dartCopy.getState(DartEntry.SOURCE_KIND), CacheState.INVALID)) {
@@ skipping 43 matching lines @@
     AnalysisException thrownException = null;
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       scanResult = internalScan(source, errorListener);
       Parser parser = new Parser(source, errorListener);
       unit = parser.parseCompilationUnit(scanResult._token);
       lineInfo = new LineInfo(scanResult._lineStarts);
       errors = errorListener.getErrors2(source);
       for (Directive directive in unit.directives) {
         if (directive is ExportDirective) {
-          Source exportSource = resolveSource(source, (directive as ExportDirective));
+          Source exportSource = resolveSource(source, directive as ExportDirective);
           if (exportSource != null) {
             javaSetAdd(exportedSources, exportSource);
           }
         } else if (directive is ImportDirective) {
-          Source importSource = resolveSource(source, (directive as ImportDirective));
+          Source importSource = resolveSource(source, directive as ImportDirective);
           if (importSource != null) {
             javaSetAdd(importedSources, importSource);
           }
         } else if (directive is LibraryDirective) {
           hasLibraryDirective = true;
         } else if (directive is PartDirective) {
-          Source partSource = resolveSource(source, (directive as PartDirective));
+          Source partSource = resolveSource(source, directive as PartDirective);
           if (partSource != null) {
             javaSetAdd(includedSources, partSource);
           }
         } else if (directive is PartOfDirective) {
           hasPartOfDirective = true;
         }
       }
       unit.parsingErrors = errors;
       unit.lineInfo = lineInfo;
     } on AnalysisException catch (exception) {
@@ skipping 521 matching lines @@
    * Parse the given source and update the cache.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be parsed
    */
   void safelyParseHtmlUnit(Source source) {
     try {
       parseHtmlUnit(source);
     } on AnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logError2("Could not parse ${source.fullName}", exception);
+      if (exception.cause is! JavaIOException) {
+        AnalysisEngine.instance.logger.logError2("Could not parse ${source.fullName}", exception);
+      }
     }
   }
 
   /**
    * Resolve the given source and update the cache.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be resolved
    */
@@ skipping 462 matching lines @@
    *
    * @param isStrict `true` if analysis is to use strict mode
    */
   void set strictMode(bool isStrict) {
     _strictMode = isStrict;
   }
 }
 /**
  * The enumeration `CacheState` defines the possible states of cached data.
  */
-class CacheState implements Enum<CacheState> {
+class CacheState extends Enum<CacheState> {
 
   /**
    * The data is not in the cache and the last time an attempt was made to compute the data an
    * exception occurred, making it pointless to attempt.
    *
    * Valid Transitions:
    *
    * * [INVALID] if a source was modified that might cause the data to be computable
    *
    */
@@ skipping 36 matching lines @@
    * The data is in the cache and up-to-date.
    *
    * Valid Transitions:
    *
    * * [FLUSHED] if the data is removed in order to manage memory usage
    * * [INVALID] if a source was modified in such a way as to invalidate the previous data
    *
    */
   static final CacheState VALID = new CacheState('VALID', 4);
   static final List<CacheState> values = [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
-
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-  CacheState(this.name, this.ordinal);
-  int compareTo(CacheState other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
+  CacheState(String name, int ordinal) : super(name, ordinal);
 }
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  *
  * @coverage dart.engine
  */
 class ChangeNoticeImpl implements ChangeNotice {
 
   /**
@@ skipping 1168 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }