Reduces code generated by dynamic calls.

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 321 matching lines @@
   Object.defineProperty(proto, name, {value: method || methods['Object']});
 }
 // ********** Code for Clock **************
 function Clock() {}
 Clock.now = function() {
   return new Date().getTime();
 }
 Clock.frequency = function() {
   return 1000;
 }
-// ********** Code for AssertError **************
-function AssertError() {}
-AssertError.prototype.toString = function() {
-  return ("Failed assertion: '" + this.failedAssertion + "' is not true ") + ("in " + this.url + " at line " + this.line + ", column " + this.column + ".");
-}
-// ********** Code for TypeError **************
-function TypeError() {}
-$inherits(TypeError, AssertError);
-TypeError.prototype.toString = function() {
-  return ("Failed type check: type " + this.srcType + " is not assignable to type ") + ("" + this.dstType + "");
-}
-// ********** Code for FallThroughError **************
-function FallThroughError() {}
-FallThroughError.prototype.toString = function() {
-  return ("Switch case fall-through in " + this.url + " at line " + this.line + ".");
-}
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
 Object.prototype.forEach$1 = function($0) {
   return this.noSuchMethod("forEach", [$0]);
 }
 ;
+Object.prototype.get_$3 = function($0, $1, $2) {
+  return this.noSuchMethod("get_", [$0, $1, $2]);
+}
+;
 Object.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("invoke", [$0, $1, $2, $3]);
 }
 ;
 Object.prototype.printOn$1 = function($0) {
   return this.noSuchMethod("printOn", [$0]);
 }
 ;
 Object.prototype.set_$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("set_", [$0, $1, $2, $3]);
 }
 ;
 Object.prototype.visitPostfixExpression$1 = function($0) {
   return this.noSuchMethod("visitPostfixExpression", [$0]);
 }
 ;
-// ********** Code for IndexOutOfRangeException **************
-function IndexOutOfRangeException() {}
-IndexOutOfRangeException.prototype.toString = function() {
-  return ("IndexOutOfRangeException: " + this._index + "");
-}
 // ********** Code for IllegalAccessException **************
 function IllegalAccessException() {
   // Initializers done
 }
 IllegalAccessException.prototype.toString = function() {
   return "Attempt to modify an immutable object";
 }
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException(_receiver, _functionName, _arguments) {
   this._receiver = _receiver;
@@ skipping 11 matching lines @@
     sb.add(this._arguments.$index(i));
   }
   sb.add("]");
   return ("NoSuchMethodException - receiver: '" + this._receiver + "' ") + ("function name: '" + this._functionName + "' arguments: [" + sb + "]");
 }
 // ********** Code for ObjectNotClosureException **************
 function ObjectNotClosureException() {}
 ObjectNotClosureException.prototype.toString = function() {
   return "Object is not closure";
 }
-// ********** Code for IllegalArgumentException **************
-function IllegalArgumentException() {}
-IllegalArgumentException.prototype.toString = function() {
-  return ("Illegal argument(s): " + this._args + "");
-}
 // ********** Code for StackOverflowException **************
 function StackOverflowException() {}
 StackOverflowException.prototype.toString = function() {
   return "Stack Overflow";
 }
 // ********** Code for BadNumberFormatException **************
 function BadNumberFormatException() {}
 BadNumberFormatException.prototype.toString = function() {
   return ("BadNumberFormatException: '" + this._s + "'");
 }
 // ********** Code for NullPointerException **************
 function NullPointerException() {}
 NullPointerException.prototype.toString = function() {
   return "NullPointerException";
 }
 // ********** Code for NoMoreElementsException **************
 function NoMoreElementsException() {
   // Initializers done
 }
 NoMoreElementsException.prototype.toString = function() {
   return "NoMoreElementsException";
 }
 // ********** Code for EmptyQueueException **************
 function EmptyQueueException() {
   // Initializers done
 }
 EmptyQueueException.prototype.toString = function() {
   return "EmptyQueueException";
 }
-// ********** Code for UnsupportedOperationException **************
-function UnsupportedOperationException() {}
-UnsupportedOperationException.prototype.toString = function() {
-  return ("UnsupportedOperationException: " + this._message + "");
-}
-// ********** Code for IllegalJSRegExpException **************
-function IllegalJSRegExpException() {}
-IllegalJSRegExpException.prototype.toString = function() {
-  return ("IllegalJSRegExpException: '" + this._pattern + "' '" + this._errmsg + "'");
-}
-// ********** Code for ExpectException **************
-function ExpectException() {}
-ExpectException.prototype.toString = function() {
-  return this.message;
-}
 // ********** Code for Math **************
 Math.parseInt = function(str) {
   var ret = parseInt(str);
     if (isNaN(ret)) $throw(new BadNumberFormatException(str));
     return ret;
 }
 Math.parseDouble = function(str) {
   var ret = parseFloat(str);
     if (isNaN(ret) && str != 'NaN') $throw(new BadNumberFormatException(str));
     return ret;
 }
 Math.min = function(a, b) {
   if (a == b) return a;
     if (a < b) {
       if (isNaN(b)) return b;
       else return a;
     }
     if (isNaN(a)) return a;
     else return b;
 }
-// ********** Code for Dispatcher **************
-function Dispatcher() {}
 // ********** Code for Strings **************
 function Strings() {}
 Strings.String$fromCharCodes$factory = function(charCodes) {
   return StringBase.createFromCharCodes(charCodes);
 }
 Strings.join = function(strings, separator) {
   return StringBase.join(strings, separator);
 }
 // ********** Code for top level **************
 function print(obj) {
@@ skipping 49 matching lines @@
 }
 ListFactory.prototype.forEach$1 = ListFactory.prototype.forEach;
 ListFactory$DoubleLinkedQueueEntry$KeyValuePair$K$V = ListFactory;
 ListFactory$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword = ListFactory;
 ListFactory$E = ListFactory;
 ListFactory$Element = ListFactory;
 ListFactory$EvaluatedValue = ListFactory;
 ListFactory$HInstruction = ListFactory;
 ListFactory$K = ListFactory;
 ListFactory$KeywordState = ListFactory;
-ListFactory$SplayTreeNode$K$V = ListFactory;
 ListFactory$String = ListFactory;
 ListFactory$T = ListFactory;
 ListFactory$V = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$15/*const NoMoreElementsException()*/);
+    $throw(const$4/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for ImmutableList **************
 function ImmutableList(length0) {
   this._length = length0;
   ListFactory$E.call(this, length0);
   // Initializers done
 }
 $inherits(ImmutableList, ListFactory$E);
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.length);
   for (var i = 0;
    i < other.length; i++) {
     list._setindex(i, other.$index(i));
   }
   return list;
 }
 ImmutableList.prototype.get$length = function() {
   return this._length;
 }
 ImmutableList.prototype.set$length = function(length0) {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 Object.defineProperty(ImmutableList.prototype, "length", {
   get: ImmutableList.prototype.get$length,
   set: ImmutableList.prototype.set$length
 });
 ImmutableList.prototype._setindex = function(index, value) {
   return this[index] = value;
 }
 ImmutableList.prototype.$setindex = function(index, value) {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.sort = function(compare) {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.add = function(element) {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.addLast = function(element) {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.addAll = function(elements) {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.clear = function() {
-  $throw(const$0/*const IllegalAccessException()*/);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.removeLast = function() {
-  $throw(const$0/*const IllegalAccessException()*/);
-}
-// ********** Code for ImmutableMap **************
-function ImmutableMap() {}
-ImmutableMap.prototype.$index = function(key) {
-  return this._internal.$index(key);
-}
-ImmutableMap.prototype.isEmpty = function() {
-  return this._internal.isEmpty();
-}
-ImmutableMap.prototype.get$length = function() {
-  return this._internal.get$length();
-}
-Object.defineProperty(ImmutableMap.prototype, "length", {
-  get: ImmutableMap.prototype.get$length,
-});
-ImmutableMap.prototype.forEach = function(f) {
-  this._internal.forEach(f);
-}
-ImmutableMap.prototype.getKeys = function() {
-  return this._internal.getKeys();
-}
-ImmutableMap.prototype.getValues = function() {
-  return this._internal.getValues();
-}
-ImmutableMap.prototype.containsKey = function(key) {
-  return this._internal.containsKey(key);
-}
-ImmutableMap.prototype.$setindex = function(key, value) {
-  $throw(const$0/*const IllegalAccessException()*/);
-}
-ImmutableMap.prototype.clear = function() {
-  $throw(const$0/*const IllegalAccessException()*/);
-}
-ImmutableMap.prototype.forEach$1 = ImmutableMap.prototype.forEach;
-// ********** Code for JSSyntaxRegExp **************
-function JSSyntaxRegExp() {}
-JSSyntaxRegExp._create$ctor = function(pattern, flags) {
-  this.re = new RegExp(pattern, flags);
-      this.pattern = pattern;
-      this.multiLine = this.re.multiline;
-      this.ignoreCase = this.re.ignoreCase;
-}
-JSSyntaxRegExp._create$ctor.prototype = JSSyntaxRegExp.prototype;
-JSSyntaxRegExp.prototype.firstMatch = function(str) {
-  var m = this.re.exec(str);
-    return m && new MatchImplementation(
-        this.pattern, str, m.index, this.re.lastIndex, m);
+  $throw(const$221/*const IllegalAccessException()*/);
 }
 // ********** Code for MatchImplementation **************
 function MatchImplementation() {}
 MatchImplementation.prototype.$index = function(group0) {
   return this._groups.$index(group0);
 }
-// ********** Code for _AllMatchesIterable **************
-function _AllMatchesIterable() {}
-_AllMatchesIterable.prototype.iterator = function() {
-  return new _AllMatchesIterator(this._re, this._str);
-}
-// ********** Code for _AllMatchesIterator **************
-function _AllMatchesIterator(re, _str) {
-  this._str = _str;
-  this._done = false;
-  this._re = new JSSyntaxRegExp._create$ctor(re.pattern, 'g' + (re.multiLine ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
-  // Initializers done
-}
-_AllMatchesIterator.prototype.next = function() {
-  if (!this.hasNext()) {
-    $throw(const$15/*const NoMoreElementsException()*/);
-  }
-  var next0 = this._next;
-  this._next = null;
-  return next0;
-}
-_AllMatchesIterator.prototype.hasNext = function() {
-  if (this._done) {
-    return false;
-  }
-  else if (this._next != null) {
-    return true;
-  }
-  this._next = this._re.firstMatch(this._str);
-  if (this._next == null) {
-    this._done = true;
-    return false;
-  }
-  else {
-    return true;
-  }
-}
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
-NumImplementation.prototype.remainder = function(other) {
-  return this % other;
-}
 NumImplementation.prototype.isNaN = function() {
   return isNaN(this);
 }
 NumImplementation.prototype.isNegative = function() {
   return this == 0 ? (1 / this) < 0 : this < 0;
 }
 NumImplementation.prototype.hashCode = function() {
   return this & 0xFFFFFFF;
 }
 NumImplementation.prototype.toInt = function() {
@@ skipping 30 matching lines @@
   else if (this.isNaN()) {
     if (other.isNaN()) {
       return 0;
     }
     return 1;
   }
   else {
     return -1;
   }
 }
-// ********** Code for DurationImplementation **************
-function DurationImplementation(days, hours, minutes, seconds, milliseconds) {
-  this.inMilliseconds = days * 86400000/*Duration.MILLISECONDS_PER_DAY*/ + hours * 3600000/*Duration.MILLISECONDS_PER_HOUR*/ + minutes * 60000/*Duration.MILLISECONDS_PER_MINUTE*/ + seconds * 1000/*Duration.MILLISECONDS_PER_SECOND*/ + milliseconds;
-  // Initializers done
-}
-DurationImplementation.prototype.is$Duration = function(){return this;};
-DurationImplementation.prototype.get$inHours = function() {
-  return $truncdiv(this.inMilliseconds, 3600000/*Duration.MILLISECONDS_PER_HOUR*/);
-}
-DurationImplementation.prototype.get$inMinutes = function() {
-  return $truncdiv(this.inMilliseconds, 60000/*Duration.MILLISECONDS_PER_MINUTE*/);
-}
-DurationImplementation.prototype.get$inSeconds = function() {
-  return $truncdiv(this.inMilliseconds, 1000/*Duration.MILLISECONDS_PER_SECOND*/);
-}
-DurationImplementation.prototype.$eq = function(other) {
-  if (!(other && other.is$Duration)) return false;
-  return this.inMilliseconds == other.inMilliseconds;
-}
-DurationImplementation.prototype.compareTo = function(other) {
-  return this.inMilliseconds.compareTo(other.inMilliseconds);
-}
-DurationImplementation.prototype.toString = function() {
-  function threeDigits(n) {
-    if (n >= 100) return ("" + n + "");
-    if (n > 10) return ("0" + n + "");
-    return ("00" + n + "");
-  }
-  function twoDigits(n) {
-    if (n >= 10) return ("" + n + "");
-    return ("0" + n + "");
-  }
-  if (this.inMilliseconds < 0) {
-    var duration = new DurationImplementation(0, 0, 0, 0, -this.inMilliseconds);
-    return ("-" + duration + "");
-  }
-  var twoDigitMinutes = twoDigits(this.get$inMinutes().remainder(60/*Duration.MINUTES_PER_HOUR*/));
-  var twoDigitSeconds = twoDigits(this.get$inSeconds().remainder(60/*Duration.SECONDS_PER_MINUTE*/));
-  var threeDigitMs = threeDigits(this.inMilliseconds.remainder(1000/*Duration.MILLISECONDS_PER_SECOND*/));
-  return ("" + this.get$inHours() + ":" + twoDigitMinutes + ":" + twoDigitSeconds + "." + threeDigitMs + "");
-}
 // ********** Code for ExceptionImplementation **************
 function ExceptionImplementation(_msg) {
   this._msg = _msg;
   // Initializers done
 }
 ExceptionImplementation.prototype.toString = function() {
   return (this._msg == null) ? "Exception" : ("Exception: " + this._msg + "");
 }
-// ********** Code for FutureNotCompleteException **************
-function FutureNotCompleteException() {
-  // Initializers done
-}
-// ********** Code for FutureImpl **************
-function FutureImpl() {}
-FutureImpl.prototype.get$value = function() {
-  if (!this.get$isComplete()) {
-    $throw(new FutureNotCompleteException());
-  }
-  if (this._exception != null) {
-    $throw(this._exception);
-  }
-  return this._value;
-}
-FutureImpl.prototype.get$exception = function() {
-  if (!this.get$isComplete()) {
-    $throw(new FutureNotCompleteException());
-  }
-  return this._exception;
-}
-FutureImpl.prototype.get$isComplete = function() {
-  return this._isComplete;
-}
-// ********** Code for FutureImpl$T **************
-function FutureImpl$T() {}
-$inherits(FutureImpl$T, FutureImpl);
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
@@ skipping 472 matching lines @@
 }
 HashSetIterator.prototype.hasNext = function() {
   if (this._nextValidIndex >= this._entries.length) return false;
   if (this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$15/*const NoMoreElementsException()*/);
+    $throw(const$4/*const NoMoreElementsException()*/);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
@@ skipping 99 matching lines @@
   this._list.clear();
 }
 LinkedHashMapImplementation.prototype.forEach$1 = LinkedHashMapImplementation.prototype.forEach;
 // ********** Code for LinkedHashMapImplementation$String$Keyword **************
 function LinkedHashMapImplementation$String$Keyword() {
   // Initializers done
   this._map = new HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword();
   this._list = new DoubleLinkedQueue$KeyValuePair$String$Keyword();
 }
 $inherits(LinkedHashMapImplementation$String$Keyword, LinkedHashMapImplementation);
-// ********** Code for PromiseImpl **************
-function PromiseImpl() {}
-PromiseImpl.prototype.get$value = function() {
-  if (!this.isDone()) {
-    $throw(new ExceptionImplementation("Attempted to get the value of an uncompleted promise."));
-  }
-  if (this.hasError()) {
-    $throw(this._error);
-  }
-  else {
-    return this._value;
-  }
-}
-PromiseImpl.prototype.isDone = function() {
-  return this._state != 0/*PromiseImpl.CREATED*/ && this._state != 1/*PromiseImpl.RUNNING*/;
-}
-PromiseImpl.prototype.hasError = function() {
-  return this._state == 3/*PromiseImpl.COMPLETE_ERROR*/ || this._state == 6/*PromiseImpl.COMPLETE_ERROR_AFTER_CANCELLED*/;
-}
-// ********** Code for PromiseImpl$T **************
-function PromiseImpl$T() {}
-$inherits(PromiseImpl$T, PromiseImpl);
-// ********** Code for PromiseImpl$bool **************
-function PromiseImpl$bool() {}
-$inherits(PromiseImpl$bool, PromiseImpl);
-// ********** Code for ProxyBase **************
-function ProxyBase() {}
-$inherits(ProxyBase, PromiseImpl$bool);
-ProxyBase.prototype.$eq = function(other) {
-  return ((other instanceof ProxyBase)) && $eq(this._promise.get$value(), other._promise.get$value());
-}
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
   // Initializers done
   this._element = e;
 }
 DoubleLinkedQueueEntry.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
@@ skipping 58 matching lines @@
 function DoubleLinkedQueueEntry$KeyValuePair$String$Keyword() {}
 $inherits(DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, DoubleLinkedQueueEntry);
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
 function _DoubleLinkedQueueEntrySentinel() {
   DoubleLinkedQueueEntry$E.call(this, null);
   // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry$E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
-  $throw(const$16/*const EmptyQueueException()*/);
+  $throw(const$5/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
-  $throw(const$16/*const EmptyQueueException()*/);
+  $throw(const$5/*const EmptyQueueException()*/);
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel$E **************
 function _DoubleLinkedQueueEntrySentinel$E() {
   DoubleLinkedQueueEntry$E.call(this, null);
   // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$E, _DoubleLinkedQueueEntrySentinel);
 _DoubleLinkedQueueEntrySentinel$E.prototype._link = function(p, n) {
   this._next = n;
@@ skipping 169 matching lines @@
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$15/*const NoMoreElementsException()*/);
+    $throw(const$4/*const NoMoreElementsException()*/);
   }
   this._currentEntry = this._currentEntry._next;
   return this._currentEntry.get$element();
 }
 // ********** Code for _DoubleLinkedQueueIterator$E **************
 function _DoubleLinkedQueueIterator$E(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
@@ skipping 26 matching lines @@
     return 0;
   }
   return (this._stop == null) ? (Clock.now() - this._start) : (this._stop - this._start);
 }
 StopWatchImplementation.prototype.elapsedInMs = function() {
   return $truncdiv((this.elapsed() * 1000), this.frequency());
 }
 StopWatchImplementation.prototype.frequency = function() {
   return Clock.frequency();
 }
-// ********** Code for SplayTreeNode **************
-function SplayTreeNode(k, v) {
-  // Initializers done
-  this.key = k;
-  this.value = v;
-}
-SplayTreeNode.prototype.get$value = function() { return this.value; };
-SplayTreeNode.prototype.set$value = function(value) { return this.value = value; };
-// ********** Code for SplayTreeNode$K$V **************
-function SplayTreeNode$K$V() {}
-$inherits(SplayTreeNode$K$V, SplayTreeNode);
-// ********** Code for SplayTree **************
-function SplayTree() {}
-SplayTree.prototype.splay_ = function(key) {
-  if (this.isEmpty()) return;
-  var left = this._dummy;
-  var right = this._dummy;
-  var current = this._root;
-  while (true) {
-    if (key.compareTo(current.key) < 0) {
-      if (current.left == null) break;
-      if (key.compareTo(current.left.key) < 0) {
-        var tmp = current.left;
-        current.left = tmp.right;
-        tmp.right = current;
-        current = tmp;
-        if (current.left == null) break;
-      }
-      right.left = current;
-      right = current;
-      current = current.left;
-    }
-    else if (key.compareTo(current.key) > 0) {
-      if (current.right == null) break;
-      if (key.compareTo(current.right.key) > 0) {
-        var tmp = current.right;
-        current.right = tmp.left;
-        tmp.left = current;
-        current = tmp;
-        if (current.right == null) break;
-      }
-      left.right = current;
-      left = current;
-      current = current.right;
-    }
-    else {
-      break;
-    }
-  }
-  left.right = current.left;
-  right.left = current.right;
-  current.left = this._dummy.right;
-  current.right = this._dummy.left;
-  this._root = current;
-  this._dummy.right = null;
-  this._dummy.left = null;
-}
-SplayTree.prototype.$index = function(key) {
-  if (!this.isEmpty()) {
-    this.splay_(key);
-    if (this._root.key.compareTo(key) == 0) return this._root.value;
-  }
-  return null;
-}
-SplayTree.prototype.$setindex = function(key, value) {
-  if (this.isEmpty()) {
-    this._count++;
-    this._root = new SplayTreeNode(key, value);
-    return;
-  }
-  this.splay_(key);
-  if (this._root.key.compareTo(key) == 0) {
-    this._root.value = value;
-    return;
-  }
-  var node = new SplayTreeNode(key, value);
-  this._count++;
-  if (key.compareTo(this._root.key) > 0) {
-    node.left = this._root;
-    node.right = this._root.right;
-    this._root.right = null;
-  }
-  else {
-    node.right = this._root;
-    node.left = this._root.left;
-    this._root.left = null;
-  }
-  this._root = node;
-}
-SplayTree.prototype.isEmpty = function() {
-  return (this._root == null);
-}
-SplayTree.prototype.forEach = function(f) {
-  var list = new ListFactory$SplayTreeNode$K$V();
-  var current = this._root;
-  while (current != null) {
-    if (current.left != null) {
-      list.add(current);
-      current = current.left;
-    }
-    else {
-      f(current.key, current.value);
-      while (current.right == null) {
-        if (list.isEmpty()) return;
-        current = list.removeLast();
-        f(current.key, current.value);
-      }
-      current = current.right;
-    }
-  }
-}
-SplayTree.prototype.get$length = function() {
-  return this._count;
-}
-Object.defineProperty(SplayTree.prototype, "length", {
-  get: SplayTree.prototype.get$length,
-});
-SplayTree.prototype.clear = function() {
-  this._root = null;
-  this._count = 0;
-}
-SplayTree.prototype.containsKey = function(key) {
-  if (!this.isEmpty()) {
-    this.splay_(key);
-    if (this._root.key.compareTo(key) == 0) return true;
-  }
-  return false;
-}
-SplayTree.prototype.getKeys = function() {
-  var list = new ListFactory$K();
-  this.forEach((function (k, v) {
-    list.add(k);
-  })
-  );
-  return list;
-}
-SplayTree.prototype.getValues = function() {
-  var list = new ListFactory$V();
-  this.forEach((function (k, v) {
-    list.add(v);
-  })
-  );
-  return list;
-}
-SplayTree.prototype.forEach$1 = SplayTree.prototype.forEach;
 // ********** Code for StringBufferImpl **************
 function StringBufferImpl(content) {
   // Initializers done
   this.clear();
   this.add(content);
 }
 StringBufferImpl.prototype.get$length = function() {
   return this._length;
 }
 Object.defineProperty(StringBufferImpl.prototype, "length", {
@@ skipping 208 matching lines @@
 }
 TimeZoneImplementation.local$ctor.prototype = TimeZoneImplementation.prototype;
 TimeZoneImplementation.prototype.$eq = function(other) {
   if (!((other instanceof TimeZoneImplementation))) return false;
   return $eq(this.isUtc, other.isUtc);
 }
 TimeZoneImplementation.prototype.toString = function() {
   if (this.isUtc) return "TimeZone (UTC)";
   return "TimeZone (Local)";
 }
-// ********** Code for SendPortImpl **************
-function SendPortImpl() {}
-SendPortImpl.prototype.$eq = function(other) {
-  return ((other instanceof SendPortImpl)) && (this._workerId == other._workerId) && (this._isolateId == other._isolateId) && (this._receivePortId == other._receivePortId);
-}
-SendPortImpl.prototype.hashCode = function() {
-  return (this._workerId << 16) ^ (this._isolateId << 8) ^ this._receivePortId;
-}
 // ********** Code for top level **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
   this.pattern = pattern;
   this.str = str;
   this._start = _start;
   this._end = _end;
   this._groups = _groups;
   // Initializers done
 }
 //  ********** Library node **************
@@ skipping 14 matching lines @@
   return require('vm');
 }
 
 function get$http() {
   return require('http');
 }
 
 function get$readline() {
   return require('readline');
 }
-// ********** Code for ServerRequest **************
 // ********** Code for Process **************
 // ********** Code for top level **************
 function createSandbox() {
   return {'require': require, 'process': process, 'console': console};
 }
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function joinPaths(path1, path2) {
   var pieces = path1.split('/');
   var $list = path2.split('/');
@@ skipping 940 matching lines @@
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for top level **************
 //  ********** Library util_implementation **************
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
 LinkFactory.Link$factory = function(head, tail) {
-  return new LinkEntry(head, (tail == null) ? const$135/*const EmptyLink<Expression>()*/ : tail);
+  return new LinkEntry(head, (tail == null) ? const$227/*const EmptyLink<DeclarationBuilder>()*/ : tail);
 }
 // ********** Code for AbstractLink **************
 function AbstractLink() {}
 AbstractLink.prototype.get$head = function() {
   $throw("bug");
 }
 AbstractLink.prototype.get$tail = function() {
   $throw("bug");
 }
 AbstractLink.prototype.prepend = function(element) {
@@ skipping 12 matching lines @@
   }
 }
 AbstractLink.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
 }
 AbstractLink.prototype.reverse = function() {
-  var result = const$135/*const EmptyLink<Expression>()*/;
+  var result = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   for (var link = this;
    !link.isEmpty(); link = link.get$tail()) {
     result = result.prepend(link.get$head());
   }
   return result;
 }
 AbstractLink.prototype.printOn$1 = function($0) {
   return this.printOn($0, '');
 }
 ;
 // ********** Code for AbstractLink$T **************
 function AbstractLink$T() {}
 $inherits(AbstractLink$T, AbstractLink);
 AbstractLink$T.prototype.iterator = function() {
   return this.toList().iterator();
 }
 // ********** Code for LinkTail **************
 function LinkTail() {
   // Initializers done
 }
 $inherits(LinkTail, AbstractLink$T);
 LinkTail.prototype.get$head = function() {
   return null;
 }
 LinkTail.prototype.get$tail = function() {
   return null;
 }
 LinkTail.prototype.toList = function() {
-  return const$14/*const <HInstruction>[]*/;
+  return const$226/*const []*/;
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 // ********** Code for LinkTail$DeclarationBuilder **************
 function LinkTail$DeclarationBuilder() {
   // Initializers done
 }
 $inherits(LinkTail$DeclarationBuilder, LinkTail);
 // ********** Code for LinkTail$Element **************
@@ skipping 42 matching lines @@
 $inherits(LinkEntry$T, LinkEntry);
 // ********** Code for LinkBuilderImplementation **************
 function LinkBuilderImplementation() {
   this.head = null
   this.lastLink = null
   // Initializers done
 }
 LinkBuilderImplementation.prototype.get$head = function() { return this.head; };
 LinkBuilderImplementation.prototype.set$head = function(value) { return this.head = value; };
 LinkBuilderImplementation.prototype.toLink = function() {
-  if (this.head == null) return const$135/*const EmptyLink<Expression>()*/;
-  this.lastLink.realTail = const$135/*const EmptyLink<Expression>()*/;
+  if (this.head == null) return const$227/*const EmptyLink<DeclarationBuilder>()*/;
+  this.lastLink.realTail = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   var link = this.head;
   this.lastLink = null;
   this.head = null;
   return link;
 }
 LinkBuilderImplementation.prototype.addLast = function(t) {
   var entry = new LinkEntry$T(t, null);
   if (this.head == null) {
     this.head = entry;
   }
@@ skipping 1638 matching lines @@
 Parser.prototype.checkEof = function(token) {
   if (token == null) {
     this.listener.unexpectedEof();
     $throw("Unexpected EOF");
   }
   return token;
 }
 Parser.prototype.parseUnit = function(token) {
   while (token != null) {
     switch (token.get$value()) {
-      case const$359/*Keyword.INTERFACE*/:
+      case const$203/*Keyword.INTERFACE*/:
 
         token = this.parseInterface(token);
         break;
 
-      case const$347/*Keyword.CLASS*/:
+      case const$191/*Keyword.CLASS*/:
 
         token = this.parseClass(token);
         break;
 
-      case const$375/*Keyword.TYPEDEF*/:
+      case const$219/*Keyword.TYPEDEF*/:
 
         token = this.parseNamedFunctionAlias(token);
         break;
 
-      case const$380/*const SourceString("#")*/:
+      case const$237/*const SourceString("#")*/:
 
         token = this.parseLibraryTags(token);
         break;
 
       default:
 
         token = this.parseTopLevelMember(token);
         break;
 
     }
@@ skipping 12 matching lines @@
   this.listener.endInterface(token);
   return token.next;
 }
 Parser.prototype.parseNamedFunctionAlias = function(token) {
   this.listener.beginFunctionTypeAlias(token);
   token = this.parseReturnTypeOpt(this.next(token));
   token = this.parseIdentifier(token);
   token = this.parseTypeVariablesOpt(token);
   token = this.parseParameters(token);
   this.listener.endFunctionTypeAlias(token);
-  return this.expect(const$147/*const SourceString(";")*/, token);
+  return this.expect(const$236/*const SourceString(";")*/, token);
 }
 Parser.prototype.parseReturnTypeOpt = function(token) {
-  if ($eq(token.get$value(), const$136/*Keyword.VOID*/)) {
+  if ($eq(token.get$value(), const$183/*Keyword.VOID*/)) {
     this.listener.voidType(token);
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
 Parser.prototype.parseParameters = function(token) {
-  this.expect(const$145/*const SourceString("(")*/, token);
-  if (this.optional(const$146/*const SourceString(")")*/, this.next(token))) {
+  this.expect(const$234/*const SourceString("(")*/, token);
+  if (this.optional(const$235/*const SourceString(")")*/, this.next(token))) {
     return this.next(this.next(token));
   }
   do {
     token = this.parseTypeOpt(this.next(token));
     token = this.parseIdentifier(token);
   }
-  while (this.optional(const$143/*const SourceString(",")*/, token))
-  return this.expect(const$146/*const SourceString(")")*/, token);
+  while (this.optional(const$230/*const SourceString(",")*/, token))
+  return this.expect(const$235/*const SourceString(")")*/, token);
 }
 Parser.prototype.parseTypeOpt = function(token) {
   switch (true) {
-    case this.optional(const$138/*const SourceString("<")*/, this.next(token)):
-    case this.optional(const$139/*const SourceString(".")*/, this.next(token)):
+    case this.optional(const$228/*const SourceString("<")*/, this.next(token)):
+    case this.optional(const$229/*const SourceString(".")*/, this.next(token)):
     case this.isIdentifier(this.next(token)):
 
       return this.parseType(token);
 
     default:
 
       return token;
 
   }
 }
 Parser.prototype.isIdentifier = function(token) {
   switch (token.kind) {
     case 97/*null.IDENTIFIER_TOKEN*/:
 
       return true;
 
     case 107/*null.KEYWORD_TOKEN*/:
 
       return token.get$value().isPseudo;
 
     default:
 
       return false;
 
   }
 }
 Parser.prototype.parseSupertypesClauseOpt = function(token) {
-  if (this.optional(const$349/*Keyword.EXTENDS*/, token)) {
+  if (this.optional(const$193/*Keyword.EXTENDS*/, token)) {
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$143/*const SourceString(",")*/, token))
+    while (this.optional(const$230/*const SourceString(",")*/, token))
   }
   return token;
 }
 Parser.prototype.parseFactoryClauseOpt = function(token) {
-  if (this.optional(const$351/*Keyword.FACTORY*/, token)) {
+  if (this.optional(const$195/*Keyword.FACTORY*/, token)) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 Parser.prototype.skipBlock = function(token) {
-  if (!this.optional(const$148/*const SourceString("{")*/, token)) {
+  if (!this.optional(const$232/*const SourceString("{")*/, token)) {
     return this.listener.expectedBlock(token);
   }
   token = this.next(token);
   var nesting = 1;
   do {
     switch (token.kind) {
       case 123/*null.LBRACE_TOKEN*/:
 
         nesting++;
         break;
@@ skipping 15 matching lines @@
 Parser.prototype.parseClass = function(token) {
   this.listener.beginClass(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSuperclassClauseOpt(token);
   token = this.parseImplementsOpt(token);
   token = this.parseNativeClassClauseOpt(token);
   return this.parseClassBody(token);
 }
 Parser.prototype.parseNativeClassClauseOpt = function(token) {
-  if (this.optional(const$363/*Keyword.NATIVE*/, token)) {
+  if (this.optional(const$207/*Keyword.NATIVE*/, token)) {
     return this.parseString(this.next(token));
   }
   return token;
 }
 Parser.prototype.parseString = function(token) {
   switch (token.kind) {
     case 39/*null.STRING_TOKEN*/:
 
       return this.next(token);
 
     default:
 
-      return this.listener.expected(const$379/*const SourceString("string")*/, token);
+      return this.listener.expected(const$233/*const SourceString("string")*/, token);
 
   }
 }
 Parser.prototype.parseIdentifier = function(token) {
   if (this.isIdentifier(token)) {
     this.listener.identifier(token);
   }
   else {
     this.listener.notIdentifier(token);
   }
   return this.next(token);
 }
 Parser.prototype.parseTypeVariablesOpt = function(token) {
-  if (!this.optional(const$138/*const SourceString("<")*/, token)) {
+  if (!this.optional(const$228/*const SourceString("<")*/, token)) {
     return token;
   }
   this.listener.beginTypeVariables(token);
   do {
     token = this.parseTypeVariable(this.next(token));
   }
-  while (this.optional(const$143/*const SourceString(",")*/, token))
-  return this.expect(const$144/*const SourceString(">")*/, token);
+  while (this.optional(const$230/*const SourceString(",")*/, token))
+  return this.expect(const$231/*const SourceString(">")*/, token);
 }
 Parser.prototype.expect = function(string, token) {
   if ($ne(string, token.get$value())) {
     return this.listener.expected(string, token);
   }
   return token.next;
 }
 Parser.prototype.parseTypeVariable = function(token) {
   this.listener.beginTypeVariable(token);
   token = this.parseIdentifier(token);
   token = this.parseSuperclassClauseOpt(token);
   this.listener.endTypeVariable(token);
   return token;
 }
 Parser.prototype.optional = function(value, token) {
   return $eq(value, token.get$value());
 }
 Parser.prototype.parseSuperclassClauseOpt = function(token) {
-  if (this.optional(const$349/*Keyword.EXTENDS*/, token)) {
+  if (this.optional(const$193/*Keyword.EXTENDS*/, token)) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 Parser.prototype.parseType = function(token) {
   if (this.isIdentifier(token)) {
     token = this.parseIdentifier(token);
-    while (this.optional(const$139/*const SourceString(".")*/, token)) {
+    while (this.optional(const$229/*const SourceString(".")*/, token)) {
       token = this.parseIdentifier(this.next(token));
     }
   }
   else {
     token = this.listener.expectedType(token);
   }
   return this.parseTypeArgumentsOpt(token);
 }
 Parser.prototype.parseTypeArgumentsOpt = function(token) {
-  if (this.optional(const$138/*const SourceString("<")*/, token)) {
+  if (this.optional(const$228/*const SourceString("<")*/, token)) {
     this.listener.beginTypeArguments(this.next(token));
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$143/*const SourceString(",")*/, token))
-    return this.expect(const$144/*const SourceString(">")*/, token);
+    while (this.optional(const$230/*const SourceString(",")*/, token))
+    return this.expect(const$231/*const SourceString(">")*/, token);
   }
   return token;
 }
 Parser.prototype.parseImplementsOpt = function(token) {
-  if (this.optional(const$355/*Keyword.IMPLEMENTS*/, token)) {
+  if (this.optional(const$199/*Keyword.IMPLEMENTS*/, token)) {
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$143/*const SourceString(",")*/, token))
+    while (this.optional(const$230/*const SourceString(",")*/, token))
   }
   return token;
 }
 Parser.prototype.parseClassBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endClass(token);
   return token.next;
 }
 Parser.prototype.parseTopLevelMember = function(token) {
   var start = token;
@@ skipping 11 matching lines @@
 
       default:
 
         previous = token;
         token = this.next(token);
         break;
 
     }
   }
   token = this.parseIdentifier(previous);
-  if (this.optional(const$145/*const SourceString("(")*/, token)) {
+  if (this.optional(const$234/*const SourceString("(")*/, token)) {
     this.listener.topLevelMethod(start);
   }
-  else if (this.optional(const$381/*const SourceString("=")*/, token) || this.optional(const$147/*const SourceString(";")*/, token)) {
+  else if (this.optional(const$238/*const SourceString("=")*/, token) || this.optional(const$236/*const SourceString(";")*/, token)) {
     this.listener.topLevelField(start);
   }
   else {
     token = this.listener.unexpected(token);
   }
   while (token != null && token.kind != 123/*null.LBRACE_TOKEN*/ && token.kind != 59/*null.SEMICOLON_TOKEN*/) {
     token = this.next(token);
   }
-  if (!this.optional(const$147/*const SourceString(";")*/, token)) {
+  if (!this.optional(const$236/*const SourceString(";")*/, token)) {
     token = this.skipBlock(token);
   }
   this.listener.endTopLevelMember(token);
   return token.next;
 }
 Parser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
-  token = this.expect(const$145/*const SourceString("(")*/, token);
+  token = this.expect(const$234/*const SourceString("(")*/, token);
   while (token != null && token.kind != 40/*null.LPAREN_TOKEN*/ && token.kind != 41/*null.RPAREN_TOKEN*/) {
     token = this.next(token);
   }
-  token = this.expect(const$146/*const SourceString(")")*/, token);
-  return this.expect(const$147/*const SourceString(";")*/, token);
+  token = this.expect(const$235/*const SourceString(")")*/, token);
+  return this.expect(const$236/*const SourceString(";")*/, token);
 }
 // ********** Code for BodyParser **************
 function BodyParser(listener0) {
   Parser.call(this, listener0);
   // Initializers done
 }
 $inherits(BodyParser, Parser);
 BodyParser.prototype.parseFunction = function(token) {
   this.listener.beginFunction(token);
   token = this.parseReturnTypeOpt(token);
   this.listener.beginFunctionName(token);
   token = this.parseIdentifier(token);
   this.listener.endFunctionName(token);
   token = this.parseFormalParameters(token);
   return this.parseFunctionBody(token);
 }
 BodyParser.prototype.parseFormalParameters = function(token) {
   this.listener.beginFormalParameters(token);
-  this.expect(const$145/*const SourceString("(")*/, token);
-  if (this.optional(const$146/*const SourceString(")")*/, token.next)) {
+  this.expect(const$234/*const SourceString("(")*/, token);
+  if (this.optional(const$235/*const SourceString(")")*/, token.next)) {
     this.listener.endFormalParameters(token.next);
     return token.next.next;
   }
   do {
     token = this.parseType(this.next(token));
     token = this.parseIdentifier(token);
   }
-  while (this.optional(const$143/*const SourceString(",")*/, token))
+  while (this.optional(const$230/*const SourceString(",")*/, token))
   this.listener.endFormalParameters(token);
-  return this.expect(const$146/*const SourceString(")")*/, token);
+  return this.expect(const$235/*const SourceString(")")*/, token);
 }
 BodyParser.prototype.parseFunctionBody = function(token) {
-  if (this.optional(const$147/*const SourceString(";")*/, token)) {
+  if (this.optional(const$236/*const SourceString(";")*/, token)) {
     this.listener.emptyFunctionBody(token);
     return token.next;
   }
   this.listener.beginFunctionBody(token);
-  token = this.checkEof(this.expect(const$148/*const SourceString("{")*/, token));
-  while (!this.optional(const$149/*const SourceString("}")*/, token)) {
+  token = this.checkEof(this.expect(const$232/*const SourceString("{")*/, token));
+  while (!this.optional(const$239/*const SourceString("}")*/, token)) {
     token = this.parseStatement(token);
   }
   this.listener.endFunctionBody(token);
-  return this.expect(const$149/*const SourceString("}")*/, token);
+  return this.expect(const$239/*const SourceString("}")*/, token);
 }
 BodyParser.prototype.parseStatement = function(token) {
   this.checkEof(token);
-  if ($eq(token.get$value(), const$150/*const SourceString('{')*/)) {
+  if ($eq(token.get$value(), const$240/*const SourceString('{')*/)) {
     return this.parseBlock(token);
   }
   switch (token.get$value()) {
-    case const$151/*Keyword.RETURN*/:
+    case const$167/*Keyword.RETURN*/:
 
       return this.parseReturnStatement(token);
 
-    case const$160/*Keyword.VAR*/:
+    case const$181/*Keyword.VAR*/:
 
       return this.parseVariablesDeclaration(token);
 
-    case const$164/*Keyword.IF*/:
+    case const$157/*Keyword.IF*/:
 
       return this.parseIfStatement(token);
 
     default:
 
       return this.parseExpressionStatement(token);
 
   }
 }
 BodyParser.prototype.expectSemicolon = function(token) {
-  return this.expect(const$147/*const SourceString(";")*/, token);
+  return this.expect(const$236/*const SourceString(";")*/, token);
 }
 BodyParser.prototype.parseReturnStatement = function(token) {
   this.listener.beginReturnStatement(token);
   token = this.parseExpression(this.next(token));
   this.listener.endReturnStatement(token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseExpressionStatement = function(token) {
   this.listener.beginExpressionStatement(token);
   token = this.parseExpression(token);
@@ skipping 185 matching lines @@
       return this.parseLiteralDouble(token);
 
     case 39/*null.STRING_TOKEN*/:
 
       return this.parseLiteralString(token);
 
     case 107/*null.KEYWORD_TOKEN*/:
 
       {
         switch (token.get$value()) {
-          case const$128/*Keyword.TRUE*/:
-          case const$130/*Keyword.FALSE*/:
+          case const$177/*Keyword.TRUE*/:
+          case const$149/*Keyword.FALSE*/:
 
             return this.parseLiteralBool(token);
 
           default:
 
             this.listener.unexpected(token);
             $throw("not yet implemented");
 
         }
       }
@@ skipping 27 matching lines @@
   return token.next;
 }
 BodyParser.prototype.parseSend = function(token) {
   this.listener.beginSend(token);
   token = this.parseIdentifier(token);
   token = this.parseArgumentsOpt(token);
   this.listener.endSend(token);
   return token;
 }
 BodyParser.prototype.parseArgumentsOpt = function(token) {
-  if (this.optional(const$145/*const SourceString("(")*/, token)) {
+  if (this.optional(const$234/*const SourceString("(")*/, token)) {
     this.listener.beginArguments(token);
-    if (this.optional(const$146/*const SourceString(")")*/, token.next)) {
+    if (this.optional(const$235/*const SourceString(")")*/, token.next)) {
       this.listener.endArguments(token.next);
       return token.next.next;
     }
     do {
       token = this.parseExpression(this.next(token));
     }
-    while (this.optional(const$143/*const SourceString(",")*/, token))
+    while (this.optional(const$230/*const SourceString(",")*/, token))
     this.listener.endArguments(token);
-    return this.expect(const$146/*const SourceString(")")*/, token);
+    return this.expect(const$235/*const SourceString(")")*/, token);
   }
   return token;
 }
 BodyParser.prototype.parseVariablesDeclaration = function(token) {
   this.listener.beginVariablesDeclaration(token);
   token = this.parseFinalVarOrType(token);
   token = this.parseOptionallyInitializedIdentifier(token);
-  while (this.optional(const$163/*const SourceString(',')*/, token)) {
+  while (this.optional(const$243/*const SourceString(',')*/, token)) {
     token = this.parseOptionallyInitializedIdentifier(this.next(token));
   }
   this.listener.endVariablesDeclaration(token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseOptionallyInitializedIdentifier = function(token) {
   this.listener.beginInitializedIdentifier(token);
   token = this.parseIdentifier(token);
-  if (this.optional(const$162/*const SourceString('=')*/, token)) {
+  if (this.optional(const$242/*const SourceString('=')*/, token)) {
     var assignment = token;
     this.listener.beginInitializer(token);
     token = this.parseExpression(this.next(token));
     this.listener.endInitializer(assignment);
   }
   this.listener.endInitializedIdentifier();
   return token;
 }
 BodyParser.prototype.parseFinalVarOrType = function(token) {
   this.listener.handleVarKeyword(token);
-  return this.expect(const$160/*Keyword.VAR*/, token);
+  return this.expect(const$181/*Keyword.VAR*/, token);
 }
 BodyParser.prototype.parseIfStatement = function(token) {
   this.listener.beginIfStatement(token);
-  token = this.expect(const$164/*Keyword.IF*/, token);
-  token = this.expect(const$166/*const SourceString('(')*/, token);
+  token = this.expect(const$157/*Keyword.IF*/, token);
+  token = this.expect(const$244/*const SourceString('(')*/, token);
   token = this.parseExpression(token);
-  token = this.expect(const$167/*const SourceString(')')*/, token);
+  token = this.expect(const$245/*const SourceString(')')*/, token);
   token = this.parseStatement(token);
-  if (this.optional(const$168/*Keyword.ELSE*/, token)) {
+  if (this.optional(const$147/*Keyword.ELSE*/, token)) {
     token = this.parseStatement(token.next);
   }
   return token;
 }
 BodyParser.prototype.parseBlock = function(token) {
-  token = this.expect(const$150/*const SourceString('{')*/, token);
-  while (!this.optional(const$149/*const SourceString("}")*/, token)) {
+  token = this.expect(const$240/*const SourceString('{')*/, token);
+  while (!this.optional(const$239/*const SourceString("}")*/, token)) {
     token = this.parseStatement(token);
   }
-  return this.expect(const$149/*const SourceString("}")*/, token);
+  return this.expect(const$239/*const SourceString("}")*/, token);
 }
 // ********** Code for Listener **************
 function Listener(canceler) {
   this.classCount = 0
   this.aliasCount = 0
   this.interfaceCount = 0
   this.libraryTagCount = 0
   this.topLevelMemberCount = 0
   this.previousIdentifier = null
   this.canceler = canceler;
-  this.builders = const$135/*const EmptyLink<Expression>()*/;
-  this.topLevelElements = const$135/*const EmptyLink<Expression>()*/;
+  this.builders = const$227/*const EmptyLink<DeclarationBuilder>()*/;
+  this.topLevelElements = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   // Initializers done
 }
 Listener.prototype.beginLibraryTag = function(token) {
   this.libraryTagCount++;
 }
 Listener.prototype.beginClass = function(token) {
   this.classCount++;
   this.push(token, this.get$buildClassElement());
 }
 Listener.prototype.buildClassElement = function(declaration) {
@@ skipping 132 matching lines @@
 FunctionContext.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionContext.prototype.push = function(statement) {
   this.statements.addLast(statement);
 }
 FunctionContext.prototype.buildFunction = function(endToken) {
   var statements0 = new NodeList(this.beginBlockToken, this.statements.toLink(), endToken);
   var block = new Block(statements0);
   return new FunctionExpression(this.name.get$head(), this.formals, block, new TypeAnnotation(this.returnType.get$head()));
 }
 FunctionContext.prototype.buildFormals = function(endToken) {
-  this.formals = new NodeList(this.beginFormalsToken, const$135/*const EmptyLink<Expression>()*/, endToken, const$143);
+  this.formals = new NodeList(this.beginFormalsToken, const$227/*const EmptyLink<DeclarationBuilder>()*/, endToken, const$230);
 }
 // ********** Code for ExpressionContext **************
 function ExpressionContext(previous) {
   this.previous = previous;
-  this.expressions = const$135/*const EmptyLink<Expression>()*/;
+  this.expressions = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   // Initializers done
 }
 ExpressionContext.prototype.push = function(expression) {
   this.expressions = this.expressions.prepend(expression);
 }
 ExpressionContext.prototype.pop = function() {
   var head = this.expressions.get$head();
   this.expressions = this.expressions.get$tail();
   return head;
 }
 ExpressionContext.prototype.popAll = function() {
   var result = this.expressions;
-  this.expressions = const$135/*const EmptyLink<Expression>()*/;
+  this.expressions = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   return result;
 }
 // ********** Code for BodyListener **************
 function BodyListener(canceler0, logger) {
   this.logger = logger;
   this.expressionContext = new ExpressionContext(null);
   Listener.call(this, canceler0);
   // Initializers done
 }
 $inherits(BodyListener, Listener);
 BodyListener.prototype.beginFormalParameters = function(token) {
   this.functionContext.beginFormalsToken = token;
 }
 BodyListener.prototype.endFormalParameters = function(token) {
   this.functionContext.buildFormals(token);
 }
 BodyListener.prototype.beginArguments = function(token) {
   this.pushExpressionContext(token);
 }
 BodyListener.prototype.endArguments = function(token) {
-  var nodes = new NodeList(this.expressionContext.beginToken, this.popAllExpressions().reverse(), token, const$143);
+  var nodes = new NodeList(this.expressionContext.beginToken, this.popAllExpressions().reverse(), token, const$230);
   this.popExpressionContext();
   this.expressionContext.nodes = nodes;
 }
 BodyListener.prototype.beginReturnStatement = function(token) {
 
 }
 BodyListener.prototype.endReturnStatement = function(token) {
   var expressions = this.popAllExpressions();
   this.pushStatement(new Return(token, expressions.get$head()));
 }
@@ skipping 188 matching lines @@
 }
 Keyword.prototype.is$SourceString = function(){return this;};
 Keyword.get$keywords = function() {
   if (Keyword._keywords == null) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
   var result = new LinkedHashMapImplementation$String$Keyword();
-  for (var $i0 = const$377/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
+  for (var $i0 = const$222/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
     var keyword = $i0.next();
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 Keyword.prototype.hashCode = function() {
   return this.syntax.hashCode();
 }
 Keyword.prototype.$eq = function(other) {
   return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
 Keyword.prototype.printOn = function(sb) {
   sb.add(this.syntax);
 }
 Keyword.prototype.toString = function() {
   return this.syntax;
 }
 Keyword.prototype.printOn$1 = Keyword.prototype.printOn;
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.get$KEYWORD_STATE = function() {
   if (KeywordState._KEYWORD_STATE == null) {
-    var strings = new ListFactory$String(const$377/*Keyword.values*/.get$length());
+    var strings = new ListFactory$String(const$222/*Keyword.values*/.get$length());
     for (var i = 0;
-     i < const$377/*Keyword.values*/.get$length(); i++) {
-      strings.$setindex(i, const$377/*Keyword.values*/[i].syntax);
+     i < const$222/*Keyword.values*/.get$length(); i++) {
+      strings.$setindex(i, const$222/*Keyword.values*/[i].syntax);
     }
     strings.sort((function (a, b) {
       return a.compareTo(b);
     })
     );
     KeywordState._KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, strings.length);
   }
   return KeywordState._KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
@@ skipping 103 matching lines @@
   return firstBeginToken(this.receiver, this.selector);
 }
 Send.prototype.getEndToken = function() {
   var token = this.argumentsNode.getEndToken();
   if (token != null) return token;
   if (this.selector != null) {
     return this.selector.getEndToken();
   }
   return this.receiver.getBeginToken();
 }
-// ********** Code for NewExpression **************
-function NewExpression() {}
-$inherits(NewExpression, Expression);
-NewExpression.prototype.getBeginToken = function() {
-  return this.newToken;
-}
-NewExpression.prototype.getEndToken = function() {
-  return this.send.getEndToken();
-}
 // ********** Code for NodeList **************
 function NodeList(beginToken, nodes, endToken, delimiter) {
   this.beginToken = beginToken;
   this.nodes = nodes;
   this.endToken = endToken;
   this.delimiter = delimiter;
   // Initializers done
 }
 NodeList.singleton$ctor = function(node) {
   NodeList.call(this, null, LinkFactory.Link$factory(node));
@@ skipping 155 matching lines @@
   return visitor.visitLiteralDouble(this);
 }
 // ********** Code for LiteralBool **************
 function LiteralBool(token0, handler0) {
   Literal$bool.call(this, token0, handler0);
   // Initializers done
 }
 $inherits(LiteralBool, Literal$bool);
 LiteralBool.prototype.get$value = function() {
   switch (this.token.get$value()) {
-    case const$128/*Keyword.TRUE*/:
+    case const$177/*Keyword.TRUE*/:
 
       return true;
 
-    case const$130/*Keyword.FALSE*/:
+    case const$149/*Keyword.FALSE*/:
 
       return false;
 
     default:
 
       (this.handler)(this.token, ("not a bool " + this.token.get$value() + ""));
 
   }
 }
 LiteralBool.prototype.accept = function(visitor) {
@@ skipping 472 matching lines @@
     this.visit(argument);
   }
   else {
     this.buffer.add(this.temporary(argument));
   }
 }
 SsaCodeGenerator.prototype.visit = function(node) {
   return node.accept(this);
 }
 SsaCodeGenerator.prototype.visitAdd = function(node) {
-  this.invoke(const$134/*const SourceString('\$add')*/, node.inputs);
+  this.invoke(const$256/*const SourceString('\$add')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitBasicBlock = function(node) {
   var instruction = node.first;
   while (instruction != null) {
     if (!instruction.canBeSkipped()) {
       this.buffer.add('  ');
       if (!instruction.get$usedBy().isEmpty()) {
         this.define(instruction);
       }
       else {
@@ skipping 124 matching lines @@
   return this.visitInstruction(node);
 }
 HBaseVisitor.prototype.visitReturn = function(node) {
   return this.visitInstruction(node);
 }
 // ********** Code for HBasicBlock **************
 function HBasicBlock() {
   this.first = null
   this.last = null
   this.predecessors = [];
-  this.successors = const$14/*const <HInstruction>[]*/;
+  this.successors = const$226/*const []*/;
   // Initializers done
 }
 HBasicBlock.prototype.number = function(basicBlockId, id0) {
   this.id = basicBlockId;
   var instruction = this.first;
   while (instruction != null) {
     instruction.id = id0++;
     instruction = instruction.next;
   }
   return id0;
@@ skipping 72 matching lines @@
 HInstruction.prototype.canBeGeneratedAtUseSite = function() {
   return this._canBeGeneratedAtUseSite;
 }
 HInstruction.prototype.setCanBeGeneratedAtUseSite = function() {
   this._canBeGeneratedAtUseSite = true;
 }
 HInstruction.prototype.canBeSkipped = function() {
   return this.canBeGeneratedAtUseSite();
 }
 HInstruction.prototype.get$usedBy = function() {
-  if (this._usedBy == null) return const$14/*const <HInstruction>[]*/;
+  if (this._usedBy == null) return const$226/*const []*/;
   return this._usedBy;
 }
 HInstruction.prototype.isInBasicBlock = function() {
   return this._usedBy != null;
 }
 HInstruction.prototype.$eq = function(other) {
   return false;
 }
 HInstruction.prototype.hashCode = function() {
   return 0;
@@ skipping 36 matching lines @@
   return ('invoke: ' + this.selector + '');
 }
 HInvoke.prototype.hasSideEffects = function() {
   return true;
 }
 HInvoke.prototype.accept = function(visitor) {
   return visitor.visitInvoke(this);
 }
 // ********** Code for HAdd **************
 function HAdd(inputs0) {
-  HInvoke.call(this, const$170/*const SourceString('+')*/, inputs0);
+  HInvoke.call(this, const$251/*const SourceString('+')*/, inputs0);
   // Initializers done
 }
 $inherits(HAdd, HInvoke);
 HAdd.prototype.hasSideEffects = function() {
   return !(this.inputs.$index(0) instanceof HLiteral);
 }
 HAdd.prototype.accept = function(visitor) {
   return visitor.visitAdd(this);
 }
 // ********** Code for HExit **************
 function HExit() {
-  HInstruction.call(this, const$14/*const <HInstruction>[]*/);
+  HInstruction.call(this, const$226/*const []*/);
   // Initializers done
 }
 $inherits(HExit, HInstruction);
 HExit.prototype.canBeSkipped = function() {
   return true;
 }
 HExit.prototype.toString = function() {
   return 'exit';
 }
 HExit.prototype.hasSideEffects = function() {
   return true;
 }
 HExit.prototype.accept = function(visitor) {
   return visitor.visitExit(this);
 }
 // ********** Code for HGoto **************
 function HGoto() {
-  HInstruction.call(this, const$14/*const <HInstruction>[]*/);
+  HInstruction.call(this, const$226/*const []*/);
   // Initializers done
 }
 $inherits(HGoto, HInstruction);
 HGoto.prototype.canBeSkipped = function() {
   return true;
 }
 HGoto.prototype.toString = function() {
   return 'goto';
 }
 HGoto.prototype.hasSideEffects = function() {
@@ skipping 448 matching lines @@
   return new SourceSpan(this.script.file, startOffset, endOffset);
 }
 WorldCompiler.prototype.reportWarning = function(node, message) {
   this.world.warning(('' + message + '.'), this.spanFromNode(node));
 }
 // ********** Code for Compiler **************
 function Compiler(script) {
   this.script = script;
   // Initializers done
   this.universe = new Universe();
-  this.worklist = DoubleLinkedQueue.DoubleLinkedQueue$from$factory([const$182/*Compiler.MAIN*/]);
+  this.worklist = DoubleLinkedQueue.DoubleLinkedQueue$from$factory([const$2/*Compiler.MAIN*/]);
   this.scanner = new ScannerTask(this);
   this.resolver = new ResolverTask(this);
   this.checker = new TypeCheckerTask(this);
   this.builder = new SsaBuilderTask(this);
   this.optimizer = new SsaOptimizerTask(this);
   this.generator = new SsaCodeGeneratorTask(this);
   this.tasks = [this.scanner, this.resolver, this.checker, this.builder, this.optimizer, this.generator];
 }
 Compiler.prototype.cancel = function(reason) {
   $throw(new CompilerCancelledException(reason));
@@ skipping 140 matching lines @@
 ResolverVisitor.prototype.visitIdentifier = function(node) {
   var element = this.context.lookup(node.get$source());
   if (element == null) this.fail(node);
   return element;
 }
 ResolverVisitor.prototype.visitSend = function(node) {
   var selector = node.selector;
   var target = this.compiler.universe.find(selector.get$source());
   if (target == null) {
     var name = selector.get$source();
-    if ($eq(name, const$172/*const SourceString('print')*/) || $eq(name, const$170/*const SourceString('+')*/) || $eq(name, const$173/*const SourceString('*')*/)) {
+    if ($eq(name, const$250/*const SourceString('print')*/) || $eq(name, const$251/*const SourceString('+')*/) || $eq(name, const$252/*const SourceString('*')*/)) {
     }
     else {
       this.fail(node);
     }
   }
   else {
     this.compiler.worklist.add(selector.get$source());
   }
   this.visit(node.argumentsNode);
   return target;
@@ skipping 35 matching lines @@
 }
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver) {
   this.definitions = definitions;
   this.resolver = resolver;
   // Initializers done
 }
 VariableDefinitionsVisitor.prototype.visitSend = function(node) {
   var selector = node.selector;
   var name = selector.get$source();
-  if ($ne(name, const$162/*const SourceString('=')*/)) this.resolver.fail(node);
+  if ($ne(name, const$242/*const SourceString('=')*/)) this.resolver.fail(node);
   this.resolver.visit(node.get$arguments().get$head());
   this.visit(node.receiver);
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   var variableElement = new Element(node.get$source(), this.resolver.context.element);
   this.resolver.context.elements.$setindex(node.token.get$value(), variableElement);
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
   for (var link = node.nodes;
    !link.isEmpty(); link = link.get$tail()) {
@@ skipping 106 matching lines @@
    !link.isEmpty(); link = link.get$tail()) {
     if (!first) sb.add(', ');
     first = false;
     sb.add(link.get$head());
   }
   sb.add((') -> ' + this.returnType + ''));
   return sb.toString();
 }
 // ********** Code for Types **************
 function Types() {
-  this.VOID = new SimpleType(const$171, new Element(const$171/*const SourceString('void')*/));
-  this.INT = new SimpleType(const$175, new Element(const$175/*const SourceString('int')*/));
-  this.DYNAMIC = new SimpleType(const$176, new Element(const$176/*const SourceString('Dynamic')*/));
-  this.STRING = new SimpleType(const$177, new Element(const$177/*const SourceString('String')*/));
+  this.VOID = new SimpleType(const$246, new Element(const$246/*const SourceString('void')*/));
+  this.INT = new SimpleType(const$247, new Element(const$247/*const SourceString('int')*/));
+  this.DYNAMIC = new SimpleType(const$248, new Element(const$248/*const SourceString('Dynamic')*/));
+  this.STRING = new SimpleType(const$249, new Element(const$249/*const SourceString('String')*/));
   // Initializers done
 }
 Types.prototype.isSubtype = function(r, s) {
   return r === s || r === this.DYNAMIC || s === this.DYNAMIC;
 }
 Types.prototype.isAssignable = function(r, s) {
   return this.isSubtype(r, s) || this.isSubtype(s, r);
 }
 // ********** Code for TypeCheckerVisitor **************
 function TypeCheckerVisitor(compiler, elements, types) {
@@ skipping 48 matching lines @@
       this.compiler.reportWarning(node, 'missing argument');
     }
     if (!arguments.isEmpty()) {
       this.compiler.reportWarning(node, 'additional arguments');
     }
     return funType.returnType;
   }
   else {
     var selector = node.selector;
     var name = selector.get$source();
-    if ($eq(name, const$172/*const SourceString('print')*/) || $eq(name, const$170/*const SourceString('+')*/)) {
+    if ($eq(name, const$250/*const SourceString('print')*/) || $eq(name, const$251/*const SourceString('+')*/)) {
       return this.types.DYNAMIC;
     }
     this.compiler.cancel(('unresolved send ' + name + '.'));
   }
 }
 TypeCheckerVisitor.prototype.visitLiteralInt = function(node) {
   return this.types.INT;
 }
 TypeCheckerVisitor.prototype.visitLiteralDouble = function(node) {
   return this.types.DYNAMIC;
@@ skipping 18 matching lines @@
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expressionType = this.visit(node.expression);
   if (!this.types.isAssignable(this.expectedReturnType, expressionType)) {
     var error = CompilerError.NOT_ASSIGNABLE(this.expectedReturnType, expressionType);
     this.compiler.reportWarning(node, error);
   }
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitTypeAnnotation = function(node) {
-  if (node.typeName != null && $ne(node.typeName.get$source(), const$171/*const SourceString('void')*/)) {
+  if (node.typeName != null && $ne(node.typeName.get$source(), const$246/*const SourceString('void')*/)) {
     this.compiler.cancel(('unsupported type ' + node.typeName + ''));
   }
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitVariableDefinitions = function(node) {
   return this.types.VOID;
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
   this.generatedCode = $map([]);
-  this.scope = new Element(const$181/*const SourceString('global scope')*/);
+  this.scope = new Element(const$1/*const SourceString('global scope')*/);
   // Initializers done
 }
 Universe.prototype.find = function(name) {
   return this.elements.$index(name);
 }
 Universe.prototype.define = function(element) {
   this.elements.$setindex(element.name, element);
 }
 Universe.prototype.addGeneratedCode = function(element, code) {
   this.generatedCode.$setindex(element, code);
 }
 // ********** Code for top level **************
 function unreachable() {
-  $throw(const$8/*const Exception("Internal Error (Leg): UNREACHABLE")*/);
+  $throw(const$255/*const Exception("Internal Error (Leg): UNREACHABLE")*/);
 }
 function compile(world) {
   var file = world.readFile(options.dartScript);
   var script = new leg_Script(file);
   var compiler = new WorldCompiler(world, script);
   return compiler.run();
 }
 //  ********** Library lang **************
 // ********** Code for CodeWriter **************
 function CodeWriter() {
@@ skipping 55 matching lines @@
 }
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
   this.main = main;
   this.writer = writer;
   this.globals = $map([]);
   // Initializers done
 }
 WorldGenerator.prototype.run = function() {
   var metaGen = new MethodGenerator(this.main, null);
-  var mainCall = this.main.invoke(metaGen, null, null, Arguments.get$EMPTY(), true);
+  var mainCall = this.main.invoke(metaGen, null, null, Arguments.get$EMPTY(), false);
   this.main.declaringType.markUsed();
   world.corelib.types.$index('BadNumberFormatException').markUsed();
   world.get$coreimpl().types.$index('MatchImplementation').markUsed();
   world.get$coreimpl().types.$index('NumImplementation').markUsed();
   world.get$coreimpl().types.$index('StringImplementation').markUsed();
   this.writeTypes(world.get$coreimpl());
   this.writeTypes(world.corelib);
   var matchConstructor = world.get$coreimpl().types.$index('MatchImplementation').getConstructor('');
   this.genMethod(matchConstructor);
   matchConstructor.generator.writeDefinition(this.writer, null);
@@ skipping 718 matching lines @@
 MethodGenerator.prototype.visitBool = function(node) {
   return this.visitTypedValue(node, world.boolType);
 }
 MethodGenerator.prototype.visitValue = function(node) {
   if (node == null) return null;
   var value = node.visit(this);
   value.checkFirstClass(node.span);
   return value;
 }
 MethodGenerator.prototype.visitTypedValue = function(node, expectedType) {
-  return this.visitValue(node).convertTo(this, expectedType, node, true);
+  return this.visitValue(node).convertTo(this, expectedType, node, false);
 }
 MethodGenerator.prototype.visitVoid = function(node) {
   if ((node instanceof PostfixExpression)) {
     var value = this.visitPostfixExpression(node, true);
     value.checkFirstClass(node.span);
     return value;
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
@@ skipping 166 matching lines @@
   this._pushBlock(true);
   var item = this._scope.create(itemName, itemType, node.item.name);
   var listVar = list;
   if (list.needsTemp) {
     listVar = this._scope.create('\$list', list.type, null);
     this.writer.writeln(('var ' + listVar.code + ' = ' + list.code + ';'));
   }
   if (list.type.get$isList()) {
     var tmpi = this._scope.create('\$i', world.numType, null);
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = 0;') + ('' + tmpi.code + ' < ' + listVar.code + '.length; ' + tmpi.code + '++) {'));
-    var value = listVar.invoke(this, '\$index', node.list, new Arguments(null, [tmpi]), true);
+    var value = listVar.invoke(this, '\$index', node.list, new Arguments(null, [tmpi]), false);
     this.writer.writeln(('var ' + item.code + ' = ' + value.code + ';'));
   }
   else {
     this._pushBlock(false);
     var c = world.get$coreimpl().types.$index('ListIterator').getConstructor('');
     c.invoke$4(this, node, null, new Arguments(null, [new Value(null, 'l', false, true, false)]));
     var iterator = list.invoke$4(this, 'iterator', node.list, Arguments.get$EMPTY());
     var tmpi = this._scope.create('\$i', iterator.type, null);
     var hasNext = tmpi.invoke$4(this, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, 'next', node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = ' + iterator.code + '; ' + hasNext.code + '; ) {'));
     this.writer.writeln(('var ' + item.code + ' = ' + next.code + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._genToDartException = function(ex) {
-  var types = const$180/*const [
+  var types = const$374/*const [
         'NullPointerException', 'ObjectNotClosureException',
         'NoSuchMethodException', 'StackOverflowException']*/;
   for (var $i = types.iterator(); $i.hasNext(); ) {
     var name = $i.next();
     world.corelib.types.$index(name).markUsed();
   }
   this.writer.writeln(('' + ex + ' = \$toDartException(' + ex + ');'));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock('try {');
@@ skipping 307 matching lines @@
     else {
       var member = this.method.declaringType.get$library().lookup(xn.name.name, xn.name.span);
       if (member == null) {
         world.warning(('can not resolve ' + xn.name.name + ''), xn.span);
         return this._makeMissingValue(xn.name.name);
       }
       members = new MemberSet(member);
     }
     if (!members.get$treatAsField() || members.get$containsMethods()) {
       if (kind != 0) {
-        var right = members.get_(this, position, x);
+        var right = members.get_$3(this, position, x);
         right = captureOriginal(right);
         y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
       }
       return members.set_$4(this, position, x, y);
     }
-    x = members.get_(this, position, x);
+    x = members.get_$3(this, position, x);
   }
-  y = y.convertTo(this, x.type, yn, true);
+  y = y.convertTo(this, x.type, yn, false);
   if (kind == 0) {
     x = captureOriginal(x);
     return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), false, true, false);
   }
   else if (x.type.get$isNum() && y.type.get$isNum() && (kind != 46/*TokenKind.TRUNCDIV*/)) {
     x = captureOriginal(x);
     var op = TokenKind.kindToString(kind);
     return new Value(y.type, ('' + x.code + ' ' + op + '= ' + y.code + ''), false, true, false);
   }
   else {
     var right = x;
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
     return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), false, true, false);
   }
 }
 MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = this.visitValue(xn.target);
   var index = this.visitValue(xn.index);
   var y = this.visitValue(yn);
   var tmptarget = target;
   var tmpindex = index;
   if (kind != 0) {
     tmptarget = this.getTemp(target);
     tmpindex = this.getTemp(index);
     var right = tmptarget.invoke$4(this, '\$index', position, new Arguments(null, [this.assignTemp(tmpindex, index)]));
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
-  var ret = this.assignTemp(tmptarget, target).invoke(this, '\$setindex', position, new Arguments(null, [index, y]), true);
+  var ret = this.assignTemp(tmptarget, target).invoke(this, '\$setindex', position, new Arguments(null, [index, y]), false);
   if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
   if ($ne(tmpindex, index)) this.freeTemp(tmpindex);
   return ret;
 }
 MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = xn.self.visit(this);
   var y = this.visitValue(yn);
   var tmptarget = target;
   if (kind != 0) {
     tmptarget = this.getTemp(target);
-    var right = tmptarget.get_(this, xn.name.name, xn.name);
+    var right = tmptarget.get_$3(this, xn.name.name, xn.name);
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
-  var ret = this.assignTemp(tmptarget, target).set_(this, xn.name.name, xn.name, y, true);
+  var ret = this.assignTemp(tmptarget, target).set_(this, xn.name.name, xn.name, y, false);
   if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
   return ret;
 }
 MethodGenerator.prototype.visitUnaryExpression = function(node) {
   var value = this.visitValue(node.self);
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       if (value.type.get$isNum()) {
@@ skipping 131 matching lines @@
         argsCode.add(arg.code);
       }
       else {
         argsCode.add(arg.canonicalCode);
       }
     }
     else {
       argsCode.add(arg.code);
     }
   }
+  world.get$coreimpl().types.$index('ListFactory').markUsed();
   var code = ('[' + Strings.join(argsCode, ", ") + ']');
   var value = new Value(world.listType, code, false, true, false);
   if (node.isConst) {
     var immutableList = world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor('from');
     var result = immutableListCtor.invoke$4(this, node, null, new Arguments(null, [value]));
     value = world.gen.globalForConst(ConstListValue.ConstListValue$factory(immutableList, argValues, ('const ' + code + ''), result.code, node.span), argValues);
   }
   return value;
 }
@@ skipping 50 matching lines @@
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var body = this.visitValue(node.body);
   if (body.get$isConst()) {
     return EvaluatedValue.EvaluatedValue$factory(body.type, body.get$actualValue(), ('(' + body.canonicalCode + ')'), node.span);
   }
   return new Value(body.type, ('(' + body.code + ')'), false, true, false);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
-  return target.get_(this, node.name.name, node.name);
+  return target.get_$3(this, node.name.name, node.name);
 }
 MethodGenerator.prototype.visitVarExpression = function(node) {
   var ret = this._scope.lookup(node.name.name);
   if ($ne(ret, null)) return ret;
   ret = this.method.declaringType.resolveMember(node.name.name);
   if ($ne(ret, null)) {
-    return ret.get_(this, node, this._makeThisOrType());
+    return ret.get_$3(this, node, this._makeThisOrType());
   }
   ret = this.method.declaringType.get$library().lookup(node.name.name, node.span);
   if ($ne(ret, null)) {
-    return ret.get_(this, node, null);
+    return ret.get_$3(this, node);
   }
   world.warning(('can not resolve ' + node.name.name + ''), node.span);
   return this._makeMissingValue(node.name.name);
 }
 MethodGenerator.prototype._makeMissingValue = function(name) {
   return new Value(null, ('' + name + '()/*NotFound*/'), false, true, false);
 }
 MethodGenerator.prototype._makeThisOrType = function() {
   var outermost = this._getOutermostMethod();
   if (outermost.method.get$isStatic()) {
@@ skipping 516 matching lines @@
 lang_Parameter.prototype.resolve = function(inType) {
   this.name = this.definition.name.name;
   this.type = inType.resolveType(this.definition.type, false);
 }
 lang_Parameter.prototype.genValue = function(method, context) {
   if (this.definition.value == null || this.value != null) return;
   if (context == null) {
     context = new MethodGenerator(method, null);
   }
   this.value = this.definition.value.visit(context);
-  this.value = this.value.convertTo(context, this.type, this.definition.value, true);
+  this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
 lang_Parameter.prototype.copyWithNewType = function(newType) {
   var ret = new lang_Parameter(this.definition);
   ret.type = newType;
   ret.name = this.name;
   return ret;
 }
 lang_Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
@@ skipping 52 matching lines @@
 }
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
   return this.get$canGet() && new Value(this.get$returnType(), null, false, true, false).canInvoke(context, '\$call', args);
 }
-Member.prototype.invoke = function(context, node, target, args, checked) {
-  var newTarget = this.get_(context, node, target);
-  return newTarget.invoke(context, '\$call', node, args, checked);
+Member.prototype.invoke = function(context, node, target, args, isDynamic) {
+  var newTarget = this.get_(context, node, target, isDynamic);
+  return newTarget.invoke(context, '\$call', node, args, isDynamic);
 }
 Member.prototype.override = function(other) {
   if (this.get$isStatic()) {
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if (other.get$isStatic()) {
     world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if (this.name == '') {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
+Member.prototype.get_$3 = Member.prototype.get_;
 Member.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, true);
+  return this.invoke($0, $1, $2, $3, false);
 }
 ;
 Member.prototype.set_$4 = Member.prototype.set_;
 // ********** Code for TypeMember **************
 function TypeMember(type0) {
   this.type = type0;
   Member.call(this, type0.name, type0.library.topType);
   // Initializers done
 }
 $inherits(TypeMember, Member);
@@ skipping 11 matching lines @@
 }
 TypeMember.prototype.get$canGet = function() {
   return true;
 }
 TypeMember.prototype.get$canSet = function() {
   return false;
 }
 TypeMember.prototype.resolve = function(inType) {
 
 }
-TypeMember.prototype.get_ = function(context, node, target) {
+TypeMember.prototype.get_ = function(context, node, target, isDynamic) {
   return new Value(this.type, this.type.get$jsname(), false, false, true);
 }
-TypeMember.prototype.set_ = function(context, node, target, value, checked) {
+TypeMember.prototype.set_ = function(context, node, target, value, isDynamic) {
   world.error('can not set type', this.type.definition.span);
 }
-TypeMember.prototype.invoke = function(context, node, target, args, checked) {
+TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   world.error('can not invoke type', this.type.definition.span);
 }
+TypeMember.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_($0, $1, $2, false);
+}
+;
 TypeMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, true);
+  return this.invoke($0, $1, $2, $3, false);
 }
 ;
 TypeMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for FieldMember **************
 function FieldMember(name0, declaringType0, definition, value) {
   this._providePropertySyntax = false
   this._computing = false
   this.definition = definition;
   this.value = value;
   this.isNative = false;
   Member.call(this, name0, declaringType0);
@@ skipping 93 matching lines @@
         world.error('non constant field must be initialized in constructor', this.value.span);
       }
     }
     if (this.isStatic) {
       this._computedValue = world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
     }
     this._computing = false;
   }
   return this._computedValue;
 }
-FieldMember.prototype.get_ = function(context, node, target) {
-  this.declaringType.markUsed();
+FieldMember.prototype.get_ = function(context, node, target, isDynamic) {
+  if (!isDynamic) {
+    this.declaringType.markUsed();
+  }
   if (this.isStatic) {
     var cv = this.computeValue();
     if (this.isFinal) {
       return cv;
     }
     if (this.declaringType.get$isTop()) {
       return new Value(this.type, ('' + this.get$jsname() + ''), false, true, false);
     }
     else {
       return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), false, true, false);
     }
   }
   else if (target.get$isConst() && this.isFinal) {
     var constTarget = (target instanceof GlobalValue) ? target.exp : target;
     if ((constTarget instanceof ConstObjectValue)) {
       return constTarget.fields.$index(this.name);
     }
     else if ($eq(constTarget.type, world.stringType) && this.name == 'length') {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), false, true, false);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), false, true, false);
 }
-FieldMember.prototype.set_ = function(context, node, target, value0, checked) {
-  var lhs = this.get_(context, node, target);
-  value0 = value0.convertTo(context, this.type, node, checked);
+FieldMember.prototype.set_ = function(context, node, target, value0, isDynamic) {
+  var lhs = this.get_(context, node, target, isDynamic);
+  value0 = value0.convertTo(context, this.type, node, isDynamic);
   return new Value(this.type, ('' + lhs.code + ' = ' + value0.code + ''), false, true, false);
 }
+FieldMember.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_($0, $1, $2, false);
+}
+;
 FieldMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for PropertyMember **************
 function PropertyMember(name0, declaringType0) {
   this._provideFieldSyntax = false
   Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.get$span = function() {
@@ skipping 30 matching lines @@
   if (!Member.prototype.override.call(this, other)) return false;
   if (other.get$isProperty() || other.get$isField()) {
     if (other.get$isProperty()) this.addFromParent(other);
     return true;
   }
   else {
     world.error('property can only override field or property', this.get$span(), other.get$span());
     return false;
   }
 }
-PropertyMember.prototype.get_ = function(context, node, target) {
+PropertyMember.prototype.get_ = function(context, node, target, isDynamic) {
   if (this.getter == null) {
-    world.warning(('no getter on ' + this.declaringType.name + '.' + this.name + ''), node.span);
-    return new Value(null, ('' + target.code + '.' + this.name + '()/*NoGetter*/'), false, true, false);
+    return target.invokeNoSuchMethod(context, ('get:' + this.name + ''), node);
   }
-  return this.getter.invoke(context, node, target, Arguments.get$EMPTY(), true);
+  return this.getter.invoke(context, node, target, Arguments.get$EMPTY(), false);
 }
-PropertyMember.prototype.set_ = function(context, node, target, value, checked) {
-  return this.setter.invoke(context, node, target, new Arguments(null, [value]), checked);
+PropertyMember.prototype.set_ = function(context, node, target, value, isDynamic) {
+  return this.setter.invoke(context, node, target, new Arguments(null, [value]), isDynamic);
 }
 PropertyMember.prototype.addFromParent = function(parentMember) {
   if ((parentMember instanceof ConcreteMember)) {
     parentMember = parentMember.baseMember;
   }
   if (this.getter == null) this.getter = parentMember.getter;
   if (this.setter == null) this.setter = parentMember.setter;
 }
 PropertyMember.prototype.resolve = function(inType) {
   if (this.getter != null) this.getter.resolve(inType);
   if (this.setter != null) this.setter.resolve(inType);
   this.get$library()._addMember(this);
 }
+PropertyMember.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_($0, $1, $2, false);
+}
+;
 PropertyMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for ConcreteMember **************
 function ConcreteMember(name0, declaringType0, baseMember) {
   this.baseMember = baseMember;
   Member.call(this, name0, declaringType0);
   // Initializers done
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType0);
   var $list = this.baseMember.get$parameters();
@@ skipping 79 matching lines @@
 ConcreteMember.prototype.set$initDelegate = function(ctor) {
   this.baseMember.set$initDelegate(ctor);
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
   var type = this.baseMember.resolveType(node, isRequired);
   return type.resolveTypeParams(this.declaringType);
 }
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
 }
-ConcreteMember.prototype.get_ = function(context, node, target) {
-  var ret = this.baseMember.get_(context, node, target);
+ConcreteMember.prototype.get_ = function(context, node, target, isDynamic) {
+  var ret = this.baseMember.get_(context, node, target, isDynamic);
   return new Value(this.returnType, ret.code, false, true, false);
 }
-ConcreteMember.prototype.set_ = function(context, node, target, value, checked) {
-  var ret = this.baseMember.set_(context, node, target, value, checked);
+ConcreteMember.prototype.set_ = function(context, node, target, value, isDynamic) {
+  var ret = this.baseMember.set_(context, node, target, value, isDynamic);
   return new Value(this.returnType, ret.code, false, true, false);
 }
-ConcreteMember.prototype.invoke = function(context, node, target, args, checked) {
-  var ret = this.baseMember.invoke(context, node, target, args, checked);
+ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
+  var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
   var code = ret.code;
   if (this.get$isConstructor()) {
     code = code.replaceFirst(this.declaringType.get$genericType().get$jsname(), this.declaringType.get$jsname());
   }
-  world.gen.genMethod(this);
+  this.declaringType.genMethod(this);
   return new Value(this.returnType, code, false, true, false);
 }
+ConcreteMember.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_($0, $1, $2, false);
+}
+;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, true);
+  return this.invoke($0, $1, $2, $3, false);
 }
 ;
 ConcreteMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for MethodMember **************
 function MethodMember(name0, declaringType0, definition) {
   this.isStatic = false
   this.isAbstract = false
   this.isConst = false
   this.isFactory = false
   this.isLambda = false
   this._providePropertySyntax = false
@@ skipping 106 matching lines @@
 }
 MethodMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   return this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
   return this._providePropertySyntax = true;
 }
-MethodMember.prototype.set_ = function(context, Node0, target, value, checked) {
+MethodMember.prototype.set_ = function(context, Node0, target, value, isDynamic) {
   world.error('can not set method', this.definition.span);
 }
-MethodMember.prototype.get_ = function(context, node, target) {
-  world.gen.genMethod(this);
+MethodMember.prototype.get_ = function(context, node, target, isDynamic) {
+  this.declaringType.genMethod(this);
   this._provideOptionalParamInfo = true;
   if (this.isStatic) {
     var type = this.declaringType.get$isTop() ? '' : ('' + this.declaringType.get$jsname() + '.');
     return new Value(this.get$functionType(), ('' + type + '' + this.get$jsname() + ''), false, true, false);
   }
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), false, true, false);
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if (!args.get$hasNames()) return true;
@@ skipping 22 matching lines @@
   }
   return target.invokeNoSuchMethod(context, this.name, node, args);
 }
 MethodMember.prototype.genParameterValues = function() {
   var $list = this.parameters;
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     p.genValue(this, this.generator);
   }
 }
-MethodMember.prototype.invoke = function(context, node, target, args, checked) {
+MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.parameters == null) {
     world.info(('surprised to need to resolve: ' + this.declaringType.name + '.' + this.name + ''));
     this.resolve(this.declaringType);
   }
-  if (!this.isGenerated) {
-    world.gen.genMethod(this);
-  }
+  this.declaringType.genMethod(this);
   if (this.isStatic || this.isFactory) {
     this.declaringType.markUsed();
   }
   if (!this.namesInOrder(args)) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
   if (target != null && (this.get$isConstructor() || target.isSuper)) {
     argsCode.add('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
    i < bareCount; i++) {
     var arg = args.values.$index(i);
     if (i >= this.parameters.length) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.length, false);
       return this._argError(context, node, target, args, msg);
     }
-    arg = arg.convertTo(context, this.parameters.$index(i).type, node, checked);
+    arg = arg.convertTo(context, this.parameters.$index(i).type, node, isDynamic);
     if (this.isConst && arg.get$isConst()) {
       argsCode.add(arg.canonicalCode);
     }
     else {
       argsCode.add(arg.code);
     }
   }
   if (bareCount < this.parameters.length) {
     this.genParameterValues();
     var namedArgsUsed = 0;
     for (var i = bareCount;
      i < this.parameters.length; i++) {
       var arg = args.getValue(this.parameters.$index(i).get$name());
       if (arg == null) {
         arg = this.parameters.$index(i).get$value();
       }
       else {
-        arg = arg.convertTo(context, this.parameters.$index(i).type, node, checked);
+        arg = arg.convertTo(context, this.parameters.$index(i).type, node, isDynamic);
         namedArgsUsed++;
       }
       if (arg == null || !this.parameters.$index(i).get$isOptional()) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
         return this._argError(context, node, target, args, msg);
       }
       else {
         argsCode.add(this.isConst && arg.get$isConst() ? arg.canonicalCode : arg.code);
       }
     }
@@ skipping 106 matching lines @@
           value = this.parameters.$index(j).get$value();
         }
       }
       this.generator._scope._vars.$setindex(name0, value);
     }
     var $list = this.definition.initializers;
     for (var $i = 0;$i < $list.length; $i++) {
       var init = $list.$index($i);
       if ((init instanceof CallExpression)) {
         var delegateArgs = this.generator._makeArgs(init.get$arguments());
-        var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, true);
+        var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, false);
         if ((init.target instanceof ThisExpression)) {
           return value;
         }
         else {
           if ((value instanceof GlobalValue)) {
             value = value.exp;
           }
           var $list0 = value.fields.getKeys();
           for (var $i0 = value.fields.getKeys().iterator(); $i0.hasNext(); ) {
             var fname = $i0.next();
@@ skipping 276 matching lines @@
     param.resolve(inType);
     this.parameters.add(param);
     if (this.isStatic && param.type.get$hasTypeParams()) {
       world.error('using type parameter in static context', formal.get$span());
     }
   }
   if (!this.isLambda) {
     this.get$library()._addMember(this);
   }
 }
+MethodMember.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_($0, $1, $2, false);
+}
+;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, true);
+  return this.invoke($0, $1, $2, $3, false);
 }
 ;
 MethodMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for MemberSet **************
 function MemberSet(member) {
   this.name = member.name;
   this.members = [member];
   this.jsname = member.get$jsname();
   // Initializers done
 }
 MemberSet.prototype.get$name = function() { return this.name; };
@@ skipping 51 matching lines @@
       if (this._treatAsField) {
         member.provideFieldSyntax();
       }
       else {
         member.providePropertySyntax();
       }
     }
   }
   return this._treatAsField;
 }
-MemberSet.prototype.get_ = function(context, node, target) {
-  if (this.members.length == 1) return this.members.$index(0).get_(context, node, target);
+MemberSet.prototype.get_ = function(context, node, target, isDynamic) {
+  if (this.members.length == 1) {
+    return this.members.$index(0).get_(context, node, target, isDynamic);
+  }
+  var targets = this.members.filter((function (m) {
+    return m.get$canGet();
+  })
+  );
+  if (targets.length == 1) {
+    return targets.$index(0).get_(context, node, target, isDynamic);
+  }
   var returnValue = null;
-  var $list = this.members;
-  for (var $i = 0;$i < $list.length; $i++) {
-    var member = $list.$index($i);
-    if (!member.get$canGet()) continue;
-    var value = member.get_(context, node, target);
+  for (var $i = targets.iterator(); $i.hasNext(); ) {
+    var member = $i.next();
+    var value = member.get_(context, node, target, true);
     returnValue = this._tryUnion(returnValue, value, node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, 'getter');
   }
   if (returnValue.code == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ''), false, true, false);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.get\$' + this.jsname + '()'), false, true, false);
     }
   }
   return returnValue;
 }
-MemberSet.prototype.set_ = function(context, node, target, value, checked) {
+MemberSet.prototype.set_ = function(context, node, target, value, isDynamic) {
   if (this.members.length == 1) {
-    return this.members.$index(0).set_(context, node, target, value, checked);
+    return this.members.$index(0).set_(context, node, target, value, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
   if (targets.length == 1) {
-    return targets.$index(0).set_(context, node, target, value, checked);
+    return targets.$index(0).set_(context, node, target, value, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
-    var setValue = member.set_(context, node, target, value, false);
-    returnValue = this._tryUnion(returnValue, setValue, node);
+    var res = member.set_(context, node, target, value, true);
+    returnValue = this._tryUnion(returnValue, res, node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, 'setter');
   }
   if (returnValue.code == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), false, true, false);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), false, true, false);
     }
   }
   return returnValue;
 }
-MemberSet.prototype.invoke = function(context, node, target, args, checked) {
+MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.members.length == 1) {
-    return this.members.$index(0).invoke(context, node, target, args, checked);
+    return this.members.$index(0).invoke(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke(context, args);
   })
   );
   if (targets.length == 1) {
-    return targets.$index(0).invoke(context, node, target, args, checked);
+    return targets.$index(0).invoke(context, node, target, args, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
-    var value = member.invoke(context, node, target, args, false);
-    returnValue = this._tryUnion(returnValue, value, node);
+    var res = member.invoke(context, node, target, args, true);
+    returnValue = this._tryUnion(returnValue, res, node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, 'method');
   }
   if (returnValue.code == null) {
     if (this.name.startsWith('\$')) {
       return target.invokeSpecial(this.name, args, returnValue.type);
     }
     else {
       return this.invokeOnVar(context, node, target, args);
@@ skipping 36 matching lines @@
     );
     var returnType = reduce(map(targets, (function (t) {
       return t.get$returnType();
     })
     ), lang_Type.union);
     stub = new VarMethodSet(stubName, targets, args, returnType);
     world.objectType.varStubs.$setindex(stubName, stub);
   }
   return stub;
 }
+MemberSet.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_($0, $1, $2, false);
+}
+;
 MemberSet.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, true);
+  return this.invoke($0, $1, $2, $3, false);
 }
 ;
 MemberSet.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for FactoryMap **************
 function FactoryMap() {
   this.factories = $map([]);
   // Initializers done
 }
 FactoryMap.prototype.getFactoriesFor = function(typeName) {
   var ret = this.factories.$index(typeName);
   if (ret == null) {
@@ skipping 3364 matching lines @@
 // ********** Code for TypeReference **************
 function TypeReference(span0, type) {
   this.type = type;
   lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(TypeReference, lang_Node);
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
-// ********** Code for TreeOutput **************
-function TreeOutput() {}
-TreeOutput.prototype.write = function(s) {
-  for (var i = 0;
-   i < this.depth; i++) {
-    this.buf.add(' ');
-  }
-  this.buf.add(s);
-}
-TreeOutput.prototype.writeln = function(s) {
-  this.write(s);
-  this.buf.add('\n');
-}
-TreeOutput.prototype.heading = function(name, span) {
-  this.buf.add(name);
-  this.buf.add('\n');
-}
-TreeOutput.prototype.toValue = function(value) {
-  if (value == null) return 'null';
-  else if ((value instanceof lang_Identifier)) return value.get$name();
-  else return value.toString();
-}
-TreeOutput.prototype.writeNode = function(label, node) {
-  this.write(label + ': ');
-  this.depth += 1;
-  if (node != null) node.visit(this.printer);
-  else this.writeln('null');
-  this.depth -= 1;
-}
-TreeOutput.prototype.writeValue = function(label, value) {
-  var v = this.toValue(value);
-  this.writeln(('' + label + ': ' + v + ''));
-}
-TreeOutput.prototype.writeList = function(label, list) {
-  this.write(label + ': ');
-  if (list == null) {
-    this.buf.add('null');
-    this.buf.add('\n');
-  }
-  else {
-    for (var $i = 0;$i < list.length; $i++) {
-      var item = list.$index($i);
-      this.buf.add(item.toString());
-      this.buf.add(', ');
-    }
-    this.buf.add('\n');
-  }
-}
-TreeOutput.prototype.writeNodeList = function(label, list) {
-  this.writeln(label + ':...');
-  if (list != null) {
-    this.depth += 1;
-    for (var $i = 0;$i < list.length; $i++) {
-      var node = list.$index($i);
-      if ($ne(node, null)) {
-        node.visit(this.printer);
-      }
-      else {
-        this.writeln('null');
-      }
-    }
-    this.depth -= 1;
-  }
-}
 // ********** Code for DirectiveDefinition **************
 function DirectiveDefinition(name, arguments, span0) {
   this.name = name;
   this.arguments = arguments;
   Definition.call(this, span0);
   // Initializers done
 }
 $inherits(DirectiveDefinition, Definition);
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
@@ skipping 609 matching lines @@
   this.name = name;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(DeclaredIdentifier, lang_Expression);
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
-// ********** Code for TreePrinter **************
-function TreePrinter() {}
-TreePrinter.prototype.visitDirectiveDefinition = function(node) {
-  this.output.heading('DirectiveDefinition', node.span);
-  this.output.writeNode('name', node.name);
-  this.output.writeNodeList('arguments', node.arguments);
-}
-TreePrinter.prototype.visitTypeDefinition = function(node) {
-  this.output.heading('TypeDefinition', node.span);
-  this.output.writeValue('isClass', node.isClass);
-  this.output.writeNode('name', node.name);
-  this.output.writeList('typeParameters', node.typeParameters);
-  this.output.writeNodeList('extendsTypes', node.extendsTypes);
-  this.output.writeNodeList('implementsTypes', node.implementsTypes);
-  this.output.writeValue('nativeType', node.nativeType);
-  this.output.writeNode('factoryType', node.factoryType);
-  this.output.writeNodeList('body', node.body);
-}
-TreePrinter.prototype.visitFunctionTypeDefinition = function(node) {
-  this.output.heading('FunctionTypeDefinition', node.span);
-  this.output.writeNode('func', node.func);
-  this.output.writeList('typeParameters', node.typeParameters);
-}
-TreePrinter.prototype.visitVariableDefinition = function(node) {
-  this.output.heading('VariableDefinition', node.span);
-  this.output.writeList('modifiers', node.modifiers);
-  this.output.writeNode('type', node.type);
-  this.output.writeNodeList('names', node.names);
-  this.output.writeNodeList('values', node.values);
-}
-TreePrinter.prototype.visitFunctionDefinition = function(node) {
-  this.output.heading('FunctionDefinition', node.span);
-  this.output.writeList('modifiers', node.modifiers);
-  this.output.writeNode('returnType', node.returnType);
-  this.output.writeNode('name', node.name);
-  this.output.writeNodeList('formals', node.formals);
-  this.output.writeNodeList('initializers', node.initializers);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitReturnStatement = function(node) {
-  this.output.heading('ReturnStatement', node.span);
-  this.output.writeNode('value', node.value);
-}
-TreePrinter.prototype.visitThrowStatement = function(node) {
-  this.output.heading('ThrowStatement', node.span);
-  this.output.writeNode('value', node.value);
-}
-TreePrinter.prototype.visitAssertStatement = function(node) {
-  this.output.heading('AssertStatement', node.span);
-  this.output.writeNode('test', node.test);
-}
-TreePrinter.prototype.visitBreakStatement = function(node) {
-  this.output.heading('BreakStatement(' + this.output.toValue(node.label) + ")", node.span);
-}
-TreePrinter.prototype.visitContinueStatement = function(node) {
-  this.output.heading('ContinueStatement(' + this.output.toValue(node.label) + ")", node.span);
-}
-TreePrinter.prototype.visitIfStatement = function(node) {
-  this.output.heading('IfStatement', node.span);
-  this.output.writeNode('test', node.test);
-  this.output.writeNode('trueBranch', node.trueBranch);
-  this.output.writeNode('falseBranch', node.falseBranch);
-}
-TreePrinter.prototype.visitWhileStatement = function(node) {
-  this.output.heading('WhileStatement', node.span);
-  this.output.writeNode('test', node.test);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitDoStatement = function(node) {
-  this.output.heading('DoStatement', node.span);
-  this.output.writeNode('body', node.body);
-  this.output.writeNode('test', node.test);
-}
-TreePrinter.prototype.visitForStatement = function(node) {
-  this.output.heading('ForStatement', node.span);
-  this.output.writeNode('init', node.init);
-  this.output.writeNode('test', node.test);
-  this.output.writeNodeList('step', node.step);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitForInStatement = function(node) {
-  this.output.heading('ForInStatement', node.span);
-  this.output.writeNode('item', node.item);
-  this.output.writeNode('list', node.list);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitTryStatement = function(node) {
-  this.output.heading('TryStatement', node.span);
-  this.output.writeNode('body', node.body);
-  this.output.writeNodeList('catches', node.catches);
-  this.output.writeNode('finallyBlock', node.finallyBlock);
-}
-TreePrinter.prototype.visitSwitchStatement = function(node) {
-  this.output.heading('SwitchStatement', node.span);
-  this.output.writeNode('test', node.test);
-  this.output.writeNodeList('cases', node.cases);
-}
-TreePrinter.prototype.visitBlockStatement = function(node) {
-  this.output.heading('BlockStatement', node.span);
-  this.output.writeNodeList('body', node.body);
-}
-TreePrinter.prototype.visitLabeledStatement = function(node) {
-  this.output.heading('LabeledStatement', node.span);
-  this.output.writeNode('name', node.name);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitExpressionStatement = function(node) {
-  this.output.heading('ExpressionStatement', node.span);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitEmptyStatement = function(node) {
-  this.output.heading('EmptyStatement', node.span);
-}
-TreePrinter.prototype.visitDietStatement = function(node) {
-  this.output.heading('DietStatement', node.span);
-}
-TreePrinter.prototype.visitNativeStatement = function(node) {
-  this.output.heading('NativeStatement(' + this.output.toValue(node.body) + ")", node.span);
-}
-TreePrinter.prototype.visitLambdaExpression = function(node) {
-  this.output.heading('LambdaExpression', node.span);
-  this.output.writeNode('func', node.func);
-}
-TreePrinter.prototype.visitCallExpression = function(node) {
-  this.output.heading('CallExpression', node.span);
-  this.output.writeNode('target', node.target);
-  this.output.writeNodeList('arguments', node.arguments);
-}
-TreePrinter.prototype.visitIndexExpression = function(node) {
-  this.output.heading('IndexExpression', node.span);
-  this.output.writeNode('target', node.target);
-  this.output.writeNode('index', node.index);
-}
-TreePrinter.prototype.visitBinaryExpression = function(node) {
-  this.output.heading('BinaryExpression', node.span);
-  this.output.writeValue('op', node.op);
-  this.output.writeNode('x', node.x);
-  this.output.writeNode('y', node.y);
-}
-TreePrinter.prototype.visitUnaryExpression = function(node) {
-  this.output.heading('UnaryExpression', node.span);
-  this.output.writeValue('op', node.op);
-  this.output.writeNode('self', node.self);
-}
-TreePrinter.prototype.visitPostfixExpression = function(node) {
-  this.output.heading('PostfixExpression', node.span);
-  this.output.writeNode('body', node.body);
-  this.output.writeValue('op', node.op);
-}
-TreePrinter.prototype.visitNewExpression = function(node) {
-  this.output.heading('NewExpression', node.span);
-  this.output.writeValue('isConst', node.isConst);
-  this.output.writeNode('type', node.type);
-  this.output.writeNode('name', node.name);
-  this.output.writeNodeList('arguments', node.arguments);
-}
-TreePrinter.prototype.visitListExpression = function(node) {
-  this.output.heading('ListExpression', node.span);
-  this.output.writeValue('isConst', node.isConst);
-  this.output.writeNode('type', node.type);
-  this.output.writeNodeList('values', node.values);
-}
-TreePrinter.prototype.visitMapExpression = function(node) {
-  this.output.heading('MapExpression', node.span);
-  this.output.writeValue('isConst', node.isConst);
-  this.output.writeNode('type', node.type);
-  this.output.writeNodeList('items', node.items);
-}
-TreePrinter.prototype.visitConditionalExpression = function(node) {
-  this.output.heading('ConditionalExpression', node.span);
-  this.output.writeNode('test', node.test);
-  this.output.writeNode('trueBranch', node.trueBranch);
-  this.output.writeNode('falseBranch', node.falseBranch);
-}
-TreePrinter.prototype.visitIsExpression = function(node) {
-  this.output.heading('IsExpression', node.span);
-  this.output.writeValue('isTrue', node.isTrue);
-  this.output.writeNode('x', node.x);
-  this.output.writeNode('type', node.type);
-}
-TreePrinter.prototype.visitParenExpression = function(node) {
-  this.output.heading('ParenExpression', node.span);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitDotExpression = function(node) {
-  this.output.heading('DotExpression', node.span);
-  this.output.writeNode('self', node.self);
-  this.output.writeNode('name', node.name);
-}
-TreePrinter.prototype.visitVarExpression = function(node) {
-  this.output.heading('VarExpression(' + this.output.toValue(node.name) + ")", node.span);
-}
-TreePrinter.prototype.visitThisExpression = function(node) {
-  this.output.heading('ThisExpression', node.span);
-}
-TreePrinter.prototype.visitSuperExpression = function(node) {
-  this.output.heading('SuperExpression', node.span);
-}
-TreePrinter.prototype.visitNullExpression = function(node) {
-  this.output.heading('NullExpression', node.span);
-}
-TreePrinter.prototype.visitLiteralExpression = function(node) {
-  this.output.heading('LiteralExpression', node.span);
-  this.output.writeValue('value', node.value);
-  this.output.writeNode('type', node.type);
-  this.output.writeValue('text', node.text);
-}
-TreePrinter.prototype.visitNameTypeReference = function(node) {
-  this.output.heading('NameTypeReference', node.span);
-  this.output.writeValue('isFinal', node.isFinal);
-  this.output.writeNode('name', node.name);
-  this.output.writeNodeList('names', node.names);
-}
-TreePrinter.prototype.visitGenericTypeReference = function(node) {
-  this.output.heading('GenericTypeReference', node.span);
-  this.output.writeNode('baseType', node.baseType);
-  this.output.writeNodeList('typeArguments', node.typeArguments);
-  this.output.writeValue('depth', node.depth);
-}
-TreePrinter.prototype.visitFunctionTypeReference = function(node) {
-  this.output.heading('FunctionTypeReference', node.span);
-  this.output.writeValue('isFinal', node.isFinal);
-  this.output.writeNode('func', node.func);
-}
-TreePrinter.prototype.visitArgumentNode = function(node) {
-  this.output.heading('ArgumentNode', node.span);
-  this.output.writeNode('label', node.label);
-  this.output.writeNode('value', node.value);
-}
-TreePrinter.prototype.visitFormalNode = function(node) {
-  this.output.heading('FormalNode', node.span);
-  this.output.writeValue('isThis', node.isThis);
-  this.output.writeValue('isRest', node.isRest);
-  this.output.writeNode('type', node.type);
-  this.output.writeNode('name', node.name);
-  this.output.writeNode('value', node.value);
-}
-TreePrinter.prototype.visitCatchNode = function(node) {
-  this.output.heading('CatchNode', node.span);
-  this.output.writeNode('exception', node.exception);
-  this.output.writeNode('trace', node.trace);
-  this.output.writeNode('body', node.body);
-}
-TreePrinter.prototype.visitCaseNode = function(node) {
-  this.output.heading('CaseNode', node.span);
-  this.output.writeNode('label', node.label);
-  this.output.writeNodeList('cases', node.cases);
-  this.output.writeNodeList('statements', node.statements);
-}
-TreePrinter.prototype.visitTypeParameter = function(node) {
-  this.output.heading('TypeParameter', node.span);
-  this.output.writeNode('name', node.name);
-  this.output.writeNode('extendsType', node.extendsType);
-}
-TreePrinter.prototype.visitIdentifier = function(node) {
-  this.output.heading('Identifier(' + this.output.toValue(node.name) + ")", node.span);
-}
-TreePrinter.prototype.visitDeclaredIdentifier = function(node) {
-  this.output.heading('DeclaredIdentifier', node.span);
-  this.output.writeNode('type', node.type);
-  this.output.writeNode('name', node.name);
-}
-TreePrinter.prototype.visitTypeReference = function(node) {
-  this.output.heading('TypeReference(' + this.output.toValue(node.type) + ")", node.span);
-}
-TreePrinter.prototype.visitPostfixExpression$1 = TreePrinter.prototype.visitPostfixExpression;
 // ********** Code for lang_Type **************
 function lang_Type(name) {
   this.name = name;
   this.isTested = false;
   // Initializers done
 }
 lang_Type.prototype.get$name = function() { return this.name; };
 lang_Type.prototype.markUsed = function() {
 
 }
@@ skipping 193 matching lines @@
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
 ParameterType.prototype.getCallMethod = function() {
   return this.extendsType.getCallMethod();
 }
+ParameterType.prototype.genMethod = function(method) {
+  this.extendsType.genMethod(method);
+}
 ParameterType.prototype.isSubtypeOf = function(child) {
   return true;
 }
 ParameterType.prototype.resolveMember = function(memberName) {
   return this.extendsType.resolveMember(memberName);
 }
 ParameterType.prototype.getConstructor = function(constructorName) {
   world.internalError('no constructors on type parameters yet');
 }
 ParameterType.prototype.resolveTypeParams = function(inType) {
@@ skipping 81 matching lines @@
     var myMember = this.members.$index(memberName);
     if ($ne(myMember, null)) {
       result.$setindex(memberName, myMember);
     }
   }
   return result;
 }
 ConcreteType.prototype.markUsed = function() {
   this.genericType.markUsed();
 }
+ConcreteType.prototype.genMethod = function(method) {
+  this.genericType.genMethod(method);
+}
 ConcreteType.prototype.getFactory = function(type, constructorName) {
   return this.genericType.getFactory(type, constructorName);
 }
 ConcreteType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($ne(ret, null)) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($ne(ret, null)) return ret;
   var genericMember = this.genericType.getConstructor(constructorName);
   if (genericMember == null) return null;
@@ skipping 137 matching lines @@
 }
 DefinedType.prototype.getCallMethod = function() {
   return this.members.$index('\$call');
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if (this.isUsed) return;
   this.isUsed = true;
+  if (this._lazyGenMethods != null) {
+    var $list = orderValuesByKeys(this._lazyGenMethods);
+    for (var $i = 0;$i < $list.length; $i++) {
+      var method = $list.$index($i);
+      world.gen.genMethod(method);
+    }
+    this._lazyGenMethods = null;
+  }
   if (this.parent != null) this.parent.markUsed();
 }
+DefinedType.prototype.genMethod = function(method) {
+  if (this.isUsed) {
+    world.gen.genMethod(method);
+  }
+  else if (this.isClass) {
+    if (this._lazyGenMethods == null) this._lazyGenMethods = $map([]);
+    this._lazyGenMethods.$setindex(method.name, method);
+  }
+}
 DefinedType.prototype._resolveInterfaces = function(types) {
   if (types == null) return [];
   var interfaces0 = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType(type, true);
     if (resolvedInterface.get$isClosed() && !(this.library.get$isCore() || this.library.get$isCoreImpl())) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype(this);
@@ skipping 523 matching lines @@
   this.isType = isType;
   // Initializers done
   if (this.type == null) this.type = world.varType;
 }
 Value.prototype.get$isConst = function() {
   return false;
 }
 Value.prototype.get_ = function(context, name, node) {
   var member = this._resolveMember(context, name, node);
   if ($ne(member, null)) {
-    member = member.get_(context, node, this);
+    member = member.get_$3(context, node, this);
   }
   if ($ne(member, null)) {
     return member;
   }
   else {
     return this.invokeNoSuchMethod(context, ('get:' + name + ''), node);
   }
 }
-Value.prototype.set_ = function(context, name, node, value, checked) {
+Value.prototype.set_ = function(context, name, node, value, isDynamic) {
   var member = this._resolveMember(context, name, node);
   if ($ne(member, null)) {
-    member = member.set_(context, node, this, value, checked);
+    member = member.set_(context, node, this, value, isDynamic);
   }
   if ($ne(member, null)) {
     return member;
   }
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name + ''), node, new Arguments(null, [value]));
   }
 }
-Value.prototype.invoke = function(context, name, node, args, checked) {
+Value.prototype.invoke = function(context, name, node, args, isDynamic) {
   if (this.type.get$isVar() && name == '\$ne') {
     if (args.values.length != 1) {
       world.warning('wrong number of arguments for !=', node.span);
     }
     return new Value(null, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), false, true, false);
   }
   if (name == '\$call') {
     if (this.isType) {
       world.error('must use "new" or "const" to construct a new instance', node.span);
     }
     if (this.type.needsVarCall(args)) {
       return this._varCall(context, args);
     }
   }
   var member = this._resolveMember(context, name, node);
   if (member == null) {
     return this.invokeNoSuchMethod(context, name, node, args);
   }
   else {
-    return member.invoke(context, node, this, args, checked);
+    return member.invoke(context, node, this, args, isDynamic);
   }
 }
 Value.prototype.canInvoke = function(context, name, args) {
   if (this.type.get$isVar() && name == '\$ne') {
     return true;
   }
   if (this.type.get$isVarOrFunction() && name == '\$call') {
     return true;
   }
   var member = this._tryResolveMember(context, name);
@@ skipping 36 matching lines @@
 }
 Value.prototype.checkFirstClass = function(span) {
   if (this.isType) {
     world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = world.functionType.getCallStub(args);
   return new Value(null, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), false, true, false);
 }
-Value.prototype.convertTo = function(context, toType, node, checked) {
+Value.prototype.convertTo = function(context, toType, node, isDynamic) {
+  var checked = options.enableTypeChecks && !isDynamic;
   var callMethod = toType.getCallMethod();
   if ($ne(callMethod, null)) {
-    if (checked && options.enableTypeChecks && !toType.isAssignable(this.type)) {
+    if (checked && !toType.isAssignable(this.type)) {
       this.convertWarning(toType, node);
     }
     var arity = callMethod.get$parameters().length;
     var myCall = this.type.getCallMethod();
     if (myCall == null || myCall.get$parameters().length != arity) {
       var stub = world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
       return new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), false, true, false);
     }
   }
   if (!options.enableTypeChecks) {
     return this;
   }
   if (this.type.isSubtypeOf(toType)) {
     return this;
   }
   else if (checked && !toType.isSubtypeOf(this.type)) {
     this.convertWarning(toType, node);
   }
+  return this._typeAssert(context, toType, node);
+}
+Value.prototype._typeAssert = function(context, toType, node) {
+  if ((toType instanceof ParameterType)) {
+    var p = toType;
+    toType = p.extendsType;
+  }
   var temp = context.getTemp(this);
-  var test = context.assignTemp(temp, this);
-  test = test.instanceOf(context, toType, node.span, true, false);
+  var testCode;
+  if (toType.get$library().get$isCore() && toType.get$typeofName() != null) {
+    testCode = ("typeof(" + temp.code + ") == '" + toType.get$typeofName() + "'");
+  }
+  else if (toType.get$isClass() && !(toType instanceof ConcreteType)) {
+    toType.markUsed();
+    testCode = ('' + temp.code + ' instanceof ' + toType.get$jsname() + '');
+  }
+  else {
+    toType.isTested = true;
+    testCode = ('' + temp.code + '.is\$' + toType.get$jsname() + '');
+  }
+  testCode = ('(' + context.assignTemp(temp, this).code + ' == null || ' + testCode + ')');
+  var test = new Value(world.boolType, testCode, false, true, false);
   var err = world.corelib.types.$index('TypeError');
   world.gen.genMethod(err.members.$index('toString'));
   var args = new Arguments(null, [temp, new Value(world.stringType, ('"' + toType.name + '"'), false, true, false)]);
   var typeErr = err.getConstructor('').invoke$4(context, node, null, args);
   var result = new Value(toType, ('(' + test.code + ' ? ' + temp.code + ' : ') + ('\$throw(' + typeErr.code + '))'), false, true, false);
   if ($ne(temp, this)) context.freeTemp(temp);
   return result;
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if (toType.get$isVar()) {
@@ skipping 51 matching lines @@
 Value.prototype.invokeSpecial = function(name, args, returnType) {
   var argsString = args.getCode();
   if (name == '\$index' || name == '\$setindex') {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), false, true, false);
   }
   else {
     if (argsString.length > 0) argsString = (', ' + argsString + '');
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), false, true, false);
   }
 }
+Value.prototype.get_$3 = Value.prototype.get_;
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, true);
+  return this.invoke($0, $1, $2, $3, false);
 }
 ;
 Value.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, true);
+  return this.set_($0, $1, $2, $3, false);
 }
 ;
 // ********** Code for EvaluatedValue **************
 function EvaluatedValue() {}
 EvaluatedValue._internal$ctor = function(type0, actualValue, canonicalCode, original, code0) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
   this.original = original;
   Value.call(this, type0, code0, false, false, false);
   // Initializers done
@@ skipping 868 matching lines @@
 function to$call$1(f) { return f && f.to$call$1(); }
 Function.prototype.to$call$2 = function() {
   this.call$2 = this.$genStub(2);
   this.to$call$2 = function() { return this.call$2; };
   return this.call$2;
 };
 Function.prototype.call$2 = function($0, $1) {
   return this.to$call$2()($0, $1);
 };
 function to$call$2(f) { return f && f.to$call$2(); }
-var const$0 = new IllegalAccessException()/*const IllegalAccessException()*/;
-var const$128 = new Keyword("true", false)/*const Keyword("true")*/;
-var const$130 = new Keyword("false", false)/*const Keyword("false")*/;
-var const$134 = new StringWrapper('\$add')/*const SourceString('\$add')*/;
-var const$135 = new LinkTail()/*const EmptyLink<Expression>()*/;
-var const$136 = new Keyword("void", false)/*const Keyword("void")*/;
-var const$138 = new StringWrapper("<")/*const SourceString("<")*/;
-var const$139 = new StringWrapper(".")/*const SourceString(".")*/;
-var const$14 = ImmutableList.ImmutableList$from$factory([])/*const <HInstruction>[]*/;
-var const$143 = new StringWrapper(",")/*const SourceString(",")*/;
-var const$144 = new StringWrapper(">")/*const SourceString(">")*/;
-var const$145 = new StringWrapper("(")/*const SourceString("(")*/;
-var const$146 = new StringWrapper(")")/*const SourceString(")")*/;
-var const$147 = new StringWrapper(";")/*const SourceString(";")*/;
-var const$148 = new StringWrapper("{")/*const SourceString("{")*/;
-var const$149 = new StringWrapper("}")/*const SourceString("}")*/;
-var const$15 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
-var const$150 = new StringWrapper('{')/*const SourceString('{')*/;
-var const$151 = new Keyword("return", false)/*const Keyword("return")*/;
-var const$153 = new StringWrapper("return")/*const SourceString("return")*/;
-var const$16 = new EmptyQueueException()/*const EmptyQueueException()*/;
-var const$160 = new Keyword("var", false)/*const Keyword("var")*/;
-var const$162 = new StringWrapper('=')/*const SourceString('=')*/;
-var const$163 = new StringWrapper(',')/*const SourceString(',')*/;
-var const$164 = new Keyword("if", false)/*const Keyword("if")*/;
-var const$166 = new StringWrapper('(')/*const SourceString('(')*/;
-var const$167 = new StringWrapper(')')/*const SourceString(')')*/;
-var const$168 = new Keyword("else", false)/*const Keyword("else")*/;
-var const$170 = new StringWrapper('+')/*const SourceString('+')*/;
-var const$171 = new StringWrapper('void')/*const SourceString('void')*/;
-var const$172 = new StringWrapper('print')/*const SourceString('print')*/;
-var const$173 = new StringWrapper('*')/*const SourceString('*')*/;
-var const$175 = new StringWrapper('int')/*const SourceString('int')*/;
-var const$176 = new StringWrapper('Dynamic')/*const SourceString('Dynamic')*/;
-var const$177 = new StringWrapper('String')/*const SourceString('String')*/;
-var const$180 = ImmutableList.ImmutableList$from$factory(['NullPointerException', 'ObjectNotClosureException', 'NoSuchMethodException', 'StackOverflowException'])/*const [
+var const$1 = new StringWrapper('global scope')/*const SourceString('global scope')*/;
+var const$133 = new Keyword("break", false)/*const Keyword("break")*/;
+var const$135 = new Keyword("case", false)/*const Keyword("case")*/;
+var const$137 = new Keyword("catch", false)/*const Keyword("catch")*/;
+var const$139 = new Keyword("const", false)/*const Keyword("const")*/;
+var const$141 = new Keyword("continue", false)/*const Keyword("continue")*/;
+var const$143 = new Keyword("default", false)/*const Keyword("default")*/;
+var const$145 = new Keyword("do", false)/*const Keyword("do")*/;
+var const$147 = new Keyword("else", false)/*const Keyword("else")*/;
+var const$149 = new Keyword("false", false)/*const Keyword("false")*/;
+var const$151 = new Keyword("final", false)/*const Keyword("final")*/;
+var const$153 = new Keyword("finally", false)/*const Keyword("finally")*/;
+var const$155 = new Keyword("for", false)/*const Keyword("for")*/;
+var const$157 = new Keyword("if", false)/*const Keyword("if")*/;
+var const$159 = new Keyword("in", false)/*const Keyword("in")*/;
+var const$161 = new Keyword("is", false)/*const Keyword("is")*/;
+var const$163 = new Keyword("new", false)/*const Keyword("new")*/;
+var const$165 = new Keyword("null", false)/*const Keyword("null")*/;
+var const$167 = new Keyword("return", false)/*const Keyword("return")*/;
+var const$169 = new Keyword("super", false)/*const Keyword("super")*/;
+var const$171 = new Keyword("switch", false)/*const Keyword("switch")*/;
+var const$173 = new Keyword("this", false)/*const Keyword("this")*/;
+var const$175 = new Keyword("throw", false)/*const Keyword("throw")*/;
+var const$177 = new Keyword("true", false)/*const Keyword("true")*/;
+var const$179 = new Keyword("try", false)/*const Keyword("try")*/;
+var const$181 = new Keyword("var", false)/*const Keyword("var")*/;
+var const$183 = new Keyword("void", false)/*const Keyword("void")*/;
+var const$185 = new Keyword("while", false)/*const Keyword("while")*/;
+var const$187 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
+var const$189 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
+var const$191 = new Keyword("class", true)/*const Keyword("class", true)*/;
+var const$193 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
+var const$195 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
+var const$197 = new Keyword("get", true)/*const Keyword("get", true)*/;
+var const$199 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
+var const$2 = new StringWrapper('main')/*const SourceString('main')*/;
+var const$201 = new Keyword("import", true)/*const Keyword("import", true)*/;
+var const$203 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
+var const$205 = new Keyword("library", true)/*const Keyword("library", true)*/;
+var const$207 = new Keyword("native", true)/*const Keyword("native", true)*/;
+var const$209 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
+var const$211 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
+var const$213 = new Keyword("set", true)/*const Keyword("set", true)*/;
+var const$215 = new Keyword("source", true)/*const Keyword("source", true)*/;
+var const$217 = new Keyword("static", true)/*const Keyword("static", true)*/;
+var const$219 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
+var const$221 = new IllegalAccessException()/*const IllegalAccessException()*/;
+var const$226 = ImmutableList.ImmutableList$from$factory([])/*const []*/;
+var const$227 = new LinkTail()/*const EmptyLink<DeclarationBuilder>()*/;
+var const$228 = new StringWrapper("<")/*const SourceString("<")*/;
+var const$229 = new StringWrapper(".")/*const SourceString(".")*/;
+var const$230 = new StringWrapper(",")/*const SourceString(",")*/;
+var const$231 = new StringWrapper(">")/*const SourceString(">")*/;
+var const$232 = new StringWrapper("{")/*const SourceString("{")*/;
+var const$233 = new StringWrapper("string")/*const SourceString("string")*/;
+var const$234 = new StringWrapper("(")/*const SourceString("(")*/;
+var const$235 = new StringWrapper(")")/*const SourceString(")")*/;
+var const$236 = new StringWrapper(";")/*const SourceString(";")*/;
+var const$237 = new StringWrapper("#")/*const SourceString("#")*/;
+var const$238 = new StringWrapper("=")/*const SourceString("=")*/;
+var const$239 = new StringWrapper("}")/*const SourceString("}")*/;
+var const$240 = new StringWrapper('{')/*const SourceString('{')*/;
+var const$241 = new StringWrapper("return")/*const SourceString("return")*/;
+var const$242 = new StringWrapper('=')/*const SourceString('=')*/;
+var const$243 = new StringWrapper(',')/*const SourceString(',')*/;
+var const$244 = new StringWrapper('(')/*const SourceString('(')*/;
+var const$245 = new StringWrapper(')')/*const SourceString(')')*/;
+var const$246 = new StringWrapper('void')/*const SourceString('void')*/;
+var const$247 = new StringWrapper('int')/*const SourceString('int')*/;
+var const$248 = new StringWrapper('Dynamic')/*const SourceString('Dynamic')*/;
+var const$249 = new StringWrapper('String')/*const SourceString('String')*/;
+var const$250 = new StringWrapper('print')/*const SourceString('print')*/;
+var const$251 = new StringWrapper('+')/*const SourceString('+')*/;
+var const$252 = new StringWrapper('*')/*const SourceString('*')*/;
+var const$255 = new ExceptionImplementation("Internal Error (Leg): UNREACHABLE")/*const Exception("Internal Error (Leg): UNREACHABLE")*/;
+var const$256 = new StringWrapper('\$add')/*const SourceString('\$add')*/;
+var const$374 = ImmutableList.ImmutableList$from$factory(['NullPointerException', 'ObjectNotClosureException', 'NoSuchMethodException', 'StackOverflowException'])/*const [
       'NullPointerException', 'ObjectNotClosureException',
       'NoSuchMethodException', 'StackOverflowException']*/;
-var const$181 = new StringWrapper('global scope')/*const SourceString('global scope')*/;
-var const$182 = new StringWrapper('main')/*const SourceString('main')*/;
-var const$303 = new Keyword("break", false)/*const Keyword("break")*/;
-var const$305 = new Keyword("case", false)/*const Keyword("case")*/;
-var const$307 = new Keyword("catch", false)/*const Keyword("catch")*/;
-var const$309 = new Keyword("const", false)/*const Keyword("const")*/;
-var const$311 = new Keyword("continue", false)/*const Keyword("continue")*/;
-var const$313 = new Keyword("default", false)/*const Keyword("default")*/;
-var const$315 = new Keyword("do", false)/*const Keyword("do")*/;
-var const$317 = new Keyword("final", false)/*const Keyword("final")*/;
-var const$319 = new Keyword("finally", false)/*const Keyword("finally")*/;
-var const$321 = new Keyword("for", false)/*const Keyword("for")*/;
-var const$323 = new Keyword("in", false)/*const Keyword("in")*/;
-var const$325 = new Keyword("is", false)/*const Keyword("is")*/;
-var const$327 = new Keyword("new", false)/*const Keyword("new")*/;
-var const$329 = new Keyword("null", false)/*const Keyword("null")*/;
-var const$331 = new Keyword("super", false)/*const Keyword("super")*/;
-var const$333 = new Keyword("switch", false)/*const Keyword("switch")*/;
-var const$335 = new Keyword("this", false)/*const Keyword("this")*/;
-var const$337 = new Keyword("throw", false)/*const Keyword("throw")*/;
-var const$339 = new Keyword("try", false)/*const Keyword("try")*/;
-var const$341 = new Keyword("while", false)/*const Keyword("while")*/;
-var const$343 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
-var const$345 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
-var const$347 = new Keyword("class", true)/*const Keyword("class", true)*/;
-var const$349 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
-var const$351 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
-var const$353 = new Keyword("get", true)/*const Keyword("get", true)*/;
-var const$355 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
-var const$357 = new Keyword("import", true)/*const Keyword("import", true)*/;
-var const$359 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
-var const$361 = new Keyword("library", true)/*const Keyword("library", true)*/;
-var const$363 = new Keyword("native", true)/*const Keyword("native", true)*/;
-var const$365 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
-var const$367 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
-var const$369 = new Keyword("set", true)/*const Keyword("set", true)*/;
-var const$371 = new Keyword("source", true)/*const Keyword("source", true)*/;
-var const$373 = new Keyword("static", true)/*const Keyword("static", true)*/;
-var const$375 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
-var const$379 = new StringWrapper("string")/*const SourceString("string")*/;
-var const$380 = new StringWrapper("#")/*const SourceString("#")*/;
-var const$381 = new StringWrapper("=")/*const SourceString("=")*/;
-var const$8 = new ExceptionImplementation("Internal Error (Leg): UNREACHABLE")/*const Exception("Internal Error (Leg): UNREACHABLE")*/;
+var const$4 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
+var const$5 = new EmptyQueueException()/*const EmptyQueueException()*/;
 HTracer._singleton = null;
-var const$377 = ImmutableList.ImmutableList$from$factory([const$303, const$305, const$307, const$309, const$311, const$313, const$315, const$168, const$130, const$317, const$319, const$321, const$164, const$323, const$325, const$327, const$329, const$151, const$331, const$333, const$335, const$337, const$128, const$339, const$160, const$136, const$341, const$343, const$345, const$347, const$349, const$351, const$353, const$355, const$357, const$359, const$361, const$363, const$365, const$367, const$369, const$371, const$373, const$375])/*const <Keyword> [
+var const$222 = ImmutableList.ImmutableList$from$factory([const$133, const$135, const$137, const$139, const$141, const$143, const$145, const$147, const$149, const$151, const$153, const$155, const$157, const$159, const$161, const$163, const$165, const$167, const$169, const$171, const$173, const$175, const$177, const$179, const$181, const$183, const$185, const$187, const$189, const$191, const$193, const$195, const$197, const$199, const$201, const$203, const$205, const$207, const$209, const$211, const$213, const$215, const$217, const$219])/*const <Keyword> [
       BREAK,
       CASE,
       CATCH,
       CONST,
       CONTINUE,
       DEFAULT,
       DO,
       ELSE,
       FALSE,
       FINAL,
@@ skipping 24 matching lines @@
       IMPORT,
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();

[jimhug, 2011/11/07 21:14:21]

Yay! 600 fewer lines!