Test that IncrementalCompilationUnitElementBuilder keeps elements in the same order as nodes.

pkg/analyzer/test/src/task/incremental_element_builder_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 analyzer.test.src.task.incremental_element_builder_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
@@ skipping 79 matching lines @@
 ''');
     helper.initNew(newUnit, unitDelta);
     // nodes
     ClassMember newConstructorNode = helper.newMembers[0];
     // elements
     ConstructorElement newConstructorElement = newConstructorNode.element;
     expect(newConstructorElement, isNotNull);
     expect(newConstructorElement.name, 'a');
     // classElement.constructors
     ClassElement classElement = helper.element;
-    expect(classElement.constructors, unorderedEquals([newConstructorElement]));
+    expect(classElement.constructors, [newConstructorElement]);
     // verify delta
     expect(helper.delta.hasUnnamedConstructorChange, isTrue);
     expect(helper.delta.addedConstructors,
         unorderedEquals([newConstructorElement]));
     expect(helper.delta.removedConstructors,
         unorderedEquals([oldConstructorElement]));
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
@@ skipping 113 matching lines @@
     expect(nodeA, same(helper.oldMembers[0]));
     // elements
     ConstructorElement elementA = nodeA.element;
     ConstructorElement elementB = nodeB.element;
     expect(elementA, isNotNull);
     expect(elementB, isNotNull);
     expect(elementA.name, 'a');
     expect(elementB.name, 'b');
     // classElement.constructors
     ClassElement classElement = helper.element;
-    expect(classElement.constructors, unorderedEquals([elementA, elementB]));
+    expect(classElement.constructors, [elementA, elementB]);
     // verify delta
     expect(helper.delta.addedConstructors, unorderedEquals([elementB]));
     expect(helper.delta.removedConstructors, unorderedEquals([]));
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
 
   test_classDelta_constructor_2to1() {
@@ skipping 15 matching lines @@
     expect(helper.delta.hasUnnamedConstructorChange, isFalse);
     // nodes
     ClassMember nodeB = helper.newMembers[0];
     expect(nodeB, same(helper.oldMembers[1]));
     // elements
     ConstructorElement elementB = nodeB.element;
     expect(elementB, isNotNull);
     expect(elementB.name, 'b');
     // classElement.constructors
     ClassElement classElement = helper.element;
-    expect(classElement.constructors, unorderedEquals([elementB]));
+    expect(classElement.constructors, [elementB]);
     // verify delta
     expect(helper.delta.addedConstructors, unorderedEquals([]));
     expect(helper.delta.removedConstructors, unorderedEquals([oldElementA]));
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
 
   test_classDelta_constructor_2to2_reorder() {
@@ skipping 19 matching lines @@
     expect(nodeA, same(helper.oldMembers[0]));
     // elements
     ConstructorElement elementB = nodeB.element;
     ConstructorElement elementA = nodeA.element;
     expect(elementB, isNotNull);
     expect(elementA, isNotNull);
     expect(elementB.name, 'b');
     expect(elementA.name, 'a');
     // classElement.constructors
     ClassElement classElement = helper.element;
-    expect(classElement.constructors, unorderedEquals([elementB, elementA]));
+    expect(classElement.constructors, [elementB, elementA]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
 
   test_classDelta_constructor_fieldReference_initializer() {
@@ skipping 135 matching lines @@
     _buildNewUnit(r'''
 class A {
   int aaa;
   int bbb;
 }
 ''');
     helper.initNew(newUnit, unitDelta);
     // nodes
     FieldDeclaration nodeA = helper.newMembers[0];
     FieldDeclaration newNodeB = helper.newMembers[1];
+    List<VariableDeclaration> fieldsA = nodeA.fields.variables;
     List<VariableDeclaration> newFieldsB = newNodeB.fields.variables;
     expect(nodeA, same(helper.oldMembers[0]));
     expect(newFieldsB, hasLength(1));
     // elements
+    FieldElement fieldElementA = fieldsA[0].name.staticElement;
     FieldElement newFieldElementB = newFieldsB[0].name.staticElement;
     expect(newFieldElementB.name, 'bbb');
+    // members
+    ClassElement classElement = helper.element;
+    expect(classElement.fields, [fieldElementA, newFieldElementB]);
     // verify delta
     expect(helper.delta.hasAnnotationChanges, isFalse);
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors,
         unorderedEquals([newFieldElementB.getter, newFieldElementB.setter]));
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
@@ skipping 52 matching lines @@
     helper.initNew(newUnit, unitDelta);
     // nodes
     FieldDeclaration newFieldDeclNode = helper.newMembers[0];
     VariableDeclaration newFieldNode = newFieldDeclNode.fields.variables.single;
     MethodDeclaration getterNode = helper.newMembers[1];
     expect(getterNode, same(helper.oldMembers[1]));
     // elements
     FieldElement newFieldElement = newFieldNode.name.staticElement;
     PropertyAccessorElement getterElement = getterNode.element;
     expect(newFieldElement.name, '_foo');
-    expect(
-        helper.element.fields,
-        unorderedMatches(
-            [same(newFieldElement), same(getterElement.variable)]));
-    expect(
-        helper.element.accessors,
-        unorderedMatches([
-          same(newFieldElement.getter),
-          same(newFieldElement.setter),
-          same(getterElement)
-        ]));
+    expect(helper.element.fields,
+        [same(newFieldElement), same(getterElement.variable)]);
+    expect(helper.element.accessors, [
+      same(newFieldElement.getter),
+      same(newFieldElement.setter),
+      same(getterElement)
+    ]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors,
         unorderedEquals([newFieldElement.getter, newFieldElement.setter]));
     expect(helper.delta.removedAccessors,
         [oldFieldElement.getter, oldFieldElement.setter]);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
@@ skipping 17 matching lines @@
     MethodDeclaration nodeA = helper.oldMembers[0];
     MethodDeclaration newNodeB = helper.newMembers[1];
     expect(nodeA, same(helper.oldMembers[0]));
     // elements
     PropertyAccessorElement elementA = nodeA.element;
     PropertyAccessorElement newElementB = newNodeB.element;
     expect(elementA, isNotNull);
     expect(elementA.name, 'aaa');
     expect(newElementB, isNotNull);
     expect(newElementB.name, 'bbb');
+    expect(helper.element.accessors, [elementA, newElementB]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, unorderedEquals([newElementB]));
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
 
   test_classDelta_getter_remove() {
@@ skipping 48 matching lines @@
     ClassMember nodeA = helper.oldMembers[0];
     ClassMember newNodeB = helper.newMembers[1];
     expect(nodeA, same(helper.oldMembers[0]));
     // elements
     MethodElement elementA = nodeA.element;
     MethodElement newElementB = newNodeB.element;
     expect(elementA, isNotNull);
     expect(elementA.name, 'aaa');
     expect(newElementB, isNotNull);
     expect(newElementB.name, 'bbb');
+    expect(helper.element.methods, [elementA, newElementB]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, unorderedEquals([newElementB]));
     expect(helper.delta.removedMethods, isEmpty);
   }
 
   test_classDelta_method_addParameter() {
@@ skipping 21 matching lines @@
     // elements
     MethodElement oldElementA = oldNodeA.element;
     MethodElement newElementA = newNodeA.element;
     MethodElement elementB = nodeB.element;
     expect(newElementA, isNotNull);
     expect(newElementA.name, 'aaa');
     expect(oldElementA.parameters, hasLength(0));
     expect(newElementA.parameters, hasLength(1));
     expect(elementB, isNotNull);
     expect(elementB.name, 'bbb');
+    expect(helper.element.methods, [newElementA, elementB]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, unorderedEquals([newElementA]));
     expect(helper.delta.removedMethods, unorderedEquals([oldElementA]));
   }
 
   test_classDelta_method_changeName() {
@@ skipping 32 matching lines @@
     ClassMember nodeB = helper.newMembers[1];
     expect(nodeB, same(helper.oldMembers[1]));
     // elements
     MethodElement oldElementA = oldNodeA.element;
     MethodElement newElementA = newNodeA.element;
     MethodElement elementB = nodeB.element;
     expect(newElementA, isNotNull);
     expect(newElementA.name, 'aaa2');
     expect(elementB, isNotNull);
     expect(elementB.name, 'bbb');
+    expect(helper.element.methods, [newElementA, elementB]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, unorderedEquals([newElementA]));
     expect(helper.delta.removedMethods, unorderedEquals([oldElementA]));
   }
 
   test_classDelta_method_remove() {
@@ skipping 54 matching lines @@
     // elements
     MethodElement oldElementA = oldNodeA.element;
     MethodElement newElementA = newNodeA.element;
     MethodElement elementB = nodeB.element;
     expect(newElementA, isNotNull);
     expect(newElementA.name, 'aaa');
     expect(oldElementA.parameters, hasLength(1));
     expect(newElementA.parameters, hasLength(0));
     expect(elementB, isNotNull);
     expect(elementB.name, 'bbb');
+    expect(helper.element.methods, [newElementA, elementB]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, unorderedEquals([newElementA]));
     expect(helper.delta.removedMethods, unorderedEquals([oldElementA]));
   }
 
+  test_classDelta_newOrder() {
+    var helper = new _ClassDeltaHelper('A');
+    _buildOldUnit(r'''
+class A {
+  bbb() {}
+}
+''');
+    helper.initOld(oldUnit);
+    _buildNewUnit(r'''
+class A {
+  aaa() {}
+  bbb() {}
+  ccc() {}
+}
+''');
+    helper.initNew(newUnit, unitDelta);
+    // nodes
+    ClassMember newNodeA = helper.newMembers[0];
+    ClassMember nodeB = helper.oldMembers[0];
+    ClassMember newNodeC = helper.newMembers[2];
+    expect(nodeB, same(helper.oldMembers[0]));
+    // elements
+    MethodElement newElementA = newNodeA.element;
+    MethodElement elementB = nodeB.element;
+    MethodElement newElementC = newNodeC.element;
+    expect(newElementA, isNotNull);
+    expect(newElementA.name, 'aaa');
+    expect(elementB, isNotNull);
+    expect(elementB.name, 'bbb');
+    expect(newElementC, isNotNull);
+    expect(newElementC.name, 'ccc');
+    expect(helper.element.methods, [newElementA, elementB, newElementC]);
+    // verify delta
+    expect(helper.delta.addedConstructors, isEmpty);
+    expect(helper.delta.removedConstructors, isEmpty);
+    expect(helper.delta.addedAccessors, isEmpty);
+    expect(helper.delta.removedAccessors, isEmpty);
+    expect(
+        helper.delta.addedMethods, unorderedEquals([newElementA, newElementC]));
+    expect(helper.delta.removedMethods, isEmpty);
+  }
+
   test_classDelta_null_abstractKeyword_add() {
     _verifyNoClassDeltaForTheLast(
         r'''
 class A {}
 ''',
         r'''
 abstract class A {}
 ''');
   }
 
@@ skipping 174 matching lines @@
     MethodDeclaration nodeA = helper.oldMembers[0];
     MethodDeclaration newNodeB = helper.newMembers[1];
     expect(nodeA, same(helper.oldMembers[0]));
     // elements
     PropertyAccessorElement elementA = nodeA.element;
     PropertyAccessorElement newElementB = newNodeB.element;
     expect(elementA, isNotNull);
     expect(elementA.name, 'aaa=');
     expect(newElementB, isNotNull);
     expect(newElementB.name, 'bbb=');
+    expect(helper.element.accessors, [elementA, newElementB]);
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, unorderedEquals([newElementB]));
     expect(helper.delta.removedAccessors, isEmpty);
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
 
   test_classDelta_setter_remove() {
@@ skipping 327 matching lines @@
     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]));
+    expect(
+        unitElement.topLevelVariables, [elementA.variable, elementB.variable]);
+    expect(unitElement.accessors, [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]));
+    expect(unitElement.types, [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.
@@ skipping 90 matching lines @@
     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]));
+    expect(unitElement.types, [elementA]);
     // verify delta
     expect(unitDelta.addedDeclarations, unorderedEquals([]));
     expect(unitDelta.removedDeclarations, unorderedEquals([elementB]));
   }
 
   test_unitMembers_class_reorder() {
     _buildOldUnit(r'''
 class A {}
 class B {}
 class C {}
