Fixes to get Swarm demo working again.

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 1827 matching lines @@
   this._previous = null;
   return this._element;
 }
 DoubleLinkedQueueEntry$E.prototype._asNonSentinelEntry = function() {
   return this;
 }
 DoubleLinkedQueueEntry$E.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
 // ********** Code for DoubleLinkedQueueEntry$KeyValuePair$K$V **************
-function DoubleLinkedQueueEntry$KeyValuePair$K$V() {}
+function DoubleLinkedQueueEntry$KeyValuePair$K$V(e) {
+  // Initializers done
+  this._element = e;
+}
 $inherits(DoubleLinkedQueueEntry$KeyValuePair$K$V, DoubleLinkedQueueEntry);
 DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
+DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype._link = function(p, n) {
+  this._next = n;
+  this._previous = p;
+  p._next = this;
+  n._previous = this;
+}
+DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.prepend = function(e) {
+  new DoubleLinkedQueueEntry$KeyValuePair$K$V(e)._link(this._previous, this);
+}
+DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype._asNonSentinelEntry = function() {
+  return this;
+}
+DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.previousEntry = function() {
+  var $0;
+  return (($0 = this._previous._asNonSentinelEntry()) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
+}
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
 function _DoubleLinkedQueueEntrySentinel() {
   // Initializers done
   DoubleLinkedQueueEntry$E.call(this, null);
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry$E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
   $throw(const$5/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
   $throw(const$5/*const EmptyQueueException()*/);
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel$E **************
 function _DoubleLinkedQueueEntrySentinel$E() {
   // Initializers done
   DoubleLinkedQueueEntry$E.call(this, null);
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$E, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V **************
 function _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V() {
   // Initializers done
-  DoubleLinkedQueueEntry$E.call(this, null);
+  DoubleLinkedQueueEntry$KeyValuePair$K$V.call(this, null);
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 DoubleLinkedQueue.prototype.is$Collection$E = function(){return this;};
 DoubleLinkedQueue.prototype.is$Collection$Object = function(){return this;};
@@ skipping 230 matching lines @@
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new ListFactory();
   this._length = 0;
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
   if (this._buffer.length == 0) return "";
-  if (this._buffer.length == 1) return $assert_String(this._buffer.$index(0));
+  if ($notnull_bool($eq(this._buffer.length, 1))) return $assert_String(this._buffer.$index(0));
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 StringBufferImpl.prototype.add$1 = StringBufferImpl.prototype.add;
 StringBufferImpl.prototype.addAll$1 = function($0) {
   return this.addAll(($0 && $0.is$Collection$Object()));
 };
 StringBufferImpl.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 StringBufferImpl.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     var length = charCodes.length;
     var tmp = new Array(length);
     for (var i = 0; i < length; i++) {
       tmp[i] = charCodes.$index(i);
     }
     charCodes = tmp;
   }
   return String.fromCharCode.apply(null, charCodes);
 }
 StringBase.join = function(strings, separator) {
-  if (strings.length == 0) return '';
+  if ($notnull_bool($eq(strings.length, 0))) return '';
   var s = $assert_String(strings.$index(0));
   for (var i = 1;
-   i < strings.length; i++) {
+   i < $assert_num(strings.length); i++) {
     s = s + separator + strings.$index(i);
   }
   return s;
 }
 StringBase.concatAll = function(strings) {
   return StringBase.join(strings, "");
 }
 // ********** Code for StringImplementation **************
 StringImplementation = String;
 StringImplementation.prototype.is$Pattern = function(){return this;};
@@ skipping 337 matching lines @@
 };
 AbstractLink.prototype.iterator$0 = function() {
   return this.iterator();
 };
 AbstractLink.prototype.printOn$1 = function($0) {
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 AbstractLink.prototype.toString$0 = function() {
   return this.toString();
 };
+// ********** Code for AbstractLink$Dynamic **************
+function AbstractLink$Dynamic() {
+  // Initializers done
+}
+$inherits(AbstractLink$Dynamic, AbstractLink);
+AbstractLink$Dynamic.prototype.is$Link = function(){return this;};
+AbstractLink$Dynamic.prototype.is$Link$Element = function(){return this;};
+AbstractLink$Dynamic.prototype.is$Link$Node = function(){return this;};
+AbstractLink$Dynamic.prototype.is$Link$T = function(){return this;};
+AbstractLink$Dynamic.prototype.is$Link$Token = function(){return this;};
+AbstractLink$Dynamic.prototype.is$Link$Type = function(){return this;};
+AbstractLink$Dynamic.prototype.is$Iterable = function(){return this;};
 // ********** Code for AbstractLink$T **************
 function AbstractLink$T() {
   // Initializers done
 }
 $inherits(AbstractLink$T, AbstractLink);
 AbstractLink$T.prototype.is$Link = function(){return this;};
 AbstractLink$T.prototype.is$Link$Element = function(){return this;};
 AbstractLink$T.prototype.is$Link$Node = function(){return this;};
 AbstractLink$T.prototype.is$Link$T = function(){return this;};
 AbstractLink$T.prototype.is$Link$Token = function(){return this;};
@@ skipping 27 matching lines @@
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 LinkTail.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkTail$Dynamic **************
 function LinkTail$Dynamic() {
   // Initializers done
-  AbstractLink$T.call(this);
+  AbstractLink$Dynamic.call(this);
 }
 $inherits(LinkTail$Dynamic, LinkTail);
 LinkTail$Dynamic.prototype.is$Link = function(){return this;};
 LinkTail$Dynamic.prototype.is$Link$Element = function(){return this;};
 LinkTail$Dynamic.prototype.is$Link$Node = function(){return this;};
 LinkTail$Dynamic.prototype.is$Link$T = function(){return this;};
 LinkTail$Dynamic.prototype.is$Link$Token = function(){return this;};
 LinkTail$Dynamic.prototype.is$Link$Type = function(){return this;};
 LinkTail$Dynamic.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$Element **************
 function LinkTail$Element() {}
 $inherits(LinkTail$Element, LinkTail);
 LinkTail$Element.prototype.is$Link = function(){return this;};
 LinkTail$Element.prototype.is$Link$Element = function(){return this;};
-LinkTail$Element.prototype.is$Link$Node = function(){return this;};
+LinkTail$Element.prototype.is$Link$Node = false;
 LinkTail$Element.prototype.is$Link$T = function(){return this;};
-LinkTail$Element.prototype.is$Link$Token = function(){return this;};
-LinkTail$Element.prototype.is$Link$Type = function(){return this;};
+LinkTail$Element.prototype.is$Link$Token = false;
+LinkTail$Element.prototype.is$Link$Type = false;
 LinkTail$Element.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$Node **************
 function LinkTail$Node() {}
 $inherits(LinkTail$Node, LinkTail);
 LinkTail$Node.prototype.is$Link = function(){return this;};
-LinkTail$Node.prototype.is$Link$Element = function(){return this;};
+LinkTail$Node.prototype.is$Link$Element = false;
 LinkTail$Node.prototype.is$Link$Node = function(){return this;};
 LinkTail$Node.prototype.is$Link$T = function(){return this;};
-LinkTail$Node.prototype.is$Link$Token = function(){return this;};
-LinkTail$Node.prototype.is$Link$Type = function(){return this;};
+LinkTail$Node.prototype.is$Link$Token = false;
+LinkTail$Node.prototype.is$Link$Type = false;
 LinkTail$Node.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$T **************
 function LinkTail$T() {}
 $inherits(LinkTail$T, LinkTail);
 LinkTail$T.prototype.is$Link = function(){return this;};
 LinkTail$T.prototype.is$Link$Element = function(){return this;};
 LinkTail$T.prototype.is$Link$Node = function(){return this;};
 LinkTail$T.prototype.is$Link$T = function(){return this;};
 LinkTail$T.prototype.is$Link$Token = function(){return this;};
 LinkTail$T.prototype.is$Link$Type = function(){return this;};
 LinkTail$T.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$Token **************
 function LinkTail$Token() {}
 $inherits(LinkTail$Token, LinkTail);
 LinkTail$Token.prototype.is$Link = function(){return this;};
-LinkTail$Token.prototype.is$Link$Element = function(){return this;};
-LinkTail$Token.prototype.is$Link$Node = function(){return this;};
+LinkTail$Token.prototype.is$Link$Element = false;
+LinkTail$Token.prototype.is$Link$Node = false;
 LinkTail$Token.prototype.is$Link$T = function(){return this;};
 LinkTail$Token.prototype.is$Link$Token = function(){return this;};
-LinkTail$Token.prototype.is$Link$Type = function(){return this;};
+LinkTail$Token.prototype.is$Link$Type = false;
 LinkTail$Token.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$Type **************
 function LinkTail$Type() {}
 $inherits(LinkTail$Type, LinkTail);
 LinkTail$Type.prototype.is$Link = function(){return this;};
-LinkTail$Type.prototype.is$Link$Element = function(){return this;};
-LinkTail$Type.prototype.is$Link$Node = function(){return this;};
+LinkTail$Type.prototype.is$Link$Element = false;
+LinkTail$Type.prototype.is$Link$Node = false;
 LinkTail$Type.prototype.is$Link$T = function(){return this;};
-LinkTail$Type.prototype.is$Link$Token = function(){return this;};
+LinkTail$Type.prototype.is$Link$Token = false;
 LinkTail$Type.prototype.is$Link$Type = function(){return this;};
 LinkTail$Type.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkEntry **************
 function LinkEntry(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
   AbstractLink$T.call(this);
 }
 $inherits(LinkEntry, AbstractLink$T);
@@ skipping 14 matching lines @@
   return list;
 }
 LinkEntry.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkEntry$Dynamic **************
 function LinkEntry$Dynamic(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
-  AbstractLink$T.call(this);
+  AbstractLink$Dynamic.call(this);
 }
 $inherits(LinkEntry$Dynamic, LinkEntry);
 // ********** Code for LinkEntry$T **************
 function LinkEntry$T(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
   AbstractLink$T.call(this);
 }
 $inherits(LinkEntry$T, LinkEntry);
@@ skipping 152 matching lines @@
   }
 }
 // ********** Code for ArrayBasedScanner$SourceString **************
 function ArrayBasedScanner$SourceString() {
   this.groupingStack = const$16/*const EmptyLink<Token>()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
   this.byteOffset = -1;
   this.tokens = new Token(0/*null.EOF_TOKEN*/, -1);
   // Initializers done
-  AbstractScanner$S.call(this);
+  AbstractScanner$SourceString.call(this);
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner$SourceString, ArrayBasedScanner);
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {
   // Initializers done
 }
 AbstractScanner.prototype.tokenize = function() {
@@ skipping 573 matching lines @@
     next = this.advance();
   }
   return next;
 }
 AbstractScanner.prototype.appendByteStringToken$2 = AbstractScanner.prototype.appendByteStringToken;
 // ********** Code for AbstractScanner$S **************
 function AbstractScanner$S() {
   // Initializers done
 }
 $inherits(AbstractScanner$S, AbstractScanner);
-AbstractScanner$S.prototype.tokenize = function() {
+// ********** Code for AbstractScanner$SourceString **************
+function AbstractScanner$SourceString() {
+  // Initializers done
+}
+$inherits(AbstractScanner$SourceString, AbstractScanner);
+AbstractScanner$SourceString.prototype.tokenize = function() {
   var next = this.advance();
   while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
-AbstractScanner$S.prototype.bigSwitch = function(next) {
+AbstractScanner$SourceString.prototype.bigSwitch = function(next) {
   this.beginToken();
   if (next === 9/*null.$TAB*/ || next === 10/*null.$LF*/ || next === 13/*null.$CR*/ || next === 32/*null.$SPACE*/) {
     this.appendWhiteSpace(next);
     return this.advance();
   }
   if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     return this.tokenizeKeywordOrIdentifier(next);
   }
   if ((65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next === 95/*null.$_*/ || next === 36/*null.$DOLLAR*/) {
     return this.tokenizeIdentifier(next, this.get$byteOffset());
@@ skipping 103 matching lines @@
     return this.tokenizeNumber(next);
   }
   if (next === -1) {
     return -1;
   }
   if (next < 0x1f) {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
   return this.tokenizeIdentifier(next, this.get$byteOffset());
 }
-AbstractScanner$S.prototype.tokenizeTag = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeTag = function(next) {
   if (this.get$byteOffset() === 0) {
     if (this.peek() === 33/*null.$BANG*/) {
       do {
         next = this.advance();
       }
       while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
       return next;
     }
   }
   this.appendStringToken(35/*null.HASH_TOKEN*/, "#");
   return this.advance();
 }
-AbstractScanner$S.prototype.tokenizeTilde = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeTilde = function(next) {
   next = this.advance();
   if (next === 47/*null.$SLASH*/) {
     return this.select(61/*null.$EQ*/, "~/=", "~/");
   }
   else {
     this.appendStringToken(126/*null.TILDE_TOKEN*/, "~");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeOpenBracket = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeOpenBracket = function(next) {
   next = this.advance();
   if (next === 93/*null.$RBRACKET*/) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendBeginGroup(91/*null.LBRACKET_TOKEN*/, "[");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeCaret = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
-AbstractScanner$S.prototype.tokenizeBar = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeBar = function(next) {
   next = this.advance();
   if (next === 124/*null.$BAR*/) {
     this.appendStringToken(124/*null.BAR_TOKEN*/, "||");
     return this.advance();
   }
   else if (next === 61/*null.$EQ*/) {
     this.appendStringToken(124/*null.BAR_TOKEN*/, "|=");
     return this.advance();
   }
   else {
     this.appendStringToken(124/*null.BAR_TOKEN*/, "|");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeAmpersand = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeAmpersand = function(next) {
   next = this.advance();
   if (next === 38/*null.$AMPERSAND*/) {
     this.appendStringToken(38/*null.AMPERSAND_TOKEN*/, "&&");
     return this.advance();
   }
   else if (next === 61/*null.$EQ*/) {
     this.appendStringToken(38/*null.AMPERSAND_TOKEN*/, "&=");
     return this.advance();
   }
   else {
     this.appendStringToken(38/*null.AMPERSAND_TOKEN*/, "&");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizePercent = function(next) {
+AbstractScanner$SourceString.prototype.tokenizePercent = function(next) {
   return this.select(61/*null.$EQ*/, "%=", "%");
 }
-AbstractScanner$S.prototype.tokenizeMultiply = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeMultiply = function(next) {
   return this.select(61/*null.$EQ*/, "*=", "*");
 }
-AbstractScanner$S.prototype.tokenizeMinus = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeMinus = function(next) {
   next = this.advance();
   if (next === 45/*null.$MINUS*/) {
     this.appendStringToken(45/*null.MINUS_TOKEN*/, "--");
     return this.advance();
   }
   else if (next === 61/*null.$EQ*/) {
     this.appendStringToken(45/*null.MINUS_TOKEN*/, "-=");
     return this.advance();
   }
   else {
     this.appendStringToken(45/*null.MINUS_TOKEN*/, "-");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizePlus = function(next) {
+AbstractScanner$SourceString.prototype.tokenizePlus = function(next) {
   next = this.advance();
   if (43/*null.$PLUS*/ === next) {
     this.appendStringToken(43/*null.PLUS_TOKEN*/, "++");
     return this.advance();
   }
   else if (61/*null.$EQ*/ === next) {
     this.appendStringToken(43/*null.PLUS_TOKEN*/, "+=");
     return this.advance();
   }
   else {
     this.appendStringToken(43/*null.PLUS_TOKEN*/, "+");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeExclamation = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
   if (next === 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "!==", "!=");
   }
   this.appendStringToken(33/*null.BANG_TOKEN*/, "!");
   return next;
 }
-AbstractScanner$S.prototype.tokenizeEquals = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeEquals = function(next) {
   next = this.advance();
   if (next === 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "===", "==");
   }
   this.appendStringToken(61/*null.EQ_TOKEN*/, "=");
   return next;
 }
-AbstractScanner$S.prototype.tokenizeGreaterThan = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   if (61/*null.$EQ*/ === next) {
     this.appendStringToken(62/*null.GT_TOKEN*/, ">=");
     return this.advance();
   }
   else if (62/*null.$GT*/ === next) {
     next = this.advance();
     if (61/*null.$EQ*/ === next) {
       this.appendStringToken(62/*null.GT_TOKEN*/, ">>=");
       return this.advance();
@@ skipping 12 matching lines @@
     else {
       this.appendGtGt(62/*null.GT_TOKEN*/, ">>");
       return next;
     }
   }
   else {
     this.appendEndGroup(62/*null.GT_TOKEN*/, ">", 60/*null.LT_TOKEN*/);
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeLessThan = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
   if (61/*null.$EQ*/ === next) {
     this.appendStringToken(188/*null.LT_EQ_TOKEN*/, "<=");
     return this.advance();
   }
   else if (60/*null.$LT*/ === next) {
     return this.select(61/*null.$EQ*/, "<<=", "<<");
   }
   else {
     this.appendBeginGroup(60/*null.LT_TOKEN*/, "<");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeNumber = function(next) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
   while (true) {
     next = this.advance();
     if (48/*null.$0*/ <= next && next <= 57/*null.$9*/) {
       continue;
     }
     else if (next === 46/*null.$PERIOD*/) {
       return this.tokenizeFractionPart(this.advance(), start);
     }
     else if (next === 101/*null.$e*/ || next === 69/*null.$E*/ || next === 100/*null.$d*/ || next === 68/*null.$D*/) {
       return this.tokenizeFractionPart(next, start);
     }
     else {
-      this.appendByteStringToken$2(105/*null.INT_TOKEN*/, this.asciiString(start));
+      this.appendByteStringToken(105/*null.INT_TOKEN*/, this.asciiString(start));
       return next;
     }
   }
 }
-AbstractScanner$S.prototype.tokenizeHexOrNumber = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeHexOrNumber = function(next) {
   var x = this.peek();
   if (x === 120/*null.$x*/ || x === 88/*null.$X*/) {
     this.advance();
     return this.tokenizeHex(x);
   }
   return this.tokenizeNumber(next);
 }
-AbstractScanner$S.prototype.tokenizeHex = function(next) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeHex = function(next) {
   var start = this.get$byteOffset();
   var hasDigits = false;
   while (true) {
     next = this.advance();
     if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 70/*null.$F*/) || (97/*null.$a*/ <= next && next <= 102/*null.$f*/)) {
       hasDigits = true;
     }
     else {
       if (!$notnull_bool(hasDigits)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
-      this.appendByteStringToken$2(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
+      this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
       return next;
     }
   }
 }
-AbstractScanner$S.prototype.tokenizeDotOrNumber = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
   if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/)) {
     return this.tokenizeFractionPart(next, start);
   }
   else if (46/*null.$PERIOD*/ === next) {
     return this.select(46/*null.$PERIOD*/, "...", "..");
   }
   else {
     this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeFractionPart = function(next, start) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
   while (!$notnull_bool(done)) {
     if (48/*null.$0*/ <= next && next <= 57/*null.$9*/) {
     }
     else if (101/*null.$e*/ === next || 69/*null.$E*/ === next) {
       next = this.tokenizeExponent(this.advance());
       done = true;
       continue LOOP;
     }
     else {
       done = true;
       continue LOOP;
     }
     next = this.advance();
   }
   if (next === 100/*null.$d*/ || next === 68/*null.$D*/) {
     next = this.advance();
   }
-  this.appendByteStringToken$2(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
+  this.appendByteStringToken(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
   return next;
 }
-AbstractScanner$S.prototype.tokenizeExponent = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeExponent = function(next) {
   if (next === 43/*null.$PLUS*/ || next === 45/*null.$MINUS*/) {
     next = this.advance();
   }
   var hasDigits = false;
   while (true) {
     if (48/*null.$0*/ <= next && next <= 57/*null.$9*/) {
       hasDigits = true;
     }
     else {
       if (!$notnull_bool(hasDigits)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return next;
     }
     next = this.advance();
   }
 }
-AbstractScanner$S.prototype.tokenizeSlashOrComment = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
   if (42/*null.$STAR*/ === next) {
     return this.tokenizeMultiLineComment(next);
   }
   else if (47/*null.$SLASH*/ === next) {
     return this.tokenizeSingleLineComment(next);
   }
   else if (61/*null.$EQ*/ === next) {
     this.appendStringToken(47/*null.SLASH_TOKEN*/, "/=");
     return this.advance();
   }
   else {
     this.appendStringToken(47/*null.SLASH_TOKEN*/, "/");
     return next;
   }
 }
-AbstractScanner$S.prototype.tokenizeSingleLineComment = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     if (10/*null.$LF*/ === next || 13/*null.$CR*/ === next || -1 === next) {
       return next;
     }
   }
 }
-AbstractScanner$S.prototype.tokenizeMultiLineComment = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     if (-1 === next) {
       return next;
     }
     else if (42/*null.$STAR*/ === next) {
       next = this.advance();
       if (next === 47/*null.$SLASH*/) {
         return this.advance();
       }
       else if (next === -1) {
         return next;
       }
     }
     else {
       next = this.advance();
     }
   }
 }
-AbstractScanner$S.prototype.tokenizeKeywordOrIdentifier = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeKeywordOrIdentifier = function(next) {
   var state = KeywordState.get$KEYWORD_STATE();
   var start = this.get$byteOffset();
   while (state != null && 97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     state = state.next(next);
     next = this.advance();
   }
   if (state == null || !$notnull_bool(state.isLeaf())) {
     return this.tokenizeIdentifier(next, start);
   }
   if ((65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || (48/*null.$0*/ <= next && next <= 57/*null.$9*/) || next === 95/*null.$_*/ || next === 36/*null.$DOLLAR*/) {
     return this.tokenizeIdentifier(next, start);
   }
   else if (next < 128) {
     this.appendKeywordToken(state.get$keyword());
     return next;
   }
   else {
     return this.tokenizeIdentifier(next, start);
   }
 }
-AbstractScanner$S.prototype.tokenizeIdentifier = function(next, start) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeIdentifier = function(next, start) {
   var isAscii = true;
   while (true) {
     if ((97/*null.$a*/ <= next && next <= 122/*null.$z*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || (48/*null.$0*/ <= next && next <= 57/*null.$9*/) || next === 95/*null.$_*/ || next === 36/*null.$DOLLAR*/) {
       next = this.advance();
     }
     else if (next < 128) {
       if ($notnull_bool(isAscii)) {
-        this.appendByteStringToken$2(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
+        this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken$2(97/*null.IDENTIFIER_TOKEN*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.utf8String(start, -1));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString$0();
+      var string = this.utf8String(nonAsciiStart, -1).toString();
       isAscii = false;
       var byteLength = nonAsciiStart - this.get$byteOffset();
       this.addToCharOffset(string.length - byteLength);
     }
   }
 }
-AbstractScanner$S.prototype.tokenizeRawString = function(next) {
+AbstractScanner$SourceString.prototype.tokenizeRawString = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
   if (next === 34/*null.$DQ*/ || next === 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
-AbstractScanner$S.prototype.tokenizeString = function(next, start, raw) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
   if (q === next) {
     next = this.advance();
     if (q === next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
-      this.appendByteStringToken$2(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
+      this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
   if ($notnull_bool(raw)) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
-AbstractScanner$S.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeSingleLineString = function(next, q1, start) {
   while (next != -1) {
     if (next === q1) {
-      this.appendByteStringToken$2(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
+      this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next === 92/*null.$BACKSLASH*/) {
       next = this.advance();
       if (next === -1) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
     else if (next === 10/*null.$LF*/ || next === 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
-AbstractScanner$S.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
   while (next != -1) {
     if (next === q1) {
-      this.appendByteStringToken$2(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
+      this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next === 10/*null.$LF*/ || next === 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
-AbstractScanner$S.prototype.tokenizeMultiLineString = function(q, start, raw) {
-  var $0;
+AbstractScanner$SourceString.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
   while (next != -1) {
     if (next === q) {
       next = this.advance();
       if (next === q) {
         next = this.advance();
         if (next === q) {
-          this.appendByteStringToken$2(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
+          this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for MalformedInputException **************
 function MalformedInputException(message) {
@@ skipping 2127 matching lines @@
   if ($globals.KeywordState__KEYWORD_STATE == null) {
     var strings = new ListFactory(const$112/*Keyword.values*/.get$length());
     for (var i = 0;
      i < const$112/*Keyword.values*/.get$length(); i++) {
       strings.$setindex(i, const$112/*Keyword.values*/[i].get$syntax());
     }
     strings.sort((function (a, b) {
       return a.compareTo$1(b);
     })
     );
-    $globals.KeywordState__KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, strings.length);
+    $globals.KeywordState__KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, $assert_num(strings.length));
   }
   return $globals.KeywordState__KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
   var result = new ListFactory(26);
   $assert(length != 0, "length != 0", "keyword.dart", 161, 12);
   var chunk = 0;
   var chunkStart = -1;
   for (var i = offset;
    i < offset + length; i++) {
@@ skipping 1492 matching lines @@
   })
   ));
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, parameterNames, graph) {
   new SsaPhiEliminator().visitGraph(graph);
   var buffer = new StringBufferImpl("");
   var codegen = new SsaCodeGenerator(this.compiler, buffer, parameterNames);
   codegen.visitGraph(graph);
   var parameters = new StringBufferImpl("");
   for (var i = 0;
-   i < parameterNames.length; i++) {
+   i < $assert_num(parameterNames.length); i++) {
     if (i != 0) parameters.add(', ');
     parameters.add(parameterNames.$index(i));
   }
   return ('function ' + methodName + '(' + parameters + ') {\n' + buffer + '}\n');
 }
 // ********** Code for SsaCodeGenerator **************
 function SsaCodeGenerator(compiler, buffer, parameterNames) {
   this.indent = 0
   this.compiler = compiler;
   this.buffer = buffer;
@@ skipping 3137 matching lines @@
   $globals.world.get$coreimpl().types.$index('StringImplementation').markUsed$0();
   this.genMethod((($0 = $globals.world.get$coreimpl().types.$index('StringImplementation').getMember$1('contains')) && $0.is$Member()));
   if ($notnull_bool($globals.world.corelib.types.$index('Isolate').get$isUsed()) || $notnull_bool($globals.world.get$coreimpl().types.$index('ReceivePortImpl').get$isUsed())) {
     this.corejs.useIsolates = true;
     var isolateMain = (($0 = $globals.world.get$coreimpl().topType.resolveMember('startRootIsolate').members.$index(0)) && $0.is$MethodMember());
     mainCall = isolateMain.invoke((metaGen && metaGen.is$MethodGenerator()), null, null, new Arguments(null, [this.main._get((metaGen && metaGen.is$MethodGenerator()), this.main.definition, null, false)]), false);
   }
   this.writeTypes($globals.world.get$coreimpl());
   this.writeTypes($globals.world.corelib);
   this.writeTypes(this.main.declaringType.get$library());
+  if (this._mixins != null) this.writer.write(this._mixins.get$text());
   this.writeGlobals();
   this.writer.writeln(('' + mainCall.get$code() + ';'));
 }
 WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
   var $0;
   this.hasStatics = true;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname());
   if (!this.globals.containsKey(fullname)) {
     this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
   }
@@ skipping 105 matching lines @@
     var $list = type.get$constructors().getValues();
     for (var $i = type.get$constructors().getValues().iterator$0(); $i.hasNext$0(); ) {
       var c = $i.next$0();
       if ($notnull_bool($ne(c.get$generator(), null)) && $notnull_bool($ne(c, standardConstructor))) {
         c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
   if (!$notnull_bool(type.get$isTop())) {
     if ((type instanceof ConcreteType)) {
+      var c = (type && type.is$ConcreteType());
       this._ensureInheritsHelper();
-      this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$genericType().get$jsname() + ');'));
+      this.writer.writeln(('\$inherits(' + c.get$jsname() + ', ' + c.genericType.get$jsname() + ');'));
+      for (var p = c._parent;
+       (p instanceof ConcreteType); p = p._parent) {
+        this._ensureInheritMembersHelper();
+        this._mixins.writeln(('\$inheritsMembers(' + c.get$jsname() + ', ' + p.get$jsname() + ');'));
+      }
     }
     else if (!$notnull_bool(type.get$isNativeType())) {
       if (type.get$parent() != null && !$notnull_bool(type.get$parent().get$isObject())) {
         this._ensureInheritsHelper();
         this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
       }
     }
   }
   if (!(type instanceof ConcreteType)) {
     this._maybeIsTest(type, type);
@@ skipping 44 matching lines @@
       this._writeMethod((member && member.is$Member()));
     }
   }
   this._writeDynamicStubs(type);
 }
 WorldGenerator.prototype._ensureInheritsHelper = function() {
   if ($notnull_bool(this._inheritsGenerated)) return;
   this._inheritsGenerated = true;
   this.writer.writeln("/** Implements extends for Dart classes on JavaScript prototypes. */\nfunction $inherits(child, parent) {\n  if (child.prototype.__proto__) {\n    child.prototype.__proto__ = parent.prototype;\n  } else {\n    function tmp() {};\n    tmp.prototype = parent.prototype;\n    child.prototype = new tmp();\n    child.prototype.constructor = child;\n  }\n}");
 }
+WorldGenerator.prototype._ensureInheritMembersHelper = function() {
+  if (this._mixins != null) return;
+  this._mixins = new CodeWriter();
+  this._mixins.comment('// ********** Generic Type Inheritance **************');
+  this._mixins.writeln("/** Implements extends for generic types. */\nfunction $inheritsMembers(child, parent) {\n  child = child.prototype;\n  parent = parent.prototype;\n  Object.getOwnPropertyNames(parent).forEach(function(name) {\n    if (typeof(child[name]) == 'undefined') child[name] = parent[name];\n  });\n}");
+}
 WorldGenerator.prototype._writeDynamicStubs = function(type) {
   if (type.varStubs != null) {
     var $list = orderValuesByKeys(type.varStubs);
     for (var $i = 0;$i < $list.length; $i++) {
       var stub = $list.$index($i);
       stub.generate$1(this.writer);
     }
   }
 }
 WorldGenerator.prototype._writeStaticField = function(field) {
@@ skipping 335 matching lines @@
   else if ($notnull_bool(this.method.get$isStatic())) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   else {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.') + ('' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   if ($notnull_bool(this.needsThis)) {
     defWriter.writeln('var \$this = this; // closure support');
   }
   if (this._usedTemps.get$length() > 0 || this._freeTemps.length > 0) {
-    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 736, 14);
+    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 769, 14);
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo$1(y);
     })
     );
     defWriter.writeln(('var ' + Strings.join(this._freeTemps, ", ") + ';'));
   }
   defWriter.writeln(this.writer.get$text());
   if ($notnull_bool($ne(names, null))) {
     defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List$String()), ", ") + ')'));
@@ skipping 50 matching lines @@
         var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
         defWriter.writeln(('' + start + meth.get$jsname() + '.\$optional = ' + optional));
       }
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
   var $0;
   var initializers = null;
   var initializedFields = null;
+  var allMembers = null;
   if ($notnull_bool(this.method.get$isConstructor())) {
     initializers = [];
     initializedFields = new HashSetImplementation();
-    var $list = $globals.world.gen._orderValues(this.method.declaringType.getAllMembers());
-    for (var $i = 0;$i < $list.length; $i++) {
-      var f = $list.$index($i);
-      if ((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic())) {
+    allMembers = $globals.world.gen._orderValues(this.method.declaringType.getAllMembers());
+    for (var $i = allMembers.iterator$0(); $i.hasNext$0(); ) {
+      var f = $i.next$0();
+      if ($notnull_bool(f.get$isField()) && !$notnull_bool(f.get$isStatic())) {
         var cv = f.computeValue$0();
         if ($notnull_bool($ne(cv, null))) {
           initializers.add$1(('this.' + f.get$jsname() + ' = ' + cv.get$code()));
           initializedFields.add$1(f.get$name());
         }
       }
     }
   }
   this._paramCode = [];
   var $list = this.method.get$parameters();
@@ skipping 82 matching lines @@
         }
       }
       if ($notnull_bool($ne(declaredInitializers, null)) && declaredInitializers.length > 1) {
         var init = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
         $globals.world.error('no initialization allowed on redirecting constructors', (($0 = init.get$span()) && $0.is$SourceSpan()));
       }
       initializedFields = null;
     }
   }
   if ($notnull_bool($ne(initializedFields, null))) {
-    var $list = this.method.declaringType.get$members().getKeys();
-    for (var $i = this.method.declaringType.get$members().getKeys().iterator$0(); $i.hasNext$0(); ) {
-      var name = $i.next$0();
-      var member = this.method.declaringType.get$members().$index(name);
-      if ((member instanceof FieldMember) && $notnull_bool(member.get$isFinal()) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains$1(name))) {
-        $globals.world.error(('Field "' + name + '" is final and was not initialized'), (($0 = this.method.get$definition().get$span()) && $0.is$SourceSpan()));
+    for (var $i = allMembers.iterator$0(); $i.hasNext$0(); ) {
+      var member = $i.next$0();
+      if ($notnull_bool(member.get$isField()) && $notnull_bool(member.get$isFinal()) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains$1(member.get$name()))) {
+        $globals.world.error(('Field "' + member.get$name() + '" is final and was not initialized'), (($0 = this.method.get$definition().get$span()) && $0.is$SourceSpan()));
       }
     }
   }
   this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
   if ((targetExp instanceof DotExpression)) {
     var dot = (targetExp && targetExp.is$DotExpression());
@@ skipping 976 matching lines @@
     var u = (item && item.is$UnaryExpression());
     return u.op.kind == 16/*TokenKind.INCR*/ || u.op.kind == 17/*TokenKind.DECR*/;
   }
   else {
     return false;
   }
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2158, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2192, 12);
   if (!!(($0 = node.value) && $0.is$List)) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator$0(); $i.hasNext$0(); ) {
       var item = $i.next$0();
       var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.get$code();
       if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression) || (item instanceof PostfixExpression) || $notnull_bool(this._isUnaryIncrement((item && item.is$lang_Expression())))) {
         code = ('(' + code + ')');
@@ skipping 664 matching lines @@
 }
 Member.prototype.get$isMethod = function() {
   return false;
 }
 Member.prototype.get$isProperty = function() {
   return false;
 }
 Member.prototype.get$isAbstract = function() {
   return false;
 }
+Member.prototype.get$isFinal = function() {
+  return false;
+}
 Member.prototype.get$isConst = function() {
   return false;
 }
 Member.prototype.get$isFactory = function() {
   return false;
 }
 Member.prototype.get$isOperator = function() {
   return this.name.startsWith('\$');
 }
 Member.prototype.get$isCallMethod = function() {
@@ skipping 16 matching lines @@
 }
 Member.prototype.providePropertySyntax = function() {
 
 }
 Member.prototype.get$initDelegate = function() {
   $globals.world.internalError('cannot have initializers', this.get$span());
 }
 Member.prototype.set$initDelegate = function(ctor) {
   $globals.world.internalError('cannot have initializers', this.get$span());
 }
+Member.prototype.computeValue = function() {
+  $globals.world.internalError('cannot have value', this.get$span());
+}
 Member.prototype.get$inferredResult = function() {
   var t = this.get$returnType();
   if ($notnull_bool(t.get$isBool()) && ($notnull_bool(this.get$library().get$isCore()) || $notnull_bool(this.get$library().get$isCoreImpl()))) {
     return $globals.world.nonNullBool;
   }
   return (t && t.is$lang_Type());
 }
 Member.prototype.get$definition = function() {
   return null;
 }
@@ skipping 13 matching lines @@
     $globals.world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     $globals.world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
-  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 195, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 201, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if (this.name == '') {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + this.name + '\$factory');
   }
 }
 Member.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
   if ($notnull_bool(this.get$isStatic()) && $notnull_bool(type.get$hasTypeParams())) {
     $globals.world.error('using type parameter in static context', node.span);
   }
   return (type && type.is$lang_Type());
 }
 Member.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()));
 };
 Member.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()));
 };
 Member.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
+Member.prototype.computeValue$0 = function() {
+  return this.computeValue();
+};
 Member.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 Member.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 Member.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 Member.prototype.provideFieldSyntax$0 = function() {
@@ skipping 388 matching lines @@
 }
 ConcreteMember.prototype.get$isAbstract = function() {
   return this.baseMember.get$isAbstract();
 }
 ConcreteMember.prototype.get$isConst = function() {
   return this.baseMember.get$isConst();
 }
 ConcreteMember.prototype.get$isFactory = function() {
   return this.baseMember.get$isFactory();
 }
+ConcreteMember.prototype.get$isFinal = function() {
+  return this.baseMember.get$isFinal();
+}
 ConcreteMember.prototype.get$jsname = function() {
   return this.baseMember.get$jsname();
 }
 ConcreteMember.prototype.set$jsname = function(name) {
   return $globals.world.internalError('bad set of jsname on ConcreteMember');
 }
 ConcreteMember.prototype.get$canGet = function() {
   return this.baseMember.get$canGet();
 }
 ConcreteMember.prototype.get$canSet = function() {
@@ skipping 37 matching lines @@
   return this.baseMember.get$initDelegate();
 }
 ConcreteMember.prototype.set$initDelegate = function(ctor) {
   this.baseMember.set$initDelegate(ctor);
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
   var $0;
   var type = this.baseMember.resolveType(node, isRequired);
   return (($0 = type.resolveTypeParams$1(this.declaringType)) && $0.is$lang_Type());
 }
+ConcreteMember.prototype.computeValue = function() {
+  return this.baseMember.computeValue();
+}
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
 }
 ConcreteMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = this.baseMember._get(context, node, target, isDynamic);
   return new Value(this.get$inferredResult(), ret.code, node.span, true);
 }
 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, node.span, true);
@@ skipping 11 matching lines @@
 }
 ConcreteMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 ConcreteMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 ConcreteMember.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
+ConcreteMember.prototype.computeValue$0 = function() {
+  return this.computeValue();
+};
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 ConcreteMember.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 ConcreteMember.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 ConcreteMember.prototype.provideFieldSyntax$0 = function() {
@@ skipping 5562 matching lines @@
 }
 lang_Type.prototype.get$parent = function() {
   return null;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
 lang_Type.prototype.hashCode = function() {
   return this.name.hashCode();
 }
+lang_Type.prototype._checkOverride = function(member) {
+  var parentMember = this._getMemberInParents(member.name);
+  if ($notnull_bool($ne(parentMember, null))) {
+    if (!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library())) {
+      member.override((parentMember && parentMember.is$Member()));
+    }
+  }
+}
+lang_Type.prototype._createNotEqualMember = function() {
+  var $0;
+  var eq = (($0 = this.get$members().$index('\$eq')) && $0.is$MethodMember());
+  if (eq == null) {
+    $globals.world.internalError('INTERNAL: object does not define ==', this.get$definition().span);
+  }
+  var ne = new MethodMember('\$ne', this, eq.definition);
+  ne.isGenerated = true;
+  ne.returnType = eq.returnType;
+  ne.parameters = eq.parameters;
+  ne.isStatic = eq.isStatic;
+  ne.isAbstract = eq.isAbstract;
+  return ne;
+}
+lang_Type.prototype._getMemberInParents = function(memberName) {
+  if ($notnull_bool(this.get$isClass())) {
+    if (this.get$parent() != null) {
+      return this.get$parent().getMember(memberName);
+    }
+    else if ($notnull_bool(this.get$isObject())) {
+      if (memberName == '\$ne') {
+        var ret = this._createNotEqualMember();
+        this.get$members().$setindex(memberName, ret);
+        return (ret && ret.is$Member());
+      }
+      return null;
+    }
+  }
+  else {
+    if (this.get$interfaces() != null && this.get$interfaces().length > 0) {
+      var $list = this.get$interfaces();
+      for (var $i = 0;$i < $list.length; $i++) {
+        var i = $list.$index($i);
+        var ret = i.getMember$1(memberName);
+        if ($notnull_bool($ne(ret, null))) {
+          return (ret && ret.is$Member());
+        }
+      }
+      return null;
+    }
+    else {
+      return $globals.world.objectType.getMember(memberName);
+    }
+  }
+}
 lang_Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
   if (!$notnull_bool(this.isSubtypeOf(other))) {
     var msg = ('type ' + this.name + ' is not a subtype of ' + other.name);
     if ($notnull_bool(typeErrors)) {
       $globals.world.error($assert_String(msg), span);
     }
     else {
       $globals.world.warning($assert_String(msg), span);
     }
   }
@@ skipping 383 matching lines @@
     if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add$1(newType);
   }
   if (!$notnull_bool(needsNewType)) return this;
   return this.genericType.getOrMakeConcreteType((newTypeArgs && newTypeArgs.is$List$Type()));
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
-  return this.genericType.get$parent();
+  if (this._parent == null && this.genericType.get$parent() != null) {
+    this._parent = this.genericType.get$parent().resolveTypeParams(this);
+  }
+  return this._parent;
 }
 ConcreteType.prototype.get$interfaces = function() {
   if (this._interfaces == null && this.genericType.interfaces != null) {
     this._interfaces = [];
     var $list = this.genericType.interfaces;
     for (var $i = 0;$i < $list.length; $i++) {
       var i = $list.$index($i);
       this._interfaces.add(i.resolveTypeParams$1(this));
     }
   }
@@ skipping 41 matching lines @@
     ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
     this.factories.addFactory(this.name, constructorName, (ret && ret.is$Member()));
   }
   else {
     ret = new ConcreteMember(this.name, this, genericMember);
     this.constructors.$setindex(constructorName, ret);
   }
   return ret;
 }
 ConcreteType.prototype.getMember = function(memberName) {
-  var ret = this.members.$index(memberName);
-  if ($notnull_bool($ne(ret, null))) return (ret && ret.is$Member());
-  var genericMember = this.genericType.getMember(memberName);
-  if ($notnull_bool(genericMember == null)) return null;
-  ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
-  this.members.$setindex(memberName, ret);
-  return (ret && ret.is$Member());
+  var $0;
+  var member = (($0 = this.members.$index(memberName)) && $0.is$Member());
+  if (member != null) {
+    this._checkOverride(member);
+    return member;
+  }
+  var genericMember = this.genericType.members.$index(memberName);
+  if ($notnull_bool($ne(genericMember, null))) {
+    member = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
+    this.members.$setindex(memberName, member);
+    return member;
+  }
+  return this._getMemberInParents(memberName);
 }
 ConcreteType.prototype.resolveMember = function(memberName) {
   var mem = this.getMember(memberName);
   if ($notnull_bool(mem == null)) return null;
   var ret = new MemberSet((mem && mem.is$Member()), false);
   if ($notnull_bool(mem.get$isStatic())) return (ret && ret.is$MemberSet());
   var $list = this.genericType.get$subtypes();
   for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext$0(); ) {
     var t = $i.next$0();
     var m = t.get$members().$index(memberName);
@@ skipping 67 matching lines @@
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
 DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 632, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 703, 12);
   this.definition = def;
   if ((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null) {
     this.isNativeType = true;
   }
   if (this.definition != null && this.definition.get$typeParameters() != null) {
     this._concreteTypes = $map([]);
     this.typeParameters = [];
     var $list = this.definition.get$typeParameters();
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
@@ skipping 89 matching lines @@
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed()) && !($notnull_bool(this.library.get$isCore()) || $notnull_bool(this.library.get$isCoreImpl()))) {
       $globals.world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', (($0 = type.get$span()) && $0.is$SourceSpan()));
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 748, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 819, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   var $0;
   if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext$0(); ) {
       var st = $i.next$0();
       this._subtypes.add(st);
@@ skipping 230 matching lines @@
     this.addMethod(null, (c && c.is$FunctionDefinition()));
     this.constructors.$index('').resolve$1(this);
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var $0;
   var member = (($0 = this.members.$index(memberName)) && $0.is$Member());
   if (member != null) {
-    var parentMember = this.getMemberInParents(memberName);
-    if ($notnull_bool($ne(parentMember, null))) {
-      if (!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library())) {
-        member.override((parentMember && parentMember.is$Member()));
-      }
-    }
+    this._checkOverride(member);
     return member;
   }
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
       return (($0 = libType.get$typeMember()) && $0.is$Member());
     }
   }
