Use memento in ParseDartTask.

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.task.dart;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1888 matching lines @@
    * Create a [GenerateHintsTask] based on the given [target] in
    * the given [context].
    */
   static GenerateHintsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new GenerateHintsTask(context, target);
   }
 }
 
 /**
+ * The memento for [ParseDartTask].
+ */
+class ParseDartMemento {
+  final Token inputTokenStream;
+  final List<Source> exportedLibraries;
+  final List<Source> importedLibraries;
+  final List<Source> includedParts;
+  final List<AnalysisError> parseErrors;
+  final CompilationUnit parsedUnit;
+  final SourceKind sourceKind;
+  final List<Source> units;
+  ParseDartMemento(this.inputTokenStream, this.exportedLibraries,
+      this.importedLibraries, this.includedParts, this.parseErrors,
+      this.parsedUnit, this.sourceKind, this.units);
+}
+
+/**
  * A task that parses the content of a Dart file, producing an AST structure.
  */
 class ParseDartTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the line information produced for the
    * file.
    */
   static const String LINE_INFO_INPUT_NAME = 'LINE_INFO_INPUT_NAME';
 
   /**
@@ skipping 24 matching lines @@
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     Source source = getRequiredSource();
     LineInfo lineInfo = getRequiredInput(LINE_INFO_INPUT_NAME);
     Token tokenStream = getRequiredInput(TOKEN_STREAM_INPUT_NAME);
 
+    if (inputMemento is ParseDartMemento) {
+      ParseDartMemento memento = inputMemento;
+      if (identical(memento.inputTokenStream, tokenStream)) {
+        outputMemento = memento;
+        outputs[EXPORTED_LIBRARIES] = memento.exportedLibraries;
+        outputs[IMPORTED_LIBRARIES] = memento.importedLibraries;
+        outputs[INCLUDED_PARTS] = memento.includedParts;
+        outputs[PARSE_ERRORS] = memento.parseErrors;
+        outputs[PARSED_UNIT] = memento.parsedUnit;
+        outputs[SOURCE_KIND] = memento.sourceKind;
+        outputs[UNITS] = memento.units;
+        return;
+      }
+    }
+
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Parser parser = new Parser(source, errorListener);
     AnalysisOptions options = context.analysisOptions;
     parser.parseFunctionBodies = options.analyzeFunctionBodiesPredicate(source);
     CompilationUnit unit = parser.parseCompilationUnit(tokenStream);
     unit.lineInfo = lineInfo;
 
     bool hasNonPartOfDirective = false;
     bool hasPartOfDirective = false;
-    HashSet<Source> exportedSources = new HashSet<Source>();
-    HashSet<Source> importedSources = new HashSet<Source>();
-    HashSet<Source> includedSources = new HashSet<Source>();
+    HashSet<Source> exportedSourceSet = new HashSet<Source>();
+    HashSet<Source> importedSourceSet = new HashSet<Source>();
+    HashSet<Source> includedSourceSet = new HashSet<Source>();
     for (Directive directive in unit.directives) {
       if (directive is PartOfDirective) {
         hasPartOfDirective = true;
       } else {
         hasNonPartOfDirective = true;
         if (directive is UriBasedDirective) {
           Source referencedSource =
               resolveDirective(context, source, directive, errorListener);
           if (referencedSource != null) {
             if (directive is ExportDirective) {
-              exportedSources.add(referencedSource);
+              exportedSourceSet.add(referencedSource);
             } else if (directive is ImportDirective) {
-              importedSources.add(referencedSource);
+              importedSourceSet.add(referencedSource);
             } else if (directive is PartDirective) {
               if (referencedSource != source) {
-                includedSources.add(referencedSource);
+                includedSourceSet.add(referencedSource);
               }
             } else {
               throw new AnalysisException(
                   '$runtimeType failed to handle a ${directive.runtimeType}');
             }
           }
         }
       }
     }
     //
     // Always include "dart:core" source.
     //
     Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
-    importedSources.add(coreLibrarySource);
+    importedSourceSet.add(coreLibrarySource);
     //
     // Compute kind.
     //
     SourceKind sourceKind = SourceKind.LIBRARY;
     if (!hasNonPartOfDirective && hasPartOfDirective) {
       sourceKind = SourceKind.PART;
     }
     //
     // Record outputs.
     //
-    outputs[EXPORTED_LIBRARIES] = exportedSources.toList();
-    outputs[IMPORTED_LIBRARIES] = importedSources.toList();
-    outputs[INCLUDED_PARTS] = includedSources.toList();
-    outputs[PARSE_ERRORS] = errorListener.getErrorsForSource(source);
+    List<Source> exportedSources = exportedSourceSet.toList();
+    List<Source> importedSources = importedSourceSet.toList();
+    List<Source> includedSources = includedSourceSet.toList();
+    List<AnalysisError> parseErrors = errorListener.errors;
+    List<Source> unitSources = <Source>[source]..addAll(includedSourceSet);
+    outputs[EXPORTED_LIBRARIES] = exportedSources;
+    outputs[IMPORTED_LIBRARIES] = importedSources;
+    outputs[INCLUDED_PARTS] = includedSources;
+    outputs[PARSE_ERRORS] = parseErrors;
     outputs[PARSED_UNIT] = unit;
     outputs[SOURCE_KIND] = sourceKind;
-    outputs[UNITS] = <Source>[source]..addAll(includedSources);
+    outputs[UNITS] = unitSources;
+    outputMemento = new ParseDartMemento(tokenStream, exportedSources,
+        importedSources, includedSources, parseErrors, unit, sourceKind,
+        unitSources);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{
       LINE_INFO_INPUT_NAME: LINE_INFO.of(source),
@@ skipping 612 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }