anchor.diff:  
     AbstractValue greaterEqualSpecial(AbstractValue left, AbstractValue right) {
       return foldBinary(constantSystem.greaterEqual, left, right);
  +  }
  +
  +  AbstractValue intConstant(int value) {
  +    return constant(new IntConstantValue(value));
  +  }
  +
  +  AbstractValue lengthSpecial(AbstractValue input) {
  +    if (input.isConstant) {
  +      ConstantValue constant = input.constant;
  +      if (constant is StringConstantValue) {
  +        return intConstant(constant.length);
  +      } else if (constant is ListConstantValue) {
  +        return intConstant(constant.length);
  +      }
  +    }
  +    int length = typeSystem.getContainerLength(input.type);
  +    if (length != null) {
  +      return intConstant(length);
  +    }
  +    return null;  // The caller will use return type from type inference.
     }
   
     AbstractValue stringConstant(String value) {
  
positive.code:     if (node.selector == Selectors.length) {
        AbstractValue object = getValue(node.dartReceiver);
        if (typeSystem.isDefinitelyIndexable(object.type, allowNull: true)) {
          int length = typeSystem.getContainerLength(object.type.nonNullable());
          if (length != null) {
            setResult(node, constantValue(new IntConstantValue(length)),
                canReplace: !object.isNullable);
          }
        }
      }
  
      if (!node.selector.isOperator) {
        // TODO(jgruber): Handle known methods on constants such as String.length.
        setResult(node, lattice.getInvokeReturnType(node.selector, node.mask));
        return;
      }
  
negative.code:   void visitGetLength(GetLength node) {
      AbstractValue input = getValue(node.object.definition);
      node.objectIsNotNull = input.isDefinitelyNotNull;
      AbstractValue length = lattice.lengthSpecial(input);
      if (length != null) {
        // TODO(asgerf): Constant-folding the length might degrade the VM's
        // own bounds-check elimination?
        setValue(node, length);
      } else {
        setValue(node, nonConstant(typeSystem.uint32Type));
      }
  