anchor.diff:      classElement.ensureResolved(compiler);
       // TODO(floitsch): copy over the generic type.
       DartType type = new InterfaceType(classElement);
  -    registerInstantiatedClass(classElement);
  +    handler.registerInstantiatedClass(classElement);
       Constant constant = new MapConstant(type, keysList, values, protoValue);
       handler.registerCompileTimeConstant(constant);
       return constant;
  
positive.code:       if (partString == null) return null;
        accumulator = new DartString.concat(accumulator, partString.value);
      };
      registerStringInstance();
      return constantSystem.createString(accumulator, node);
    }
  
    Constant makeTypeConstant(Element element) {
      // If we use a type literal in a constant, the compile time constant
      // emitter will generate a call to the runtime type cache helper, so we
      // resolve it and put it into the codegen work list.
      if (!enabledRuntimeTypeSupport) {
        SourceString helperName = const SourceString('createRuntimeType');
        Element helper = compiler.findHelper(helperName);
        compiler.enqueuer.resolution.addToWorkList(helper);
        compiler.enqueuer.codegen.addToWorkList(helper);
        enabledRuntimeTypeSupport = true;
      }
  
      DartType elementType = element.computeType(compiler).asRaw();
      DartType constantType = compiler.typeClass.computeType(compiler);
      Constant constant = new TypeConstant(elementType, constantType);
      handler.registerCompileTimeConstant(constant);
      return constant;
    }
  
negative.code:   /** Caches the statics where the initial value cannot be eagerly compiled. */
    final Set<VariableElement> lazyStatics;
  
    /** Caches the createRuntimeType function if registered. */
    Element createRuntimeTypeFunction = null;
  
    ConstantHandler(Compiler compiler, this.constantSystem)
        : initialVariableValues = new Map<VariableElement, dynamic>(),
          compiledConstants = new Set<Constant>(),
          pendingVariables = new Set<VariableElement>(),
          lazyStatics = new Set<VariableElement>(),
          super(compiler);
  
    String get name => 'ConstantHandler';
  
    void registerCompileTimeConstant(Constant constant) {
      registerInstantiatedClass(constant.computeType(compiler).element);
      if (constant.isFunction()) {
        FunctionConstant function = constant;
        registerGetOfStaticFunction(function.element);
      }
      compiledConstants.add(constant);
    }
  
    void registerInstantiatedClass(ClassElement element) {
      compiler.enqueuer.codegen.registerInstantiatedClass(element);
    }
  
    void registerStaticUse(Element element) {
      compiler.enqueuer.codegen.registerStaticUse(element);
    }
  
    void registerGetOfStaticFunction(FunctionElement element) {
      compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
    }
  
    void registerStringInstance() {
      registerInstantiatedClass(compiler.stringClass);
    }
  
    void registerCreateRuntimeTypeFunction() {
      if (createRuntimeTypeFunction != null) return;
      SourceString helperName = const SourceString('createRuntimeType');
      createRuntimeTypeFunction = compiler.findHelper(helperName);
      registerStaticUse(createRuntimeTypeFunction);
      // TODO(kasperl): It looks a bit fishy that we have to register
      // this in the resolution queue too. Can we do this in the
      // resolver instead? That would be more consistent with how we
      // register all the other resolution work items.
      compiler.enqueuer.resolution.registerStaticUse(createRuntimeTypeFunction);
    }
  
    /**
  