anchor.diff:      }
   
       bool generateAtUseSite = isGenerateAtUseSite(input);
  -    if (input is HIdentity && generateAtUseSite) {
  +    if (input is HIs) {
  +      emitIs(input, '!==');
  +    } else if (input is HIdentity && generateAtUseSite) {
         emitIdentityComparison(input.left, input.right, true);
       } else if (input is HBoolify && generateAtUseSite) {
         use(input.inputs[0]);
  
positive.code:     push(new js.Binary('!=', pop(), new js.LiteralNull()));
    }
  
    void checkFunction(HInstruction input, DartType type) {
      checkTypeOf(input, '===', 'function');
      js.Expression functionTest = pop();
      checkObject(input, '===');
      js.Expression objectTest = pop();
      checkType(input, type);
      push(new js.Binary('||',
                         functionTest,
                         new js.Binary('&&', objectTest, pop())));
    }
  
    void checkType(HInstruction input, DartType type, {bool negative: false}) {
  
negative.code: 
    }
  
    void handleNumberOrStringSupertypeCheck(HInstruction input,
                                            DartType type,
                                            { bool negative: false }) {
      assert(!identical(type.element, compiler.listClass)
             && !Elements.isListSupertype(type.element, compiler)
             && !Elements.isStringOnlySupertype(type.element, compiler));
      String relation = negative ? '!==' : '===';
      checkNum(input, relation);
      js.Expression numberTest = pop();
      checkString(input, relation);
      js.Expression stringTest = pop();
      checkObject(input, relation);
      js.Expression objectTest = pop();
      checkType(input, type, negative: negative);
      String combiner = negative ? '&&' : '||';
      String combiner2 = negative ? '||' : '&&';
      push(new js.Binary(combiner,
                         new js.Binary(combiner, numberTest, stringTest),
                         new js.Binary(combiner2, objectTest, pop())));
    }
  
    void handleStringSupertypeCheck(HInstruction input,
                                    DartType type,
                                    { bool negative: false }) {
      assert(!identical(type.element, compiler.listClass)
             && !Elements.isListSupertype(type.element, compiler)
             && !Elements.isNumberOrStringSupertype(type.element, compiler));
      String relation = negative ? '!==' : '===';
      checkString(input, relation);
      js.Expression stringTest = pop();
      checkObject(input, relation);
      js.Expression objectTest = pop();
      checkType(input, type, negative: negative);
      String combiner = negative ? '||' : '&&';
      push(new js.Binary(negative ? '&&' : '||',
                         stringTest,
                         new js.Binary(combiner, objectTest, pop())));
    }
  
    void handleListOrSupertypeCheck(HInstruction input,
                                    DartType type,
                                    { bool negative: false }) {
      assert(!identical(type.element, compiler.stringClass)
             && !Elements.isStringOnlySupertype(type.element, compiler)
             && !Elements.isNumberOrStringSupertype(type.element, compiler));
      String relation = negative ? '!==' : '===';
      checkObject(input, relation);
      js.Expression objectTest = pop();
      checkArray(input, relation);
      js.Expression arrayTest = pop();
      checkType(input, type, negative: negative);
      String combiner = negative ? '&&' : '||';
      push(new js.Binary(negative ? '||' : '&&',
                         objectTest,
                         new js.Binary(combiner, arrayTest, pop())));
    }
  
    void visitIs(HIs node) {
      emitIs(node, "===");
    }
  
    void emitIs(HIs node, String relation)  {
      DartType type = node.typeExpression;
      world.registerIsCheck(type, work.resolutionTree);
      HInstruction input = node.expression;
  
      // If this is changed to single == there are several places below that must
      // be changed to match.
      assert(relation == '===' || relation == '!==');
      bool negative = relation == '!==';
  
      if (node.isVariableCheck || node.isCompoundCheck) {
        use(node.checkCall);
        if (negative) push(new js.Prefix('!', pop()));
      } else {
        assert(node.isRawCheck);
        LibraryElement coreLibrary = compiler.coreLibrary;
  