Add SourceEntry.CONTENT_ERRORS data descriptor.

pkg/analyzer/lib/src/generated/engine.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;
 
 import "dart:math" as math;
@@ skipping 4666 matching lines @@
    */
   SourceEntry _recordGetContentsTask(GetContentTask task) {
     if (!task.isComplete) {
       return null;
     }
     Source source = task.source;
     SourceEntry sourceEntry = _cache.get(source);
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       sourceEntry.recordContentError(thrownException);
-      // TODO(scheglov) should we add separate ContentErrorCode and
-      // SourceEntry.CONTENT_ERRORS entry?
-      if (sourceEntry is DartEntry) {
-        sourceEntry.setValue(
-            DartEntry.SCAN_ERRORS,
-            <AnalysisError>[
-                new AnalysisError.con1(
-                    source,
-                    ScannerErrorCode.UNABLE_GET_CONTENT,
-                    [thrownException.toString()])]);
+      {
+        sourceEntry.setValue(SourceEntry.CONTENT_ERRORS, task.errors);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(sourceEntry.allErrors, null);
       }
       _workManager.remove(source);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     sourceEntry.modificationTime = task.modificationTime;
     sourceEntry.setValue(SourceEntry.CONTENT, task.content);
     return sourceEntry;
   }
@@ skipping 3171 matching lines @@
           "DartEntry.RESOLUTION_ERRORS",
           AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<CompilationUnit> RESOLVED_UNIT =
       new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
 
   /**
-   * The data descriptor representing the token stream.
+   * The data descriptor representing the errors resulting from scanning the
+   * source.
    */
   static final DataDescriptor<List<AnalysisError>> SCAN_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
           "DartEntry.SCAN_ERRORS",
           AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the source kind.
    */
   static final DataDescriptor<SourceKind> SOURCE_KIND =
@@ skipping 26 matching lines @@
    * `null`.
    */
   ResolutionState _resolutionState = new ResolutionState();
 
   /**
    * Return all of the errors associated with the compilation unit that are
    * currently cached.
    */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
+    errors.addAll(super.allErrors);
     errors.addAll(getValue(SCAN_ERRORS));
     errors.addAll(getValue(PARSE_ERRORS));
     ResolutionState state = _resolutionState;
     while (state != null) {
       errors.addAll(state.getValue(RESOLUTION_ERRORS));
       errors.addAll(state.getValue(VERIFICATION_ERRORS));
       errors.addAll(state.getValue(HINTS));
       errors.addAll(state.getValue(LINTS));
       state = state._nextState;
     }
@@ skipping 1094 matching lines @@
    * A flag indicating whether this task is complete.
    */
   bool _complete = false;
 
   /**
    * The contents of the source.
    */
   String _content;
 
   /**
+   * The errors that were produced by getting the source content.
+   */
+  final List<AnalysisError> errors = <AnalysisError>[];
+
+  /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param contentData the time-stamped contents of the source
@@ skipping 43 matching lines @@
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
       AnalysisEngine.instance.instrumentationService.logFileRead(
           source.fullName,
           _modificationTime,
           _content);
     } catch (exception, stackTrace) {
+      errors.add(
+          new AnalysisError.con1(
+              source,
+              ScannerErrorCode.UNABLE_GET_CONTENT,
+              [exception]));
       throw new AnalysisException(
           "Could not get contents of $source",
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * An `HtmlEntry` maintains the information cached by an analysis context about
  * an individual HTML file.
@@ skipping 51 matching lines @@
       new DataDescriptor<List<AnalysisError>>(
           "HtmlEntry.RESOLUTION_ERRORS",
           AnalysisError.NO_ERRORS);
 
   /**
    * Return all of the errors associated with the HTML file that are currently
    * cached.
    */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
+    errors.addAll(super.allErrors);
     errors.addAll(getValue(PARSE_ERRORS));
     errors.addAll(getValue(RESOLUTION_ERRORS));
     errors.addAll(getValue(HINTS));
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return errors;
   }
 
   /**
@@ skipping 2411 matching lines @@
  * an individual source, no matter what kind of source it is.
  */
 abstract class SourceEntry {
   /**
    * The data descriptor representing the contents of the source.
    */
   static final DataDescriptor<String> CONTENT =
       new DataDescriptor<String>("SourceEntry.CONTENT");
 
   /**
+   * The data descriptor representing the errors resulting from reading the
+   * source content.
+   */
+  static final DataDescriptor<List<AnalysisError>> CONTENT_ERRORS =
+      new DataDescriptor<List<AnalysisError>>(
+          "SourceEntry.CONTENT_ERRORS",
+          AnalysisError.NO_ERRORS);
+
+  /**
    * The data descriptor representing the line information.
    */
   static final DataDescriptor<LineInfo> LINE_INFO =
       new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO");
 
   /**
    * The index of the flag indicating whether the source was explicitly added to
    * the context or whether the source was implicitly added because it was
    * referenced by another source.
    */
@@ skipping 24 matching lines @@
   int _flags = 0;
 
   /**
    * A table mapping data descriptors to the cached results for those
    * descriptors.
    */
   Map<DataDescriptor, CachedResult> resultMap =
       new HashMap<DataDescriptor, CachedResult>();
 
   /**
+   * Return all of the errors associated with this entry.
+   */
+  List<AnalysisError> get allErrors {
+    List<AnalysisError> errors = new List<AnalysisError>();

[Brian Wilkerson, 2015/02/11 20:49:23]

Or just
  return getValue(CONTENT_ERRORS);
at least until there are other lists of errors.

+    errors.addAll(getValue(CONTENT_ERRORS));
+    return errors;
+  }
+
+  /**
    * Get a list of all the library-independent descriptors for which values may
    * be stored in this SourceEntry.
    */
   List<DataDescriptor> get descriptors {
-    return <DataDescriptor>[SourceEntry.CONTENT, SourceEntry.LINE_INFO];
+    return <DataDescriptor>[CONTENT, CONTENT_ERRORS, LINE_INFO];
   }
 
   /**
    * Return `true` if the source was explicitly added to the context or `false`
    * if the source was implicitly added because it was referenced by another
    * source.
    */
   bool get explicitlyAdded => _getFlag(_EXPLICITLY_ADDED_FLAG);
 
   /**
@@ skipping 78 matching lines @@
       }
     }
     return false;
   }
 
   /**
    * Invalidate all of the information associated with this source.
    */
   void invalidateAllInformation() {
     setState(CONTENT, CacheState.INVALID);
+    setState(CONTENT_ERRORS, CacheState.INVALID);
     setState(LINE_INFO, CacheState.INVALID);
   }
 
   /**
    * Record that an [exception] occurred while attempting to get the contents of
    * the source represented by this entry. This will set the state of all
    * information, including any resolution-based information, as being in error.
    */
   void recordContentError(CaughtException exception) {
     setState(CONTENT, CacheState.ERROR);
@@ skipping 78 matching lines @@
 
   /**
    * Return the value of the flag with the given [index].
    */
   bool _getFlag(int index) => BooleanArray.get(_flags, index);
 
   /**
    * Return `true` if the [descriptor] is valid for this entry.
    */
   bool _isValidDescriptor(DataDescriptor descriptor) {
-    return descriptor == CONTENT || descriptor == LINE_INFO;
+    return descriptor == CONTENT ||
+        descriptor == CONTENT_ERRORS ||
+        descriptor == LINE_INFO;
   }
 
   /**
    * Set the value of the flag with the given [index] to the given [value].
    */
   void _setFlag(int index, bool value) {
     _flags = BooleanArray.set(_flags, index, value);
   }
 
   /**
@@ skipping 40 matching lines @@
         buffer.write("; ");
       }
       buffer.write("time = ");
       buffer.write(oldModificationTime);
       buffer.write(" -> ");
       buffer.write(modificationTime);
       needsSeparator = true;
     }
     needsSeparator =
         _writeStateDiffOn(buffer, needsSeparator, "content", CONTENT, oldEntry);
+    needsSeparator = _writeStateDiffOn(
+        buffer,
+        needsSeparator,
+        "contentErrors",
+        CONTENT_ERRORS,
+        oldEntry);
     needsSeparator =
         _writeStateDiffOn(buffer, needsSeparator, "lineInfo", LINE_INFO, oldEntry);
     return needsSeparator;
   }
 
   /**
    * Write a textual representation of this entry to the given [buffer]. The
    * result should only be used for debugging purposes.
    */
   void _writeOn(StringBuffer buffer) {
     buffer.write("time = ");
     buffer.write(modificationTime);
     _writeStateOn(buffer, "content", CONTENT);
+    _writeStateOn(buffer, "contentErrors", CONTENT_ERRORS);
     _writeStateOn(buffer, "lineInfo", LINE_INFO);
   }
 
   /**
    * Write a textual representation of the difference between the state of the
    * value described by the given [descriptor] between the [oldEntry] and this
    * entry to the given [buffer]. Return `true` if some difference was written.
    */
   bool _writeStateDiffOn(StringBuffer buffer, bool needsSeparator, String label,
       DataDescriptor descriptor, SourceEntry oldEntry) {
@@ skipping 455 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }