Return outline after parse

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 2352 matching lines @@
           } else {
             dartEntry.recordResolutionErrorInLibrary(
                 librarySource,
                 thrownException);
           }
           if (source != librarySource) {
             _workManager.add(source, SourcePriority.PRIORITY_PART);
           }
           ChangeNoticeImpl notice = _getNotice(source);
           notice.compilationUnit = unit;
+          notice.resolved = true;
           notice.setErrors(dartEntry.allErrors, lineInfo);
         }
       }
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return unitEntry;
   }
 
@@ skipping 64 matching lines @@
             dartEntry.recordResolutionErrorInLibrary(
                 librarySource,
                 thrownException);
             _cache.remove(source);
           }
           if (source != librarySource) {
             _workManager.add(source, SourcePriority.PRIORITY_PART);
           }
           ChangeNoticeImpl notice = _getNotice(source);
           notice.compilationUnit = unit;
+          notice.resolved = true;
           notice.setErrors(dartEntry.allErrors, lineInfo);
         }
       }
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return unitEntry;
   }
 
@@ skipping 2152 matching lines @@
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry
       _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
     CompilationUnit unit = task.compilationUnit;
     if (unit != null) {
       ChangeNoticeImpl notice = _getNotice(task.source);
       notice.compilationUnit = unit;
+      notice.resolved = true;
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.cacheResult(task.cache, unit);
     }
     return null;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
@@ skipping 40 matching lines @@
         partEntry.addContainingLibrary(source);
       }
     }
     dartEntry.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
     dartEntry.setValue(DartEntry.PARSE_ERRORS, task.errors);
     dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
     dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
     dartEntry.setValue(DartEntry.INCLUDED_PARTS, newParts);
     _cache.storedAst(source);
     ChangeNoticeImpl notice = _getNotice(source);
+    if (notice.compilationUnit == null) {
+      notice.compilationUnit = task.compilationUnit;
+      notice.resolved = false;
+    }
     notice.setErrors(dartEntry.allErrors, task.lineInfo);
     // Verify that the incrementally parsed and resolved unit in the incremental
     // cache is structurally equivalent to the fully parsed unit
     _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(
         _incrementalAnalysisCache,
         source,
         task.compilationUnit);
     return dartEntry;
   }
 
@@ skipping 58 matching lines @@
       _cache.removedAst(source);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     htmlEntry.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
     htmlEntry.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
     htmlEntry.setValue(HtmlEntry.ELEMENT, task.element);
     htmlEntry.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
     _cache.storedAst(source);
     ChangeNoticeImpl notice = _getNotice(source);
     notice.htmlUnit = task.resolvedUnit;
