Avoid writing to the same parts of the element model in two tasks.

pkg/analyzer/test/src/context/context_test.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.
 
 library analyzer.test.src.context.context_test;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1145 matching lines @@
       }
       return false;
     });
     // Update the file, but don't notify the context.
     resourceProvider.updateFile(path, newCode);
     // Driver must detect that the file was changed and recover.
     CompilationUnit unit = context.resolveCompilationUnit2(source, source);
     expect(unit, isNotNull);
   }
 
+  void test_flushSingleResolvedUnit_instanceField() {
+    _checkFlushSingleResolvedUnit('class C { var x = 0; }',
+        (CompilationUnitElement unitElement, String reason) {
+      expect(unitElement.types, hasLength(1), reason: reason);
+      ClassElement cls = unitElement.types[0];
+      expect(cls.fields, hasLength(1), reason: reason);
+      expect(cls.fields[0].type.toString(), 'int', reason: reason);
+      expect(cls.accessors, hasLength(2), reason: reason);
+      expect(cls.accessors[0].isGetter, isTrue, reason: reason);
+      expect(cls.accessors[0].returnType.toString(), 'int', reason: reason);
+      expect(cls.accessors[1].isSetter, isTrue, reason: reason);
+      expect(cls.accessors[1].returnType.toString(), 'void', reason: reason);
+      expect(cls.accessors[1].parameters, hasLength(1), reason: reason);
+      expect(cls.accessors[1].parameters[0].type.toString(), 'int',
+          reason: reason);
+    });
+  }
+
+  void test_flushSingleResolvedUnit_instanceGetter() {
+    _checkFlushSingleResolvedUnit(
+        '''
+abstract class B {
+  int get x;
+}
+class C extends B {
+  get x => null;
+}
+''', (CompilationUnitElement unitElement, String reason) {
+      expect(unitElement.types, hasLength(2), reason: reason);
+      ClassElement cls = unitElement.types[1];
+      expect(cls.name, 'C', reason: reason);
+      expect(cls.accessors, hasLength(1), reason: reason);
+      expect(cls.accessors[0].returnType.toString(), 'int', reason: reason);
+      expect(cls.fields, hasLength(1), reason: reason);
+      expect(cls.fields[0].type.toString(), 'int', reason: reason);
+    });
+  }
+
+  void test_flushSingleResolvedUnit_instanceMethod() {
+    _checkFlushSingleResolvedUnit(
+        '''
+abstract class B {
+  int f(String s);
+}
+class C extends B {
+  f(s) => null;
+}
+''', (CompilationUnitElement unitElement, String reason) {
+      expect(unitElement.types, hasLength(2), reason: reason);
+      ClassElement cls = unitElement.types[1];
+      expect(cls.name, 'C', reason: reason);
+      expect(cls.methods, hasLength(1), reason: reason);
+      expect(cls.methods[0].returnType.toString(), 'int', reason: reason);
+      expect(cls.methods[0].parameters, hasLength(1), reason: reason);
+      expect(cls.methods[0].parameters[0].type.toString(), 'String',
+          reason: reason);
+    });
+  }
+
+  void test_flushSingleResolvedUnit_instanceSetter() {
+    _checkFlushSingleResolvedUnit(
+        '''
+abstract class B {
+  set x(int value);
+}
+class C extends B {
+  set x(value) {}
+}
+''', (CompilationUnitElement unitElement, String reason) {
+      expect(unitElement.types, hasLength(2), reason: reason);
+      ClassElement cls = unitElement.types[1];
+      expect(cls.name, 'C', reason: reason);
+      expect(cls.accessors, hasLength(1), reason: reason);
+      expect(cls.accessors[0].returnType.toString(), 'void', reason: reason);
+      expect(cls.accessors[0].parameters, hasLength(1), reason: reason);
+      expect(cls.accessors[0].parameters[0].type.toString(), 'int',
+          reason: reason);
+      expect(cls.fields, hasLength(1), reason: reason);
+      expect(cls.fields[0].type.toString(), 'int', reason: reason);
+    });
+  }
+
+  void test_flushSingleResolvedUnit_staticField() {
+    _checkFlushSingleResolvedUnit('class C { static var x = 0; }',
+        (CompilationUnitElement unitElement, String reason) {
+      expect(unitElement.types, hasLength(1), reason: reason);
+      ClassElement cls = unitElement.types[0];
+      expect(cls.fields, hasLength(1), reason: reason);
+      expect(cls.fields[0].type.toString(), 'int', reason: reason);
+      expect(cls.accessors, hasLength(2), reason: reason);
+      expect(cls.accessors[0].isGetter, isTrue, reason: reason);
+      expect(cls.accessors[0].returnType.toString(), 'int', reason: reason);
+      expect(cls.accessors[1].isSetter, isTrue, reason: reason);
+      expect(cls.accessors[1].returnType.toString(), 'void', reason: reason);
+      expect(cls.accessors[1].parameters, hasLength(1), reason: reason);
+      expect(cls.accessors[1].parameters[0].type.toString(), 'int',
+          reason: reason);
+    });
+  }
+
+  void test_flushSingleResolvedUnit_topLevelVariable() {
+    _checkFlushSingleResolvedUnit('var x = 0;',
+        (CompilationUnitElement unitElement, String reason) {
+      expect(unitElement.topLevelVariables, hasLength(1), reason: reason);
+      expect(unitElement.topLevelVariables[0].type.toString(), 'int',
+          reason: reason);
+      expect(unitElement.accessors, hasLength(2), reason: reason);
+      expect(unitElement.accessors[0].isGetter, isTrue, reason: reason);
+      expect(unitElement.accessors[0].returnType.toString(), 'int',
+          reason: reason);
+      expect(unitElement.accessors[1].isSetter, isTrue, reason: reason);
+      expect(unitElement.accessors[1].returnType.toString(), 'void',
+          reason: reason);
+      expect(unitElement.accessors[1].parameters, hasLength(1), reason: reason);
+      expect(unitElement.accessors[1].parameters[0].type.toString(), 'int',
+          reason: reason);
+    });
+  }
+
   void test_getAnalysisOptions() {
     expect(context.analysisOptions, isNotNull);
   }
 
   void test_getContents_fromSource() {
     String content = "library lib;";
     TimestampedData<String> contents =
         context.getContents(new TestSource('/test.dart', content));
     expect(contents.data.toString(), content);
   }
@@ skipping 1346 matching lines @@
         addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}");
     addSource("/libB.dart", "library libB; import 'libA.dart'; class B{}");
     CompilationUnit compilationUnit =
         context.resolveCompilationUnit2(sourceA, sourceA);
     expect(compilationUnit, isNotNull);
     LibraryElement library = compilationUnit.element.library;
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "libB"]);
   }
 
+  void test_resolveCompilationUnit_library() {
+    Source source = addSource("/lib.dart", "library lib;");
+    LibraryElement library = context.computeLibraryElement(source);
+    CompilationUnit compilationUnit =
+        context.resolveCompilationUnit(source, library);
+    expect(compilationUnit, isNotNull);
+    expect(compilationUnit.element, isNotNull);
+  }
+
 //  void test_resolveCompilationUnit_sourceChangeDuringResolution() {
 //    _context = new _AnalysisContext_sourceChangeDuringResolution();
 //    AnalysisContextFactory.initContextWithCore(_context);
 //    _sourceFactory = _context.sourceFactory;
 //    Source source = _addSource("/lib.dart", "library lib;");
 //    CompilationUnit compilationUnit =
 //        _context.resolveCompilationUnit2(source, source);
 //    expect(compilationUnit, isNotNull);
 //    expect(_context.getLineInfo(source), isNotNull);
 //  }
 
-  void test_resolveCompilationUnit_library() {
-    Source source = addSource("/lib.dart", "library lib;");
-    LibraryElement library = context.computeLibraryElement(source);
-    CompilationUnit compilationUnit =
-        context.resolveCompilationUnit(source, library);
-    expect(compilationUnit, isNotNull);
-    expect(compilationUnit.element, isNotNull);
-  }
-
   void test_resolveCompilationUnit_source() {
     Source source = addSource("/lib.dart", "library lib;");
     CompilationUnit compilationUnit =
         context.resolveCompilationUnit2(source, source);
     expect(compilationUnit, isNotNull);
   }
 
   void test_setAnalysisOptions() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.dart2jsHint = false;
@@ skipping 260 matching lines @@
     }
   }
 
   void _changeSource(TestSource source, String contents) {
     source.setContents(contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
     context.applyChanges(changeSet);
   }
 
+  void _checkFlushSingleResolvedUnit(String code,
+      void validate(CompilationUnitElement unitElement, String reason)) {
+    prepareAnalysisContext(new AnalysisOptionsImpl()..strongMode = true);
+    String path = resourceProvider.convertPath('/test.dart');
+    Source source = resourceProvider.newFile(path, code).createSource();
+    context.applyChanges(new ChangeSet()..addedSource(source));
+    CompilationUnitElement unitElement =
+        context.resolveCompilationUnit2(source, source).element;
+    validate(unitElement, 'initial state');
+    for (ResultDescriptor<CompilationUnit> descriptor
+        in RESOLVED_UNIT_RESULTS) {
+      context.analysisCache.flush(
+          (target, result) => target.source == source && result == descriptor);
+      context.computeResult(
+          new LibrarySpecificUnit(source, source), descriptor);
+      validate(unitElement, 'after flushing $descriptor');
+    }
+  }
+
   /**
    * Search the given compilation unit for a class with the given name. Return the class with the
    * given name, or `null` if the class cannot be found.
    *
    * @param unit the compilation unit being searched
    * @param className the name of the class being searched for
    * @return the class with the given name
    */
   ClassElement _findClass(CompilationUnitElement unit, String className) {
     for (ClassElement classElement in unit.types) {
@@ skipping 2451 matching lines @@
    * Initialize the visitor.
    */
   _ElementGatherer();
 
   @override
   void visitElement(Element element) {
     elements[element] = element;
     super.visitElement(element);
   }
 }