Roll Observatory packages and add a roll script

packages/analyzer/test/src/task/incremental_element_builder_test.dart

Index: packages/analyzer/test/src/task/incremental_element_builder_test.dart
diff --git a/packages/analyzer/test/src/task/incremental_element_builder_test.dart b/packages/analyzer/test/src/task/incremental_element_builder_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..b495be76e68c596d8753407e46f7a7e2ae36d922
--- /dev/null
+++ b/packages/analyzer/test/src/task/incremental_element_builder_test.dart
@@ -0,0 +1,694 @@
+// 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.incremental_element_builder_test;
+
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/task/incremental_element_builder.dart';
+import 'package:unittest/unittest.dart';
+
+import '../../reflective_tests.dart';
+import '../../utils.dart';
+import '../context/abstract_context.dart';
+
+main() {
+  initializeTestEnvironment();
+  runReflectiveTests(IncrementalCompilationUnitElementBuilderTest);
+}
+
+@reflectiveTest
+class IncrementalCompilationUnitElementBuilderTest extends AbstractContextTest {
+  Source source;
+
+  String oldCode;
+  CompilationUnit oldUnit;
+  CompilationUnitElement unitElement;
+
+  String newCode;
+  CompilationUnit newUnit;
+
+  CompilationUnitElementDelta unitDelta;
+
+  String getNodeText(AstNode node) {
+    return newCode.substring(node.offset, node.end);
+  }
+
+  test_directives_add() {
+    _buildOldUnit(r'''
+library test;
+import 'dart:math';
+''');
+    List<Directive> oldDirectives = oldUnit.directives.toList();
+    _buildNewUnit(r'''
+library test;
+import 'dart:async';
+import 'dart:math';
+''');
+    List<Directive> newDirectives = newUnit.directives;
+    {
+      Directive newNode = newDirectives[0];
+      expect(newNode, same(oldDirectives[0]));
+      expect(getNodeText(newNode), "library test;");
+      LibraryElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf('test;'));
+    }
+    {
+      Directive newNode = newDirectives[1];
+      expect(getNodeText(newNode), "import 'dart:async';");
+      ImportElement element = newNode.element;
+      expect(element, isNull);
+    }
+    {
+      Directive newNode = newDirectives[2];
+      expect(newNode, same(oldDirectives[1]));
+      expect(getNodeText(newNode), "import 'dart:math';");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:math';"));
+    }
+    expect(unitDelta.hasDirectiveChange, isTrue);
+  }
+
+  test_directives_keepOffset_partOf() {
+    String libCode = '''
+// comment to shift tokens
+library my_lib;
+part 'test.dart';
+''';
+    Source libSource = newSource('/lib.dart', libCode);
+    _buildOldUnit(
+        r'''
+part of my_lib;
+class A {}
+''',
+        libSource);
+    List<Directive> oldDirectives = oldUnit.directives.toList();
+    _buildNewUnit(r'''
+part of my_lib;
+class A {}
+''');
+    List<Directive> newDirectives = newUnit.directives;
+    {
+      Directive newNode = newDirectives[0];
+      expect(newNode, same(oldDirectives[0]));
+      expect(getNodeText(newNode), 'part of my_lib;');
+      LibraryElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, libCode.indexOf('my_lib;'));
+    }
+  }
+
+  test_directives_remove() {
+    _buildOldUnit(r'''
+library test;
+import 'dart:async';
+import 'dart:math';
+''');
+    List<Directive> oldDirectives = oldUnit.directives.toList();
+    _buildNewUnit(r'''
+library test;
+import 'dart:math';
+''');
+    List<Directive> newDirectives = newUnit.directives;
+    {
+      Directive newNode = newDirectives[0];
+      expect(newNode, same(oldDirectives[0]));
+      expect(getNodeText(newNode), "library test;");
+      LibraryElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf('test;'));
+    }
+    {
+      Directive newNode = newDirectives[1];
+      expect(newNode, same(oldDirectives[2]));
+      expect(getNodeText(newNode), "import 'dart:math';");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:math';"));
+    }
+    expect(unitDelta.hasDirectiveChange, isTrue);
+  }
+
+  test_directives_reorder() {
+    _buildOldUnit(r'''
+library test;
+import  'dart:math' as m;
+import 'dart:async';
+''');
+    List<Directive> oldDirectives = oldUnit.directives.toList();
+    _buildNewUnit(r'''
+library test;
+import 'dart:async';
+import 'dart:math' as m;
+''');
+    List<Directive> newDirectives = newUnit.directives;
+    {
+      Directive newNode = newDirectives[0];
+      expect(newNode, same(oldDirectives[0]));
+      expect(getNodeText(newNode), "library test;");
+      LibraryElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf('test;'));
+    }
+    {
+      Directive newNode = newDirectives[1];
+      expect(newNode, same(oldDirectives[2]));
+      expect(getNodeText(newNode), "import 'dart:async';");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:async';"));
+    }
+    {
+      Directive newNode = newDirectives[2];
+      expect(newNode, same(oldDirectives[1]));
+      expect(getNodeText(newNode), "import 'dart:math' as m;");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:math' as m;"));
+      expect(element.prefix.nameOffset, newCode.indexOf("m;"));
+    }
+    expect(unitDelta.hasDirectiveChange, isFalse);
+  }
+
+  test_directives_sameOrder_insertSpaces() {
+    _buildOldUnit(r'''
+library test;
+import 'dart:async';
+import 'dart:math';
+''');
+    List<Directive> oldDirectives = oldUnit.directives.toList();
+    _buildNewUnit(r'''
+library test;
+
+import 'dart:async' ;
+import  'dart:math';
+''');
+    List<Directive> newDirectives = newUnit.directives;
+    {
+      Directive newNode = newDirectives[0];
+      expect(newNode, same(oldDirectives[0]));
+      expect(getNodeText(newNode), "library test;");
+      LibraryElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf('test;'));
+    }
+    {
+      Directive newNode = newDirectives[1];
+      expect(newNode, same(oldDirectives[1]));
+      expect(getNodeText(newNode), "import 'dart:async' ;");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:async' ;"));
+    }
+    {
+      Directive newNode = newDirectives[2];
+      expect(newNode, same(oldDirectives[2]));
+      expect(getNodeText(newNode), "import  'dart:math';");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import  'dart:math';"));
+    }
+    expect(unitDelta.hasDirectiveChange, isFalse);
+  }
+
+  test_directives_sameOrder_removeSpaces() {
+    _buildOldUnit(r'''
+library test;
+
+import 'dart:async' ;
+import  'dart:math';
+''');
+    List<Directive> oldDirectives = oldUnit.directives.toList();
+    _buildNewUnit(r'''
+library test;
+import 'dart:async';
+import 'dart:math';
+''');
+    List<Directive> newDirectives = newUnit.directives;
+    {
+      Directive newNode = newDirectives[0];
+      expect(newNode, same(oldDirectives[0]));
+      expect(getNodeText(newNode), "library test;");
+      LibraryElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf('test;'));
+    }
+    {
+      Directive newNode = newDirectives[1];
+      expect(newNode, same(oldDirectives[1]));
+      expect(getNodeText(newNode), "import 'dart:async';");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:async';"));
+    }
+    {
+      Directive newNode = newDirectives[2];
+      expect(newNode, same(oldDirectives[2]));
+      expect(getNodeText(newNode), "import 'dart:math';");
+      ImportElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.nameOffset, newCode.indexOf("import 'dart:math';"));
+    }
+    expect(unitDelta.hasDirectiveChange, isFalse);
+  }
+
+  test_unitMembers_accessor_add() {
+    _buildOldUnit(r'''
+get a => 1;
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+get a => 1;
+get b => 2;
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    FunctionDeclaration node1 = newNodes[0];
+    FunctionDeclaration node2 = newNodes[1];
+    expect(node1, same(oldNodes[0]));
+    // elements
+    PropertyAccessorElement elementA = node1.element;
+    PropertyAccessorElement elementB = node2.element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementA.name, 'a');
+    expect(elementB.name, 'b');
+    // unit.types
+    expect(unitElement.topLevelVariables,
+        unorderedEquals([elementA.variable, elementB.variable]));
+    expect(unitElement.accessors, unorderedEquals([elementA, elementB]));
+  }
+
+  test_unitMembers_class_add() {
+    _buildOldUnit(r'''
+class A {}
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+class A {}
+class B {}
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    CompilationUnitMember nodeA = newNodes[0];
+    CompilationUnitMember nodeB = newNodes[1];
+    expect(nodeA, same(oldNodes[0]));
+    // elements
+    ClassElement elementA = nodeA.element;
+    ClassElement elementB = nodeB.element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementA.name, 'A');
+    expect(elementB.name, 'B');
+    // unit.types
+    expect(unitElement.types, unorderedEquals([elementA, elementB]));
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([elementB]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_class_comments() {
+    _buildOldUnit(r'''
+/// reference [bool] type.
+class A {}
+/// reference [int] type.
+class B {}
+/// reference [double] and [B] types.
+class C {}
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+/// reference [double] and [B] types.
+class C {}
+/// reference [bool] type.
+class A {}
+/// reference [int] type.
+class B {}
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    {
+      CompilationUnitMember newNode = newNodes[0];
+      expect(newNode, same(oldNodes[2]));
+      expect(
+          getNodeText(newNode),
+          r'''
+/// reference [double] and [B] types.
+class C {}''');
+      ClassElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.name, 'C');
+      expect(element.nameOffset, newCode.indexOf('C {}'));
+      // [double] and [B] are still resolved
+      {
+        var docReferences = newNode.documentationComment.references;
+        expect(docReferences, hasLength(2));
+        expect(docReferences[0].identifier.staticElement.name, 'double');
+        expect(docReferences[1].identifier.staticElement,
+            same(newNodes[2].element));
+      }
+    }
+    {
+      CompilationUnitMember newNode = newNodes[1];
+      expect(newNode, same(oldNodes[0]));
+      expect(
+          getNodeText(newNode),
+          r'''
+/// reference [bool] type.
+class A {}''');
+      ClassElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.name, 'A');
+      expect(element.nameOffset, newCode.indexOf('A {}'));
+      // [bool] is still resolved
+      {
+        var docReferences = newNode.documentationComment.references;
+        expect(docReferences, hasLength(1));
+        expect(docReferences[0].identifier.staticElement.name, 'bool');
+      }
+    }
+    {
+      CompilationUnitMember newNode = newNodes[2];
+      expect(newNode, same(oldNodes[1]));
+      expect(
+          getNodeText(newNode),
+          r'''
+/// reference [int] type.
+class B {}''');
+      ClassElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.name, 'B');
+      expect(element.nameOffset, newCode.indexOf('B {}'));
+      // [int] is still resolved
+      {
+        var docReferences = newNode.documentationComment.references;
+        expect(docReferences, hasLength(1));
+        expect(docReferences[0].identifier.staticElement.name, 'int');
+      }
+    }
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_class_remove() {
+    _buildOldUnit(r'''
+class A {}
+class B {}
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+class A {}
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    CompilationUnitMember nodeA = newNodes[0];
+    CompilationUnitMember nodeB = oldNodes[1];
+    expect(nodeA, same(oldNodes[0]));
+    // elements
+    ClassElement elementA = nodeA.element;
+    ClassElement elementB = nodeB.element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementA.name, 'A');
+    expect(elementB.name, 'B');
+    // unit.types
+    expect(unitElement.types, unorderedEquals([elementA]));
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([elementB]));
+  }
+
+  test_unitMembers_class_reorder() {
+    _buildOldUnit(r'''
+class A {}
+class B {}
+class C {}
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+class C {}
+class A {}
+class B {}
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    {
+      CompilationUnitMember newNode = newNodes[0];
+      expect(newNode, same(oldNodes[2]));
+      expect(getNodeText(newNode), 'class C {}');
+      ClassElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.name, 'C');
+      expect(element.nameOffset, newCode.indexOf('C {}'));
+    }
+    {
+      CompilationUnitMember newNode = newNodes[1];
+      expect(newNode, same(oldNodes[0]));
+      expect(getNodeText(newNode), 'class A {}');
+      ClassElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.name, 'A');
+      expect(element.nameOffset, newCode.indexOf('A {}'));
+    }
+    {
+      CompilationUnitMember newNode = newNodes[2];
+      expect(newNode, same(oldNodes[1]));
+      expect(getNodeText(newNode), 'class B {}');
+      ClassElement element = newNode.element;
+      expect(element, isNotNull);
+      expect(element.name, 'B');
+      expect(element.nameOffset, newCode.indexOf('B {}'));
+    }
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_enum_add() {
+    _buildOldUnit(r'''
+enum A {A1, A2}
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+enum A {A1, A2}
+enum B {B1, B2}
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    CompilationUnitMember nodeA = newNodes[0];
+    CompilationUnitMember nodeB = newNodes[1];
+    expect(nodeA, same(oldNodes[0]));
+    // elements
+    ClassElement elementA = nodeA.element;
+    ClassElement elementB = nodeB.element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementA.name, 'A');
+    expect(elementB.name, 'B');
+    // unit.types
+    expect(unitElement.enums, unorderedEquals([elementA, elementB]));
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([elementB]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_function_add() {
+    _buildOldUnit(r'''
+a() {}
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+a() {}
+b() {}
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    CompilationUnitMember nodeA = newNodes[0];
+    CompilationUnitMember nodeB = newNodes[1];
+    expect(nodeA, same(oldNodes[0]));
+    // elements
+    FunctionElement elementA = nodeA.element;
+    FunctionElement elementB = nodeB.element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementA.name, 'a');
+    expect(elementB.name, 'b');
+    // unit.types
+    expect(unitElement.functions, unorderedEquals([elementA, elementB]));
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([elementB]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_functionTypeAlias_add() {
+    _buildOldUnit(r'''
+typedef A();
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+typedef A();
+typedef B();
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    CompilationUnitMember nodeA = newNodes[0];
+    CompilationUnitMember nodeB = newNodes[1];
+    expect(nodeA, same(oldNodes[0]));
+    // elements
+    FunctionTypeAliasElement elementA = nodeA.element;
+    FunctionTypeAliasElement elementB = nodeB.element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementA.name, 'A');
+    expect(elementB.name, 'B');
+    // unit.types
+    expect(
+        unitElement.functionTypeAliases, unorderedEquals([elementA, elementB]));
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([elementB]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_topLevelVariable() {
+    _buildOldUnit(r'''
+bool a = 1, b = 2;
+int c = 3;
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+int c = 3;
+
+bool a =1, b = 2;
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    {
+      TopLevelVariableDeclaration newNode = newNodes[0];
+      expect(newNode, same(oldNodes[1]));
+      expect(getNodeText(newNode), 'int c = 3;');
+      {
+        TopLevelVariableElement element =
+            newNode.variables.variables[0].element;
+        expect(element, isNotNull);
+        expect(element.name, 'c');
+        expect(element.nameOffset, newCode.indexOf('c = 3'));
+      }
+    }
+    {
+      TopLevelVariableDeclaration newNode = newNodes[1];
+      expect(newNode, same(oldNodes[0]));
+      expect(getNodeText(newNode), 'bool a =1, b = 2;');
+      {
+        TopLevelVariableElement element =
+            newNode.variables.variables[0].element;
+        expect(element, isNotNull);
+        expect(element.name, 'a');
+        expect(element.nameOffset, newCode.indexOf('a =1'));
+      }
+      {
+        TopLevelVariableElement element =
+            newNode.variables.variables[1].element;
+        expect(element, isNotNull);
+        expect(element.name, 'b');
+        expect(element.nameOffset, newCode.indexOf('b = 2'));
+      }
+    }
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  test_unitMembers_topLevelVariable_add() {
+    _buildOldUnit(r'''
+int a, b;
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+int a, b;
+int c, d;
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    TopLevelVariableDeclaration node1 = newNodes[0];
+    TopLevelVariableDeclaration node2 = newNodes[1];
+    expect(node1, same(oldNodes[0]));
+    // elements
+    TopLevelVariableElement elementA = node1.variables.variables[0].element;
+    TopLevelVariableElement elementB = node1.variables.variables[1].element;
+    TopLevelVariableElement elementC = node2.variables.variables[0].element;
+    TopLevelVariableElement elementD = node2.variables.variables[1].element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementC, isNotNull);
+    expect(elementD, isNotNull);
+    expect(elementA.name, 'a');
+    expect(elementB.name, 'b');
+    expect(elementC.name, 'c');
+    expect(elementD.name, 'd');
+    // unit.types
+    expect(unitElement.topLevelVariables,
+        unorderedEquals([elementA, elementB, elementC, elementD]));
+    expect(
+        unitElement.accessors,
+        unorderedEquals([
+          elementA.getter,
+          elementA.setter,
+          elementB.getter,
+          elementB.setter,
+          elementC.getter,
+          elementC.setter,
+          elementD.getter,
+          elementD.setter
+        ]));
+  }
+
+  test_unitMembers_topLevelVariable_final() {
+    _buildOldUnit(r'''
+final int a = 1;
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+final int a =  1;
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    {
+      TopLevelVariableDeclaration newNode = newNodes[0];
+      expect(newNode, same(oldNodes[0]));
+      expect(getNodeText(newNode), 'final int a =  1;');
+      {
+        TopLevelVariableElement element =
+            newNode.variables.variables[0].element;
+        expect(element, isNotNull);
+        expect(element.name, 'a');
+        expect(element.nameOffset, newCode.indexOf('a =  1'));
+      }
+    }
+    // verify delta
+    expect(unitDelta.addedDeclarations, unorderedEquals([]));
+    expect(unitDelta.removedDeclarations, unorderedEquals([]));
+  }
+
+  void _buildNewUnit(String newCode) {
+    this.newCode = newCode;
+    context.setContents(source, newCode);
+    newUnit = context.parseCompilationUnit(source);
+    IncrementalCompilationUnitElementBuilder builder =
+        new IncrementalCompilationUnitElementBuilder(oldUnit, newUnit);
+    builder.build();
+    unitDelta = builder.unitDelta;
+    expect(newUnit.element, unitElement);
+  }
+
+  void _buildOldUnit(String oldCode, [Source libSource]) {
+    this.oldCode = oldCode;
+    source = newSource('/test.dart', oldCode);
+    if (libSource == null) {
+      libSource = source;
+    }
+    oldUnit = context.resolveCompilationUnit2(source, libSource);
+    unitElement = oldUnit.element;
+    expect(unitElement, isNotNull);
+  }
+}