anchor.diff:      if (node.selector == Selectors.length) {
         AbstractValue object = getValue(node.dartReceiver);
         if (typeSystem.isDefinitelyIndexable(object.type, allowNull: true)) {
  -        int length = typeSystem.getContainerLength(object.type.nonNullable());
  +        AbstractValue length = lattice.lengthSpecial(object);
           if (length != null) {
  -          setResult(node, constantValue(new IntConstantValue(length)),
  -              canReplace: !object.isNullable);
  +          setResult(node, 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;
       }
  
positive.code:   void visitGetLength(GetLength node) {
      AbstractValue input = getValue(node.object.definition);
      node.objectIsNotNull = input.isDefinitelyNotNull;
      int length = typeSystem.getContainerLength(input.type);
      if (length != null) {
        // TODO(asgerf): Constant-folding the length might degrade the VM's
        // own bounds-check elimination?
        setValue(node, constantValue(new IntConstantValue(length)));
      } else {
        setValue(node, nonConstant(typeSystem.uint32Type));
      }
  
negative.code: 
    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) {
  