Observatory: Lexicaly sort all kinds of lists (imports, libraries, classes, functions, fields).

runtime/bin/vmservice/client/lib/src/service/object.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.
 
 part of service;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
+  static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
+    return o1.name.compareTo(o2.name);
+  }
+
+  List removeDuplicatesAndSortLexical(List<ServiceObject> list) {
+    return list.toSet().toList()..sort(LexicalSortName);
+  }
+
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
   /// [VM], or null.
   @reflectable ServiceObjectOwner get owner => _owner;
   ServiceObjectOwner _owner;
 
   /// The [VM] which owns this [ServiceObject].
   @reflectable VM get vm => _owner.vm;
 
   /// The [Isolate] which owns this [ServiceObject].  May be null.
   @reflectable Isolate get isolate => _owner.isolate;
@@ skipping 794 matching lines @@
         }
       }
     }
     // Isolate status
     pauseEvent = map['pauseEvent'];
     running = (!_isPaused && map['topFrame'] != null);
     idle = (!_isPaused && map['topFrame'] == null);
     error = map['error'];
 
     libraries.clear();
-    for (var lib in map['libraries']) {
-      libraries.add(lib);
-    }
-    libraries.sort((a,b) => a.name.compareTo(b.name));
+    libraries.addAll(map['libraries']);
+    libraries.sort(ServiceObject.LexicalSortName);
   }
 
   Future<TagProfile> updateTagProfile() {
     return vm.getAsMap(relativeLink('profile/tag')).then((ObservableMap m) {
       var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
       tagProfile._processTagProfile(seconds, m);
       return tagProfile;
     });
   }
 
@@ skipping 210 matching lines @@
     if (name.isEmpty) {
       name = shortUrl;
     }
     vmName = map['name'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     _upgradeCollection(map, isolate);
     imports.clear();
-    imports.addAll(map['imports']);
+    imports.addAll(removeDuplicatesAndSortLexical(map['imports']));
     scripts.clear();
-    scripts.addAll(map['scripts']);
+    scripts.addAll(removeDuplicatesAndSortLexical(map['scripts']));
     classes.clear();
     classes.addAll(map['classes']);
+    classes.sort(ServiceObject.LexicalSortName);
     variables.clear();
     variables.addAll(map['variables']);
+    variables.sort(ServiceObject.LexicalSortName);
     functions.clear();
     functions.addAll(map['functions']);
+    functions.sort(ServiceObject.LexicalSortName);
   }
 }
 
 class AllocationCount extends Observable {
   @observable int instances = 0;
   @observable int bytes = 0;
 
   void reset() {
     instances = 0;
     bytes = 0;
@@ skipping 87 matching lines @@
     isAbstract = map['abstract'];
     isConst = map['const'];
     isFinalized = map['finalized'];
     isPatch = map['patch'];
     isImplemented = map['implemented'];
 
     tokenPos = map['tokenPos'];
 
     subClasses.clear();
     subClasses.addAll(map['subclasses']);
+    subClasses.sort(ServiceObject.LexicalSortName);
 
     fields.clear();
     fields.addAll(map['fields']);
+    fields.sort(ServiceObject.LexicalSortName);
 
     functions.clear();
     functions.addAll(map['functions']);
+    functions.sort(ServiceObject.LexicalSortName);
 
     superClass = map['super'];
     if (superClass != null) {
       superClass._addToChildren(this);
     }
     error = map['error'];
 
     var allocationStats = map['allocationStats'];
     if (allocationStats != null) {
       newSpace.update(allocationStats['new']);
@@ skipping 712 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }