fixes #40, extension methods for primitive types

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 32 matching lines @@
     }
     decodeStream(byteStream) {
       return dart.as(byteStream.transform(this.decoder).fold(new core.StringBuffer(), dart.fn((buffer, string) => ((() => {
         dart.dsend(buffer, 'write', string);
         return buffer;
       })()))).then(dart.fn(buffer => dart.toString(buffer), core.String, [core.Object])), async.Future$(core.String));
     }
     static getByName(name) {
       if (name == null)
         return null;
-      name = name.toLowerCase();
+      name = name[dartx.toLowerCase]();
       return Encoding._nameToEncoding.get(name);
     }
   }
   dart.setSignature(Encoding, {
     constructors: () => ({Encoding: [Encoding, []]}),
     methods: () => ({decodeStream: [async.Future$(core.String), [async.Stream$(core.List$(core.int))]]}),
     statics: () => ({getByName: [Encoding, [core.String]]}),
     names: ['getByName']
   });
   let _allowInvalid = Symbol('_allowInvalid');
@@ skipping 69 matching lines @@
         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 = dart.notNull(end) - dart.notNull(start);
       let result = typed_data.Uint8List.new(length);
       for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-        let codeUnit = string.codeUnitAt(dart.notNull(start) + dart.notNull(i));
+        let codeUnit = string[dartx.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[core.$set](i, codeUnit);
+        result[dartx.set](i, codeUnit);
       }
       return dart.as(result, core.List$(core.int));
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = ByteConversionSink.from(sink);
       }
       return new _UnicodeSubsetEncoderSink(this[_subsetMask], dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
@@ skipping 41 matching lines @@
     _UnicodeSubsetEncoderSink(subsetMask, sink) {
       this[_subsetMask] = subsetMask;
       this[_sink] = sink;
     }
     close() {
       this[_sink].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 codeUnit = source.codeUnitAt(i);
+        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.codeUnits[core.$sublist](start, end));
+      this[_sink].add(source[dartx.codeUnits][dartx.sublist](start, end));
       if (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]]
     })
   });
   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[core.$length];
+      let byteCount = bytes.length;
       core.RangeError.checkValidRange(start, end, byteCount);
       if (end == null)
         end = byteCount;
       let length = dart.notNull(end) - dart.notNull(start);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        let byte = bytes[core.$get](i);
+        let byte = bytes[dartx.get](i);
         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 core.String.fromCharCodes(bytes, start, end);
     }
     [_convertInvalid](bytes, start, end) {
       let buffer = new core.StringBuffer();
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        let value = bytes[core.$get](i);
+        let value = bytes[dartx.get](i);
         if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0)
           value = 65533;
         buffer.writeCharCode(value);
       }
       return dart.toString(buffer);
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
@@ skipping 62 matching lines @@
       ByteConversionSink: [ByteConversionSink, []],
       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[core.$sublist](start, end));
+      this.add(chunk[dartx.sublist](start, end));
       if (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[core.$length], false);
+      this.addSlice(source, 0, source.length, false);
     }
     addSlice(source, start, end, isLast) {
-      core.RangeError.checkValidRange(start, end, source[core.$length]);
+      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[core.$get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
+        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.setType([239, 191, 189], core.List$(core.int))));
+          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) {
         this.close();
       }
     }
   }
   dart.setSignature(_ErrorHandlingAsciiDecoderSink, {
     constructors: () => ({_ErrorHandlingAsciiDecoderSink: [_ErrorHandlingAsciiDecoderSink, [ByteConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       add: [dart.void, [core.List$(core.int)]]
     })
   });
   class _SimpleAsciiDecoderSink extends ByteConversionSinkBase {
     _SimpleAsciiDecoderSink(sink) {
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     add(source) {
-      for (let i = 0; dart.notNull(i) < dart.notNull(source[core.$length]); i = dart.notNull(i) + 1) {
-        if ((dart.notNull(source[core.$get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(source.length); i = dart.notNull(i) + 1) {
+        if ((dart.notNull(source[dartx.get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
           throw new core.FormatException("Source contains non-ASCII bytes.");
         }
       }
       this[_sink].add(core.String.fromCharCodes(source));
     }
     addSlice(source, start, end, isLast) {
-      let length = source[core.$length];
+      let length = source.length;
       core.RangeError.checkValidRange(start, end, length);
       if (dart.notNull(start) < dart.notNull(end)) {
         if (start != 0 || end != length) {
-          source = source[core.$sublist](start, end);
+          source = source[dartx.sublist](start, end);
         }
         this.add(source);
       }
       if (isLast)
         this.close();
     }
   }
   dart.setSignature(_SimpleAsciiDecoderSink, {
     constructors: () => ({_SimpleAsciiDecoderSink: [_SimpleAsciiDecoderSink, [core.Sink]]}),
     methods: () => ({
@@ skipping 22 matching lines @@
   let _buffer = Symbol('_buffer');
   let _callback = Symbol('_callback');
   let _bufferIndex = Symbol('_bufferIndex');
   class _ByteCallbackSink extends ByteConversionSinkBase {
     _ByteCallbackSink(callback) {
       this[_buffer] = typed_data.Uint8List.new(_ByteCallbackSink._INITIAL_BUFFER_SIZE);
       this[_callback] = callback;
       this[_bufferIndex] = 0;
     }
     add(chunk) {
-      let freeCount = dart.notNull(this[_buffer][core.$length]) - dart.notNull(this[_bufferIndex]);
-      if (dart.notNull(chunk[core.$length]) > dart.notNull(freeCount)) {
-        let oldLength = this[_buffer][core.$length];
-        let newLength = dart.notNull(_ByteCallbackSink._roundToPowerOf2(dart.notNull(chunk[core.$length]) + dart.notNull(oldLength))) * 2;
+      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 = dart.notNull(_ByteCallbackSink._roundToPowerOf2(dart.notNull(chunk.length) + dart.notNull(oldLength))) * 2;
         let grown = typed_data.Uint8List.new(newLength);
-        grown[core.$setRange](0, this[_buffer][core.$length], this[_buffer]);
+        grown[dartx.setRange](0, this[_buffer].length, this[_buffer]);
         this[_buffer] = grown;
       }
-      this[_buffer][core.$setRange](this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[core.$length]), chunk);
-      this[_bufferIndex] = dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[core.$length]);
+      this[_buffer][dartx.setRange](this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk.length), chunk);
+      this[_bufferIndex] = dart.notNull(this[_bufferIndex]) + dart.notNull(chunk.length);
     }
     static _roundToPowerOf2(v) {
       dart.assert(dart.notNull(v) > 0);
       v = dart.notNull(v) - 1;
       v = dart.notNull(v) | dart.notNull(v) >> 1;
       v = dart.notNull(v) | dart.notNull(v) >> 2;
       v = dart.notNull(v) | dart.notNull(v) >> 4;
       v = dart.notNull(v) | dart.notNull(v) >> 8;
       v = dart.notNull(v) | dart.notNull(v) >> 16;
       v = dart.notNull(v) + 1;
       return v;
     }
     close() {
-      this[_callback](this[_buffer][core.$sublist](0, this[_bufferIndex]));
+      this[_callback](this[_buffer][dartx.sublist](0, this[_bufferIndex]));
     }
   }
   dart.setSignature(_ByteCallbackSink, {
     constructors: () => ({_ByteCallbackSink: [_ByteCallbackSink, [dart.functionType(dart.void, [core.List$(core.int)])]]}),
     methods: () => ({
       add: [dart.void, [core.Iterable$(core.int)]],
       close: [dart.void, []]
     }),
     statics: () => ({_roundToPowerOf2: [core.int, [core.int]]}),
     names: ['_roundToPowerOf2']
   });
   _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
   let _ChunkedConversionCallback$ = dart.generic(function(T) {
     let _ChunkedConversionCallback = dart.typedef('_ChunkedConversionCallback', () => dart.functionType(dart.void, [T]));
     return _ChunkedConversionCallback;
   });
   let _ChunkedConversionCallback = _ChunkedConversionCallback$();
   let _accumulated = Symbol('_accumulated');
   let _SimpleCallbackSink$ = dart.generic(function(T) {
     class _SimpleCallbackSink extends ChunkedConversionSink$(T) {
       _SimpleCallbackSink(callback) {
-        this[_accumulated] = dart.setType([], core.List$(T));
+        this[_accumulated] = dart.list([], T);
         this[_callback] = callback;
         super.ChunkedConversionSink();
       }
       add(chunk) {
         dart.as(chunk, T);
-        this[_accumulated][core.$add](chunk);
+        this[_accumulated][dartx.add](chunk);
       }
       close() {
         this[_callback](this[_accumulated]);
       }
     }
     dart.setSignature(_SimpleCallbackSink, {
       constructors: () => ({_SimpleCallbackSink: [_SimpleCallbackSink$(T), [_ChunkedConversionCallback$(core.List$(T))]]}),
       methods: () => ({
         add: [dart.void, [T]],
         close: [dart.void, []]
@@ skipping 162 matching lines @@
       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; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        let ch = text.get(i);
+        let ch = text[dartx.get](i);
         let replace = null;
         switch (ch) {
           case '&':
           {
             replace = '&amp;';
             break;
           }
           case ' ':
           {
             replace = '&nbsp;';
@@ skipping 25 matching lines @@
           }
           case '/':
           {
             if (this.mode.escapeSlash)
               replace = '&#x2F;';
             break;
           }
         }
         if (replace != null) {
           if (result == null)
-            result = new core.StringBuffer(text.substring(start, i));
+            result = new core.StringBuffer(text[dartx.substring](start, i));
           result.write(replace);
         } else if (result != null) {
           result.write(ch);
         }
       }
       return result != null ? dart.toString(result) : null;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
         sink = StringConversionSink.from(sink);
@@ skipping 182 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.isEmpty)
+      if (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.codeUnitAt(i)) >= 128)
+          if (dart.notNull(string[dartx.codeUnitAt](i)) >= 128)
             break checkAscii;
         }
-        return string.codeUnits;
+        return string[dartx.codeUnits];
       }
       return UTF8.encode(string);
     }
     convert(object) {
-      let bytes = dart.setType([], core.List$(core.List$(core.int)));
+      let bytes = dart.list([], core.List$(core.int));
       let addChunk = (chunk, start, end) => {
-        if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk[core.$length])) {
+        if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk.length)) {
           let length = dart.notNull(end) - dart.notNull(start);
           chunk = typed_data.Uint8List.view(chunk.buffer, dart.notNull(chunk.offsetInBytes) + dart.notNull(start), length);
         }
-        bytes[core.$add](chunk);
+        bytes[dartx.add](chunk);
       };
       dart.fn(addChunk, dart.void, [typed_data.Uint8List, core.int, core.int]);
       _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.functionType(core.Object, [core.Object])), this[_bufferSize], addChunk);
-      if (bytes[core.$length] == 1)
-        return bytes[core.$get](0);
+      if (bytes.length == 1)
+        return bytes[dartx.get](0);
       let length = 0;
-      for (let i = 0; dart.notNull(i) < dart.notNull(bytes[core.$length]); i = dart.notNull(i) + 1) {
-        length = dart.notNull(length) + dart.notNull(bytes[core.$get](i)[core.$length]);
+      for (let i = 0; dart.notNull(i) < dart.notNull(bytes.length); i = dart.notNull(i) + 1) {
+        length = dart.notNull(length) + dart.notNull(bytes[dartx.get](i).length);
       }
       let result = typed_data.Uint8List.new(length);
-      for (let i = 0, offset = 0; dart.notNull(i) < dart.notNull(bytes[core.$length]); i = dart.notNull(i) + 1) {
-        let byteList = bytes[core.$get](i);
-        let end = dart.notNull(offset) + dart.notNull(byteList[core.$length]);
-        result[core.$setRange](offset, end, byteList);
+      for (let i = 0, offset = 0; dart.notNull(i) < dart.notNull(bytes.length); i = dart.notNull(i) + 1) {
+        let byteList = bytes[dartx.get](i);
+        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 {
         byteSink = ByteConversionSink.from(sink);
@@ skipping 136 matching lines @@
       this[_seen] = core.List.new();
       this[_toEncodable$] = _toEncodable != null ? _toEncodable : _defaultToEncodable;
     }
     static hexDigit(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; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-        let charCode = s.codeUnitAt(i);
+        let charCode = s[dartx.codeUnitAt](i);
         if (dart.notNull(charCode) > dart.notNull(_JsonStringifier.BACKSLASH))
           continue;
         if (dart.notNull(charCode) < 32) {
           if (dart.notNull(i) > dart.notNull(offset))
             this.writeStringSlice(s, offset, i);
           offset = dart.notNull(i) + 1;
           this.writeCharCode(_JsonStringifier.BACKSLASH);
           switch (charCode) {
             case _JsonStringifier.BACKSPACE:
             {
@@ skipping 38 matching lines @@
           this.writeCharCode(charCode);
         }
       }
       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][core.$length]); i = dart.notNull(i) + 1) {
-        if (core.identical(object, this[_seen][core.$get](i))) {
+      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))) {
           throw new JsonCyclicError(object);
         }
       }
-      this[_seen][core.$add](object);
+      this[_seen][dartx.add](object);
     }
     [_removeSeen](object) {
-      dart.assert(!dart.notNull(this[_seen][core.$isEmpty]));
-      dart.assert(core.identical(this[_seen][core.$last], object));
-      this[_seen][core.$removeLast]();
+      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))
         return;
       this[_checkCycle](object);
       try {
         let customJson = dart.dcall(this[_toEncodable$], object);
         if (!dart.notNull(this.writeJsonValue(customJson))) {
           throw new JsonUnsupportedObjectError(object);
         }
@@ skipping 32 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 (dart.notNull(list[core.$length]) > 0) {
-        this.writeObject(list[core.$get](0));
-        for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
+      if (dart.notNull(list.length) > 0) {
+        this.writeObject(list[dartx.get](0));
+        for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart.notNull(i) + 1) {
           this.writeString(',');
-          this.writeObject(list[core.$get](i));
+          this.writeObject(list[dartx.get](i));
         }
       }
       this.writeString(']');
     }
     writeMap(map) {
       this.writeString('{');
       let separator = '"';
       map.forEach(dart.fn((key, value) => {
         this.writeString(separator);
         separator = ',"';
@@ skipping 31 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[core.$isEmpty]) {
+      if (list[dartx.isEmpty]) {
         this.writeString('[]');
       } else {
         this.writeString('[\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
         this.writeIndentation(this[_indentLevel]);
-        this.writeObject(list[core.$get](0));
-        for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
+        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[core.$get](i));
+          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) {
         this.writeString('{}');
@@ skipping 39 matching lines @@
     static printOn(object, output, toEncodable, indent) {
       let stringifier = null;
       if (indent == null) {
         stringifier = new _JsonStringStringifier(output, toEncodable);
       } else {
         stringifier = new _JsonStringStringifierPretty(output, toEncodable, indent);
       }
       dart.dsend(stringifier, 'writeObject', object);
     }
     writeNumber(number) {
-      this[_sink].write(dart.toString(number));
+      this[_sink].write(dart[dartx.toString](number));
     }
     writeString(string) {
       this[_sink].write(string);
     }
     writeStringSlice(string, start, end) {
-      this[_sink].write(string.substring(start, end));
+      this[_sink].write(string[dartx.substring](start, end));
     }
     writeCharCode(charCode) {
       this[_sink].writeCharCode(charCode);
     }
   }
   dart.setSignature(_JsonStringStringifier, {
     constructors: () => ({_JsonStringStringifier: [_JsonStringStringifier, [core.StringSink, core.Object]]}),
     methods: () => ({
       writeNumber: [dart.void, [core.num]],
       writeString: [dart.void, [core.String]],
@@ skipping 39 matching lines @@
       stringifier.flush();
     }
     flush() {
       if (dart.notNull(this.index) > 0) {
         dart.dcall(this.addChunk, this.buffer, 0, this.index);
       }
       this.buffer = null;
       this.index = 0;
     }
     writeNumber(number) {
-      this.writeAsciiString(dart.toString(number));
+      this.writeAsciiString(dart[dartx.toString](number));
     }
     writeAsciiString(string) {
       for (let i = 0; dart.notNull(i) < dart.notNull(string.length); i = dart.notNull(i) + 1) {
-        let char = string.codeUnitAt(i);
+        let char = string[dartx.codeUnitAt](i);
         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; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        let char = string.codeUnitAt(i);
+        let char = string[dartx.codeUnitAt](i);
         if (dart.notNull(char) <= 127) {
           this.writeByte(char);
         } else {
           if ((dart.notNull(char) & 64512) == 55296 && dart.notNull(i) + 1 < dart.notNull(end)) {
-            let nextChar = string.codeUnitAt(dart.notNull(i) + 1);
+            let nextChar = string[dartx.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) + 1;
               continue;
             }
           }
           this.writeMultiByteCharCode(char);
         }
       }
@@ skipping 21 matching lines @@
     }
     writeFourByteCharCode(charCode) {
       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(dart.notNull(byte) <= 255);
-      if (this.index == this.buffer[core.$length]) {
+      if (this.index == this.buffer.length) {
         dart.dcall(this.addChunk, this.buffer, 0, this.index);
         this.buffer = typed_data.Uint8List.new(this.bufferSize);
         this.index = 0;
       }
-      this.buffer[core.$set]((() => {
+      this.buffer.set((() => {
         let x = this.index;
         this.index = dart.notNull(x) + 1;
         return x;
       })(), byte);
     }
   }
   dart.setSignature(_JsonUtf8Stringifier, {
     constructors: () => ({_JsonUtf8Stringifier: [_JsonUtf8Stringifier, [core.Object, core.int, core.Function]]}),
     methods: () => ({
       flush: [dart.void, []],
       writeNumber: [dart.void, [core.num]],
       writeAsciiString: [dart.void, [core.String]],
       writeString: [dart.void, [core.String]],
       writeStringSlice: [dart.void, [core.String, core.int, core.int]],
       writeCharCode: [dart.void, [core.int]],
       writeMultiByteCharCode: [dart.void, [core.int]],
       writeFourByteCharCode: [dart.void, [core.int]],
       writeByte: [dart.void, [core.int]]
     }),
     statics: () => ({stringify: [dart.void, [core.Object, core.List$(core.int), dart.functionType(core.Object, [core.Object]), core.int, dart.functionType(dart.void, [typed_data.Uint8List, core.int, core.int])]]}),
     names: ['stringify']
   });
   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[core.$length];
+      let indentLength = indent.length;
       if (indentLength == 1) {
-        let char = indent[core.$get](0);
+        let char = indent[dartx.get](0);
         while (dart.notNull(count) > 0) {
           this.writeByte(char);
           count = dart.notNull(count) - 1;
         }
         return;
       }
       while (dart.notNull(count) > 0) {
         count = dart.notNull(count) - 1;
         let end = dart.notNull(this.index) + dart.notNull(indentLength);
-        if (dart.notNull(end) <= dart.notNull(this.buffer[core.$length])) {
-          this.buffer[core.$setRange](this.index, end, indent);
+        if (dart.notNull(end) <= dart.notNull(this.buffer.length)) {
+          this.buffer.setRange(this.index, end, indent);
           this.index = end;
         } else {
           for (let i = 0; dart.notNull(i) < dart.notNull(indentLength); i = dart.notNull(i) + 1) {
-            this.writeByte(indent[core.$get](i));
+            this.writeByte(indent[dartx.get](i));
           }
         }
       }
     }
   }
   dart.setSignature(_JsonUtf8StringifierPretty, {
     constructors: () => ({_JsonUtf8StringifierPretty: [_JsonUtf8StringifierPretty, [core.Object, core.List$(core.int), core.Object, core.Object]]}),
     methods: () => ({writeIndentation: [dart.void, [core.int]]})
   });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [core.Object]));
@@ skipping 62 matching lines @@
   });
   let _addSliceToSink = Symbol('_addSliceToSink');
   class _Latin1DecoderSink extends ByteConversionSinkBase {
     _Latin1DecoderSink(sink) {
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     add(source) {
-      this.addSlice(source, 0, source[core.$length], false);
+      this.addSlice(source, 0, source.length, false);
     }
     [_addSliceToSink](source, start, end, isLast) {
       this[_sink].add(core.String.fromCharCodes(source, start, end));
       if (isLast)
         this.close();
     }
     addSlice(source, start, end, isLast) {
-      core.RangeError.checkValidRange(start, end, source[core.$length]);
+      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[core.$get](i);
+        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) {
         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]]
     })
   });
   class _Latin1AllowInvalidDecoderSink extends _Latin1DecoderSink {
     _Latin1AllowInvalidDecoderSink(sink) {
       super._Latin1DecoderSink(sink);
     }
     addSlice(source, start, end, isLast) {
-      core.RangeError.checkValidRange(start, end, source[core.$length]);
+      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[core.$get](i);
+        let char = source[dartx.get](i);
         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.setType([65533], core.List$(core.int))), 0, 1, 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) {
         this.close();
       }
     }
   }
   dart.setSignature(_Latin1AllowInvalidDecoderSink, {
     constructors: () => ({_Latin1AllowInvalidDecoderSink: [_Latin1AllowInvalidDecoderSink, [StringConversionSink]]})
   });
   class LineSplitter extends Converter$(core.String, core.List$(core.String)) {
     LineSplitter() {
       super.Converter();
     }
     convert(data) {
       let lines = core.List$(core.String).new();
-      _LineSplitterSink._addSlice(data, 0, data.length, true, dart.bind(lines, core.$add));
+      _LineSplitterSink._addSlice(data, 0, data.length, true, dart.bind(lines, dartx.add));
       return lines;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
         sink = StringConversionSink.from(dart.as(sink, core.Sink$(core.String)));
       }
       return new _LineSplitterSink(dart.as(sink, StringConversionSink));
     }
   }
   dart.setSignature(LineSplitter, {
     constructors: () => ({LineSplitter: [LineSplitter, []]}),
     methods: () => ({
       convert: [core.List$(core.String), [core.String]],
       startChunkedConversion: [StringConversionSink, [core.Sink]]
     })
   });
   let _carry = Symbol('_carry');
   class _LineSplitterSink extends StringConversionSinkBase {
     _LineSplitterSink(sink) {
       this[_sink] = sink;
       this[_carry] = null;
     }
     addSlice(chunk, start, end, isLast) {
       if (this[_carry] != null) {
-        chunk = dart.notNull(this[_carry]) + dart.notNull(chunk.substring(start, end));
+        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)
         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.codeUnitAt(pos);
+        let char = chunk[dartx.codeUnitAt](pos);
         if (char == _LineSplitterSink._LF) {
           skip = 1;
         } else if (char == _LineSplitterSink._CR) {
           skip = 1;
           if (dart.notNull(pos) + 1 < dart.notNull(end)) {
-            if (chunk.codeUnitAt(dart.notNull(pos) + 1) == _LineSplitterSink._LF) {
+            if (chunk[dartx.codeUnitAt](dart.notNull(pos) + 1) == _LineSplitterSink._LF) {
               skip = 2;
             }
           } else if (!dart.notNull(isLast)) {
-            return chunk.substring(start, end);
+            return chunk[dartx.substring](start, end);
           }
         }
         if (dart.notNull(skip) > 0) {
-          adder(chunk.substring(start, pos));
+          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.substring(start, pos);
+        let carry = chunk[dartx.substring](start, pos);
         if (isLast) {
           adder(carry);
         } else {
           return carry;
         }
       }
       return null;
     }
   }
   dart.setSignature(_LineSplitterSink, {
@@ skipping 101 matching lines @@
         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)
         this[_flush]();
-      let iterator = objects[core.$iterator];
+      let iterator = objects[dartx.iterator];
       if (!dart.notNull(iterator.moveNext()))
         return;
-      if (separator.isEmpty) {
+      if (separator[dartx.isEmpty]) {
         do {
           this[_chunkedSink].add(dart.toString(iterator.current));
         } while (iterator.moveNext());
       } else {
         this[_chunkedSink].add(dart.toString(iterator.current));
         while (iterator.moveNext()) {
           this.write(separator);
           this[_chunkedSink].add(dart.toString(iterator.current));
         }
       }
@@ skipping 19 matching lines @@
   _StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE = 16;
   let _stringSink = Symbol('_stringSink');
   class _StringSinkConversionSink extends StringConversionSinkBase {
     _StringSinkConversionSink(stringSink) {
       this[_stringSink] = stringSink;
     }
     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.codeUnitAt(i));
+          this[_stringSink].writeCharCode(str[dartx.codeUnitAt](i));
         }
       } else {
         this[_stringSink].write(str);
       }
       if (isLast)
         this.close();
     }
     add(str) {
       return this[_stringSink].write(str);
     }
@@ skipping 33 matching lines @@
     _StringAdapterSink(sink) {
       this[_sink] = sink;
     }
     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.substring(start, end));
+        this.add(str[dartx.substring](start, end));
       }
       if (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]],
       close: [dart.void, []]
     })
   });
   let _decoder = Symbol('_decoder');
   class _Utf8StringSinkAdapter extends ByteConversionSink {
     _Utf8StringSinkAdapter(sink, stringSink, allowMalformed) {
       this[_sink] = sink;
       this[_decoder] = new _Utf8Decoder(stringSink, allowMalformed);
       super.ByteConversionSink();
     }
     close() {
       this[_decoder].close();
       if (this[_sink] != null)
         this[_sink].close();
     }
     add(chunk) {
-      this.addSlice(chunk, 0, chunk[core.$length], false);
+      this.addSlice(chunk, 0, chunk.length, false);
     }
     addSlice(codeUnits, startIndex, endIndex, isLast) {
       this[_decoder].convert(codeUnits, startIndex, endIndex);
       if (isLast)
         this.close();
     }
   }
   dart.setSignature(_Utf8StringSinkAdapter, {
     constructors: () => ({_Utf8StringSinkAdapter: [_Utf8StringSinkAdapter, [core.Sink, core.StringSink, core.bool]]}),
     methods: () => ({
@@ skipping 16 matching lines @@
       this[_decoder].close();
       if (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[core.$length], false);
+      this.addSlice(chunk, 0, chunk.length, false);
     }
     addSlice(chunk, startIndex, endIndex, isLast) {
       this[_decoder].convert(chunk, startIndex, endIndex);
       if (this[_buffer].isNotEmpty) {
         let accumulated = dart.toString(this[_buffer]);
         this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, isLast);
         this[_buffer].clear();
         return;
       }
       if (isLast)
@@ skipping 57 matching lines @@
       core.RangeError.checkValidRange(start, end, stringLength);
       if (end == null)
         end = stringLength;
       let length = dart.notNull(end) - dart.notNull(start);
       if (length == 0)
         return typed_data.Uint8List.new(0);
       let encoder = new _Utf8Encoder.withBufferSize(dart.notNull(length) * 3);
       let endPosition = encoder[_fillBuffer](string, start, end);
       dart.assert(dart.notNull(endPosition) >= dart.notNull(end) - 1);
       if (endPosition != end) {
-        let lastCodeUnit = string.codeUnitAt(dart.notNull(end) - 1);
+        let lastCodeUnit = string[dartx.codeUnitAt](dart.notNull(end) - 1);
         dart.assert(_isLeadSurrogate(lastCodeUnit));
         let wasCombined = encoder[_writeSurrogate](lastCodeUnit, 0);
         dart.assert(!dart.notNull(wasCombined));
       }
-      return encoder[_buffer][core.$sublist](0, encoder[_bufferIndex]);
+      return encoder[_buffer][dartx.sublist](0, encoder[_bufferIndex]);
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = ByteConversionSink.from(sink);
       }
       return new _Utf8EncoderSink(dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
       return super.bind(stream);
     }
@@ skipping 16 matching lines @@
       this[_bufferIndex] = 0;
     }
     static _createBuffer(size) {
       return typed_data.Uint8List.new(size);
     }
     [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
       if (_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][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 240 | dart.notNull(rune) >> 18);
-        this[_buffer][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 128 | dart.notNull(rune) >> 12 & 63);
-        this[_buffer][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 128 | dart.notNull(rune) >> 6 & 63);
-        this[_buffer][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 128 | dart.notNull(rune) & 63);
         return true;
       } else {
-        this[_buffer][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 224 | dart.notNull(leadingSurrogate) >> 12);
-        this[_buffer][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
-        this[_buffer][core.$set]((() => {
+        this[_buffer][dartx.set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
         })(), 128 | dart.notNull(leadingSurrogate) & 63);
         return false;
       }
     }
     [_fillBuffer](str, start, end) {
-      if (start != end && dart.notNull(_isLeadSurrogate(str.codeUnitAt(dart.notNull(end) - 1)))) {
+      if (start != end && dart.notNull(_isLeadSurrogate(str[dartx.codeUnitAt](dart.notNull(end) - 1)))) {
         end = dart.notNull(end) - 1;
       }
       let stringIndex = null;
       for (stringIndex = start; dart.notNull(stringIndex) < dart.notNull(end); stringIndex = dart.notNull(stringIndex) + 1) {
-        let codeUnit = str.codeUnitAt(stringIndex);
+        let codeUnit = str[dartx.codeUnitAt](stringIndex);
         if (dart.notNull(codeUnit) <= dart.notNull(_ONE_BYTE_LIMIT)) {
-          if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][core.$length]))
+          if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer].length))
             break;
-          this[_buffer][core.$set]((() => {
+          this[_buffer][dartx.set]((() => {
             let x = this[_bufferIndex];
             this[_bufferIndex] = dart.notNull(x) + 1;
             return x;
           })(), codeUnit);
         } else if (_isLeadSurrogate(codeUnit)) {
-          if (dart.notNull(this[_bufferIndex]) + 3 >= dart.notNull(this[_buffer][core.$length]))
+          if (dart.notNull(this[_bufferIndex]) + 3 >= dart.notNull(this[_buffer].length))
             break;
-          let nextCodeUnit = str.codeUnitAt(dart.notNull(stringIndex) + 1);
+          let nextCodeUnit = str[dartx.codeUnitAt](dart.notNull(stringIndex) + 1);
           let wasCombined = this[_writeSurrogate](codeUnit, nextCodeUnit);
           if (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][core.$length]))
+            if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer].length))
               break;
-            this[_buffer][core.$set]((() => {
+            this[_buffer][dartx.set]((() => {
               let x = this[_bufferIndex];
               this[_bufferIndex] = dart.notNull(x) + 1;
               return x;
             })(), 192 | dart.notNull(rune) >> 6);
-            this[_buffer][core.$set]((() => {
+            this[_buffer][dartx.set]((() => {
               let x = this[_bufferIndex];
               this[_bufferIndex] = dart.notNull(x) + 1;
               return x;
             })(), 128 | dart.notNull(rune) & 63);
           } else {
             dart.assert(dart.notNull(rune) <= dart.notNull(_THREE_BYTE_LIMIT));
-            if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][core.$length]))
+            if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer].length))
               break;
-            this[_buffer][core.$set]((() => {
+            this[_buffer][dartx.set]((() => {
               let x = this[_bufferIndex];
               this[_bufferIndex] = dart.notNull(x) + 1;
               return x;
             })(), 224 | dart.notNull(rune) >> 12);
-            this[_buffer][core.$set]((() => {
+            this[_buffer][dartx.set]((() => {
               let x = this[_bufferIndex];
               this[_bufferIndex] = dart.notNull(x) + 1;
               return x;
             })(), 128 | dart.notNull(rune) >> 6 & 63);
-            this[_buffer][core.$set]((() => {
+            this[_buffer][dartx.set]((() => {
               let x = this[_bufferIndex];
               this[_bufferIndex] = dart.notNull(x) + 1;
               return x;
             })(), 128 | dart.notNull(rune) & 63);
           }
         }
       }
       return stringIndex;
     }
   }
@@ skipping 24 matching lines @@
       this[_sink].close();
     }
     addSlice(str, start, end, isLast) {
       this[_bufferIndex] = 0;
       if (start == end && !dart.notNull(isLast)) {
         return;
       }
       if (this[_carry] != 0) {
         let nextCodeUnit = 0;
         if (start != end) {
-          nextCodeUnit = str.codeUnitAt(start);
+          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) {
           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.codeUnitAt(start)))) {
-          if (dart.notNull(isLast) && dart.notNull(this[_bufferIndex]) < dart.notNull(this[_buffer][core.$length]) - 3) {
-            let hasBeenCombined = this[_writeSurrogate](str.codeUnitAt(start), 0);
+        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.codeUnitAt(start);
+            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)
         this.close();
     }
   }
   dart.setSignature(_Utf8EncoderSink, {
     constructors: () => ({_Utf8EncoderSink: [_Utf8EncoderSink, [ByteConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]]
     })
   });
   class Utf8Decoder extends Converter$(core.List$(core.int), core.String) {
     Utf8Decoder(opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
       this[_allowMalformed] = allowMalformed;
       super.Converter();
     }
     convert(codeUnits, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
-      let length = codeUnits[core.$length];
+      let length = codeUnits.length;
       core.RangeError.checkValidRange(start, end, length);
       if (end == null)
         end = length;
       let buffer = new core.StringBuffer();
       let decoder = new _Utf8Decoder(buffer, this[_allowMalformed]);
       decoder.convert(codeUnits, start, end);
       decoder.close();
       return dart.toString(buffer);
     }
     startChunkedConversion(sink) {
@@ skipping 102 matching lines @@
       dart.fn(addSingleBytes, dart.void, [core.int, core.int]);
       let i = startIndex;
       loop:
         while (true) {
           multibyte:
             if (dart.notNull(expectedUnits) > 0) {
               do {
                 if (i == endIndex) {
                   break loop;
                 }
-                let unit = codeUnits[core.$get](i);
+                let unit = codeUnits[dartx.get](i);
                 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)}`);
+                    throw new core.FormatException(`Bad UTF-8 encoding 0x${unit[dartx.toRadixString](16)}`);
                   }
                   this[_isFirstCharacter] = false;
                   this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
                   break multibyte;
                 } else {
                   value = dart.notNull(value) << 6 | dart.notNull(unit) & 63;
                   expectedUnits = dart.notNull(expectedUnits) - 1;
                   i = dart.notNull(i) + 1;
                 }
               } while (dart.notNull(expectedUnits) > 0);
-              if (dart.notNull(value) <= dart.notNull(_Utf8Decoder._LIMITS[core.$get](dart.notNull(extraUnits) - 1))) {
+              if (dart.notNull(value) <= dart.notNull(_Utf8Decoder._LIMITS[dartx.get](dart.notNull(extraUnits) - 1))) {
                 if (!dart.notNull(this[_allowMalformed])) {
-                  throw new core.FormatException(`Overlong encoding of 0x${value.toRadixString(16)}`);
+                  throw new core.FormatException(`Overlong encoding of 0x${value[dartx.toRadixString](16)}`);
                 }
                 expectedUnits = extraUnits = 0;
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
               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)}`);
+                  throw new core.FormatException("Character outside valid Unicode range: " + `0x${value[dartx.toRadixString](16)}`);
                 }
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
               if (!dart.notNull(this[_isFirstCharacter]) || value != UNICODE_BOM_CHARACTER_RUNE) {
                 this[_stringSink].writeCharCode(value);
               }
               this[_isFirstCharacter] = false;
             }
           while (dart.notNull(i) < dart.notNull(endIndex)) {
             let oneBytes = scanOneByteCharacters(codeUnits, i);
             if (dart.notNull(oneBytes) > 0) {
               this[_isFirstCharacter] = false;
               addSingleBytes(i, dart.notNull(i) + dart.notNull(oneBytes));
               i = dart.notNull(i) + dart.notNull(oneBytes);
               if (i == endIndex)
                 break;
             }
-            let unit = codeUnits[core.$get]((() => {
+            let unit = codeUnits[dartx.get]((() => {
               let x = i;
               i = dart.notNull(x) + 1;
               return x;
             })());
             if (dart.notNull(unit) < 0) {
               if (!dart.notNull(this[_allowMalformed])) {
-                throw new core.FormatException(`Negative UTF-8 code unit: -0x${(-dart.notNull(unit)).toRadixString(16)}`);
+                throw new core.FormatException(`Negative UTF-8 code unit: -0x${(-dart.notNull(unit))[dartx.toRadixString](16)}`);
               }
               this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
             } else {
               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 ((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 = 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)}`);
+                throw new core.FormatException(`Bad UTF-8 encoding 0x${unit[dartx.toRadixString](16)}`);
               }
               value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               expectedUnits = extraUnits = 0;
               this[_isFirstCharacter] = false;
               this[_stringSink].writeCharCode(value);
             }
           }
           break loop;
         }
       if (dart.notNull(expectedUnits) > 0) {
         this[_value] = value;
         this[_expectedUnits] = expectedUnits;
         this[_extraUnits] = extraUnits;
       }
     }
   }
   dart.setSignature(_Utf8Decoder, {
     constructors: () => ({_Utf8Decoder: [_Utf8Decoder, [core.StringSink, core.bool]]}),
     methods: () => ({
       close: [dart.void, []],
       flush: [dart.void, []],
       convert: [dart.void, [core.List$(core.int), core.int, core.int]]
     })
   });
-  _Utf8Decoder._LIMITS = dart.const(dart.setType([_ONE_BYTE_LIMIT, _TWO_BYTE_LIMIT, _THREE_BYTE_LIMIT, _FOUR_BYTE_LIMIT], core.List$(core.int)));
+  _Utf8Decoder._LIMITS = dart.const(dart.list([_ONE_BYTE_LIMIT, _TWO_BYTE_LIMIT, _THREE_BYTE_LIMIT, _FOUR_BYTE_LIMIT], core.int));
   let _processed = Symbol('_processed');
   let _computeKeys = Symbol('_computeKeys');
   let _original = Symbol('_original');
   function _convertJsonToDart(json, reviver) {
     dart.assert(reviver != null);
     let walk = e => {
       if (e == null || typeof e != "object") {
         return e;
       }
       if (Object.getPrototypeOf(e) === Array.prototype) {
         for (let i = 0; dart.notNull(i) < e.length; i = dart.notNull(i) + 1) {
           let item = e[i];
           e[i] = dart.dcall(reviver, i, walk(item));
         }
         return e;
       }
       let map = new _JsonMap(e);
       let processed = map[_processed];
       let keys = map[_computeKeys]();
-      for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
-        let key = keys[core.$get](i);
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
+        let key = keys[dartx.get](i);
         let revived = dart.dcall(reviver, key, walk(e[key]));
         processed[key] = revived;
       }
       map[_original] = processed;
       return map;
     };
     dart.fn(walk);
     return dart.dcall(reviver, null, walk(json));
   }
   dart.fn(_convertJsonToDart, core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, dart.bottom])]);
@@ skipping 30 matching lines @@
       } else if (!(typeof key == 'string')) {
         return null;
       } else {
         let result = _JsonMap._getProperty(this[_processed], dart.as(key, core.String));
         if (_JsonMap._isUnprocessed(result))
           result = this[_process](dart.as(key, core.String));
         return result;
       }
     }
     get length() {
-      return this[_isUpgraded] ? this[_upgradedMap].length : this[_computeKeys]()[core.$length];
+      return 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])
         return this[_upgradedMap].keys;
@@ skipping 20 matching lines @@
     }
     addAll(other) {
       other.forEach(dart.fn((key, value) => {
         this.set(key, value);
       }));
     }
     containsValue(value) {
       if (this[_isUpgraded])
         return this[_upgradedMap].containsValue(value);
       let keys = this[_computeKeys]();
-      for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
-        let key = keys[core.$get](i);
+      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])
         return this[_upgradedMap].containsKey(key);
       if (!(typeof key == 'string'))
         return false;
@@ skipping 19 matching lines @@
           dart.dsend(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; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
-        let key = keys[core.$get](i);
+      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)) {
           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);
         }
       }
@@ skipping 14 matching lines @@
       if (keys == null) {
         keys = this[_data] = _JsonMap._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; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
-        let key = keys[core.$get](i);
+      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[core.$isEmpty]) {
-        keys[core.$add](null);
+      if (keys[dartx.isEmpty]) {
+        keys[dartx.add](null);
       } else {
-        keys[core.$clear]();
+        keys[dartx.clear]();
       }
       this[_original] = this[_processed] = null;
       this[_data] = result;
       dart.assert(this[_isUpgraded]);
       return result;
     }
     [_process](key) {
       if (!dart.notNull(_JsonMap._hasProperty(this[_original], key)))
         return null;
       let result = _convertJsonToDartLazy(_JsonMap._getProperty(this[_original], key));
@@ skipping 44 matching lines @@
       _newJavaScriptObject: [core.Object, []]
     }),
     names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
   });
   let _parent = Symbol('_parent');
   class _JsonMapKeyIterable extends _internal.ListIterable {
     _JsonMapKeyIterable(parent) {
       this[_parent] = parent;
       super.ListIterable();
     }
-    get [core.$length]() {
+    get length() {
       return this[_parent].length;
     }
-    [core.$elementAt](index) {
-      return this[_parent][_isUpgraded] ? dart.as(this[_parent].keys[core.$elementAt](index), core.String) : this[_parent][_computeKeys]()[core.$get](index);
+    elementAt(index) {
+      return this[_parent][_isUpgraded] ? dart.as(this[_parent].keys[dartx.elementAt](index), core.String) : this[_parent][_computeKeys]()[dartx.get](index);
     }
-    get [core.$iterator]() {
-      return this[_parent][_isUpgraded] ? this[_parent].keys[core.$iterator] : this[_parent][_computeKeys]()[core.$iterator];
+    get iterator() {
+      return this[_parent][_isUpgraded] ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys]()[dartx.iterator];
     }
-    [core.$contains](key) {
+    contains(key) {
       return this[_parent].containsKey(key);
     }
   }
   dart.setSignature(_JsonMapKeyIterable, {
     constructors: () => ({_JsonMapKeyIterable: [_JsonMapKeyIterable, [_JsonMap]]}),
-    methods: () => ({[core.$elementAt]: [core.String, [core.int]]})
+    methods: () => ({elementAt: [core.String, [core.int]]})
   });
   class _JsonDecoderSink extends _StringSinkConversionSink {
     _JsonDecoderSink(reviver, sink) {
       this[_reviver] = reviver;
       this[_sink] = sink;
       super._StringSinkConversionSink(new core.StringBuffer());
     }
     close() {
       super.close();
       let buffer = dart.as(this[_stringSink], core.StringBuffer);
@@ skipping 40 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);