@@ skipping 60 matching lines @@
     expect(elementB.name, 'B');
     expect(elementA.fields.map((f) => f.name),
         unorderedEquals(['index', 'values', 'A1', 'A2']));
     expect(elementA.accessors.map((a) => a.name),
         unorderedEquals(['index', 'values', 'A1', 'A2']));
     expect(elementB.fields.map((f) => f.name),
         unorderedEquals(['index', 'values', 'B1', 'B2']));
     expect(elementB.accessors.map((a) => a.name),
         unorderedEquals(['index', 'values', 'B1', 'B2']));
     // unit.types
-    expect(unitElement.enums, unorderedEquals([elementA, elementB]));
+    expect(unitElement.enums, [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]));
+    expect(unitElement.functions, [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]));
+    expect(unitElement.functionTypeAliases, [elementA, elementB]);
     // verify delta
     expect(unitDelta.addedDeclarations, unorderedEquals([elementB]));
     expect(unitDelta.removedDeclarations, unorderedEquals([]));
   }
 
+  test_unitMembers_newOrder() {
+    _buildOldUnit(r'''
+int b;
+''');
+    List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
+    _buildNewUnit(r'''
+int a;
+int b;
+int c;
+''');
+    List<CompilationUnitMember> newNodes = newUnit.declarations;
+    // nodes
+    TopLevelVariableDeclaration node1 = newNodes[0];
+    TopLevelVariableDeclaration node2 = newNodes[1];
+    TopLevelVariableDeclaration node3 = newNodes[2];
+    expect(node2, same(oldNodes[0]));
+    // elements
+    TopLevelVariableElement elementA = node1.variables.variables[0].element;
+    TopLevelVariableElement elementB = node2.variables.variables[0].element;
+    TopLevelVariableElement elementC = node3.variables.variables[0].element;
+    expect(elementA, isNotNull);
+    expect(elementB, isNotNull);
+    expect(elementC, isNotNull);
+    expect(elementA.name, 'a');
+    expect(elementB.name, 'b');
+    expect(elementC.name, 'c');
+    // unit.types
+    expect(unitElement.topLevelVariables, [elementA, elementB, elementC]);
+    expect(unitElement.accessors, [
+      elementA.getter,
+      elementA.setter,
+      elementB.getter,
+      elementB.setter,
+      elementC.getter,
+      elementC.setter,
+    ]);
+  }
+
   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;
@@ skipping 57 matching lines @@
     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
-        ]));
+        [elementA, elementB, elementC, elementD]);
+    expect(unitElement.accessors, [
+      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;
 ''');
@@ skipping 460 matching lines @@
           unitMember is ClassDeclaration && unitMember.name.name == name);
 }
 
 class _MaterializeLazyElementsVisitor extends GeneralizingElementVisitor {
   @override
   visitExecutableElement(ExecutableElement element) {
     element.parameters;
     super.visitExecutableElement(element);
   }
 }