Remove memento.

pkg/analyzer/test/src/task/dart_test.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 test.src.task.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 190 matching lines @@
 part 'part.dart';
 class A {}
 class B = Object with A;
 ''');
     expect(outputs, hasLength(3));
     expect(outputs[CLASS_ELEMENTS], hasLength(2));
     expect(outputs[COMPILATION_UNIT_ELEMENT], isNotNull);
     expect(outputs[RESOLVED_UNIT1], isNotNull);
   }
 
-  test_perform_useMemento() {
-    Source source = newSource('/test.dart', r'''
-class A {}
-class B {}
-class C {}
-''');
-    AnalysisTarget target = new LibrarySpecificUnit(source, source);
-    _computeResult(target, RESOLVED_UNIT1);
-    // update content
-    context.setContents(source, r'''
-class C {}
-class A {}
-class B {}
-''');
-    assertIsInvalid(target, RESOLVED_UNIT1);
-    // recompute
-    _computeResult(target, RESOLVED_UNIT1);
-    assertIsValid(target, RESOLVED_UNIT1);
-    // values are produced using memento
-    List<ClassElement> newClassElements = outputs[CLASS_ELEMENTS];
-    CompilationUnit newUnit = outputs[RESOLVED_UNIT1];
-    CompilationUnitElement newUnitElement = outputs[COMPILATION_UNIT_ELEMENT];
-    expect(
-        newClassElements.map((_) => _.name), unorderedEquals(['A', 'B', 'C']));
-    expect(newUnitElement, same(oldOutputs[COMPILATION_UNIT_ELEMENT]));
-    expect(newUnit.element, newUnitElement);
-  }
-
   void _performBuildTask(String content) {
     Source source = newSource('/test.dart', content);
     AnalysisTarget target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT1);
     expect(task, new isInstanceOf<BuildCompilationUnitElementTask>());
   }
 }
 
 @reflectiveTest
 class BuildDirectiveElementsTaskTest extends _AbstractDartTaskTest {
@@ skipping 1498 matching lines @@
     expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
     expect(outputs[EXPORTED_LIBRARIES], hasLength(1));
     _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
     expect(outputs[INCLUDED_PARTS], hasLength(1));
     expect(outputs[PARSE_ERRORS], hasLength(1));
     expect(outputs[PARSED_UNIT], isNotNull);
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
     expect(outputs[UNITS], hasLength(2));
   }
 
-  test_perform_useMemento() {
-    String content = r'''
-library lib;
-import 'lib2.dart';
-export 'lib3.dart';
-part 'part.dart';
-class A {''';
-    AnalysisTarget target = newSource('/test.dart', content);
-    _computeResult(target, PARSED_UNIT);
-    // update content
-    context.setContents(target, content);
-    assertIsInvalid(target, PARSED_UNIT);
-    // recompute
-    _computeResult(target, PARSED_UNIT);
-    assertIsValid(target, PARSED_UNIT);
-    // values from the memento are returned
-    assertSameResults(ParseDartTask.DESCRIPTOR.results);
-  }
-
   void _performParseTask(String content) {
     AnalysisTarget target = newSource('/test.dart', content);
     _computeResult(target, PARSED_UNIT);
     expect(task, new isInstanceOf<ParseDartTask>());
   }
 
   static void _assertHasCore(List<Source> sources, int lenght) {
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
@@ skipping 269 matching lines @@
   }
 
   test_perform_noErrors() {
     _performScanTask('class A {}');
     expect(outputs, hasLength(3));
     expect(outputs[LINE_INFO], isNotNull);
     expect(outputs[SCAN_ERRORS], hasLength(0));
     expect(outputs[TOKEN_STREAM], isNotNull);
   }
 
-  test_perform_useMemento() {
-    AnalysisTarget target = newSource('/test.dart', 'main() {}');
-    _computeResult(target, TOKEN_STREAM);
-    // update content
-    context.setContents(target, 'main() {}');
-    assertIsInvalid(target, TOKEN_STREAM);
-    // recompute
-    _computeResult(target, TOKEN_STREAM);
-    assertIsValid(target, TOKEN_STREAM);
-    // values from the memento are returned
-    assertSameResults(ScanDartTask.DESCRIPTOR.results);
-  }
-
   void _performScanTask(String content) {
     AnalysisTarget target = newSource('/test.dart', content);
     _computeResult(target, TOKEN_STREAM);
     expect(task, new isInstanceOf<ScanDartTask>());
   }
 }
 
 @reflectiveTest
 class VerifyUnitTaskTest extends _AbstractDartTaskTest {
   test_perform_verifyError() {
@@ skipping 55 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }