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 [changed]
+  /// 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> changed);

[ahe, 2017/06/08 20:18:10]

I suggest that you rename this parameter to classes.

Then you can write:

This method is invoked by the client after it changed [classes], ...

[scheglov, 2017/06/08 21:00:25]

Done.

 }
 
 /// Implementation of [ClassHierarchy] for closed world.
 class ClosedWorldClassHierarchy implements ClassHierarchy {
+  /// The [Program] that this class hierarchy represents.
+  final Program program;

[ahe, 2017/06/08 20:18:10]

Private?

[scheglov, 2017/06/08 21:00:24]

Done.

+
   /// 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> changed) {
+    if (changed.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 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.
@@ skipping 657 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;
   }
 }