+    notice.resolved = true;
     LineInfo lineInfo = htmlEntry.getValue(SourceEntry.LINE_INFO);
     notice.setErrors(htmlEntry.allErrors, lineInfo);
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   DartEntry _recordScanDartTaskResults(ScanDartTask task) {
@@ skipping 277 matching lines @@
           oldUnit.element.library.source;
       incrementalResolutionValidation_lastUnit = oldUnit;
       return false;
     }
     // prepare notices
     units.forEach((Source source, CompilationUnit unit) {
       DartEntry dartEntry = _cache.get(source);
       LineInfo lineInfo = getLineInfo(source);
       ChangeNoticeImpl notice = _getNotice(source);
       notice.compilationUnit = unit;
+      notice.resolved = true;
       notice.setErrors(dartEntry.allErrors, lineInfo);
     });
     // OK
     return true;
   }
 
   /**
    * Check the cache for any invalid entries (entries whose modification time does not match the
    * modification time of the source associated with the entry). Invalid entries will be marked as
    * invalid so that the source will be re-analyzed.
@@ skipping 2150 matching lines @@
       ERROR,
       FLUSHED,
       IN_PROCESS,
       INVALID,
       VALID];
 
   const CacheState(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
- * The interface `ChangeNotice` defines the behavior of objects that represent a change to the
- * analysis results associated with a given source.
+ * An object that represents a change to the analysis results associated with a
+ * given source.
  */
 abstract class ChangeNotice implements AnalysisErrorInfo {
   /**
-   * Return the fully resolved AST that changed as a result of the analysis, or `null` if the
-   * AST was not changed.
-   *
-   * @return the fully resolved AST that changed as a result of the analysis
+   * Return the AST that changed as a result of the analysis, or `null` if the
+   * AST was not changed. Use the getter [resolved] to determine whether the
+   * AST has been fully resolved.
    */
   CompilationUnit get compilationUnit;
 
   /**
-   * Return the fully resolved HTML that changed as a result of the analysis, or `null` if the
-   * HTML was not changed.
-   *
-   * @return the fully resolved HTML that changed as a result of the analysis
+   * Return the HTML that changed as a result of the analysis, or `null` if the
+   * HTML was not changed. Use the getter [resolved] to determine whether the
+   * HTML has been fully resolved.
    */
   ht.HtmlUnit get htmlUnit;
 
   /**
+   * Return `true` if the [compilationUnit] or [htmlUnit] (whichever is
+   * currently set) has been resolved.
+   */
+  bool get resolved;
+
+  /**
    * Return the source for which the result is being reported.
-   *
-   * @return the source for which the result is being reported
    */
   Source get source;
 }
 
 /**
- * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
- * associated with a given source.
+ * An implementation of a [ChangeNotice].
  */
 class ChangeNoticeImpl implements ChangeNotice {
   /**
    * An empty list of change notices.
    */
   static const List<ChangeNoticeImpl> EMPTY_ARRAY = const <ChangeNoticeImpl>[];
 
   /**
    * The source for which the result is being reported.
    */
   final Source source;
 
   /**
-   * The fully resolved AST that changed as a result of the analysis, or `null` if the AST was
-   * not changed.
+   * The AST that changed as a result of the analysis, or `null` if the AST was
+   * not changed. Use the getter [resolved] to determine whether the AST has
+   * been fully resolved.
    */
   CompilationUnit compilationUnit;
 
   /**
-   * The fully resolved HTML that changed as a result of the analysis, or `null` if the HTML
-   * was not changed.
+   * The HTML that changed as a result of the analysis, or `null` if the HTML
+   * was not changed. Use the getter [resolved] to determine whether the HTML
+   * has been fully resolved.
    */
   ht.HtmlUnit htmlUnit;
 
   /**
-   * The errors that changed as a result of the analysis, or `null` if errors were not
-   * changed.
+   * A flag indicating whether the [compilationUnit] or [htmlUnit] (whichever is
+   * currently set) has been resolved.
+   */
+  bool resolved = false;
+
+  /**
+   * The errors that changed as a result of the analysis, or `null` if errors
+   * were not changed.
    */
   List<AnalysisError> _errors;
 
   /**
-   * The line information associated with the source, or `null` if errors were not changed.
+   * The line information associated with the source, or `null` if errors were
+   * not changed.
    */
   LineInfo _lineInfo;
 
   /**
    * Initialize a newly created notice associated with the given source.
    *
    * @param source the source for which the change is being reported
    */
   ChangeNoticeImpl(this.source);
 
   @override
   List<AnalysisError> get errors => _errors;
 
   @override
   LineInfo get lineInfo => _lineInfo;
 
   /**
-   * Set the errors that changed as a result of the analysis to the given errors and set the line
-   * information to the given line information.
-   *
-   * @param errors the errors that changed as a result of the analysis
-   * @param lineInfo the line information associated with the source
+   * Set the errors that changed as a result of the analysis to the given
+   * [errors] and set the line information to the given [lineInfo].
    */
   void setErrors(List<AnalysisError> errors, LineInfo lineInfo) {
     this._errors = errors;
     this._lineInfo = lineInfo;
     if (lineInfo == null) {
       AnalysisEngine.instance.logger.logInformation(
           "No line info: $source",
           new CaughtException(new AnalysisException(), null));
     }
   }
@@ skipping 4919 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }