anchor.diff:      return constantSystem.createNull();
     }
   
  -  void registerInstantiatedClass(ClassElement element) {
  -    compiler.enqueuer.codegen.registerInstantiatedClass(element);
  -  }
  -
  -  void registerStringInstance() {
  -    registerInstantiatedClass(compiler.stringClass);
  -  }
  -
     Constant visitLiteralString(LiteralString node) {
  -    registerStringInstance();
  +    handler.registerStringInstance();
       return constantSystem.createString(node.dartString, node);
     }
   
  
positive.code:     classElement.ensureResolved(compiler);
      // TODO(floitsch): copy over the generic type.
      DartType type = new InterfaceType(classElement);
      registerInstantiatedClass(classElement);
      Constant constant = new MapConstant(type, keysList, values, protoValue);
      handler.registerCompileTimeConstant(constant);
      return constant;
  
negative.code:       if (partString == null) return null;
        accumulator = new DartString.concat(accumulator, partString.value);
      };
      handler.registerStringInstance();
      return constantSystem.createString(accumulator, node);
    }
  
    Constant makeTypeConstant(Element element) {
      DartType elementType = element.computeType(compiler).asRaw();
      DartType constantType = compiler.typeClass.computeType(compiler);
      Constant constant = new TypeConstant(elementType, constantType);
      // If we use a type literal in a constant, the compile time
      // constant emitter will generate a call to the createRuntimeType
      // helper so we register a use of that.
      handler.registerCreateRuntimeTypeFunction();
      handler.registerCompileTimeConstant(constant);
      return constant;
    }
  