anchor.diff:            .getExplicitCastCheckPolicy(_currentFrame.member);
       }
   
  -    if (policy.isEmitted) {
  +    if (!policy.isEmitted) {
  +      stack.add(expressionInstruction);
  +      return;
  +    }
  +
  +    void generateCheck() {
         HInstruction converted = _typeBuilder.buildAsCheck(
             expressionInstruction, localsHandler.substInContext(type),
             isTypeError: node.isTypeError, sourceInformation: sourceInformation);
  
positive.code: 
    @override
    void visitAsExpression(ir.AsExpression node) {
      ir.Expression operand = node.operand;
      operand.accept(this);
  
      StaticType operandType = _getStaticType(operand);
      DartType type = _elementMap.getDartType(node.type);
      if (!node.isCovarianceCheck &&
          _elementMap.types.isSubtype(operandType.type, type)) {
        // Skip unneeded casts.
        return;
      }
  
      SourceInformation sourceInformation =
  
negative.code:         add(converted);
        }
        stack.add(converted);
      }
  
      if (isNullRemovalPattern) {
        // Generate a conditional to test only `null` values:
        //
        //     temp = e;
        //     temp == null ? temp as T : temp
        SsaBranchBuilder(this).handleConditional(
            () {
              push(HIdentity(
                  expressionInstruction,
                  graph.addConstantNull(closedWorld),
                  _abstractValueDomain.boolType));
            },
            generateCheck,
            () {
              stack.add(expressionInstruction);
            });
      } else {
        generateCheck();
      }
    }
  
    static ir.Expression _skipCastsToDynamic(ir.Expression node) {
      if (node is ir.AsExpression && node.type is ir.DynamicType) {
        return _skipCastsToDynamic(node.operand);
      }
      return node;
    }
  
    @override
  