-  return this.getMemberInParents(memberName);
-}
-DefinedType.prototype.getMemberInParents = function(memberName) {
-  if ($notnull_bool(this.isClass)) {
-    if (this.get$parent() != null) {
-      return this.get$parent().getMember(memberName);
-    }
-    else if ($notnull_bool(this.get$isObject())) {
-      if (memberName == '\$ne') {
-        var ret = this._createNotEqualMember();
-        this.members.$setindex(memberName, ret);
-        return (ret && ret.is$Member());
-      }
-      return null;
-    }
-  }
-  else {
-    if (this.interfaces != null && this.interfaces.length > 0) {
-      var $list = this.interfaces;
-      for (var $i = 0;$i < $list.length; $i++) {
-        var i = $list.$index($i);
-        var ret = i.getMember$1(memberName);
-        if ($notnull_bool($ne(ret, null))) {
-          return (ret && ret.is$Member());
-        }
-      }
-      return null;
-    }
-    else {
-      return $globals.world.objectType.getMember(memberName);
-    }
-  }
+  return this._getMemberInParents(memberName);
 }
 DefinedType.prototype.resolveMember = function(memberName) {
   var $0;
   var ret = (($0 = this._resolvedMembers.$index(memberName)) && $0.is$MemberSet());
   if (ret != null) return ret;
   var member = this.getMember(memberName);
   if (member == null) {
     return null;
   }
   ret = new MemberSet(member, false);
@@ skipping 10 matching lines @@
         m = t.getMember$1(memberName);
       }
       else {
         m = t.get$members().$index(memberName);
       }
       if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
     }
     return ret;
   }
 }
