fixes #206, add checking for unary ops

lib/runtime/dart/convert.js

 var convert = dart.defineLibrary(convert, {});
 var core = dart.import(core);
 var async = dart.import(async);
 var typed_data = dart.import(typed_data);
 var _internal = dart.import(_internal);
 var collection = dart.import(collection);
 (function(exports, core, async, typed_data, _internal, collection) {
   'use strict';
   let Codec$ = dart.generic(function(S, T) {
     class Codec extends core.Object {
@@ skipping 56 matching lines @@
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
     get name() {
       return "us-ascii";
     }
     decode(bytes, opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
       if (allowInvalid == null)
         allowInvalid = this[_allowInvalid];
-      if (allowInvalid) {
+      if (dart.notNull(allowInvalid)) {
         return dart.const(new AsciiDecoder({allowInvalid: true})).convert(bytes);
       } else {
         return dart.const(new AsciiDecoder({allowInvalid: false})).convert(bytes);
       }
     }
     get encoder() {
       return dart.const(new AsciiEncoder());
     }
     get decoder() {
-      return this[_allowInvalid] ? dart.const(new AsciiDecoder({allowInvalid: true})) : dart.const(new AsciiDecoder({allowInvalid: false}));
+      return dart.notNull(this[_allowInvalid]) ? dart.const(new AsciiDecoder({allowInvalid: true})) : dart.const(new AsciiDecoder({allowInvalid: false}));
     }
   }
   dart.setSignature(AsciiCodec, {
     constructors: () => ({AsciiCodec: [AsciiCodec, [], {allowInvalid: core.bool}]}),
     methods: () => ({decode: [core.String, [core.List$(core.int)], {allowInvalid: core.bool}]})
   });
   let ASCII = dart.const(new AsciiCodec());
   let _ASCII_MASK = 127;
   let Converter$ = dart.generic(function(S, T) {
     class Converter extends core.Object {
@@ skipping 107 matching lines @@
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let codeUnit = source[dartx.codeUnitAt](i);
         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[dartx.codeUnits][dartx.sublist](start, end));
-      if (isLast) {
+      if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
   dart.setSignature(_UnicodeSubsetEncoderSink, {
     constructors: () => ({_UnicodeSubsetEncoderSink: [_UnicodeSubsetEncoderSink, [core.int, ByteConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]]
     })
@@ skipping 53 matching lines @@
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       super._UnicodeSubsetDecoder(allowInvalid, _ASCII_MASK);
     }
     startChunkedConversion(sink) {
       let stringSink = null;
       if (dart.is(sink, StringConversionSink)) {
         stringSink = sink;
       } else {
         stringSink = StringConversionSink.from(sink);
       }
-      if (this[_allowInvalid]) {
+      if (dart.notNull(this[_allowInvalid])) {
         return new _ErrorHandlingAsciiDecoderSink(stringSink.asUtf8Sink(false));
       } else {
         return new _SimpleAsciiDecoderSink(stringSink);
       }
     }
   }
   dart.setSignature(AsciiDecoder, {
     constructors: () => ({AsciiDecoder: [AsciiDecoder, [], {allowInvalid: core.bool}]}),
     methods: () => ({startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]]})
   });
@@ skipping 32 matching lines @@
       withCallback: [ByteConversionSink, [dart.functionType(dart.void, [core.List$(core.int)])]],
       from: [ByteConversionSink, [core.Sink$(core.List$(core.int))]]
     })
   });
   class ByteConversionSinkBase extends ByteConversionSink {
     ByteConversionSinkBase() {
       super.ByteConversionSink();
     }
     addSlice(chunk, start, end, isLast) {
       this.add(chunk[dartx.sublist](start, end));
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
   }
   dart.setSignature(ByteConversionSinkBase, {
     methods: () => ({addSlice: [dart.void, [core.List$(core.int), core.int, core.int, core.bool]]})
   });
   let _utf8Sink = Symbol('_utf8Sink');
   class _ErrorHandlingAsciiDecoderSink extends ByteConversionSinkBase {
     _ErrorHandlingAsciiDecoderSink(utf8Sink) {
       this[_utf8Sink] = utf8Sink;
     }
     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; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         if ((dart.notNull(source[dartx.get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
           if (dart.notNull(i) > dart.notNull(start))
             this[_utf8Sink].addSlice(source, start, i, false);
           this[_utf8Sink].add(dart.const(dart.list([239, 191, 189], core.int)));
           start = dart.notNull(i) + 1;
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_utf8Sink].addSlice(source, start, end, isLast);
-      } else if (isLast) {
+      } else if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
   dart.setSignature(_ErrorHandlingAsciiDecoderSink, {
     constructors: () => ({_ErrorHandlingAsciiDecoderSink: [_ErrorHandlingAsciiDecoderSink, [ByteConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       add: [dart.void, [core.List$(core.int)]]
     })
@@ skipping 15 matching lines @@
     }
     addSlice(source, start, end, isLast) {
       let length = source.length;
       core.RangeError.checkValidRange(start, end, length);
       if (dart.notNull(start) < dart.notNull(end)) {
         if (start != 0 || end != length) {
           source = source[dartx.sublist](start, end);
         }
         this.add(source);
       }
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
   }
   dart.setSignature(_SimpleAsciiDecoderSink, {
     constructors: () => ({_SimpleAsciiDecoderSink: [_SimpleAsciiDecoderSink, [core.Sink]]}),
     methods: () => ({
       close: [dart.void, []],
       add: [dart.void, [core.List$(core.int)]]
     })
   });
@@ skipping 267 matching lines @@
             replace = '&amp;';
             break;
           }
           case ' ':
           {
             replace = '&nbsp;';
             break;
           }
           case '"':
           {
-            if (this.mode.escapeQuot)
+            if (dart.notNull(this.mode.escapeQuot))
               replace = '&quot;';
             break;
           }
           case "'":
           {
-            if (this.mode.escapeApos)
+            if (dart.notNull(this.mode.escapeApos))
               replace = '&#x27;';
             break;
           }
           case '<':
           {
-            if (this.mode.escapeLtGt)
+            if (dart.notNull(this.mode.escapeLtGt))
               replace = '&lt;';
             break;
           }
           case '>':
           {
-            if (this.mode.escapeLtGt)
+            if (dart.notNull(this.mode.escapeLtGt))
               replace = '&gt;';
             break;
           }
           case '/':
           {
-            if (this.mode.escapeSlash)
+            if (dart.notNull(this.mode.escapeSlash))
               replace = '&#x2F;';
             break;
           }
         }
         if (replace != null) {
           if (result == null)
             result = new core.StringBuffer(text[dartx.substring](start, i));
           result.write(replace);
         } else if (result != null) {
           result.write(ch);
@@ skipping 24 matching lines @@
     _HtmlEscapeSink(escape, sink) {
       this[_escape] = escape;
       this[_sink] = sink;
     }
     addSlice(chunk, start, end, isLast) {
       let val = this[_escape][_convert](chunk, start, end);
       if (val == null) {
         this[_sink].addSlice(chunk, start, end, isLast);
       } else {
         this[_sink].add(val);
-        if (isLast)
+        if (dart.notNull(isLast))
           this[_sink].close();
       }
     }
     close() {
       return this[_sink].close();
     }
   }
   dart.setSignature(_HtmlEscapeSink, {
     constructors: () => ({_HtmlEscapeSink: [_HtmlEscapeSink, [HtmlEscape, StringConversionSink]]}),
     methods: () => ({
@@ skipping 144 matching lines @@
       if (bufferSize === void 0)
         bufferSize = JsonUtf8Encoder.DEFAULT_BUFFER_SIZE;
       this[_indent] = JsonUtf8Encoder._utf8Encode(indent);
       this[_toEncodable$] = toEncodable;
       this[_bufferSize] = bufferSize;
       super.Converter();
     }
     static _utf8Encode(string) {
       if (string == null)
         return null;
-      if (string[dartx.isEmpty])
+      if (dart.notNull(string[dartx.isEmpty]))
         return typed_data.Uint8List.new(0);
       checkAscii: {
         for (let i = 0; dart.notNull(i) < dart.notNull(string.length); i = dart.notNull(i) + 1) {
           if (dart.notNull(string[dartx.codeUnitAt](i)) >= 128)
             break checkAscii;
         }
         return string[dartx.codeUnits];
       }
       return UTF8.encode(string);
     }
@@ skipping 54 matching lines @@
   let _isDone = Symbol('_isDone');
   class _JsonEncoderSink extends ChunkedConversionSink$(core.Object) {
     _JsonEncoderSink(sink, toEncodable, indent) {
       this[_sink] = sink;
       this[_toEncodable$] = toEncodable;
       this[_indent] = indent;
       this[_isDone] = false;
       super.ChunkedConversionSink();
     }
     add(o) {
-      if (this[_isDone]) {
+      if (dart.notNull(this[_isDone])) {
         throw new core.StateError("Only one call to add allowed");
       }
       this[_isDone] = true;
       let stringSink = this[_sink].asStringSink();
       _JsonStringStringifier.printOn(o, stringSink, dart.as(this[_toEncodable$], dart.functionType(core.Object, [dart.bottom])), this[_indent]);
       stringSink.close();
     }
     close() {}
   }
   dart.setSignature(_JsonEncoderSink, {
@@ skipping 10 matching lines @@
       this[_toEncodable$] = toEncodable;
       this[_indent] = indent;
       this[_bufferSize] = bufferSize;
       this[_isDone] = false;
       super.ChunkedConversionSink();
     }
     [_addChunk](chunk, start, end) {
       this[_sink].addSlice(chunk, start, end, false);
     }
     add(object) {
-      if (this[_isDone]) {
+      if (dart.notNull(this[_isDone])) {
         throw new core.StateError("Only one call to add allowed");
       }
       this[_isDone] = true;
       _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.functionType(core.Object, [core.Object])), this[_bufferSize], dart.bind(this, _addChunk));
       this[_sink].close();
     }
     close() {
       if (!dart.notNull(this[_isDone])) {
         this[_isDone] = true;
         this[_sink].close();
@@ skipping 122 matching lines @@
         }
       }
       if (offset == 0) {
         this.writeString(s);
       } else if (dart.notNull(offset) < dart.notNull(length)) {
         this.writeStringSlice(s, offset, length);
       }
     }
     [_checkCycle](object) {
       for (let i = 0; dart.notNull(i) < dart.notNull(this[_seen].length); i = dart.notNull(i) + 1) {
-        if (core.identical(object, this[_seen][dartx.get](i))) {
+        if (dart.notNull(core.identical(object, this[_seen][dartx.get](i)))) {
           throw new JsonCyclicError(object);
         }
       }
       this[_seen][dartx.add](object);
     }
     [_removeSeen](object) {
       dart.assert(!dart.notNull(this[_seen][dartx.isEmpty]));
       dart.assert(core.identical(this[_seen][dartx.last], object));
       this[_seen][dartx.removeLast]();
     }
     writeObject(object) {
-      if (this.writeJsonValue(object))
+      if (dart.notNull(this.writeJsonValue(object)))
         return;
       this[_checkCycle](object);
       try {
         let customJson = dart.dcall(this[_toEncodable$], object);
         if (!dart.notNull(this.writeJsonValue(customJson))) {
           throw new JsonUnsupportedObjectError(object);
         }
         this[_removeSeen](object);
       } catch (e) {
         throw new JsonUnsupportedObjectError(object, {cause: e});
       }
 
     }
     writeJsonValue(object) {
       if (dart.is(object, core.num)) {
-        if (dart.dsend(dart.dload(object, 'isFinite'), '!'))
+        if (!dart.notNull(dart.as(dart.dload(object, 'isFinite'), core.bool)))
           return false;
         this.writeNumber(dart.as(object, core.num));
         return true;
-      } else if (core.identical(object, true)) {
+      } else if (dart.notNull(core.identical(object, true))) {
         this.writeString('true');
         return true;
-      } else if (core.identical(object, false)) {
+      } else if (dart.notNull(core.identical(object, false))) {
         this.writeString('false');
         return true;
       } else if (object == null) {
         this.writeString('null');
         return true;
       } else if (typeof object == 'string') {
         this.writeString('"');
         this.writeStringContent(dart.as(object, core.String));
         this.writeString('"');
         return true;
@@ skipping 62 matching lines @@
   _JsonStringifier.CHAR_n = 110;
   _JsonStringifier.CHAR_r = 114;
   _JsonStringifier.CHAR_t = 116;
   _JsonStringifier.CHAR_u = 117;
   let _indentLevel = Symbol('_indentLevel');
   class _JsonPrettyPrintMixin extends core.Object {
     _JsonPrettyPrintMixin() {
       this[_indentLevel] = 0;
     }
     writeList(list) {
-      if (list[dartx.isEmpty]) {
+      if (dart.notNull(list[dartx.isEmpty])) {
         this.writeString('[]');
       } else {
         this.writeString('[\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
         this.writeIndentation(this[_indentLevel]);
         this.writeObject(list[dartx.get](0));
         for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart.notNull(i) + 1) {
           this.writeString(',\n');
           this.writeIndentation(this[_indentLevel]);
           this.writeObject(list[dartx.get](i));
         }
         this.writeString('\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
         this.writeIndentation(this[_indentLevel]);
         this.writeString(']');
       }
     }
     writeMap(map) {
-      if (map.isEmpty) {
+      if (dart.notNull(map.isEmpty)) {
         this.writeString('{}');
       } else {
         this.writeString('{\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
         let first = true;
         map.forEach(dart.fn((key, value) => {
           if (!dart.notNull(first)) {
             this.writeString(",\n");
           }
           this.writeIndentation(this[_indentLevel]);
@@ skipping 235 matching lines @@
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
     get name() {
       return "iso-8859-1";
     }
     decode(bytes, opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
       if (allowInvalid == null)
         allowInvalid = this[_allowInvalid];
-      if (allowInvalid) {
+      if (dart.notNull(allowInvalid)) {
         return dart.const(new Latin1Decoder({allowInvalid: true})).convert(bytes);
       } else {
         return dart.const(new Latin1Decoder({allowInvalid: false})).convert(bytes);
       }
     }
     get encoder() {
       return dart.const(new Latin1Encoder());
     }
     get decoder() {
-      return this[_allowInvalid] ? dart.const(new Latin1Decoder({allowInvalid: true})) : dart.const(new Latin1Decoder({allowInvalid: false}));
+      return dart.notNull(this[_allowInvalid]) ? dart.const(new Latin1Decoder({allowInvalid: true})) : dart.const(new Latin1Decoder({allowInvalid: false}));
     }
   }
   dart.setSignature(Latin1Codec, {
     constructors: () => ({Latin1Codec: [Latin1Codec, [], {allowInvalid: core.bool}]}),
     methods: () => ({decode: [core.String, [core.List$(core.int)], {allowInvalid: core.bool}]})
   });
   let LATIN1 = dart.const(new Latin1Codec());
   let _LATIN1_MASK = 255;
   class Latin1Encoder extends _UnicodeSubsetEncoder {
     Latin1Encoder() {
@@ skipping 30 matching lines @@
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     add(source) {
       this.addSlice(source, 0, source.length, false);
     }
     [_addSliceToSink](source, start, end, isLast) {
       this[_sink].add(core.String.fromCharCodes(source, start, end));
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let char = source[dartx.get](i);
         if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
           throw new core.FormatException("Source contains non-Latin-1 characters.");
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
-      if (isLast) {
+      if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
   dart.setSignature(_Latin1DecoderSink, {
     constructors: () => ({_Latin1DecoderSink: [_Latin1DecoderSink, [StringConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       add: [dart.void, [core.List$(core.int)]],
       [_addSliceToSink]: [dart.void, [core.List$(core.int), core.int, core.int, core.bool]]
@@ skipping 10 matching lines @@
         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.const(dart.list([65533], core.int)), 0, 1, false);
           start = dart.notNull(i) + 1;
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
-      if (isLast) {
+      if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
   dart.setSignature(_Latin1AllowInvalidDecoderSink, {
     constructors: () => ({_Latin1AllowInvalidDecoderSink: [_Latin1AllowInvalidDecoderSink, [StringConversionSink]]})
   });
   class LineSplitter extends Converter$(core.String, core.List$(core.String)) {
     LineSplitter() {
       super.Converter();
@@ skipping 24 matching lines @@
       this[_carry] = null;
     }
     addSlice(chunk, start, end, isLast) {
       if (this[_carry] != null) {
         chunk = dart.notNull(this[_carry]) + dart.notNull(chunk[dartx.substring](start, end));
         start = 0;
         end = chunk.length;
         this[_carry] = null;
       }
       this[_carry] = _LineSplitterSink._addSlice(chunk, start, end, isLast, dart.bind(this[_sink], 'add'));
-      if (isLast)
+      if (dart.notNull(isLast))
         this[_sink].close();
     }
     close() {
       this.addSlice('', 0, 0, true);
     }
     static _addSlice(chunk, start, end, isLast, adder) {
       let pos = start;
       while (dart.notNull(pos) < dart.notNull(end)) {
         let skip = 0;
         let char = chunk[dartx.codeUnitAt](pos);
@@ skipping 11 matching lines @@
         }
         if (dart.notNull(skip) > 0) {
           adder(chunk[dartx.substring](start, pos));
           start = pos = dart.notNull(pos) + dart.notNull(skip);
         } else {
           pos = dart.notNull(pos) + 1;
         }
       }
       if (pos != start) {
         let carry = chunk[dartx.substring](start, pos);
-        if (isLast) {
+        if (dart.notNull(isLast)) {
           adder(carry);
         } else {
           return carry;
         }
       }
       return null;
     }
   }
   dart.setSignature(_LineSplitterSink, {
     constructors: () => ({_LineSplitterSink: [_LineSplitterSink, [StringConversionSink]]}),
@@ skipping 73 matching lines @@
       writeAll: [dart.void, [core.Iterable], [core.String]]
     })
   });
   let _flush = Symbol('_flush');
   class _StringConversionSinkAsStringSinkAdapter extends core.Object {
     _StringConversionSinkAsStringSinkAdapter(chunkedSink) {
       this[_chunkedSink] = chunkedSink;
       this[_buffer] = new core.StringBuffer();
     }
     close() {
-      if (this[_buffer].isNotEmpty)
+      if (dart.notNull(this[_buffer].isNotEmpty))
         this[_flush]();
       this[_chunkedSink].close();
     }
     writeCharCode(charCode) {
       this[_buffer].writeCharCode(charCode);
       if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE))
         this[_flush]();
     }
     write(o) {
-      if (this[_buffer].isNotEmpty)
+      if (dart.notNull(this[_buffer].isNotEmpty))
         this[_flush]();
       let str = dart.toString(o);
       this[_chunkedSink].add(dart.toString(o));
     }
     writeln(o) {
       if (o === void 0)
         o = "";
       this[_buffer].writeln(o);
       if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE))
         this[_flush]();
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
-      if (this[_buffer].isNotEmpty)
+      if (dart.notNull(this[_buffer].isNotEmpty))
         this[_flush]();
       let iterator = objects[dartx.iterator];
       if (!dart.notNull(iterator.moveNext()))
         return;
-      if (separator[dartx.isEmpty]) {
+      if (dart.notNull(separator[dartx.isEmpty])) {
         do {
           this[_chunkedSink].add(dart.toString(iterator.current));
-        } while (iterator.moveNext());
+        } while (dart.notNull(iterator.moveNext()));
       } else {
         this[_chunkedSink].add(dart.toString(iterator.current));
-        while (iterator.moveNext()) {
+        while (dart.notNull(iterator.moveNext())) {
           this.write(separator);
           this[_chunkedSink].add(dart.toString(iterator.current));
         }
       }
     }
     [_flush]() {
       let accumulated = dart.toString(this[_buffer]);
       this[_buffer].clear();
       this[_chunkedSink].add(accumulated);
     }
@@ skipping 18 matching lines @@
     }
     close() {}
     addSlice(str, start, end, isLast) {
       if (start != 0 || end != str.length) {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           this[_stringSink].writeCharCode(str[dartx.codeUnitAt](i));
         }
       } else {
         this[_stringSink].write(str);
       }
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
     add(str) {
       return this[_stringSink].write(str);
     }
     asUtf8Sink(allowMalformed) {
       return new _Utf8StringSinkAdapter(this, this[_stringSink], allowMalformed);
     }
     asStringSink() {
       return ClosableStringSink.fromStringSink(this[_stringSink], dart.bind(this, 'close'));
@@ skipping 30 matching lines @@
     }
     add(str) {
       return this[_sink].add(str);
     }
     addSlice(str, start, end, isLast) {
       if (start == 0 && end == str.length) {
         this.add(str);
       } else {
         this.add(str[dartx.substring](start, end));
       }
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
     close() {
       return this[_sink].close();
     }
   }
   dart.setSignature(_StringAdapterSink, {
     constructors: () => ({_StringAdapterSink: [_StringAdapterSink, [core.Sink$(core.String)]]}),
     methods: () => ({
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]],
@@ skipping 10 matching lines @@
     close() {
       this[_decoder].close();
       if (this[_sink] != null)
         this[_sink].close();
     }
     add(chunk) {
       this.addSlice(chunk, 0, chunk.length, false);
     }
     addSlice(codeUnits, startIndex, endIndex, isLast) {
       this[_decoder].convert(codeUnits, startIndex, endIndex);
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
   }
   dart.setSignature(_Utf8StringSinkAdapter, {
     constructors: () => ({_Utf8StringSinkAdapter: [_Utf8StringSinkAdapter, [core.Sink, core.StringSink, core.bool]]}),
     methods: () => ({
       close: [dart.void, []],
       add: [dart.void, [core.List$(core.int)]],
       addSlice: [dart.void, [core.List$(core.int), core.int, core.int, core.bool]]
     })
   });
   class _Utf8ConversionSink extends ByteConversionSink {
     _Utf8ConversionSink(sink, allowMalformed) {
       this._(sink, new core.StringBuffer(), allowMalformed);
     }
     _(chunkedSink, stringBuffer, allowMalformed) {
       this[_chunkedSink] = chunkedSink;
       this[_decoder] = new _Utf8Decoder(stringBuffer, allowMalformed);
       this[_buffer] = stringBuffer;
       super.ByteConversionSink();
     }
     close() {
       this[_decoder].close();
-      if (this[_buffer].isNotEmpty) {
+      if (dart.notNull(this[_buffer].isNotEmpty)) {
         let accumulated = dart.toString(this[_buffer]);
         this[_buffer].clear();
         this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, true);
       } else {
         this[_chunkedSink].close();
       }
     }
     add(chunk) {
       this.addSlice(chunk, 0, chunk.length, false);
     }
     addSlice(chunk, startIndex, endIndex, isLast) {
       this[_decoder].convert(chunk, startIndex, endIndex);
-      if (this[_buffer].isNotEmpty) {
+      if (dart.notNull(this[_buffer].isNotEmpty)) {
         let accumulated = dart.toString(this[_buffer]);
         this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, isLast);
         this[_buffer].clear();
         return;
       }
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
   }
   dart.defineNamedConstructor(_Utf8ConversionSink, '_');
   dart.setSignature(_Utf8ConversionSink, {
     constructors: () => ({
       _Utf8ConversionSink: [_Utf8ConversionSink, [StringConversionSink, core.bool]],
       _: [_Utf8ConversionSink, [StringConversionSink, core.StringBuffer, core.bool]]
     }),
     methods: () => ({
@@ skipping 85 matching lines @@
     }
     withBufferSize(bufferSize) {
       this[_buffer] = _Utf8Encoder._createBuffer(bufferSize);
       this[_carry] = 0;
       this[_bufferIndex] = 0;
     }
     static _createBuffer(size) {
       return typed_data.Uint8List.new(size);
     }
     [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
-      if (_isTailSurrogate(nextCodeUnit)) {
+      if (dart.notNull(_isTailSurrogate(nextCodeUnit))) {
         let rune = _combineSurrogatePair(leadingSurrogate, nextCodeUnit);
         dart.assert(dart.notNull(rune) > dart.notNull(_THREE_BYTE_LIMIT));
         dart.assert(dart.notNull(rune) <= dart.notNull(_FOUR_BYTE_LIMIT));
         this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 240 | dart.notNull(rune) >> 18);
         this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
@@ skipping 38 matching lines @@
       for (stringIndex = start; dart.notNull(stringIndex) < dart.notNull(end); stringIndex = dart.notNull(stringIndex) + 1) {
         let codeUnit = str[dartx.codeUnitAt](stringIndex);
         if (dart.notNull(codeUnit) <= dart.notNull(_ONE_BYTE_LIMIT)) {
           if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer].length))
             break;
           this[_buffer][dartx.set]((() => {
             let x = this[_bufferIndex];
             this[_bufferIndex] = dart.notNull(x) + 1;
             return x;
           })(), codeUnit);
-        } else if (_isLeadSurrogate(codeUnit)) {
+        } else if (dart.notNull(_isLeadSurrogate(codeUnit))) {
           if (dart.notNull(this[_bufferIndex]) + 3 >= dart.notNull(this[_buffer].length))
             break;
           let nextCodeUnit = str[dartx.codeUnitAt](dart.notNull(stringIndex) + 1);
           let wasCombined = this[_writeSurrogate](codeUnit, nextCodeUnit);
-          if (wasCombined) {
+          if (dart.notNull(wasCombined)) {
             stringIndex = dart.notNull(stringIndex) + 1;
           }
         } else {
           let rune = codeUnit;
           if (dart.notNull(rune) <= dart.notNull(_TWO_BYTE_LIMIT)) {
             if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer].length))
               break;
             this[_buffer][dartx.set]((() => {
               let x = this[_bufferIndex];
               this[_bufferIndex] = dart.notNull(x) + 1;
@@ skipping 62 matching lines @@
       }
       if (this[_carry] != 0) {
         let nextCodeUnit = 0;
         if (start != end) {
           nextCodeUnit = str[dartx.codeUnitAt](start);
         } else {
           dart.assert(isLast);
         }
         let wasCombined = this[_writeSurrogate](this[_carry], nextCodeUnit);
         dart.assert(!dart.notNull(wasCombined) || start != end);
-        if (wasCombined) {
+        if (dart.notNull(wasCombined)) {
           start = dart.notNull(start) + 1;
         }
         this[_carry] = 0;
       }
       do {
         start = this[_fillBuffer](str, start, end);
         let isLastSlice = dart.notNull(isLast) && start == end;
         if (start == dart.notNull(end) - 1 && dart.notNull(_isLeadSurrogate(str[dartx.codeUnitAt](start)))) {
           if (dart.notNull(isLast) && dart.notNull(this[_bufferIndex]) < dart.notNull(this[_buffer].length) - 3) {
             let hasBeenCombined = this[_writeSurrogate](str[dartx.codeUnitAt](start), 0);
             dart.assert(!dart.notNull(hasBeenCombined));
           } else {
             this[_carry] = str[dartx.codeUnitAt](start);
           }
           start = dart.notNull(start) + 1;
         }
         this[_sink].addSlice(this[_buffer], 0, this[_bufferIndex], isLastSlice);
         this[_bufferIndex] = 0;
       } while (dart.notNull(start) < dart.notNull(end));
-      if (isLast)
+      if (dart.notNull(isLast))
         this.close();
     }
   }
   dart.setSignature(_Utf8EncoderSink, {
     constructors: () => ({_Utf8EncoderSink: [_Utf8EncoderSink, [ByteConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]]
     })
   });
@@ skipping 81 matching lines @@
       this[_expectedUnits] = 0;
       this[_extraUnits] = 0;
     }
     get hasPartialInput() {
       return dart.notNull(this[_expectedUnits]) > 0;
     }
     close() {
       this.flush();
     }
     flush() {
-      if (this.hasPartialInput) {
+      if (dart.notNull(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) {
@@ skipping 177 matching lines @@
   let _upgradedMap = Symbol('_upgradedMap');
   let _process = Symbol('_process');
   let _upgrade = Symbol('_upgrade');
   class _JsonMap extends core.Object {
     _JsonMap(original) {
       this[_processed] = _JsonMap._newJavaScriptObject();
       this[_original] = original;
       this[_data] = null;
     }
     get(key) {
-      if (this[_isUpgraded]) {
+      if (dart.notNull(this[_isUpgraded])) {
         return this[_upgradedMap].get(key);
       } else if (!(typeof key == 'string')) {
         return null;
       } else {
         let result = _JsonMap._getProperty(this[_processed], dart.as(key, core.String));
-        if (_JsonMap._isUnprocessed(result))
+        if (dart.notNull(_JsonMap._isUnprocessed(result)))
           result = this[_process](dart.as(key, core.String));
         return result;
       }
     }
     get length() {
-      return this[_isUpgraded] ? this[_upgradedMap].length : this[_computeKeys]().length;
+      return dart.notNull(this[_isUpgraded]) ? this[_upgradedMap].length : this[_computeKeys]().length;
     }
     get isEmpty() {
       return this.length == 0;
     }
     get isNotEmpty() {
       return dart.notNull(this.length) > 0;
     }
     get keys() {
-      if (this[_isUpgraded])
+      if (dart.notNull(this[_isUpgraded]))
         return this[_upgradedMap].keys;
       return new _JsonMapKeyIterable(this);
     }
     get values() {
-      if (this[_isUpgraded])
+      if (dart.notNull(this[_isUpgraded]))
         return this[_upgradedMap].values;
       return _internal.MappedIterable.new(this[_computeKeys](), dart.fn(each => this.get(each)));
     }
     set(key, value) {
-      if (this[_isUpgraded]) {
+      if (dart.notNull(this[_isUpgraded])) {
         this[_upgradedMap].set(key, value);
-      } else if (this.containsKey(key)) {
+      } else if (dart.notNull(this.containsKey(key))) {
         let processed = this[_processed];
         _JsonMap._setProperty(processed, dart.as(key, core.String), value);
         let original = this[_original];
         if (!dart.notNull(core.identical(original, processed))) {
           _JsonMap._setProperty(original, dart.as(key, core.String), null);
         }
       } else {
         this[_upgrade]().set(key, value);
       }
     }
     addAll(other) {
       other.forEach(dart.fn((key, value) => {
         this.set(key, value);
       }));
     }
     containsValue(value) {
-      if (this[_isUpgraded])
+      if (dart.notNull(this[_isUpgraded]))
         return this[_upgradedMap].containsValue(value);
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         let key = keys[dartx.get](i);
         if (dart.equals(this.get(key), value))
           return true;
       }
       return false;
     }
     containsKey(key) {
-      if (this[_isUpgraded])
+      if (dart.notNull(this[_isUpgraded]))
         return this[_upgradedMap].containsKey(key);
       if (!(typeof key == 'string'))
         return false;
       return _JsonMap._hasProperty(this[_original], dart.as(key, core.String));
     }
     putIfAbsent(key, ifAbsent) {
-      if (this.containsKey(key))
+      if (dart.notNull(this.containsKey(key)))
         return this.get(key);
       let value = ifAbsent();
       this.set(key, value);
       return value;
     }
     remove(key) {
       if (!dart.notNull(this[_isUpgraded]) && !dart.notNull(this.containsKey(key)))
         return null;
       return this[_upgrade]().remove(key);
     }
     clear() {
-      if (this[_isUpgraded]) {
+      if (dart.notNull(this[_isUpgraded])) {
         this[_upgradedMap].clear();
       } else {
         if (this[_data] != null) {
           dart.dsend(this[_data], 'clear');
         }
         this[_original] = this[_processed] = null;
         this[_data] = dart.map();
       }
     }
     forEach(f) {
-      if (this[_isUpgraded])
+      if (dart.notNull(this[_isUpgraded]))
         return this[_upgradedMap].forEach(f);
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         let key = keys[dartx.get](i);
         let value = _JsonMap._getProperty(this[_processed], key);
-        if (_JsonMap._isUnprocessed(value)) {
+        if (dart.notNull(_JsonMap._isUnprocessed(value))) {
           value = _convertJsonToDartLazy(_JsonMap._getProperty(this[_original], key));
           _JsonMap._setProperty(this[_processed], key, value);
         }
         dart.dcall(f, key, value);
         if (!dart.notNull(core.identical(keys, this[_data]))) {
           throw new core.ConcurrentModificationError(this);
         }
       }
     }
     toString() {
       return collection.Maps.mapToString(this);
     }
     get [_isUpgraded]() {
       return this[_processed] == null;
     }
     get [_upgradedMap]() {
       dart.assert(this[_isUpgraded]);
       return dart.as(this[_data], core.Map);
     }
     [_computeKeys]() {
       dart.assert(!dart.notNull(this[_isUpgraded]));
       let keys = dart.as(this[_data], core.List);
       if (keys == null) {
         keys = this[_data] = _JsonMap._getPropertyNames(this[_original]);
       }
       return dart.as(keys, core.List$(core.String));
     }
     [_upgrade]() {
-      if (this[_isUpgraded])
+      if (dart.notNull(this[_isUpgraded]))
         return this[_upgradedMap];
       let result = dart.map();
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         let key = keys[dartx.get](i);
         result.set(key, this.get(key));
       }
-      if (keys[dartx.isEmpty]) {
+      if (dart.notNull(keys[dartx.isEmpty])) {
         keys[dartx.add](null);
       } else {
         keys[dartx.clear]();
       }
       this[_original] = this[_processed] = null;
       this[_data] = result;
       dart.assert(this[_isUpgraded]);
       return result;
     }
     [_process](key) {
@@ skipping 51 matching lines @@
   let _parent = Symbol('_parent');
   class _JsonMapKeyIterable extends _internal.ListIterable {
     _JsonMapKeyIterable(parent) {
       this[_parent] = parent;
       super.ListIterable();
     }
     get length() {
       return this[_parent].length;
     }
     elementAt(index) {
-      return this[_parent][_isUpgraded] ? dart.as(this[_parent].keys[dartx.elementAt](index), core.String) : this[_parent][_computeKeys]()[dartx.get](index);
+      return dart.notNull(this[_parent][_isUpgraded]) ? dart.as(this[_parent].keys[dartx.elementAt](index), core.String) : this[_parent][_computeKeys]()[dartx.get](index);
     }
     get iterator() {
-      return this[_parent][_isUpgraded] ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys]()[dartx.iterator];
+      return dart.notNull(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys]()[dartx.iterator];
     }
     contains(key) {
       return this[_parent].containsKey(key);
     }
   }
   dart.setSignature(_JsonMapKeyIterable, {
     constructors: () => ({_JsonMapKeyIterable: [_JsonMapKeyIterable, [_JsonMap]]}),
     methods: () => ({elementAt: [core.String, [core.int]]})
   });
   class _JsonDecoderSink extends _StringSinkConversionSink {
@@ skipping 48 matching lines @@
   exports.LineSplitter = LineSplitter;
   exports.StringConversionSink = StringConversionSink;
   exports.ClosableStringSink = ClosableStringSink;
   exports.UNICODE_REPLACEMENT_CHARACTER_RUNE = UNICODE_REPLACEMENT_CHARACTER_RUNE;
   exports.UNICODE_BOM_CHARACTER_RUNE = UNICODE_BOM_CHARACTER_RUNE;
   exports.Utf8Codec = Utf8Codec;
   exports.UTF8 = UTF8;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 })(convert, core, async, typed_data, _internal, collection);