Use ClassHierarchy.applyChanges() in MixinFullResolution.

pkg/kernel/lib/class_hierarchy.dart

 // Copyright (c) 2016, 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 kernel.class_hierarchy;
 
 import 'ast.dart';
 import 'dart:math';
 import 'dart:typed_data';
 import 'src/heap.dart';
 import 'type_algebra.dart';
@@ skipping 102 matching lines @@
   /// This method will not report that a member overrides itself. A given pair
   /// may be reported multiple times when there are multiple inheritance paths
   /// to the overridden member.
   ///
   /// It is possible for two methods to override one another in both directions.
   ///
   /// Getters and setters are overridden separately.  The [isSetter] callback
   /// parameter determines which type of access is being overridden.
   void forEachOverridePair(Class class_,
       callback(Member declaredMember, Member interfaceMember, bool isSetter));
+
+  /// This method is invoked by the client after it changed the [classes], and
+  /// some of the information that this hierarchy might have cached, is not
+  /// valid anymore. The hierarchy may perform required updates and return the
+  /// same instance, or return a new instance.
+  ClassHierarchy applyChanges(Iterable<Class> classes);
 }
 
 /// Implementation of [ClassHierarchy] for closed world.
 class ClosedWorldClassHierarchy implements ClassHierarchy {
+  /// The [Program] that this class hierarchy represents.
+  final Program _program;
+
   /// All classes in the program.
   ///
   /// The list is ordered so that classes occur after their super classes.
   final List<Class> classes;
 
   final Map<Class, _ClassInfo> _infoFor = <Class, _ClassInfo>{};
 
   ClosedWorldClassHierarchy(Program program)
       : this._internal(program, _countClasses(program));
 
@@ skipping 303 matching lines @@
   /// Returns the subtypes of [class_] as an interval list.
   ClassSet getSubtypesOf(Class class_) {
     return new ClassSet(this, _infoFor[class_].subtypeIntervalList);
   }
 
   /// Returns the subclasses of [class_] as an interval list.
   ClassSet getSubclassesOf(Class class_) {
     return new ClassSet(this, _infoFor[class_].subclassIntervalList);
   }
 
-  ClosedWorldClassHierarchy._internal(Program program, int numberOfClasses)
+  @override
+  ClassHierarchy applyChanges(Iterable<Class> classes) {
+    if (classes.isEmpty) return this;
+    return new ClosedWorldClassHierarchy(_program);
+  }
+
+  ClosedWorldClassHierarchy._internal(this._program, int numberOfClasses)
       : classes = new List<Class>(numberOfClasses) {
     // Build the class ordering based on a topological sort.
-    for (var library in program.libraries) {
+    for (var library in _program.libraries) {
       for (var classNode in library.classes) {
         _topologicalSortVisit(classNode);
       }
     }
 
     // Build index of direct children.  Do this after the topological sort so
     // that super types always occur before subtypes.
     for (int i = 0; i < classes.length; ++i) {
       var class_ = classes[i];
       var info = _infoFor[class_];
@@ skipping 654 matching lines @@
 class _LubHeap extends Heap<_ClassInfo> {
   @override
   bool sortsBefore(_ClassInfo a, _ClassInfo b) => sortsBeforeStatic(a, b);
 
   static bool sortsBeforeStatic(_ClassInfo a, _ClassInfo b) {
     if (a.depth > b.depth) return true;
     if (a.depth < b.depth) return false;
     return a.topologicalIndex < b.topologicalIndex;
   }
 }