Rewire DDC to use the analyzer task model

lib/runtime/dart/core.js

 dart_library.library('dart/core', null, /* Imports */[
   "dart_runtime/dart"
 ], /* Lazy imports */[
   'dart/_js_helper',
   'dart/_internal',
   'dart/collection',
   'dart/_interceptors',
   'dart/convert'
 ], function(exports, dart, _js_helper, _internal, collection, _interceptors, convert) {
   'use strict';
   let dartx = dart.dartx;
   class Object {
     constructor() {
       let name = this.constructor.name;
       let result = void 0;
       if (name in this)
         result = this[name](...arguments);
       return result === void 0 ? this : result;
     }
     ['=='](other) {
-      return identical(this, other);
+      return dart.dcall(identical, this, other);
     }
     get hashCode() {
-      return _js_helper.Primitives.objectHashCode(this);
+      return dart.dcall(_js_helper.Primitives.objectHashCode, this);
     }
     toString() {
-      return _js_helper.Primitives.objectToString(this);
+      return dart.dcall(_js_helper.Primitives.objectToString, this);
     }
     noSuchMethod(invocation) {
       dart.throw(new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments));
     }
     get runtimeType() {
-      return dart.realRuntimeType(this);
+      return dart.as(dart.realRuntimeType(this), Type);
     }
   }
   dart.setSignature(Object, {
     constructors: () => ({Object: [Object, []]}),
     methods: () => ({
       '==': [bool, [dart.dynamic]],
       toString: [String, []],
       noSuchMethod: [dart.dynamic, [Invocation]]
     })
   });
@@ skipping 41 matching lines @@
     constructors: () => ({fromEnvironment: [bool, [String], {defaultValue: bool}]})
   });
   let Comparator$ = dart.generic(function(T) {
     let Comparator = dart.typedef('Comparator', () => dart.functionType(int, [T, T]));
     return Comparator;
   });
   let Comparator = Comparator$();
   let Comparable$ = dart.generic(function(T) {
     class Comparable extends Object {
       static compare(a, b) {
-        return a[dartx.compareTo](b);
+        return dart.dcall(a[dartx.compareTo], b);
       }
     }
     dart.setSignature(Comparable, {
       statics: () => ({compare: [int, [Comparable$(), Comparable$()]]}),
       names: ['compare']
     });
     return Comparable;
   });
   let Comparable = Comparable$();
   class DateTime extends Object {
@@ skipping 25 matching lines @@
         second = 0;
       if (millisecond === void 0)
         millisecond = 0;
       this._internal(year, month, day, hour, minute, second, millisecond, true);
     }
     now() {
       this._now();
     }
     static parse(formattedString) {
       let re = RegExp.new('^([+-]?\\d{4,6})-?(\\d\\d)-?(\\d\\d)' + '(?:[ T](\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(.\\d{1,6})?)?)?' + '( ?[zZ]| ?([-+])(\\d\\d)(?::?(\\d\\d))?)?)?$');
-      let match = re.firstMatch(formattedString);
+      let match = dart.dcall(re.firstMatch, formattedString);
       if (match != null) {
         function parseIntOrZero(matched) {
           if (matched == null)
             return 0;
-          return int.parse(matched);
+          return dart.dcall(int.parse, matched);
         }
         dart.fn(parseIntOrZero, int, [String]);
         function parseDoubleOrZero(matched) {
           if (matched == null)
             return 0.0;
-          return double.parse(matched);
+          return dart.dcall(double.parse, matched);
         }
         dart.fn(parseDoubleOrZero, double, [String]);
-        let years = int.parse(match.get(1));
-        let month = int.parse(match.get(2));
-        let day = int.parse(match.get(3));
-        let hour = parseIntOrZero(match.get(4));
-        let minute = parseIntOrZero(match.get(5));
-        let second = parseIntOrZero(match.get(6));
+        let years = dart.dcall(int.parse, match.get(1));
+        let month = dart.dcall(int.parse, match.get(2));
+        let day = dart.dcall(int.parse, match.get(3));
+        let hour = dart.dcall(parseIntOrZero, match.get(4));
+        let minute = dart.dcall(parseIntOrZero, match.get(5));
+        let second = dart.dcall(parseIntOrZero, match.get(6));
         let addOneMillisecond = false;
-        let millisecond = (dart.notNull(parseDoubleOrZero(match.get(7))) * 1000)[dartx.round]();
+        let millisecond = dart.dcall((dart.notNull(dart.dcall(parseDoubleOrZero, match.get(7))) * 1000)[dartx.round]);
         if (millisecond == 1000) {
           addOneMillisecond = true;
           millisecond = 999;
         }
         let isUtc = false;
         if (match.get(8) != null) {
           isUtc = true;
           if (match.get(9) != null) {
             let sign = match.get(9) == '-' ? -1 : 1;
-            let hourDifference = int.parse(match.get(10));
-            let minuteDifference = parseIntOrZero(match.get(11));
+            let hourDifference = dart.dcall(int.parse, match.get(10));
+            let minuteDifference = dart.dcall(parseIntOrZero, match.get(11));
             minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
             minute = dart.notNull(minute) - dart.notNull(sign) * dart.notNull(minuteDifference);
           }
         }
-        let millisecondsSinceEpoch = DateTime._brokenDownDateToMillisecondsSinceEpoch(years, month, day, hour, minute, second, millisecond, isUtc);
+        let millisecondsSinceEpoch = dart.dcall(DateTime._brokenDownDateToMillisecondsSinceEpoch, years, month, day, hour, minute, second, millisecond, isUtc);
         if (millisecondsSinceEpoch == null) {
           dart.throw(new FormatException("Time out of range", formattedString));
         }
         if (dart.notNull(addOneMillisecond)) {
           millisecondsSinceEpoch = dart.notNull(millisecondsSinceEpoch) + 1;
         }
         return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, {isUtc: isUtc});
       } else {
         dart.throw(new FormatException("Invalid date format", formattedString));
       }
     }
     fromMillisecondsSinceEpoch(millisecondsSinceEpoch, opts) {
       let isUtc = opts && 'isUtc' in opts ? opts.isUtc : false;
       this.millisecondsSinceEpoch = millisecondsSinceEpoch;
       this.isUtc = isUtc;
-      if (dart.notNull(millisecondsSinceEpoch[dartx.abs]()) > dart.notNull(DateTime._MAX_MILLISECONDS_SINCE_EPOCH)) {
+      if (dart.notNull(dart.dcall(millisecondsSinceEpoch[dartx.abs])) > dart.notNull(DateTime._MAX_MILLISECONDS_SINCE_EPOCH)) {
         dart.throw(new ArgumentError(millisecondsSinceEpoch));
       }
       if (isUtc == null)
         dart.throw(new ArgumentError(isUtc));
     }
     ['=='](other) {
       if (!dart.is(other, DateTime))
         return false;
       return dart.equals(this.millisecondsSinceEpoch, dart.dload(other, 'millisecondsSinceEpoch')) && dart.equals(this.isUtc, dart.dload(other, 'isUtc'));
     }
     isBefore(other) {
       return dart.notNull(this.millisecondsSinceEpoch) < dart.notNull(other.millisecondsSinceEpoch);
     }
     isAfter(other) {
       return dart.notNull(this.millisecondsSinceEpoch) > dart.notNull(other.millisecondsSinceEpoch);
     }
     isAtSameMomentAs(other) {
       return this.millisecondsSinceEpoch == other.millisecondsSinceEpoch;
     }
     compareTo(other) {
-      return this.millisecondsSinceEpoch[dartx.compareTo](other.millisecondsSinceEpoch);
+      return dart.dcall(this.millisecondsSinceEpoch[dartx.compareTo], other.millisecondsSinceEpoch);
     }
     get hashCode() {
       return this.millisecondsSinceEpoch;
     }
     toLocal() {
       if (dart.notNull(this.isUtc)) {
         return new DateTime.fromMillisecondsSinceEpoch(this.millisecondsSinceEpoch, {isUtc: false});
       }
       return this;
     }
     toUtc() {
       if (dart.notNull(this.isUtc))
         return this;
       return new DateTime.fromMillisecondsSinceEpoch(this.millisecondsSinceEpoch, {isUtc: true});
     }
     static _fourDigits(n) {
-      let absN = n[dartx.abs]();
+      let absN = dart.dcall(n[dartx.abs]);
       let sign = dart.notNull(n) < 0 ? "-" : "";
       if (dart.notNull(absN) >= 1000)
         return `${n}`;
       if (dart.notNull(absN) >= 100)
         return `${sign}0${absN}`;
       if (dart.notNull(absN) >= 10)
         return `${sign}00${absN}`;
       return `${sign}000${absN}`;
     }
     static _sixDigits(n) {
       dart.assert(dart.notNull(n) < -9999 || dart.notNull(n) > 9999);
-      let absN = n[dartx.abs]();
+      let absN = dart.dcall(n[dartx.abs]);
       let sign = dart.notNull(n) < 0 ? "-" : "+";
       if (dart.notNull(absN) >= 100000)
         return `${sign}${absN}`;
       return `${sign}0${absN}`;
     }
     static _threeDigits(n) {
       if (dart.notNull(n) >= 100)
         return `${n}`;
       if (dart.notNull(n) >= 10)
         return `0${n}`;
       return `00${n}`;
     }
     static _twoDigits(n) {
       if (dart.notNull(n) >= 10)
         return `${n}`;
       return `0${n}`;
     }
     toString() {
-      let y = DateTime._fourDigits(this.year);
-      let m = DateTime._twoDigits(this.month);
-      let d = DateTime._twoDigits(this.day);
-      let h = DateTime._twoDigits(this.hour);
-      let min = DateTime._twoDigits(this.minute);
-      let sec = DateTime._twoDigits(this.second);
-      let ms = DateTime._threeDigits(this.millisecond);
+      let y = dart.dcall(DateTime._fourDigits, this.year);
+      let m = dart.dcall(DateTime._twoDigits, this.month);
+      let d = dart.dcall(DateTime._twoDigits, this.day);
+      let h = dart.dcall(DateTime._twoDigits, this.hour);
+      let min = dart.dcall(DateTime._twoDigits, this.minute);
+      let sec = dart.dcall(DateTime._twoDigits, this.second);
+      let ms = dart.dcall(DateTime._threeDigits, this.millisecond);
       if (dart.notNull(this.isUtc)) {
         return `${y}-${m}-${d} ${h}:${min}:${sec}.${ms}Z`;
       } else {
         return `${y}-${m}-${d} ${h}:${min}:${sec}.${ms}`;
       }
     }
     toIso8601String() {
-      let y = dart.notNull(this.year) >= -9999 && dart.notNull(this.year) <= 9999 ? DateTime._fourDigits(this.year) : DateTime._sixDigits(this.year);
-      let m = DateTime._twoDigits(this.month);
-      let d = DateTime._twoDigits(this.day);
-      let h = DateTime._twoDigits(this.hour);
-      let min = DateTime._twoDigits(this.minute);
-      let sec = DateTime._twoDigits(this.second);
-      let ms = DateTime._threeDigits(this.millisecond);
+      let y = dart.notNull(this.year) >= -9999 && dart.notNull(this.year) <= 9999 ? dart.dcall(DateTime._fourDigits, this.year) : dart.dcall(DateTime._sixDigits, this.year);
+      let m = dart.dcall(DateTime._twoDigits, this.month);
+      let d = dart.dcall(DateTime._twoDigits, this.day);
+      let h = dart.dcall(DateTime._twoDigits, this.hour);
+      let min = dart.dcall(DateTime._twoDigits, this.minute);
+      let sec = dart.dcall(DateTime._twoDigits, this.second);
+      let ms = dart.dcall(DateTime._threeDigits, this.millisecond);
       if (dart.notNull(this.isUtc)) {
         return `${y}-${m}-${d}T${h}:${min}:${sec}.${ms}Z`;
       } else {
         return `${y}-${m}-${d}T${h}:${min}:${sec}.${ms}`;
       }
     }
     add(duration) {
       let ms = this.millisecondsSinceEpoch;
       return new DateTime.fromMillisecondsSinceEpoch(dart.notNull(ms) + dart.notNull(duration.inMilliseconds), {isUtc: this.isUtc});
     }
     subtract(duration) {
       let ms = this.millisecondsSinceEpoch;
       return new DateTime.fromMillisecondsSinceEpoch(dart.notNull(ms) - dart.notNull(duration.inMilliseconds), {isUtc: this.isUtc});
     }
     difference(other) {
       let ms = this.millisecondsSinceEpoch;
       let otherMs = other.millisecondsSinceEpoch;
       return new Duration({milliseconds: dart.notNull(ms) - dart.notNull(otherMs)});
     }
     _internal(year, month, day, hour, minute, second, millisecond, isUtc) {
       this.isUtc = typeof isUtc == 'boolean' ? isUtc : dart.throw(new ArgumentError(isUtc));
-      this.millisecondsSinceEpoch = dart.as(_js_helper.checkInt(_js_helper.Primitives.valueFromDecomposedDate(year, month, day, hour, minute, second, millisecond, isUtc)), int);
+      this.millisecondsSinceEpoch = dart.as(dart.dcall(_js_helper.checkInt, dart.dcall(_js_helper.Primitives.valueFromDecomposedDate, year, month, day, hour, minute, second, millisecond, isUtc)), int);
     }
     _now() {
       this.isUtc = false;
-      this.millisecondsSinceEpoch = _js_helper.Primitives.dateNow();
+      this.millisecondsSinceEpoch = dart.dcall(_js_helper.Primitives.dateNow);
     }
     static _brokenDownDateToMillisecondsSinceEpoch(year, month, day, hour, minute, second, millisecond, isUtc) {
-      return dart.as(_js_helper.Primitives.valueFromDecomposedDate(year, month, day, hour, minute, second, millisecond, isUtc), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.valueFromDecomposedDate, year, month, day, hour, minute, second, millisecond, isUtc), int);
     }
     get timeZoneName() {
       if (dart.notNull(this.isUtc))
         return "UTC";
-      return _js_helper.Primitives.getTimeZoneName(this);
+      return dart.dcall(_js_helper.Primitives.getTimeZoneName, this);
     }
     get timeZoneOffset() {
       if (dart.notNull(this.isUtc))
         return new Duration();
-      return new Duration({minutes: _js_helper.Primitives.getTimeZoneOffsetInMinutes(this)});
+      return new Duration({minutes: dart.dcall(_js_helper.Primitives.getTimeZoneOffsetInMinutes, this)});
     }
     get year() {
-      return dart.as(_js_helper.Primitives.getYear(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getYear, this), int);
     }
     get month() {
-      return dart.as(_js_helper.Primitives.getMonth(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getMonth, this), int);
     }
     get day() {
-      return dart.as(_js_helper.Primitives.getDay(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getDay, this), int);
     }
     get hour() {
-      return dart.as(_js_helper.Primitives.getHours(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getHours, this), int);
     }
     get minute() {
-      return dart.as(_js_helper.Primitives.getMinutes(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getMinutes, this), int);
     }
     get second() {
-      return dart.as(_js_helper.Primitives.getSeconds(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getSeconds, this), int);
     }
     get millisecond() {
-      return dart.as(_js_helper.Primitives.getMilliseconds(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getMilliseconds, this), int);
     }
     get weekday() {
-      return dart.as(_js_helper.Primitives.getWeekday(this), int);
+      return dart.as(dart.dcall(_js_helper.Primitives.getWeekday, this), int);
     }
   }
   DateTime[dart.implements] = () => [Comparable];
   dart.defineNamedConstructor(DateTime, 'utc');
   dart.defineNamedConstructor(DateTime, 'now');
   dart.defineNamedConstructor(DateTime, 'fromMillisecondsSinceEpoch');
   dart.defineNamedConstructor(DateTime, '_internal');
   dart.defineNamedConstructor(DateTime, '_now');
   dart.setSignature(DateTime, {
     constructors: () => ({
@@ skipping 46 matching lines @@
   DateTime.SEPTEMBER = 9;
   DateTime.OCTOBER = 10;
   DateTime.NOVEMBER = 11;
   DateTime.DECEMBER = 12;
   DateTime.MONTHS_PER_YEAR = 12;
   DateTime._MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
   class num extends Object {
     static parse(input, onError) {
       if (onError === void 0)
         onError = null;
-      let source = input[dartx.trim]();
+      let source = dart.dcall(input[dartx.trim]);
       num._parseError = false;
-      let result = int.parse(source, {onError: num._onParseErrorInt});
+      let result = dart.dcall(int.parse, source, {onError: num._onParseErrorInt});
       if (!dart.notNull(num._parseError))
         return result;
       num._parseError = false;
-      result = double.parse(source, num._onParseErrorDouble);
+      result = dart.dcall(double.parse, source, num._onParseErrorDouble);
       if (!dart.notNull(num._parseError))
         return result;
       if (onError == null)
         dart.throw(new FormatException(input));
       return onError(input);
     }
     static _onParseErrorInt(_) {
       num._parseError = true;
       return 0;
     }
     static _onParseErrorDouble(_) {
       num._parseError = true;
       return 0.0;
     }
   }
   num[dart.implements] = () => [Comparable$(num)];
   dart.setSignature(num, {
     statics: () => ({
       parse: [num, [String], [dart.functionType(num, [String])]],
       _onParseErrorInt: [int, [String]],
       _onParseErrorDouble: [double, [String]]
     }),
     names: ['parse', '_onParseErrorInt', '_onParseErrorDouble']
   });
   class double extends num {
     static parse(source, onError) {
       if (onError === void 0)
         onError = null;
-      return _js_helper.Primitives.parseDouble(source, onError);
+      return dart.dcall(_js_helper.Primitives.parseDouble, source, onError);
     }
   }
   dart.setSignature(double, {
     statics: () => ({parse: [double, [String], [dart.functionType(double, [String])]]}),
     names: ['parse']
   });
   double.NAN = 0.0 / 0.0;
   double.INFINITY = 1.0 / 0.0;
   double.NEGATIVE_INFINITY = -dart.notNull(double.INFINITY);
   double.MIN_POSITIVE = 5e-324;
@@ skipping 12 matching lines @@
     _microseconds(duration) {
       this[_duration] = duration;
     }
     ['+'](other) {
       return new Duration._microseconds(dart.notNull(this[_duration]) + dart.notNull(other[_duration]));
     }
     ['-'](other) {
       return new Duration._microseconds(dart.notNull(this[_duration]) - dart.notNull(other[_duration]));
     }
     ['*'](factor) {
-      return new Duration._microseconds((dart.notNull(this[_duration]) * dart.notNull(factor))[dartx.round]());
+      return new Duration._microseconds(dart.dcall((dart.notNull(this[_duration]) * dart.notNull(factor))[dartx.round]));
     }
     ['~/'](quotient) {
       if (quotient == 0)
         dart.throw(new IntegerDivisionByZeroException());
       return new Duration._microseconds((dart.notNull(this[_duration]) / dart.notNull(quotient))[dartx.truncate]());
     }
     ['<'](other) {
       return dart.notNull(this[_duration]) < dart.notNull(other[_duration]);
     }
     ['>'](other) {
@@ skipping 25 matching lines @@
     }
     ['=='](other) {
       if (!dart.is(other, Duration))
         return false;
       return dart.equals(this[_duration], dart.dload(other, _duration));
     }
     get hashCode() {
       return dart.hashCode(this[_duration]);
     }
     compareTo(other) {
-      return this[_duration][dartx.compareTo](other[_duration]);
+      return dart.dcall(this[_duration][dartx.compareTo], other[_duration]);
     }
     toString() {
       function sixDigits(n) {
         if (dart.notNull(n) >= 100000)
           return `${n}`;
         if (dart.notNull(n) >= 10000)
           return `0${n}`;
         if (dart.notNull(n) >= 1000)
           return `00${n}`;
         if (dart.notNull(n) >= 100)
           return `000${n}`;
         if (dart.notNull(n) >= 10)
           return `0000${n}`;
         return `00000${n}`;
       }
       dart.fn(sixDigits, String, [int]);
       function twoDigits(n) {
         if (dart.notNull(n) >= 10)
           return `${n}`;
         return `0${n}`;
       }
       dart.fn(twoDigits, String, [int]);
       if (dart.notNull(this.inMicroseconds) < 0) {
         return `-${this['unary-']()}`;
       }
-      let twoDigitMinutes = twoDigits(this.inMinutes[dartx.remainder](Duration.MINUTES_PER_HOUR));
-      let twoDigitSeconds = twoDigits(this.inSeconds[dartx.remainder](Duration.SECONDS_PER_MINUTE));
-      let sixDigitUs = sixDigits(this.inMicroseconds[dartx.remainder](Duration.MICROSECONDS_PER_SECOND));
+      let twoDigitMinutes = dart.dcall(twoDigits, dart.dcall(this.inMinutes[dartx.remainder], Duration.MINUTES_PER_HOUR));
+      let twoDigitSeconds = dart.dcall(twoDigits, dart.dcall(this.inSeconds[dartx.remainder], Duration.SECONDS_PER_MINUTE));
+      let sixDigitUs = dart.dcall(sixDigits, dart.dcall(this.inMicroseconds[dartx.remainder], Duration.MICROSECONDS_PER_SECOND));
       return `${this.inHours}:${twoDigitMinutes}:${twoDigitSeconds}.${sixDigitUs}`;
     }
     get isNegative() {
       return dart.notNull(this[_duration]) < 0;
     }
     abs() {
-      return new Duration._microseconds(this[_duration][dartx.abs]());
+      return new Duration._microseconds(dart.dcall(this[_duration][dartx.abs]));
     }
     ['unary-']() {
       return new Duration._microseconds(-dart.notNull(this[_duration]));
     }
   }
   Duration[dart.implements] = () => [Comparable$(Duration)];
   dart.defineNamedConstructor(Duration, '_microseconds');
   dart.setSignature(Duration, {
     constructors: () => ({
       Duration: [Duration, [], {days: int, hours: int, minutes: int, seconds: int, milliseconds: int, microseconds: int}],
@@ skipping 28 matching lines @@
   Duration.MILLISECONDS_PER_DAY = dart.notNull(Duration.MILLISECONDS_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.SECONDS_PER_HOUR = dart.notNull(Duration.SECONDS_PER_MINUTE) * dart.notNull(Duration.MINUTES_PER_HOUR);
   Duration.SECONDS_PER_DAY = dart.notNull(Duration.SECONDS_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.MINUTES_PER_DAY = dart.notNull(Duration.MINUTES_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.ZERO = dart.const(new Duration({seconds: 0}));
   class Error extends Object {
     Error() {
     }
     static safeToString(object) {
       if (dart.is(object, num) || typeof object == 'boolean' || null == object) {
-        return dart.toString(object);
+        return dart.dcall(object.toString);
       }
       if (typeof object == 'string') {
-        return Error._stringToSafeString(object);
+        return dart.dcall(Error._stringToSafeString, object);
       }
-      return Error._objectToString(object);
+      return dart.dcall(Error._objectToString, object);
     }
     static _stringToSafeString(string) {
-      return _js_helper.jsonEncodeNative(string);
+      return dart.dcall(_js_helper.jsonEncodeNative, string);
     }
     static _objectToString(object) {
-      return _js_helper.Primitives.objectToString(object);
+      return dart.dcall(_js_helper.Primitives.objectToString, object);
     }
     get stackTrace() {
-      return _js_helper.Primitives.extractStackTrace(this);
+      return dart.dcall(_js_helper.Primitives.extractStackTrace, this);
     }
   }
   dart.setSignature(Error, {
     constructors: () => ({Error: [Error, []]}),
     statics: () => ({
       safeToString: [String, [Object]],
       _stringToSafeString: [String, [String]],
       _objectToString: [String, [Object]]
     }),
     names: ['safeToString', '_stringToSafeString', '_objectToString']
@@ skipping 43 matching lines @@
       if (name === void 0)
         name = null;
       this.value(null, name, "Must not be null");
     }
     toString() {
       if (!dart.notNull(this[_hasValue])) {
         let result = "Invalid arguments(s)";
         if (this.message != null) {
           result = `${result}: ${this.message}`;
         }
-        return result;
+        return dart.as(result, String);
       }
       let nameString = "";
       if (this.name != null) {
         nameString = ` (${this.name})`;
       }
-      return `${this.message}${nameString}: ${Error.safeToString(this.invalidValue)}`;
+      return `${this.message}${nameString}: ${dart.dcall(Error.safeToString, this.invalidValue)}`;
     }
   }
   dart.defineNamedConstructor(ArgumentError, 'value');
   dart.defineNamedConstructor(ArgumentError, 'notNull');
   dart.setSignature(ArgumentError, {
     constructors: () => ({
       ArgumentError: [ArgumentError, [], [dart.dynamic]],
       value: [ArgumentError, [dart.dynamic], [String, String]],
       notNull: [ArgumentError, [], [String]]
     })
@@ skipping 71 matching lines @@
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(value) < 0)
         dart.throw(new RangeError.range(value, 0, null, name, message));
     }
     toString() {
       if (!dart.notNull(this[_hasValue]))
         return `RangeError: ${this.message}`;
-      let value = Error.safeToString(this.invalidValue);
+      let value = dart.dcall(Error.safeToString, this.invalidValue);
       let explanation = "";
       if (this.start == null) {
         if (this.end != null) {
           explanation = `: Not less than or equal to ${this.end}`;
         }
       } else if (this.end == null) {
         explanation = `: Not greater than or equal to ${this.start}`;
       } else if (dart.notNull(this.end) > dart.notNull(this.start)) {
         explanation = `: Not in range ${this.start}..${this.end}, inclusive.`;
       } else if (dart.notNull(this.end) < dart.notNull(this.start)) {
@@ skipping 34 matching lines @@
       super.value(invalidValue, name, message != null ? message : "Index out of range");
     }
     get start() {
       return 0;
     }
     get end() {
       return dart.notNull(this.length) - 1;
     }
     toString() {
       dart.assert(this[_hasValue]);
-      let target = Error.safeToString(this.indexable);
+      let target = dart.dcall(Error.safeToString, this.indexable);
       let explanation = `index should be less than ${this.length}`;
       if (dart.notNull(dart.as(dart.dsend(this.invalidValue, '<', 0), bool))) {
         explanation = "index must not be negative";
       }
       return `RangeError: ${this.message} (${target}[${this.invalidValue}]): ${explanation}`;
     }
   }
   IndexError[dart.implements] = () => [RangeError];
   dart.setSignature(IndexError, {
     constructors: () => ({IndexError: [IndexError, [int, dart.dynamic], [String, String, int]]})
@@ skipping 34 matching lines @@
       this[_namedArguments] = namedArguments;
       this[_existingArgumentNames] = existingArgumentNames;
       super.Error();
     }
     toString() {
       let sb = new StringBuffer();
       let i = 0;
       if (this[_arguments] != null) {
         for (; dart.notNull(i) < dart.notNull(this[_arguments][dartx.length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
-            sb.write(", ");
+            dart.dcall(sb.write, ", ");
           }
-          sb.write(Error.safeToString(this[_arguments][dartx.get](i)));
+          dart.dcall(sb.write, dart.dcall(Error.safeToString, this[_arguments][dartx.get](i)));
         }
       }
       if (this[_namedArguments] != null) {
-        this[_namedArguments].forEach(dart.fn((key, value) => {
+        dart.dcall(this[_namedArguments].forEach, dart.fn((key, value) => {
           if (dart.notNull(i) > 0) {
-            sb.write(", ");
+            dart.dcall(sb.write, ", ");
           }
-          sb.write(_symbolToString(key));
-          sb.write(": ");
-          sb.write(Error.safeToString(value));
+          dart.dcall(sb.write, dart.dcall(_symbolToString, key));
+          dart.dcall(sb.write, ": ");
+          dart.dcall(sb.write, dart.dcall(Error.safeToString, value));
           i = dart.notNull(i) + 1;
         }, dart.dynamic, [Symbol, dart.dynamic]));
       }
       if (this[_existingArgumentNames] == null) {
-        return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Arguments: [${sb}]`;
+        return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${dart.dcall(Error.safeToString, this[_receiver])}\n` + `Arguments: [${sb}]`;
       } else {
-        let actualParameters = dart.toString(sb);
+        let actualParameters = dart.dcall(sb.toString);
         sb = new StringBuffer();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_existingArgumentNames][dartx.length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
-            sb.write(", ");
+            dart.dcall(sb.write, ", ");
           }
-          sb.write(this[_existingArgumentNames][dartx.get](i));
+          dart.dcall(sb.write, this[_existingArgumentNames][dartx.get](i));
         }
-        let formalParameters = dart.toString(sb);
-        return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
+        let formalParameters = dart.dcall(sb.toString);
+        return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${dart.dcall(Error.safeToString, this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
       }
     }
   }
   dart.setSignature(NoSuchMethodError, {
     constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [Object, Symbol, List, Map$(Symbol, dart.dynamic)], [List]]})
   });
   class UnsupportedError extends Error {
     UnsupportedError(message) {
       this.message = message;
       super.Error();
@@ skipping 36 matching lines @@
     ConcurrentModificationError(modifiedObject) {
       if (modifiedObject === void 0)
         modifiedObject = null;
       this.modifiedObject = modifiedObject;
       super.Error();
     }
     toString() {
       if (this.modifiedObject == null) {
         return "Concurrent modification during iteration.";
       }
-      return "Concurrent modification during iteration: " + `${Error.safeToString(this.modifiedObject)}.`;
+      return "Concurrent modification during iteration: " + `${dart.dcall(Error.safeToString, this.modifiedObject)}.`;
     }
   }
   dart.setSignature(ConcurrentModificationError, {
     constructors: () => ({ConcurrentModificationError: [ConcurrentModificationError, [], [Object]]})
   });
   class OutOfMemoryError extends Object {
     OutOfMemoryError() {
     }
     toString() {
       return "Out of Memory";
@@ skipping 83 matching lines @@
           report = dart.notNull(report) + ` (at offset ${offset})`;
         }
         return report;
       }
       if (offset != -1 && (dart.notNull(offset) < 0 || dart.notNull(offset) > dart.notNull(dart.as(dart.dload(this.source, 'length'), num)))) {
         offset = -1;
       }
       if (offset == -1) {
         let source = dart.as(this.source, String);
         if (dart.notNull(source[dartx.length]) > 78) {
-          source = dart.notNull(source[dartx.substring](0, 75)) + "...";
+          source = dart.notNull(dart.dcall(source[dartx.substring], 0, 75)) + "...";
         }
         return `${report}\n${source}`;
       }
       let lineNum = 1;
       let lineStart = 0;
       let lastWasCR = null;
       for (let i = 0; dart.notNull(i) < dart.notNull(offset); i = dart.notNull(i) + 1) {
         let char = dart.as(dart.dsend(this.source, 'codeUnitAt', i), int);
         if (char == 10) {
           if (lineStart != i || !dart.notNull(lastWasCR)) {
@@ skipping 64 matching lines @@
     class Expando extends Object {
       Expando(name) {
         if (name === void 0)
           name = null;
         this.name = name;
       }
       toString() {
         return `Expando:${this.name}`;
       }
       get(object) {
-        let values = _js_helper.Primitives.getProperty(object, Expando$()._EXPANDO_PROPERTY_NAME);
-        return values == null ? null : dart.as(_js_helper.Primitives.getProperty(values, this[_getKey]()), T);
+        let values = dart.dcall(_js_helper.Primitives.getProperty, object, Expando$()._EXPANDO_PROPERTY_NAME);
+        return values == null ? null : dart.as(dart.dcall(_js_helper.Primitives.getProperty, values, dart.dcall(this[_getKey])), T);
       }
       set(object, value) {
         dart.as(value, T);
-        let values = _js_helper.Primitives.getProperty(object, Expando$()._EXPANDO_PROPERTY_NAME);
+        let values = dart.dcall(_js_helper.Primitives.getProperty, object, Expando$()._EXPANDO_PROPERTY_NAME);
         if (values == null) {
           values = new Object();
-          _js_helper.Primitives.setProperty(object, Expando$()._EXPANDO_PROPERTY_NAME, values);
+          dart.dcall(_js_helper.Primitives.setProperty, object, Expando$()._EXPANDO_PROPERTY_NAME, values);
         }
-        _js_helper.Primitives.setProperty(values, this[_getKey](), value);
+        dart.dcall(_js_helper.Primitives.setProperty, values, dart.dcall(this[_getKey]), value);
         return value;
       }
       [_getKey]() {
-        let key = dart.as(_js_helper.Primitives.getProperty(this, Expando$()._KEY_PROPERTY_NAME), String);
+        let key = dart.as(dart.dcall(_js_helper.Primitives.getProperty, this, Expando$()._KEY_PROPERTY_NAME), String);
         if (key == null) {
           key = `expando$key$${(() => {
             let x = Expando$()._keyCount;
             Expando$()._keyCount = dart.notNull(x) + 1;
             return x;
           })()}`;
-          _js_helper.Primitives.setProperty(this, Expando$()._KEY_PROPERTY_NAME, key);
+          dart.dcall(_js_helper.Primitives.setProperty, this, Expando$()._KEY_PROPERTY_NAME, key);
         }
         return key;
       }
     }
     dart.setSignature(Expando, {
       constructors: () => ({Expando: [Expando$(T), [], [String]]}),
       methods: () => ({
         get: [T, [Object]],
         set: [dart.void, [Object, T]],
         [_getKey]: [String, []]
       })
     });
     return Expando;
   });
   let Expando = Expando$();
   Expando._KEY_PROPERTY_NAME = 'expando$key';
   Expando._EXPANDO_PROPERTY_NAME = 'expando$values';
   Expando._keyCount = 0;
   class Function extends Object {
     static apply(f, positionalArguments, namedArguments) {
       if (namedArguments === void 0)
         namedArguments = null;
       return dart.dcall.apply(null, [f].concat(positionalArguments));
     }
     static _toMangledNames(namedArguments) {
       let result = dart.map();
-      namedArguments.forEach(dart.fn((symbol, value) => {
-        result.set(_symbolToString(dart.as(symbol, Symbol)), value);
+      dart.dcall(namedArguments.forEach, dart.fn((symbol, value) => {
+        result.set(dart.dcall(_symbolToString, symbol), value);
       }));
       return result;
     }
   }
   dart.setSignature(Function, {
     statics: () => ({
       apply: [dart.dynamic, [Function, List], [Map$(Symbol, dart.dynamic)]],
       _toMangledNames: [Map$(String, dart.dynamic), [Map$(Symbol, dart.dynamic)]]
     }),
     names: ['apply', '_toMangledNames']
   });
   function identical(a, b) {
-    return _js_helper.Primitives.identicalImplementation(a, b);
+    return dart.dcall(_js_helper.Primitives.identicalImplementation, a, b);
   }
   dart.fn(identical, bool, [Object, Object]);
   function identityHashCode(object) {
-    return _js_helper.objectHashCode(object);
+    return dart.dcall(_js_helper.objectHashCode, object);
   }
   dart.fn(identityHashCode, () => dart.definiteFunctionType(int, [Object]));
   class int extends num {
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       dart.throw(new UnsupportedError('int.fromEnvironment can only be used as a const constructor'));
     }
     static parse(source, opts) {
       let radix = opts && 'radix' in opts ? opts.radix : null;
       let onError = opts && 'onError' in opts ? opts.onError : null;
-      return _js_helper.Primitives.parseInt(source, radix, onError);
+      return dart.dcall(_js_helper.Primitives.parseInt, source, radix, onError);
     }
   }
   dart.setSignature(int, {
     constructors: () => ({fromEnvironment: [int, [String], {defaultValue: int}]}),
     statics: () => ({parse: [int, [String], {radix: int, onError: dart.functionType(int, [String])}]}),
     names: ['parse']
   });
   class Invocation extends Object {
     get isAccessor() {
       return dart.notNull(this.isGetter) || dart.notNull(this.isSetter);
@@ skipping 13 matching lines @@
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E))(count, generator);
       }
       [dart.JsSymbol.iterator]() {
         return new dart.JsIterator(this[dartx.iterator]);
       }
       [dartx.join](separator) {
         if (separator === void 0)
           separator = "";
         let buffer = new StringBuffer();
-        buffer.writeAll(this, separator);
-        return dart.toString(buffer);
+        dart.dcall(buffer.writeAll, this, separator);
+        return dart.dcall(buffer.toString);
       }
     }
     dart.setSignature(Iterable, {
       constructors: () => ({
         Iterable: [Iterable$(E), []],
         generate: [Iterable$(E), [int], [dart.functionType(E, [int])]]
       }),
       methods: () => ({[dartx.join]: [String, [], [String]]})
     });
     return Iterable;
@@ skipping 21 matching lines @@
         this[_generator] = generator;
         super.IterableBase();
       }
       get iterator() {
         return new (_GeneratorIterator$(E))(this[_start], this[_end], this[_generator]);
       }
       get length() {
         return dart.notNull(this[_end]) - dart.notNull(this[_start]);
       }
       skip(count) {
-        RangeError.checkNotNegative(count, "count");
+        dart.dcall(RangeError.checkNotNegative, count, "count");
         if (count == 0)
           return this;
         let newStart = dart.notNull(this[_start]) + dart.notNull(count);
         if (dart.notNull(newStart) >= dart.notNull(this[_end]))
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E)).slice(newStart, this[_end], this[_generator]);
       }
       take(count) {
-        RangeError.checkNotNegative(count, "count");
+        dart.dcall(RangeError.checkNotNegative, count, "count");
         if (count == 0)
           return new (_internal.EmptyIterable$(E))();
         let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
         if (dart.notNull(newEnd) >= dart.notNull(this[_end]))
           return this;
         return new (exports._GeneratorIterable$(E)).slice(this[_start], newEnd, this[_generator]);
       }
       static _id(n) {
         return n;
       }
@@ skipping 21 matching lines @@
   let _GeneratorIterator$ = dart.generic(function(E) {
     class _GeneratorIterator extends Object {
       _GeneratorIterator(index, end, generator) {
         this[_index] = index;
         this[_end] = end;
         this[_generator] = generator;
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_index]) < dart.notNull(this[_end])) {
-          this[_current] = this[_generator](this[_index]);
+          this[_current] = dart.dcall(this[_generator], this[_index]);
           this[_index] = dart.notNull(this[_index]) + 1;
           return true;
         } else {
           this[_current] = null;
           return false;
         }
       }
       get current() {
         return this[_current];
       }
@@ skipping 22 matching lines @@
       static new(length) {
         if (length === void 0)
           length = null;
         let list = null;
         if (length == null) {
           list = [];
         } else {
           if (!(typeof length == 'number') || dart.notNull(length) < 0) {
             dart.throw(new ArgumentError(`Length must be a non-negative integer: ${length}`));
           }
-          list = _interceptors.JSArray.markFixedList(dart.as(new Array(length), List$()));
+          list = dart.dcall(_interceptors.JSArray.markFixedList, new Array(length));
         }
         return _interceptors.JSArray$(E).typed(list);
       }
       static filled(length, fill) {
         let result = List$(E).new(length);
         if (length != 0 && fill != null) {
           for (let i = 0; dart.notNull(i) < dart.notNull(result[dartx.length]); i = dart.notNull(i) + 1) {
             result[dartx.set](i, fill);
           }
         }
         return result;
       }
       static from(elements, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = List$(E).new();
         for (let e of elements) {
-          list[dartx.add](dart.as(e, E));
+          dart.dcall(list[dartx.add], e);
         }
         if (dart.notNull(growable))
           return list;
-        return dart.as(_internal.makeListFixedLength(list), List$(E));
+        return dart.as(dart.dcall(_internal.makeListFixedLength, list), List$(E));
       }
       static generate(length, generator, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (dart.notNull(growable)) {
           result = dart.list([], E);
           result[dartx.length] = length;
         } else {
           result = List$(E).new(length);
         }
@@ skipping 57 matching lines @@
     }
   }
   dart.setSignature(Null, {
     constructors: () => ({_uninstantiable: [Null, []]})
   });
   num._parseError = false;
   class Pattern extends Object {}
   function print(object) {
     let line = `${object}`;
     if (_internal.printToZone == null) {
-      _internal.printToConsole(line);
+      dart.dcall(_internal.printToConsole, line);
     } else {
       dart.dcall(_internal.printToZone, line);
     }
   }
   dart.fn(print, dart.void, [Object]);
   class Match extends Object {}
   class RegExp extends Object {
     static new(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
@@ skipping 34 matching lines @@
   let Sink = Sink$();
   class StackTrace extends Object {}
   let _stop = dart.JsSymbol('_stop');
   class Stopwatch extends Object {
     get frequency() {
       return Stopwatch._frequency;
     }
     Stopwatch() {
       this[_start] = null;
       this[_stop] = null;
-      Stopwatch._initTicker();
+      dart.dcall(Stopwatch._initTicker);
     }
     start() {
       if (dart.notNull(this.isRunning))
         return;
       if (this[_start] == null) {
-        this[_start] = Stopwatch._now();
+        this[_start] = dart.dcall(Stopwatch._now);
       } else {
-        this[_start] = dart.notNull(Stopwatch._now()) - (dart.notNull(this[_stop]) - dart.notNull(this[_start]));
+        this[_start] = dart.notNull(dart.dcall(Stopwatch._now)) - (dart.notNull(this[_stop]) - dart.notNull(this[_start]));
         this[_stop] = null;
       }
     }
     stop() {
       if (!dart.notNull(this.isRunning))
         return;
-      this[_stop] = Stopwatch._now();
+      this[_stop] = dart.dcall(Stopwatch._now);
     }
     reset() {
       if (this[_start] == null)
         return;
-      this[_start] = Stopwatch._now();
+      this[_start] = dart.dcall(Stopwatch._now);
       if (this[_stop] != null) {
         this[_stop] = this[_start];
       }
     }
     get elapsedTicks() {
       if (this[_start] == null) {
         return 0;
       }
-      return this[_stop] == null ? dart.notNull(Stopwatch._now()) - dart.notNull(this[_start]) : dart.notNull(this[_stop]) - dart.notNull(this[_start]);
+      return this[_stop] == null ? dart.notNull(dart.dcall(Stopwatch._now)) - dart.notNull(this[_start]) : dart.notNull(this[_stop]) - dart.notNull(this[_start]);
     }
     get elapsed() {
       return new Duration({microseconds: this.elapsedMicroseconds});
     }
     get elapsedMicroseconds() {
       return (dart.notNull(this.elapsedTicks) * 1000000 / dart.notNull(this.frequency))[dartx.truncate]();
     }
     get elapsedMilliseconds() {
       return (dart.notNull(this.elapsedTicks) * 1000 / dart.notNull(this.frequency))[dartx.truncate]();
     }
     get isRunning() {
       return this[_start] != null && this[_stop] == null;
     }
     static _initTicker() {
-      _js_helper.Primitives.initTicker();
+      dart.dcall(_js_helper.Primitives.initTicker);
       Stopwatch._frequency = _js_helper.Primitives.timerFrequency;
     }
     static _now() {
       return dart.as(dart.dcall(_js_helper.Primitives.timerTicks), int);
     }
   }
   dart.setSignature(Stopwatch, {
     constructors: () => ({Stopwatch: [Stopwatch, []]}),
     methods: () => ({
       start: [dart.void, []],
       stop: [dart.void, []],
       reset: [dart.void, []]
     }),
     statics: () => ({
       _initTicker: [dart.void, []],
       _now: [int, []]
     }),
     names: ['_initTicker', '_now']
   });
   Stopwatch._frequency = null;
   class String extends Object {
     static fromCharCodes(charCodes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (!dart.is(charCodes, _interceptors.JSArray)) {
-        return String._stringFromIterable(charCodes, start, end);
+        return dart.dcall(String._stringFromIterable, charCodes, start, end);
       }
       let list = dart.as(charCodes, List);
       let len = list[dartx.length];
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(len)) {
         dart.throw(new RangeError.range(start, 0, len));
       }
       if (end == null) {
         end = len;
       } else if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(len)) {
         dart.throw(new RangeError.range(end, start, len));
       }
       if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(len)) {
-        list = list[dartx.sublist](start, end);
+        list = dart.dcall(list[dartx.sublist], start, end);
       }
-      return _js_helper.Primitives.stringFromCharCodes(list);
+      return dart.dcall(_js_helper.Primitives.stringFromCharCodes, list);
     }
     static fromCharCode(charCode) {
-      return _js_helper.Primitives.stringFromCharCode(charCode);
+      return dart.dcall(_js_helper.Primitives.stringFromCharCode, charCode);
     }
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       dart.throw(new UnsupportedError('String.fromEnvironment can only be used as a const constructor'));
     }
     static _stringFromIterable(charCodes, start, end) {
       if (dart.notNull(start) < 0)
         dart.throw(new RangeError.range(start, 0, charCodes[dartx.length]));
       if (end != null && dart.notNull(end) < dart.notNull(start)) {
         dart.throw(new RangeError.range(end, start, charCodes[dartx.length]));
       }
       let it = charCodes[dartx.iterator];
       for (let i = 0; dart.notNull(i) < dart.notNull(start); i = dart.notNull(i) + 1) {
-        if (!dart.notNull(it.moveNext())) {
+        if (!dart.notNull(dart.as(dart.dsend(it, 'moveNext'), bool))) {
           dart.throw(new RangeError.range(start, 0, i));
         }
       }
       let list = [];
       if (end == null) {
-        while (dart.notNull(it.moveNext()))
-          list[dartx.add](it.current);
+        while (dart.notNull(dart.as(dart.dsend(it, 'moveNext'), bool)))
+          dart.dsend(list, 'add', dart.dload(it, 'current'));
       } else {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-          if (!dart.notNull(it.moveNext())) {
+          if (!dart.notNull(dart.as(dart.dsend(it, 'moveNext'), bool))) {
             dart.throw(new RangeError.range(end, start, i));
           }
-          list[dartx.add](it.current);
+          dart.dsend(list, 'add', dart.dload(it, 'current'));
         }
       }
-      return _js_helper.Primitives.stringFromCharCodes(list);
+      return dart.dcall(_js_helper.Primitives.stringFromCharCodes, list);
     }
   }
   String[dart.implements] = () => [Comparable$(String), Pattern];
   dart.setSignature(String, {
     constructors: () => ({
       fromCharCodes: [String, [Iterable$(int)], [int, int]],
       fromCharCode: [String, [int]],
       fromEnvironment: [String, [String], {defaultValue: String}]
     }),
     statics: () => ({_stringFromIterable: [String, [Iterable$(int), int, int]]}),
     names: ['_stringFromIterable']
   });
   dart.defineLazyClass(exports, {
     get Runes() {
       class Runes extends collection.IterableBase$(int) {
         Runes(string) {
           this.string = string;
           super.IterableBase();
         }
         get iterator() {
           return new RuneIterator(this.string);
         }
         get last() {
           if (this.string[dartx.length] == 0) {
             dart.throw(new StateError('No elements.'));
           }
           let length = this.string[dartx.length];
-          let code = this.string[dartx.codeUnitAt](dart.notNull(length) - 1);
-          if (dart.notNull(_isTrailSurrogate(code)) && dart.notNull(this.string[dartx.length]) > 1) {
-            let previousCode = this.string[dartx.codeUnitAt](dart.notNull(length) - 2);
-            if (dart.notNull(_isLeadSurrogate(previousCode))) {
-              return _combineSurrogatePair(previousCode, code);
+          let code = dart.dcall(this.string[dartx.codeUnitAt], dart.notNull(length) - 1);
+          if (dart.notNull(dart.dcall(_isTrailSurrogate, code)) && dart.notNull(this.string[dartx.length]) > 1) {
+            let previousCode = dart.dcall(this.string[dartx.codeUnitAt], dart.notNull(length) - 2);
+            if (dart.notNull(dart.dcall(_isLeadSurrogate, previousCode))) {
+              return dart.dcall(_combineSurrogatePair, previousCode, code);
             }
           }
           return code;
         }
       }
       dart.setSignature(Runes, {
         constructors: () => ({Runes: [exports.Runes, [String]]})
       });
       dart.defineExtensionMembers(Runes, ['iterator', 'last']);
       return Runes;
@@ skipping 20 matching lines @@
       this.string = string;
       this[_position] = 0;
       this[_nextPosition] = 0;
       this[_currentCodePoint] = null;
     }
     at(string, index) {
       this.string = string;
       this[_position] = index;
       this[_nextPosition] = index;
       this[_currentCodePoint] = null;
-      RangeError.checkValueInInterval(index, 0, string[dartx.length]);
-      this[_checkSplitSurrogate](index);
+      dart.dcall(RangeError.checkValueInInterval, index, 0, string[dartx.length]);
+      dart.dcall(this[_checkSplitSurrogate], index);
     }
     [_checkSplitSurrogate](index) {
-      if (dart.notNull(index) > 0 && dart.notNull(index) < dart.notNull(this.string[dartx.length]) && dart.notNull(_isLeadSurrogate(this.string[dartx.codeUnitAt](dart.notNull(index) - 1))) && dart.notNull(_isTrailSurrogate(this.string[dartx.codeUnitAt](index)))) {
+      if (dart.notNull(index) > 0 && dart.notNull(index) < dart.notNull(this.string[dartx.length]) && dart.notNull(dart.dcall(_isLeadSurrogate, dart.dcall(this.string[dartx.codeUnitAt], dart.notNull(index) - 1))) && dart.notNull(dart.dcall(_isTrailSurrogate, dart.dcall(this.string[dartx.codeUnitAt], index)))) {
         dart.throw(new ArgumentError(`Index inside surrogate pair: ${index}`));
       }
     }
     get rawIndex() {
       return this[_position] != this[_nextPosition] ? this[_position] : null;
     }
     set rawIndex(rawIndex) {
-      RangeError.checkValidIndex(rawIndex, this.string, "rawIndex");
-      this.reset(rawIndex);
-      this.moveNext();
+      dart.dcall(RangeError.checkValidIndex, rawIndex, this.string, "rawIndex");
+      dart.dcall(this.reset, rawIndex);
+      dart.dcall(this.moveNext);
     }
     reset(rawIndex) {
       if (rawIndex === void 0)
         rawIndex = 0;
-      RangeError.checkValueInInterval(rawIndex, 0, this.string[dartx.length], "rawIndex");
-      this[_checkSplitSurrogate](rawIndex);
+      dart.dcall(RangeError.checkValueInInterval, rawIndex, 0, this.string[dartx.length], "rawIndex");
+      dart.dcall(this[_checkSplitSurrogate], rawIndex);
       this[_position] = this[_nextPosition] = rawIndex;
       this[_currentCodePoint] = null;
     }
     get current() {
       return this[_currentCodePoint];
     }
     get currentSize() {
       return dart.notNull(this[_nextPosition]) - dart.notNull(this[_position]);
     }
     get currentAsString() {
       if (this[_position] == this[_nextPosition])
         return null;
       if (dart.notNull(this[_position]) + 1 == this[_nextPosition])
         return this.string[dartx.get](this[_position]);
-      return this.string[dartx.substring](this[_position], this[_nextPosition]);
+      return dart.dcall(this.string[dartx.substring], this[_position], this[_nextPosition]);
     }
     moveNext() {
       this[_position] = this[_nextPosition];
       if (this[_position] == this.string[dartx.length]) {
         this[_currentCodePoint] = null;
         return false;
       }
-      let codeUnit = this.string[dartx.codeUnitAt](this[_position]);
+      let codeUnit = dart.dcall(this.string[dartx.codeUnitAt], this[_position]);
       let nextPosition = dart.notNull(this[_position]) + 1;
-      if (dart.notNull(_isLeadSurrogate(codeUnit)) && dart.notNull(nextPosition) < dart.notNull(this.string[dartx.length])) {
-        let nextCodeUnit = this.string[dartx.codeUnitAt](nextPosition);
-        if (dart.notNull(_isTrailSurrogate(nextCodeUnit))) {
+      if (dart.notNull(dart.dcall(_isLeadSurrogate, codeUnit)) && dart.notNull(nextPosition) < dart.notNull(this.string[dartx.length])) {
+        let nextCodeUnit = dart.dcall(this.string[dartx.codeUnitAt], nextPosition);
+        if (dart.notNull(dart.dcall(_isTrailSurrogate, nextCodeUnit))) {
           this[_nextPosition] = dart.notNull(nextPosition) + 1;
-          this[_currentCodePoint] = _combineSurrogatePair(codeUnit, nextCodeUnit);
+          this[_currentCodePoint] = dart.dcall(_combineSurrogatePair, codeUnit, nextCodeUnit);
           return true;
         }
       }
       this[_nextPosition] = nextPosition;
       this[_currentCodePoint] = codeUnit;
       return true;
     }
     movePrevious() {
       this[_nextPosition] = this[_position];
       if (this[_position] == 0) {
         this[_currentCodePoint] = null;
         return false;
       }
       let position = dart.notNull(this[_position]) - 1;
-      let codeUnit = this.string[dartx.codeUnitAt](position);
-      if (dart.notNull(_isTrailSurrogate(codeUnit)) && dart.notNull(position) > 0) {
-        let prevCodeUnit = this.string[dartx.codeUnitAt](dart.notNull(position) - 1);
-        if (dart.notNull(_isLeadSurrogate(prevCodeUnit))) {
+      let codeUnit = dart.dcall(this.string[dartx.codeUnitAt], position);
+      if (dart.notNull(dart.dcall(_isTrailSurrogate, codeUnit)) && dart.notNull(position) > 0) {
+        let prevCodeUnit = dart.dcall(this.string[dartx.codeUnitAt], dart.notNull(position) - 1);
+        if (dart.notNull(dart.dcall(_isLeadSurrogate, prevCodeUnit))) {
           this[_position] = dart.notNull(position) - 1;
-          this[_currentCodePoint] = _combineSurrogatePair(prevCodeUnit, codeUnit);
+          this[_currentCodePoint] = dart.dcall(_combineSurrogatePair, prevCodeUnit, codeUnit);
           return true;
         }
       }
       this[_position] = position;
       this[_currentCodePoint] = codeUnit;
       return true;
     }
   }
   RuneIterator[dart.implements] = () => [BidirectionalIterator$(int)];
   dart.defineNamedConstructor(RuneIterator, 'at');
@@ skipping 20 matching lines @@
     get length() {
       return this[_contents][dartx.length];
     }
     get isEmpty() {
       return this.length == 0;
     }
     get isNotEmpty() {
       return !dart.notNull(this.isEmpty);
     }
     write(obj) {
-      this[_writeString](`${obj}`);
+      dart.dcall(this[_writeString], `${obj}`);
     }
     writeCharCode(charCode) {
-      this[_writeString](String.fromCharCode(charCode));
+      dart.dcall(this[_writeString], String.fromCharCode(charCode));
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
       let iterator = objects[dartx.iterator];
-      if (!dart.notNull(iterator.moveNext()))
+      if (!dart.notNull(dart.dcall(iterator.moveNext)))
         return;
       if (dart.notNull(separator[dartx.isEmpty])) {
         do {
-          this.write(iterator.current);
-        } while (dart.notNull(iterator.moveNext()));
+          dart.dcall(this.write, iterator.current);
+        } while (dart.notNull(dart.dcall(iterator.moveNext)));
       } else {
-        this.write(iterator.current);
-        while (dart.notNull(iterator.moveNext())) {
-          this.write(separator);
-          this.write(iterator.current);
+        dart.dcall(this.write, iterator.current);
+        while (dart.notNull(dart.dcall(iterator.moveNext))) {
+          dart.dcall(this.write, separator);
+          dart.dcall(this.write, iterator.current);
         }
       }
     }
     writeln(obj) {
       if (obj === void 0)
         obj = "";
-      this.write(obj);
-      this.write("\n");
+      dart.dcall(this.write, obj);
+      dart.dcall(this.write, "\n");
     }
     clear() {
       this[_contents] = "";
     }
     toString() {
-      return _js_helper.Primitives.flattenString(this[_contents]);
+      return dart.dcall(_js_helper.Primitives.flattenString, this[_contents]);
     }
     [_writeString](str) {
-      this[_contents] = _js_helper.Primitives.stringConcatUnchecked(this[_contents], dart.as(str, String));
+      this[_contents] = dart.dcall(_js_helper.Primitives.stringConcatUnchecked, this[_contents], str);
     }
   }
   StringBuffer[dart.implements] = () => [StringSink];
   dart.setSignature(StringBuffer, {
     constructors: () => ({StringBuffer: [StringBuffer, [], [Object]]}),
     methods: () => ({
       write: [dart.void, [Object]],
       writeCharCode: [dart.void, [int]],
       writeAll: [dart.void, [Iterable], [String]],
       writeln: [dart.void, [], [Object]],
@@ skipping 24 matching lines @@
   let _hasDotSegments = dart.JsSymbol('_hasDotSegments');
   let _removeDotSegments = dart.JsSymbol('_removeDotSegments');
   let _toWindowsFilePath = dart.JsSymbol('_toWindowsFilePath');
   let _toFilePath = dart.JsSymbol('_toFilePath');
   let _isPathAbsolute = dart.JsSymbol('_isPathAbsolute');
   class Uri extends Object {
     get authority() {
       if (!dart.notNull(this.hasAuthority))
         return "";
       let sb = new StringBuffer();
-      this[_writeAuthority](sb);
-      return dart.toString(sb);
+      dart.dcall(this[_writeAuthority], sb);
+      return dart.as(dart.dsend(sb, 'toString'), String);
     }
     get userInfo() {
       return this[_userInfo];
     }
     get host() {
       if (this[_host] == null)
         return "";
-      if (dart.notNull(this[_host][dartx.startsWith]('['))) {
-        return this[_host][dartx.substring](1, dart.notNull(this[_host][dartx.length]) - 1);
+      if (dart.notNull(dart.dcall(this[_host][dartx.startsWith], '['))) {
+        return dart.dcall(this[_host][dartx.substring], 1, dart.notNull(this[_host][dartx.length]) - 1);
       }
       return this[_host];
     }
     get port() {
       if (this[_port] == null)
-        return Uri._defaultPort(this.scheme);
+        return dart.dcall(Uri._defaultPort, this.scheme);
       return this[_port];
     }
     static _defaultPort(scheme) {
       if (scheme == "http")
         return 80;
       if (scheme == "https")
         return 443;
       return 0;
     }
     get path() {
       return this[_path];
     }
     get query() {
       return this[_query] == null ? "" : this[_query];
     }
     get fragment() {
       return this[_fragment] == null ? "" : this[_fragment];
     }
     static parse(uri) {
       function isRegName(ch) {
-        return dart.notNull(ch) < 128 && !dart.equals(dart.dsend(Uri._regNameTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
+        return dart.notNull(ch) < 128 && !dart.equals(dart.dsend(dart.dindex(Uri._regNameTable, dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
       }
       dart.fn(isRegName, bool, [int]);
       let EOI = -1;
       let scheme = "";
       let userinfo = "";
       let host = null;
       let port = null;
       let path = null;
       let query = null;
       let fragment = null;
       let index = 0;
       let pathStart = 0;
       let char = EOI;
       function parseAuth() {
         if (index == uri[dartx.length]) {
           char = EOI;
           return;
         }
         let authStart = index;
         let lastColon = -1;
         let lastAt = -1;
-        char = uri[dartx.codeUnitAt](index);
+        char = dart.dcall(uri[dartx.codeUnitAt], index);
         while (dart.notNull(index) < dart.notNull(uri[dartx.length])) {
-          char = uri[dartx.codeUnitAt](index);
+          char = dart.dcall(uri[dartx.codeUnitAt], index);
           if (char == Uri._SLASH || char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
             break;
           }
           if (char == Uri._AT_SIGN) {
             lastAt = index;
             lastColon = -1;
           } else if (char == Uri._COLON) {
             lastColon = index;
           } else if (char == Uri._LEFT_BRACKET) {
             lastColon = -1;
-            let endBracket = uri[dartx.indexOf](']', dart.notNull(index) + 1);
+            let endBracket = dart.dcall(uri[dartx.indexOf], ']', dart.notNull(index) + 1);
             if (endBracket == -1) {
               index = uri[dartx.length];
               char = EOI;
               break;
             } else {
               index = endBracket;
             }
           }
           index = dart.notNull(index) + 1;
           char = EOI;
         }
         let hostStart = authStart;
         let hostEnd = index;
         if (dart.notNull(lastAt) >= 0) {
-          userinfo = Uri._makeUserInfo(uri, authStart, lastAt);
+          userinfo = dart.dcall(Uri._makeUserInfo, uri, authStart, lastAt);
           hostStart = dart.notNull(lastAt) + 1;
         }
         if (dart.notNull(lastColon) >= 0) {
           let portNumber = null;
           if (dart.notNull(lastColon) + 1 < dart.notNull(index)) {
             portNumber = 0;
             for (let i = dart.notNull(lastColon) + 1; dart.notNull(i) < dart.notNull(index); i = dart.notNull(i) + 1) {
-              let digit = uri[dartx.codeUnitAt](i);
+              let digit = dart.dcall(uri[dartx.codeUnitAt], i);
               if (dart.notNull(Uri._ZERO) > dart.notNull(digit) || dart.notNull(Uri._NINE) < dart.notNull(digit)) {
-                Uri._fail(uri, i, "Invalid port number");
+                dart.dcall(Uri._fail, uri, i, "Invalid port number");
               }
               portNumber = dart.notNull(portNumber) * 10 + (dart.notNull(digit) - dart.notNull(Uri._ZERO));
             }
           }
-          port = Uri._makePort(portNumber, scheme);
+          port = dart.dcall(Uri._makePort, portNumber, scheme);
           hostEnd = lastColon;
         }
-        host = Uri._makeHost(uri, hostStart, hostEnd, true);
+        host = dart.dcall(Uri._makeHost, uri, hostStart, hostEnd, true);
         if (dart.notNull(index) < dart.notNull(uri[dartx.length])) {
-          char = uri[dartx.codeUnitAt](index);
+          char = dart.dcall(uri[dartx.codeUnitAt], index);
         }
       }
       dart.fn(parseAuth, dart.void, []);
       let NOT_IN_PATH = 0;
       let IN_PATH = 1;
       let ALLOW_AUTH = 2;
       let state = NOT_IN_PATH;
       let i = index;
       while (dart.notNull(i) < dart.notNull(uri[dartx.length])) {
-        char = uri[dartx.codeUnitAt](i);
+        char = dart.dcall(uri[dartx.codeUnitAt], i);
         if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
           state = NOT_IN_PATH;
           break;
         }
         if (char == Uri._SLASH) {
           state = i == 0 ? ALLOW_AUTH : IN_PATH;
           break;
         }
         if (char == Uri._COLON) {
           if (i == 0)
-            Uri._fail(uri, 0, "Invalid empty scheme");
-          scheme = Uri._makeScheme(uri, i);
+            dart.dcall(Uri._fail, uri, 0, "Invalid empty scheme");
+          scheme = dart.dcall(Uri._makeScheme, uri, i);
           i = dart.notNull(i) + 1;
           pathStart = i;
           if (i == uri[dartx.length]) {
             char = EOI;
             state = NOT_IN_PATH;
           } else {
-            char = uri[dartx.codeUnitAt](i);
+            char = dart.dcall(uri[dartx.codeUnitAt], i);
             if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
               state = NOT_IN_PATH;
             } else if (char == Uri._SLASH) {
               state = ALLOW_AUTH;
             } else {
               state = IN_PATH;
             }
           }
           break;
         }
         i = dart.notNull(i) + 1;
         char = EOI;
       }
       index = i;
       if (state == ALLOW_AUTH) {
         dart.assert(char == Uri._SLASH);
         index = dart.notNull(index) + 1;
         if (index == uri[dartx.length]) {
           char = EOI;
           state = NOT_IN_PATH;
         } else {
-          char = uri[dartx.codeUnitAt](index);
+          char = dart.dcall(uri[dartx.codeUnitAt], index);
           if (char == Uri._SLASH) {
             index = dart.notNull(index) + 1;
-            parseAuth();
+            dart.dcall(parseAuth);
             pathStart = index;
           }
           if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN || char == EOI) {
             state = NOT_IN_PATH;
           } else {
             state = IN_PATH;
           }
         }
       }
       dart.assert(state == IN_PATH || state == NOT_IN_PATH);
       if (state == IN_PATH) {
         while ((index = dart.notNull(index) + 1) < dart.notNull(uri[dartx.length])) {
-          char = uri[dartx.codeUnitAt](index);
+          char = dart.dcall(uri[dartx.codeUnitAt], index);
           if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
             break;
           }
           char = EOI;
         }
         state = NOT_IN_PATH;
       }
       dart.assert(state == NOT_IN_PATH);
       let isFile = scheme == "file";
       let ensureLeadingSlash = host != null;
-      path = Uri._makePath(uri, pathStart, index, null, ensureLeadingSlash, isFile);
+      path = dart.dcall(Uri._makePath, uri, pathStart, index, null, ensureLeadingSlash, isFile);
       if (char == Uri._QUESTION) {
-        let numberSignIndex = uri[dartx.indexOf]('#', dart.notNull(index) + 1);
+        let numberSignIndex = dart.dcall(uri[dartx.indexOf], '#', dart.notNull(index) + 1);
         if (dart.notNull(numberSignIndex) < 0) {
-          query = Uri._makeQuery(uri, dart.notNull(index) + 1, uri[dartx.length], null);
+          query = dart.dcall(Uri._makeQuery, uri, dart.notNull(index) + 1, uri[dartx.length], null);
         } else {
-          query = Uri._makeQuery(uri, dart.notNull(index) + 1, numberSignIndex, null);
-          fragment = Uri._makeFragment(uri, dart.notNull(numberSignIndex) + 1, uri[dartx.length]);
+          query = dart.dcall(Uri._makeQuery, uri, dart.notNull(index) + 1, numberSignIndex, null);
+          fragment = dart.dcall(Uri._makeFragment, uri, dart.notNull(numberSignIndex) + 1, uri[dartx.length]);
         }
       } else if (char == Uri._NUMBER_SIGN) {
-        fragment = Uri._makeFragment(uri, dart.notNull(index) + 1, uri[dartx.length]);
+        fragment = dart.dcall(Uri._makeFragment, uri, dart.notNull(index) + 1, uri[dartx.length]);
       }
       return new Uri._internal(scheme, userinfo, host, port, path, query, fragment);
     }
     static _fail(uri, index, message) {
       dart.throw(new FormatException(message, uri, index));
     }
     _internal(scheme, userInfo, host, port, path, query, fragment) {
       this.scheme = scheme;
       this[_userInfo] = userInfo;
       this[_host] = host;
       this[_port] = port;
       this[_path] = path;
       this[_query] = query;
       this[_fragment] = fragment;
       this[_pathSegments] = null;
       this[_queryParameters] = null;
     }
     static new(opts) {
       let scheme = opts && 'scheme' in opts ? opts.scheme : "";
       let userInfo = opts && 'userInfo' in opts ? opts.userInfo : "";
       let host = opts && 'host' in opts ? opts.host : null;
       let port = opts && 'port' in opts ? opts.port : null;
       let path = opts && 'path' in opts ? opts.path : null;
       let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
       let query = opts && 'query' in opts ? opts.query : null;
       let queryParameters = opts && 'queryParameters' in opts ? opts.queryParameters : null;
       let fragment = opts && 'fragment' in opts ? opts.fragment : null;
-      scheme = Uri._makeScheme(scheme, Uri._stringOrNullLength(scheme));
-      userInfo = Uri._makeUserInfo(userInfo, 0, Uri._stringOrNullLength(userInfo));
-      host = Uri._makeHost(host, 0, Uri._stringOrNullLength(host), false);
+      scheme = dart.dcall(Uri._makeScheme, scheme, dart.dcall(Uri._stringOrNullLength, scheme));
+      userInfo = dart.dcall(Uri._makeUserInfo, userInfo, 0, dart.dcall(Uri._stringOrNullLength, userInfo));
+      host = dart.dcall(Uri._makeHost, host, 0, dart.dcall(Uri._stringOrNullLength, host), false);
       if (query == "")
         query = null;
-      query = Uri._makeQuery(query, 0, Uri._stringOrNullLength(query), queryParameters);
-      fragment = Uri._makeFragment(fragment, 0, Uri._stringOrNullLength(fragment));
-      port = Uri._makePort(port, scheme);
+      query = dart.dcall(Uri._makeQuery, query, 0, dart.dcall(Uri._stringOrNullLength, query), queryParameters);
+      fragment = dart.dcall(Uri._makeFragment, fragment, 0, dart.dcall(Uri._stringOrNullLength, fragment));
+      port = dart.dcall(Uri._makePort, port, scheme);
       let isFile = scheme == "file";
       if (host == null && (dart.notNull(userInfo[dartx.isNotEmpty]) || port != null || dart.notNull(isFile))) {
         host = "";
       }
       let ensureLeadingSlash = host != null;
-      path = Uri._makePath(path, 0, Uri._stringOrNullLength(path), pathSegments, ensureLeadingSlash, isFile);
+      path = dart.dcall(Uri._makePath, path, 0, dart.dcall(Uri._stringOrNullLength, path), pathSegments, ensureLeadingSlash, isFile);
       return new Uri._internal(scheme, userInfo, host, port, path, query, fragment);
     }
     static http(authority, unencodedPath, queryParameters) {
       if (queryParameters === void 0)
         queryParameters = null;
-      return Uri._makeHttpUri("http", authority, unencodedPath, queryParameters);
+      return dart.dcall(Uri._makeHttpUri, "http", authority, unencodedPath, queryParameters);
     }
     static https(authority, unencodedPath, queryParameters) {
       if (queryParameters === void 0)
         queryParameters = null;
-      return Uri._makeHttpUri("https", authority, unencodedPath, queryParameters);
+      return dart.dcall(Uri._makeHttpUri, "https", authority, unencodedPath, queryParameters);
     }
     static _makeHttpUri(scheme, authority, unencodedPath, queryParameters) {
       let userInfo = "";
       let host = null;
       let port = null;
       if (authority != null && dart.notNull(authority[dartx.isNotEmpty])) {
         let hostStart = 0;
         let hasUserInfo = false;
         for (let i = 0; dart.notNull(i) < dart.notNull(authority[dartx.length]); i = dart.notNull(i) + 1) {
-          if (authority[dartx.codeUnitAt](i) == Uri._AT_SIGN) {
+          if (dart.dcall(authority[dartx.codeUnitAt], i) == Uri._AT_SIGN) {
             hasUserInfo = true;
-            userInfo = authority[dartx.substring](0, i);
+            userInfo = dart.dcall(authority[dartx.substring], 0, i);
             hostStart = dart.notNull(i) + 1;
             break;
           }
         }
         let hostEnd = hostStart;
-        if (dart.notNull(hostStart) < dart.notNull(authority[dartx.length]) && authority[dartx.codeUnitAt](hostStart) == Uri._LEFT_BRACKET) {
-          for (; dart.notNull(hostEnd) < dart.notNull(authority[dartx.length]); hostEnd = dart.notNull(hostEnd) + 1) {
-            if (authority[dartx.codeUnitAt](hostEnd) == Uri._RIGHT_BRACKET)
+        if (dart.notNull(dart.as(dart.dsend(hostStart, '<', authority[dartx.length]), bool)) && dart.dcall(authority[dartx.codeUnitAt], hostStart) == Uri._LEFT_BRACKET) {
+          for (; dart.notNull(dart.as(dart.dsend(hostEnd, '<', authority[dartx.length]), bool)); hostEnd = dart.dsend(hostEnd, '+', 1)) {
+            if (dart.dcall(authority[dartx.codeUnitAt], hostEnd) == Uri._RIGHT_BRACKET)
               break;
           }
-          if (hostEnd == authority[dartx.length]) {
-            dart.throw(new FormatException("Invalid IPv6 host entry.", authority, hostStart));
+          if (dart.equals(hostEnd, authority[dartx.length])) {
+            dart.throw(new FormatException("Invalid IPv6 host entry.", authority, dart.as(hostStart, int)));
           }
-          Uri.parseIPv6Address(authority, dart.notNull(hostStart) + 1, hostEnd);
-          hostEnd = dart.notNull(hostEnd) + 1;
-          if (hostEnd != authority[dartx.length] && authority[dartx.codeUnitAt](hostEnd) != Uri._COLON) {
-            dart.throw(new FormatException("Invalid end of authority", authority, hostEnd));
+          dart.dcall(Uri.parseIPv6Address, authority, dart.dsend(hostStart, '+', 1), hostEnd);
+          hostEnd = dart.dsend(hostEnd, '+', 1);
+          if (!dart.equals(hostEnd, authority[dartx.length]) && dart.dcall(authority[dartx.codeUnitAt], hostEnd) != Uri._COLON) {
+            dart.throw(new FormatException("Invalid end of authority", authority, dart.as(hostEnd, int)));
           }
         }
         let hasPort = false;
-        for (; dart.notNull(hostEnd) < dart.notNull(authority[dartx.length]); hostEnd = dart.notNull(hostEnd) + 1) {
-          if (authority[dartx.codeUnitAt](hostEnd) == Uri._COLON) {
-            let portString = authority[dartx.substring](dart.notNull(hostEnd) + 1);
-            if (dart.notNull(portString[dartx.isNotEmpty]))
-              port = int.parse(portString);
+        for (; dart.notNull(dart.as(dart.dsend(hostEnd, '<', authority[dartx.length]), bool)); hostEnd = dart.dsend(hostEnd, '+', 1)) {
+          if (dart.dcall(authority[dartx.codeUnitAt], hostEnd) == Uri._COLON) {
+            let portString = dart.dcall(authority[dartx.substring], dart.dsend(hostEnd, '+', 1));
+            if (dart.notNull(dart.as(dart.dload(portString, 'isNotEmpty'), bool)))
+              port = dart.dcall(int.parse, portString);
             break;
           }
         }
-        host = authority[dartx.substring](hostStart, hostEnd);
+        host = dart.dcall(authority[dartx.substring], hostStart, hostEnd);
       }
-      return Uri.new({scheme: scheme, userInfo: userInfo, host: dart.as(host, String), port: dart.as(port, int), pathSegments: unencodedPath[dartx.split]("/"), queryParameters: queryParameters});
+      return Uri.new({scheme: scheme, userInfo: dart.as(userInfo, String), host: dart.as(host, String), port: dart.as(port, int), pathSegments: dart.dcall(unencodedPath[dartx.split], "/"), queryParameters: queryParameters});
     }
     static file(path, opts) {
       let windows = opts && 'windows' in opts ? opts.windows : null;
       windows = windows == null ? Uri._isWindows : windows;
-      return dart.notNull(windows) ? dart.as(Uri._makeWindowsFileUrl(path), Uri) : dart.as(Uri._makeFileUri(path), Uri);
+      return dart.notNull(windows) ? dart.as(dart.dcall(Uri._makeWindowsFileUrl, path), Uri) : dart.as(dart.dcall(Uri._makeFileUri, path), Uri);
     }
     static get base() {
-      let uri = _js_helper.Primitives.currentUri();
+      let uri = dart.dcall(_js_helper.Primitives.currentUri);
       if (uri != null)
-        return Uri.parse(uri);
+        return dart.dcall(Uri.parse, uri);
       dart.throw(new UnsupportedError("'Uri.base' is not supported"));
     }
     static get _isWindows() {
       return false;
     }
     static _checkNonWindowsPathReservedCharacters(segments, argumentError) {
-      segments[dartx.forEach](dart.fn(segment => {
+      dart.dcall(segments[dartx.forEach], dart.fn(segment => {
         if (dart.notNull(dart.as(dart.dsend(segment, 'contains', "/"), bool))) {
           if (dart.notNull(argumentError)) {
             dart.throw(new ArgumentError(`Illegal path character ${segment}`));
           } else {
             dart.throw(new UnsupportedError(`Illegal path character ${segment}`));
           }
         }
       }));
     }
     static _checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) {
       if (firstSegment === void 0)
         firstSegment = 0;
-      segments[dartx.skip](firstSegment)[dartx.forEach](dart.fn(segment => {
+      dart.dcall(dart.dcall(segments[dartx.skip], firstSegment)[dartx.forEach], dart.fn(segment => {
         if (dart.notNull(dart.as(dart.dsend(segment, 'contains', RegExp.new('["*/:<>?\\\\|]')), bool))) {
           if (dart.notNull(argumentError)) {
             dart.throw(new ArgumentError("Illegal character in path"));
           } else {
             dart.throw(new UnsupportedError("Illegal character in path"));
           }
         }
       }));
     }
     static _checkWindowsDriveLetter(charCode, argumentError) {
       if (dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._UPPER_CASE_Z) || dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._LOWER_CASE_Z)) {
         return;
       }
       if (dart.notNull(argumentError)) {
         dart.throw(new ArgumentError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode))));
       } else {
         dart.throw(new UnsupportedError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode))));
       }
     }
     static _makeFileUri(path) {
       let sep = "/";
-      if (dart.notNull(path[dartx.startsWith](sep))) {
-        return Uri.new({scheme: "file", pathSegments: path[dartx.split](sep)});
+      if (dart.notNull(dart.dcall(path[dartx.startsWith], sep))) {
+        return Uri.new({scheme: "file", pathSegments: dart.dcall(path[dartx.split], sep)});
       } else {
-        return Uri.new({pathSegments: path[dartx.split](sep)});
+        return Uri.new({pathSegments: dart.dcall(path[dartx.split], sep)});
       }
     }
     static _makeWindowsFileUrl(path) {
-      if (dart.notNull(path[dartx.startsWith]("\\\\?\\"))) {
-        if (dart.notNull(path[dartx.startsWith]("\\\\?\\UNC\\"))) {
-          path = `\\${path[dartx.substring](7)}`;
+      if (dart.notNull(dart.dcall(path[dartx.startsWith], "\\\\?\\"))) {
+        if (dart.notNull(dart.dcall(path[dartx.startsWith], "\\\\?\\UNC\\"))) {
+          path = `\\${dart.dcall(path[dartx.substring], 7)}`;
         } else {
-          path = path[dartx.substring](4);
-          if (dart.notNull(path[dartx.length]) < 3 || path[dartx.codeUnitAt](1) != Uri._COLON || path[dartx.codeUnitAt](2) != Uri._BACKSLASH) {
+          path = dart.dcall(path[dartx.substring], 4);
+          if (dart.notNull(path[dartx.length]) < 3 || dart.dcall(path[dartx.codeUnitAt], 1) != Uri._COLON || dart.dcall(path[dartx.codeUnitAt], 2) != Uri._BACKSLASH) {
             dart.throw(new ArgumentError("Windows paths with \\\\?\\ prefix must be absolute"));
           }
         }
       } else {
-        path = path[dartx.replaceAll]("/", "\\");
+        path = dart.dcall(path[dartx.replaceAll], "/", "\\");
       }
       let sep = "\\";
       if (dart.notNull(path[dartx.length]) > 1 && path[dartx.get](1) == ":") {
-        Uri._checkWindowsDriveLetter(path[dartx.codeUnitAt](0), true);
-        if (path[dartx.length] == 2 || path[dartx.codeUnitAt](2) != Uri._BACKSLASH) {
+        dart.dcall(Uri._checkWindowsDriveLetter, dart.dcall(path[dartx.codeUnitAt], 0), true);
+        if (path[dartx.length] == 2 || dart.dcall(path[dartx.codeUnitAt], 2) != Uri._BACKSLASH) {
           dart.throw(new ArgumentError("Windows paths with drive letter must be absolute"));
         }
-        let pathSegments = path[dartx.split](sep);
-        Uri._checkWindowsPathReservedCharacters(pathSegments, true, 1);
-        return Uri.new({scheme: "file", pathSegments: pathSegments});
+        let pathSegments = dart.dcall(path[dartx.split], sep);
+        dart.dcall(Uri._checkWindowsPathReservedCharacters, pathSegments, true, 1);
+        return Uri.new({scheme: "file", pathSegments: dart.as(pathSegments, Iterable$(String))});
       }
       if (dart.notNull(path[dartx.length]) > 0 && path[dartx.get](0) == sep) {
         if (dart.notNull(path[dartx.length]) > 1 && path[dartx.get](1) == sep) {
-          let pathStart = path[dartx.indexOf]("\\", 2);
-          let hostPart = pathStart == -1 ? path[dartx.substring](2) : path[dartx.substring](2, pathStart);
-          let pathPart = pathStart == -1 ? "" : path[dartx.substring](dart.notNull(pathStart) + 1);
-          let pathSegments = pathPart[dartx.split](sep);
-          Uri._checkWindowsPathReservedCharacters(pathSegments, true);
-          return Uri.new({scheme: "file", host: hostPart, pathSegments: pathSegments});
+          let pathStart = dart.dcall(path[dartx.indexOf], "\\", 2);
+          let hostPart = pathStart == -1 ? dart.dcall(path[dartx.substring], 2) : dart.dcall(path[dartx.substring], 2, pathStart);
+          let pathPart = pathStart == -1 ? "" : dart.dcall(path[dartx.substring], dart.notNull(pathStart) + 1);
+          let pathSegments = dart.dcall(pathPart[dartx.split], sep);
+          dart.dcall(Uri._checkWindowsPathReservedCharacters, pathSegments, true);
+          return Uri.new({scheme: "file", host: hostPart, pathSegments: dart.as(pathSegments, Iterable$(String))});
         } else {
-          let pathSegments = path[dartx.split](sep);
-          Uri._checkWindowsPathReservedCharacters(pathSegments, true);
-          return Uri.new({scheme: "file", pathSegments: pathSegments});
+          let pathSegments = dart.dcall(path[dartx.split], sep);
+          dart.dcall(Uri._checkWindowsPathReservedCharacters, pathSegments, true);
+          return Uri.new({scheme: "file", pathSegments: dart.as(pathSegments, Iterable$(String))});
         }
       } else {
-        let pathSegments = path[dartx.split](sep);
-        Uri._checkWindowsPathReservedCharacters(pathSegments, true);
-        return Uri.new({pathSegments: pathSegments});
+        let pathSegments = dart.dcall(path[dartx.split], sep);
+        dart.dcall(Uri._checkWindowsPathReservedCharacters, pathSegments, true);
+        return Uri.new({pathSegments: dart.as(pathSegments, Iterable$(String))});
       }
     }
     replace(opts) {
       let scheme = opts && 'scheme' in opts ? opts.scheme : null;
       let userInfo = opts && 'userInfo' in opts ? opts.userInfo : null;
       let host = opts && 'host' in opts ? opts.host : null;
       let port = opts && 'port' in opts ? opts.port : null;
       let path = opts && 'path' in opts ? opts.path : null;
       let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
       let query = opts && 'query' in opts ? opts.query : null;
       let queryParameters = opts && 'queryParameters' in opts ? opts.queryParameters : null;
       let fragment = opts && 'fragment' in opts ? opts.fragment : null;
       let schemeChanged = false;
       if (scheme != null) {
-        scheme = Uri._makeScheme(scheme, scheme[dartx.length]);
+        scheme = dart.dcall(Uri._makeScheme, scheme, scheme[dartx.length]);
         schemeChanged = true;
       } else {
         scheme = this.scheme;
       }
       let isFile = scheme == "file";
       if (userInfo != null) {
-        userInfo = Uri._makeUserInfo(userInfo, 0, userInfo[dartx.length]);
+        userInfo = dart.dcall(Uri._makeUserInfo, userInfo, 0, userInfo[dartx.length]);
       } else {
         userInfo = this.userInfo;
       }
       if (port != null) {
-        port = Uri._makePort(port, scheme);
+        port = dart.dcall(Uri._makePort, port, scheme);
       } else {
         port = this[_port];
         if (dart.notNull(schemeChanged)) {
-          port = Uri._makePort(port, scheme);
+          port = dart.dcall(Uri._makePort, port, scheme);
         }
       }
       if (host != null) {
-        host = Uri._makeHost(host, 0, host[dartx.length], false);
+        host = dart.dcall(Uri._makeHost, host, 0, host[dartx.length], false);
       } else if (dart.notNull(this.hasAuthority)) {
         host = this.host;
       } else if (dart.notNull(userInfo[dartx.isNotEmpty]) || port != null || dart.notNull(isFile)) {
         host = "";
       }
       let ensureLeadingSlash = host != null;
       if (path != null || pathSegments != null) {
-        path = Uri._makePath(path, 0, Uri._stringOrNullLength(path), pathSegments, ensureLeadingSlash, isFile);
+        path = dart.dcall(Uri._makePath, path, 0, dart.dcall(Uri._stringOrNullLength, path), pathSegments, ensureLeadingSlash, isFile);
       } else {
         path = this.path;
-        if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash) && !dart.notNull(path[dartx.isEmpty])) && !dart.notNull(path[dartx.startsWith]('/'))) {
+        if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash) && !dart.notNull(path[dartx.isEmpty])) && !dart.notNull(dart.dcall(path[dartx.startsWith], '/'))) {
           path = `/${path}`;
         }
       }
       if (query != null || queryParameters != null) {
-        query = Uri._makeQuery(query, 0, Uri._stringOrNullLength(query), queryParameters);
+        query = dart.dcall(Uri._makeQuery, query, 0, dart.dcall(Uri._stringOrNullLength, query), queryParameters);
       } else if (dart.notNull(this.hasQuery)) {
         query = this.query;
       }
       if (fragment != null) {
-        fragment = Uri._makeFragment(fragment, 0, fragment[dartx.length]);
+        fragment = dart.dcall(Uri._makeFragment, fragment, 0, fragment[dartx.length]);
       } else if (dart.notNull(this.hasFragment)) {
         fragment = this.fragment;
       }
       return new Uri._internal(scheme, userInfo, host, port, path, query, fragment);
     }
     get pathSegments() {
       if (this[_pathSegments] == null) {
-        let pathToSplit = !dart.notNull(this.path[dartx.isEmpty]) && this.path[dartx.codeUnitAt](0) == Uri._SLASH ? this.path[dartx.substring](1) : this.path;
-        this[_pathSegments] = new (collection.UnmodifiableListView$(String))(pathToSplit == "" ? dart.const(dart.list([], String)) : List$(String).from(pathToSplit[dartx.split]("/")[dartx.map](Uri.decodeComponent), {growable: false}));
+        let pathToSplit = !dart.notNull(this.path[dartx.isEmpty]) && dart.dcall(this.path[dartx.codeUnitAt], 0) == Uri._SLASH ? dart.dcall(this.path[dartx.substring], 1) : this.path;
+        this[_pathSegments] = new (collection.UnmodifiableListView$(String))(dart.equals(pathToSplit, "") ? dart.const(dart.list([], String)) : List$(String).from(dart.as(dart.dsend(dart.dsend(pathToSplit, 'split', "/"), 'map', Uri.decodeComponent), Iterable), {growable: false}));
       }
       return this[_pathSegments];
     }
     get queryParameters() {
       if (this[_queryParameters] == null) {
-        this[_queryParameters] = new (collection.UnmodifiableMapView$(String, String))(Uri.splitQueryString(this.query));
+        this[_queryParameters] = new (collection.UnmodifiableMapView$(String, String))(dart.dcall(Uri.splitQueryString, this.query));
       }
       return this[_queryParameters];
     }
     static _makePort(port, scheme) {
-      if (port != null && port == Uri._defaultPort(scheme))
+      if (port != null && port == dart.dcall(Uri._defaultPort, scheme))
         return null;
       return port;
     }
     static _makeHost(host, start, end, strictIPv6) {
       if (host == null)
         return null;
       if (start == end)
         return "";
-      if (host[dartx.codeUnitAt](start) == Uri._LEFT_BRACKET) {
-        if (host[dartx.codeUnitAt](dart.notNull(end) - 1) != Uri._RIGHT_BRACKET) {
-          Uri._fail(host, start, 'Missing end `]` to match `[` in host');
+      if (dart.dcall(host[dartx.codeUnitAt], start) == Uri._LEFT_BRACKET) {
+        if (dart.dcall(host[dartx.codeUnitAt], dart.notNull(end) - 1) != Uri._RIGHT_BRACKET) {
+          dart.dcall(Uri._fail, host, start, 'Missing end `]` to match `[` in host');
         }
-        Uri.parseIPv6Address(host, dart.notNull(start) + 1, dart.notNull(end) - 1);
-        return host[dartx.substring](start, end)[dartx.toLowerCase]();
+        dart.dcall(Uri.parseIPv6Address, host, dart.notNull(start) + 1, dart.notNull(end) - 1);
+        return dart.dcall(dart.dcall(host[dartx.substring], start, end)[dartx.toLowerCase]);
       }
       if (!dart.notNull(strictIPv6)) {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-          if (host[dartx.codeUnitAt](i) == Uri._COLON) {
-            Uri.parseIPv6Address(host, start, end);
+          if (dart.dcall(host[dartx.codeUnitAt], i) == Uri._COLON) {
+            dart.dcall(Uri.parseIPv6Address, host, start, end);
             return `[${host}]`;
           }
         }
       }
-      return Uri._normalizeRegName(host, start, end);
+      return dart.dcall(Uri._normalizeRegName, host, start, end);
     }
     static _isRegNameChar(char) {
-      return dart.notNull(char) < 127 && !dart.equals(dart.dsend(Uri._regNameTable[dartx.get](dart.notNull(char) >> 4), '&', 1 << (dart.notNull(char) & 15)), 0);
+      return dart.notNull(char) < 127 && !dart.equals(dart.dsend(dart.dindex(Uri._regNameTable, dart.notNull(char) >> 4), '&', 1 << (dart.notNull(char) & 15)), 0);
     }
     static _normalizeRegName(host, start, end) {
       let buffer = null;
       let sectionStart = start;
       let index = start;
       let isNormalized = true;
       while (dart.notNull(index) < dart.notNull(end)) {
-        let char = host[dartx.codeUnitAt](index);
+        let char = dart.dcall(host[dartx.codeUnitAt], index);
         if (char == Uri._PERCENT) {
-          let replacement = Uri._normalizeEscape(host, index, true);
+          let replacement = dart.dcall(Uri._normalizeEscape, host, index, true);
           if (replacement == null && dart.notNull(isNormalized)) {
             index = dart.notNull(index) + 3;
             continue;
           }
           if (buffer == null)
             buffer = new StringBuffer();
-          let slice = host[dartx.substring](sectionStart, index);
+          let slice = dart.dcall(host[dartx.substring], sectionStart, index);
           if (!dart.notNull(isNormalized))
-            slice = slice[dartx.toLowerCase]();
-          buffer.write(slice);
+            slice = dart.dcall(slice[dartx.toLowerCase]);
+          dart.dcall(buffer.write, slice);
           let sourceLength = 3;
           if (replacement == null) {
-            replacement = host[dartx.substring](index, dart.notNull(index) + 3);
+            replacement = dart.dcall(host[dartx.substring], index, dart.notNull(index) + 3);
           } else if (replacement == "%") {
             replacement = "%25";
             sourceLength = 1;
           }
-          buffer.write(replacement);
+          dart.dcall(buffer.write, replacement);
           index = dart.notNull(index) + dart.notNull(sourceLength);
           sectionStart = index;
           isNormalized = true;
-        } else if (dart.notNull(Uri._isRegNameChar(char))) {
+        } else if (dart.notNull(dart.dcall(Uri._isRegNameChar, char))) {
           if (dart.notNull(isNormalized) && dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(char) && dart.notNull(Uri._UPPER_CASE_Z) >= dart.notNull(char)) {
             if (buffer == null)
               buffer = new StringBuffer();
             if (dart.notNull(sectionStart) < dart.notNull(index)) {
-              buffer.write(host[dartx.substring](sectionStart, index));
+              dart.dcall(buffer.write, dart.dcall(host[dartx.substring], sectionStart, index));
               sectionStart = index;
             }
             isNormalized = false;
           }
           index = dart.notNull(index) + 1;
-        } else if (dart.notNull(Uri._isGeneralDelimiter(char))) {
-          Uri._fail(host, index, "Invalid character");
+        } else if (dart.notNull(dart.dcall(Uri._isGeneralDelimiter, char))) {
+          dart.dcall(Uri._fail, host, index, "Invalid character");
         } else {
           let sourceLength = 1;
           if ((dart.notNull(char) & 64512) == 55296 && dart.notNull(index) + 1 < dart.notNull(end)) {
-            let tail = host[dartx.codeUnitAt](dart.notNull(index) + 1);
+            let tail = dart.dcall(host[dartx.codeUnitAt], dart.notNull(index) + 1);
             if ((dart.notNull(tail) & 64512) == 56320) {
               char = 65536 | (dart.notNull(char) & 1023) << 10 | dart.notNull(tail) & 1023;
               sourceLength = 2;
             }
           }
           if (buffer == null)
             buffer = new StringBuffer();
-          let slice = host[dartx.substring](sectionStart, index);
+          let slice = dart.dcall(host[dartx.substring], sectionStart, index);
           if (!dart.notNull(isNormalized))
-            slice = slice[dartx.toLowerCase]();
-          buffer.write(slice);
-          buffer.write(Uri._escapeChar(char));
+            slice = dart.dcall(slice[dartx.toLowerCase]);
+          dart.dcall(buffer.write, slice);
+          dart.dcall(buffer.write, dart.dcall(Uri._escapeChar, char));
           index = dart.notNull(index) + dart.notNull(sourceLength);
           sectionStart = index;
         }
       }
       if (buffer == null)
-        return host[dartx.substring](start, end);
+        return dart.dcall(host[dartx.substring], start, end);
       if (dart.notNull(sectionStart) < dart.notNull(end)) {
-        let slice = host[dartx.substring](sectionStart, end);
+        let slice = dart.dcall(host[dartx.substring], sectionStart, end);
         if (!dart.notNull(isNormalized))
-          slice = slice[dartx.toLowerCase]();
-        buffer.write(slice);
+          slice = dart.dcall(slice[dartx.toLowerCase]);
+        dart.dcall(buffer.write, slice);
       }
-      return dart.toString(buffer);
+      return dart.dcall(buffer.toString);
     }
     static _makeScheme(scheme, end) {
       if (end == 0)
         return "";
-      let firstCodeUnit = scheme[dartx.codeUnitAt](0);
-      if (!dart.notNull(Uri._isAlphabeticCharacter(firstCodeUnit))) {
-        Uri._fail(scheme, 0, "Scheme not starting with alphabetic character");
+      let firstCodeUnit = dart.dcall(scheme[dartx.codeUnitAt], 0);
+      if (!dart.notNull(dart.dcall(Uri._isAlphabeticCharacter, firstCodeUnit))) {
+        dart.dcall(Uri._fail, scheme, 0, "Scheme not starting with alphabetic character");
       }
       let allLowercase = dart.notNull(firstCodeUnit) >= dart.notNull(Uri._LOWER_CASE_A);
       for (let i = 0; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        let codeUnit = scheme[dartx.codeUnitAt](i);
-        if (!dart.notNull(Uri._isSchemeCharacter(codeUnit))) {
-          Uri._fail(scheme, i, "Illegal scheme character");
+        let codeUnit = dart.dcall(scheme[dartx.codeUnitAt], i);
+        if (!dart.notNull(dart.dcall(Uri._isSchemeCharacter, codeUnit))) {
+          dart.dcall(Uri._fail, scheme, i, "Illegal scheme character");
         }
         if (dart.notNull(codeUnit) < dart.notNull(Uri._LOWER_CASE_A) || dart.notNull(codeUnit) > dart.notNull(Uri._LOWER_CASE_Z)) {
           allLowercase = false;
         }
       }
-      scheme = scheme[dartx.substring](0, end);
+      scheme = dart.dcall(scheme[dartx.substring], 0, end);
       if (!dart.notNull(allLowercase))
-        scheme = scheme[dartx.toLowerCase]();
+        scheme = dart.dcall(scheme[dartx.toLowerCase]);
       return scheme;
     }
     static _makeUserInfo(userInfo, start, end) {
       if (userInfo == null)
         return "";
-      return Uri._normalize(userInfo, start, end, dart.as(Uri._userinfoTable, List$(int)));
+      return dart.dcall(Uri._normalize, userInfo, start, end, Uri._userinfoTable);
     }
     static _makePath(path, start, end, pathSegments, ensureLeadingSlash, isFile) {
       if (path == null && pathSegments == null)
         return dart.notNull(isFile) ? "/" : "";
       if (path != null && pathSegments != null) {
         dart.throw(new ArgumentError('Both path and pathSegments specified'));
       }
       let result = null;
       if (path != null) {
-        result = Uri._normalize(path, start, end, dart.as(Uri._pathCharOrSlashTable, List$(int)));
+        result = dart.dcall(Uri._normalize, path, start, end, Uri._pathCharOrSlashTable);
       } else {
-        result = pathSegments[dartx.map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [dart.dynamic]))[dartx.join]("/");
+        result = dart.dcall(dart.dcall(pathSegments[dartx.map], dart.fn(s => dart.dcall(Uri._uriEncode, Uri._pathCharTable, s), String, [dart.dynamic]))[dartx.join], "/");
       }
       if (dart.notNull(dart.as(dart.dload(result, 'isEmpty'), bool))) {
         if (dart.notNull(isFile))
           return "/";
       } else if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash)) && !dart.equals(dart.dsend(result, 'codeUnitAt', 0), Uri._SLASH)) {
         return `/${result}`;
       }
       return dart.as(result, String);
     }
     static _makeQuery(query, start, end, queryParameters) {
       if (query == null && queryParameters == null)
         return null;
       if (query != null && queryParameters != null) {
         dart.throw(new ArgumentError('Both query and queryParameters specified'));
       }
       if (query != null)
-        return Uri._normalize(query, start, end, dart.as(Uri._queryCharTable, List$(int)));
+        return dart.dcall(Uri._normalize, query, start, end, Uri._queryCharTable);
       let result = new StringBuffer();
       let first = true;
-      queryParameters.forEach(dart.fn((key, value) => {
-        if (!dart.notNull(first)) {
-          result.write("&");
+      dart.dcall(queryParameters.forEach, dart.fn((key, value) => {
+        if (!dart.notNull(dart.as(first, bool))) {
+          dart.dsend(result, 'write', "&");
         }
         first = false;
-        result.write(Uri.encodeQueryComponent(dart.as(key, String)));
+        dart.dsend(result, 'write', dart.dcall(Uri.encodeQueryComponent, key));
         if (value != null && !dart.notNull(dart.as(dart.dload(value, 'isEmpty'), bool))) {
-          result.write("=");
-          result.write(Uri.encodeQueryComponent(dart.as(value, String)));
+          dart.dsend(result, 'write', "=");
+          dart.dsend(result, 'write', dart.dcall(Uri.encodeQueryComponent, value));
         }
       }));
-      return dart.toString(result);
+      return dart.as(dart.dsend(result, 'toString'), String);
     }
     static _makeFragment(fragment, start, end) {
       if (fragment == null)
         return null;
-      return Uri._normalize(fragment, start, end, dart.as(Uri._queryCharTable, List$(int)));
+      return dart.dcall(Uri._normalize, fragment, start, end, Uri._queryCharTable);
     }
     static _stringOrNullLength(s) {
       return s == null ? 0 : s[dartx.length];
     }
     static _isHexDigit(char) {
       if (dart.notNull(Uri._NINE) >= dart.notNull(char))
         return dart.notNull(Uri._ZERO) <= dart.notNull(char);
       char = dart.notNull(char) | 32;
       return dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(char) && dart.notNull(Uri._LOWER_CASE_F) >= dart.notNull(char);
     }
     static _hexValue(char) {
-      dart.assert(Uri._isHexDigit(char));
+      dart.assert(dart.dcall(Uri._isHexDigit, char));
       if (dart.notNull(Uri._NINE) >= dart.notNull(char))
         return dart.notNull(char) - dart.notNull(Uri._ZERO);
       char = dart.notNull(char) | 32;
       return dart.notNull(char) - (dart.notNull(Uri._LOWER_CASE_A) - 10);
     }
     static _normalizeEscape(source, index, lowerCase) {
-      dart.assert(source[dartx.codeUnitAt](index) == Uri._PERCENT);
+      dart.assert(dart.dcall(source[dartx.codeUnitAt], index) == Uri._PERCENT);
       if (dart.notNull(index) + 2 >= dart.notNull(source[dartx.length])) {
         return "%";
       }
-      let firstDigit = source[dartx.codeUnitAt](dart.notNull(index) + 1);
-      let secondDigit = source[dartx.codeUnitAt](dart.notNull(index) + 2);
-      if (!dart.notNull(Uri._isHexDigit(firstDigit)) || !dart.notNull(Uri._isHexDigit(secondDigit))) {
+      let firstDigit = dart.dcall(source[dartx.codeUnitAt], dart.notNull(index) + 1);
+      let secondDigit = dart.dcall(source[dartx.codeUnitAt], dart.notNull(index) + 2);
+      if (!dart.notNull(dart.dcall(Uri._isHexDigit, firstDigit)) || !dart.notNull(dart.dcall(Uri._isHexDigit, secondDigit))) {
         return "%";
       }
-      let value = dart.notNull(Uri._hexValue(firstDigit)) * 16 + dart.notNull(Uri._hexValue(secondDigit));
-      if (dart.notNull(Uri._isUnreservedChar(value))) {
+      let value = dart.notNull(dart.dcall(Uri._hexValue, firstDigit)) * 16 + dart.notNull(dart.dcall(Uri._hexValue, secondDigit));
+      if (dart.notNull(dart.dcall(Uri._isUnreservedChar, value))) {
         if (dart.notNull(lowerCase) && dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(value) && dart.notNull(Uri._UPPER_CASE_Z) >= dart.notNull(value)) {
           value = dart.notNull(value) | 32;
         }
         return String.fromCharCode(value);
       }
       if (dart.notNull(firstDigit) >= dart.notNull(Uri._LOWER_CASE_A) || dart.notNull(secondDigit) >= dart.notNull(Uri._LOWER_CASE_A)) {
-        return source[dartx.substring](index, dart.notNull(index) + 3)[dartx.toUpperCase]();
+        return dart.dcall(dart.dcall(source[dartx.substring], index, dart.notNull(index) + 3)[dartx.toUpperCase]);
       }
       return null;
     }
     static _isUnreservedChar(ch) {
-      return dart.notNull(ch) < 127 && !dart.equals(dart.dsend(Uri._unreservedTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
+      return dart.notNull(ch) < 127 && !dart.equals(dart.dsend(dart.dindex(Uri._unreservedTable, dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
     }
     static _escapeChar(char) {
       dart.assert(dart.dsend(char, '<=', 1114111));
       let hexDigits = "0123456789ABCDEF";
       let codeUnits = null;
       if (dart.notNull(dart.as(dart.dsend(char, '<', 128), bool))) {
         codeUnits = List.new(3);
         codeUnits[dartx.set](0, Uri._PERCENT);
-        codeUnits[dartx.set](1, hexDigits[dartx.codeUnitAt](dart.as(dart.dsend(char, '>>', 4), int)));
-        codeUnits[dartx.set](2, hexDigits[dartx.codeUnitAt](dart.as(dart.dsend(char, '&', 15), int)));
+        codeUnits[dartx.set](1, dart.dsend(hexDigits, 'codeUnitAt', dart.dsend(char, '>>', 4)));
+        codeUnits[dartx.set](2, dart.dsend(hexDigits, 'codeUnitAt', dart.dsend(char, '&', 15)));
       } else {
         let flag = 192;
         let encodedBytes = 2;
         if (dart.notNull(dart.as(dart.dsend(char, '>', 2047), bool))) {
           flag = 224;
           encodedBytes = 3;
           if (dart.notNull(dart.as(dart.dsend(char, '>', 65535), bool))) {
             encodedBytes = 4;
             flag = 240;
           }
         }
         codeUnits = List.new(3 * dart.notNull(encodedBytes));
         let index = 0;
         while ((encodedBytes = dart.notNull(encodedBytes) - 1) >= 0) {
           let byte = dart.as(dart.dsend(dart.dsend(dart.dsend(char, '>>', 6 * dart.notNull(encodedBytes)), '&', 63), '|', flag), int);
           codeUnits[dartx.set](index, Uri._PERCENT);
-          codeUnits[dartx.set](dart.notNull(index) + 1, hexDigits[dartx.codeUnitAt](dart.notNull(byte) >> 4));
-          codeUnits[dartx.set](dart.notNull(index) + 2, hexDigits[dartx.codeUnitAt](dart.notNull(byte) & 15));
+          codeUnits[dartx.set](dart.notNull(index) + 1, dart.dsend(hexDigits, 'codeUnitAt', dart.notNull(byte) >> 4));
+          codeUnits[dartx.set](dart.notNull(index) + 2, dart.dsend(hexDigits, 'codeUnitAt', dart.notNull(byte) & 15));
           index = dart.notNull(index) + 3;
           flag = 128;
         }
       }
       return String.fromCharCodes(dart.as(codeUnits, Iterable$(int)));
     }
     static _normalize(component, start, end, charTable) {
       let buffer = null;
       let sectionStart = start;
       let index = start;
       while (dart.notNull(index) < dart.notNull(end)) {
-        let char = component[dartx.codeUnitAt](index);
+        let char = dart.dcall(component[dartx.codeUnitAt], index);
         if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx.get](dart.notNull(char) >> 4)) & 1 << (dart.notNull(char) & 15)) != 0) {
           index = dart.notNull(index) + 1;
         } else {
           let replacement = null;
           let sourceLength = null;
           if (char == Uri._PERCENT) {
-            replacement = Uri._normalizeEscape(component, index, false);
+            replacement = dart.dcall(Uri._normalizeEscape, component, index, false);
             if (replacement == null) {
               index = dart.notNull(index) + 3;
               continue;
             }
             if ("%" == replacement) {
               replacement = "%25";
               sourceLength = 1;
             } else {
               sourceLength = 3;
             }
-          } else if (dart.notNull(Uri._isGeneralDelimiter(char))) {
-            Uri._fail(component, index, "Invalid character");
+          } else if (dart.notNull(dart.dcall(Uri._isGeneralDelimiter, char))) {
+            dart.dcall(Uri._fail, component, index, "Invalid character");
           } else {
             sourceLength = 1;
             if ((dart.notNull(char) & 64512) == 55296) {
               if (dart.notNull(index) + 1 < dart.notNull(end)) {
-                let tail = component[dartx.codeUnitAt](dart.notNull(index) + 1);
+                let tail = dart.dcall(component[dartx.codeUnitAt], dart.notNull(index) + 1);
                 if ((dart.notNull(tail) & 64512) == 56320) {
                   sourceLength = 2;
                   char = 65536 | (dart.notNull(char) & 1023) << 10 | dart.notNull(tail) & 1023;
                 }
               }
             }
-            replacement = Uri._escapeChar(char);
+            replacement = dart.dcall(Uri._escapeChar, char);
           }
           if (buffer == null)
             buffer = new StringBuffer();
-          buffer.write(component[dartx.substring](sectionStart, index));
-          buffer.write(replacement);
+          dart.dcall(buffer.write, dart.dcall(component[dartx.substring], sectionStart, index));
+          dart.dcall(buffer.write, replacement);
           index = dart.notNull(index) + dart.notNull(sourceLength);
           sectionStart = index;
         }
       }
       if (buffer == null) {
-        return component[dartx.substring](start, end);
+        return dart.dcall(component[dartx.substring], start, end);
       }
       if (dart.notNull(sectionStart) < dart.notNull(end)) {
-        buffer.write(component[dartx.substring](sectionStart, end));
+        dart.dcall(buffer.write, dart.dcall(component[dartx.substring], sectionStart, end));
       }
-      return dart.toString(buffer);
+      return dart.dcall(buffer.toString);
     }
     static _isSchemeCharacter(ch) {
-      return dart.notNull(ch) < 128 && !dart.equals(dart.dsend(Uri._schemeTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
+      return dart.notNull(ch) < 128 && !dart.equals(dart.dsend(dart.dindex(Uri._schemeTable, dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
     }
     static _isGeneralDelimiter(ch) {
-      return dart.notNull(ch) <= dart.notNull(Uri._RIGHT_BRACKET) && !dart.equals(dart.dsend(Uri._genDelimitersTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
+      return dart.notNull(ch) <= dart.notNull(Uri._RIGHT_BRACKET) && !dart.equals(dart.dsend(dart.dindex(Uri._genDelimitersTable, dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0);
     }
     get isAbsolute() {
       return this.scheme != "" && this.fragment == "";
     }
     [_merge](base, reference) {
       if (dart.notNull(base[dartx.isEmpty]))
         return `/${reference}`;
       let backCount = 0;
       let refStart = 0;
-      while (dart.notNull(reference[dartx.startsWith]("../", refStart))) {
+      while (dart.notNull(dart.dcall(reference[dartx.startsWith], "../", refStart))) {
         refStart = dart.notNull(refStart) + 3;
         backCount = dart.notNull(backCount) + 1;
       }
-      let baseEnd = base[dartx.lastIndexOf]('/');
+      let baseEnd = dart.dcall(base[dartx.lastIndexOf], '/');
       while (dart.notNull(baseEnd) > 0 && dart.notNull(backCount) > 0) {
-        let newEnd = base[dartx.lastIndexOf]('/', dart.notNull(baseEnd) - 1);
+        let newEnd = dart.dcall(base[dartx.lastIndexOf], '/', dart.notNull(baseEnd) - 1);
         if (dart.notNull(newEnd) < 0) {
           break;
         }
         let delta = dart.notNull(baseEnd) - dart.notNull(newEnd);
-        if ((delta == 2 || delta == 3) && base[dartx.codeUnitAt](dart.notNull(newEnd) + 1) == Uri._DOT && (delta == 2 || base[dartx.codeUnitAt](dart.notNull(newEnd) + 2) == Uri._DOT)) {
+        if ((delta == 2 || delta == 3) && dart.dcall(base[dartx.codeUnitAt], dart.notNull(newEnd) + 1) == Uri._DOT && (delta == 2 || dart.dcall(base[dartx.codeUnitAt], dart.notNull(newEnd) + 2) == Uri._DOT)) {
           break;
         }
         baseEnd = newEnd;
         backCount = dart.notNull(backCount) - 1;
       }
-      return dart.notNull(base[dartx.substring](0, dart.notNull(baseEnd) + 1)) + dart.notNull(reference[dartx.substring](dart.notNull(refStart) - 3 * dart.notNull(backCount)));
+      return dart.notNull(dart.dcall(base[dartx.substring], 0, dart.notNull(baseEnd) + 1)) + dart.notNull(dart.dcall(reference[dartx.substring], dart.notNull(refStart) - 3 * dart.notNull(backCount)));
     }
     [_hasDotSegments](path) {
-      if (dart.notNull(path[dartx.length]) > 0 && path[dartx.codeUnitAt](0) == Uri._DOT)
+      if (dart.notNull(path[dartx.length]) > 0 && dart.dcall(path[dartx.codeUnitAt], 0) == Uri._DOT)
         return true;
-      let index = path[dartx.indexOf]("/.");
+      let index = dart.dcall(path[dartx.indexOf], "/.");
       return index != -1;
     }
     [_removeDotSegments](path) {
-      if (!dart.notNull(this[_hasDotSegments](path)))
+      if (!dart.notNull(dart.dcall(this[_hasDotSegments], path)))
         return path;
       let output = dart.list([], String);
       let appendSlash = false;
-      for (let segment of path[dartx.split]("/")) {
+      for (let segment of dart.dcall(path[dartx.split], "/")) {
         appendSlash = false;
         if (segment == "..") {
           if (!dart.notNull(output[dartx.isEmpty]) && (output[dartx.length] != 1 || output[dartx.get](0) != ""))
-            output[dartx.removeLast]();
+            dart.dcall(output[dartx.removeLast]);
           appendSlash = true;
         } else if ("." == segment) {
           appendSlash = true;
         } else {
-          output[dartx.add](segment);
+          dart.dcall(output[dartx.add], segment);
         }
       }
       if (dart.notNull(appendSlash))
-        output[dartx.add]("");
-      return output[dartx.join]("/");
+        dart.dcall(output[dartx.add], "");
+      return dart.dcall(output[dartx.join], "/");
     }
     resolve(reference) {
-      return this.resolveUri(Uri.parse(reference));
+      return dart.dcall(this.resolveUri, dart.dcall(Uri.parse, reference));
     }
     resolveUri(reference) {
       let targetScheme = null;
       let targetUserInfo = "";
       let targetHost = null;
       let targetPort = null;
       let targetPath = null;
       let targetQuery = null;
       if (dart.notNull(reference.scheme[dartx.isNotEmpty])) {
         targetScheme = reference.scheme;
         if (dart.notNull(reference.hasAuthority)) {
           targetUserInfo = reference.userInfo;
           targetHost = reference.host;
           targetPort = dart.notNull(reference.hasPort) ? reference.port : null;
         }
-        targetPath = this[_removeDotSegments](reference.path);
+        targetPath = dart.dcall(this[_removeDotSegments], reference.path);
         if (dart.notNull(reference.hasQuery)) {
           targetQuery = reference.query;
         }
       } else {
         targetScheme = this.scheme;
         if (dart.notNull(reference.hasAuthority)) {
           targetUserInfo = reference.userInfo;
           targetHost = reference.host;
-          targetPort = Uri._makePort(dart.notNull(reference.hasPort) ? reference.port : null, targetScheme);
-          targetPath = this[_removeDotSegments](reference.path);
+          targetPort = dart.dcall(Uri._makePort, dart.notNull(reference.hasPort) ? reference.port : null, targetScheme);
+          targetPath = dart.dcall(this[_removeDotSegments], reference.path);
           if (dart.notNull(reference.hasQuery))
             targetQuery = reference.query;
         } else {
           if (reference.path == "") {
             targetPath = this[_path];
             if (dart.notNull(reference.hasQuery)) {
               targetQuery = reference.query;
             } else {
               targetQuery = this[_query];
             }
           } else {
-            if (dart.notNull(reference.path[dartx.startsWith]("/"))) {
-              targetPath = this[_removeDotSegments](reference.path);
+            if (dart.notNull(dart.dcall(reference.path[dartx.startsWith], "/"))) {
+              targetPath = dart.dcall(this[_removeDotSegments], reference.path);
             } else {
-              targetPath = this[_removeDotSegments](this[_merge](this[_path], reference.path));
+              targetPath = dart.dcall(this[_removeDotSegments], dart.dcall(this[_merge], this[_path], reference.path));
             }
             if (dart.notNull(reference.hasQuery))
               targetQuery = reference.query;
           }
           targetUserInfo = this[_userInfo];
           targetHost = this[_host];
           targetPort = this[_port];
         }
       }
       let fragment = dart.notNull(reference.hasFragment) ? reference.fragment : null;
@@ skipping 28 matching lines @@
         dart.throw(new UnsupportedError(`Cannot extract a file path from a ${this.scheme} URI`));
       }
       if (this.query != "") {
         dart.throw(new UnsupportedError("Cannot extract a file path from a URI with a query component"));
       }
       if (this.fragment != "") {
         dart.throw(new UnsupportedError("Cannot extract a file path from a URI with a fragment component"));
       }
       if (windows == null)
         windows = Uri._isWindows;
-      return dart.notNull(windows) ? this[_toWindowsFilePath]() : this[_toFilePath]();
+      return dart.notNull(windows) ? dart.dcall(this[_toWindowsFilePath]) : dart.dcall(this[_toFilePath]);
     }
     [_toFilePath]() {
       if (this.host != "") {
         dart.throw(new UnsupportedError("Cannot extract a non-Windows file path from a file URI " + "with an authority"));
       }
-      Uri._checkNonWindowsPathReservedCharacters(this.pathSegments, false);
+      dart.dcall(Uri._checkNonWindowsPathReservedCharacters, this.pathSegments, false);
       let result = new StringBuffer();
       if (dart.notNull(this[_isPathAbsolute]))
-        result.write("/");
-      result.writeAll(this.pathSegments, "/");
-      return dart.toString(result);
+        dart.dsend(result, 'write', "/");
+      dart.dsend(result, 'writeAll', this.pathSegments, "/");
+      return dart.as(dart.dsend(result, 'toString'), String);
     }
     [_toWindowsFilePath]() {
       let hasDriveLetter = false;
       let segments = this.pathSegments;
-      if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx.get](0)[dartx.length] == 2 && segments[dartx.get](0)[dartx.codeUnitAt](1) == Uri._COLON) {
-        Uri._checkWindowsDriveLetter(segments[dartx.get](0)[dartx.codeUnitAt](0), false);
-        Uri._checkWindowsPathReservedCharacters(segments, false, 1);
+      if (dart.notNull(dart.as(dart.dsend(dart.dload(segments, 'length'), '>', 0), bool)) && dart.equals(dart.dload(dart.dindex(segments, 0), 'length'), 2) && dart.equals(dart.dsend(dart.dindex(segments, 0), 'codeUnitAt', 1), Uri._COLON)) {
+        dart.dcall(Uri._checkWindowsDriveLetter, dart.dsend(dart.dindex(segments, 0), 'codeUnitAt', 0), false);
+        dart.dcall(Uri._checkWindowsPathReservedCharacters, segments, false, 1);
         hasDriveLetter = true;
       } else {
-        Uri._checkWindowsPathReservedCharacters(segments, false);
+        dart.dcall(Uri._checkWindowsPathReservedCharacters, segments, false);
       }
       let result = new StringBuffer();
       if (dart.notNull(this[_isPathAbsolute]) && !dart.notNull(hasDriveLetter))
-        result.write("\\");
+        dart.dsend(result, 'write', "\\");
       if (this.host != "") {
-        result.write("\\");
-        result.write(this.host);
-        result.write("\\");
+        dart.dsend(result, 'write', "\\");
+        dart.dsend(result, 'write', this.host);
+        dart.dsend(result, 'write', "\\");
       }
-      result.writeAll(segments, "\\");
-      if (dart.notNull(hasDriveLetter) && segments[dartx.length] == 1)
-        result.write("\\");
-      return dart.toString(result);
+      dart.dsend(result, 'writeAll', segments, "\\");
+      if (dart.notNull(hasDriveLetter) && dart.equals(dart.dload(segments, 'length'), 1))
+        dart.dsend(result, 'write', "\\");
+      return dart.as(dart.dsend(result, 'toString'), String);
     }
     get [_isPathAbsolute]() {
       if (this.path == null || dart.notNull(this.path[dartx.isEmpty]))
         return false;
-      return this.path[dartx.startsWith]('/');
+      return dart.dcall(this.path[dartx.startsWith], '/');
     }
     [_writeAuthority](ss) {
       if (dart.notNull(this[_userInfo][dartx.isNotEmpty])) {
-        ss.write(this[_userInfo]);
-        ss.write("@");
+        dart.dcall(ss.write, this[_userInfo]);
+        dart.dcall(ss.write, "@");
       }
       if (this[_host] != null)
-        ss.write(this[_host]);
+        dart.dcall(ss.write, this[_host]);
       if (this[_port] != null) {
-        ss.write(":");
-        ss.write(this[_port]);
+        dart.dcall(ss.write, ":");
+        dart.dcall(ss.write, this[_port]);
       }
     }
     toString() {
       let sb = new StringBuffer();
-      Uri._addIfNonEmpty(sb, this.scheme, this.scheme, ':');
-      if (dart.notNull(this.hasAuthority) || dart.notNull(this.path[dartx.startsWith]("//")) || this.scheme == "file") {
-        sb.write("//");
-        this[_writeAuthority](sb);
+      dart.dcall(Uri._addIfNonEmpty, sb, this.scheme, this.scheme, ':');
+      if (dart.notNull(this.hasAuthority) || dart.notNull(dart.dcall(this.path[dartx.startsWith], "//")) || this.scheme == "file") {
+        dart.dcall(sb.write, "//");
+        dart.dcall(this[_writeAuthority], sb);
       }
-      sb.write(this.path);
+      dart.dcall(sb.write, this.path);
       if (this[_query] != null) {
-        sb.write("?");
-        sb.write(this[_query]);
+        dart.dcall(sb.write, "?");
+        dart.dcall(sb.write, this[_query]);
       }
       if (this[_fragment] != null) {
-        sb.write("#");
-        sb.write(this[_fragment]);
+        dart.dcall(sb.write, "#");
+        dart.dcall(sb.write, this[_fragment]);
       }
-      return dart.toString(sb);
+      return dart.dcall(sb.toString);
     }
     ['=='](other) {
       if (!dart.is(other, Uri))
         return false;
       let uri = dart.as(other, Uri);
       return this.scheme == uri.scheme && this.hasAuthority == uri.hasAuthority && this.userInfo == uri.userInfo && this.host == uri.host && this.port == uri.port && this.path == uri.path && this.hasQuery == uri.hasQuery && this.query == uri.query && this.hasFragment == uri.hasFragment && this.fragment == uri.fragment;
     }
     get hashCode() {
       function combine(part, current) {
-        return dart.as(dart.dsend(dart.dsend(dart.dsend(current, '*', 31), '+', dart.hashCode(part)), '&', 1073741823), int);
+        return dart.as(dart.dsend(dart.dsend(dart.dsend(current, '*', 31), '+', dart.dload(part, 'hashCode')), '&', 1073741823), int);
       }
       dart.fn(combine, int, [dart.dynamic, dart.dynamic]);
-      return combine(this.scheme, combine(this.userInfo, combine(this.host, combine(this.port, combine(this.path, combine(this.query, combine(this.fragment, 1)))))));
+      return dart.dcall(combine, this.scheme, dart.dcall(combine, this.userInfo, dart.dcall(combine, this.host, dart.dcall(combine, this.port, dart.dcall(combine, this.path, dart.dcall(combine, this.query, dart.dcall(combine, this.fragment, 1)))))));
     }
     static _addIfNonEmpty(sb, test, first, second) {
       if ("" != test) {
-        sb.write(first);
-        sb.write(second);
+        dart.dcall(sb.write, first);
+        dart.dcall(sb.write, second);
       }
     }
     static encodeComponent(component) {
-      return Uri._uriEncode(dart.as(Uri._unreserved2396Table, List$(int)), component);
+      return dart.dcall(Uri._uriEncode, Uri._unreserved2396Table, component);
     }
     static encodeQueryComponent(component, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
-      return Uri._uriEncode(dart.as(Uri._unreservedTable, List$(int)), component, {encoding: encoding, spaceToPlus: true});
+      return dart.dcall(Uri._uriEncode, Uri._unreservedTable, component, {encoding: encoding, spaceToPlus: true});
     }
     static decodeComponent(encodedComponent) {
-      return Uri._uriDecode(encodedComponent);
+      return dart.dcall(Uri._uriDecode, encodedComponent);
     }
     static decodeQueryComponent(encodedComponent, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
-      return Uri._uriDecode(encodedComponent, {plusToSpace: true, encoding: encoding});
+      return dart.dcall(Uri._uriDecode, encodedComponent, {plusToSpace: true, encoding: encoding});
     }
     static encodeFull(uri) {
-      return Uri._uriEncode(dart.as(Uri._encodeFullTable, List$(int)), uri);
+      return dart.dcall(Uri._uriEncode, Uri._encodeFullTable, uri);
     }
     static decodeFull(uri) {
-      return Uri._uriDecode(uri);
+      return dart.dcall(Uri._uriDecode, uri);
     }
     static splitQueryString(query, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
-      return dart.as(query[dartx.split]("&")[dartx.fold](dart.map(), dart.fn((map, element) => {
+      return dart.as(dart.dcall(dart.dcall(query[dartx.split], "&")[dartx.fold], dart.map(), dart.fn((map, element) => {
         let index = dart.as(dart.dsend(element, 'indexOf', "="), int);
         if (index == -1) {
           if (!dart.equals(element, "")) {
-            dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(element, String), {encoding: encoding}), "");
+            dart.dsetindex(map, dart.dcall(Uri.decodeQueryComponent, element, {encoding: encoding}), "");
           }
         } else if (index != 0) {
           let key = dart.dsend(element, 'substring', 0, index);
           let value = dart.dsend(element, 'substring', dart.notNull(index) + 1);
-          dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(key, String), {encoding: encoding}), Uri.decodeQueryComponent(dart.as(value, String), {encoding: encoding}));
+          dart.dsetindex(map, dart.dcall(Uri.decodeQueryComponent, key, {encoding: encoding}), dart.dcall(Uri.decodeQueryComponent, value, {encoding: encoding}));
         }
         return map;
       })), Map$(String, String));
     }
     static parseIPv4Address(host) {
       function error(msg) {
         dart.throw(new FormatException(`Illegal IPv4 address, ${msg}`));
       }
       dart.fn(error, dart.void, [String]);
-      let bytes = host[dartx.split]('.');
-      if (bytes[dartx.length] != 4) {
-        error('IPv4 address should contain exactly 4 parts');
+      let bytes = dart.dcall(host[dartx.split], '.');
+      if (!dart.equals(dart.dload(bytes, 'length'), 4)) {
+        dart.dcall(error, 'IPv4 address should contain exactly 4 parts');
       }
-      return dart.as(bytes[dartx.map](dart.fn(byteString => {
-        let byte = int.parse(dart.as(byteString, String));
+      return dart.as(dart.dsend(dart.dsend(bytes, 'map', dart.fn(byteString => {
+        let byte = dart.dcall(int.parse, byteString);
         if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
-          error('each part must be in the range of `0..255`');
+          dart.dcall(error, 'each part must be in the range of `0..255`');
         }
         return byte;
-      }))[dartx.toList](), List$(int));
+      })), 'toList'), List$(int));
     }
     static parseIPv6Address(host, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (end == null)
         end = host[dartx.length];
       function error(msg, position) {
         if (position === void 0)
           position = null;
         dart.throw(new FormatException(`Illegal IPv6 address, ${msg}`, host, dart.as(position, int)));
       }
       dart.fn(error, dart.void, [String], [dart.dynamic]);
       function parseHex(start, end) {
         if (dart.notNull(end) - dart.notNull(start) > 4) {
-          error('an IPv6 part can only contain a maximum of 4 hex digits', start);
+          dart.dcall(error, 'an IPv6 part can only contain a maximum of 4 hex digits', start);
         }
-        let value = int.parse(host[dartx.substring](start, end), {radix: 16});
+        let value = dart.dcall(int.parse, dart.dcall(host[dartx.substring], start, end), {radix: 16});
         if (dart.notNull(value) < 0 || dart.notNull(value) > (1 << 16) - 1) {
-          error('each part must be in the range of `0x0..0xFFFF`', start);
+          dart.dcall(error, 'each part must be in the range of `0x0..0xFFFF`', start);
         }
         return value;
       }
       dart.fn(parseHex, int, [int, int]);
       if (dart.notNull(host[dartx.length]) < 2)
-        error('address is too short');
+        dart.dcall(error, 'address is too short');
       let parts = dart.list([], int);
       let wildcardSeen = false;
       let partStart = start;
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        if (host[dartx.codeUnitAt](i) == Uri._COLON) {
+        if (dart.dcall(host[dartx.codeUnitAt], i) == Uri._COLON) {
           if (i == start) {
             i = dart.notNull(i) + 1;
-            if (host[dartx.codeUnitAt](i) != Uri._COLON) {
-              error('invalid start colon.', i);
+            if (dart.dcall(host[dartx.codeUnitAt], i) != Uri._COLON) {
+              dart.dcall(error, 'invalid start colon.', i);
             }
             partStart = i;
           }
           if (i == partStart) {
             if (dart.notNull(wildcardSeen)) {
-              error('only one wildcard `::` is allowed', i);
+              dart.dcall(error, 'only one wildcard `::` is allowed', i);
             }
             wildcardSeen = true;
-            parts[dartx.add](-1);
+            dart.dcall(parts[dartx.add], -1);
           } else {
-            parts[dartx.add](parseHex(partStart, i));
+            dart.dcall(parts[dartx.add], dart.dcall(parseHex, partStart, i));
           }
           partStart = dart.notNull(i) + 1;
         }
       }
       if (parts[dartx.length] == 0)
-        error('too few parts');
+        dart.dcall(error, 'too few parts');
       let atEnd = partStart == end;
       let isLastWildcard = parts[dartx.last] == -1;
       if (dart.notNull(atEnd) && !dart.notNull(isLastWildcard)) {
-        error('expected a part after last `:`', end);
+        dart.dcall(error, 'expected a part after last `:`', end);
       }
       if (!dart.notNull(atEnd)) {
         try {
-          parts[dartx.add](parseHex(partStart, end));
+          dart.dcall(parts[dartx.add], dart.dcall(parseHex, partStart, end));
         } catch (e) {
           try {
-            let last = Uri.parseIPv4Address(host[dartx.substring](partStart, end));
-            parts[dartx.add](dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1)));
-            parts[dartx.add](dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3)));
+            let last = dart.dcall(Uri.parseIPv4Address, dart.dcall(host[dartx.substring], partStart, end));
+            dart.dcall(parts[dartx.add], dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1)));
+            dart.dcall(parts[dartx.add], dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3)));
           } catch (e) {
-            error('invalid end of IPv6 address.', partStart);
+            dart.dcall(error, 'invalid end of IPv6 address.', partStart);
           }
 
         }
 
       }
       if (dart.notNull(wildcardSeen)) {
         if (dart.notNull(parts[dartx.length]) > 7) {
-          error('an address with a wildcard must have less than 7 parts');
+          dart.dcall(error, 'an address with a wildcard must have less than 7 parts');
         }
       } else if (parts[dartx.length] != 8) {
-        error('an address without a wildcard must contain exactly 8 parts');
+        dart.dcall(error, 'an address without a wildcard must contain exactly 8 parts');
       }
       let bytes = List$(int).new(16);
       for (let i = 0, index = 0; dart.notNull(i) < dart.notNull(parts[dartx.length]); i = dart.notNull(i) + 1) {
         let value = parts[dartx.get](i);
         if (value == -1) {
           let wildCardLength = 9 - dart.notNull(parts[dartx.length]);
           for (let j = 0; dart.notNull(j) < dart.notNull(wildCardLength); j = dart.notNull(j) + 1) {
             bytes[dartx.set](index, 0);
             bytes[dartx.set](dart.notNull(index) + 1, 0);
             index = dart.notNull(index) + 2;
           }
         } else {
           bytes[dartx.set](index, dart.notNull(value) >> 8);
           bytes[dartx.set](dart.notNull(index) + 1, dart.notNull(value) & 255);
           index = dart.notNull(index) + 2;
         }
       }
       return dart.as(bytes, List$(int));
     }
     static _uriEncode(canonicalTable, text, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
       let spaceToPlus = opts && 'spaceToPlus' in opts ? opts.spaceToPlus : false;
       function byteToHex(byte, buffer) {
         let hex = '0123456789ABCDEF';
-        dart.dsend(buffer, 'writeCharCode', hex[dartx.codeUnitAt](dart.as(dart.dsend(byte, '>>', 4), int)));
-        dart.dsend(buffer, 'writeCharCode', hex[dartx.codeUnitAt](dart.as(dart.dsend(byte, '&', 15), int)));
+        dart.dsend(buffer, 'writeCharCode', dart.dcall(hex[dartx.codeUnitAt], dart.dsend(byte, '>>', 4)));
+        dart.dsend(buffer, 'writeCharCode', dart.dcall(hex[dartx.codeUnitAt], dart.dsend(byte, '&', 15)));
       }
       dart.fn(byteToHex);
       let result = new StringBuffer();
-      let bytes = encoding.encode(text);
-      for (let i = 0; dart.notNull(i) < dart.notNull(bytes[dartx.length]); i = dart.notNull(i) + 1) {
-        let byte = bytes[dartx.get](i);
+      let bytes = dart.dcall(encoding.encode, text);
+      for (let i = 0; dart.notNull(i) < dart.notNull(dart.as(dart.dload(bytes, 'length'), num)); i = dart.notNull(i) + 1) {
+        let byte = dart.as(dart.dindex(bytes, i), int);
         if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](dart.notNull(byte) >> 4)) & 1 << (dart.notNull(byte) & 15)) != 0) {
-          result.writeCharCode(byte);
+          dart.dcall(result.writeCharCode, byte);
         } else if (dart.notNull(spaceToPlus) && byte == Uri._SPACE) {
-          result.writeCharCode(Uri._PLUS);
+          dart.dcall(result.writeCharCode, Uri._PLUS);
         } else {
-          result.writeCharCode(Uri._PERCENT);
-          byteToHex(byte, result);
+          dart.dcall(result.writeCharCode, Uri._PERCENT);
+          dart.dcall(byteToHex, byte, result);
         }
       }
-      return dart.toString(result);
+      return dart.dcall(result.toString);
     }
     static _hexCharPairToByte(s, pos) {
       let byte = 0;
       for (let i = 0; dart.notNull(i) < 2; i = dart.notNull(i) + 1) {
-        let charCode = s[dartx.codeUnitAt](dart.notNull(pos) + dart.notNull(i));
-        if (48 <= dart.notNull(charCode) && dart.notNull(charCode) <= 57) {
-          byte = dart.notNull(byte) * 16 + dart.notNull(charCode) - 48;
+        let charCode = dart.dcall(s[dartx.codeUnitAt], dart.notNull(pos) + dart.notNull(i));
+        if (48 <= dart.notNull(dart.as(charCode, num)) && dart.notNull(dart.as(dart.dsend(charCode, '<=', 57), bool))) {
+          byte = dart.notNull(byte) * 16 + dart.notNull(dart.as(charCode, num)) - 48;
         } else {
-          charCode = dart.notNull(charCode) | 32;
-          if (97 <= dart.notNull(charCode) && dart.notNull(charCode) <= 102) {
-            byte = dart.notNull(byte) * 16 + dart.notNull(charCode) - 87;
+          charCode = dart.dsend(charCode, '|', 32);
+          if (97 <= dart.notNull(dart.as(charCode, num)) && dart.notNull(dart.as(dart.dsend(charCode, '<=', 102), bool))) {
+            byte = dart.notNull(byte) * 16 + dart.notNull(dart.as(charCode, num)) - 87;
           } else {
             dart.throw(new ArgumentError("Invalid URL encoding"));
           }
         }
       }
       return byte;
     }
     static _uriDecode(text, opts) {
       let plusToSpace = opts && 'plusToSpace' in opts ? opts.plusToSpace : false;
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
       let simple = true;
       for (let i = 0; dart.notNull(i) < dart.notNull(text[dartx.length]) && dart.notNull(simple); i = dart.notNull(i) + 1) {
-        let codeUnit = text[dartx.codeUnitAt](i);
-        simple = codeUnit != Uri._PERCENT && codeUnit != Uri._PLUS;
+        let codeUnit = dart.dcall(text[dartx.codeUnitAt], i);
+        simple = !dart.equals(codeUnit, Uri._PERCENT) && !dart.equals(codeUnit, Uri._PLUS);
       }
       let bytes = null;
       if (dart.notNull(simple)) {
         if (dart.equals(encoding, convert.UTF8) || dart.equals(encoding, convert.LATIN1)) {
           return text;
         } else {
           bytes = text[dartx.codeUnits];
         }
       } else {
         bytes = List$(int).new();
         for (let i = 0; dart.notNull(i) < dart.notNull(text[dartx.length]); i = dart.notNull(i) + 1) {
-          let codeUnit = text[dartx.codeUnitAt](i);
-          if (dart.notNull(codeUnit) > 127) {
+          let codeUnit = dart.dcall(text[dartx.codeUnitAt], i);
+          if (dart.notNull(dart.as(dart.dsend(codeUnit, '>', 127), bool))) {
             dart.throw(new ArgumentError("Illegal percent encoding in URI"));
           }
-          if (codeUnit == Uri._PERCENT) {
+          if (dart.equals(codeUnit, Uri._PERCENT)) {
             if (dart.notNull(i) + 3 > dart.notNull(text[dartx.length])) {
               dart.throw(new ArgumentError('Truncated URI'));
             }
-            bytes[dartx.add](Uri._hexCharPairToByte(text, dart.notNull(i) + 1));
+            dart.dcall(bytes[dartx.add], dart.dcall(Uri._hexCharPairToByte, text, dart.notNull(i) + 1));
             i = dart.notNull(i) + 2;
-          } else if (dart.notNull(plusToSpace) && codeUnit == Uri._PLUS) {
-            bytes[dartx.add](Uri._SPACE);
+          } else if (dart.notNull(plusToSpace) && dart.equals(codeUnit, Uri._PLUS)) {
+            dart.dcall(bytes[dartx.add], Uri._SPACE);
           } else {
-            bytes[dartx.add](codeUnit);
+            dart.dcall(bytes[dartx.add], codeUnit);
           }
         }
       }
-      return encoding.decode(bytes);
+      return dart.dcall(encoding.decode, bytes);
     }
     static _isAlphabeticCharacter(codeUnit) {
       return dart.notNull(codeUnit) >= dart.notNull(Uri._LOWER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._LOWER_CASE_Z) || dart.notNull(codeUnit) >= dart.notNull(Uri._UPPER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._UPPER_CASE_Z);
     }
   }
   dart.defineNamedConstructor(Uri, '_internal');
   dart.setSignature(Uri, {
     constructors: () => ({
       _internal: [Uri, [String, String, String, num, String, String, String]],
       new: [Uri, [], {scheme: String, userInfo: String, host: String, port: int, path: String, pathSegments: Iterable$(String), query: String, queryParameters: Map$(String, String), fragment: String}],
@@ skipping 89 matching lines @@
   Uri._schemeTable = dart.const([0, 0, 26624, 1023, 65534, 2047, 65534, 2047]);
   Uri._schemeLowerTable = dart.const([0, 0, 26624, 1023, 0, 0, 65534, 2047]);
   Uri._subDelimitersTable = dart.const([0, 0, 32722, 11263, 65534, 34815, 65534, 18431]);
   Uri._genDelimitersTable = dart.const([0, 0, 32776, 33792, 1, 10240, 0, 0]);
   Uri._userinfoTable = dart.const([0, 0, 32722, 12287, 65534, 34815, 65534, 18431]);
   Uri._regNameTable = dart.const([0, 0, 32754, 11263, 65534, 34815, 65534, 18431]);
   Uri._pathCharTable = dart.const([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]);
   Uri._pathCharOrSlashTable = dart.const([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]);
   Uri._queryCharTable = dart.const([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]);
   function _symbolToString(symbol) {
-    return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
+    return dart.dcall(_internal.Symbol.getName, symbol);
   }
   dart.fn(_symbolToString, String, [Symbol]);
   // Exports:
   exports.Object = Object;
   exports.Deprecated = Deprecated;
   exports.deprecated = deprecated;
   exports.override = override;
   exports.proxy = proxy;
   exports.bool = bool;
   exports.Comparator$ = Comparator$;
@@ skipping 53 matching lines @@
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
 });