Make int and double nullable by default

test/codegen/expect/dart/convert.js

 var convert;
 (function(exports) {
   'use strict';
   let _processed = Symbol('_processed');
   let _original = Symbol('_original');
   // Function _convertJsonToDart: (dynamic, (dynamic, dynamic) → dynamic) → dynamic
   function _convertJsonToDart(json, reviver) {
     dart.assert(reviver !== null);
     // Function walk: (dynamic) → dynamic
     function walk(e) {
-      if (dart.notNull(e == null) || dart.notNull(typeof e != "object")) {
+      if (e == null || typeof e != "object") {
         return e;
       }
       if (Object.getPrototypeOf(e) === Array.prototype) {
-        for (let i = 0; i < e.length; i++) {
+        for (let i = 0; dart.notNull(i) < e.length; dart.notNull(i)++) {
           let item = e[i];
           e[i] = reviver(i, walk(item));
         }
         return e;
       }
       let map = new _JsonMap(e);
       let processed = map[_processed];
       let keys = map._computeKeys();
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         let key = keys.get(i);
         let revived = reviver(key, walk(e[key]));
         processed[key] = revived;
       }
       map[_original] = processed;
       return map;
     }
     return reviver(null, walk(json));
   }
   // Function _convertJsonToDartLazy: (dynamic) → dynamic
   function _convertJsonToDartLazy(object) {
     if (object === null)
       return null;
     if (typeof object != "object") {
       return object;
     }
     if (Object.getPrototypeOf(object) !== Array.prototype) {
       return new _JsonMap(object);
     }
-    for (let i = 0; i < object.length; i++) {
+    for (let i = 0; dart.notNull(i) < object.length; dart.notNull(i)++) {
       let item = object[i];
       object[i] = _convertJsonToDartLazy(item);
     }
     return object;
   }
   let _data = Symbol('_data');
   let _isUpgraded = Symbol('_isUpgraded');
   let _upgradedMap = Symbol('_upgradedMap');
   let _process = Symbol('_process');
   let _computeKeys = Symbol('_computeKeys');
@@ skipping 22 matching lines @@
         return result;
       }
     }
     get length() {
       return this[_isUpgraded] ? this[_upgradedMap].length : this[_computeKeys]().length;
     }
     get isEmpty() {
       return this.length === 0;
     }
     get isNotEmpty() {
-      return this.length > 0;
+      return dart.notNull(this.length) > 0;
     }
     get keys() {
       if (this[_isUpgraded])
         return this[_upgradedMap].keys;
       return new _JsonMapKeyIterable(this);
     }
     get values() {
       if (this[_isUpgraded])
         return this[_upgradedMap].values;
       return new _internal.MappedIterable(this[_computeKeys](), ((each) => this.get(each)).bind(this));
@@ skipping 14 matching lines @@
     }
     addAll(other) {
       other.forEach(((key, value) => {
         this.set(key, value);
       }).bind(this));
     }
     containsValue(value) {
       if (this[_isUpgraded])
         return this[_upgradedMap].containsValue(value);
       let keys = this[_computeKeys]();
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         let key = keys.get(i);
         if (dart.equals(this.get(key), value))
           return true;
       }
       return false;
     }
     containsKey(key) {
       if (this[_isUpgraded])
         return this[_upgradedMap].containsKey(key);
       if (!(typeof key == string))
         return false;
       return _hasProperty(this[_original], dart.as(key, core.String));
     }
     putIfAbsent(key, ifAbsent) {
       if (this.containsKey(key))
         return this.get(key);
       let value = ifAbsent();
       this.set(key, value);
       return value;
     }
     remove(key) {
-      if (dart.notNull(!dart.notNull(this[_isUpgraded])) && dart.notNull(!dart.notNull(this.containsKey(key))))
+      if (!dart.notNull(this[_isUpgraded]) && !dart.notNull(this.containsKey(key)))
         return null;
       return this[_upgrade]().remove(key);
     }
     clear() {
       if (this[_isUpgraded]) {
         this[_upgradedMap].clear();
       } else {
         if (this[_data] !== null) {
           dart.dinvoke(this[_data], 'clear');
         }
         this[_original] = this[_processed] = null;
         this[_data] = dart.map();
       }
     }
     forEach(f) {
       if (this[_isUpgraded])
         return this[_upgradedMap].forEach(f);
       let keys = this[_computeKeys]();
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         let key = keys.get(i);
         let value = _getProperty(this[_processed], key);
         if (_isUnprocessed(value)) {
           value = _convertJsonToDartLazy(_getProperty(this[_original], key));
           _setProperty(this[_processed], key, value);
         }
         f(key, value);
         if (!dart.notNull(core.identical(keys, this[_data]))) {
           throw new core.ConcurrentModificationError(this);
         }
@@ skipping 15 matching lines @@
       if (keys === null) {
         keys = this[_data] = _getPropertyNames(this[_original]);
       }
       return dart.as(keys, core.List$(core.String));
     }
     [_upgrade]() {
       if (this[_isUpgraded])
         return this[_upgradedMap];
       let result = dart.map();
       let keys = this[_computeKeys]();
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         let key = keys.get(i);
         result.set(key, this.get(key));
       }
       if (keys.isEmpty) {
         keys.add(null);
       } else {
         keys.clear();
       }
       this[_original] = this[_processed] = null;
       this[_data] = result;
@@ skipping 100 matching lines @@
     }
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       let stringLength = string.length;
       core.RangeError.checkValidRange(start, end, stringLength);
       if (end === null)
         end = stringLength;
-      let length = end - start;
+      let length = dart.notNull(end) - dart.notNull(start);
       let result = new typed_data.Uint8List(length);
-      for (let i = 0; i < length; i++) {
-        let codeUnit = string.codeUnitAt(start + i);
-        if ((codeUnit & ~this[_subsetMask]) !== 0) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(length); dart.notNull(i)++) {
+        let codeUnit = string.codeUnitAt(dart.notNull(start) + dart.notNull(i));
+        if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) !== 0) {
           throw new core.ArgumentError("String contains invalid characters.");
         }
         result.set(i, codeUnit);
       }
       return dart.as(result, core.List$(core.int));
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = new ByteConversionSink.from(sink);
       }
@@ skipping 12 matching lines @@
     _UnicodeSubsetEncoderSink($_subsetMask, $_sink) {
       this[_subsetMask] = $_subsetMask;
       this[_sink] = $_sink;
       super.StringConversionSinkBase();
     }
     close() {
       this[_sink].close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
-      for (let i = start; i < end; i++) {
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let codeUnit = source.codeUnitAt(i);
-        if ((codeUnit & ~this[_subsetMask]) !== 0) {
+        if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) !== 0) {
           throw new core.ArgumentError(`Source contains invalid character with code point: ${codeUnit}.`);
         }
       }
       this[_sink].add(source.codeUnits.sublist(start, end));
       if (isLast) {
         this.close();
       }
     }
   }
   let _convertInvalid = Symbol('_convertInvalid');
   class _UnicodeSubsetDecoder extends Converter$(core.List$(core.int), core.String) {
     _UnicodeSubsetDecoder($_allowInvalid, $_subsetMask) {
       this[_allowInvalid] = $_allowInvalid;
       this[_subsetMask] = $_subsetMask;
       super.Converter();
     }
     convert(bytes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       let byteCount = bytes.length;
       core.RangeError.checkValidRange(start, end, byteCount);
       if (end === null)
         end = byteCount;
-      let length = end - start;
-      for (let i = start; i < end; i++) {
+      let length = dart.notNull(end) - dart.notNull(start);
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let byte = bytes.get(i);
-        if ((byte & ~this[_subsetMask]) !== 0) {
+        if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) !== 0) {
           if (!dart.notNull(this[_allowInvalid])) {
             throw new core.FormatException(`Invalid value in input: ${byte}`);
           }
           return this[_convertInvalid](bytes, start, end);
         }
       }
       return new core.String.fromCharCodes(bytes, start, end);
     }
     [_convertInvalid](bytes, start, end) {
       let buffer = new core.StringBuffer();
-      for (let i = start; i < end; i++) {
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let value = bytes.get(i);
-        if ((value & ~this[_subsetMask]) !== 0)
+        if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) !== 0)
           value = 65533;
         buffer.writeCharCode(value);
       }
       return buffer.toString();
     }
     bind(stream) {
       return dart.as(super.bind(stream), async.Stream$(core.String));
     }
   }
   class AsciiDecoder extends _UnicodeSubsetDecoder {
@@ skipping 22 matching lines @@
       super.ByteConversionSinkBase();
     }
     close() {
       this[_utf8Sink].close();
     }
     add(source) {
       this.addSlice(source, 0, source.length, false);
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
-      for (let i = start; i < end; i++) {
-        if ((source.get(i) & ~_ASCII_MASK) !== 0) {
-          if (i > start)
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
+        if ((dart.notNull(source.get(i)) & ~dart.notNull(_ASCII_MASK)) !== 0) {
+          if (dart.notNull(i) > dart.notNull(start))
             this[_utf8Sink].addSlice(source, start, i, false);
           this[_utf8Sink].add(/* Unimplemented const */new List.from([239, 191, 189]));
-          start = i + 1;
+          start = dart.notNull(i) + 1;
         }
       }
-      if (start < end) {
+      if (dart.notNull(start) < dart.notNull(end)) {
         this[_utf8Sink].addSlice(source, start, end, isLast);
       } else if (isLast) {
         this.close();
       }
     }
   }
   class _SimpleAsciiDecoderSink extends ByteConversionSinkBase {
     _SimpleAsciiDecoderSink($_sink) {
       this[_sink] = $_sink;
       super.ByteConversionSinkBase();
     }
     close() {
       this[_sink].close();
     }
     add(source) {
-      for (let i = 0; i < source.length; i++) {
-        if ((source.get(i) & ~_ASCII_MASK) !== 0) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(source.length); dart.notNull(i)++) {
+        if ((dart.notNull(source.get(i)) & ~dart.notNull(_ASCII_MASK)) !== 0) {
           throw new core.FormatException("Source contains non-ASCII bytes.");
         }
       }
       this[_sink].add(new core.String.fromCharCodes(source));
     }
     addSlice(source, start, end, isLast) {
       let length = source.length;
       core.RangeError.checkValidRange(start, end, length);
-      if (start < end) {
-        if (dart.notNull(start !== 0) || dart.notNull(end !== length)) {
+      if (dart.notNull(start) < dart.notNull(end)) {
+        if (start !== 0 || end !== length) {
           source = source.sublist(start, end);
         }
         this.add(source);
       }
       if (isLast)
         this.close();
     }
   }
   class ByteConversionSink extends ChunkedConversionSink$(core.List$(core.int)) {
     ByteConversionSink() {
@@ skipping 32 matching lines @@
   let _bufferIndex = Symbol('_bufferIndex');
   let _roundToPowerOf2 = Symbol('_roundToPowerOf2');
   class _ByteCallbackSink extends ByteConversionSinkBase {
     _ByteCallbackSink(callback) {
       this[_buffer] = new typed_data.Uint8List(dart.as(_INITIAL_BUFFER_SIZE, core.int));
       this[_callback] = callback;
       this[_bufferIndex] = 0;
       super.ByteConversionSinkBase();
     }
     add(chunk) {
-      let freeCount = this[_buffer].length - this[_bufferIndex];
-      if (chunk.length > freeCount) {
+      let freeCount = dart.notNull(this[_buffer].length) - dart.notNull(this[_bufferIndex]);
+      if (dart.notNull(chunk.length) > dart.notNull(freeCount)) {
         let oldLength = this[_buffer].length;
-        let newLength = _roundToPowerOf2(chunk.length + oldLength) * 2;
+        let newLength = dart.notNull(_roundToPowerOf2(dart.notNull(chunk.length) + dart.notNull(oldLength))) * 2;
         let grown = new typed_data.Uint8List(newLength);
         grown.setRange(0, this[_buffer].length, this[_buffer]);
         this[_buffer] = grown;
       }
-      this[_buffer].setRange(this[_bufferIndex], this[_bufferIndex] + chunk.length, chunk);
+      this[_buffer].setRange(this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk.length), chunk);
       this[_bufferIndex] = chunk.length;
     }
     static [_roundToPowerOf2](v) {
-      dart.assert(v > 0);
-      v--;
-      v = v >> 1;
-      v = v >> 2;
-      v = v >> 4;
-      v = v >> 8;
-      v = v >> 16;
-      v++;
+      dart.assert(dart.notNull(v) > 0);
+      dart.notNull(v)--;
+      v = dart.notNull(v) >> 1;
+      v = dart.notNull(v) >> 2;
+      v = dart.notNull(v) >> 4;
+      v = dart.notNull(v) >> 8;
+      v = dart.notNull(v) >> 16;
+      dart.notNull(v)++;
       return v;
     }
     close() {
       this[_callback](this[_buffer].sublist(0, this[_bufferIndex]));
     }
   }
   _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
   let ChunkedConversionSink$ = dart.generic(function(T) {
     class ChunkedConversionSink extends dart.Object {
       ChunkedConversionSink() {
@@ skipping 200 matching lines @@
         mode = HtmlEscapeMode.UNKNOWN;
       this.mode = mode;
       super.Converter();
     }
     convert(text) {
       let val = this[_convert](text, 0, text.length);
       return val === null ? text : val;
     }
     [_convert](text, start, end) {
       let result = null;
-      for (let i = start; i < end; i++) {
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let ch = text.get(i);
         let replace = null;
         switch (ch) {
           case '&':
             replace = '&amp;';
             break;
           case ' ':
             replace = '&nbsp;';
             break;
           case '"':
@@ skipping 171 matching lines @@
       this[_toEncodable] = toEncodable;
       this[_bufferSize] = bufferSize;
       super.Converter();
     }
     static [_utf8Encode](string) {
       if (string === null)
         return null;
       if (string.isEmpty)
         return new typed_data.Uint8List(0);
       checkAscii: {
-        for (let i = 0; i < string.length; i++) {
-          if (string.codeUnitAt(i) >= 128)
+        for (let i = 0; dart.notNull(i) < dart.notNull(string.length); dart.notNull(i)++) {
+          if (dart.notNull(string.codeUnitAt(i)) >= 128)
             break checkAscii;
         }
         return string.codeUnits;
       }
       return UTF8.encode(string);
     }
     convert(object) {
       let bytes = dart.as(new List.from([]), core.List$(core.List$(core.int)));
       // Function addChunk: (Uint8List, int, int) → void
       function addChunk(chunk, start, end) {
-        if (dart.notNull(start > 0) || dart.notNull(end < chunk.length)) {
-          let length = end - start;
-          chunk = new typed_data.Uint8List.view(chunk.buffer, chunk.offsetInBytes + start, length);
+        if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk.length)) {
+          let length = dart.notNull(end) - dart.notNull(start);
+          chunk = new typed_data.Uint8List.view(chunk.buffer, dart.notNull(chunk.offsetInBytes) + dart.notNull(start), length);
         }
         bytes.add(chunk);
       }
       _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable], dart.throw_("Unimplemented type (Object) → dynamic")), this[_bufferSize], addChunk);
       if (bytes.length === 1)
         return bytes.get(0);
       let length = 0;
-      for (let i = 0; i < bytes.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(bytes.length); dart.notNull(i)++) {
         length = bytes.get(i).length;
       }
       let result = new typed_data.Uint8List(length);
-      for (let i = 0, offset = 0; i < bytes.length; i++) {
+      for (let i = 0, offset = 0; dart.notNull(i) < dart.notNull(bytes.length); dart.notNull(i)++) {
         let byteList = bytes.get(i);
-        let end = offset + byteList.length;
+        let end = dart.notNull(offset) + dart.notNull(byteList.length);
         result.setRange(offset, end, byteList);
         offset = end;
       }
       return result;
     }
     startChunkedConversion(sink) {
       let byteSink = null;
       if (dart.is(sink, ByteConversionSink)) {
         byteSink = sink;
       } else {
@@ skipping 97 matching lines @@
   }
   let _seen = Symbol('_seen');
   let _checkCycle = Symbol('_checkCycle');
   let _removeSeen = Symbol('_removeSeen');
   class _JsonStringifier extends dart.Object {
     _JsonStringifier(_toEncodable) {
       this[_seen] = new core.List();
       this[_toEncodable] = dart.as(_toEncodable !== null ? _toEncodable : _defaultToEncodable, core.Function);
     }
     static hexDigit(x) {
-      return x < 10 ? 48 + x : 87 + x;
+      return dart.notNull(x) < 10 ? 48 + dart.notNull(x) : 87 + dart.notNull(x);
     }
     writeStringContent(s) {
       let offset = 0;
       let length = s.length;
-      for (let i = 0; i < length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(length); dart.notNull(i)++) {
         let charCode = s.codeUnitAt(i);
-        if (charCode > BACKSLASH)
+        if (dart.notNull(charCode) > dart.notNull(BACKSLASH))
           continue;
-        if (charCode < 32) {
-          if (i > offset)
+        if (dart.notNull(charCode) < 32) {
+          if (dart.notNull(i) > dart.notNull(offset))
             this.writeStringSlice(s, offset, i);
-          offset = i + 1;
+          offset = dart.notNull(i) + 1;
           this.writeCharCode(BACKSLASH);
           switch (charCode) {
             case BACKSPACE:
               this.writeCharCode(CHAR_b);
               break;
             case TAB:
               this.writeCharCode(CHAR_t);
               break;
             case NEWLINE:
               this.writeCharCode(CHAR_n);
               break;
             case FORM_FEED:
               this.writeCharCode(CHAR_f);
               break;
             case CARRIAGE_RETURN:
               this.writeCharCode(CHAR_r);
               break;
             default:
               this.writeCharCode(CHAR_u);
               this.writeCharCode(CHAR_0);
               this.writeCharCode(CHAR_0);
-              this.writeCharCode(hexDigit(charCode >> 4 & 15));
-              this.writeCharCode(hexDigit(charCode & 15));
+              this.writeCharCode(hexDigit(dart.notNull(charCode) >> 4 & 15));
+              this.writeCharCode(hexDigit(dart.notNull(charCode) & 15));
               break;
           }
-        } else if (dart.notNull(charCode === QUOTE) || dart.notNull(charCode === BACKSLASH)) {
-          if (i > offset)
+        } else if (charCode === QUOTE || charCode === BACKSLASH) {
+          if (dart.notNull(i) > dart.notNull(offset))
             this.writeStringSlice(s, offset, i);
-          offset = i + 1;
+          offset = dart.notNull(i) + 1;
           this.writeCharCode(BACKSLASH);
           this.writeCharCode(charCode);
         }
       }
       if (offset === 0) {
         this.writeString(s);
-      } else if (offset < length) {
+      } else if (dart.notNull(offset) < dart.notNull(length)) {
         this.writeStringSlice(s, offset, length);
       }
     }
     [_checkCycle](object) {
-      for (let i = 0; i < this[_seen].length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(this[_seen].length); dart.notNull(i)++) {
         if (core.identical(object, this[_seen].get(i))) {
           throw new JsonCyclicError(object);
         }
       }
       this[_seen].add(object);
     }
     [_removeSeen](object) {
       dart.assert(!dart.notNull(this[_seen].isEmpty));
       dart.assert(core.identical(this[_seen].last, object));
       this[_seen].removeLast();
@@ skipping 42 matching lines @@
         this[_checkCycle](object);
         this.writeMap(dart.as(object, core.Map$(core.String, core.Object)));
         this[_removeSeen](object);
         return true;
       } else {
         return false;
       }
     }
     writeList(list) {
       this.writeString('[');
-      if (list.length > 0) {
+      if (dart.notNull(list.length) > 0) {
         this.writeObject(list.get(0));
-        for (let i = 1; i < list.length; i++) {
+        for (let i = 1; dart.notNull(i) < dart.notNull(list.length); dart.notNull(i)++) {
           this.writeString(',');
           this.writeObject(list.get(i));
         }
       }
       this.writeString(']');
     }
     writeMap(map) {
       this.writeString('{');
       let separator = '"';
       map.forEach(((key, value) => {
@@ skipping 23 matching lines @@
   let _indentLevel = Symbol('_indentLevel');
   class _JsonPrettyPrintMixin extends dart.Object {
     _JsonPrettyPrintMixin() {
       this[_indentLevel] = 0;
     }
     writeList(list) {
       if (list.isEmpty) {
         this.writeString('[]');
       } else {
         this.writeString('[\n');
-        this[_indentLevel]++;
+        dart.notNull(this[_indentLevel])++;
         this.writeIndentation(this[_indentLevel]);
         this.writeObject(list.get(0));
-        for (let i = 1; i < list.length; i++) {
+        for (let i = 1; dart.notNull(i) < dart.notNull(list.length); dart.notNull(i)++) {
           this.writeString(',\n');
           this.writeIndentation(this[_indentLevel]);
           this.writeObject(list.get(i));
         }
         this.writeString('\n');
-        this[_indentLevel]--;
+        dart.notNull(this[_indentLevel])--;
         this.writeIndentation(this[_indentLevel]);
         this.writeString(']');
       }
     }
     writeMap(map) {
       if (map.isEmpty) {
         this.writeString('{}');
       } else {
         this.writeString('{\n');
-        this[_indentLevel]++;
+        dart.notNull(this[_indentLevel])++;
         let first = true;
         map.forEach(dart.as(((key, value) => {
           if (!dart.notNull(first)) {
             this.writeString(",\n");
           }
           this.writeIndentation(this[_indentLevel]);
           this.writeString('"');
           this.writeStringContent(key);
           this.writeString('": ');
           this.writeObject(value);
           first = false;
         }).bind(this), dart.throw_("Unimplemented type (dynamic, dynamic) → void")));
         this.writeString('\n');
-        this[_indentLevel]--;
+        dart.notNull(this[_indentLevel])--;
         this.writeIndentation(this[_indentLevel]);
         this.writeString('}');
       }
     }
   }
   class _JsonStringStringifier extends _JsonStringifier {
     _JsonStringStringifier($_sink, _toEncodable) {
       this[_sink] = $_sink;
       super._JsonStringifier(dart.as(_toEncodable, dart.throw_("Unimplemented type (Object) → Object")));
     }
@@ skipping 23 matching lines @@
     writeCharCode(charCode) {
       this[_sink].writeCharCode(charCode);
     }
   }
   class _JsonStringStringifierPretty extends dart.mixin(_JsonStringStringifier, _JsonPrettyPrintMixin) {
     _JsonStringStringifierPretty(sink, toEncodable, $_indent) {
       this[_indent] = $_indent;
       super._JsonStringStringifier(sink, toEncodable);
     }
     writeIndentation(count) {
-      for (let i = 0; i < count; i++)
+      for (let i = 0; dart.notNull(i) < dart.notNull(count); dart.notNull(i)++)
         this.writeString(this[_indent]);
     }
   }
   class _JsonUtf8Stringifier extends _JsonStringifier {
     _JsonUtf8Stringifier(toEncodable, bufferSize, addChunk) {
       this.addChunk = addChunk;
       this.bufferSize = bufferSize;
       this.buffer = new typed_data.Uint8List(bufferSize);
       this.index = 0;
       super._JsonStringifier(dart.as(toEncodable, dart.throw_("Unimplemented type (Object) → Object")));
     }
     static stringify(object, indent, toEncodableFunction, bufferSize, addChunk) {
       let stringifier = null;
       if (indent !== null) {
         stringifier = new _JsonUtf8StringifierPretty(toEncodableFunction, indent, bufferSize, addChunk);
       } else {
         stringifier = new _JsonUtf8Stringifier(toEncodableFunction, bufferSize, addChunk);
       }
       stringifier.writeObject(object);
       stringifier.flush();
     }
     flush() {
-      if (this.index > 0) {
+      if (dart.notNull(this.index) > 0) {
         dart.dinvokef(this.addChunk, this.buffer, 0, this.index);
       }
       this.buffer = null;
       this.index = 0;
     }
     writeNumber(number) {
       this.writeAsciiString(number.toString());
     }
     writeAsciiString(string) {
-      for (let i = 0; i < string.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(string.length); dart.notNull(i)++) {
         let char = string.codeUnitAt(i);
-        dart.assert(char <= 127);
+        dart.assert(dart.notNull(char) <= 127);
         this.writeByte(char);
       }
     }
     writeString(string) {
       this.writeStringSlice(string, 0, string.length);
     }
     writeStringSlice(string, start, end) {
-      for (let i = start; i < end; i++) {
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let char = string.codeUnitAt(i);
-        if (char <= 127) {
+        if (dart.notNull(char) <= 127) {
           this.writeByte(char);
         } else {
-          if (dart.notNull((char & 64512) === 55296) && dart.notNull(i + 1 < end)) {
-            let nextChar = string.codeUnitAt(i + 1);
-            if ((nextChar & 64512) === 56320) {
-              char = 65536 + ((char & 1023) << 10) + (nextChar & 1023);
+          if ((dart.notNull(char) & 64512) === 55296 && dart.notNull(i) + 1 < dart.notNull(end)) {
+            let nextChar = string.codeUnitAt(dart.notNull(i) + 1);
+            if ((dart.notNull(nextChar) & 64512) === 56320) {
+              char = 65536 + ((dart.notNull(char) & 1023) << 10) + (dart.notNull(nextChar) & 1023);
               this.writeFourByteCharCode(char);
-              i++;
+              dart.notNull(i)++;
               continue;
             }
           }
           this.writeMultiByteCharCode(char);
         }
       }
     }
     writeCharCode(charCode) {
-      if (charCode <= 127) {
+      if (dart.notNull(charCode) <= 127) {
         this.writeByte(charCode);
         return;
       }
       this.writeMultiByteCharCode(charCode);
     }
     writeMultiByteCharCode(charCode) {
-      if (charCode <= 2047) {
-        this.writeByte(192 | charCode >> 6);
-        this.writeByte(128 | charCode & 63);
+      if (dart.notNull(charCode) <= 2047) {
+        this.writeByte(192 | dart.notNull(charCode) >> 6);
+        this.writeByte(128 | dart.notNull(charCode) & 63);
         return;
       }
-      if (charCode <= 65535) {
-        this.writeByte(224 | charCode >> 12);
-        this.writeByte(128 | charCode >> 6 & 63);
-        this.writeByte(128 | charCode & 63);
+      if (dart.notNull(charCode) <= 65535) {
+        this.writeByte(224 | dart.notNull(charCode) >> 12);
+        this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
+        this.writeByte(128 | dart.notNull(charCode) & 63);
         return;
       }
       this.writeFourByteCharCode(charCode);
     }
     writeFourByteCharCode(charCode) {
-      dart.assert(charCode <= 1114111);
-      this.writeByte(240 | charCode >> 18);
-      this.writeByte(128 | charCode >> 12 & 63);
-      this.writeByte(128 | charCode >> 6 & 63);
-      this.writeByte(128 | charCode & 63);
+      dart.assert(dart.notNull(charCode) <= 1114111);
+      this.writeByte(240 | dart.notNull(charCode) >> 18);
+      this.writeByte(128 | dart.notNull(charCode) >> 12 & 63);
+      this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
+      this.writeByte(128 | dart.notNull(charCode) & 63);
     }
     writeByte(byte) {
-      dart.assert(byte <= 255);
+      dart.assert(dart.notNull(byte) <= 255);
       if (this.index === this.buffer.length) {
         dart.dinvokef(this.addChunk, this.buffer, 0, this.index);
         this.buffer = new typed_data.Uint8List(this.bufferSize);
         this.index = 0;
       }
-      this.buffer.set(this.index++, byte);
+      this.buffer.set(dart.notNull(this.index)++, byte);
     }
   }
   class _JsonUtf8StringifierPretty extends dart.mixin(_JsonUtf8Stringifier, _JsonPrettyPrintMixin) {
     _JsonUtf8StringifierPretty(toEncodableFunction, indent, bufferSize, addChunk) {
       this.indent = indent;
       super._JsonUtf8Stringifier(toEncodableFunction, dart.as(bufferSize, core.int), dart.as(addChunk, core.Function));
     }
     writeIndentation(count) {
       let indent = this.indent;
       let indentLength = indent.length;
       if (indentLength === 1) {
         let char = indent.get(0);
-        while (count > 0) {
+        while (dart.notNull(count) > 0) {
           this.writeByte(char);
           count = 1;
         }
         return;
       }
-      while (count > 0) {
-        count--;
-        let end = this.index + indentLength;
-        if (end <= this.buffer.length) {
+      while (dart.notNull(count) > 0) {
+        dart.notNull(count)--;
+        let end = dart.notNull(this.index) + dart.notNull(indentLength);
+        if (dart.notNull(end) <= dart.notNull(this.buffer.length)) {
           this.buffer.setRange(this.index, end, indent);
           this.index = end;
         } else {
-          for (let i = 0; i < indentLength; i++) {
+          for (let i = 0; dart.notNull(i) < dart.notNull(indentLength); dart.notNull(i)++) {
             this.writeByte(indent.get(i));
           }
         }
       }
     }
   }
   let LATIN1 = new Latin1Codec();
   let _LATIN1_MASK = 255;
   class Latin1Codec extends Encoding {
     Latin1Codec(opt$) {
@@ skipping 55 matching lines @@
     add(source) {
       this.addSlice(source, 0, source.length, false);
     }
     [_addSliceToSink](source, start, end, isLast) {
       this[_sink].add(new core.String.fromCharCodes(source, start, end));
       if (isLast)
         this.close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
-      for (let i = start; i < end; i++) {
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let char = source.get(i);
-        if (dart.notNull(char > _LATIN1_MASK) || dart.notNull(char < 0)) {
+        if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
           throw new core.FormatException("Source contains non-Latin-1 characters.");
         }
       }
-      if (start < end) {
+      if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
       if (isLast) {
         this.close();
       }
     }
   }
   class _Latin1AllowInvalidDecoderSink extends _Latin1DecoderSink {
     _Latin1AllowInvalidDecoderSink(sink) {
       super._Latin1DecoderSink(sink);
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
-      for (let i = start; i < end; i++) {
+      for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
         let char = source.get(i);
-        if (dart.notNull(char > _LATIN1_MASK) || dart.notNull(char < 0)) {
-          if (i > start)
+        if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
+          if (dart.notNull(i) > dart.notNull(start))
             this[_addSliceToSink](source, start, i, false);
           this[_addSliceToSink](dart.as(/* Unimplemented const */new List.from([65533]), core.List$(core.int)), 0, 1, false);
-          start = i + 1;
+          start = dart.notNull(i) + 1;
         }
       }
-      if (start < end) {
+      if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
       if (isLast) {
         this.close();
       }
     }
   }
   class LineSplitter extends Converter$(core.String, core.List$(core.String)) {
     LineSplitter() {
       super.Converter();
@@ skipping 27 matching lines @@
       }
       this[_carry] = _addSlice(chunk, start, end, isLast, this[_sink].add);
       if (isLast)
         this[_sink].close();
     }
     close() {
       this.addSlice('', 0, 0, true);
     }
     static [_addSlice](chunk, start, end, isLast, adder) {
       let pos = start;
-      while (pos < end) {
+      while (dart.notNull(pos) < dart.notNull(end)) {
         let skip = 0;
         let char = chunk.codeUnitAt(pos);
         if (char === _LF) {
           skip = 1;
         } else if (char === _CR) {
           skip = 1;
-          if (pos + 1 < end) {
-            if (chunk.codeUnitAt(pos + 1) === _LF) {
+          if (dart.notNull(pos) + 1 < dart.notNull(end)) {
+            if (chunk.codeUnitAt(dart.notNull(pos) + 1) === _LF) {
               skip = 2;
             }
           } else if (!dart.notNull(isLast)) {
             return chunk.substring(start, end);
           }
         }
-        if (skip > 0) {
+        if (dart.notNull(skip) > 0) {
           adder(chunk.substring(start, pos));
-          start = pos = pos + skip;
+          start = pos = dart.notNull(pos) + dart.notNull(skip);
         } else {
-          pos++;
+          dart.notNull(pos)++;
         }
       }
       if (pos !== start) {
         let carry = chunk.substring(start, pos);
         if (isLast) {
           adder(carry);
         } else {
           return carry;
         }
       }
@@ skipping 119 matching lines @@
       return new _StringConversionSinkAsStringSinkAdapter(this);
     }
   }
   class _StringSinkConversionSink extends StringConversionSinkBase {
     _StringSinkConversionSink($_stringSink) {
       this[_stringSink] = $_stringSink;
       super.StringConversionSinkBase();
     }
     close() {}
     addSlice(str, start, end, isLast) {
-      if (dart.notNull(start !== 0) || dart.notNull(end !== str.length)) {
-        for (let i = start; i < end; i++) {
+      if (start !== 0 || end !== str.length) {
+        for (let i = start; dart.notNull(i) < dart.notNull(end); dart.notNull(i)++) {
           this[_stringSink].writeCharCode(str.codeUnitAt(i));
         }
       } else {
         this[_stringSink].write(str);
       }
       if (isLast)
         this.close();
     }
     add(str) {
       return this[_stringSink].write(str);
@@ skipping 22 matching lines @@
   }
   class _StringAdapterSink extends StringConversionSinkBase {
     _StringAdapterSink($_sink) {
       this[_sink] = $_sink;
       super.StringConversionSinkBase();
     }
     add(str) {
       return this[_sink].add(str);
     }
     addSlice(str, start, end, isLast) {
-      if (dart.notNull(start === 0) && dart.notNull(end === str.length)) {
+      if (start === 0 && end === str.length) {
         this.add(str);
       } else {
         this.add(str.substring(start, end));
       }
       if (isLast)
         this.close();
     }
     close() {
       return this[_sink].close();
     }
@@ skipping 88 matching lines @@
     }
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       let stringLength = string.length;
       core.RangeError.checkValidRange(start, end, stringLength);
       if (end === null)
         end = stringLength;
-      let length = end - start;
+      let length = dart.notNull(end) - dart.notNull(start);
       if (length === 0)
         return new typed_data.Uint8List(0);
-      let encoder = new _Utf8Encoder.withBufferSize(length * 3);
+      let encoder = new _Utf8Encoder.withBufferSize(dart.notNull(length) * 3);
       let endPosition = encoder._fillBuffer(string, start, end);
-      dart.assert(endPosition >= end - 1);
+      dart.assert(dart.notNull(endPosition) >= dart.notNull(end) - 1);
       if (endPosition !== end) {
-        let lastCodeUnit = string.codeUnitAt(end - 1);
+        let lastCodeUnit = string.codeUnitAt(dart.notNull(end) - 1);
         dart.assert(_isLeadSurrogate(lastCodeUnit));
         let wasCombined = encoder._writeSurrogate(lastCodeUnit, 0);
         dart.assert(!dart.notNull(wasCombined));
       }
       return encoder[_buffer].sublist(0, encoder[_bufferIndex]);
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = new ByteConversionSink.from(sink);
       }
@@ skipping 15 matching lines @@
       this[_buffer] = _createBuffer(bufferSize);
       this[_carry] = 0;
       this[_bufferIndex] = 0;
     }
     static [_createBuffer](size) {
       return new typed_data.Uint8List(size);
     }
     [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
       if (_isTailSurrogate(nextCodeUnit)) {
         let rune = _combineSurrogatePair(leadingSurrogate, nextCodeUnit);
-        dart.assert(rune > _THREE_BYTE_LIMIT);
-        dart.assert(rune <= _FOUR_BYTE_LIMIT);
-        this[_buffer].set(this[_bufferIndex]++, 240 | rune >> 18);
-        this[_buffer].set(this[_bufferIndex]++, 128 | rune >> 12 & 63);
-        this[_buffer].set(this[_bufferIndex]++, 128 | rune >> 6 & 63);
-        this[_buffer].set(this[_bufferIndex]++, 128 | rune & 63);
+        dart.assert(dart.notNull(rune) > dart.notNull(_THREE_BYTE_LIMIT));
+        dart.assert(dart.notNull(rune) <= dart.notNull(_FOUR_BYTE_LIMIT));
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 240 | dart.notNull(rune) >> 18);
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(rune) >> 12 & 63);
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(rune) >> 6 & 63);
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(rune) & 63);
         return true;
       } else {
-        this[_buffer].set(this[_bufferIndex]++, 224 | leadingSurrogate >> 12);
-        this[_buffer].set(this[_bufferIndex]++, 128 | leadingSurrogate >> 6 & 63);
-        this[_buffer].set(this[_bufferIndex]++, 128 | leadingSurrogate & 63);
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 224 | dart.notNull(leadingSurrogate) >> 12);
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
+        this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(leadingSurrogate) & 63);
         return false;
       }
     }
     [_fillBuffer](str, start, end) {
-      if (dart.notNull(start !== end) && dart.notNull(_isLeadSurrogate(str.codeUnitAt(end - 1)))) {
-        end--;
+      if (start !== end && dart.notNull(_isLeadSurrogate(str.codeUnitAt(dart.notNull(end) - 1)))) {
+        dart.notNull(end)--;
       }
       let stringIndex = null;
-      for (stringIndex = start; stringIndex < end; stringIndex++) {
+      for (stringIndex = start; dart.notNull(stringIndex) < dart.notNull(end); dart.notNull(stringIndex)++) {
         let codeUnit = str.codeUnitAt(stringIndex);
-        if (codeUnit <= _ONE_BYTE_LIMIT) {
-          if (this[_bufferIndex] >= this[_buffer].length)
+        if (dart.notNull(codeUnit) <= dart.notNull(_ONE_BYTE_LIMIT)) {
+          if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer].length))
             break;
-          this[_buffer].set(this[_bufferIndex]++, codeUnit);
+          this[_buffer].set(dart.notNull(this[_bufferIndex])++, codeUnit);
         } else if (_isLeadSurrogate(codeUnit)) {
-          if (this[_bufferIndex] + 3 >= this[_buffer].length)
+          if (dart.notNull(this[_bufferIndex]) + 3 >= dart.notNull(this[_buffer].length))
             break;
-          let nextCodeUnit = str.codeUnitAt(stringIndex + 1);
+          let nextCodeUnit = str.codeUnitAt(dart.notNull(stringIndex) + 1);
           let wasCombined = this[_writeSurrogate](codeUnit, nextCodeUnit);
           if (wasCombined)
-            stringIndex++;
+            dart.notNull(stringIndex)++;
         } else {
           let rune = codeUnit;
-          if (rune <= _TWO_BYTE_LIMIT) {
-            if (this[_bufferIndex] + 1 >= this[_buffer].length)
+          if (dart.notNull(rune) <= dart.notNull(_TWO_BYTE_LIMIT)) {
+            if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer].length))
               break;
-            this[_buffer].set(this[_bufferIndex]++, 192 | rune >> 6);
-            this[_buffer].set(this[_bufferIndex]++, 128 | rune & 63);
+            this[_buffer].set(dart.notNull(this[_bufferIndex])++, 192 | dart.notNull(rune) >> 6);
+            this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(rune) & 63);
           } else {
-            dart.assert(rune <= _THREE_BYTE_LIMIT);
-            if (this[_bufferIndex] + 2 >= this[_buffer].length)
+            dart.assert(dart.notNull(rune) <= dart.notNull(_THREE_BYTE_LIMIT));
+            if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer].length))
               break;
-            this[_buffer].set(this[_bufferIndex]++, 224 | rune >> 12);
-            this[_buffer].set(this[_bufferIndex]++, 128 | rune >> 6 & 63);
-            this[_buffer].set(this[_bufferIndex]++, 128 | rune & 63);
+            this[_buffer].set(dart.notNull(this[_bufferIndex])++, 224 | dart.notNull(rune) >> 12);
+            this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(rune) >> 6 & 63);
+            this[_buffer].set(dart.notNull(this[_bufferIndex])++, 128 | dart.notNull(rune) & 63);
           }
         }
       }
       return stringIndex;
     }
   }
   dart.defineNamedConstructor(_Utf8Encoder, 'withBufferSize');
   _Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE = 1024;
   class _Utf8EncoderSink extends dart.mixin(_Utf8Encoder, StringConversionSinkMixin) {
     _Utf8EncoderSink($_sink) {
       this[_sink] = $_sink;
       super._Utf8Encoder();
     }
     close() {
       if (this[_carry] !== 0) {
         this.addSlice("", 0, 0, true);
         return;
       }
       this[_sink].close();
     }
     addSlice(str, start, end, isLast) {
       this[_bufferIndex] = 0;
-      if (dart.notNull(start === end) && dart.notNull(!dart.notNull(isLast))) {
+      if (start === end && !dart.notNull(isLast)) {
         return;
       }
       if (this[_carry] !== 0) {
         let nextCodeUnit = 0;
         if (start !== end) {
           nextCodeUnit = str.codeUnitAt(start);
         } else {
           dart.assert(isLast);
         }
         let wasCombined = this[_writeSurrogate](this[_carry], nextCodeUnit);
-        dart.assert(dart.notNull(!dart.notNull(wasCombined)) || dart.notNull(start !== end));
+        dart.assert(!dart.notNull(wasCombined) || start !== end);
         if (wasCombined)
-          start++;
+          dart.notNull(start)++;
         this[_carry] = 0;
       }
       do {
         start = this[_fillBuffer](str, start, end);
-        let isLastSlice = dart.notNull(isLast) && dart.notNull(start === end);
-        if (dart.notNull(start === end - 1) && dart.notNull(_isLeadSurrogate(str.codeUnitAt(start)))) {
-          if (dart.notNull(isLast) && dart.notNull(this[_bufferIndex] < this[_buffer].length - 3)) {
+        let isLastSlice = dart.notNull(isLast) && start === end;
+        if (start === dart.notNull(end) - 1 && dart.notNull(_isLeadSurrogate(str.codeUnitAt(start)))) {
+          if (dart.notNull(isLast) && dart.notNull(this[_bufferIndex]) < dart.notNull(this[_buffer].length) - 3) {
             let hasBeenCombined = this[_writeSurrogate](str.codeUnitAt(start), 0);
             dart.assert(!dart.notNull(hasBeenCombined));
           } else {
             this[_carry] = str.codeUnitAt(start);
           }
-          start++;
+          dart.notNull(start)++;
         }
         this[_sink].addSlice(this[_buffer], 0, this[_bufferIndex], isLastSlice);
         this[_bufferIndex] = 0;
-      } while (start < end);
+      } while (dart.notNull(start) < dart.notNull(end));
       if (isLast)
         this.close();
     }
   }
   class Utf8Decoder extends Converter$(core.List$(core.int), core.String) {
     Utf8Decoder(opt$) {
       let allowMalformed = opt$.allowMalformed === void 0 ? false : opt$.allowMalformed;
       this[_allowMalformed] = allowMalformed;
       super.Converter();
     }
@@ skipping 32 matching lines @@
   let _TWO_BYTE_LIMIT = 2047;
   let _THREE_BYTE_LIMIT = 65535;
   let _FOUR_BYTE_LIMIT = 1114111;
   let _SURROGATE_MASK = 63488;
   let _SURROGATE_TAG_MASK = 64512;
   let _SURROGATE_VALUE_MASK = 1023;
   let _LEAD_SURROGATE_MIN = 55296;
   let _TAIL_SURROGATE_MIN = 56320;
   // Function _isSurrogate: (int) → bool
   function _isSurrogate(codeUnit) {
-    return (codeUnit & _SURROGATE_MASK) === _LEAD_SURROGATE_MIN;
+    return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_MASK)) === _LEAD_SURROGATE_MIN;
   }
   // Function _isLeadSurrogate: (int) → bool
   function _isLeadSurrogate(codeUnit) {
-    return (codeUnit & _SURROGATE_TAG_MASK) === _LEAD_SURROGATE_MIN;
+    return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) === _LEAD_SURROGATE_MIN;
   }
   // Function _isTailSurrogate: (int) → bool
   function _isTailSurrogate(codeUnit) {
-    return (codeUnit & _SURROGATE_TAG_MASK) === _TAIL_SURROGATE_MIN;
+    return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) === _TAIL_SURROGATE_MIN;
   }
   // Function _combineSurrogatePair: (int, int) → int
   function _combineSurrogatePair(lead, tail) {
-    return 65536 + ((lead & _SURROGATE_VALUE_MASK) << 10) | tail & _SURROGATE_VALUE_MASK;
+    return 65536 + ((dart.notNull(lead) & dart.notNull(_SURROGATE_VALUE_MASK)) << 10) | dart.notNull(tail) & dart.notNull(_SURROGATE_VALUE_MASK);
   }
   let _isFirstCharacter = Symbol('_isFirstCharacter');
   let _value = Symbol('_value');
   let _expectedUnits = Symbol('_expectedUnits');
   let _extraUnits = Symbol('_extraUnits');
   class _Utf8Decoder extends dart.Object {
     _Utf8Decoder($_stringSink, $_allowMalformed) {
       this[_stringSink] = $_stringSink;
       this[_allowMalformed] = $_allowMalformed;
       this[_isFirstCharacter] = true;
       this[_value] = 0;
       this[_expectedUnits] = 0;
       this[_extraUnits] = 0;
     }
     get hasPartialInput() {
-      return this[_expectedUnits] > 0;
+      return dart.notNull(this[_expectedUnits]) > 0;
     }
     close() {
       this.flush();
     }
     flush() {
       if (this.hasPartialInput) {
         if (!dart.notNull(this[_allowMalformed])) {
           throw new core.FormatException("Unfinished UTF-8 octet sequence");
         }
         this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
         this[_value] = 0;
         this[_expectedUnits] = 0;
         this[_extraUnits] = 0;
       }
     }
     convert(codeUnits, startIndex, endIndex) {
       let value = this[_value];
       let expectedUnits = this[_expectedUnits];
       let extraUnits = this[_extraUnits];
       this[_value] = 0;
       this[_expectedUnits] = 0;
       this[_extraUnits] = 0;
       // Function scanOneByteCharacters: (dynamic, int) → int
       function scanOneByteCharacters(units, from) {
         let to = endIndex;
         let mask = _ONE_BYTE_LIMIT;
-        for (let i = from; i < to; i++) {
+        for (let i = from; dart.notNull(i) < dart.notNull(to); dart.notNull(i)++) {
           let unit = dart.dindex(units, i);
           if (!dart.equals(dart.dbinary(unit, '&', mask), unit))
-            return i - from;
+            return dart.notNull(i) - dart.notNull(from);
         }
-        return to - from;
+        return dart.notNull(to) - dart.notNull(from);
       }
       // Function addSingleBytes: (int, int) → void
       function addSingleBytes(from, to) {
-        dart.assert(dart.notNull(from >= startIndex) && dart.notNull(from <= endIndex));
-        dart.assert(dart.notNull(to >= startIndex) && dart.notNull(to <= endIndex));
+        dart.assert(dart.notNull(from) >= dart.notNull(startIndex) && dart.notNull(from) <= dart.notNull(endIndex));
+        dart.assert(dart.notNull(to) >= dart.notNull(startIndex) && dart.notNull(to) <= dart.notNull(endIndex));
         this[_stringSink].write(new core.String.fromCharCodes(codeUnits, from, to));
       }
       let i = startIndex;
       loop:
         while (true) {
           multibyte:
-            if (expectedUnits > 0) {
+            if (dart.notNull(expectedUnits) > 0) {
               do {
                 if (i === endIndex) {
                   break loop;
                 }
                 let unit = codeUnits.get(i);
-                if ((unit & 192) !== 128) {
+                if ((dart.notNull(unit) & 192) !== 128) {
                   expectedUnits = 0;
                   if (!dart.notNull(this[_allowMalformed])) {
                     throw new core.FormatException(`Bad UTF-8 encoding 0x${unit.toRadixString(16)}`);
                   }
                   this[_isFirstCharacter] = false;
                   this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
                   break multibyte;
                 } else {
-                  value = value << 6 | unit & 63;
-                  expectedUnits--;
-                  i++;
+                  value = dart.notNull(value) << 6 | dart.notNull(unit) & 63;
+                  dart.notNull(expectedUnits)--;
+                  dart.notNull(i)++;
                 }
-              } while (expectedUnits > 0);
-              if (value <= _LIMITS.get(extraUnits - 1)) {
+              } while (dart.notNull(expectedUnits) > 0);
+              if (dart.notNull(value) <= dart.notNull(_LIMITS.get(dart.notNull(extraUnits) - 1))) {
                 if (!dart.notNull(this[_allowMalformed])) {
                   throw new core.FormatException(`Overlong encoding of 0x${value.toRadixString(16)}`);
                 }
                 expectedUnits = extraUnits = 0;
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
-              if (value > _FOUR_BYTE_LIMIT) {
+              if (dart.notNull(value) > dart.notNull(_FOUR_BYTE_LIMIT)) {
                 if (!dart.notNull(this[_allowMalformed])) {
                   throw new core.FormatException("Character outside valid Unicode range: " + `0x${value.toRadixString(16)}`);
                 }
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
-              if (dart.notNull(!dart.notNull(this[_isFirstCharacter])) || dart.notNull(value !== UNICODE_BOM_CHARACTER_RUNE)) {
+              if (!dart.notNull(this[_isFirstCharacter]) || value !== UNICODE_BOM_CHARACTER_RUNE) {
                 this[_stringSink].writeCharCode(value);
               }
               this[_isFirstCharacter] = false;
             }
-          while (i < endIndex) {
+          while (dart.notNull(i) < dart.notNull(endIndex)) {
             let oneBytes = scanOneByteCharacters(codeUnits, i);
-            if (oneBytes > 0) {
+            if (dart.notNull(oneBytes) > 0) {
               this[_isFirstCharacter] = false;
-              addSingleBytes(i, i + oneBytes);
+              addSingleBytes(i, dart.notNull(i) + dart.notNull(oneBytes));
               i = oneBytes;
               if (i === endIndex)
                 break;
             }
-            let unit = codeUnits.get(i++);
-            if (unit < 0) {
+            let unit = codeUnits.get(dart.notNull(i)++);
+            if (dart.notNull(unit) < 0) {
               if (!dart.notNull(this[_allowMalformed])) {
-                throw new core.FormatException(`Negative UTF-8 code unit: -0x${(-unit).toRadixString(16)}`);
+                throw new core.FormatException(`Negative UTF-8 code unit: -0x${(-dart.notNull(unit)).toRadixString(16)}`);
               }
               this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
             } else {
-              dart.assert(unit > _ONE_BYTE_LIMIT);
-              if ((unit & 224) === 192) {
-                value = unit & 31;
+              dart.assert(dart.notNull(unit) > dart.notNull(_ONE_BYTE_LIMIT));
+              if ((dart.notNull(unit) & 224) === 192) {
+                value = dart.notNull(unit) & 31;
                 expectedUnits = extraUnits = 1;
                 continue loop;
               }
-              if ((unit & 240) === 224) {
-                value = unit & 15;
+              if ((dart.notNull(unit) & 240) === 224) {
+                value = dart.notNull(unit) & 15;
                 expectedUnits = extraUnits = 2;
                 continue loop;
               }
-              if (dart.notNull((unit & 248) === 240) && dart.notNull(unit < 245)) {
-                value = unit & 7;
+              if ((dart.notNull(unit) & 248) === 240 && dart.notNull(unit) < 245) {
+                value = dart.notNull(unit) & 7;
                 expectedUnits = extraUnits = 3;
                 continue loop;
               }
               if (!dart.notNull(this[_allowMalformed])) {
                 throw new core.FormatException(`Bad UTF-8 encoding 0x${unit.toRadixString(16)}`);
               }
               value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               expectedUnits = extraUnits = 0;
               this[_isFirstCharacter] = false;
               this[_stringSink].writeCharCode(value);
             }
           }
           break loop;
         }
-      if (expectedUnits > 0) {
+      if (dart.notNull(expectedUnits) > 0) {
         this[_value] = value;
         this[_expectedUnits] = expectedUnits;
         this[_extraUnits] = extraUnits;
       }
     }
   }
   _Utf8Decoder._LIMITS = /* Unimplemented const */new List.from([_ONE_BYTE_LIMIT, _TWO_BYTE_LIMIT, _THREE_BYTE_LIMIT, _FOUR_BYTE_LIMIT]);
   // Exports:
   exports.ASCII = ASCII;
   exports.AsciiCodec = AsciiCodec;
@@ skipping 27 matching lines @@
   exports.ClosableStringSink = ClosableStringSink;
   exports.StringConversionSinkBase = StringConversionSinkBase;
   exports.StringConversionSinkMixin = StringConversionSinkMixin;
   exports.UNICODE_REPLACEMENT_CHARACTER_RUNE = UNICODE_REPLACEMENT_CHARACTER_RUNE;
   exports.UNICODE_BOM_CHARACTER_RUNE = UNICODE_BOM_CHARACTER_RUNE;
   exports.UTF8 = UTF8;
   exports.Utf8Codec = Utf8Codec;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 })(convert || (convert = {}));