anchor.diff:    final Sorter _sorter;
   
     final Set<ClassEntity> neededClasses = {};
  +  final Set<ClassEntity> neededClassTypes = {};
     final Set<ClassEntity> classesOnlyNeededForRti = {};
  -  // This field is set in [computeNeededDeclarations].
  -  Set<ClassEntity> classesOnlyNeededForConstructor;
  +  final Set<ClassEntity> classesOnlyNeededForConstructor = {};
     final Map<OutputUnit, List<ClassEntity>> outputClassLists = {};
     final Map<OutputUnit, List<ClassEntity>> outputClassTypeLists = {};
     final Map<OutputUnit, List<ConstantValue>> outputConstantLists = {};
  
positive.code:     neededClasses.addAll(mixinClasses);
  
      // 3. Add classes only needed for their constructors.
      classesOnlyNeededForConstructor = _codegenWorld.constructorReferences
          .where((cls) => !neededClasses.contains(cls))
          .toSet();
      neededClasses.addAll(classesOnlyNeededForConstructor);
  
      // 4. Find all classes needed for rti.
      // It is important that this is the penultimate step, at this point,
  
negative.code:             .putIfAbsent(_outputUnitData.outputUnitForClass(cls), () => [])
              .add(cls);
        }
      }
  
      // 6. Collect any class types 'shadowed' by direct instantiation.
      for (ClassEntity cls in _rtiNeededClasses) {
        if (isClassTypeShadowed(cls)) {
          neededClassTypes.add(cls);
        }
      }
  
      // 7. Sort classes needed for type checking and then add them to their
      // respective OutputUnits.
      for (ClassEntity cls in _sorter.sortClasses(neededClassTypes)) {
        _outputListsForClassType
            .putIfAbsent(_outputUnitData.outputUnitForClassType(cls), () => [])
            .add(cls);
      }
    }
  
  