-DefinedType.prototype._createNotEqualMember = function() {
-  var $0;
-  var eq = (($0 = this.members.$index('\$eq')) && $0.is$MethodMember());
-  if (eq == null) {
-    $globals.world.internalError('INTERNAL: object does not define ==', this.definition.span);
-  }
-  var ne = new MethodMember('\$ne', this, eq.definition);
-  ne.isGenerated = true;
-  ne.returnType = eq.returnType;
-  ne.parameters = eq.parameters;
-  ne.isStatic = eq.isStatic;
-  ne.isAbstract = eq.isAbstract;
-  return ne;
-}
 DefinedType._getDottedName = function(type) {
   if (type.names != null) {
     var names = map(type.names, (function (n) {
       return n.get$name();
     })
     );
     return type.name.name + '.' + Strings.join((names && names.is$List$String()), '.');
   }
   else {
     return type.name.name;
@@ skipping 67 matching lines @@
   }
   else {
     $globals.world.internalError('unknown type reference', node.span);
   }
   return node.type;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
-  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1231, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1248, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
    i < typeArgs.length; i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1251, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1268, 12);
   var name = _getCallStubName('call', args);
   if (this.varStubs == null) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return (stub && stub.is$VarFunctionStub());
 }
 DefinedType.prototype.addDirectSubtype$1 = function($0) {
@@ skipping 232 matching lines @@
         $globals.world.error($assert_String(message), node.span);
       }
       else {
         $globals.world.warning($assert_String(message), node.span);
       }
     }
   }
   if ($notnull_bool(member == null) && !$notnull_bool(this.isSuper) && !$notnull_bool(this.isType)) {
     member = context.findMembers(name);
     if ($notnull_bool(member == null) && !$notnull_bool(isDynamic)) {
-      $globals.world.warning(('' + name + ' is not defined anywhere in the world.'), node.span);
+      var where = 'the world';
+      if (name.startsWith('_')) {
+        where = ('library "' + context.get$library().name + '"');
+      }
+      $globals.world.warning(('' + name + ' is not defined anywhere in ' + where + '.'), node.span);
     }
   }
   return member;
 }
 Value.prototype.checkFirstClass = function(span) {
   if ($notnull_bool(this.isType)) {
     $globals.world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
@@ skipping 158 matching lines @@
     for (var i = 0;
      i < args.get$length(); i++) {
       argsCode.add$1(args.values.$index(i).get$code());
     }
     pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value($globals.world.stringType, ('"' + name + '"'), node.span, true), new Value($globals.world.listType, ('[' + pos + ']'), node.span, true)];
   return (($0 = this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs))) && $0.is$Value());
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 484, 12);
-  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 485, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 488, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 489, 12);
   var argsString = args.getCode();
   if (name == '\$index' || name == '\$setindex') {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), this.span, true);
   }
   else {
     if (argsString.length > 0) argsString = (', ' + argsString);
     $globals.world.gen.corejs.useOperator(name);
     return new Value(returnType, ('' + name + '(' + this.code + argsString + ')'), this.span, true);
   }
 }
@@ skipping 207 matching lines @@
 BareValue.prototype._ensureCode = function() {
   if (this.code != null) return;
   if ($notnull_bool(this.isType)) {
     this.code = this.type.get$jsname();
   }
   else {
     this.code = this.home._makeThisCode();
   }
 }
 BareValue.prototype._tryResolveMember = function(context, name) {
-  $assert($eq(context, this.home), "context == home", "value.dart", 705, 12);
+  $assert($eq(context, this.home), "context == home", "value.dart", 709, 12);
   var member = this.type.resolveMember(name);
   if ($notnull_bool($ne(member, null))) {
     this._ensureCode();
     return member;
   }
   member = this.home.get$library().lookup(name, this.span);
   if ($notnull_bool($ne(member, null))) {
     return member;
   }
   this._ensureCode();
@@ skipping 344 matching lines @@
   this.throwOnFatal = false
   this.showInfo = false
   this.showWarnings = true
   // Initializers done
   this.libDir = homedir + '/lib';
   var ignoreUnrecognizedFlags = false;
   var passedLibDir = false;
   this.childArgs = [];
   loop:
   for (var i = 2;
-   i < args.length; i++) {
+   i < $assert_num(args.length); i++) {
     var arg = args.$index(i);
     switch (arg) {
       case '--enable_leg':
 
         this.enableLeg = true;
         continue loop;
 
       case '--leg_only':
 
         this.enableLeg = true;
@@ skipping 425 matching lines @@
     if (!$notnull_bool($globals.options.compileOnly)) {
       process.argv = [argv.$index(0), argv.$index(1)];
       process.argv.addAll($globals.options.childArgs);
       vm.runInNewContext($assert_String(code), createSandbox());
     }
   }
   else {
     process.exit(1);
   }
 }
+// ********** Generic Type Inheritance **************
+/** Implements extends for generic types. */
+function $inheritsMembers(child, parent) {
+  child = child.prototype;
+  parent = parent.prototype;
+  Object.getOwnPropertyNames(parent).forEach(function(name) {
+    if (typeof(child[name]) == 'undefined') child[name] = parent[name];
+  });
+}
+$inheritsMembers(_DoubleLinkedQueueEntrySentinel$E, DoubleLinkedQueueEntry$E);
+$inheritsMembers(_DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V, DoubleLinkedQueueEntry$KeyValuePair$K$V);
+$inheritsMembers(LinkTail$Dynamic, AbstractLink$Dynamic);
+$inheritsMembers(LinkEntry$Dynamic, AbstractLink$Dynamic);
+$inheritsMembers(LinkEntry$T, AbstractLink$T);
+$inheritsMembers(ArrayBasedScanner$SourceString, AbstractScanner$SourceString);
 //  ********** Globals **************
 function $static_init(){
   $globals.HTracer__singleton = null;
 }
 const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 const$1 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 const$10 = new StringWrapper('Dynamic')/*const SourceString('Dynamic')*/;
 const$100 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
 const$102 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
 const$104 = new Keyword("set", true)/*const Keyword("set", true)*/;
@@ skipping 285 matching lines @@
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 var $globals = {};
 $static_init();
 main();