anchor.diff:        backend,
         keepFields,
         keepVariables,
  +      evaluateAnnotations,
         coreTypes,
         typeEnvironment,
         strongMode,
         enableAsserts,
         errorReporter);
     for (final Library library in libraries) {
  -    constantsTransformer.convertLibraryAnnotations(library);
  -
  -    for (final Field field in library.fields.toList()) {
  -      constantsTransformer.convertField(field);
  -    }
  -    for (final Procedure procedure in library.procedures) {
  -      constantsTransformer.convertProcedure(procedure);
  -    }
  -    for (final Class klass in library.classes) {
  -      constantsTransformer.convertClassAnnotations(klass);
  -
  -      for (final Field field in klass.fields.toList()) {
  -        constantsTransformer.convertField(field);
  -      }
  -      for (final Procedure procedure in klass.procedures) {
  -        constantsTransformer.convertProcedure(procedure);
  -      }
  -      for (final Constructor constructor in klass.constructors) {
  -        constantsTransformer.convertConstructor(constructor);
  -      }
  -    }
  -    for (final Typedef td in library.typedefs) {
  -      constantsTransformer.convertTypedef(td);
  -    }
  -
  -    if (!keepFields) {
  -      // The transformer API does not iterate over `Library.additionalExports`,
  -      // so we manually delete the references to shaken nodes.
  -      library.additionalExports.removeWhere((Reference reference) {
  -        return reference.canonicalName == null;
  -      });
  -    }
  +    constantsTransformer.convertLibrary(library);
     }
   }
   
  
positive.code: 
    // Transform the library/class members:
  
    void convertLibraryAnnotations(Library lib) {
      constantEvaluator.withNewEnvironment(() {
        transformList(lib.annotations, this, lib);
      });
    }
  
    void convertClassAnnotations(Class klass) {
      constantEvaluator.withNewEnvironment(() {
        transformList(klass.annotations, this, klass);
      });
    }
  
    void convertProcedure(Procedure procedure) {
      constantEvaluator.withNewEnvironment(() {
        procedure.accept(this);
      });
    }
  
    void convertConstructor(Constructor constructor) {
      constantEvaluator.withNewEnvironment(() {
        constructor.accept(this);
      });
    }
  
    void convertField(Field field) {
      constantEvaluator.withNewEnvironment(() {
        if (field.accept(this) == null) field.remove();
      });
    }
  
    void convertTypedef(Typedef td) {
      // A typedef can have annotations on variables which are constants.
      constantEvaluator.withNewEnvironment(() {
        td.accept(this);
      });
    }
  
    // Handle definition of constants:
  
negative.code:     CoreTypes coreTypes, TypeEnvironment typeEnvironment,
      {bool keepFields: false,
      bool keepVariables: false,
      bool evaluateAnnotations: true,
      bool strongMode: false,
      bool enableAsserts: false,
      ErrorReporter errorReporter: const _SimpleErrorReporter()}) {
  