Remove unnecessary state transitions

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 3285 matching lines @@
           new AnalysisException(
               "Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"),
           null);
       AnalysisEngine.instance.logger.logInformation(
           exception.toString(),
           exception);
       unitEntry.recordResolutionError(exception);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-    unitEntry.setStateInLibrary(
-        DartEntry.VERIFICATION_ERRORS,
-        librarySource,
-        CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new GenerateDartErrorsTask(this, unitSource, unit, libraryElement),
         false);
   }
 
   /**
    * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
    * in-process.
    *
    * @param source the source whose content is to be verified
@@ skipping 20 matching lines @@
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     for (int i = 0; i < parts.length; i++) {
       units[i + 1] = _getResolvedUnit(parts[i], librarySource);
       if (units[i + 1] == null) {
         // TODO(brianwilkerson) We should return a ResolveDartUnitTask
         // (unless there are multiple ASTs that need to be resolved).
         return _createResolveDartLibraryTask(librarySource, libraryEntry);
       }
     }
-    dartEntry.setStateInLibrary(
-        DartEntry.HINTS,
-        librarySource,
-        CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new GenerateDartHintsTask(this, units, libraryElement),
         false);
   }
 
   /**
    * Create a [GenerateDartLintsTask] for the given source, marking the lints as
    * being in-process.
    *
    * @param source the source whose content is to be verified
@@ skipping 20 matching lines @@
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     for (int i = 0; i < parts.length; i++) {
       units[i + 1] = _getResolvedUnit(parts[i], librarySource);
       if (units[i + 1] == null) {
         // TODO(brianwilkerson) We should return a ResolveDartUnitTask
         // (unless there are multiple ASTs that need to be resolved).
         return _createResolveDartLibraryTask(librarySource, libraryEntry);
       }
     }
-    dartEntry.setStateInLibrary(
-        DartEntry.LINTS,
-        librarySource,
-        CacheState.IN_PROCESS);
     //TODO(pquitslund): revisit if we need all units or whether one will do
     return new AnalysisContextImpl_TaskData(
         new GenerateDartLintsTask(this, units, libraryElement),
         false);
   }
 
   /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGetContentTask(Source source,
       SourceEntry sourceEntry) {
-    sourceEntry.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new GetContentTask(this, source),
         false);
   }
 
   /**
    * Create a [ParseDartTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createParseDartTask(Source source,
       DartEntry dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID ||
         dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
-    dartEntry.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new ParseDartTask(
             this,
             source,
             tokenStream,
             dartEntry.getValue(SourceEntry.LINE_INFO)),
         false);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createParseHtmlTask(Source source,
       HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     htmlEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
-    htmlEntry.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new ParseHtmlTask(this, source, content),
         false);
   }
 
   /**
    * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param dartEntry the entry for the source
@@ skipping 28 matching lines @@
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source,
       HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
     }
-    htmlEntry.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new ResolveHtmlTask(
             this,
             source,
             htmlEntry.modificationTime,
             htmlEntry.getValue(HtmlEntry.PARSED_UNIT)),
         false);
   }
 
   /**
    * Create a [ScanDartTask] for the given source, marking the scan errors as being
    * in-process.
    *
    * @param source the source whose content is to be scanned
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createScanDartTask(Source source,
       DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
-    dartEntry.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new ScanDartTask(this, source, content),
         false);
   }
 
   /**
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
@@ skipping 420 matching lines @@
       }
       List<Source> librariesContaining = dartEntry.containingLibraries;
       for (Source librarySource in librariesContaining) {
         SourceEntry librarySourceEntry = _cache.get(librarySource);
         if (librarySourceEntry is DartEntry) {
           DartEntry libraryEntry = librarySourceEntry;
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (elementState == CacheState.INVALID ||
               (isPriority && elementState == CacheState.FLUSHED)) {
 //            return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
-            libraryEntry.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             return new AnalysisContextImpl_TaskData(
                 new ResolveDartLibraryTask(this, source, librarySource),
                 false);
           }
           CacheState resolvedUnitState =
               dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
           if (resolvedUnitState == CacheState.INVALID ||
               (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             //
             // The commented out lines below are an optimization that doesn't
             // quite work yet. The problem is that if the source was not
             // resolved because it wasn't part of any library, then there won't
             // be any elements in the element model that we can use to resolve
             // it.
             //
 //            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
 //            if (libraryElement != null) {
 //              return new ResolveDartUnitTask(this, source, libraryElement);
 //            }
             // Possibly replace with:
 //             return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
-            dartEntry.setStateInLibrary(
-                DartEntry.RESOLVED_UNIT,
-                librarySource,
-                CacheState.IN_PROCESS);
             return new AnalysisContextImpl_TaskData(
                 new ResolveDartLibraryTask(this, source, librarySource),
                 false);
           }
           if (_generateSdkErrors || !source.isInSystemLibrary) {
             CacheState verificationErrorsState =
                 dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
             if (verificationErrorsState == CacheState.INVALID ||
                 (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               return _createGenerateDartErrorsTask(
@@ skipping 3224 matching lines @@
    * Return the priority of retaining the AST structure for the given source.
    *
    * @param source the source whose AST structure is being considered for removal
    * @param sourceEntry the entry representing the source
    * @return the priority of retaining the AST structure for the given source
    */
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry);
 }
 
 /**
- * The enumeration `CacheState` defines the possible states of cached data.
+ * The possible states of cached data.
  */
 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.
+   * 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 to
+   * compute the data again.
    *
    * Valid Transitions:
-   * * [INVALID] if a source was modified that might cause the data to be computable
+   * * [INVALID] if a source was modified that might cause the data to be
+   *   computable
    */
   static const CacheState ERROR = const CacheState('ERROR', 0);
 
   /**
-   * The data is not in the cache because it was flushed from the cache in order to control memory
-   * usage. If the data is recomputed, results do not need to be reported.
+   * The data is not in the cache because it was flushed from the cache in order
+   * to control memory usage. If the data is recomputed, results do not need to
+   * be reported.
    *
    * Valid Transitions:
    * * [IN_PROCESS] if the data is being recomputed
-   * * [INVALID] if a source was modified that causes the data to need to be recomputed
+   * * [INVALID] if a source was modified that causes the data to need to be
+   *   recomputed
    */
   static const CacheState FLUSHED = const CacheState('FLUSHED', 1);
 
   /**
-   * The data might or might not be in the cache but is in the process of being recomputed.
+   * The data might or might not be in the cache but is in the process of being
+   * recomputed.
    *
    * Valid Transitions:
    * * [ERROR] if an exception occurred while trying to compute the data
    * * [VALID] if the data was successfully computed and stored in the cache
    */
   static const CacheState IN_PROCESS = const CacheState('IN_PROCESS', 2);
 
   /**
-   * The data is not in the cache and needs to be recomputed so that results can be reported.
+   * The data is not in the cache and needs to be recomputed so that results can
+   * be reported.
    *
    * Valid Transitions:
    * * [IN_PROCESS] if an attempt is being made to recompute the data
    */
   static const CacheState INVALID = const CacheState('INVALID', 3);
 
   /**
    * 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
+   * * [INVALID] if a source was modified in such a way as to invalidate the
+   *   previous data
    */
   static const CacheState VALID = const CacheState('VALID', 4);
 
   static const List<CacheState> values = const [
       ERROR,
       FLUSHED,
       IN_PROCESS,
       INVALID,
       VALID];
 
@@ skipping 5119 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }